dom/devicestorage/nsDeviceStorage.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 sw=2 et tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsDeviceStorage.h"
   8
   9 #include "mozilla/Attributes.h"
  10 #include "mozilla/ClearOnShutdown.h"
  11 #include "mozilla/DebugOnly.h"
  12 #include "mozilla/dom/ContentChild.h"
  13 #include "mozilla/dom/DeviceStorageBinding.h"
  14 #include "mozilla/dom/DeviceStorageChangeEvent.h"
  15 #include "mozilla/dom/DeviceStorageFileSystem.h"
  16 #include "mozilla/dom/devicestorage/PDeviceStorageRequestChild.h"
  17 #include "mozilla/dom/Directory.h"
  18 #include "mozilla/dom/FileSystemUtils.h"
  19 #include "mozilla/dom/ipc/BlobChild.h"
  20 #include "mozilla/dom/PBrowserChild.h"
  21 #include "mozilla/dom/PermissionMessageUtils.h"
  22 #include "mozilla/dom/Promise.h"
  23 #include "mozilla/dom/ScriptSettings.h"
  24 #include "mozilla/EventDispatcher.h"
  25 #include "mozilla/EventListenerManager.h"
  26 #include "mozilla/LazyIdleThread.h"
  27 #include "mozilla/Preferences.h"
  28 #include "mozilla/Scoped.h"
  29 #include "mozilla/Services.h"
  30
  31 #include "nsArrayUtils.h"
  32 #include "nsAutoPtr.h"
  33 #include "nsGlobalWindow.h"
  34 #include "nsServiceManagerUtils.h"
  35 #include "nsIFile.h"
  36 #include "nsIDirectoryEnumerator.h"
  37 #include "nsAppDirectoryServiceDefs.h"
  38 #include "nsDirectoryServiceDefs.h"
  39 #include "nsNetUtil.h"
  40 #include "nsCycleCollectionParticipant.h"
  41 #include "nsIPrincipal.h"
  42 #include "nsJSUtils.h"
  43 #include "nsContentUtils.h"
  44 #include "nsXULAppAPI.h"
  45 #include "DeviceStorageFileDescriptor.h"
  46 #include "DeviceStorageRequestChild.h"
  47 #include "nsCRT.h"
  48 #include "nsIObserverService.h"
  49 #include "nsIMIMEService.h"
  50 #include "nsCExternalHandlerService.h"
  51 #include "nsIPermissionManager.h"
  52 #include "nsIStringBundle.h"
  53 #include "nsISupportsPrimitives.h"
  54 #include "nsIDocument.h"
  55 #include "nsPrintfCString.h"
  56 #include <algorithm>
  57 #include "private/pprio.h"
  58 #include "nsContentPermissionHelper.h"
  59
  60 #include "mozilla/dom/DeviceStorageBinding.h"
  61
  62 // Microsoft's API Name hackery sucks
  63 #undef CreateEvent
  64
  65 #ifdef MOZ_WIDGET_ANDROID
  66 #include "AndroidBridge.h"
  67 #endif
  68
  69 #ifdef MOZ_WIDGET_GONK
  70 #include "nsIVolume.h"
  71 #include "nsIVolumeService.h"
  72 #endif
  73
  74 #define DEVICESTORAGE_PROPERTIES \
  75   "chrome://global/content/devicestorage.properties"
  76 #define DEFAULT_THREAD_TIMEOUT_MS 30000
  77
  78 using namespace mozilla;
  79 using namespace mozilla::dom;
  80 using namespace mozilla::dom::devicestorage;
  81 using namespace mozilla::ipc;
  82
  83 #include "nsDirectoryServiceDefs.h"
  84
  85 const char* kFileWatcherUpdate = "file-watcher-update";
  86 const char* kFileWatcherNotify = "file-watcher-notify";
  87 const char *kDownloadWatcherNotify = "download-watcher-notify";
  88
  89 namespace mozilla {
  90   MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE(ScopedPRFileDesc, PRFileDesc, PR_Close);
  91 }
  92
  93 StaticAutoPtr<DeviceStorageUsedSpaceCache>
  94   DeviceStorageUsedSpaceCache::sDeviceStorageUsedSpaceCache;
  95
  96 DeviceStorageUsedSpaceCache::DeviceStorageUsedSpaceCache()
  97 {
  98   MOZ_ASSERT(NS_IsMainThread());
  99
 100   mIOThread = new LazyIdleThread(
 101     DEFAULT_THREAD_TIMEOUT_MS,
 102     NS_LITERAL_CSTRING("DeviceStorageUsedSpaceCache I/O"));
 103
 104 }
 105
 106 DeviceStorageUsedSpaceCache::~DeviceStorageUsedSpaceCache()
 107 {
 108 }
 109
 110 DeviceStorageUsedSpaceCache*
 111 DeviceStorageUsedSpaceCache::CreateOrGet()
 112 {
 113   if (sDeviceStorageUsedSpaceCache) {
 114     return sDeviceStorageUsedSpaceCache;
 115   }
 116
 117   MOZ_ASSERT(NS_IsMainThread());
 118
 119   sDeviceStorageUsedSpaceCache = new DeviceStorageUsedSpaceCache();
 120   ClearOnShutdown(&sDeviceStorageUsedSpaceCache);
 121   return sDeviceStorageUsedSpaceCache;
 122 }
 123
 124 already_AddRefed<DeviceStorageUsedSpaceCache::CacheEntry>
 125 DeviceStorageUsedSpaceCache::GetCacheEntry(const nsAString& aStorageName)
 126 {
 127   nsTArray<nsRefPtr<CacheEntry>>::size_type numEntries = mCacheEntries.Length();
 128   nsTArray<nsRefPtr<CacheEntry>>::index_type i;
 129   for (i = 0; i < numEntries; i++) {
 130     nsRefPtr<CacheEntry>& cacheEntry = mCacheEntries[i];
 131     if (cacheEntry->mStorageName.Equals(aStorageName)) {
 132       nsRefPtr<CacheEntry> addRefedCacheEntry = cacheEntry;
 133       return addRefedCacheEntry.forget();
 134     }
 135   }
 136   return nullptr;
 137 }
 138
 139 static int64_t
 140 GetFreeBytes(const nsAString& aStorageName)
 141 {
 142   // This function makes the assumption that the various types
 143   // are all stored on the same filesystem. So we use pictures.
 144
 145   nsRefPtr<DeviceStorageFile> dsf(new DeviceStorageFile(NS_LITERAL_STRING(DEVICESTORAGE_PICTURES),
 146                                                         aStorageName));
 147   int64_t freeBytes = 0;
 148   dsf->GetDiskFreeSpace(&freeBytes);
 149   return freeBytes;
 150 }
 151
 152 nsresult
 153 DeviceStorageUsedSpaceCache::AccumUsedSizes(const nsAString& aStorageName,
 154                                             uint64_t* aPicturesSoFar,
 155                                             uint64_t* aVideosSoFar,
 156                                             uint64_t* aMusicSoFar,
 157                                             uint64_t* aTotalSoFar)
 158 {
 159   nsRefPtr<CacheEntry> cacheEntry = GetCacheEntry(aStorageName);
 160   if (!cacheEntry || cacheEntry->mDirty) {
 161     return NS_ERROR_NOT_AVAILABLE;
 162   }
 163   int64_t freeBytes = GetFreeBytes(cacheEntry->mStorageName);
 164   if (freeBytes != cacheEntry->mFreeBytes) {
 165     // Free space changed, so our cached results are no longer valid.
 166     return NS_ERROR_NOT_AVAILABLE;
 167   }
 168
 169   *aPicturesSoFar += cacheEntry->mPicturesUsedSize;
 170   *aVideosSoFar += cacheEntry->mVideosUsedSize;
 171   *aMusicSoFar += cacheEntry->mMusicUsedSize;
 172   *aTotalSoFar += cacheEntry->mTotalUsedSize;
 173
 174   return NS_OK;
 175 }
 176
 177 void
 178 DeviceStorageUsedSpaceCache::SetUsedSizes(const nsAString& aStorageName,
 179                                           uint64_t aPictureSize,
 180                                           uint64_t aVideosSize,
 181                                           uint64_t aMusicSize,
 182                                           uint64_t aTotalUsedSize)
 183 {
 184   nsRefPtr<CacheEntry> cacheEntry = GetCacheEntry(aStorageName);
 185   if (!cacheEntry) {
 186     cacheEntry = new CacheEntry;
 187     cacheEntry->mStorageName = aStorageName;
 188     mCacheEntries.AppendElement(cacheEntry);
 189   }
 190   cacheEntry->mFreeBytes = GetFreeBytes(cacheEntry->mStorageName);
 191
 192   cacheEntry->mPicturesUsedSize = aPictureSize;
 193   cacheEntry->mVideosUsedSize = aVideosSize;
 194   cacheEntry->mMusicUsedSize = aMusicSize;
 195   cacheEntry->mTotalUsedSize = aTotalUsedSize;
 196   cacheEntry->mDirty = false;
 197 }
 198
 199 class GlobalDirs
 200 {
 201 private:
 202   ~GlobalDirs() {}
 203 public:
 204   NS_INLINE_DECL_REFCOUNTING(GlobalDirs)
 205 #if !defined(MOZ_WIDGET_GONK)
 206   nsCOMPtr<nsIFile> pictures;
 207   nsCOMPtr<nsIFile> videos;
 208   nsCOMPtr<nsIFile> music;
 209   nsCOMPtr<nsIFile> sdcard;
 210 #endif
 211   nsCOMPtr<nsIFile> apps;
 212   nsCOMPtr<nsIFile> crashes;
 213   nsCOMPtr<nsIFile> overrideRootDir;
 214 };
 215
 216 static StaticRefPtr<GlobalDirs> sDirs;
 217
 218 StaticAutoPtr<DeviceStorageTypeChecker>
 219   DeviceStorageTypeChecker::sDeviceStorageTypeChecker;
 220
 221 DeviceStorageTypeChecker::DeviceStorageTypeChecker()
 222 {
 223 }
 224
 225 DeviceStorageTypeChecker::~DeviceStorageTypeChecker()
 226 {
 227 }
 228
 229 DeviceStorageTypeChecker*
 230 DeviceStorageTypeChecker::CreateOrGet()
 231 {
 232   if (sDeviceStorageTypeChecker) {
 233     return sDeviceStorageTypeChecker;
 234   }
 235
 236   MOZ_ASSERT(NS_IsMainThread());
 237
 238   nsCOMPtr<nsIStringBundleService> stringService
 239     = mozilla::services::GetStringBundleService();
 240   if (!stringService) {
 241     return nullptr;
 242   }
 243
 244   nsCOMPtr<nsIStringBundle> filterBundle;
 245   if (NS_FAILED(stringService->CreateBundle(DEVICESTORAGE_PROPERTIES,
 246                                             getter_AddRefs(filterBundle)))) {
 247     return nullptr;
 248   }
 249
 250   DeviceStorageTypeChecker* result = new DeviceStorageTypeChecker();
 251   result->InitFromBundle(filterBundle);
 252
 253   sDeviceStorageTypeChecker = result;
 254   ClearOnShutdown(&sDeviceStorageTypeChecker);
 255   return result;
 256 }
 257
 258 void
 259 DeviceStorageTypeChecker::InitFromBundle(nsIStringBundle* aBundle)
 260 {
 261   aBundle->GetStringFromName(
 262     NS_ConvertASCIItoUTF16(DEVICESTORAGE_PICTURES).get(),
 263     getter_Copies(mPicturesExtensions));
 264   aBundle->GetStringFromName(
 265     NS_ConvertASCIItoUTF16(DEVICESTORAGE_MUSIC).get(),
 266     getter_Copies(mMusicExtensions));
 267   aBundle->GetStringFromName(
 268     NS_ConvertASCIItoUTF16(DEVICESTORAGE_VIDEOS).get(),
 269     getter_Copies(mVideosExtensions));
 270 }
 271
 272
 273 bool
 274 DeviceStorageTypeChecker::Check(const nsAString& aType, nsIDOMBlob* aBlob)
 275 {
 276   MOZ_ASSERT(aBlob);
 277
 278   nsString mimeType;
 279   if (NS_FAILED(aBlob->GetType(mimeType))) {
 280     return false;
 281   }
 282
 283   if (aType.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
 284     return StringBeginsWith(mimeType, NS_LITERAL_STRING("image/"));
 285   }
 286
 287   if (aType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
 288     return StringBeginsWith(mimeType, NS_LITERAL_STRING("video/"));
 289   }
 290
 291   if (aType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
 292     return StringBeginsWith(mimeType, NS_LITERAL_STRING("audio/"));
 293   }
 294
 295   if (aType.EqualsLiteral(DEVICESTORAGE_APPS) ||
 296       aType.EqualsLiteral(DEVICESTORAGE_SDCARD) ||
 297       aType.EqualsLiteral(DEVICESTORAGE_CRASHES)) {
 298     // Apps, crashes and sdcard have no restriction on mime types
 299     return true;
 300   }
 301
 302   return false;
 303 }
 304
 305 bool
 306 DeviceStorageTypeChecker::Check(const nsAString& aType, nsIFile* aFile)
 307 {
 308   if (!aFile) {
 309     return false;
 310   }
 311
 312   nsString path;
 313   aFile->GetPath(path);
 314
 315   return Check(aType, path);
 316 }
 317
 318 bool
 319 DeviceStorageTypeChecker::Check(const nsAString& aType, const nsString& aPath)
 320 {
 321   if (aType.EqualsLiteral(DEVICESTORAGE_APPS) ||
 322       aType.EqualsLiteral(DEVICESTORAGE_SDCARD) ||
 323       aType.EqualsLiteral(DEVICESTORAGE_CRASHES)) {
 324     // Apps, crashes and sdcard have no restrictions on what file extensions used.
 325     return true;
 326   }
 327
 328   int32_t dotIdx = aPath.RFindChar(char16_t('.'));
 329   if (dotIdx == kNotFound) {
 330     return false;
 331   }
 332
 333   nsAutoString extensionMatch;
 334   extensionMatch.Assign('*');
 335   extensionMatch.Append(Substring(aPath, dotIdx));
 336   extensionMatch.Append(';');
 337
 338   if (aType.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
 339     return CaseInsensitiveFindInReadable(extensionMatch, mPicturesExtensions);
 340   }
 341
 342   if (aType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
 343     return CaseInsensitiveFindInReadable(extensionMatch, mVideosExtensions);
 344   }
 345
 346   if (aType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
 347     return CaseInsensitiveFindInReadable(extensionMatch, mMusicExtensions);
 348   }
 349
 350   return false;
 351 }
 352
 353 void
 354 DeviceStorageTypeChecker::GetTypeFromFile(nsIFile* aFile, nsAString& aType)
 355 {
 356   MOZ_ASSERT(aFile);
 357
 358   nsString path;
 359   aFile->GetPath(path);
 360
 361   GetTypeFromFileName(path, aType);
 362 }
 363
 364 void
 365 DeviceStorageTypeChecker::GetTypeFromFileName(const nsAString& aFileName,
 366                                               nsAString& aType)
 367 {
 368   aType.AssignLiteral(DEVICESTORAGE_SDCARD);
 369
 370   nsString fileName(aFileName);
 371   int32_t dotIdx = fileName.RFindChar(char16_t('.'));
 372   if (dotIdx == kNotFound) {
 373     return;
 374   }
 375
 376   nsAutoString extensionMatch;
 377   extensionMatch.Assign('*');
 378   extensionMatch.Append(Substring(aFileName, dotIdx));
 379   extensionMatch.Append(';');
 380
 381   if (CaseInsensitiveFindInReadable(extensionMatch, mPicturesExtensions)) {
 382     aType.AssignLiteral(DEVICESTORAGE_PICTURES);
 383   }
 384   else if (CaseInsensitiveFindInReadable(extensionMatch, mVideosExtensions)) {
 385     aType.AssignLiteral(DEVICESTORAGE_VIDEOS);
 386   }
 387   else if (CaseInsensitiveFindInReadable(extensionMatch, mMusicExtensions)) {
 388     aType.AssignLiteral(DEVICESTORAGE_MUSIC);
 389   }
 390 }
 391
 392 nsresult
 393 DeviceStorageTypeChecker::GetPermissionForType(const nsAString& aType,
 394                                                nsACString& aPermissionResult)
 395 {
 396   if (!aType.EqualsLiteral(DEVICESTORAGE_PICTURES) &&
 397       !aType.EqualsLiteral(DEVICESTORAGE_VIDEOS) &&
 398       !aType.EqualsLiteral(DEVICESTORAGE_MUSIC) &&
 399       !aType.EqualsLiteral(DEVICESTORAGE_APPS) &&
 400       !aType.EqualsLiteral(DEVICESTORAGE_SDCARD) &&
 401       !aType.EqualsLiteral(DEVICESTORAGE_CRASHES)) {
 402     // unknown type
 403     return NS_ERROR_FAILURE;
 404   }
 405
 406   aPermissionResult.AssignLiteral("device-storage:");
 407   aPermissionResult.Append(NS_ConvertUTF16toUTF8(aType));
 408   return NS_OK;
 409 }
 410
 411 nsresult
 412 DeviceStorageTypeChecker::GetAccessForRequest(
 413   const DeviceStorageRequestType aRequestType, nsACString& aAccessResult)
 414 {
 415   switch(aRequestType) {
 416     case DEVICE_STORAGE_REQUEST_READ:
 417     case DEVICE_STORAGE_REQUEST_WATCH:
 418     case DEVICE_STORAGE_REQUEST_FREE_SPACE:
 419     case DEVICE_STORAGE_REQUEST_USED_SPACE:
 420     case DEVICE_STORAGE_REQUEST_AVAILABLE:
 421     case DEVICE_STORAGE_REQUEST_STATUS:
 422       aAccessResult.AssignLiteral("read");
 423       break;
 424     case DEVICE_STORAGE_REQUEST_WRITE:
 425     case DEVICE_STORAGE_REQUEST_APPEND:
 426     case DEVICE_STORAGE_REQUEST_DELETE:
 427     case DEVICE_STORAGE_REQUEST_FORMAT:
 428     case DEVICE_STORAGE_REQUEST_MOUNT:
 429     case DEVICE_STORAGE_REQUEST_UNMOUNT:
 430       aAccessResult.AssignLiteral("write");
 431       break;
 432     case DEVICE_STORAGE_REQUEST_CREATE:
 433     case DEVICE_STORAGE_REQUEST_CREATEFD:
 434       aAccessResult.AssignLiteral("create");
 435       break;
 436     default:
 437       aAccessResult.AssignLiteral("undefined");
 438   }
 439   return NS_OK;
 440 }
 441
 442 static bool IsMediaType(const nsAString& aType)
 443 {
 444   return aType.EqualsLiteral(DEVICESTORAGE_PICTURES) ||
 445          aType.EqualsLiteral(DEVICESTORAGE_VIDEOS) ||
 446          aType.EqualsLiteral(DEVICESTORAGE_MUSIC) ||
 447          aType.EqualsLiteral(DEVICESTORAGE_SDCARD);
 448 }
 449
 450 //static
 451 bool
 452 DeviceStorageTypeChecker::IsVolumeBased(const nsAString& aType)
 453 {
 454 #ifdef MOZ_WIDGET_GONK
 455   // The apps and crashes aren't stored in the same place as the media, so
 456   // we only ever return a single apps object, and not an array
 457   // with one per volume (as is the case for the remaining
 458   // storage types).
 459   return IsMediaType(aType);
 460 #else
 461   return false;
 462 #endif
 463 }
 464
 465 //static
 466 bool
 467 DeviceStorageTypeChecker::IsSharedMediaRoot(const nsAString& aType)
 468 {
 469   // This function determines if aType shares a root directory with the
 470   // other media types (so only applies to music, videos, pictures and sdcard).
 471 #ifdef MOZ_WIDGET_GONK
 472   return IsMediaType(aType);
 473 #else
 474   // For desktop, if the directories have been overridden, then they share
 475   // a common root.
 476   return IsMediaType(aType) && sDirs->overrideRootDir;
 477 #endif
 478 }
 479
 480 NS_IMPL_ISUPPORTS(FileUpdateDispatcher, nsIObserver)
 481
 482 mozilla::StaticRefPtr<FileUpdateDispatcher> FileUpdateDispatcher::sSingleton;
 483
 484 FileUpdateDispatcher*
 485 FileUpdateDispatcher::GetSingleton()
 486 {
 487   if (sSingleton) {
 488     return sSingleton;
 489   }
 490
 491   sSingleton = new FileUpdateDispatcher();
 492   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
 493   obs->AddObserver(sSingleton, kFileWatcherNotify, false);
 494   obs->AddObserver(sSingleton, kDownloadWatcherNotify, false);
 495   ClearOnShutdown(&sSingleton);
 496
 497   return sSingleton;
 498 }
 499
 500 NS_IMETHODIMP
 501 FileUpdateDispatcher::Observe(nsISupports* aSubject,
 502                               const char* aTopic,
 503                               const char16_t* aData)
 504 {
 505   nsRefPtr<DeviceStorageFile> dsf;
 506
 507   if (!strcmp(aTopic, kDownloadWatcherNotify)) {
 508     // aSubject will be an nsISupportsString with the native path to the file
 509     // in question.
 510
 511     nsCOMPtr<nsISupportsString> supportsString = do_QueryInterface(aSubject);
 512     if (!supportsString) {
 513       return NS_OK;
 514     }
 515     nsString path;
 516     nsresult rv = supportsString->GetData(path);
 517     if (NS_WARN_IF(NS_FAILED(rv))) {
 518       return NS_OK;
 519     }
 520
 521     // The downloader uses the sdcard storage type.
 522     nsString volName;
 523 #ifdef MOZ_WIDGET_GONK
 524     if (DeviceStorageTypeChecker::IsVolumeBased(NS_LITERAL_STRING(DEVICESTORAGE_SDCARD))) {
 525       nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
 526       if (NS_WARN_IF(!vs)) {
 527         return NS_OK;
 528       }
 529       nsCOMPtr<nsIVolume> vol;
 530       rv = vs->GetVolumeByPath(path, getter_AddRefs(vol));
 531       if (NS_WARN_IF(NS_FAILED(rv))) {
 532         return NS_OK;
 533       }
 534       rv = vol->GetName(volName);
 535       if (NS_WARN_IF(NS_FAILED(rv))) {
 536         return NS_OK;
 537       }
 538       nsString mountPoint;
 539       rv = vol->GetMountPoint(mountPoint);
 540       if (NS_WARN_IF(NS_FAILED(rv))) {
 541         return NS_OK;
 542       }
 543       if (!Substring(path, 0, mountPoint.Length()).Equals(mountPoint)) {
 544         return NS_OK;
 545       }
 546       path = Substring(path, mountPoint.Length() + 1);
 547     }
 548 #endif
 549     dsf = new DeviceStorageFile(NS_LITERAL_STRING(DEVICESTORAGE_SDCARD), volName, path);
 550
 551   } else if (!strcmp(aTopic, kFileWatcherNotify)) {
 552     dsf = static_cast<DeviceStorageFile*>(aSubject);
 553   } else {
 554     NS_WARNING("FileUpdateDispatcher: Unrecognized topic");
 555     return NS_OK;
 556   }
 557
 558   if (!dsf || !dsf->mFile) {
 559     NS_WARNING("FileUpdateDispatcher: Device storage file looks invalid!");
 560     return NS_OK;
 561   }
 562
 563   if (XRE_GetProcessType() != GeckoProcessType_Default) {
 564     // Child process. Forward the notification to the parent.
 565     ContentChild::GetSingleton()
 566       ->SendFilePathUpdateNotify(dsf->mStorageType,
 567                                  dsf->mStorageName,
 568                                  dsf->mPath,
 569                                  NS_ConvertUTF16toUTF8(aData));
 570     return NS_OK;
 571   }
 572
 573   // Multiple storage types may match the same files. So walk through each of
 574   // the storage types, and if the extension matches, tell them about it.
 575   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
 576   if (DeviceStorageTypeChecker::IsSharedMediaRoot(dsf->mStorageType)) {
 577     DeviceStorageTypeChecker* typeChecker
 578       = DeviceStorageTypeChecker::CreateOrGet();
 579     MOZ_ASSERT(typeChecker);
 580
 581     static const nsLiteralString kMediaTypes[] = {
 582       NS_LITERAL_STRING(DEVICESTORAGE_SDCARD),
 583       NS_LITERAL_STRING(DEVICESTORAGE_PICTURES),
 584       NS_LITERAL_STRING(DEVICESTORAGE_VIDEOS),
 585       NS_LITERAL_STRING(DEVICESTORAGE_MUSIC),
 586     };
 587
 588     for (size_t i = 0; i < MOZ_ARRAY_LENGTH(kMediaTypes); i++) {
 589       nsRefPtr<DeviceStorageFile> dsf2;
 590       if (typeChecker->Check(kMediaTypes[i], dsf->mPath)) {
 591         if (dsf->mStorageType.Equals(kMediaTypes[i])) {
 592           dsf2 = dsf;
 593         } else {
 594           dsf2 = new DeviceStorageFile(kMediaTypes[i],
 595                                        dsf->mStorageName, dsf->mPath);
 596         }
 597         obs->NotifyObservers(dsf2, kFileWatcherUpdate, aData);
 598       }
 599     }
 600   } else {
 601     obs->NotifyObservers(dsf, kFileWatcherUpdate, aData);
 602   }
 603   return NS_OK;
 604 }
 605
 606 class IOEventComplete : public nsRunnable
 607 {
 608 public:
 609   IOEventComplete(DeviceStorageFile *aFile, const char *aType)
 610     : mFile(aFile)
 611     , mType(aType)
 612   {
 613   }
 614
 615   ~IOEventComplete() {}
 616
 617   NS_IMETHOD Run()
 618   {
 619     MOZ_ASSERT(NS_IsMainThread());
 620     nsString data;
 621     CopyASCIItoUTF16(mType, data);
 622     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
 623
 624     obs->NotifyObservers(mFile, kFileWatcherNotify, data.get());
 625
 626     DeviceStorageUsedSpaceCache* usedSpaceCache
 627       = DeviceStorageUsedSpaceCache::CreateOrGet();
 628     MOZ_ASSERT(usedSpaceCache);
 629     usedSpaceCache->Invalidate(mFile->mStorageName);
 630     return NS_OK;
 631   }
 632
 633 private:
 634   nsRefPtr<DeviceStorageFile> mFile;
 635   nsCString mType;
 636 };
 637
 638 DeviceStorageFile::DeviceStorageFile(const nsAString& aStorageType,
 639                                      const nsAString& aStorageName,
 640                                      const nsAString& aRootDir,
 641                                      const nsAString& aPath)
 642   : mStorageType(aStorageType)
 643   , mStorageName(aStorageName)
 644   , mRootDir(aRootDir)
 645   , mPath(aPath)
 646   , mEditable(false)
 647   , mLength(UINT64_MAX)
 648   , mLastModifiedDate(UINT64_MAX)
 649 {
 650   Init();
 651   AppendRelativePath(mRootDir);
 652   if (!mPath.EqualsLiteral("")) {
 653     AppendRelativePath(mPath);
 654   }
 655   NormalizeFilePath();
 656 }
 657
 658 DeviceStorageFile::DeviceStorageFile(const nsAString& aStorageType,
 659                                      const nsAString& aStorageName,
 660                                      const nsAString& aPath)
 661   : mStorageType(aStorageType)
 662   , mStorageName(aStorageName)
 663   , mPath(aPath)
 664   , mEditable(false)
 665   , mLength(UINT64_MAX)
 666   , mLastModifiedDate(UINT64_MAX)
 667 {
 668   Init();
 669   AppendRelativePath(aPath);
 670   NormalizeFilePath();
 671 }
 672
 673 DeviceStorageFile::DeviceStorageFile(const nsAString& aStorageType,
 674                                      const nsAString& aStorageName)
 675   : mStorageType(aStorageType)
 676   , mStorageName(aStorageName)
 677   , mEditable(false)
 678   , mLength(UINT64_MAX)
 679   , mLastModifiedDate(UINT64_MAX)
 680 {
 681   Init();
 682 }
 683
 684 void
 685 DeviceStorageFile::Dump(const char* label)
 686 {
 687   nsString path;
 688   if (mFile) {
 689     mFile->GetPath(path);
 690   } else {
 691     path = NS_LITERAL_STRING("(null)");
 692   }
 693   const char* ptStr;
 694   if (XRE_GetProcessType() == GeckoProcessType_Default) {
 695     ptStr = "parent";
 696   } else {
 697     ptStr = "child";
 698   }
 699
 700   printf_stderr("DSF (%s) %s: mStorageType '%s' mStorageName '%s' "
 701                 "mRootDir '%s' mPath '%s' mFile->GetPath '%s'\n",
 702                 ptStr, label,
 703                 NS_LossyConvertUTF16toASCII(mStorageType).get(),
 704                 NS_LossyConvertUTF16toASCII(mStorageName).get(),
 705                 NS_LossyConvertUTF16toASCII(mRootDir).get(),
 706                 NS_LossyConvertUTF16toASCII(mPath).get(),
 707                 NS_LossyConvertUTF16toASCII(path).get());
 708 }
 709
 710 void
 711 DeviceStorageFile::Init()
 712 {
 713   DeviceStorageFile::GetRootDirectoryForType(mStorageType,
 714                                              mStorageName,
 715                                              getter_AddRefs(mFile));
 716
 717   DebugOnly<DeviceStorageTypeChecker*> typeChecker
 718     = DeviceStorageTypeChecker::CreateOrGet();
 719   MOZ_ASSERT(typeChecker);
 720 }
 721
 722 // The OverrideRootDir is needed to facilitate testing of the
 723 // device.storage.overrideRootDir preference. The preference is normally
 724 // only read once during initialization, but since the test environment has
 725 // no convenient way to restart, we use a pref watcher instead.
 726 class OverrideRootDir MOZ_FINAL : public nsIObserver
 727 {
 728   ~OverrideRootDir();
 729
 730 public:
 731   NS_DECL_ISUPPORTS
 732   NS_DECL_NSIOBSERVER
 733
 734   static OverrideRootDir* GetSingleton();
 735   void Init();
 736 private:
 737   static mozilla::StaticRefPtr<OverrideRootDir> sSingleton;
 738 };
 739
 740 NS_IMPL_ISUPPORTS(OverrideRootDir, nsIObserver)
 741
 742 mozilla::StaticRefPtr<OverrideRootDir>
 743   OverrideRootDir::sSingleton;
 744
 745 OverrideRootDir*
 746 OverrideRootDir::GetSingleton()
 747 {
 748   if (sSingleton) {
 749     return sSingleton;
 750   }
 751   // Preference changes are automatically forwarded from parent to child
 752   // in ContentParent::Observe, so we'll see the change in both the parent
 753   // and the child process.
 754
 755   sSingleton = new OverrideRootDir();
 756   Preferences::AddStrongObserver(sSingleton, "device.storage.overrideRootDir");
 757   Preferences::AddStrongObserver(sSingleton, "device.storage.testing");
 758   ClearOnShutdown(&sSingleton);
 759
 760   return sSingleton;
 761 }
 762
 763 OverrideRootDir::~OverrideRootDir()
 764 {
 765   Preferences::RemoveObserver(this, "device.storage.overrideRootDir");
 766   Preferences::RemoveObserver(this, "device.storage.testing");
 767 }
 768
 769 NS_IMETHODIMP
 770 OverrideRootDir::Observe(nsISupports *aSubject,
 771                               const char *aTopic,
 772                               const char16_t *aData)
 773 {
 774   MOZ_ASSERT(NS_IsMainThread());
 775
 776   if (sSingleton) {
 777     sSingleton->Init();
 778   }
 779   return NS_OK;
 780 }
 781
 782 void
 783 OverrideRootDir::Init()
 784 {
 785   MOZ_ASSERT(NS_IsMainThread());
 786
 787   if (!sDirs) {
 788     return;
 789   }
 790
 791   if (mozilla::Preferences::GetBool("device.storage.testing", false)) {
 792     nsCOMPtr<nsIProperties> dirService
 793       = do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
 794     MOZ_ASSERT(dirService);
 795     dirService->Get(NS_OS_TEMP_DIR, NS_GET_IID(nsIFile),
 796                     getter_AddRefs(sDirs->overrideRootDir));
 797     if (sDirs->overrideRootDir) {
 798       sDirs->overrideRootDir->AppendRelativeNativePath(
 799         NS_LITERAL_CSTRING("device-storage-testing"));
 800     }
 801   } else {
 802     // For users running on desktop, it's convenient to be able to override
 803     // all of the directories to point to a single tree, much like what happens
 804     // on a real device.
 805     const nsAdoptingString& overrideRootDir =
 806       mozilla::Preferences::GetString("device.storage.overrideRootDir");
 807     if (overrideRootDir && overrideRootDir.Length() > 0) {
 808       NS_NewLocalFile(overrideRootDir, false,
 809                       getter_AddRefs(sDirs->overrideRootDir));
 810     } else {
 811       sDirs->overrideRootDir = nullptr;
 812     }
 813   }
 814
 815   if (sDirs->overrideRootDir) {
 816     if (XRE_GetProcessType() == GeckoProcessType_Default) {
 817       // Only the parent process can create directories. In testing, because
 818       // the preference is updated after startup, its entirely possible that
 819       // the preference updated notification will be received by a child
 820       // prior to the parent.
 821       nsresult rv
 822         = sDirs->overrideRootDir->Create(nsIFile::DIRECTORY_TYPE, 0777);
 823       nsString path;
 824       sDirs->overrideRootDir->GetPath(path);
 825       if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) {
 826         nsPrintfCString msg("DeviceStorage: Unable to create directory '%s'",
 827                             NS_LossyConvertUTF16toASCII(path).get());
 828         NS_WARNING(msg.get());
 829       }
 830     }
 831     sDirs->overrideRootDir->Normalize();
 832   }
 833 }
 834
 835 // Directories which don't depend on a volume should be calculated once
 836 // here. Directories which depend on the root directory of a volume
 837 // should be calculated in DeviceStorageFile::GetRootDirectoryForType.
 838 static void
 839 InitDirs()
 840 {
 841   if (sDirs) {
 842     return;
 843   }
 844   MOZ_ASSERT(NS_IsMainThread());
 845   sDirs = new GlobalDirs;
 846   ClearOnShutdown(&sDirs);
 847
 848   nsCOMPtr<nsIProperties> dirService
 849     = do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
 850   MOZ_ASSERT(dirService);
 851
 852 #if !defined(MOZ_WIDGET_GONK)
 853
 854 // Keep MOZ_WIDGET_COCOA above XP_UNIX,
 855 // because both are defined in Darwin builds.
 856 #if defined (MOZ_WIDGET_COCOA)
 857   dirService->Get(NS_OSX_PICTURE_DOCUMENTS_DIR,
 858                   NS_GET_IID(nsIFile),
 859                   getter_AddRefs(sDirs->pictures));
 860   dirService->Get(NS_OSX_MOVIE_DOCUMENTS_DIR,
 861                   NS_GET_IID(nsIFile),
 862                   getter_AddRefs(sDirs->videos));
 863   dirService->Get(NS_OSX_MUSIC_DOCUMENTS_DIR,
 864                   NS_GET_IID(nsIFile),
 865                   getter_AddRefs(sDirs->music));
 866
 867 // Keep MOZ_WIDGET_ANDROID above XP_UNIX,
 868 // because both are defined in Android builds.
 869 #elif defined (MOZ_WIDGET_ANDROID)
 870   nsAutoString path;
 871   if (NS_SUCCEEDED(mozilla::AndroidBridge::GetExternalPublicDirectory(
 872       NS_LITERAL_STRING(DEVICESTORAGE_PICTURES), path))) {
 873     NS_NewLocalFile(path, /* aFollowLinks */ true,
 874                     getter_AddRefs(sDirs->pictures));
 875   }
 876   if (NS_SUCCEEDED(mozilla::AndroidBridge::GetExternalPublicDirectory(
 877       NS_LITERAL_STRING(DEVICESTORAGE_VIDEOS), path))) {
 878     NS_NewLocalFile(path, /* aFollowLinks */ true,
 879                     getter_AddRefs(sDirs->videos));
 880   }
 881   if (NS_SUCCEEDED(mozilla::AndroidBridge::GetExternalPublicDirectory(
 882       NS_LITERAL_STRING(DEVICESTORAGE_MUSIC), path))) {
 883     NS_NewLocalFile(path, /* aFollowLinks */ true,
 884                     getter_AddRefs(sDirs->music));
 885   }
 886   if (NS_SUCCEEDED(mozilla::AndroidBridge::GetExternalPublicDirectory(
 887       NS_LITERAL_STRING(DEVICESTORAGE_SDCARD), path))) {
 888     NS_NewLocalFile(path, /* aFollowLinks */ true,
 889                     getter_AddRefs(sDirs->sdcard));
 890   }
 891
 892 #elif defined (XP_UNIX)
 893   dirService->Get(NS_UNIX_XDG_PICTURES_DIR,
 894                   NS_GET_IID(nsIFile),
 895                   getter_AddRefs(sDirs->pictures));
 896   dirService->Get(NS_UNIX_XDG_VIDEOS_DIR,
 897                   NS_GET_IID(nsIFile),
 898                   getter_AddRefs(sDirs->videos));
 899   dirService->Get(NS_UNIX_XDG_MUSIC_DIR,
 900                   NS_GET_IID(nsIFile),
 901                   getter_AddRefs(sDirs->music));
 902
 903 #elif defined (XP_WIN)
 904   dirService->Get(NS_WIN_PICTURES_DIR,
 905                   NS_GET_IID(nsIFile),
 906                   getter_AddRefs(sDirs->pictures));
 907   dirService->Get(NS_WIN_VIDEOS_DIR,
 908                   NS_GET_IID(nsIFile),
 909                   getter_AddRefs(sDirs->videos));
 910   dirService->Get(NS_WIN_MUSIC_DIR,
 911                   NS_GET_IID(nsIFile),
 912                   getter_AddRefs(sDirs->music));
 913 #endif
 914
 915 #ifndef MOZ_WIDGET_ANDROID
 916   // Eventually, on desktop, we want to do something smarter -- for example,
 917   // detect when an sdcard is inserted, and use that instead of this.
 918   dirService->Get(NS_APP_USER_PROFILE_50_DIR, NS_GET_IID(nsIFile),
 919                   getter_AddRefs(sDirs->sdcard));
 920   if (sDirs->sdcard) {
 921     sDirs->sdcard->AppendRelativeNativePath(NS_LITERAL_CSTRING("fake-sdcard"));
 922   }
 923 #endif // !MOZ_WIDGET_ANDROID
 924 #endif // !MOZ_WIDGET_GONK
 925
 926 #ifdef MOZ_WIDGET_GONK
 927   NS_NewLocalFile(NS_LITERAL_STRING("/data"),
 928                   false,
 929                   getter_AddRefs(sDirs->apps));
 930 #else
 931   dirService->Get(NS_APP_USER_PROFILE_50_DIR, NS_GET_IID(nsIFile),
 932                   getter_AddRefs(sDirs->apps));
 933   if (sDirs->apps) {
 934     sDirs->apps->AppendRelativeNativePath(NS_LITERAL_CSTRING("webapps"));
 935   }
 936 #endif
 937
 938   if (XRE_GetProcessType() == GeckoProcessType_Default) {
 939     NS_GetSpecialDirectory("UAppData", getter_AddRefs(sDirs->crashes));
 940     if (sDirs->crashes) {
 941       sDirs->crashes->Append(NS_LITERAL_STRING("Crash Reports"));
 942     }
 943   } else {
 944     // NS_GetSpecialDirectory("UAppData") fails in content processes because
 945     // gAppData from toolkit/xre/nsAppRunner.cpp is not initialized.
 946 #ifdef MOZ_WIDGET_GONK
 947     NS_NewLocalFile(NS_LITERAL_STRING("/data/b2g/mozilla/Crash Reports"),
 948                                       false,
 949                                       getter_AddRefs(sDirs->crashes));
 950 #endif
 951   }
 952
 953   OverrideRootDir::GetSingleton()->Init();
 954 }
 955
 956 void
 957 DeviceStorageFile::GetFullPath(nsAString &aFullPath)
 958 {
 959   aFullPath.Truncate();
 960   if (!mStorageName.EqualsLiteral("")) {
 961     aFullPath.Append('/');
 962     aFullPath.Append(mStorageName);
 963     aFullPath.Append('/');
 964   }
 965   if (!mRootDir.EqualsLiteral("")) {
 966     aFullPath.Append(mRootDir);
 967     aFullPath.Append('/');
 968   }
 969   aFullPath.Append(mPath);
 970 }
 971
 972
 973 // Directories which don't depend on a volume should be calculated once
 974 // in InitDirs. Directories which depend on the root directory of a volume
 975 // should be calculated in this method.
 976 void
 977 DeviceStorageFile::GetRootDirectoryForType(const nsAString& aStorageType,
 978                                            const nsAString& aStorageName,
 979                                            nsIFile** aFile)
 980 {
 981   nsCOMPtr<nsIFile> f;
 982   *aFile = nullptr;
 983   bool allowOverride = true;
 984
 985   InitDirs();
 986
 987 #ifdef MOZ_WIDGET_GONK
 988   nsresult rv;
 989   nsString volMountPoint;
 990   if (DeviceStorageTypeChecker::IsVolumeBased(aStorageType)) {
 991     nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
 992     NS_ENSURE_TRUE_VOID(vs);
 993     nsCOMPtr<nsIVolume> vol;
 994     rv = vs->GetVolumeByName(aStorageName, getter_AddRefs(vol));
 995     if(NS_FAILED(rv)) {
 996       printf_stderr("##### DeviceStorage: GetVolumeByName('%s') failed\n",
 997                     NS_LossyConvertUTF16toASCII(aStorageName).get());
 998     }
 999     NS_ENSURE_SUCCESS_VOID(rv);
1000     vol->GetMountPoint(volMountPoint);
1001   }
1002 #endif
1003
1004   // Picture directory
1005   if (aStorageType.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
1006 #ifdef MOZ_WIDGET_GONK
1007     rv = NS_NewLocalFile(volMountPoint, false, getter_AddRefs(f));
1008     if(NS_FAILED(rv)) {
1009       printf_stderr("##### DeviceStorage: NS_NewLocalFile failed StorageType: '%s' path '%s'\n",
1010                     NS_LossyConvertUTF16toASCII(volMountPoint).get(),
1011                     NS_LossyConvertUTF16toASCII(aStorageType).get());
1012     }
1013 #else
1014     f = sDirs->pictures;
1015 #endif
1016   }
1017
1018   // Video directory
1019   else if (aStorageType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
1020 #ifdef MOZ_WIDGET_GONK
1021     rv = NS_NewLocalFile(volMountPoint, false, getter_AddRefs(f));
1022     if(NS_FAILED(rv)) {
1023       printf_stderr("##### DeviceStorage: NS_NewLocalFile failed StorageType: '%s' path '%s'\n",
1024                     NS_LossyConvertUTF16toASCII(volMountPoint).get(),
1025                     NS_LossyConvertUTF16toASCII(aStorageType).get());
1026     }
1027 #else
1028     f = sDirs->videos;
1029 #endif
1030   }
1031
1032   // Music directory
1033   else if (aStorageType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
1034 #ifdef MOZ_WIDGET_GONK
1035     rv = NS_NewLocalFile(volMountPoint, false, getter_AddRefs(f));
1036     if(NS_FAILED(rv)) {
1037       printf_stderr("##### DeviceStorage: NS_NewLocalFile failed StorageType: '%s' path '%s'\n",
1038                     NS_LossyConvertUTF16toASCII(volMountPoint).get(),
1039                     NS_LossyConvertUTF16toASCII(aStorageType).get());
1040     }
1041 #else
1042     f = sDirs->music;
1043 #endif
1044   }
1045
1046   // Apps directory
1047   else if (aStorageType.EqualsLiteral(DEVICESTORAGE_APPS)) {
1048     f = sDirs->apps;
1049     allowOverride = false;
1050   }
1051
1052    // default SDCard
1053    else if (aStorageType.EqualsLiteral(DEVICESTORAGE_SDCARD)) {
1054 #ifdef MOZ_WIDGET_GONK
1055      rv = NS_NewLocalFile(volMountPoint, false, getter_AddRefs(f));
1056      if(NS_FAILED(rv)) {
1057        printf_stderr("##### DeviceStorage: NS_NewLocalFile failed StorageType: '%s' path '%s'\n",
1058                      NS_LossyConvertUTF16toASCII(volMountPoint).get(),
1059                      NS_LossyConvertUTF16toASCII(aStorageType).get());
1060      }
1061 #else
1062      f = sDirs->sdcard;
1063 #endif
1064   }
1065
1066   // crash reports directory.
1067   else if (aStorageType.EqualsLiteral(DEVICESTORAGE_CRASHES)) {
1068     f = sDirs->crashes;
1069     allowOverride = false;
1070   } else {
1071     // Not a storage type that we recognize. Return null
1072     return;
1073   }
1074
1075   // In testing, we default all device storage types to a temp directory.
1076   // sDirs->overrideRootDir will only have been initialized (in InitDirs)
1077   // if the preference device.storage.testing was set to true, or if
1078   // device.storage.overrideRootDir is set. We can't test the preferences
1079   // directly here, since we may not be on the main thread.
1080   if (allowOverride && sDirs->overrideRootDir) {
1081     f = sDirs->overrideRootDir;
1082   }
1083
1084   if (f) {
1085     f->Clone(aFile);
1086   } else {
1087     // This should never happen unless something is severely wrong. So
1088     // scream a little.
1089     printf_stderr("##### GetRootDirectoryForType('%s', '%s') failed #####",
1090                   NS_LossyConvertUTF16toASCII(aStorageType).get(),
1091                   NS_LossyConvertUTF16toASCII(aStorageName).get());
1092   }
1093 }
1094
1095 //static
1096 already_AddRefed<DeviceStorageFile>
1097 DeviceStorageFile::CreateUnique(nsAString& aFileName,
1098                                 uint32_t aFileType,
1099                                 uint32_t aFileAttributes)
1100 {
1101   DeviceStorageTypeChecker* typeChecker
1102     = DeviceStorageTypeChecker::CreateOrGet();
1103   MOZ_ASSERT(typeChecker);
1104
1105   nsString storageType;
1106   typeChecker->GetTypeFromFileName(aFileName, storageType);
1107
1108   nsString storageName;
1109   nsString storagePath;
1110   if (!nsDOMDeviceStorage::ParseFullPath(aFileName, storageName, storagePath)) {
1111     return nullptr;
1112   }
1113   if (storageName.IsEmpty()) {
1114     nsDOMDeviceStorage::GetDefaultStorageName(storageType, storageName);
1115   }
1116   nsRefPtr<DeviceStorageFile> dsf =
1117     new DeviceStorageFile(storageType, storageName, storagePath);
1118   if (!dsf->mFile) {
1119     return nullptr;
1120   }
1121
1122   nsresult rv = dsf->mFile->CreateUnique(aFileType, aFileAttributes);
1123   NS_ENSURE_SUCCESS(rv, nullptr);
1124
1125   // CreateUnique may cause the filename to change. So we need to update mPath
1126   // to reflect that.
1127   nsString leafName;
1128   dsf->mFile->GetLeafName(leafName);
1129
1130   int32_t lastSlashIndex = dsf->mPath.RFindChar('/');
1131   if (lastSlashIndex == kNotFound) {
1132     dsf->mPath.Assign(leafName);
1133   } else {
1134     // Include the last '/'
1135     dsf->mPath = Substring(dsf->mPath, 0, lastSlashIndex + 1);
1136     dsf->mPath.Append(leafName);
1137   }
1138
1139   return dsf.forget();
1140 }
1141
1142 void
1143 DeviceStorageFile::SetPath(const nsAString& aPath) {
1144   mPath.Assign(aPath);
1145   NormalizeFilePath();
1146 }
1147
1148 void
1149 DeviceStorageFile::SetEditable(bool aEditable) {
1150   mEditable = aEditable;
1151 }
1152
1153 // we want to make sure that the names of file can't reach
1154 // outside of the type of storage the user asked for.
1155 bool
1156 DeviceStorageFile::IsSafePath()
1157 {
1158   return IsSafePath(mRootDir) && IsSafePath(mPath);
1159 }
1160
1161 bool
1162 DeviceStorageFile::IsSafePath(const nsAString& aPath)
1163 {
1164   nsAString::const_iterator start, end;
1165   aPath.BeginReading(start);
1166   aPath.EndReading(end);
1167
1168   // if the path is a '~' or starts with '~/', return false.
1169   NS_NAMED_LITERAL_STRING(tilde, "~");
1170   NS_NAMED_LITERAL_STRING(tildeSlash, "~/");
1171   if (aPath.Equals(tilde) ||
1172       StringBeginsWith(aPath, tildeSlash)) {
1173     NS_WARNING("Path name starts with tilde!");
1174     return false;
1175    }
1176   // split on /.  if any token is "", ., or .., return false.
1177   NS_ConvertUTF16toUTF8 cname(aPath);
1178   char* buffer = cname.BeginWriting();
1179   const char* token;
1180
1181   while ((token = nsCRT::strtok(buffer, "/", &buffer))) {
1182     if (PL_strcmp(token, "") == 0 ||
1183         PL_strcmp(token, ".") == 0 ||
1184         PL_strcmp(token, "..") == 0 ) {
1185       return false;
1186     }
1187   }
1188   return true;
1189 }
1190
1191 void
1192 DeviceStorageFile::NormalizeFilePath() {
1193   FileSystemUtils::LocalPathToNormalizedPath(mPath, mPath);
1194 }
1195
1196 void
1197 DeviceStorageFile::AppendRelativePath(const nsAString& aPath) {
1198   if (!mFile) {
1199     return;
1200   }
1201   if (!IsSafePath(aPath)) {
1202     // All of the APIs (in the child) do checks to verify that the path is
1203     // valid and return PERMISSION_DENIED if a non-safe path is entered.
1204     // This check is done in the parent and prevents a compromised
1205     // child from bypassing the check. It shouldn't be possible for this
1206     // code path to be taken with a non-compromised child.
1207     NS_WARNING("Unsafe path detected - ignoring");
1208     NS_WARNING(NS_LossyConvertUTF16toASCII(aPath).get());
1209     return;
1210   }
1211   nsString localPath;
1212   FileSystemUtils::NormalizedPathToLocalPath(aPath, localPath);
1213   mFile->AppendRelativePath(localPath);
1214 }
1215
1216 nsresult
1217 DeviceStorageFile::CreateFileDescriptor(FileDescriptor& aFileDescriptor)
1218 {
1219   if (!mFile) {
1220     return NS_ERROR_FAILURE;
1221   }
1222   ScopedPRFileDesc fd;
1223   nsresult rv = mFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE,
1224                                         0660, &fd.rwget());
1225   NS_ENSURE_SUCCESS(rv, rv);
1226
1227   // NOTE: The FileDescriptor::PlatformHandleType constructor returns a dup of
1228   //       the file descriptor, so we don't need the original fd after this.
1229   //       Our scoped file descriptor will automatically close fd.
1230   aFileDescriptor = FileDescriptor(
1231     FileDescriptor::PlatformHandleType(PR_FileDesc2NativeHandle(fd)));
1232   return NS_OK;
1233 }
1234
1235 nsresult
1236 DeviceStorageFile::Write(nsIInputStream* aInputStream)
1237 {
1238   if (!aInputStream || !mFile) {
1239     return NS_ERROR_FAILURE;
1240   }
1241
1242   nsresult rv = mFile->Create(nsIFile::NORMAL_FILE_TYPE, 00600);
1243   if (NS_WARN_IF(NS_FAILED(rv))) {
1244     return rv;
1245   }
1246
1247   nsCOMPtr<nsIRunnable> iocomplete = new IOEventComplete(this, "created");
1248   rv = NS_DispatchToMainThread(iocomplete);
1249   if (NS_WARN_IF(NS_FAILED(rv))) {
1250     return rv;
1251   }
1252
1253   nsCOMPtr<nsIOutputStream> outputStream;
1254   NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), mFile);
1255
1256   if (!outputStream) {
1257     return NS_ERROR_FAILURE;
1258   }
1259
1260   return Append(aInputStream, outputStream);
1261 }
1262
1263 nsresult
1264 DeviceStorageFile::Write(InfallibleTArray<uint8_t>& aBits)
1265 {
1266   if (!mFile) {
1267     return NS_ERROR_FAILURE;
1268   }
1269
1270   nsresult rv = mFile->Create(nsIFile::NORMAL_FILE_TYPE, 00600);
1271   if (NS_WARN_IF(NS_FAILED(rv))) {
1272     return rv;
1273   }
1274
1275   nsCOMPtr<nsIRunnable> iocomplete = new IOEventComplete(this, "created");
1276   rv = NS_DispatchToMainThread(iocomplete);
1277   if (NS_WARN_IF(NS_FAILED(rv))) {
1278     return rv;
1279   }
1280
1281   nsCOMPtr<nsIOutputStream> outputStream;
1282   NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), mFile);
1283
1284   if (!outputStream) {
1285     return NS_ERROR_FAILURE;
1286   }
1287
1288   uint32_t wrote;
1289   outputStream->Write((char*) aBits.Elements(), aBits.Length(), &wrote);
1290   outputStream->Close();
1291
1292   iocomplete = new IOEventComplete(this, "modified");
1293   rv = NS_DispatchToMainThread(iocomplete);
1294   if (NS_WARN_IF(NS_FAILED(rv))) {
1295     return rv;
1296   }
1297
1298   if (aBits.Length() != wrote) {
1299     return NS_ERROR_FAILURE;
1300   }
1301   return NS_OK;
1302 }
1303
1304 nsresult
1305 DeviceStorageFile::Append(nsIInputStream* aInputStream)
1306 {
1307   if (!aInputStream || !mFile) {
1308     return NS_ERROR_FAILURE;
1309   }
1310
1311   nsCOMPtr<nsIOutputStream> outputStream;
1312   NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), mFile, PR_WRONLY | PR_CREATE_FILE | PR_APPEND, -1, 0);
1313
1314   if (!outputStream) {
1315     return NS_ERROR_FAILURE;
1316   }
1317
1318   return Append(aInputStream, outputStream);
1319 }
1320
1321
1322 nsresult
1323 DeviceStorageFile::Append(nsIInputStream* aInputStream, nsIOutputStream* aOutputStream)
1324 {
1325   uint64_t bufSize = 0;
1326   aInputStream->Available(&bufSize);
1327
1328   nsCOMPtr<nsIOutputStream> bufferedOutputStream;
1329   nsresult rv = NS_NewBufferedOutputStream(getter_AddRefs(bufferedOutputStream),
1330                                   aOutputStream,
1331                                   4096*4);
1332   NS_ENSURE_SUCCESS(rv, rv);
1333
1334   while (bufSize) {
1335     uint32_t wrote;
1336     rv = bufferedOutputStream->WriteFrom(
1337       aInputStream,
1338         static_cast<uint32_t>(std::min<uint64_t>(bufSize, UINT32_MAX)),
1339         &wrote);
1340     if (NS_FAILED(rv)) {
1341       break;
1342     }
1343     bufSize -= wrote;
1344   }
1345
1346   nsCOMPtr<nsIRunnable> iocomplete = new IOEventComplete(this, "modified");
1347   rv = NS_DispatchToMainThread(iocomplete);
1348   if (NS_WARN_IF(NS_FAILED(rv))) {
1349     return rv;
1350   }
1351
1352   bufferedOutputStream->Close();
1353   aOutputStream->Close();
1354   if (NS_WARN_IF(NS_FAILED(rv))) {
1355     return rv;
1356   }
1357   return NS_OK;
1358 }
1359
1360 nsresult
1361 DeviceStorageFile::Remove()
1362 {
1363   MOZ_ASSERT(!NS_IsMainThread());
1364
1365   if (!mFile) {
1366     return NS_ERROR_FAILURE;
1367   }
1368
1369   bool check;
1370   nsresult rv = mFile->Exists(&check);
1371   if (NS_FAILED(rv)) {
1372     return rv;
1373   }
1374
1375   if (!check) {
1376     return NS_OK;
1377   }
1378
1379   rv = mFile->Remove(true);
1380   if (NS_WARN_IF(NS_FAILED(rv))) {
1381     return rv;
1382   }
1383
1384   nsCOMPtr<nsIRunnable> iocomplete = new IOEventComplete(this, "deleted");
1385   return NS_DispatchToMainThread(iocomplete);
1386 }
1387
1388 nsresult
1389 DeviceStorageFile::CalculateMimeType()
1390 {
1391   MOZ_ASSERT(NS_IsMainThread());
1392
1393   if (!mFile) {
1394     return NS_ERROR_FAILURE;
1395   }
1396   nsAutoCString mimeType;
1397   nsCOMPtr<nsIMIMEService> mimeService =
1398     do_GetService(NS_MIMESERVICE_CONTRACTID);
1399   if (mimeService) {
1400     nsresult rv = mimeService->GetTypeFromFile(mFile, mimeType);
1401     if (NS_FAILED(rv)) {
1402       mimeType.Truncate();
1403       return rv;
1404     }
1405   }
1406
1407   mMimeType = NS_ConvertUTF8toUTF16(mimeType);
1408   return NS_OK;
1409 }
1410
1411 nsresult
1412 DeviceStorageFile::CalculateSizeAndModifiedDate()
1413 {
1414   MOZ_ASSERT(!NS_IsMainThread());
1415
1416   if (!mFile) {
1417     return NS_ERROR_FAILURE;
1418   }
1419
1420   int64_t fileSize;
1421   nsresult rv = mFile->GetFileSize(&fileSize);
1422   NS_ENSURE_SUCCESS(rv, rv);
1423
1424   mLength = fileSize;
1425
1426   PRTime modDate;
1427   rv = mFile->GetLastModifiedTime(&modDate);
1428   NS_ENSURE_SUCCESS(rv, rv);
1429
1430   mLastModifiedDate = modDate;
1431   return NS_OK;
1432 }
1433
1434 void
1435 DeviceStorageFile::CollectFiles(nsTArray<nsRefPtr<DeviceStorageFile> > &aFiles,
1436                                 PRTime aSince)
1437 {
1438   if (!mFile) {
1439     return;
1440   }
1441   nsString fullRootPath;
1442   mFile->GetPath(fullRootPath);
1443   collectFilesInternal(aFiles, aSince, fullRootPath);
1444 }
1445
1446 void
1447 DeviceStorageFile::collectFilesInternal(
1448   nsTArray<nsRefPtr<DeviceStorageFile> > &aFiles,
1449   PRTime aSince,
1450   nsAString& aRootPath)
1451 {
1452   if (!mFile || !IsAvailable()) {
1453     return;
1454   }
1455
1456   nsCOMPtr<nsISimpleEnumerator> e;
1457   mFile->GetDirectoryEntries(getter_AddRefs(e));
1458
1459   if (!e) {
1460     return;
1461   }
1462
1463   nsCOMPtr<nsIDirectoryEnumerator> files = do_QueryInterface(e);
1464   nsCOMPtr<nsIFile> f;
1465
1466   while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(f))) && f) {
1467
1468     bool isFile;
1469     f->IsFile(&isFile);
1470
1471     if (isFile) {
1472       PRTime msecs;
1473       f->GetLastModifiedTime(&msecs);
1474
1475       if (msecs < aSince) {
1476         continue;
1477       }
1478     }
1479
1480     bool isDir;
1481     f->IsDirectory(&isDir);
1482
1483     nsString fullpath;
1484     nsresult rv = f->GetPath(fullpath);
1485     if (NS_FAILED(rv)) {
1486       continue;
1487     }
1488
1489     if (!StringBeginsWith(fullpath, aRootPath)) {
1490       NS_ERROR("collectFiles returned a path that does not belong!");
1491       continue;
1492     }
1493
1494     nsAString::size_type len = aRootPath.Length() + 1; // +1 for the trailing /
1495     nsDependentSubstring newPath = Substring(fullpath, len);
1496
1497     if (isDir) {
1498       DeviceStorageFile dsf(mStorageType, mStorageName, mRootDir, newPath);
1499       dsf.collectFilesInternal(aFiles, aSince, aRootPath);
1500     } else if (isFile) {
1501       nsRefPtr<DeviceStorageFile> dsf =
1502         new DeviceStorageFile(mStorageType, mStorageName, mRootDir, newPath);
1503       dsf->CalculateSizeAndModifiedDate();
1504       aFiles.AppendElement(dsf);
1505     }
1506   }
1507 }
1508
1509 void
1510 DeviceStorageFile::AccumDiskUsage(uint64_t* aPicturesSoFar,
1511                                   uint64_t* aVideosSoFar,
1512                                   uint64_t* aMusicSoFar,
1513                                   uint64_t* aTotalSoFar)
1514 {
1515   if (!IsAvailable()) {
1516     return;
1517   }
1518
1519   uint64_t pictureUsage = 0, videoUsage = 0, musicUsage = 0, totalUsage = 0;
1520
1521   if (DeviceStorageTypeChecker::IsVolumeBased(mStorageType)) {
1522     DeviceStorageUsedSpaceCache* usedSpaceCache =
1523       DeviceStorageUsedSpaceCache::CreateOrGet();
1524     MOZ_ASSERT(usedSpaceCache);
1525     nsresult rv = usedSpaceCache->AccumUsedSizes(mStorageName,
1526                                                  aPicturesSoFar, aVideosSoFar,
1527                                                  aMusicSoFar, aTotalSoFar);
1528     if (NS_SUCCEEDED(rv)) {
1529       return;
1530     }
1531     AccumDirectoryUsage(mFile, &pictureUsage, &videoUsage,
1532                         &musicUsage, &totalUsage);
1533     usedSpaceCache->SetUsedSizes(mStorageName, pictureUsage, videoUsage,
1534                                  musicUsage, totalUsage);
1535   } else {
1536     AccumDirectoryUsage(mFile, &pictureUsage, &videoUsage,
1537                         &musicUsage, &totalUsage);
1538   }
1539
1540   *aPicturesSoFar += pictureUsage;
1541   *aVideosSoFar += videoUsage;
1542   *aMusicSoFar += musicUsage;
1543   *aTotalSoFar += totalUsage;
1544 }
1545
1546 void
1547 DeviceStorageFile::AccumDirectoryUsage(nsIFile* aFile,
1548                                        uint64_t* aPicturesSoFar,
1549                                        uint64_t* aVideosSoFar,
1550                                        uint64_t* aMusicSoFar,
1551                                        uint64_t* aTotalSoFar)
1552 {
1553   if (!aFile) {
1554     return;
1555   }
1556
1557   nsresult rv;
1558   nsCOMPtr<nsISimpleEnumerator> e;
1559   rv = aFile->GetDirectoryEntries(getter_AddRefs(e));
1560
1561   if (NS_FAILED(rv) || !e) {
1562     return;
1563   }
1564
1565   nsCOMPtr<nsIDirectoryEnumerator> files = do_QueryInterface(e);
1566   MOZ_ASSERT(files);
1567
1568   nsCOMPtr<nsIFile> f;
1569   while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(f))) && f) {
1570     bool isDir;
1571     rv = f->IsDirectory(&isDir);
1572     if (NS_FAILED(rv)) {
1573       continue;
1574     }
1575
1576     bool isFile;
1577     rv = f->IsFile(&isFile);
1578     if (NS_FAILED(rv)) {
1579       continue;
1580     }
1581
1582     bool isLink;
1583     rv = f->IsSymlink(&isLink);
1584     if (NS_FAILED(rv)) {
1585       continue;
1586     }
1587
1588     if (isLink) {
1589       // for now, lets just totally ignore symlinks.
1590       NS_WARNING("DirectoryDiskUsage ignores symlinks");
1591     } else if (isDir) {
1592       AccumDirectoryUsage(f, aPicturesSoFar, aVideosSoFar,
1593                           aMusicSoFar, aTotalSoFar);
1594     } else if (isFile) {
1595
1596       int64_t size;
1597       rv = f->GetFileSize(&size);
1598       if (NS_FAILED(rv)) {
1599         continue;
1600       }
1601       DeviceStorageTypeChecker* typeChecker
1602         = DeviceStorageTypeChecker::CreateOrGet();
1603       MOZ_ASSERT(typeChecker);
1604       nsString type;
1605       typeChecker->GetTypeFromFile(f, type);
1606
1607       if (type.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
1608         *aPicturesSoFar += size;
1609       }
1610       else if (type.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
1611         *aVideosSoFar += size;
1612       }
1613       else if (type.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
1614         *aMusicSoFar += size;
1615       }
1616       *aTotalSoFar += size;
1617     }
1618   }
1619 }
1620
1621 void
1622 DeviceStorageFile::GetDiskFreeSpace(int64_t* aSoFar)
1623 {
1624   DeviceStorageTypeChecker* typeChecker
1625     = DeviceStorageTypeChecker::CreateOrGet();
1626   if (!typeChecker) {
1627     return;
1628   }
1629   if (!mFile || !IsAvailable()) {
1630     return;
1631   }
1632
1633   int64_t storageAvail = 0;
1634   nsresult rv = mFile->GetDiskSpaceAvailable(&storageAvail);
1635   if (NS_SUCCEEDED(rv)) {
1636     *aSoFar += storageAvail;
1637   }
1638 }
1639
1640 bool
1641 DeviceStorageFile::IsAvailable()
1642 {
1643   nsString status;
1644   GetStatus(status);
1645   return status.EqualsLiteral("available");
1646 }
1647
1648 void
1649 DeviceStorageFile::DoFormat(nsAString& aStatus)
1650 {
1651   DeviceStorageTypeChecker* typeChecker
1652     = DeviceStorageTypeChecker::CreateOrGet();
1653   if (!typeChecker || !mFile) {
1654     return;
1655   }
1656   if (!typeChecker->IsVolumeBased(mStorageType)) {
1657     aStatus.AssignLiteral("notVolume");
1658     return;
1659   }
1660 #ifdef MOZ_WIDGET_GONK
1661   nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
1662   NS_ENSURE_TRUE_VOID(vs);
1663
1664   nsCOMPtr<nsIVolume> vol;
1665   nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
1666   NS_ENSURE_SUCCESS_VOID(rv);
1667   if (!vol) {
1668     return;
1669   }
1670
1671   vol->Format();
1672
1673   aStatus.AssignLiteral("formatting");
1674 #endif
1675   return;
1676 }
1677
1678 void
1679 DeviceStorageFile::DoMount(nsAString& aStatus)
1680 {
1681   DeviceStorageTypeChecker* typeChecker
1682     = DeviceStorageTypeChecker::CreateOrGet();
1683   if (!typeChecker || !mFile) {
1684     return;
1685   }
1686   if (!typeChecker->IsVolumeBased(mStorageType)) {
1687     aStatus.AssignLiteral("notVolume");
1688     return;
1689   }
1690 #ifdef MOZ_WIDGET_GONK
1691   nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
1692   NS_ENSURE_TRUE_VOID(vs);
1693
1694   nsCOMPtr<nsIVolume> vol;
1695   nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
1696   NS_ENSURE_SUCCESS_VOID(rv);
1697   if (!vol) {
1698     return;
1699   }
1700
1701   vol->Mount();
1702
1703   aStatus.AssignLiteral("mounting");
1704 #endif
1705   return;
1706 }
1707
1708 void
1709 DeviceStorageFile::DoUnmount(nsAString& aStatus)
1710 {
1711   DeviceStorageTypeChecker* typeChecker
1712     = DeviceStorageTypeChecker::CreateOrGet();
1713   if (!typeChecker || !mFile) {
1714     return;
1715   }
1716   if (!typeChecker->IsVolumeBased(mStorageType)) {
1717     aStatus.AssignLiteral("notVolume");
1718     return;
1719   }
1720 #ifdef MOZ_WIDGET_GONK
1721   nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
1722   NS_ENSURE_TRUE_VOID(vs);
1723
1724   nsCOMPtr<nsIVolume> vol;
1725   nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
1726   NS_ENSURE_SUCCESS_VOID(rv);
1727   if (!vol) {
1728     return;
1729   }
1730
1731   vol->Unmount();
1732
1733   aStatus.AssignLiteral("unmounting");
1734 #endif
1735   return;
1736 }
1737
1738 void
1739 DeviceStorageFile::GetStatus(nsAString& aStatus)
1740 {
1741   aStatus.AssignLiteral("unavailable");
1742
1743   DeviceStorageTypeChecker* typeChecker
1744     = DeviceStorageTypeChecker::CreateOrGet();
1745   if (!typeChecker || !mFile) {
1746     return;
1747   }
1748   if (!typeChecker->IsVolumeBased(mStorageType)) {
1749     aStatus.AssignLiteral("available");
1750     return;
1751   }
1752
1753 #ifdef MOZ_WIDGET_GONK
1754   nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
1755   NS_ENSURE_TRUE_VOID(vs);
1756
1757   nsCOMPtr<nsIVolume> vol;
1758   nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
1759   NS_ENSURE_SUCCESS_VOID(rv);
1760   if (!vol) {
1761     return;
1762   }
1763   bool isMediaPresent;
1764   rv = vol->GetIsMediaPresent(&isMediaPresent);
1765   NS_ENSURE_SUCCESS_VOID(rv);
1766   if (!isMediaPresent) {
1767     return;
1768   }
1769   bool isSharing;
1770   rv = vol->GetIsSharing(&isSharing);
1771   NS_ENSURE_SUCCESS_VOID(rv);
1772   if (isSharing) {
1773     aStatus.AssignLiteral("shared");
1774     return;
1775   }
1776   bool isFormatting;
1777   rv = vol->GetIsFormatting(&isFormatting);
1778   NS_ENSURE_SUCCESS_VOID(rv);
1779   if (isFormatting) {
1780     aStatus.AssignLiteral("unavailable");
1781     return;
1782   }
1783   bool isUnmounting;
1784   rv = vol->GetIsUnmounting(&isUnmounting);
1785   NS_ENSURE_SUCCESS_VOID(rv);
1786   if (isUnmounting) {
1787     aStatus.AssignLiteral("unavailable");
1788     return;
1789   }
1790   int32_t volState;
1791   rv = vol->GetState(&volState);
1792   NS_ENSURE_SUCCESS_VOID(rv);
1793   if (volState == nsIVolume::STATE_MOUNTED) {
1794     aStatus.AssignLiteral("available");
1795   }
1796 #endif
1797 }
1798
1799 void
1800 DeviceStorageFile::GetStorageStatus(nsAString& aStatus)
1801 {
1802   aStatus.AssignLiteral("undefined");
1803
1804   DeviceStorageTypeChecker* typeChecker
1805     = DeviceStorageTypeChecker::CreateOrGet();
1806   if (!typeChecker || !mFile) {
1807     return;
1808   }
1809   if (!typeChecker->IsVolumeBased(mStorageType)) {
1810     aStatus.AssignLiteral("available");
1811     return;
1812   }
1813
1814 #ifdef MOZ_WIDGET_GONK
1815   nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
1816   NS_ENSURE_TRUE_VOID(vs);
1817
1818   nsCOMPtr<nsIVolume> vol;
1819   nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
1820   NS_ENSURE_SUCCESS_VOID(rv);
1821   if (!vol) {
1822     return;
1823   }
1824
1825   int32_t volState;
1826   rv = vol->GetState(&volState);
1827   NS_ENSURE_SUCCESS_VOID(rv);
1828   aStatus.AssignASCII(mozilla::system::NS_VolumeStateStr(volState));
1829 #endif
1830 }
1831
1832 NS_IMPL_ISUPPORTS0(DeviceStorageFile)
1833
1834 static void
1835 RegisterForSDCardChanges(nsIObserver* aObserver)
1836 {
1837 #ifdef MOZ_WIDGET_GONK
1838   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
1839   obs->AddObserver(aObserver, NS_VOLUME_STATE_CHANGED, false);
1840 #endif
1841 }
1842
1843 static void
1844 UnregisterForSDCardChanges(nsIObserver* aObserver)
1845 {
1846 #ifdef MOZ_WIDGET_GONK
1847   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
1848   obs->RemoveObserver(aObserver, NS_VOLUME_STATE_CHANGED);
1849 #endif
1850 }
1851
1852 void
1853 nsDOMDeviceStorage::SetRootDirectoryForType(const nsAString& aStorageType,
1854                                             const nsAString& aStorageName)
1855 {
1856   MOZ_ASSERT(NS_IsMainThread());
1857
1858   nsCOMPtr<nsIFile> f;
1859   DeviceStorageFile::GetRootDirectoryForType(aStorageType,
1860                                              aStorageName,
1861                                              getter_AddRefs(f));
1862   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
1863   obs->AddObserver(this, kFileWatcherUpdate, false);
1864   obs->AddObserver(this, "disk-space-watcher", false);
1865   mRootDirectory = f;
1866   mStorageType = aStorageType;
1867   mStorageName = aStorageName;
1868 }
1869
1870 JS::Value
1871 InterfaceToJsval(nsPIDOMWindow* aWindow,
1872                  nsISupports* aObject,
1873                  const nsIID* aIID)
1874 {
1875   nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aWindow);
1876   if (!sgo) {
1877     return JS::NullValue();
1878   }
1879
1880   JSObject *unrootedScopeObj = sgo->GetGlobalJSObject();
1881   NS_ENSURE_TRUE(unrootedScopeObj, JS::NullValue());
1882   JSRuntime *runtime = JS_GetObjectRuntime(unrootedScopeObj);
1883   JS::Rooted<JS::Value> someJsVal(runtime);
1884   JS::Rooted<JSObject*> scopeObj(runtime, unrootedScopeObj);
1885   nsresult rv;
1886
1887   { // Protect someJsVal from moving GC in ~JSAutoCompartment
1888     AutoJSContext cx;
1889     JSAutoCompartment ac(cx, scopeObj);
1890
1891     rv = nsContentUtils::WrapNative(cx, aObject, aIID, &someJsVal);
1892   }
1893   if (NS_FAILED(rv)) {
1894     return JS::NullValue();
1895   }
1896
1897   return someJsVal;
1898 }
1899
1900 JS::Value
1901 nsIFileToJsval(nsPIDOMWindow* aWindow, DeviceStorageFile* aFile)
1902 {
1903   MOZ_ASSERT(NS_IsMainThread());
1904   MOZ_ASSERT(aWindow);
1905
1906   if (!aFile) {
1907     return JSVAL_NULL;
1908   }
1909
1910   if (aFile->mEditable) {
1911     // TODO - needs janv's file handle support.
1912     return JSVAL_NULL;
1913   }
1914
1915   nsString fullPath;
1916   aFile->GetFullPath(fullPath);
1917
1918   // This check is useful to know if somewhere the DeviceStorageFile
1919   // has not been properly set. Mimetype is not checked because it can be
1920   // empty.
1921   MOZ_ASSERT(aFile->mLength != UINT64_MAX);
1922   MOZ_ASSERT(aFile->mLastModifiedDate != UINT64_MAX);
1923
1924   nsCOMPtr<nsIDOMBlob> blob = new File(aWindow,
1925     new FileImplFile(fullPath, aFile->mMimeType,
1926                      aFile->mLength, aFile->mFile,
1927                      aFile->mLastModifiedDate));
1928   return InterfaceToJsval(aWindow, blob, &NS_GET_IID(nsIDOMBlob));
1929 }
1930
1931 bool
1932 StringToJsval(nsPIDOMWindow* aWindow, nsAString& aString,
1933               JS::MutableHandle<JS::Value> result)
1934 {
1935   MOZ_ASSERT(NS_IsMainThread());
1936   MOZ_ASSERT(aWindow);
1937
1938   AutoJSAPI jsapi;
1939   if (NS_WARN_IF(!jsapi.Init(aWindow))) {
1940     return false;
1941   }
1942   JSContext* cx = jsapi.cx();
1943
1944   if (!xpc::StringToJsval(cx, aString, result)) {
1945     return false;
1946   }
1947
1948   return true;
1949 }
1950
1951 class DeviceStorageCursorRequest MOZ_FINAL
1952   : public nsIContentPermissionRequest
1953 {
1954 public:
1955   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
1956   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(DeviceStorageCursorRequest,
1957                                            nsIContentPermissionRequest)
1958
1959   NS_FORWARD_NSICONTENTPERMISSIONREQUEST(mCursor->);
1960
1961   explicit DeviceStorageCursorRequest(nsDOMDeviceStorageCursor* aCursor)
1962     : mCursor(aCursor) { }
1963
1964 private:
1965   ~DeviceStorageCursorRequest() {}
1966
1967   nsRefPtr<nsDOMDeviceStorageCursor> mCursor;
1968 };
1969
1970 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeviceStorageCursorRequest)
1971   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentPermissionRequest)
1972   NS_INTERFACE_MAP_ENTRY(nsIContentPermissionRequest)
1973 NS_INTERFACE_MAP_END
1974
1975 NS_IMPL_CYCLE_COLLECTING_ADDREF(DeviceStorageCursorRequest)
1976 NS_IMPL_CYCLE_COLLECTING_RELEASE(DeviceStorageCursorRequest)
1977
1978 NS_IMPL_CYCLE_COLLECTION(DeviceStorageCursorRequest,
1979                          mCursor)
1980
1981
1982 class PostErrorEvent : public nsRunnable
1983 {
1984 public:
1985   PostErrorEvent(already_AddRefed<DOMRequest> aRequest, const char* aMessage)
1986     : mRequest(aRequest)
1987   {
1988     CopyASCIItoUTF16(aMessage, mError);
1989   }
1990
1991   PostErrorEvent(DOMRequest* aRequest, const char* aMessage)
1992     : mRequest(aRequest)
1993   {
1994     CopyASCIItoUTF16(aMessage, mError);
1995   }
1996
1997   ~PostErrorEvent() {}
1998
1999   NS_IMETHOD Run()
2000   {
2001     MOZ_ASSERT(NS_IsMainThread());
2002     if (!mRequest->GetOwner()) {
2003       return NS_OK;
2004     }
2005     mRequest->FireError(mError);
2006     mRequest = nullptr;
2007     return NS_OK;
2008   }
2009
2010 private:
2011   nsRefPtr<DOMRequest> mRequest;
2012   nsString mError;
2013 };
2014
2015 ContinueCursorEvent::ContinueCursorEvent(already_AddRefed<DOMRequest> aRequest)
2016   : mRequest(aRequest)
2017 {
2018 }
2019
2020 ContinueCursorEvent::ContinueCursorEvent(DOMRequest* aRequest)
2021   : mRequest(aRequest)
2022 {
2023 }
2024
2025 already_AddRefed<DeviceStorageFile>
2026 ContinueCursorEvent::GetNextFile()
2027 {
2028   MOZ_ASSERT(NS_IsMainThread());
2029
2030   nsDOMDeviceStorageCursor* cursor
2031     = static_cast<nsDOMDeviceStorageCursor*>(mRequest.get());
2032   nsString cursorStorageType;
2033   cursor->GetStorageType(cursorStorageType);
2034
2035   DeviceStorageTypeChecker* typeChecker
2036     = DeviceStorageTypeChecker::CreateOrGet();
2037   if (!typeChecker) {
2038     return nullptr;
2039   }
2040
2041   while (cursor->mFiles.Length() > 0) {
2042     nsRefPtr<DeviceStorageFile> file = cursor->mFiles[0];
2043     cursor->mFiles.RemoveElementAt(0);
2044     if (!typeChecker->Check(cursorStorageType, file->mFile)) {
2045       continue;
2046     }
2047
2048     file->CalculateMimeType();
2049     return file.forget();
2050   }
2051
2052   return nullptr;
2053 }
2054
2055 ContinueCursorEvent::~ContinueCursorEvent() {}
2056
2057 void
2058 ContinueCursorEvent::Continue()
2059 {
2060   if (XRE_GetProcessType() == GeckoProcessType_Default) {
2061     DebugOnly<nsresult> rv = NS_DispatchToMainThread(this);
2062     MOZ_ASSERT(NS_SUCCEEDED(rv));
2063     return;
2064   }
2065
2066   nsRefPtr<DeviceStorageFile> file = GetNextFile();
2067
2068   if (!file) {
2069     // done with enumeration.
2070     DebugOnly<nsresult> rv = NS_DispatchToMainThread(this);
2071     MOZ_ASSERT(NS_SUCCEEDED(rv));
2072     return;
2073   }
2074
2075   nsDOMDeviceStorageCursor* cursor
2076     = static_cast<nsDOMDeviceStorageCursor*>(mRequest.get());
2077   nsString cursorStorageType;
2078   cursor->GetStorageType(cursorStorageType);
2079
2080   DeviceStorageRequestChild* child
2081     = new DeviceStorageRequestChild(mRequest, file);
2082   child->SetCallback(cursor);
2083   DeviceStorageGetParams params(cursorStorageType,
2084                                 file->mStorageName,
2085                                 file->mRootDir,
2086                                 file->mPath);
2087   ContentChild::GetSingleton()->SendPDeviceStorageRequestConstructor(child,
2088                                                                      params);
2089   mRequest = nullptr;
2090 }
2091
2092 NS_IMETHODIMP
2093 ContinueCursorEvent::Run()
2094 {
2095   nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
2096   if (!window) {
2097     return NS_OK;
2098   }
2099
2100   nsRefPtr<DeviceStorageFile> file = GetNextFile();
2101
2102   nsDOMDeviceStorageCursor* cursor
2103     = static_cast<nsDOMDeviceStorageCursor*>(mRequest.get());
2104
2105   AutoJSContext cx;
2106   JS::Rooted<JS::Value> val(cx, nsIFileToJsval(window, file));
2107
2108   if (file) {
2109     cursor->mOkToCallContinue = true;
2110     cursor->FireSuccess(val);
2111   } else {
2112     cursor->FireDone();
2113   }
2114   mRequest = nullptr;
2115   return NS_OK;
2116 }
2117
2118 class InitCursorEvent : public nsRunnable
2119 {
2120 public:
2121     InitCursorEvent(DOMRequest* aRequest, DeviceStorageFile* aFile)
2122     : mFile(aFile)
2123     , mRequest(aRequest)
2124   {
2125   }
2126
2127   ~InitCursorEvent() {}
2128
2129   NS_IMETHOD Run() {
2130     MOZ_ASSERT(!NS_IsMainThread());
2131
2132     if (mFile->mFile) {
2133       bool check;
2134       mFile->mFile->IsDirectory(&check);
2135       if (!check) {
2136         nsCOMPtr<nsIRunnable> event =
2137           new PostErrorEvent(mRequest.forget(),
2138                              POST_ERROR_EVENT_FILE_NOT_ENUMERABLE);
2139         return NS_DispatchToMainThread(event);
2140       }
2141     }
2142
2143     nsDOMDeviceStorageCursor* cursor
2144       = static_cast<nsDOMDeviceStorageCursor*>(mRequest.get());
2145     mFile->CollectFiles(cursor->mFiles, cursor->mSince);
2146
2147     nsRefPtr<ContinueCursorEvent> event
2148       = new ContinueCursorEvent(mRequest.forget());
2149     event->Continue();
2150
2151     return NS_OK;
2152   }
2153
2154
2155 private:
2156   nsRefPtr<DeviceStorageFile> mFile;
2157   nsRefPtr<DOMRequest> mRequest;
2158 };
2159
2160 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsDOMDeviceStorageCursor)
2161   NS_INTERFACE_MAP_ENTRY(nsIContentPermissionRequest)
2162 NS_INTERFACE_MAP_END_INHERITING(DOMCursor)
2163
2164 NS_IMPL_ADDREF_INHERITED(nsDOMDeviceStorageCursor, DOMCursor)
2165 NS_IMPL_RELEASE_INHERITED(nsDOMDeviceStorageCursor, DOMCursor)
2166
2167 nsDOMDeviceStorageCursor::nsDOMDeviceStorageCursor(nsPIDOMWindow* aWindow,
2168                                                    nsIPrincipal* aPrincipal,
2169                                                    DeviceStorageFile* aFile,
2170                                                    PRTime aSince)
2171   : DOMCursor(aWindow, nullptr)
2172   , mOkToCallContinue(false)
2173   , mSince(aSince)
2174   , mFile(aFile)
2175   , mPrincipal(aPrincipal)
2176 {
2177 }
2178
2179 nsDOMDeviceStorageCursor::~nsDOMDeviceStorageCursor()
2180 {
2181 }
2182
2183 void
2184 nsDOMDeviceStorageCursor::GetStorageType(nsAString & aType)
2185 {
2186   aType = mFile->mStorageType;
2187 }
2188
2189 NS_IMETHODIMP
2190 nsDOMDeviceStorageCursor::GetTypes(nsIArray** aTypes)
2191 {
2192   nsCString type;
2193   nsresult rv =
2194     DeviceStorageTypeChecker::GetPermissionForType(mFile->mStorageType, type);
2195   NS_ENSURE_SUCCESS(rv, rv);
2196
2197   nsTArray<nsString> emptyOptions;
2198   return nsContentPermissionUtils::CreatePermissionArray(type,
2199                                                          NS_LITERAL_CSTRING("read"),
2200                                                          emptyOptions,
2201                                                          aTypes);
2202 }
2203
2204 NS_IMETHODIMP
2205 nsDOMDeviceStorageCursor::GetPrincipal(nsIPrincipal** aRequestingPrincipal)
2206 {
2207   NS_IF_ADDREF(*aRequestingPrincipal = mPrincipal);
2208   return NS_OK;
2209 }
2210
2211 NS_IMETHODIMP
2212 nsDOMDeviceStorageCursor::GetWindow(nsIDOMWindow** aRequestingWindow)
2213 {
2214   NS_IF_ADDREF(*aRequestingWindow = GetOwner());
2215   return NS_OK;
2216 }
2217
2218 NS_IMETHODIMP
2219 nsDOMDeviceStorageCursor::GetElement(nsIDOMElement** aRequestingElement)
2220 {
2221   *aRequestingElement = nullptr;
2222   return NS_OK;
2223 }
2224
2225 NS_IMETHODIMP
2226 nsDOMDeviceStorageCursor::Cancel()
2227 {
2228   nsCOMPtr<nsIRunnable> event
2229     = new PostErrorEvent(this, POST_ERROR_EVENT_PERMISSION_DENIED);
2230   return NS_DispatchToMainThread(event);
2231 }
2232
2233 NS_IMETHODIMP
2234 nsDOMDeviceStorageCursor::Allow(JS::HandleValue aChoices)
2235 {
2236   MOZ_ASSERT(aChoices.isUndefined());
2237
2238   if (!mFile->IsSafePath()) {
2239     nsCOMPtr<nsIRunnable> r
2240       = new PostErrorEvent(this, POST_ERROR_EVENT_PERMISSION_DENIED);
2241     return NS_DispatchToMainThread(r);
2242   }
2243
2244   if (XRE_GetProcessType() != GeckoProcessType_Default) {
2245     PDeviceStorageRequestChild* child
2246       = new DeviceStorageRequestChild(this, mFile);
2247     DeviceStorageEnumerationParams params(mFile->mStorageType,
2248                                           mFile->mStorageName,
2249                                           mFile->mRootDir,
2250                                           mSince);
2251     ContentChild::GetSingleton()->SendPDeviceStorageRequestConstructor(child,
2252                                                                        params);
2253     return NS_OK;
2254   }
2255
2256   nsCOMPtr<nsIEventTarget> target
2257     = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
2258   MOZ_ASSERT(target);
2259
2260   nsCOMPtr<nsIRunnable> event = new InitCursorEvent(this, mFile);
2261   target->Dispatch(event, NS_DISPATCH_NORMAL);
2262   return NS_OK;
2263 }
2264
2265 void
2266 nsDOMDeviceStorageCursor::Continue(ErrorResult& aRv)
2267 {
2268   if (!mOkToCallContinue) {
2269     aRv.Throw(NS_ERROR_UNEXPECTED);
2270     return;
2271   }
2272
2273   if (mResult != JSVAL_VOID) {
2274     // We call onsuccess multiple times. Clear the last
2275     // result.
2276     mResult = JSVAL_VOID;
2277     mDone = false;
2278   }
2279
2280   nsRefPtr<ContinueCursorEvent> event = new ContinueCursorEvent(this);
2281   event->Continue();
2282
2283   mOkToCallContinue = false;
2284 }
2285
2286 void
2287 nsDOMDeviceStorageCursor::RequestComplete()
2288 {
2289   MOZ_ASSERT(!mOkToCallContinue);
2290   mOkToCallContinue = true;
2291 }
2292
2293 class PostAvailableResultEvent : public nsRunnable
2294 {
2295 public:
2296   PostAvailableResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
2297     : mFile(aFile)
2298     , mRequest(aRequest)
2299   {
2300     MOZ_ASSERT(mRequest);
2301   }
2302
2303   ~PostAvailableResultEvent() {}
2304
2305   NS_IMETHOD Run()
2306   {
2307     MOZ_ASSERT(NS_IsMainThread());
2308     nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
2309     if (!window) {
2310       return NS_OK;
2311     }
2312
2313     nsString state = NS_LITERAL_STRING("unavailable");
2314     if (mFile) {
2315       mFile->GetStatus(state);
2316     }
2317
2318     AutoJSContext cx;
2319     JS::Rooted<JS::Value> result(cx);
2320     StringToJsval(window, state, &result);
2321     mRequest->FireSuccess(result);
2322     mRequest = nullptr;
2323     return NS_OK;
2324   }
2325
2326 private:
2327   nsRefPtr<DeviceStorageFile> mFile;
2328   nsRefPtr<DOMRequest> mRequest;
2329 };
2330
2331 class PostStatusResultEvent : public nsRunnable
2332 {
2333 public:
2334   PostStatusResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
2335     : mFile(aFile)
2336     , mRequest(aRequest)
2337   {
2338     MOZ_ASSERT(mRequest);
2339   }
2340
2341   ~PostStatusResultEvent() {}
2342
2343   NS_IMETHOD Run()
2344   {
2345     MOZ_ASSERT(NS_IsMainThread());
2346     nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
2347     if (!window) {
2348       return NS_OK;
2349     }
2350
2351     nsString state = NS_LITERAL_STRING("undefined");
2352     if (mFile) {
2353       mFile->GetStorageStatus(state);
2354     }
2355
2356     AutoJSContext cx;
2357     JS::Rooted<JS::Value> result(cx);
2358     StringToJsval(window, state, &result);
2359     mRequest->FireSuccess(result);
2360     mRequest = nullptr;
2361     return NS_OK;
2362   }
2363
2364 private:
2365   nsRefPtr<DeviceStorageFile> mFile;
2366   nsRefPtr<DOMRequest> mRequest;
2367 };
2368
2369 class PostFormatResultEvent : public nsRunnable
2370 {
2371 public:
2372   PostFormatResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
2373     : mFile(aFile)
2374     , mRequest(aRequest)
2375   {
2376     MOZ_ASSERT(mRequest);
2377   }
2378
2379   ~PostFormatResultEvent() {}
2380
2381   NS_IMETHOD Run()
2382   {
2383     MOZ_ASSERT(NS_IsMainThread());
2384     nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
2385     if (!window) {
2386       return NS_OK;
2387     }
2388
2389     nsString state = NS_LITERAL_STRING("unavailable");
2390     if (mFile) {
2391       mFile->DoFormat(state);
2392     }
2393
2394     AutoJSContext cx;
2395     JS::Rooted<JS::Value> result(cx);
2396     StringToJsval(window, state, &result);
2397     mRequest->FireSuccess(result);
2398     mRequest = nullptr;
2399     return NS_OK;
2400   }
2401
2402 private:
2403   nsRefPtr<DeviceStorageFile> mFile;
2404   nsRefPtr<DOMRequest> mRequest;
2405 };
2406
2407 class PostMountResultEvent : public nsRunnable
2408 {
2409 public:
2410   PostMountResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
2411     : mFile(aFile)
2412     , mRequest(aRequest)
2413   {
2414     MOZ_ASSERT(mRequest);
2415   }
2416
2417   ~PostMountResultEvent() {}
2418
2419   NS_IMETHOD Run()
2420   {
2421     MOZ_ASSERT(NS_IsMainThread());
2422     nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
2423     if (!window) {
2424       return NS_OK;
2425     }
2426
2427     nsString state = NS_LITERAL_STRING("unavailable");
2428     if (mFile) {
2429       mFile->DoMount(state);
2430     }
2431
2432     AutoJSContext cx;
2433     JS::Rooted<JS::Value> result(cx);
2434     StringToJsval(window, state, &result);
2435     mRequest->FireSuccess(result);
2436     mRequest = nullptr;
2437     return NS_OK;
2438   }
2439
2440 private:
2441   nsRefPtr<DeviceStorageFile> mFile;
2442   nsRefPtr<DOMRequest> mRequest;
2443 };
2444
2445 class PostUnmountResultEvent : public nsRunnable
2446 {
2447 public:
2448   PostUnmountResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
2449     : mFile(aFile)
2450     , mRequest(aRequest)
2451   {
2452     MOZ_ASSERT(mRequest);
2453   }
2454
2455   ~PostUnmountResultEvent() {}
2456
2457   NS_IMETHOD Run()
2458   {
2459     MOZ_ASSERT(NS_IsMainThread());
2460     nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
2461     if (!window) {
2462       return NS_OK;
2463     }
2464
2465     nsString state = NS_LITERAL_STRING("unavailable");
2466     if (mFile) {
2467       mFile->DoUnmount(state);
2468     }
2469
2470     AutoJSContext cx;
2471     JS::Rooted<JS::Value> result(cx);
2472     StringToJsval(window, state, &result);
2473     mRequest->FireSuccess(result);
2474     mRequest = nullptr;
2475     return NS_OK;
2476   }
2477
2478 private:
2479   nsRefPtr<DeviceStorageFile> mFile;
2480   nsRefPtr<DOMRequest> mRequest;
2481 };
2482
2483 class PostResultEvent : public nsRunnable
2484 {
2485 public:
2486   PostResultEvent(already_AddRefed<DOMRequest> aRequest,
2487                   DeviceStorageFile* aFile)
2488     : mFile(aFile)
2489     , mRequest(aRequest)
2490   {
2491     MOZ_ASSERT(mRequest);
2492   }
2493
2494   PostResultEvent(already_AddRefed<DOMRequest> aRequest,
2495                   const nsAString & aPath)
2496     : mPath(aPath)
2497     , mRequest(aRequest)
2498   {
2499     MOZ_ASSERT(mRequest);
2500   }
2501
2502   PostResultEvent(already_AddRefed<DOMRequest> aRequest,
2503                   const uint64_t aValue)
2504     : mValue(aValue)
2505     , mRequest(aRequest)
2506   {
2507     MOZ_ASSERT(mRequest);
2508   }
2509
2510   ~PostResultEvent() {}
2511
2512   NS_IMETHOD Run()
2513   {
2514     MOZ_ASSERT(NS_IsMainThread());
2515     nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
2516     if (!window) {
2517       return NS_OK;
2518     }
2519
2520     AutoJSContext cx;
2521     JS::Rooted<JS::Value> result(cx, JSVAL_NULL);
2522
2523     if (mFile) {
2524       result = nsIFileToJsval(window, mFile);
2525     } else if (mPath.Length()) {
2526       StringToJsval(window, mPath, &result);
2527     }
2528     else {
2529       result = JS_NumberValue(double(mValue));
2530     }
2531
2532     mRequest->FireSuccess(result);
2533     mRequest = nullptr;
2534     return NS_OK;
2535   }
2536
2537 private:
2538   nsRefPtr<DeviceStorageFile> mFile;
2539   nsString mPath;
2540   uint64_t mValue;
2541   nsRefPtr<DOMRequest> mRequest;
2542 };
2543
2544 class CreateFdEvent : public nsRunnable
2545 {
2546 public:
2547   CreateFdEvent(DeviceStorageFileDescriptor* aDSFileDescriptor,
2548                 already_AddRefed<DOMRequest> aRequest)
2549     : mDSFileDescriptor(aDSFileDescriptor)
2550     , mRequest(aRequest)
2551   {
2552     MOZ_ASSERT(mDSFileDescriptor);
2553     MOZ_ASSERT(mDSFileDescriptor->mDSFile);
2554     MOZ_ASSERT(mDSFileDescriptor->mDSFile->mFile);
2555     MOZ_ASSERT(mRequest);
2556   }
2557
2558   NS_IMETHOD Run()
2559   {
2560     MOZ_ASSERT(!NS_IsMainThread());
2561
2562     DeviceStorageFile* dsFile = mDSFileDescriptor->mDSFile;
2563
2564     nsString fullPath;
2565     dsFile->GetFullPath(fullPath);
2566     MOZ_ASSERT(!fullPath.IsEmpty());
2567
2568     bool check = false;
2569     dsFile->mFile->Exists(&check);
2570     if (check) {
2571       nsCOMPtr<nsIRunnable> event =
2572         new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_FILE_EXISTS);
2573       return NS_DispatchToMainThread(event);
2574     }
2575
2576     nsresult rv = dsFile->CreateFileDescriptor(mDSFileDescriptor->mFileDescriptor);
2577
2578     if (NS_FAILED(rv)) {
2579       dsFile->mFile->Remove(false);
2580
2581       nsCOMPtr<nsIRunnable> event =
2582         new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_UNKNOWN);
2583       return NS_DispatchToMainThread(event);
2584     }
2585
2586     nsCOMPtr<nsIRunnable> event =
2587       new PostResultEvent(mRequest.forget(), fullPath);
2588     return NS_DispatchToMainThread(event);
2589   }
2590
2591 private:
2592   nsRefPtr<DeviceStorageFileDescriptor> mDSFileDescriptor;
2593   nsRefPtr<DOMRequest> mRequest;
2594 };
2595
2596 class WriteFileEvent : public nsRunnable
2597 {
2598 public:
2599   WriteFileEvent(FileImpl* aBlobImpl,
2600                  DeviceStorageFile *aFile,
2601                  already_AddRefed<DOMRequest> aRequest,
2602                  int32_t aRequestType)
2603     : mBlobImpl(aBlobImpl)
2604     , mFile(aFile)
2605     , mRequest(aRequest)
2606     , mRequestType(aRequestType)
2607   {
2608     MOZ_ASSERT(mFile);
2609     MOZ_ASSERT(mFile->mFile);
2610     MOZ_ASSERT(mRequest);
2611     MOZ_ASSERT(mRequestType);
2612   }
2613
2614   ~WriteFileEvent() {}
2615
2616   NS_IMETHOD Run()
2617   {
2618     MOZ_ASSERT(!NS_IsMainThread());
2619
2620     nsCOMPtr<nsIInputStream> stream;
2621     mBlobImpl->GetInternalStream(getter_AddRefs(stream));
2622
2623     bool check = false;
2624     mFile->mFile->Exists(&check);
2625     nsresult rv;
2626
2627     if (mRequestType == DEVICE_STORAGE_REQUEST_APPEND) {
2628       if (!check) {
2629         nsCOMPtr<nsIRunnable> event =
2630           new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_FILE_DOES_NOT_EXIST);
2631         return NS_DispatchToMainThread(event);
2632       }
2633       rv = mFile->Append(stream);
2634     }
2635     else if (mRequestType == DEVICE_STORAGE_REQUEST_CREATE) {
2636       if (check) {
2637         nsCOMPtr<nsIRunnable> event =
2638           new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_FILE_EXISTS);
2639         return NS_DispatchToMainThread(event);
2640       }
2641       rv = mFile->Write(stream);
2642       if (NS_FAILED(rv)) {
2643         mFile->mFile->Remove(false);
2644       }
2645     } else {
2646       nsCOMPtr<nsIRunnable> event =
2647         new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_UNKNOWN);
2648       return NS_DispatchToMainThread(event);
2649     }
2650
2651     if (NS_FAILED(rv)) {
2652       nsCOMPtr<nsIRunnable> event =
2653         new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_UNKNOWN);
2654       return NS_DispatchToMainThread(event);
2655     }
2656
2657     nsString fullPath;
2658     mFile->GetFullPath(fullPath);
2659     nsCOMPtr<nsIRunnable> event =
2660       new PostResultEvent(mRequest.forget(), fullPath);
2661     return NS_DispatchToMainThread(event);
2662   }
2663
2664 private:
2665   nsRefPtr<FileImpl> mBlobImpl;
2666   nsRefPtr<DeviceStorageFile> mFile;
2667   nsRefPtr<DOMRequest> mRequest;
2668   int32_t mRequestType;
2669 };
2670
2671
2672 class ReadFileEvent : public nsRunnable
2673 {
2674 public:
2675   ReadFileEvent(DeviceStorageFile* aFile,
2676                 already_AddRefed<DOMRequest> aRequest)
2677     : mFile(aFile)
2678     , mRequest(aRequest)
2679   {
2680     MOZ_ASSERT(mFile);
2681     MOZ_ASSERT(mRequest);
2682     mFile->CalculateMimeType();
2683   }
2684
2685   ~ReadFileEvent() {}
2686
2687   NS_IMETHOD Run()
2688   {
2689     MOZ_ASSERT(!NS_IsMainThread());
2690
2691     nsCOMPtr<nsIRunnable> r;
2692     if (!mFile->mEditable) {
2693       bool check = false;
2694       mFile->mFile->Exists(&check);
2695       if (!check) {
2696         r = new PostErrorEvent(mRequest.forget(),
2697                                POST_ERROR_EVENT_FILE_DOES_NOT_EXIST);
2698       }
2699     }
2700
2701     if (!r) {
2702       nsresult rv = mFile->CalculateSizeAndModifiedDate();
2703       if (NS_FAILED(rv)) {
2704         r = new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_UNKNOWN);
2705       }
2706     }
2707
2708     if (!r) {
2709       r = new PostResultEvent(mRequest.forget(), mFile);
2710     }
2711     return NS_DispatchToMainThread(r);
2712   }
2713
2714 private:
2715   nsRefPtr<DeviceStorageFile> mFile;
2716   nsRefPtr<DOMRequest> mRequest;
2717 };
2718
2719 class DeleteFileEvent : public nsRunnable
2720 {
2721 public:
2722   DeleteFileEvent(DeviceStorageFile* aFile,
2723                   already_AddRefed<DOMRequest> aRequest)
2724     : mFile(aFile)
2725     , mRequest(aRequest)
2726   {
2727     MOZ_ASSERT(mFile);
2728     MOZ_ASSERT(mRequest);
2729   }
2730
2731   ~DeleteFileEvent() {}
2732
2733   NS_IMETHOD Run()
2734   {
2735     MOZ_ASSERT(!NS_IsMainThread());
2736     mFile->Remove();
2737
2738     nsCOMPtr<nsIRunnable> r;
2739     bool check = false;
2740     mFile->mFile->Exists(&check);
2741     if (check) {
2742       r = new PostErrorEvent(mRequest.forget(),
2743                              POST_ERROR_EVENT_FILE_DOES_NOT_EXIST);
2744     }
2745     else {
2746       nsString fullPath;
2747       mFile->GetFullPath(fullPath);
2748       r = new PostResultEvent(mRequest.forget(), fullPath);
2749     }
2750     return NS_DispatchToMainThread(r);
2751   }
2752
2753 private:
2754   nsRefPtr<DeviceStorageFile> mFile;
2755   nsRefPtr<DOMRequest> mRequest;
2756 };
2757
2758 class UsedSpaceFileEvent : public nsRunnable
2759 {
2760 public:
2761   UsedSpaceFileEvent(DeviceStorageFile* aFile,
2762                      already_AddRefed<DOMRequest> aRequest)
2763     : mFile(aFile)
2764     , mRequest(aRequest)
2765   {
2766     MOZ_ASSERT(mFile);
2767     MOZ_ASSERT(mRequest);
2768   }
2769
2770   ~UsedSpaceFileEvent() {}
2771
2772   NS_IMETHOD Run()
2773   {
2774     MOZ_ASSERT(!NS_IsMainThread());
2775
2776     uint64_t picturesUsage = 0, videosUsage = 0, musicUsage = 0, totalUsage = 0;
2777     mFile->AccumDiskUsage(&picturesUsage, &videosUsage,
2778                           &musicUsage, &totalUsage);
2779     nsCOMPtr<nsIRunnable> r;
2780     if (mFile->mStorageType.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
2781       r = new PostResultEvent(mRequest.forget(), picturesUsage);
2782     }
2783     else if (mFile->mStorageType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
2784       r = new PostResultEvent(mRequest.forget(), videosUsage);
2785     }
2786     else if (mFile->mStorageType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
2787       r = new PostResultEvent(mRequest.forget(), musicUsage);
2788     } else {
2789       r = new PostResultEvent(mRequest.forget(), totalUsage);
2790     }
2791     return NS_DispatchToMainThread(r);
2792   }
2793
2794 private:
2795   nsRefPtr<DeviceStorageFile> mFile;
2796   nsRefPtr<DOMRequest> mRequest;
2797 };
2798
2799 class FreeSpaceFileEvent : public nsRunnable
2800 {
2801 public:
2802   FreeSpaceFileEvent(DeviceStorageFile* aFile,
2803                      already_AddRefed<DOMRequest> aRequest)
2804     : mFile(aFile)
2805     , mRequest(aRequest)
2806   {
2807     MOZ_ASSERT(mFile);
2808     MOZ_ASSERT(mRequest);
2809   }
2810
2811   ~FreeSpaceFileEvent() {}
2812
2813   NS_IMETHOD Run()
2814   {
2815     MOZ_ASSERT(!NS_IsMainThread());
2816
2817     int64_t freeSpace = 0;
2818     if (mFile) {
2819       mFile->GetDiskFreeSpace(&freeSpace);
2820     }
2821
2822     nsCOMPtr<nsIRunnable> r;
2823     r = new PostResultEvent(mRequest.forget(),
2824                             static_cast<uint64_t>(freeSpace));
2825     return NS_DispatchToMainThread(r);
2826   }
2827
2828 private:
2829   nsRefPtr<DeviceStorageFile> mFile;
2830   nsRefPtr<DOMRequest> mRequest;
2831 };
2832
2833 class DeviceStorageRequest MOZ_FINAL
2834   : public nsIContentPermissionRequest
2835   , public nsIRunnable
2836 {
2837 public:
2838
2839   DeviceStorageRequest(const DeviceStorageRequestType aRequestType,
2840                        nsPIDOMWindow* aWindow,
2841                        nsIPrincipal* aPrincipal,
2842                        DeviceStorageFile* aFile,
2843                        DOMRequest* aRequest,
2844                        nsDOMDeviceStorage* aDeviceStorage)
2845     : mRequestType(aRequestType)
2846     , mWindow(aWindow)
2847     , mPrincipal(aPrincipal)
2848     , mFile(aFile)
2849     , mRequest(aRequest)
2850     , mDeviceStorage(aDeviceStorage)
2851   {
2852     MOZ_ASSERT(mWindow);
2853     MOZ_ASSERT(mPrincipal);
2854     MOZ_ASSERT(mFile);
2855     MOZ_ASSERT(mRequest);
2856     MOZ_ASSERT(mDeviceStorage);
2857   }
2858
2859   DeviceStorageRequest(const DeviceStorageRequestType aRequestType,
2860                        nsPIDOMWindow* aWindow,
2861                        nsIPrincipal* aPrincipal,
2862                        DeviceStorageFile* aFile,
2863                        DOMRequest* aRequest,
2864                        nsIDOMBlob* aBlob = nullptr)
2865     : mRequestType(aRequestType)
2866     , mWindow(aWindow)
2867     , mPrincipal(aPrincipal)
2868     , mFile(aFile)
2869     , mRequest(aRequest)
2870     , mBlob(aBlob)
2871   {
2872     MOZ_ASSERT(mWindow);
2873     MOZ_ASSERT(mPrincipal);
2874     MOZ_ASSERT(mFile);
2875     MOZ_ASSERT(mRequest);
2876   }
2877
2878   DeviceStorageRequest(const DeviceStorageRequestType aRequestType,
2879                        nsPIDOMWindow* aWindow,
2880                        nsIPrincipal* aPrincipal,
2881                        DeviceStorageFile* aFile,
2882                        DOMRequest* aRequest,
2883                        DeviceStorageFileDescriptor* aDSFileDescriptor)
2884     : mRequestType(aRequestType)
2885     , mWindow(aWindow)
2886     , mPrincipal(aPrincipal)
2887     , mFile(aFile)
2888     , mRequest(aRequest)
2889     , mDSFileDescriptor(aDSFileDescriptor)
2890   {
2891     MOZ_ASSERT(mRequestType == DEVICE_STORAGE_REQUEST_CREATEFD);
2892     MOZ_ASSERT(mWindow);
2893     MOZ_ASSERT(mPrincipal);
2894     MOZ_ASSERT(mFile);
2895     MOZ_ASSERT(mRequest);
2896     MOZ_ASSERT(mDSFileDescriptor);
2897   }
2898
2899   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
2900   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(DeviceStorageRequest,
2901                                            nsIContentPermissionRequest)
2902
2903   NS_IMETHOD Run() MOZ_OVERRIDE
2904   {
2905     MOZ_ASSERT(NS_IsMainThread());
2906
2907     if (mozilla::Preferences::GetBool("device.storage.prompt.testing", false)) {
2908       Allow(JS::UndefinedHandleValue);
2909       return NS_OK;
2910     }
2911
2912     return nsContentPermissionUtils::AskPermission(this, mWindow);
2913   }
2914
2915   NS_IMETHODIMP GetTypes(nsIArray** aTypes) MOZ_OVERRIDE
2916   {
2917     nsCString type;
2918     nsresult rv =
2919       DeviceStorageTypeChecker::GetPermissionForType(mFile->mStorageType, type);
2920     if (NS_FAILED(rv)) {
2921       return rv;
2922     }
2923
2924     nsCString access;
2925     rv = DeviceStorageTypeChecker::GetAccessForRequest(
2926       DeviceStorageRequestType(mRequestType), access);
2927     if (NS_FAILED(rv)) {
2928       return rv;
2929     }
2930
2931     nsTArray<nsString> emptyOptions;
2932     return nsContentPermissionUtils::CreatePermissionArray(type, access, emptyOptions, aTypes);
2933   }
2934
2935   NS_IMETHOD GetPrincipal(nsIPrincipal * *aRequestingPrincipal) MOZ_OVERRIDE
2936   {
2937     NS_IF_ADDREF(*aRequestingPrincipal = mPrincipal);
2938     return NS_OK;
2939   }
2940
2941   NS_IMETHOD GetWindow(nsIDOMWindow * *aRequestingWindow) MOZ_OVERRIDE
2942   {
2943     NS_IF_ADDREF(*aRequestingWindow = mWindow);
2944     return NS_OK;
2945   }
2946
2947   NS_IMETHOD GetElement(nsIDOMElement * *aRequestingElement) MOZ_OVERRIDE
2948   {
2949     *aRequestingElement = nullptr;
2950     return NS_OK;
2951   }
2952
2953   NS_IMETHOD Cancel() MOZ_OVERRIDE
2954   {
2955     nsCOMPtr<nsIRunnable> event
2956       = new PostErrorEvent(mRequest.forget(),
2957                            POST_ERROR_EVENT_PERMISSION_DENIED);
2958     return NS_DispatchToMainThread(event);
2959   }
2960
2961   NS_IMETHOD Allow(JS::HandleValue aChoices) MOZ_OVERRIDE
2962   {
2963     MOZ_ASSERT(NS_IsMainThread());
2964     MOZ_ASSERT(aChoices.isUndefined());
2965
2966     if (!mRequest) {
2967       return NS_ERROR_FAILURE;
2968     }
2969
2970     nsCOMPtr<nsIRunnable> r;
2971
2972     switch(mRequestType) {
2973       case DEVICE_STORAGE_REQUEST_CREATEFD:
2974       {
2975         if (!mFile->mFile) {
2976           return NS_ERROR_FAILURE;
2977         }
2978
2979         DeviceStorageTypeChecker* typeChecker
2980           = DeviceStorageTypeChecker::CreateOrGet();
2981         if (!typeChecker) {
2982           return NS_OK;
2983         }
2984
2985         if (!typeChecker->Check(mFile->mStorageType, mFile->mFile)) {
2986           r = new PostErrorEvent(mRequest.forget(),
2987                                  POST_ERROR_EVENT_ILLEGAL_TYPE);
2988           return NS_DispatchToCurrentThread(r);
2989         }
2990
2991         if (XRE_GetProcessType() != GeckoProcessType_Default) {
2992
2993           DeviceStorageCreateFdParams params;
2994           params.type() = mFile->mStorageType;
2995           params.storageName() = mFile->mStorageName;
2996           params.relpath() = mFile->mPath;
2997
2998           mFile->Dump("DeviceStorageCreateFdParams");
2999
3000           PDeviceStorageRequestChild* child
3001             = new DeviceStorageRequestChild(mRequest, mFile,
3002                                             mDSFileDescriptor.get());
3003           ContentChild::GetSingleton()
3004             ->SendPDeviceStorageRequestConstructor(child, params);
3005           return NS_OK;
3006         }
3007         mDSFileDescriptor->mDSFile = mFile;
3008         r = new CreateFdEvent(mDSFileDescriptor.get(), mRequest.forget());
3009         break;
3010       }
3011
3012       case DEVICE_STORAGE_REQUEST_CREATE:
3013       {
3014         if (!mBlob || !mFile->mFile) {
3015           return NS_ERROR_FAILURE;
3016         }
3017
3018         DeviceStorageTypeChecker* typeChecker
3019           = DeviceStorageTypeChecker::CreateOrGet();
3020         if (!typeChecker) {
3021           return NS_OK;
3022         }
3023
3024         if (!typeChecker->Check(mFile->mStorageType, mFile->mFile) ||
3025             !typeChecker->Check(mFile->mStorageType, mBlob)) {
3026           r = new PostErrorEvent(mRequest.forget(),
3027                                  POST_ERROR_EVENT_ILLEGAL_TYPE);
3028           return NS_DispatchToCurrentThread(r);
3029         }
3030
3031         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3032           BlobChild* actor
3033             = ContentChild::GetSingleton()->GetOrCreateActorForBlob(
3034               static_cast<File*>(mBlob.get()));
3035           if (!actor) {
3036             return NS_ERROR_FAILURE;
3037           }
3038
3039           DeviceStorageAddParams params;
3040           params.blobChild() = actor;
3041           params.type() = mFile->mStorageType;
3042           params.storageName() = mFile->mStorageName;
3043           params.relpath() = mFile->mPath;
3044
3045           PDeviceStorageRequestChild* child
3046             = new DeviceStorageRequestChild(mRequest, mFile);
3047           ContentChild::GetSingleton()
3048             ->SendPDeviceStorageRequestConstructor(child, params);
3049           return NS_OK;
3050         }
3051
3052         File* blob = static_cast<File*>(mBlob.get());
3053         r = new WriteFileEvent(blob->Impl(), mFile, mRequest.forget(),
3054                                mRequestType);
3055         break;
3056       }
3057
3058       case DEVICE_STORAGE_REQUEST_APPEND:
3059       {
3060         if (!mBlob || !mFile->mFile) {
3061           return NS_ERROR_FAILURE;
3062         }
3063
3064         DeviceStorageTypeChecker* typeChecker
3065           = DeviceStorageTypeChecker::CreateOrGet();
3066         if (!typeChecker) {
3067           return NS_OK;
3068         }
3069
3070         if (!typeChecker->Check(mFile->mStorageType, mFile->mFile) ||
3071             !typeChecker->Check(mFile->mStorageType, mBlob)) {
3072           r = new PostErrorEvent(mRequest.forget(),
3073                                  POST_ERROR_EVENT_ILLEGAL_TYPE);
3074           return NS_DispatchToCurrentThread(r);
3075         }
3076
3077         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3078           BlobChild* actor
3079             = ContentChild::GetSingleton()->GetOrCreateActorForBlob(
3080               static_cast<File*>(mBlob.get()));
3081           if (!actor) {
3082             return NS_ERROR_FAILURE;
3083           }
3084
3085           DeviceStorageAppendParams params;
3086           params.blobChild() = actor;
3087           params.type() = mFile->mStorageType;
3088           params.storageName() = mFile->mStorageName;
3089           params.relpath() = mFile->mPath;
3090
3091           PDeviceStorageRequestChild* child
3092             = new DeviceStorageRequestChild(mRequest, mFile);
3093           ContentChild::GetSingleton()
3094             ->SendPDeviceStorageRequestConstructor(child, params);
3095           return NS_OK;
3096         }
3097
3098         File* blob = static_cast<File*>(mBlob.get());
3099         r = new WriteFileEvent(blob->Impl(), mFile, mRequest.forget(),
3100                                mRequestType);
3101         break;
3102       }
3103
3104       case DEVICE_STORAGE_REQUEST_READ:
3105       case DEVICE_STORAGE_REQUEST_WRITE:
3106       {
3107         if (!mFile->mFile) {
3108           return NS_ERROR_FAILURE;
3109         }
3110
3111         DeviceStorageTypeChecker* typeChecker
3112           = DeviceStorageTypeChecker::CreateOrGet();
3113         if (!typeChecker) {
3114           return NS_OK;
3115         }
3116
3117         if (!typeChecker->Check(mFile->mStorageType, mFile->mFile)) {
3118           r = new PostErrorEvent(mRequest.forget(),
3119                                  POST_ERROR_EVENT_ILLEGAL_TYPE);
3120           return NS_DispatchToCurrentThread(r);
3121         }
3122
3123         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3124           PDeviceStorageRequestChild* child
3125             = new DeviceStorageRequestChild(mRequest, mFile);
3126           DeviceStorageGetParams params(mFile->mStorageType,
3127                                         mFile->mStorageName,
3128                                         mFile->mRootDir,
3129                                         mFile->mPath);
3130           ContentChild::GetSingleton()
3131             ->SendPDeviceStorageRequestConstructor(child, params);
3132           return NS_OK;
3133         }
3134
3135         r = new ReadFileEvent(mFile, mRequest.forget());
3136         break;
3137       }
3138
3139       case DEVICE_STORAGE_REQUEST_DELETE:
3140       {
3141         if (!mFile->mFile) {
3142           return NS_ERROR_FAILURE;
3143         }
3144
3145         DeviceStorageTypeChecker* typeChecker
3146           = DeviceStorageTypeChecker::CreateOrGet();
3147         if (!typeChecker) {
3148           return NS_OK;
3149         }
3150
3151         if (!typeChecker->Check(mFile->mStorageType, mFile->mFile)) {
3152           r = new PostErrorEvent(mRequest.forget(),
3153                                  POST_ERROR_EVENT_ILLEGAL_TYPE);
3154           return NS_DispatchToCurrentThread(r);
3155         }
3156
3157         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3158           PDeviceStorageRequestChild* child
3159             = new DeviceStorageRequestChild(mRequest, mFile);
3160           DeviceStorageDeleteParams params(mFile->mStorageType,
3161                                            mFile->mStorageName,
3162                                            mFile->mPath);
3163           ContentChild::GetSingleton()
3164             ->SendPDeviceStorageRequestConstructor(child, params);
3165           return NS_OK;
3166         }
3167         r = new DeleteFileEvent(mFile, mRequest.forget());
3168         break;
3169       }
3170
3171       case DEVICE_STORAGE_REQUEST_FREE_SPACE:
3172       {
3173         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3174           PDeviceStorageRequestChild* child
3175             = new DeviceStorageRequestChild(mRequest, mFile);
3176           DeviceStorageFreeSpaceParams params(mFile->mStorageType,
3177                                               mFile->mStorageName);
3178           ContentChild::GetSingleton()
3179             ->SendPDeviceStorageRequestConstructor(child, params);
3180           return NS_OK;
3181         }
3182         r = new FreeSpaceFileEvent(mFile, mRequest.forget());
3183         break;
3184       }
3185
3186       case DEVICE_STORAGE_REQUEST_USED_SPACE:
3187       {
3188         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3189           PDeviceStorageRequestChild* child
3190             = new DeviceStorageRequestChild(mRequest, mFile);
3191           DeviceStorageUsedSpaceParams params(mFile->mStorageType,
3192                                               mFile->mStorageName);
3193           ContentChild::GetSingleton()
3194             ->SendPDeviceStorageRequestConstructor(child, params);
3195           return NS_OK;
3196         }
3197         // this needs to be dispatched to only one (1)
3198         // thread or we will do more work than required.
3199         DeviceStorageUsedSpaceCache* usedSpaceCache
3200           = DeviceStorageUsedSpaceCache::CreateOrGet();
3201         MOZ_ASSERT(usedSpaceCache);
3202         r = new UsedSpaceFileEvent(mFile, mRequest.forget());
3203         usedSpaceCache->Dispatch(r);
3204         return NS_OK;
3205       }
3206
3207       case DEVICE_STORAGE_REQUEST_AVAILABLE:
3208       {
3209         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3210           PDeviceStorageRequestChild* child
3211             = new DeviceStorageRequestChild(mRequest, mFile);
3212           DeviceStorageAvailableParams params(mFile->mStorageType,
3213                                               mFile->mStorageName);
3214           ContentChild::GetSingleton()
3215             ->SendPDeviceStorageRequestConstructor(child, params);
3216           return NS_OK;
3217         }
3218         r = new PostAvailableResultEvent(mFile, mRequest);
3219         return NS_DispatchToCurrentThread(r);
3220       }
3221
3222       case DEVICE_STORAGE_REQUEST_STATUS:
3223       {
3224         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3225           PDeviceStorageRequestChild* child
3226             = new DeviceStorageRequestChild(mRequest, mFile);
3227           DeviceStorageStatusParams params(mFile->mStorageType,
3228                                               mFile->mStorageName);
3229           ContentChild::GetSingleton()
3230             ->SendPDeviceStorageRequestConstructor(child, params);
3231           return NS_OK;
3232         }
3233         r = new PostStatusResultEvent(mFile, mRequest);
3234         return NS_DispatchToCurrentThread(r);
3235       }
3236
3237       case DEVICE_STORAGE_REQUEST_WATCH:
3238       {
3239         mDeviceStorage->mAllowedToWatchFile = true;
3240         return NS_OK;
3241       }
3242
3243       case DEVICE_STORAGE_REQUEST_FORMAT:
3244       {
3245         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3246           PDeviceStorageRequestChild* child
3247             = new DeviceStorageRequestChild(mRequest, mFile);
3248           DeviceStorageFormatParams params(mFile->mStorageType,
3249                                            mFile->mStorageName);
3250           ContentChild::GetSingleton()
3251             ->SendPDeviceStorageRequestConstructor(child, params);
3252           return NS_OK;
3253         }
3254         r = new PostFormatResultEvent(mFile, mRequest);
3255         return NS_DispatchToCurrentThread(r);
3256       }
3257
3258       case DEVICE_STORAGE_REQUEST_MOUNT:
3259       {
3260         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3261           PDeviceStorageRequestChild* child
3262             = new DeviceStorageRequestChild(mRequest, mFile);
3263           DeviceStorageMountParams params(mFile->mStorageType,
3264                                            mFile->mStorageName);
3265           ContentChild::GetSingleton()
3266             ->SendPDeviceStorageRequestConstructor(child, params);
3267           return NS_OK;
3268         }
3269         r = new PostMountResultEvent(mFile, mRequest);
3270         return NS_DispatchToCurrentThread(r);
3271       }
3272
3273       case DEVICE_STORAGE_REQUEST_UNMOUNT:
3274       {
3275         if (XRE_GetProcessType() != GeckoProcessType_Default) {
3276           PDeviceStorageRequestChild* child
3277             = new DeviceStorageRequestChild(mRequest, mFile);
3278           DeviceStorageUnmountParams params(mFile->mStorageType,
3279                                            mFile->mStorageName);
3280           ContentChild::GetSingleton()
3281             ->SendPDeviceStorageRequestConstructor(child, params);
3282           return NS_OK;
3283         }
3284         r = new PostUnmountResultEvent(mFile, mRequest);
3285         return NS_DispatchToCurrentThread(r);
3286       }
3287     }
3288
3289     if (r) {
3290       nsCOMPtr<nsIEventTarget> target
3291         = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
3292       MOZ_ASSERT(target);
3293       target->Dispatch(r, NS_DISPATCH_NORMAL);
3294     }
3295
3296     return NS_OK;
3297   }
3298
3299 private:
3300   ~DeviceStorageRequest() {}
3301
3302   int32_t mRequestType;
3303   nsCOMPtr<nsPIDOMWindow> mWindow;
3304   nsCOMPtr<nsIPrincipal> mPrincipal;
3305   nsRefPtr<DeviceStorageFile> mFile;
3306
3307   nsRefPtr<DOMRequest> mRequest;
3308   nsCOMPtr<nsIDOMBlob> mBlob;
3309   nsRefPtr<nsDOMDeviceStorage> mDeviceStorage;
3310   nsRefPtr<DeviceStorageFileDescriptor> mDSFileDescriptor;
3311 };
3312
3313 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeviceStorageRequest)
3314   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentPermissionRequest)
3315   NS_INTERFACE_MAP_ENTRY(nsIContentPermissionRequest)
3316   NS_INTERFACE_MAP_ENTRY(nsIRunnable)
3317 NS_INTERFACE_MAP_END
3318
3319 NS_IMPL_CYCLE_COLLECTING_ADDREF(DeviceStorageRequest)
3320 NS_IMPL_CYCLE_COLLECTING_RELEASE(DeviceStorageRequest)
3321
3322 NS_IMPL_CYCLE_COLLECTION(DeviceStorageRequest,
3323                          mRequest,
3324                          mWindow,
3325                          mBlob,
3326                          mDeviceStorage)
3327
3328
3329 NS_INTERFACE_MAP_BEGIN(nsDOMDeviceStorage)
3330   NS_INTERFACE_MAP_ENTRY(nsIDOMDeviceStorage)
3331   NS_INTERFACE_MAP_ENTRY(nsIObserver)
3332 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
3333
3334 NS_IMPL_ADDREF_INHERITED(nsDOMDeviceStorage, DOMEventTargetHelper)
3335 NS_IMPL_RELEASE_INHERITED(nsDOMDeviceStorage, DOMEventTargetHelper)
3336
3337 nsDOMDeviceStorage::nsDOMDeviceStorage(nsPIDOMWindow* aWindow)
3338   : DOMEventTargetHelper(aWindow)
3339   , mIsShareable(false)
3340   , mIsRemovable(false)
3341   , mIsWatchingFile(false)
3342   , mAllowedToWatchFile(false)
3343 {
3344 }
3345
3346 /* virtual */ JSObject*
3347 nsDOMDeviceStorage::WrapObject(JSContext* aCx)
3348 {
3349   return DeviceStorageBinding::Wrap(aCx, this);
3350 }
3351
3352 nsresult
3353 nsDOMDeviceStorage::Init(nsPIDOMWindow* aWindow, const nsAString &aType,
3354                          const nsAString &aVolName)
3355 {
3356   DebugOnly<FileUpdateDispatcher*> observer
3357     = FileUpdateDispatcher::GetSingleton();
3358   MOZ_ASSERT(observer);
3359
3360   MOZ_ASSERT(aWindow);
3361
3362   SetRootDirectoryForType(aType, aVolName);
3363   if (!mRootDirectory) {
3364     return NS_ERROR_NOT_AVAILABLE;
3365   }
3366   if (!mStorageName.IsEmpty()) {
3367     RegisterForSDCardChanges(this);
3368
3369 #ifdef MOZ_WIDGET_GONK
3370     if (DeviceStorageTypeChecker::IsVolumeBased(mStorageType)) {
3371       nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
3372       if (NS_WARN_IF(!vs)) {
3373         return NS_ERROR_FAILURE;
3374       }
3375       nsresult rv;
3376       nsCOMPtr<nsIVolume> vol;
3377       rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
3378       if (NS_WARN_IF(NS_FAILED(rv))) {
3379         return rv;
3380       }
3381       bool isFake;
3382       rv = vol->GetIsFake(&isFake);
3383       if (NS_WARN_IF(NS_FAILED(rv))) {
3384         return rv;
3385       }
3386       mIsShareable = !isFake;
3387       bool isRemovable;
3388       rv = vol->GetIsHotSwappable(&isRemovable);
3389       if (NS_WARN_IF(NS_FAILED(rv))) {
3390         return rv;
3391       }
3392       mIsRemovable = isRemovable;
3393     }
3394 #endif
3395   }
3396
3397   // Grab the principal of the document
3398   nsCOMPtr<nsIDocument> doc = aWindow->GetDoc();
3399   if (!doc) {
3400     return NS_ERROR_FAILURE;
3401   }
3402   mPrincipal = doc->NodePrincipal();
3403
3404   // the 'apps' type is special.  We only want this exposed
3405   // if the caller has the "webapps-manage" permission.
3406   if (aType.EqualsLiteral(DEVICESTORAGE_APPS)) {
3407     nsCOMPtr<nsIPermissionManager> permissionManager
3408       = services::GetPermissionManager();
3409     NS_ENSURE_TRUE(permissionManager, NS_ERROR_FAILURE);
3410
3411     uint32_t permission;
3412     nsresult rv
3413       = permissionManager->TestPermissionFromPrincipal(mPrincipal,
3414                                                        "webapps-manage",
3415                                                        &permission);
3416
3417     if (NS_FAILED(rv) || permission != nsIPermissionManager::ALLOW_ACTION) {
3418       return NS_ERROR_NOT_AVAILABLE;
3419     }
3420   }
3421
3422   return NS_OK;
3423 }
3424
3425 nsDOMDeviceStorage::~nsDOMDeviceStorage()
3426 {
3427 }
3428
3429 void
3430 nsDOMDeviceStorage::Shutdown()
3431 {
3432   MOZ_ASSERT(NS_IsMainThread());
3433
3434   if (mFileSystem) {
3435     mFileSystem->Shutdown();
3436     mFileSystem = nullptr;
3437   }
3438
3439   if (!mStorageName.IsEmpty()) {
3440     UnregisterForSDCardChanges(this);
3441   }
3442
3443   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
3444   obs->RemoveObserver(this, kFileWatcherUpdate);
3445   obs->RemoveObserver(this, "disk-space-watcher");
3446 }
3447
3448 StaticAutoPtr<nsTArray<nsString>> nsDOMDeviceStorage::sVolumeNameCache;
3449
3450 // static
3451 void
3452 nsDOMDeviceStorage::GetOrderedVolumeNames(
3453   nsDOMDeviceStorage::VolumeNameArray &aVolumeNames)
3454 {
3455   if (sVolumeNameCache && sVolumeNameCache->Length() > 0) {
3456     aVolumeNames.AppendElements(*sVolumeNameCache);
3457     return;
3458   }
3459 #ifdef MOZ_WIDGET_GONK
3460   nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
3461   if (vs) {
3462     nsCOMPtr<nsIArray> volNames;
3463     vs->GetVolumeNames(getter_AddRefs(volNames));
3464     uint32_t length = -1;
3465     volNames->GetLength(&length);
3466     for (uint32_t i = 0; i < length; i++) {
3467       nsCOMPtr<nsISupportsString> str = do_QueryElementAt(volNames, i);
3468       if (str) {
3469         nsAutoString s;
3470         if (NS_SUCCEEDED(str->GetData(s)) && !s.IsEmpty()) {
3471           aVolumeNames.AppendElement(s);
3472         }
3473       }
3474     }
3475
3476     // If the volume sdcard exists, then we want it to be first.
3477
3478     VolumeNameArray::index_type sdcardIndex;
3479     sdcardIndex = aVolumeNames.IndexOf(NS_LITERAL_STRING("sdcard"));
3480     if (sdcardIndex != VolumeNameArray::NoIndex && sdcardIndex > 0) {
3481       aVolumeNames.RemoveElementAt(sdcardIndex);
3482       aVolumeNames.InsertElementAt(0, NS_LITERAL_STRING("sdcard"));
3483     }
3484   }
3485 #endif
3486   if (aVolumeNames.IsEmpty()) {
3487     aVolumeNames.AppendElement(EmptyString());
3488   }
3489   sVolumeNameCache = new nsTArray<nsString>;
3490   sVolumeNameCache->AppendElements(aVolumeNames);
3491 }
3492
3493 // static
3494 void
3495 nsDOMDeviceStorage::CreateDeviceStorageFor(nsPIDOMWindow* aWin,
3496                                            const nsAString &aType,
3497                                            nsDOMDeviceStorage** aStore)
3498 {
3499   nsString storageName;
3500   if (!DeviceStorageTypeChecker::IsVolumeBased(aType)) {
3501     // The storage name will be the empty string
3502     storageName.Truncate();
3503   } else {
3504     GetDefaultStorageName(aType, storageName);
3505   }
3506
3507   nsRefPtr<nsDOMDeviceStorage> ds = new nsDOMDeviceStorage(aWin);
3508   if (NS_FAILED(ds->Init(aWin, aType, storageName))) {
3509     *aStore = nullptr;
3510     return;
3511   }
3512   NS_ADDREF(*aStore = ds.get());
3513 }
3514
3515 // static
3516 void
3517 nsDOMDeviceStorage::CreateDeviceStoragesFor(
3518   nsPIDOMWindow* aWin,
3519   const nsAString &aType,
3520   nsTArray<nsRefPtr<nsDOMDeviceStorage> > &aStores)
3521 {
3522   nsresult rv;
3523
3524   if (!DeviceStorageTypeChecker::IsVolumeBased(aType)) {
3525     nsRefPtr<nsDOMDeviceStorage> storage = new nsDOMDeviceStorage(aWin);
3526     rv = storage->Init(aWin, aType, EmptyString());
3527     if (NS_SUCCEEDED(rv)) {
3528       aStores.AppendElement(storage);
3529     }
3530     return;
3531   }
3532   VolumeNameArray volNames;
3533   GetOrderedVolumeNames(volNames);
3534
3535   VolumeNameArray::size_type numVolumeNames = volNames.Length();
3536   for (VolumeNameArray::index_type i = 0; i < numVolumeNames; i++) {
3537     nsRefPtr<nsDOMDeviceStorage> storage = new nsDOMDeviceStorage(aWin);
3538     rv = storage->Init(aWin, aType, volNames[i]);
3539     if (NS_FAILED(rv)) {
3540       break;
3541     }
3542     aStores.AppendElement(storage);
3543   }
3544 }
3545
3546 // static
3547 bool
3548 nsDOMDeviceStorage::ParseFullPath(const nsAString& aFullPath,
3549                                   nsAString& aOutStorageName,
3550                                   nsAString& aOutStoragePath)
3551 {
3552   aOutStorageName.Truncate();
3553   aOutStoragePath.Truncate();
3554
3555   NS_NAMED_LITERAL_STRING(slash, "/");
3556
3557   nsDependentSubstring storageName;
3558
3559   if (StringBeginsWith(aFullPath, slash)) {
3560     int32_t slashIndex = aFullPath.FindChar('/', 1);
3561     if (slashIndex == kNotFound) {
3562       // names of the form /filename are illegal
3563       return false;
3564     }
3565     storageName.Rebind(aFullPath, 1, slashIndex - 1);
3566     aOutStoragePath = Substring(aFullPath, slashIndex + 1);
3567   } else {
3568     aOutStoragePath = aFullPath;
3569   }
3570   // If no volume name was specified in aFullPath, then aOutStorageName
3571   // will wind up being the empty string. It's up to the caller to figure
3572   // out which storage name to actually use.
3573   aOutStorageName = storageName;
3574   return true;
3575 }
3576
3577 already_AddRefed<nsDOMDeviceStorage>
3578 nsDOMDeviceStorage::GetStorage(const nsAString& aFullPath,
3579                                nsAString& aOutStoragePath)
3580 {
3581   nsString storageName;
3582   if (!ParseFullPath(aFullPath, storageName, aOutStoragePath)) {
3583     return nullptr;
3584   }
3585   nsRefPtr<nsDOMDeviceStorage> ds;
3586   if (storageName.IsEmpty()) {
3587     ds = this;
3588   } else {
3589     ds = GetStorageByName(storageName);
3590   }
3591   return ds.forget();
3592 }
3593
3594 already_AddRefed<nsDOMDeviceStorage>
3595 nsDOMDeviceStorage::GetStorageByName(const nsAString& aStorageName)
3596 {
3597   MOZ_ASSERT(NS_IsMainThread());
3598
3599   nsRefPtr<nsDOMDeviceStorage> ds;
3600
3601   if (mStorageName.Equals(aStorageName)) {
3602     ds = this;
3603     return ds.forget();
3604   }
3605   VolumeNameArray volNames;
3606   GetOrderedVolumeNames(volNames);
3607   VolumeNameArray::size_type numVolumes = volNames.Length();
3608   VolumeNameArray::index_type i;
3609   for (i = 0; i < numVolumes; i++) {
3610     if (volNames[i].Equals(aStorageName)) {
3611       ds = new nsDOMDeviceStorage(GetOwner());
3612       nsresult rv = ds->Init(GetOwner(), mStorageType, aStorageName);
3613       if (NS_FAILED(rv)) {
3614         return nullptr;
3615       }
3616       return ds.forget();
3617     }
3618   }
3619   return nullptr;
3620 }
3621
3622 // static
3623 void
3624 nsDOMDeviceStorage::GetDefaultStorageName(const nsAString& aStorageType,
3625                                           nsAString& aStorageName)
3626 {
3627   // See if the preferred volume is available.
3628   nsRefPtr<nsDOMDeviceStorage> ds;
3629   nsAdoptingString prefStorageName =
3630     mozilla::Preferences::GetString("device.storage.writable.name");
3631   if (prefStorageName) {
3632     aStorageName = prefStorageName;
3633     return;
3634   }
3635
3636   // No preferred storage, we'll use the first one (which should be sdcard).
3637
3638   VolumeNameArray volNames;
3639   GetOrderedVolumeNames(volNames);
3640   if (volNames.Length() > 0) {
3641     aStorageName = volNames[0];
3642     return;
3643   }
3644
3645   // No volumes available, return the empty string. This is normal for
3646   // b2g-desktop.
3647   aStorageName.Truncate();
3648 }
3649
3650 bool
3651 nsDOMDeviceStorage::IsAvailable()
3652 {
3653   nsRefPtr<DeviceStorageFile> dsf(new DeviceStorageFile(mStorageType, mStorageName));
3654   return dsf->IsAvailable();
3655 }
3656
3657 NS_IMETHODIMP
3658 nsDOMDeviceStorage::Add(nsIDOMBlob *aBlob, nsIDOMDOMRequest * *_retval)
3659 {
3660   ErrorResult rv;
3661   nsRefPtr<DOMRequest> request = Add(aBlob, rv);
3662   request.forget(_retval);
3663   return rv.ErrorCode();
3664 }
3665
3666 already_AddRefed<DOMRequest>
3667 nsDOMDeviceStorage::Add(nsIDOMBlob* aBlob, ErrorResult& aRv)
3668 {
3669   if (!aBlob) {
3670     return nullptr;
3671   }
3672
3673   nsCOMPtr<nsIMIMEService> mimeSvc = do_GetService(NS_MIMESERVICE_CONTRACTID);
3674   if (!mimeSvc) {
3675     aRv.Throw(NS_ERROR_FAILURE);
3676     return nullptr;
3677   }
3678
3679   // if mimeType isn't set, we will not get a correct
3680   // extension, and AddNamed() will fail.  This will post an
3681   // onerror to the requestee.
3682   nsString mimeType;
3683   aBlob->GetType(mimeType);
3684
3685   nsCString extension;
3686   mimeSvc->GetPrimaryExtension(NS_LossyConvertUTF16toASCII(mimeType),
3687                                EmptyCString(), extension);
3688   // if extension is null here, we will ignore it for now.
3689   // AddNamed() will check the file path and fail.  This
3690   // will post an onerror to the requestee.
3691
3692   // possible race here w/ unique filename
3693   char buffer[32];
3694   NS_MakeRandomString(buffer, ArrayLength(buffer) - 1);
3695
3696   nsAutoCString path;
3697   path.Assign(nsDependentCString(buffer));
3698   path.Append('.');
3699   path.Append(extension);
3700
3701   return AddNamed(aBlob, NS_ConvertASCIItoUTF16(path), aRv);
3702 }
3703
3704 NS_IMETHODIMP
3705 nsDOMDeviceStorage::AddNamed(nsIDOMBlob *aBlob,
3706                              const nsAString & aPath,
3707                              nsIDOMDOMRequest * *_retval)
3708 {
3709   ErrorResult rv;
3710   nsRefPtr<DOMRequest> request = AddNamed(aBlob, aPath, rv);
3711   request.forget(_retval);
3712   return rv.ErrorCode();
3713 }
3714
3715 already_AddRefed<DOMRequest>
3716 nsDOMDeviceStorage::AddNamed(nsIDOMBlob* aBlob, const nsAString& aPath,
3717                              ErrorResult& aRv)
3718 {
3719   return AddOrAppendNamed(aBlob, aPath,
3720                           DEVICE_STORAGE_REQUEST_CREATE, aRv);
3721 }
3722
3723 already_AddRefed<DOMRequest>
3724 nsDOMDeviceStorage::AppendNamed(nsIDOMBlob* aBlob, const nsAString& aPath,
3725                                 ErrorResult& aRv)
3726 {
3727   return AddOrAppendNamed(aBlob, aPath,
3728                           DEVICE_STORAGE_REQUEST_APPEND, aRv);
3729 }
3730
3731
3732 already_AddRefed<DOMRequest>
3733 nsDOMDeviceStorage::AddOrAppendNamed(nsIDOMBlob* aBlob, const nsAString& aPath,
3734                                      const int32_t aRequestType, ErrorResult& aRv)
3735 {
3736   MOZ_ASSERT(NS_IsMainThread());
3737
3738   // if the blob is null here, bail
3739   if (!aBlob) {
3740     return nullptr;
3741   }
3742
3743   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
3744   if (!win) {
3745     aRv.Throw(NS_ERROR_UNEXPECTED);
3746     return nullptr;
3747   }
3748
3749   DeviceStorageTypeChecker* typeChecker
3750     = DeviceStorageTypeChecker::CreateOrGet();
3751   if (!typeChecker) {
3752     aRv.Throw(NS_ERROR_FAILURE);
3753     return nullptr;
3754   }
3755
3756   nsCOMPtr<nsIRunnable> r;
3757   nsresult rv;
3758
3759   if (IsFullPath(aPath)) {
3760     nsString storagePath;
3761     nsRefPtr<nsDOMDeviceStorage> ds = GetStorage(aPath, storagePath);
3762     if (!ds) {
3763       nsRefPtr<DOMRequest> request = new DOMRequest(win);
3764       r = new PostErrorEvent(request, POST_ERROR_EVENT_UNKNOWN);
3765       rv = NS_DispatchToCurrentThread(r);
3766       if (NS_FAILED(rv)) {
3767         aRv.Throw(rv);
3768       }
3769       return request.forget();
3770     }
3771
3772     return ds->AddOrAppendNamed(aBlob, storagePath,
3773                                 aRequestType, aRv);
3774   }
3775
3776   nsRefPtr<DOMRequest> request = new DOMRequest(win);
3777
3778   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
3779                                                           mStorageName,
3780                                                           aPath);
3781   if (!dsf->IsSafePath()) {
3782     r = new PostErrorEvent(request, POST_ERROR_EVENT_PERMISSION_DENIED);
3783   } else if (!typeChecker->Check(mStorageType, dsf->mFile) ||
3784       !typeChecker->Check(mStorageType, aBlob)) {
3785     r = new PostErrorEvent(request, POST_ERROR_EVENT_ILLEGAL_TYPE);
3786   } else if (aRequestType == DEVICE_STORAGE_REQUEST_APPEND ||
3787              aRequestType == DEVICE_STORAGE_REQUEST_CREATE) {
3788     r = new DeviceStorageRequest(DeviceStorageRequestType(aRequestType),
3789                                  win, mPrincipal, dsf, request, aBlob);
3790   } else {
3791       aRv.Throw(NS_ERROR_UNEXPECTED);
3792       return nullptr;
3793   }
3794
3795   rv = NS_DispatchToCurrentThread(r);
3796   if (NS_FAILED(rv)) {
3797     aRv.Throw(rv);
3798   }
3799   return request.forget();
3800 }
3801
3802 NS_IMETHODIMP
3803 nsDOMDeviceStorage::Get(const nsAString& aPath, nsIDOMDOMRequest** aRetval)
3804 {
3805   ErrorResult rv;
3806   nsRefPtr<DOMRequest> request = Get(aPath, rv);
3807   request.forget(aRetval);
3808   return rv.ErrorCode();
3809 }
3810
3811 NS_IMETHODIMP
3812 nsDOMDeviceStorage::GetEditable(const nsAString& aPath,
3813                                 nsIDOMDOMRequest** aRetval)
3814 {
3815   ErrorResult rv;
3816   nsRefPtr<DOMRequest> request = GetEditable(aPath, rv);
3817   request.forget(aRetval);
3818   return rv.ErrorCode();
3819 }
3820
3821 already_AddRefed<DOMRequest>
3822 nsDOMDeviceStorage::GetInternal(const nsAString& aPath, bool aEditable,
3823                                 ErrorResult& aRv)
3824 {
3825   MOZ_ASSERT(NS_IsMainThread());
3826
3827   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
3828   if (!win) {
3829     aRv.Throw(NS_ERROR_UNEXPECTED);
3830     return nullptr;
3831   }
3832
3833   nsRefPtr<DOMRequest> request = new DOMRequest(win);
3834
3835   if (IsFullPath(aPath)) {
3836     nsString storagePath;
3837     nsRefPtr<nsDOMDeviceStorage> ds = GetStorage(aPath, storagePath);
3838     if (!ds) {
3839       nsCOMPtr<nsIRunnable> r =
3840         new PostErrorEvent(request, POST_ERROR_EVENT_UNKNOWN);
3841       nsresult rv = NS_DispatchToCurrentThread(r);
3842       if (NS_FAILED(rv)) {
3843         aRv.Throw(rv);
3844       }
3845       return request.forget();
3846     }
3847     ds->GetInternal(win, storagePath, request, aEditable);
3848     return request.forget();
3849   }
3850   GetInternal(win, aPath, request, aEditable);
3851   return request.forget();
3852 }
3853
3854 void
3855 nsDOMDeviceStorage::GetInternal(nsPIDOMWindow *aWin,
3856                                 const nsAString& aPath,
3857                                 DOMRequest* aRequest,
3858                                 bool aEditable)
3859 {
3860   MOZ_ASSERT(NS_IsMainThread());
3861
3862   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
3863                                                           mStorageName,
3864                                                           aPath);
3865   dsf->SetEditable(aEditable);
3866
3867   nsCOMPtr<nsIRunnable> r;
3868   if (!dsf->IsSafePath()) {
3869     r = new PostErrorEvent(aRequest, POST_ERROR_EVENT_PERMISSION_DENIED);
3870   } else {
3871     r = new DeviceStorageRequest(aEditable ? DEVICE_STORAGE_REQUEST_WRITE
3872                                            : DEVICE_STORAGE_REQUEST_READ,
3873                                  aWin, mPrincipal, dsf, aRequest);
3874   }
3875   DebugOnly<nsresult> rv = NS_DispatchToCurrentThread(r);
3876   MOZ_ASSERT(NS_SUCCEEDED(rv));
3877 }
3878
3879 NS_IMETHODIMP
3880 nsDOMDeviceStorage::Delete(const nsAString& aPath, nsIDOMDOMRequest** aRetval)
3881 {
3882   ErrorResult rv;
3883   nsRefPtr<DOMRequest> request = Delete(aPath, rv);
3884   request.forget(aRetval);
3885   return rv.ErrorCode();
3886 }
3887
3888 already_AddRefed<DOMRequest>
3889 nsDOMDeviceStorage::Delete(const nsAString& aPath, ErrorResult& aRv)
3890 {
3891   MOZ_ASSERT(NS_IsMainThread());
3892
3893   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
3894   if (!win) {
3895     aRv.Throw(NS_ERROR_UNEXPECTED);
3896     return nullptr;
3897   }
3898
3899   nsRefPtr<DOMRequest> request = new DOMRequest(win);
3900
3901   if (IsFullPath(aPath)) {
3902     nsString storagePath;
3903     nsRefPtr<nsDOMDeviceStorage> ds = GetStorage(aPath, storagePath);
3904     if (!ds) {
3905       nsCOMPtr<nsIRunnable> r =
3906         new PostErrorEvent(request, POST_ERROR_EVENT_UNKNOWN);
3907       nsresult rv = NS_DispatchToCurrentThread(r);
3908       if (NS_FAILED(rv)) {
3909         aRv.Throw(rv);
3910       }
3911       return request.forget();
3912     }
3913     ds->DeleteInternal(win, storagePath, request);
3914     return request.forget();
3915   }
3916   DeleteInternal(win, aPath, request);
3917   return request.forget();
3918 }
3919
3920 void
3921 nsDOMDeviceStorage::DeleteInternal(nsPIDOMWindow *aWin,
3922                                    const nsAString& aPath,
3923                                    DOMRequest* aRequest)
3924 {
3925   MOZ_ASSERT(NS_IsMainThread());
3926
3927   nsCOMPtr<nsIRunnable> r;
3928   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
3929                                                           mStorageName,
3930                                                           aPath);
3931   if (!dsf->IsSafePath()) {
3932     r = new PostErrorEvent(aRequest, POST_ERROR_EVENT_PERMISSION_DENIED);
3933   } else {
3934     r = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_DELETE,
3935                                  aWin, mPrincipal, dsf, aRequest);
3936   }
3937   DebugOnly<nsresult> rv = NS_DispatchToCurrentThread(r);
3938   MOZ_ASSERT(NS_SUCCEEDED(rv));
3939 }
3940
3941 NS_IMETHODIMP
3942 nsDOMDeviceStorage::FreeSpace(nsIDOMDOMRequest** aRetval)
3943 {
3944   ErrorResult rv;
3945   nsRefPtr<DOMRequest> request = FreeSpace(rv);
3946   request.forget(aRetval);
3947   return rv.ErrorCode();
3948 }
3949
3950 already_AddRefed<DOMRequest>
3951 nsDOMDeviceStorage::FreeSpace(ErrorResult& aRv)
3952 {
3953   MOZ_ASSERT(NS_IsMainThread());
3954
3955   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
3956   if (!win) {
3957     aRv.Throw(NS_ERROR_UNEXPECTED);
3958     return nullptr;
3959   }
3960
3961   nsRefPtr<DOMRequest> request = new DOMRequest(win);
3962
3963   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
3964                                                           mStorageName);
3965   nsCOMPtr<nsIRunnable> r
3966     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_FREE_SPACE,
3967                                win, mPrincipal, dsf, request);
3968   nsresult rv = NS_DispatchToCurrentThread(r);
3969   if (NS_FAILED(rv)) {
3970     aRv.Throw(rv);
3971   }
3972   return request.forget();
3973 }
3974
3975 NS_IMETHODIMP
3976 nsDOMDeviceStorage::UsedSpace(nsIDOMDOMRequest** aRetval)
3977 {
3978   ErrorResult rv;
3979   nsRefPtr<DOMRequest> request = UsedSpace(rv);
3980   request.forget(aRetval);
3981   return rv.ErrorCode();
3982 }
3983
3984 already_AddRefed<DOMRequest>
3985 nsDOMDeviceStorage::UsedSpace(ErrorResult& aRv)
3986 {
3987   MOZ_ASSERT(NS_IsMainThread());
3988
3989   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
3990   if (!win) {
3991     aRv.Throw(NS_ERROR_UNEXPECTED);
3992     return nullptr;
3993   }
3994
3995   DebugOnly<DeviceStorageUsedSpaceCache*> usedSpaceCache
3996     = DeviceStorageUsedSpaceCache::CreateOrGet();
3997   MOZ_ASSERT(usedSpaceCache);
3998
3999   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4000
4001   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4002                                                           mStorageName);
4003   nsCOMPtr<nsIRunnable> r
4004     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_USED_SPACE,
4005                                win, mPrincipal, dsf, request);
4006   nsresult rv = NS_DispatchToCurrentThread(r);
4007   if (NS_FAILED(rv)) {
4008     aRv.Throw(rv);
4009   }
4010   return request.forget();
4011 }
4012
4013 NS_IMETHODIMP
4014 nsDOMDeviceStorage::Available(nsIDOMDOMRequest** aRetval)
4015 {
4016   ErrorResult rv;
4017   nsRefPtr<DOMRequest> request = Available(rv);
4018   request.forget(aRetval);
4019   return rv.ErrorCode();
4020 }
4021
4022 already_AddRefed<DOMRequest>
4023 nsDOMDeviceStorage::Available(ErrorResult& aRv)
4024 {
4025   MOZ_ASSERT(NS_IsMainThread());
4026
4027   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4028   if (!win) {
4029     aRv.Throw(NS_ERROR_UNEXPECTED);
4030     return nullptr;
4031   }
4032
4033   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4034
4035   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4036                                                           mStorageName);
4037   nsCOMPtr<nsIRunnable> r
4038     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_AVAILABLE,
4039                                win, mPrincipal, dsf, request);
4040   nsresult rv = NS_DispatchToCurrentThread(r);
4041   if (NS_FAILED(rv)) {
4042     aRv.Throw(rv);
4043   }
4044   return request.forget();
4045 }
4046
4047 already_AddRefed<DOMRequest>
4048 nsDOMDeviceStorage::StorageStatus(ErrorResult& aRv)
4049 {
4050   MOZ_ASSERT(NS_IsMainThread());
4051
4052   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4053   if (!win) {
4054     aRv.Throw(NS_ERROR_UNEXPECTED);
4055     return nullptr;
4056   }
4057
4058   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4059
4060   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4061                                                           mStorageName);
4062   nsCOMPtr<nsIRunnable> r
4063     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_STATUS,
4064                                win, mPrincipal, dsf, request);
4065   nsresult rv = NS_DispatchToCurrentThread(r);
4066   if (NS_FAILED(rv)) {
4067     aRv.Throw(rv);
4068   }
4069   return request.forget();
4070 }
4071
4072 already_AddRefed<DOMRequest>
4073 nsDOMDeviceStorage::Format(ErrorResult& aRv)
4074 {
4075   MOZ_ASSERT(NS_IsMainThread());
4076
4077   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4078   if (!win) {
4079     aRv.Throw(NS_ERROR_UNEXPECTED);
4080     return nullptr;
4081   }
4082
4083   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4084
4085   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4086                                                           mStorageName);
4087   nsCOMPtr<nsIRunnable> r
4088     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_FORMAT,
4089                                win, mPrincipal, dsf, request);
4090   nsresult rv = NS_DispatchToCurrentThread(r);
4091   if (NS_FAILED(rv)) {
4092     aRv.Throw(rv);
4093   }
4094   return request.forget();
4095 }
4096
4097 already_AddRefed<DOMRequest>
4098 nsDOMDeviceStorage::Mount(ErrorResult& aRv)
4099 {
4100   MOZ_ASSERT(NS_IsMainThread());
4101
4102   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4103   if (!win) {
4104     aRv.Throw(NS_ERROR_UNEXPECTED);
4105     return nullptr;
4106   }
4107
4108   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4109
4110   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4111                                                           mStorageName);
4112   nsCOMPtr<nsIRunnable> r
4113     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_MOUNT,
4114                                win, mPrincipal, dsf, request);
4115   nsresult rv = NS_DispatchToCurrentThread(r);
4116   if (NS_FAILED(rv)) {
4117     aRv.Throw(rv);
4118   }
4119   return request.forget();
4120 }
4121
4122 already_AddRefed<DOMRequest>
4123 nsDOMDeviceStorage::Unmount(ErrorResult& aRv)
4124 {
4125   MOZ_ASSERT(NS_IsMainThread());
4126
4127   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4128   if (!win) {
4129     aRv.Throw(NS_ERROR_UNEXPECTED);
4130     return nullptr;
4131   }
4132
4133   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4134
4135   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4136                                                           mStorageName);
4137   nsCOMPtr<nsIRunnable> r
4138     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_UNMOUNT,
4139                                win, mPrincipal, dsf, request);
4140   nsresult rv = NS_DispatchToCurrentThread(r);
4141   if (NS_FAILED(rv)) {
4142     aRv.Throw(rv);
4143   }
4144   return request.forget();
4145 }
4146
4147 NS_IMETHODIMP
4148 nsDOMDeviceStorage::CreateFileDescriptor(const nsAString& aPath,
4149                                          DeviceStorageFileDescriptor* aDSFileDescriptor,
4150                                          nsIDOMDOMRequest** aRequest)
4151 {
4152   MOZ_ASSERT(NS_IsMainThread());
4153   MOZ_ASSERT(aDSFileDescriptor);
4154
4155   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4156   if (!win) {
4157     return NS_ERROR_UNEXPECTED;
4158   }
4159
4160   DeviceStorageTypeChecker* typeChecker
4161     = DeviceStorageTypeChecker::CreateOrGet();
4162   if (!typeChecker) {
4163     return NS_ERROR_FAILURE;
4164   }
4165
4166   nsCOMPtr<nsIRunnable> r;
4167   nsresult rv;
4168
4169   if (IsFullPath(aPath)) {
4170     nsString storagePath;
4171     nsRefPtr<nsDOMDeviceStorage> ds = GetStorage(aPath, storagePath);
4172     if (!ds) {
4173       nsRefPtr<DOMRequest> request = new DOMRequest(win);
4174       r = new PostErrorEvent(request, POST_ERROR_EVENT_UNKNOWN);
4175       rv = NS_DispatchToCurrentThread(r);
4176       if (NS_FAILED(rv)) {
4177         return rv;
4178       }
4179       request.forget(aRequest);
4180       return NS_OK;
4181     }
4182     return ds->CreateFileDescriptor(storagePath, aDSFileDescriptor, aRequest);
4183   }
4184
4185   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4186
4187   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4188                                                           mStorageName,
4189                                                           aPath);
4190   if (!dsf->IsSafePath()) {
4191     r = new PostErrorEvent(request, POST_ERROR_EVENT_PERMISSION_DENIED);
4192   } else if (!typeChecker->Check(mStorageType, dsf->mFile)) {
4193     r = new PostErrorEvent(request, POST_ERROR_EVENT_ILLEGAL_TYPE);
4194   } else {
4195     r = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_CREATEFD,
4196                                  win, mPrincipal, dsf, request,
4197                                  aDSFileDescriptor);
4198   }
4199
4200   rv = NS_DispatchToCurrentThread(r);
4201   if (NS_FAILED(rv)) {
4202     return rv;
4203   }
4204   request.forget(aRequest);
4205   return NS_OK;
4206 }
4207
4208 bool
4209 nsDOMDeviceStorage::Default()
4210 {
4211   nsString defaultStorageName;
4212   GetDefaultStorageName(mStorageType, defaultStorageName);
4213   return mStorageName.Equals(defaultStorageName);
4214 }
4215
4216 bool
4217 nsDOMDeviceStorage::CanBeFormatted()
4218 {
4219   // Currently, any volume which can be shared can also be formatted.
4220   return mIsShareable;
4221 }
4222
4223 bool
4224 nsDOMDeviceStorage::CanBeMounted()
4225 {
4226   // Currently, any volume which can be shared can also be mounted/unmounted.
4227   return mIsShareable;
4228 }
4229
4230 bool
4231 nsDOMDeviceStorage::CanBeShared()
4232 {
4233   return mIsShareable;
4234 }
4235
4236 bool
4237 nsDOMDeviceStorage::IsRemovable()
4238 {
4239   return mIsRemovable;
4240 }
4241
4242 already_AddRefed<Promise>
4243 nsDOMDeviceStorage::GetRoot(ErrorResult& aRv)
4244 {
4245   if (!mFileSystem) {
4246     mFileSystem = new DeviceStorageFileSystem(mStorageType, mStorageName);
4247     mFileSystem->Init(this);
4248   }
4249   return mozilla::dom::Directory::GetRoot(mFileSystem, aRv);
4250 }
4251
4252 NS_IMETHODIMP
4253 nsDOMDeviceStorage::GetDefault(bool* aDefault)
4254 {
4255   *aDefault = Default();
4256   return NS_OK;
4257 }
4258
4259 NS_IMETHODIMP
4260 nsDOMDeviceStorage::GetStorageName(nsAString& aStorageName)
4261 {
4262   aStorageName = mStorageName;
4263   return NS_OK;
4264 }
4265
4266 already_AddRefed<DOMCursor>
4267 nsDOMDeviceStorage::Enumerate(const nsAString& aPath,
4268                               const EnumerationParameters& aOptions,
4269                               ErrorResult& aRv)
4270 {
4271   return EnumerateInternal(aPath, aOptions, false, aRv);
4272 }
4273
4274 already_AddRefed<DOMCursor>
4275 nsDOMDeviceStorage::EnumerateEditable(const nsAString& aPath,
4276                                       const EnumerationParameters& aOptions,
4277                                       ErrorResult& aRv)
4278 {
4279   return EnumerateInternal(aPath, aOptions, true, aRv);
4280 }
4281
4282
4283 already_AddRefed<DOMCursor>
4284 nsDOMDeviceStorage::EnumerateInternal(const nsAString& aPath,
4285                                       const EnumerationParameters& aOptions,
4286                                       bool aEditable, ErrorResult& aRv)
4287 {
4288   MOZ_ASSERT(NS_IsMainThread());
4289
4290   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4291   if (!win) {
4292     aRv.Throw(NS_ERROR_UNEXPECTED);
4293     return nullptr;
4294   }
4295
4296   PRTime since = 0;
4297   if (aOptions.mSince.WasPassed() && !aOptions.mSince.Value().IsUndefined()) {
4298     since = PRTime(aOptions.mSince.Value().TimeStamp());
4299   }
4300
4301   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4302                                                           mStorageName,
4303                                                           aPath,
4304                                                           EmptyString());
4305   dsf->SetEditable(aEditable);
4306
4307   nsRefPtr<nsDOMDeviceStorageCursor> cursor
4308     = new nsDOMDeviceStorageCursor(win, mPrincipal, dsf, since);
4309   nsRefPtr<DeviceStorageCursorRequest> r
4310     = new DeviceStorageCursorRequest(cursor);
4311
4312   if (mozilla::Preferences::GetBool("device.storage.prompt.testing", false)) {
4313     r->Allow(JS::UndefinedHandleValue);
4314     return cursor.forget();
4315   }
4316
4317   nsContentPermissionUtils::AskPermission(r, win);
4318
4319   return cursor.forget();
4320 }
4321
4322 #ifdef MOZ_WIDGET_GONK
4323 void
4324 nsDOMDeviceStorage::DispatchStatusChangeEvent(nsAString& aStatus)
4325 {
4326   if (aStatus == mLastStatus) {
4327     // We've already sent this status, don't bother sending it again.
4328     return;
4329   }
4330   mLastStatus = aStatus;
4331
4332   DeviceStorageChangeEventInit init;
4333   init.mBubbles = true;
4334   init.mCancelable = false;
4335   init.mPath = mStorageName;
4336   init.mReason = aStatus;
4337
4338   nsRefPtr<DeviceStorageChangeEvent> event =
4339     DeviceStorageChangeEvent::Constructor(this, NS_LITERAL_STRING("change"),
4340                                           init);
4341   event->SetTrusted(true);
4342
4343   bool ignore;
4344   DispatchEvent(event, &ignore);
4345 }
4346
4347 void
4348 nsDOMDeviceStorage::DispatchStorageStatusChangeEvent(nsAString& aStorageStatus)
4349 {
4350   if (aStorageStatus == mLastStorageStatus) {
4351      // We've already sent this status, don't bother sending it again.
4352     return;
4353   }
4354   mLastStorageStatus = aStorageStatus;
4355
4356   DeviceStorageChangeEventInit init;
4357   init.mBubbles = true;
4358   init.mCancelable = false;
4359   init.mPath = mStorageName;
4360   init.mReason = aStorageStatus;
4361
4362   nsRefPtr<DeviceStorageChangeEvent> event =
4363     DeviceStorageChangeEvent::Constructor(this, NS_LITERAL_STRING("storage-state-change"),
4364                                           init);
4365   event->SetTrusted(true);
4366
4367   bool ignore;
4368   DispatchEvent(event, &ignore);
4369 }
4370 #endif
4371
4372 NS_IMETHODIMP
4373 nsDOMDeviceStorage::Observe(nsISupports *aSubject,
4374                             const char *aTopic,
4375                             const char16_t *aData)
4376 {
4377   MOZ_ASSERT(NS_IsMainThread());
4378
4379   if (!strcmp(aTopic, kFileWatcherUpdate)) {
4380
4381     DeviceStorageFile* file = static_cast<DeviceStorageFile*>(aSubject);
4382     Notify(NS_ConvertUTF16toUTF8(aData).get(), file);
4383     return NS_OK;
4384   }
4385   if (!strcmp(aTopic, "disk-space-watcher")) {
4386     // 'disk-space-watcher' notifications are sent when there is a modification
4387     // of a file in a specific location while a low device storage situation
4388     // exists or after recovery of a low storage situation. For Firefox OS,
4389     // these notifications are specific for apps storage.
4390     nsRefPtr<DeviceStorageFile> file =
4391       new DeviceStorageFile(mStorageType, mStorageName);
4392     if (!NS_strcmp(aData, MOZ_UTF16("full"))) {
4393       Notify("low-disk-space", file);
4394     } else if (!NS_strcmp(aData, MOZ_UTF16("free"))) {
4395       Notify("available-disk-space", file);
4396     }
4397     return NS_OK;
4398   }
4399
4400 #ifdef MOZ_WIDGET_GONK
4401   else if (!strcmp(aTopic, NS_VOLUME_STATE_CHANGED)) {
4402     // We invalidate the used space cache for the volume that actually changed
4403     // state.
4404     nsCOMPtr<nsIVolume> vol = do_QueryInterface(aSubject);
4405     if (!vol) {
4406       return NS_OK;
4407     }
4408     nsString volName;
4409     vol->GetName(volName);
4410
4411     DeviceStorageUsedSpaceCache* usedSpaceCache
4412       = DeviceStorageUsedSpaceCache::CreateOrGet();
4413     MOZ_ASSERT(usedSpaceCache);
4414     usedSpaceCache->Invalidate(volName);
4415
4416     if (!volName.Equals(mStorageName)) {
4417       // Not our volume - we can ignore.
4418       return NS_OK;
4419     }
4420
4421     nsRefPtr<DeviceStorageFile> dsf(new DeviceStorageFile(mStorageType, mStorageName));
4422     nsString status, storageStatus;
4423
4424     // Get Status (one of "available, unavailable, shared")
4425     dsf->GetStatus(status);
4426     DispatchStatusChangeEvent(status);
4427
4428     // Get real volume status (defined in dom/system/gonk/nsIVolume.idl)
4429     dsf->GetStorageStatus(storageStatus);
4430     DispatchStorageStatusChangeEvent(storageStatus);
4431     return NS_OK;
4432   }
4433 #endif
4434   return NS_OK;
4435 }
4436
4437 nsresult
4438 nsDOMDeviceStorage::Notify(const char* aReason, DeviceStorageFile* aFile)
4439 {
4440   if (!mAllowedToWatchFile) {
4441     return NS_OK;
4442   }
4443
4444   if (!mStorageType.Equals(aFile->mStorageType) ||
4445       !mStorageName.Equals(aFile->mStorageName)) {
4446     // Ignore this
4447     return NS_OK;
4448   }
4449
4450   DeviceStorageChangeEventInit init;
4451   init.mBubbles = true;
4452   init.mCancelable = false;
4453   aFile->GetFullPath(init.mPath);
4454   init.mReason.AssignWithConversion(aReason);
4455
4456   nsRefPtr<DeviceStorageChangeEvent> event =
4457     DeviceStorageChangeEvent::Constructor(this, NS_LITERAL_STRING("change"),
4458                                           init);
4459   event->SetTrusted(true);
4460
4461   bool ignore;
4462   DispatchEvent(event, &ignore);
4463   return NS_OK;
4464 }
4465
4466 NS_IMETHODIMP
4467 nsDOMDeviceStorage::AddEventListener(const nsAString & aType,
4468                                      nsIDOMEventListener *aListener,
4469                                      bool aUseCapture,
4470                                      bool aWantsUntrusted,
4471                                      uint8_t aArgc)
4472 {
4473   MOZ_ASSERT(NS_IsMainThread());
4474
4475   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4476   if (!win) {
4477     return NS_ERROR_UNEXPECTED;
4478   }
4479
4480   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4481   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4482                                                           mStorageName);
4483   nsCOMPtr<nsIRunnable> r
4484     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_WATCH,
4485                                win, mPrincipal, dsf, request, this);
4486   nsresult rv = NS_DispatchToCurrentThread(r);
4487   if (NS_WARN_IF(NS_FAILED(rv))) {
4488     return rv;
4489   }
4490
4491   return DOMEventTargetHelper::AddEventListener(aType, aListener, aUseCapture,
4492                                                 aWantsUntrusted, aArgc);
4493 }
4494
4495 void
4496 nsDOMDeviceStorage::AddEventListener(const nsAString & aType,
4497                                      EventListener *aListener,
4498                                      bool aUseCapture,
4499                                      const Nullable<bool>& aWantsUntrusted,
4500                                      ErrorResult& aRv)
4501 {
4502   MOZ_ASSERT(NS_IsMainThread());
4503
4504   nsCOMPtr<nsPIDOMWindow> win = GetOwner();
4505   if (!win) {
4506     aRv.Throw(NS_ERROR_UNEXPECTED);
4507     return;
4508   }
4509
4510   nsRefPtr<DOMRequest> request = new DOMRequest(win);
4511   nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
4512                                                           mStorageName);
4513   nsCOMPtr<nsIRunnable> r
4514     = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_WATCH,
4515                                win, mPrincipal, dsf, request, this);
4516   nsresult rv = NS_DispatchToCurrentThread(r);
4517   if (NS_WARN_IF(NS_FAILED(rv))) {
4518     return;
4519   }
4520   DOMEventTargetHelper::AddEventListener(aType, aListener, aUseCapture,
4521                                          aWantsUntrusted, aRv);
4522 }
4523
4524 NS_IMETHODIMP
4525 nsDOMDeviceStorage::AddSystemEventListener(const nsAString & aType,
4526                                            nsIDOMEventListener *aListener,
4527                                            bool aUseCapture,
4528                                            bool aWantsUntrusted,
4529                                            uint8_t aArgc)
4530 {
4531   if (!mIsWatchingFile) {
4532     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
4533     obs->AddObserver(this, kFileWatcherUpdate, false);
4534     mIsWatchingFile = true;
4535   }
4536
4537   return nsDOMDeviceStorage::AddEventListener(aType, aListener, aUseCapture,
4538                                               aWantsUntrusted, aArgc);
4539 }
4540
4541 NS_IMETHODIMP
4542 nsDOMDeviceStorage::RemoveEventListener(const nsAString & aType,
4543                                         nsIDOMEventListener *aListener,
4544                                         bool aUseCapture)
4545 {
4546   DOMEventTargetHelper::RemoveEventListener(aType, aListener, false);
4547
4548   if (mIsWatchingFile && !HasListenersFor(nsGkAtoms::onchange)) {
4549     mIsWatchingFile = false;
4550     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
4551     obs->RemoveObserver(this, kFileWatcherUpdate);
4552   }
4553   return NS_OK;
4554 }
4555
4556 void
4557 nsDOMDeviceStorage::RemoveEventListener(const nsAString& aType,
4558                                         EventListener* aListener,
4559                                         bool aCapture,
4560                                         ErrorResult& aRv)
4561 {
4562   DOMEventTargetHelper::RemoveEventListener(aType, aListener, aCapture, aRv);
4563
4564   if (mIsWatchingFile && !HasListenersFor(nsGkAtoms::onchange)) {
4565     mIsWatchingFile = false;
4566     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
4567     obs->RemoveObserver(this, kFileWatcherUpdate);
4568   }
4569 }
4570
4571 NS_IMETHODIMP
4572 nsDOMDeviceStorage::RemoveSystemEventListener(const nsAString & aType,
4573                                               nsIDOMEventListener *aListener,
4574                                               bool aUseCapture)
4575 {
4576   return nsDOMDeviceStorage::RemoveEventListener(aType, aListener, aUseCapture);
4577 }
4578
4579 NS_IMETHODIMP
4580 nsDOMDeviceStorage::DispatchEvent(nsIDOMEvent *aEvt,
4581                                   bool *aRetval)
4582 {
4583   return DOMEventTargetHelper::DispatchEvent(aEvt, aRetval);
4584 }
4585
4586 EventTarget*
4587 nsDOMDeviceStorage::GetTargetForDOMEvent()
4588 {
4589   return DOMEventTargetHelper::GetTargetForDOMEvent();
4590 }
4591
4592 EventTarget *
4593 nsDOMDeviceStorage::GetTargetForEventTargetChain()
4594 {
4595   return DOMEventTargetHelper::GetTargetForEventTargetChain();
4596 }
4597
4598 nsresult
4599 nsDOMDeviceStorage::PreHandleEvent(EventChainPreVisitor& aVisitor)
4600 {
4601   return DOMEventTargetHelper::PreHandleEvent(aVisitor);
4602 }
4603
4604 nsresult
4605 nsDOMDeviceStorage::WillHandleEvent(EventChainPostVisitor& aVisitor)
4606 {
4607   return DOMEventTargetHelper::WillHandleEvent(aVisitor);
4608 }
4609
4610 nsresult
4611 nsDOMDeviceStorage::PostHandleEvent(EventChainPostVisitor& aVisitor)
4612 {
4613   return DOMEventTargetHelper::PostHandleEvent(aVisitor);
4614 }
4615
4616 nsresult
4617 nsDOMDeviceStorage::DispatchDOMEvent(WidgetEvent* aEvent,
4618                                      nsIDOMEvent* aDOMEvent,
4619                                      nsPresContext* aPresContext,
4620                                      nsEventStatus* aEventStatus)
4621 {
4622   return DOMEventTargetHelper::DispatchDOMEvent(aEvent,
4623                                                 aDOMEvent,
4624                                                 aPresContext,
4625                                                 aEventStatus);
4626 }
4627
4628 EventListenerManager*
4629 nsDOMDeviceStorage::GetOrCreateListenerManager()
4630 {
4631   return DOMEventTargetHelper::GetOrCreateListenerManager();
4632 }
4633
4634 EventListenerManager*
4635 nsDOMDeviceStorage::GetExistingListenerManager() const
4636 {
4637   return DOMEventTargetHelper::GetExistingListenerManager();
4638 }
4639
4640 nsIScriptContext *
4641 nsDOMDeviceStorage::GetContextForEventHandlers(nsresult *aRv)
4642 {
4643   return DOMEventTargetHelper::GetContextForEventHandlers(aRv);
4644 }
4645
4646 JSContext *
4647 nsDOMDeviceStorage::GetJSContextForEventHandlers()
4648 {
4649   return DOMEventTargetHelper::GetJSContextForEventHandlers();
4650 }
4651
4652 NS_IMPL_EVENT_HANDLER(nsDOMDeviceStorage, change)