The Tor Browser: comparison dom/devicestorage/nsDeviceStorage.cpp

--1:000000000000
+:292391600de3
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this file,
+* You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsDeviceStorage.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/DeviceStorageBinding.h"
+#include "mozilla/dom/DeviceStorageFileSystem.h"
+#include "mozilla/dom/devicestorage/PDeviceStorageRequestChild.h"
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/FileSystemUtils.h"
+#include "mozilla/dom/ipc/Blob.h"
+#include "mozilla/dom/PBrowserChild.h"
+#include "mozilla/dom/PContentPermissionRequestChild.h"
+#include "mozilla/dom/PermissionMessageUtils.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/LazyIdleThread.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Scoped.h"
+#include "mozilla/Services.h"
+#include "nsAutoPtr.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIFile.h"
+#include "nsIDirectoryEnumerator.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsIDOMFile.h"
+#include "nsDOMBlobBuilder.h"
+#include "nsNetUtil.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIPrincipal.h"
+#include "nsJSUtils.h"
+#include "nsContentUtils.h"
+#include "nsCxPusher.h"
+#include "nsXULAppAPI.h"
+#include "TabChild.h"
+#include "DeviceStorageFileDescriptor.h"
+#include "DeviceStorageRequestChild.h"
+#include "nsIDOMDeviceStorageChangeEvent.h"
+#include "nsCRT.h"
+#include "nsIObserverService.h"
+#include "GeneratedEvents.h"
+#include "nsIMIMEService.h"
+#include "nsCExternalHandlerService.h"
+#include "nsIPermissionManager.h"
+#include "nsIStringBundle.h"
+#include "nsIDocument.h"
+#include "nsPrintfCString.h"
+#include <algorithm>
+#include "private/pprio.h"
+#include "nsContentPermissionHelper.h"
+#include "mozilla/dom/DeviceStorageBinding.h"
+// Microsoft's API Name hackery sucks
+#undef CreateEvent
+#ifdef MOZ_WIDGET_GONK
+#include "nsIVolume.h"
+#include "nsIVolumeService.h"
+#endif
+#define DEVICESTORAGE_PROPERTIES \
+"chrome://global/content/devicestorage.properties"
+#define DEFAULT_THREAD_TIMEOUT_MS 30000
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::dom::devicestorage;
+using namespace mozilla::ipc;
+#include "nsDirectoryServiceDefs.h"
+namespace mozilla {
+MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE(ScopedPRFileDesc, PRFileDesc, PR_Close);
+}
+StaticAutoPtr<DeviceStorageUsedSpaceCache>
+DeviceStorageUsedSpaceCache::sDeviceStorageUsedSpaceCache;
+DeviceStorageUsedSpaceCache::DeviceStorageUsedSpaceCache()
+{
+MOZ_ASSERT(NS_IsMainThread());
+mIOThread = new LazyIdleThread(
+DEFAULT_THREAD_TIMEOUT_MS,
+NS_LITERAL_CSTRING("DeviceStorageUsedSpaceCache I/O"));
+}
+DeviceStorageUsedSpaceCache::~DeviceStorageUsedSpaceCache()
+{
+}
+DeviceStorageUsedSpaceCache*
+DeviceStorageUsedSpaceCache::CreateOrGet()
+{
+if (sDeviceStorageUsedSpaceCache) {
+return sDeviceStorageUsedSpaceCache;
+}
+MOZ_ASSERT(NS_IsMainThread());
+sDeviceStorageUsedSpaceCache = new DeviceStorageUsedSpaceCache();
+ClearOnShutdown(&sDeviceStorageUsedSpaceCache);
+return sDeviceStorageUsedSpaceCache;
+}
+already_AddRefed<DeviceStorageUsedSpaceCache::CacheEntry>
+DeviceStorageUsedSpaceCache::GetCacheEntry(const nsAString& aStorageName)
+{
+nsTArray<nsRefPtr<CacheEntry>>::size_type numEntries = mCacheEntries.Length();
+nsTArray<nsRefPtr<CacheEntry>>::index_type i;
+for (i = 0; i < numEntries; i++) {
+nsRefPtr<CacheEntry>& cacheEntry = mCacheEntries[i];
+if (cacheEntry->mStorageName.Equals(aStorageName)) {
+nsRefPtr<CacheEntry> addRefedCacheEntry = cacheEntry;
+return addRefedCacheEntry.forget();
+}
+}
+return nullptr;
+}
+static int64_t
+GetFreeBytes(const nsAString& aStorageName)
+{
+// This function makes the assumption that the various types
+// are all stored on the same filesystem. So we use pictures.
+DeviceStorageFile dsf(NS_LITERAL_STRING(DEVICESTORAGE_PICTURES),
+aStorageName);
+int64_t freeBytes = 0;
+dsf.GetDiskFreeSpace(&freeBytes);
+return freeBytes;
+}
+nsresult
+DeviceStorageUsedSpaceCache::AccumUsedSizes(const nsAString& aStorageName,
+uint64_t* aPicturesSoFar,
+uint64_t* aVideosSoFar,
+uint64_t* aMusicSoFar,
+uint64_t* aTotalSoFar)
+{
+nsRefPtr<CacheEntry> cacheEntry = GetCacheEntry(aStorageName);
+if (!cacheEntry || cacheEntry->mDirty) {
+return NS_ERROR_NOT_AVAILABLE;
+}
+int64_t freeBytes = GetFreeBytes(cacheEntry->mStorageName);
+if (freeBytes != cacheEntry->mFreeBytes) {
+// Free space changed, so our cached results are no longer valid.
+return NS_ERROR_NOT_AVAILABLE;
+}
+*aPicturesSoFar += cacheEntry->mPicturesUsedSize;
+*aVideosSoFar += cacheEntry->mVideosUsedSize;
+*aMusicSoFar += cacheEntry->mMusicUsedSize;
+*aTotalSoFar += cacheEntry->mTotalUsedSize;
+return NS_OK;
+}
+void
+DeviceStorageUsedSpaceCache::SetUsedSizes(const nsAString& aStorageName,
+uint64_t aPictureSize,
+uint64_t aVideosSize,
+uint64_t aMusicSize,
+uint64_t aTotalUsedSize)
+{
+nsRefPtr<CacheEntry> cacheEntry = GetCacheEntry(aStorageName);
+if (!cacheEntry) {
+cacheEntry = new CacheEntry;
+cacheEntry->mStorageName = aStorageName;
+mCacheEntries.AppendElement(cacheEntry);
+}
+cacheEntry->mFreeBytes = GetFreeBytes(cacheEntry->mStorageName);
+cacheEntry->mPicturesUsedSize = aPictureSize;
+cacheEntry->mVideosUsedSize = aVideosSize;
+cacheEntry->mMusicUsedSize = aMusicSize;
+cacheEntry->mTotalUsedSize = aTotalUsedSize;
+cacheEntry->mDirty = false;
+}
+class GlobalDirs
+{
+public:
+NS_INLINE_DECL_REFCOUNTING(GlobalDirs)
+#if !defined(MOZ_WIDGET_GONK)
+nsCOMPtr<nsIFile> pictures;
+nsCOMPtr<nsIFile> videos;
+nsCOMPtr<nsIFile> music;
+nsCOMPtr<nsIFile> sdcard;
+#endif
+nsCOMPtr<nsIFile> apps;
+nsCOMPtr<nsIFile> crashes;
+nsCOMPtr<nsIFile> overrideRootDir;
+};
+static StaticRefPtr<GlobalDirs> sDirs;
+StaticAutoPtr<DeviceStorageTypeChecker>
+DeviceStorageTypeChecker::sDeviceStorageTypeChecker;
+DeviceStorageTypeChecker::DeviceStorageTypeChecker()
+{
+}
+DeviceStorageTypeChecker::~DeviceStorageTypeChecker()
+{
+}
+DeviceStorageTypeChecker*
+DeviceStorageTypeChecker::CreateOrGet()
+{
+if (sDeviceStorageTypeChecker) {
+return sDeviceStorageTypeChecker;
+}
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsIStringBundleService> stringService
+= mozilla::services::GetStringBundleService();
+if (!stringService) {
+return nullptr;
+}
+nsCOMPtr<nsIStringBundle> filterBundle;
+if (NS_FAILED(stringService->CreateBundle(DEVICESTORAGE_PROPERTIES,
+getter_AddRefs(filterBundle)))) {
+return nullptr;
+}
+DeviceStorageTypeChecker* result = new DeviceStorageTypeChecker();
+result->InitFromBundle(filterBundle);
+sDeviceStorageTypeChecker = result;
+ClearOnShutdown(&sDeviceStorageTypeChecker);
+return result;
+}
+void
+DeviceStorageTypeChecker::InitFromBundle(nsIStringBundle* aBundle)
+{
+aBundle->GetStringFromName(
+NS_ConvertASCIItoUTF16(DEVICESTORAGE_PICTURES).get(),
+getter_Copies(mPicturesExtensions));
+aBundle->GetStringFromName(
+NS_ConvertASCIItoUTF16(DEVICESTORAGE_MUSIC).get(),
+getter_Copies(mMusicExtensions));
+aBundle->GetStringFromName(
+NS_ConvertASCIItoUTF16(DEVICESTORAGE_VIDEOS).get(),
+getter_Copies(mVideosExtensions));
+}
+bool
+DeviceStorageTypeChecker::Check(const nsAString& aType, nsIDOMBlob* aBlob)
+{
+MOZ_ASSERT(aBlob);
+nsString mimeType;
+if (NS_FAILED(aBlob->GetType(mimeType))) {
+return false;
+}
+if (aType.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
+return StringBeginsWith(mimeType, NS_LITERAL_STRING("image/"));
+}
+if (aType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
+return StringBeginsWith(mimeType, NS_LITERAL_STRING("video/"));
+}
+if (aType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
+return StringBeginsWith(mimeType, NS_LITERAL_STRING("audio/"));
+}
+if (aType.EqualsLiteral(DEVICESTORAGE_APPS) ||
+aType.EqualsLiteral(DEVICESTORAGE_SDCARD) ||
+aType.EqualsLiteral(DEVICESTORAGE_CRASHES)) {
+// Apps, crashes and sdcard have no restriction on mime types
+return true;
+}
+return false;
+}
+bool
+DeviceStorageTypeChecker::Check(const nsAString& aType, nsIFile* aFile)
+{
+MOZ_ASSERT(aFile);
+if (aType.EqualsLiteral(DEVICESTORAGE_APPS) ||
+aType.EqualsLiteral(DEVICESTORAGE_SDCARD) ||
+aType.EqualsLiteral(DEVICESTORAGE_CRASHES)) {
+// Apps, crashes and sdcard have no restrictions on what file extensions used.
+return true;
+}
+nsString path;
+aFile->GetPath(path);
+int32_t dotIdx = path.RFindChar(char16_t('.'));
+if (dotIdx == kNotFound) {
+return false;
+}
+nsAutoString extensionMatch;
+extensionMatch.AssignLiteral("*");
+extensionMatch.Append(Substring(path, dotIdx));
+extensionMatch.AppendLiteral(";");
+if (aType.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
+return CaseInsensitiveFindInReadable(extensionMatch, mPicturesExtensions);
+}
+if (aType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
+return CaseInsensitiveFindInReadable(extensionMatch, mVideosExtensions);
+}
+if (aType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
+return CaseInsensitiveFindInReadable(extensionMatch, mMusicExtensions);
+}
+return false;
+}
+void
+DeviceStorageTypeChecker::GetTypeFromFile(nsIFile* aFile, nsAString& aType)
+{
+MOZ_ASSERT(aFile);
+nsString path;
+aFile->GetPath(path);
+GetTypeFromFileName(path, aType);
+}
+void
+DeviceStorageTypeChecker::GetTypeFromFileName(const nsAString& aFileName,
+nsAString& aType)
+{
+aType.AssignLiteral(DEVICESTORAGE_SDCARD);
+nsString fileName(aFileName);
+int32_t dotIdx = fileName.RFindChar(char16_t('.'));
+if (dotIdx == kNotFound) {
+return;
+}
+nsAutoString extensionMatch;
+extensionMatch.AssignLiteral("*");
+extensionMatch.Append(Substring(aFileName, dotIdx));
+extensionMatch.AppendLiteral(";");
+if (CaseInsensitiveFindInReadable(extensionMatch, mPicturesExtensions)) {
+aType.AssignLiteral(DEVICESTORAGE_PICTURES);
+}
+else if (CaseInsensitiveFindInReadable(extensionMatch, mVideosExtensions)) {
+aType.AssignLiteral(DEVICESTORAGE_VIDEOS);
+}
+else if (CaseInsensitiveFindInReadable(extensionMatch, mMusicExtensions)) {
+aType.AssignLiteral(DEVICESTORAGE_MUSIC);
+}
+}
+nsresult
+DeviceStorageTypeChecker::GetPermissionForType(const nsAString& aType,
+nsACString& aPermissionResult)
+{
+if (!aType.EqualsLiteral(DEVICESTORAGE_PICTURES) &&
+!aType.EqualsLiteral(DEVICESTORAGE_VIDEOS) &&
+!aType.EqualsLiteral(DEVICESTORAGE_MUSIC) &&
+!aType.EqualsLiteral(DEVICESTORAGE_APPS) &&
+!aType.EqualsLiteral(DEVICESTORAGE_SDCARD) &&
+!aType.EqualsLiteral(DEVICESTORAGE_CRASHES)) {
+// unknown type
+return NS_ERROR_FAILURE;
+}
+aPermissionResult.AssignLiteral("device-storage:");
+aPermissionResult.Append(NS_ConvertUTF16toUTF8(aType));
+return NS_OK;
+}
+nsresult
+DeviceStorageTypeChecker::GetAccessForRequest(
+const DeviceStorageRequestType aRequestType, nsACString& aAccessResult)
+{
+switch(aRequestType) {
+case DEVICE_STORAGE_REQUEST_READ:
+case DEVICE_STORAGE_REQUEST_WATCH:
+case DEVICE_STORAGE_REQUEST_FREE_SPACE:
+case DEVICE_STORAGE_REQUEST_USED_SPACE:
+case DEVICE_STORAGE_REQUEST_AVAILABLE:
+case DEVICE_STORAGE_REQUEST_STATUS:
+aAccessResult.AssignLiteral("read");
+break;
+case DEVICE_STORAGE_REQUEST_WRITE:
+case DEVICE_STORAGE_REQUEST_DELETE:
+case DEVICE_STORAGE_REQUEST_FORMAT:
+case DEVICE_STORAGE_REQUEST_MOUNT:
+case DEVICE_STORAGE_REQUEST_UNMOUNT:
+aAccessResult.AssignLiteral("write");
+break;
+case DEVICE_STORAGE_REQUEST_CREATE:
+case DEVICE_STORAGE_REQUEST_CREATEFD:
+aAccessResult.AssignLiteral("create");
+break;
+default:
+aAccessResult.AssignLiteral("undefined");
+}
+return NS_OK;
+}
+//static
+bool
+DeviceStorageTypeChecker::IsVolumeBased(const nsAString& aType)
+{
+#ifdef MOZ_WIDGET_GONK
+// The apps and crashes aren't stored in the same place as the media, so
+// we only ever return a single apps object, and not an array
+// with one per volume (as is the case for the remaining
+// storage types).
+return !aType.EqualsLiteral(DEVICESTORAGE_APPS) &&
+!aType.EqualsLiteral(DEVICESTORAGE_CRASHES);
+#else
+return false;
+#endif
+}
+NS_IMPL_ISUPPORTS(FileUpdateDispatcher, nsIObserver)
+mozilla::StaticRefPtr<FileUpdateDispatcher> FileUpdateDispatcher::sSingleton;
+FileUpdateDispatcher*
+FileUpdateDispatcher::GetSingleton()
+{
+if (sSingleton) {
+return sSingleton;
+}
+sSingleton = new FileUpdateDispatcher();
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->AddObserver(sSingleton, "file-watcher-notify", false);
+ClearOnShutdown(&sSingleton);
+return sSingleton;
+}
+NS_IMETHODIMP
+FileUpdateDispatcher::Observe(nsISupports *aSubject,
+const char *aTopic,
+const char16_t *aData)
+{
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+DeviceStorageFile* file = static_cast<DeviceStorageFile*>(aSubject);
+if (!file || !file->mFile) {
+NS_WARNING("Device storage file looks invalid!");
+return NS_OK;
+}
+ContentChild::GetSingleton()
+->SendFilePathUpdateNotify(file->mStorageType,
+file->mStorageName,
+file->mPath,
+NS_ConvertUTF16toUTF8(aData));
+} else {
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->NotifyObservers(aSubject, "file-watcher-update", aData);
+}
+return NS_OK;
+}
+class IOEventComplete : public nsRunnable
+{
+public:
+IOEventComplete(DeviceStorageFile *aFile, const char *aType)
+: mFile(aFile)
+, mType(aType)
+{
+}
+~IOEventComplete() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsString data;
+CopyASCIItoUTF16(mType, data);
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->NotifyObservers(mFile, "file-watcher-notify", data.get());
+DeviceStorageUsedSpaceCache* usedSpaceCache
+= DeviceStorageUsedSpaceCache::CreateOrGet();
+MOZ_ASSERT(usedSpaceCache);
+usedSpaceCache->Invalidate(mFile->mStorageName);
+return NS_OK;
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsCString mType;
+};
+DeviceStorageFile::DeviceStorageFile(const nsAString& aStorageType,
+const nsAString& aStorageName,
+const nsAString& aRootDir,
+const nsAString& aPath)
+: mStorageType(aStorageType)
+, mStorageName(aStorageName)
+, mRootDir(aRootDir)
+, mPath(aPath)
+, mEditable(false)
+, mLength(UINT64_MAX)
+, mLastModifiedDate(UINT64_MAX)
+{
+Init();
+AppendRelativePath(mRootDir);
+if (!mPath.EqualsLiteral("")) {
+AppendRelativePath(mPath);
+}
+NormalizeFilePath();
+}
+DeviceStorageFile::DeviceStorageFile(const nsAString& aStorageType,
+const nsAString& aStorageName,
+const nsAString& aPath)
+: mStorageType(aStorageType)
+, mStorageName(aStorageName)
+, mPath(aPath)
+, mEditable(false)
+, mLength(UINT64_MAX)
+, mLastModifiedDate(UINT64_MAX)
+{
+Init();
+AppendRelativePath(aPath);
+NormalizeFilePath();
+}
+DeviceStorageFile::DeviceStorageFile(const nsAString& aStorageType,
+const nsAString& aStorageName)
+: mStorageType(aStorageType)
+, mStorageName(aStorageName)
+, mEditable(false)
+, mLength(UINT64_MAX)
+, mLastModifiedDate(UINT64_MAX)
+{
+Init();
+}
+void
+DeviceStorageFile::Dump(const char* label)
+{
+nsString path;
+if (mFile) {
+mFile->GetPath(path);
+} else {
+path = NS_LITERAL_STRING("(null)");
+}
+const char* ptStr;
+if (XRE_GetProcessType() == GeckoProcessType_Default) {
+ptStr = "parent";
+} else {
+ptStr = "child";
+}
+printf_stderr("DSF (%s) %s: mStorageType '%s' mStorageName '%s' "
+"mRootDir '%s' mPath '%s' mFile->GetPath '%s'\n",
+ptStr, label,
+NS_LossyConvertUTF16toASCII(mStorageType).get(),
+NS_LossyConvertUTF16toASCII(mStorageName).get(),
+NS_LossyConvertUTF16toASCII(mRootDir).get(),
+NS_LossyConvertUTF16toASCII(mPath).get(),
+NS_LossyConvertUTF16toASCII(path).get());
+}
+void
+DeviceStorageFile::Init()
+{
+DeviceStorageFile::GetRootDirectoryForType(mStorageType,
+mStorageName,
+getter_AddRefs(mFile));
+DebugOnly<DeviceStorageTypeChecker*> typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+MOZ_ASSERT(typeChecker);
+}
+// The OverrideRootDir is needed to facilitate testing of the
+// device.storage.overrideRootDir preference. The preference is normally
+// only read once during initialization, but since the test environment has
+// no convenient way to restart, we use a pref watcher instead.
+class OverrideRootDir MOZ_FINAL : public nsIObserver
+{
+public:
+NS_DECL_ISUPPORTS
+NS_DECL_NSIOBSERVER
+static OverrideRootDir* GetSingleton();
+~OverrideRootDir();
+void Init();
+private:
+static mozilla::StaticRefPtr<OverrideRootDir> sSingleton;
+};
+NS_IMPL_ISUPPORTS(OverrideRootDir, nsIObserver)
+mozilla::StaticRefPtr<OverrideRootDir>
+OverrideRootDir::sSingleton;
+OverrideRootDir*
+OverrideRootDir::GetSingleton()
+{
+if (sSingleton) {
+return sSingleton;
+}
+// Preference changes are automatically forwarded from parent to child
+// in ContentParent::Observe, so we'll see the change in both the parent
+// and the child process.
+sSingleton = new OverrideRootDir();
+Preferences::AddStrongObserver(sSingleton, "device.storage.overrideRootDir");
+ClearOnShutdown(&sSingleton);
+return sSingleton;
+}
+OverrideRootDir::~OverrideRootDir()
+{
+Preferences::RemoveObserver(this, "device.storage.overrideRootDir");
+}
+NS_IMETHODIMP
+OverrideRootDir::Observe(nsISupports *aSubject,
+const char *aTopic,
+const char16_t *aData)
+{
+MOZ_ASSERT(NS_IsMainThread());
+if (sSingleton) {
+sSingleton->Init();
+}
+return NS_OK;
+}
+void
+OverrideRootDir::Init()
+{
+MOZ_ASSERT(NS_IsMainThread());
+if (!sDirs) {
+return;
+}
+if (mozilla::Preferences::GetBool("device.storage.testing", false)) {
+nsCOMPtr<nsIProperties> dirService
+= do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
+MOZ_ASSERT(dirService);
+dirService->Get(NS_OS_TEMP_DIR, NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->overrideRootDir));
+if (sDirs->overrideRootDir) {
+sDirs->overrideRootDir->AppendRelativeNativePath(
+NS_LITERAL_CSTRING("device-storage-testing"));
+}
+} else {
+// For users running on desktop, it's convenient to be able to override
+// all of the directories to point to a single tree, much like what happens
+// on a real device.
+const nsAdoptingString& overrideRootDir =
+mozilla::Preferences::GetString("device.storage.overrideRootDir");
+if (overrideRootDir && overrideRootDir.Length() > 0) {
+NS_NewLocalFile(overrideRootDir, false,
+getter_AddRefs(sDirs->overrideRootDir));
+} else {
+sDirs->overrideRootDir = nullptr;
+}
+}
+if (sDirs->overrideRootDir) {
+if (XRE_GetProcessType() == GeckoProcessType_Default) {
+// Only the parent process can create directories. In testing, because
+// the preference is updated after startup, its entirely possible that
+// the preference updated notification will be received by a child
+// prior to the parent.
+nsresult rv
+= sDirs->overrideRootDir->Create(nsIFile::DIRECTORY_TYPE, 0777);
+nsString path;
+sDirs->overrideRootDir->GetPath(path);
+if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) {
+nsPrintfCString msg("DeviceStorage: Unable to create directory '%s'",
+NS_LossyConvertUTF16toASCII(path).get());
+NS_WARNING(msg.get());
+}
+}
+sDirs->overrideRootDir->Normalize();
+}
+}
+// Directories which don't depend on a volume should be calculated once
+// here. Directories which depend on the root directory of a volume
+// should be calculated in DeviceStorageFile::GetRootDirectoryForType.
+static void
+InitDirs()
+{
+if (sDirs) {
+return;
+}
+MOZ_ASSERT(NS_IsMainThread());
+sDirs = new GlobalDirs;
+ClearOnShutdown(&sDirs);
+nsCOMPtr<nsIProperties> dirService
+= do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
+MOZ_ASSERT(dirService);
+#if !defined(MOZ_WIDGET_GONK)
+#if defined (MOZ_WIDGET_COCOA)
+dirService->Get(NS_OSX_PICTURE_DOCUMENTS_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->pictures));
+dirService->Get(NS_OSX_MOVIE_DOCUMENTS_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->videos));
+dirService->Get(NS_OSX_MUSIC_DOCUMENTS_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->music));
+#elif defined (XP_UNIX)
+dirService->Get(NS_UNIX_XDG_PICTURES_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->pictures));
+dirService->Get(NS_UNIX_XDG_VIDEOS_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->videos));
+dirService->Get(NS_UNIX_XDG_MUSIC_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->music));
+#elif defined (XP_WIN)
+dirService->Get(NS_WIN_PICTURES_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->pictures));
+dirService->Get(NS_WIN_VIDEOS_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->videos));
+dirService->Get(NS_WIN_MUSIC_DIR,
+NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->music));
+#endif
+// Eventually, on desktop, we want to do something smarter -- for example,
+// detect when an sdcard is inserted, and use that instead of this.
+dirService->Get(NS_APP_USER_PROFILE_50_DIR, NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->sdcard));
+if (sDirs->sdcard) {
+sDirs->sdcard->AppendRelativeNativePath(NS_LITERAL_CSTRING("fake-sdcard"));
+}
+#endif // !MOZ_WIDGET_GONK
+#ifdef MOZ_WIDGET_GONK
+NS_NewLocalFile(NS_LITERAL_STRING("/data"),
+false,
+getter_AddRefs(sDirs->apps));
+#else
+dirService->Get(NS_APP_USER_PROFILE_50_DIR, NS_GET_IID(nsIFile),
+getter_AddRefs(sDirs->apps));
+if (sDirs->apps) {
+sDirs->apps->AppendRelativeNativePath(NS_LITERAL_CSTRING("webapps"));
+}
+#endif
+if (XRE_GetProcessType() == GeckoProcessType_Default) {
+NS_GetSpecialDirectory("UAppData", getter_AddRefs(sDirs->crashes));
+if (sDirs->crashes) {
+sDirs->crashes->Append(NS_LITERAL_STRING("Crash Reports"));
+}
+} else {
+// NS_GetSpecialDirectory("UAppData") fails in content processes because
+// gAppData from toolkit/xre/nsAppRunner.cpp is not initialized.
+#ifdef MOZ_WIDGET_GONK
+NS_NewLocalFile(NS_LITERAL_STRING("/data/b2g/mozilla/Crash Reports"),
+false,
+getter_AddRefs(sDirs->crashes));
+#endif
+}
+OverrideRootDir::GetSingleton()->Init();
+}
+void
+DeviceStorageFile::GetFullPath(nsAString &aFullPath)
+{
+aFullPath.Truncate();
+if (!mStorageName.EqualsLiteral("")) {
+aFullPath.AppendLiteral("/");
+aFullPath.Append(mStorageName);
+aFullPath.AppendLiteral("/");
+}
+if (!mRootDir.EqualsLiteral("")) {
+aFullPath.Append(mRootDir);
+aFullPath.AppendLiteral("/");
+}
+aFullPath.Append(mPath);
+}
+// Directories which don't depend on a volume should be calculated once
+// in InitDirs. Directories which depend on the root directory of a volume
+// should be calculated in this method.
+void
+DeviceStorageFile::GetRootDirectoryForType(const nsAString& aStorageType,
+const nsAString& aStorageName,
+nsIFile** aFile)
+{
+nsCOMPtr<nsIFile> f;
+*aFile = nullptr;
+bool allowOverride = true;
+InitDirs();
+#ifdef MOZ_WIDGET_GONK
+nsString volMountPoint;
+if (DeviceStorageTypeChecker::IsVolumeBased(aStorageType)) {
+nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
+NS_ENSURE_TRUE_VOID(vs);
+nsresult rv;
+nsCOMPtr<nsIVolume> vol;
+rv = vs->GetVolumeByName(aStorageName, getter_AddRefs(vol));
+NS_ENSURE_SUCCESS_VOID(rv);
+vol->GetMountPoint(volMountPoint);
+}
+#endif
+// Picture directory
+if (aStorageType.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
+#ifdef MOZ_WIDGET_GONK
+NS_NewLocalFile(volMountPoint, false, getter_AddRefs(f));
+#else
+f = sDirs->pictures;
+#endif
+}
+// Video directory
+else if (aStorageType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
+#ifdef MOZ_WIDGET_GONK
+NS_NewLocalFile(volMountPoint, false, getter_AddRefs(f));
+#else
+f = sDirs->videos;
+#endif
+}
+// Music directory
+else if (aStorageType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
+#ifdef MOZ_WIDGET_GONK
+NS_NewLocalFile(volMountPoint, false, getter_AddRefs(f));
+#else
+f = sDirs->music;
+#endif
+}
+// Apps directory
+else if (aStorageType.EqualsLiteral(DEVICESTORAGE_APPS)) {
+f = sDirs->apps;
+allowOverride = false;
+}
+// default SDCard
+else if (aStorageType.EqualsLiteral(DEVICESTORAGE_SDCARD)) {
+#ifdef MOZ_WIDGET_GONK
+NS_NewLocalFile(volMountPoint, false, getter_AddRefs(f));
+#else
+f = sDirs->sdcard;
+#endif
+}
+// crash reports directory.
+else if (aStorageType.EqualsLiteral(DEVICESTORAGE_CRASHES)) {
+f = sDirs->crashes;
+allowOverride = false;
+} else {
+// Not a storage type that we recognize. Return null
+return;
+}
+// In testing, we default all device storage types to a temp directory.
+// sDirs->overrideRootDir will only have been initialized (in InitDirs)
+// if the preference device.storage.testing was set to true, or if
+// device.storage.overrideRootDir is set. We can't test the preferences
+// directly here, since we may not be on the main thread.
+if (allowOverride && sDirs->overrideRootDir) {
+f = sDirs->overrideRootDir;
+}
+if (f) {
+f->Clone(aFile);
+}
+}
+//static
+already_AddRefed<DeviceStorageFile>
+DeviceStorageFile::CreateUnique(nsAString& aFileName,
+uint32_t aFileType,
+uint32_t aFileAttributes)
+{
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+MOZ_ASSERT(typeChecker);
+nsString storageType;
+typeChecker->GetTypeFromFileName(aFileName, storageType);
+nsString storageName;
+nsString storagePath;
+if (!nsDOMDeviceStorage::ParseFullPath(aFileName, storageName, storagePath)) {
+return nullptr;
+}
+if (storageName.IsEmpty()) {
+nsDOMDeviceStorage::GetDefaultStorageName(storageType, storageName);
+}
+nsRefPtr<DeviceStorageFile> dsf =
+new DeviceStorageFile(storageType, storageName, storagePath);
+if (!dsf->mFile) {
+return nullptr;
+}
+nsresult rv = dsf->mFile->CreateUnique(aFileType, aFileAttributes);
+NS_ENSURE_SUCCESS(rv, nullptr);
+// CreateUnique may cause the filename to change. So we need to update mPath
+// to reflect that.
+nsString leafName;
+dsf->mFile->GetLeafName(leafName);
+int32_t lastSlashIndex = dsf->mPath.RFindChar('/');
+if (lastSlashIndex == kNotFound) {
+dsf->mPath.Assign(leafName);
+} else {
+// Include the last '/'
+dsf->mPath = Substring(dsf->mPath, 0, lastSlashIndex + 1);
+dsf->mPath.Append(leafName);
+}
+return dsf.forget();
+}
+void
+DeviceStorageFile::SetPath(const nsAString& aPath) {
+mPath.Assign(aPath);
+NormalizeFilePath();
+}
+void
+DeviceStorageFile::SetEditable(bool aEditable) {
+mEditable = aEditable;
+}
+// we want to make sure that the names of file can't reach
+// outside of the type of storage the user asked for.
+bool
+DeviceStorageFile::IsSafePath()
+{
+return IsSafePath(mRootDir) && IsSafePath(mPath);
+}
+bool
+DeviceStorageFile::IsSafePath(const nsAString& aPath)
+{
+nsAString::const_iterator start, end;
+aPath.BeginReading(start);
+aPath.EndReading(end);
+// if the path is a '~' or starts with '~/', return false.
+NS_NAMED_LITERAL_STRING(tilde, "~");
+NS_NAMED_LITERAL_STRING(tildeSlash, "~/");
+if (aPath.Equals(tilde) ||
+StringBeginsWith(aPath, tildeSlash)) {
+NS_WARNING("Path name starts with tilde!");
+return false;
+}
+// split on /.  if any token is "", ., or .., return false.
+NS_ConvertUTF16toUTF8 cname(aPath);
+char* buffer = cname.BeginWriting();
+const char* token;
+while ((token = nsCRT::strtok(buffer, "/", &buffer))) {
+if (PL_strcmp(token, "") == 0 ||
+PL_strcmp(token, ".") == 0 ||
+PL_strcmp(token, "..") == 0 ) {
+return false;
+}
+}
+return true;
+}
+void
+DeviceStorageFile::NormalizeFilePath() {
+FileSystemUtils::LocalPathToNormalizedPath(mPath, mPath);
+}
+void
+DeviceStorageFile::AppendRelativePath(const nsAString& aPath) {
+if (!mFile) {
+return;
+}
+if (!IsSafePath(aPath)) {
+// All of the APIs (in the child) do checks to verify that the path is
+// valid and return PERMISSION_DENIED if a non-safe path is entered.
+// This check is done in the parent and prevents a compromised
+// child from bypassing the check. It shouldn't be possible for this
+// code path to be taken with a non-compromised child.
+NS_WARNING("Unsafe path detected - ignoring");
+NS_WARNING(NS_LossyConvertUTF16toASCII(aPath).get());
+return;
+}
+nsString localPath;
+FileSystemUtils::NormalizedPathToLocalPath(aPath, localPath);
+mFile->AppendRelativePath(localPath);
+}
+nsresult
+DeviceStorageFile::CreateFileDescriptor(FileDescriptor& aFileDescriptor)
+{
+ScopedPRFileDesc fd;
+nsresult rv = mFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE,
+0660, &fd.rwget());
+NS_ENSURE_SUCCESS(rv, rv);
+// NOTE: The FileDescriptor::PlatformHandleType constructor returns a dup of
+//       the file descriptor, so we don't need the original fd after this.
+//       Our scoped file descriptor will automatically close fd.
+aFileDescriptor =
+FileDescriptor::PlatformHandleType(PR_FileDesc2NativeHandle(fd));
+return NS_OK;
+}
+nsresult
+DeviceStorageFile::Write(nsIInputStream* aInputStream)
+{
+if (!aInputStream || !mFile) {
+return NS_ERROR_FAILURE;
+}
+nsresult rv = mFile->Create(nsIFile::NORMAL_FILE_TYPE, 00600);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+nsCOMPtr<nsIRunnable> iocomplete = new IOEventComplete(this, "created");
+rv = NS_DispatchToMainThread(iocomplete);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+uint64_t bufSize = 0;
+aInputStream->Available(&bufSize);
+nsCOMPtr<nsIOutputStream> outputStream;
+NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), mFile);
+if (!outputStream) {
+return NS_ERROR_FAILURE;
+}
+nsCOMPtr<nsIOutputStream> bufferedOutputStream;
+rv = NS_NewBufferedOutputStream(getter_AddRefs(bufferedOutputStream),
+outputStream,
+4096*4);
+NS_ENSURE_SUCCESS(rv, rv);
+while (bufSize) {
+uint32_t wrote;
+rv = bufferedOutputStream->WriteFrom(
+aInputStream,
+static_cast<uint32_t>(std::min<uint64_t>(bufSize, UINT32_MAX)),
+&wrote);
+if (NS_FAILED(rv)) {
+break;
+}
+bufSize -= wrote;
+}
+iocomplete = new IOEventComplete(this, "modified");
+rv = NS_DispatchToMainThread(iocomplete);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+bufferedOutputStream->Close();
+outputStream->Close();
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+return NS_OK;
+}
+nsresult
+DeviceStorageFile::Write(InfallibleTArray<uint8_t>& aBits)
+{
+if (!mFile) {
+return NS_ERROR_FAILURE;
+}
+nsresult rv = mFile->Create(nsIFile::NORMAL_FILE_TYPE, 00600);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+nsCOMPtr<nsIRunnable> iocomplete = new IOEventComplete(this, "created");
+rv = NS_DispatchToMainThread(iocomplete);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+nsCOMPtr<nsIOutputStream> outputStream;
+NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), mFile);
+if (!outputStream) {
+return NS_ERROR_FAILURE;
+}
+uint32_t wrote;
+outputStream->Write((char*) aBits.Elements(), aBits.Length(), &wrote);
+outputStream->Close();
+iocomplete = new IOEventComplete(this, "modified");
+rv = NS_DispatchToMainThread(iocomplete);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+if (aBits.Length() != wrote) {
+return NS_ERROR_FAILURE;
+}
+return NS_OK;
+}
+nsresult
+DeviceStorageFile::Remove()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+if (!mFile) {
+return NS_ERROR_FAILURE;
+}
+bool check;
+nsresult rv = mFile->Exists(&check);
+if (NS_FAILED(rv)) {
+return rv;
+}
+if (!check) {
+return NS_OK;
+}
+rv = mFile->Remove(true);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+nsCOMPtr<nsIRunnable> iocomplete = new IOEventComplete(this, "deleted");
+return NS_DispatchToMainThread(iocomplete);
+}
+nsresult
+DeviceStorageFile::CalculateMimeType()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsAutoCString mimeType;
+nsCOMPtr<nsIMIMEService> mimeService =
+do_GetService(NS_MIMESERVICE_CONTRACTID);
+if (mimeService) {
+nsresult rv = mimeService->GetTypeFromFile(mFile, mimeType);
+if (NS_FAILED(rv)) {
+mimeType.Truncate();
+return rv;
+}
+}
+mMimeType = NS_ConvertUTF8toUTF16(mimeType);
+return NS_OK;
+}
+nsresult
+DeviceStorageFile::CalculateSizeAndModifiedDate()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+int64_t fileSize;
+nsresult rv = mFile->GetFileSize(&fileSize);
+NS_ENSURE_SUCCESS(rv, rv);
+mLength = fileSize;
+PRTime modDate;
+rv = mFile->GetLastModifiedTime(&modDate);
+NS_ENSURE_SUCCESS(rv, rv);
+mLastModifiedDate = modDate;
+return NS_OK;
+}
+void
+DeviceStorageFile::CollectFiles(nsTArray<nsRefPtr<DeviceStorageFile> > &aFiles,
+PRTime aSince)
+{
+nsString fullRootPath;
+mFile->GetPath(fullRootPath);
+collectFilesInternal(aFiles, aSince, fullRootPath);
+}
+void
+DeviceStorageFile::collectFilesInternal(
+nsTArray<nsRefPtr<DeviceStorageFile> > &aFiles,
+PRTime aSince,
+nsAString& aRootPath)
+{
+if (!mFile || !IsAvailable()) {
+return;
+}
+nsCOMPtr<nsISimpleEnumerator> e;
+mFile->GetDirectoryEntries(getter_AddRefs(e));
+if (!e) {
+return;
+}
+nsCOMPtr<nsIDirectoryEnumerator> files = do_QueryInterface(e);
+nsCOMPtr<nsIFile> f;
+while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(f))) && f) {
+PRTime msecs;
+f->GetLastModifiedTime(&msecs);
+if (msecs < aSince) {
+continue;
+}
+bool isDir;
+f->IsDirectory(&isDir);
+bool isFile;
+f->IsFile(&isFile);
+nsString fullpath;
+nsresult rv = f->GetPath(fullpath);
+if (NS_FAILED(rv)) {
+continue;
+}
+if (!StringBeginsWith(fullpath, aRootPath)) {
+NS_ERROR("collectFiles returned a path that does not belong!");
+continue;
+}
+nsAString::size_type len = aRootPath.Length() + 1; // +1 for the trailing /
+nsDependentSubstring newPath = Substring(fullpath, len);
+if (isDir) {
+DeviceStorageFile dsf(mStorageType, mStorageName, mRootDir, newPath);
+dsf.collectFilesInternal(aFiles, aSince, aRootPath);
+} else if (isFile) {
+nsRefPtr<DeviceStorageFile> dsf =
+new DeviceStorageFile(mStorageType, mStorageName, mRootDir, newPath);
+dsf->CalculateSizeAndModifiedDate();
+aFiles.AppendElement(dsf);
+}
+}
+}
+void
+DeviceStorageFile::AccumDiskUsage(uint64_t* aPicturesSoFar,
+uint64_t* aVideosSoFar,
+uint64_t* aMusicSoFar,
+uint64_t* aTotalSoFar)
+{
+if (!IsAvailable()) {
+return;
+}
+uint64_t pictureUsage = 0, videoUsage = 0, musicUsage = 0, totalUsage = 0;
+if (DeviceStorageTypeChecker::IsVolumeBased(mStorageType)) {
+DeviceStorageUsedSpaceCache* usedSpaceCache =
+DeviceStorageUsedSpaceCache::CreateOrGet();
+MOZ_ASSERT(usedSpaceCache);
+nsresult rv = usedSpaceCache->AccumUsedSizes(mStorageName,
+aPicturesSoFar, aVideosSoFar,
+aMusicSoFar, aTotalSoFar);
+if (NS_SUCCEEDED(rv)) {
+return;
+}
+AccumDirectoryUsage(mFile, &pictureUsage, &videoUsage,
+&musicUsage, &totalUsage);
+usedSpaceCache->SetUsedSizes(mStorageName, pictureUsage, videoUsage,
+musicUsage, totalUsage);
+} else {
+AccumDirectoryUsage(mFile, &pictureUsage, &videoUsage,
+&musicUsage, &totalUsage);
+}
+*aPicturesSoFar += pictureUsage;
+*aVideosSoFar += videoUsage;
+*aMusicSoFar += musicUsage;
+*aTotalSoFar += totalUsage;
+}
+void
+DeviceStorageFile::AccumDirectoryUsage(nsIFile* aFile,
+uint64_t* aPicturesSoFar,
+uint64_t* aVideosSoFar,
+uint64_t* aMusicSoFar,
+uint64_t* aTotalSoFar)
+{
+if (!aFile) {
+return;
+}
+nsresult rv;
+nsCOMPtr<nsISimpleEnumerator> e;
+rv = aFile->GetDirectoryEntries(getter_AddRefs(e));
+if (NS_FAILED(rv) || !e) {
+return;
+}
+nsCOMPtr<nsIDirectoryEnumerator> files = do_QueryInterface(e);
+MOZ_ASSERT(files);
+nsCOMPtr<nsIFile> f;
+while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(f))) && f) {
+bool isDir;
+rv = f->IsDirectory(&isDir);
+if (NS_FAILED(rv)) {
+continue;
+}
+bool isFile;
+rv = f->IsFile(&isFile);
+if (NS_FAILED(rv)) {
+continue;
+}
+bool isLink;
+rv = f->IsSymlink(&isLink);
+if (NS_FAILED(rv)) {
+continue;
+}
+if (isLink) {
+// for now, lets just totally ignore symlinks.
+NS_WARNING("DirectoryDiskUsage ignores symlinks");
+} else if (isDir) {
+AccumDirectoryUsage(f, aPicturesSoFar, aVideosSoFar,
+aMusicSoFar, aTotalSoFar);
+} else if (isFile) {
+int64_t size;
+rv = f->GetFileSize(&size);
+if (NS_FAILED(rv)) {
+continue;
+}
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+MOZ_ASSERT(typeChecker);
+nsString type;
+typeChecker->GetTypeFromFile(f, type);
+if (type.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
+*aPicturesSoFar += size;
+}
+else if (type.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
+*aVideosSoFar += size;
+}
+else if (type.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
+*aMusicSoFar += size;
+}
+*aTotalSoFar += size;
+}
+}
+}
+void
+DeviceStorageFile::GetDiskFreeSpace(int64_t* aSoFar)
+{
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return;
+}
+if (!mFile || !IsAvailable()) {
+return;
+}
+int64_t storageAvail = 0;
+nsresult rv = mFile->GetDiskSpaceAvailable(&storageAvail);
+if (NS_SUCCEEDED(rv)) {
+*aSoFar += storageAvail;
+}
+}
+bool
+DeviceStorageFile::IsAvailable()
+{
+nsString status;
+GetStatus(status);
+return status.EqualsLiteral("available");
+}
+void
+DeviceStorageFile::DoFormat(nsAString& aStatus)
+{
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return;
+}
+if (!typeChecker->IsVolumeBased(mStorageType)) {
+aStatus.AssignLiteral("notVolume");
+return;
+}
+#ifdef MOZ_WIDGET_GONK
+nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
+NS_ENSURE_TRUE_VOID(vs);
+nsCOMPtr<nsIVolume> vol;
+nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
+NS_ENSURE_SUCCESS_VOID(rv);
+if (!vol) {
+return;
+}
+vol->Format();
+aStatus.AssignLiteral("formatting");
+#endif
+return;
+}
+void
+DeviceStorageFile::DoMount(nsAString& aStatus)
+{
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return;
+}
+if (!typeChecker->IsVolumeBased(mStorageType)) {
+aStatus.AssignLiteral("notVolume");
+return;
+}
+#ifdef MOZ_WIDGET_GONK
+nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
+NS_ENSURE_TRUE_VOID(vs);
+nsCOMPtr<nsIVolume> vol;
+nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
+NS_ENSURE_SUCCESS_VOID(rv);
+if (!vol) {
+return;
+}
+vol->Mount();
+aStatus.AssignLiteral("mounting");
+#endif
+return;
+}
+void
+DeviceStorageFile::DoUnmount(nsAString& aStatus)
+{
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return;
+}
+if (!typeChecker->IsVolumeBased(mStorageType)) {
+aStatus.AssignLiteral("notVolume");
+return;
+}
+#ifdef MOZ_WIDGET_GONK
+nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
+NS_ENSURE_TRUE_VOID(vs);
+nsCOMPtr<nsIVolume> vol;
+nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
+NS_ENSURE_SUCCESS_VOID(rv);
+if (!vol) {
+return;
+}
+vol->Unmount();
+aStatus.AssignLiteral("unmounting");
+#endif
+return;
+}
+void
+DeviceStorageFile::GetStatus(nsAString& aStatus)
+{
+aStatus.AssignLiteral("unavailable");
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return;
+}
+if (!typeChecker->IsVolumeBased(mStorageType)) {
+aStatus.AssignLiteral("available");
+return;
+}
+#ifdef MOZ_WIDGET_GONK
+nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
+NS_ENSURE_TRUE_VOID(vs);
+nsCOMPtr<nsIVolume> vol;
+nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
+NS_ENSURE_SUCCESS_VOID(rv);
+if (!vol) {
+return;
+}
+bool isMediaPresent;
+rv = vol->GetIsMediaPresent(&isMediaPresent);
+NS_ENSURE_SUCCESS_VOID(rv);
+if (!isMediaPresent) {
+return;
+}
+bool isSharing;
+rv = vol->GetIsSharing(&isSharing);
+NS_ENSURE_SUCCESS_VOID(rv);
+if (isSharing) {
+aStatus.AssignLiteral("shared");
+return;
+}
+bool isFormatting;
+rv = vol->GetIsFormatting(&isFormatting);
+NS_ENSURE_SUCCESS_VOID(rv);
+if (isFormatting) {
+aStatus.AssignLiteral("unavailable");
+return;
+}
+int32_t volState;
+rv = vol->GetState(&volState);
+NS_ENSURE_SUCCESS_VOID(rv);
+if (volState == nsIVolume::STATE_MOUNTED) {
+aStatus.AssignLiteral("available");
+}
+#endif
+}
+void
+DeviceStorageFile::GetStorageStatus(nsAString& aStatus)
+{
+aStatus.AssignLiteral("undefined");
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return;
+}
+if (!typeChecker->IsVolumeBased(mStorageType)) {
+aStatus.AssignLiteral("available");
+return;
+}
+#ifdef MOZ_WIDGET_GONK
+nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
+NS_ENSURE_TRUE_VOID(vs);
+nsCOMPtr<nsIVolume> vol;
+nsresult rv = vs->GetVolumeByName(mStorageName, getter_AddRefs(vol));
+NS_ENSURE_SUCCESS_VOID(rv);
+if (!vol) {
+return;
+}
+int32_t volState;
+rv = vol->GetState(&volState);
+NS_ENSURE_SUCCESS_VOID(rv);
+aStatus.AssignASCII(mozilla::system::NS_VolumeStateStr(volState));
+#endif
+}
+NS_IMPL_ISUPPORTS0(DeviceStorageFile)
+static void
+RegisterForSDCardChanges(nsIObserver* aObserver)
+{
+#ifdef MOZ_WIDGET_GONK
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->AddObserver(aObserver, NS_VOLUME_STATE_CHANGED, false);
+#endif
+}
+static void
+UnregisterForSDCardChanges(nsIObserver* aObserver)
+{
+#ifdef MOZ_WIDGET_GONK
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->RemoveObserver(aObserver, NS_VOLUME_STATE_CHANGED);
+#endif
+}
+void
+nsDOMDeviceStorage::SetRootDirectoryForType(const nsAString& aStorageType,
+const nsAString& aStorageName)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsIFile> f;
+DeviceStorageFile::GetRootDirectoryForType(aStorageType,
+aStorageName,
+getter_AddRefs(f));
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->AddObserver(this, "file-watcher-update", false);
+obs->AddObserver(this, "disk-space-watcher", false);
+mRootDirectory = f;
+mStorageType = aStorageType;
+mStorageName = aStorageName;
+}
+JS::Value
+InterfaceToJsval(nsPIDOMWindow* aWindow,
+nsISupports* aObject,
+const nsIID* aIID)
+{
+nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aWindow);
+if (!sgo) {
+return JS::NullValue();
+}
+JSObject *unrootedScopeObj = sgo->GetGlobalJSObject();
+NS_ENSURE_TRUE(unrootedScopeObj, JS::NullValue());
+JSRuntime *runtime = JS_GetObjectRuntime(unrootedScopeObj);
+JS::Rooted<JS::Value> someJsVal(runtime);
+nsresult rv;
+{ // Protect someJsVal from moving GC in ~JSAutoCompartment
+AutoJSContext cx;
+JS::Rooted<JSObject*> scopeObj(cx, unrootedScopeObj);
+JSAutoCompartment ac(cx, scopeObj);
+rv = nsContentUtils::WrapNative(cx, aObject, aIID, &someJsVal);
+}
+if (NS_FAILED(rv)) {
+return JS::NullValue();
+}
+return someJsVal;
+}
+JS::Value
+nsIFileToJsval(nsPIDOMWindow* aWindow, DeviceStorageFile* aFile)
+{
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(aWindow);
+if (!aFile) {
+return JSVAL_NULL;
+}
+if (aFile->mEditable) {
+// TODO - needs janv's file handle support.
+return JSVAL_NULL;
+}
+nsString fullPath;
+aFile->GetFullPath(fullPath);
+// This check is useful to know if somewhere the DeviceStorageFile
+// has not been properly set. Mimetype is not checked because it can be
+// empty.
+MOZ_ASSERT(aFile->mLength != UINT64_MAX);
+MOZ_ASSERT(aFile->mLastModifiedDate != UINT64_MAX);
+nsCOMPtr<nsIDOMBlob> blob = new nsDOMFileFile(fullPath, aFile->mMimeType,
+aFile->mLength, aFile->mFile,
+aFile->mLastModifiedDate);
+return InterfaceToJsval(aWindow, blob, &NS_GET_IID(nsIDOMBlob));
+}
+JS::Value StringToJsval(nsPIDOMWindow* aWindow, nsAString& aString)
+{
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(aWindow);
+nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aWindow);
+if (!sgo) {
+return JSVAL_NULL;
+}
+nsIScriptContext *scriptContext = sgo->GetScriptContext();
+if (!scriptContext) {
+return JSVAL_NULL;
+}
+AutoPushJSContext cx(scriptContext->GetNativeContext());
+if (!cx) {
+return JSVAL_NULL;
+}
+JS::Rooted<JS::Value> result(cx);
+if (!xpc::StringToJsval(cx, aString, &result)) {
+return JSVAL_NULL;
+}
+return result;
+}
+class DeviceStorageCursorRequest MOZ_FINAL
+: public nsIContentPermissionRequest
+, public PCOMContentPermissionRequestChild
+{
+public:
+NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(DeviceStorageCursorRequest,
+nsIContentPermissionRequest)
+NS_FORWARD_NSICONTENTPERMISSIONREQUEST(mCursor->);
+DeviceStorageCursorRequest(nsDOMDeviceStorageCursor* aCursor)
+: mCursor(aCursor) { }
+~DeviceStorageCursorRequest() {}
+bool Recv__delete__(const bool& allow,
+const InfallibleTArray<PermissionChoice>& choices)
+{
+MOZ_ASSERT(choices.IsEmpty(), "DeviceStorageCursor doesn't support permission choice");
+if (allow) {
+Allow(JS::UndefinedHandleValue);
+}
+else {
+Cancel();
+}
+return true;
+}
+void IPDLRelease()
+{
+Release();
+}
+private:
+nsRefPtr<nsDOMDeviceStorageCursor> mCursor;
+};
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeviceStorageCursorRequest)
+NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentPermissionRequest)
+NS_INTERFACE_MAP_ENTRY(nsIContentPermissionRequest)
+NS_INTERFACE_MAP_END
+NS_IMPL_CYCLE_COLLECTING_ADDREF(DeviceStorageCursorRequest)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(DeviceStorageCursorRequest)
+NS_IMPL_CYCLE_COLLECTION(DeviceStorageCursorRequest,
+mCursor)
+class PostErrorEvent : public nsRunnable
+{
+public:
+PostErrorEvent(already_AddRefed<DOMRequest> aRequest, const char* aMessage)
+: mRequest(aRequest)
+{
+CopyASCIItoUTF16(aMessage, mError);
+}
+PostErrorEvent(DOMRequest* aRequest, const char* aMessage)
+: mRequest(aRequest)
+{
+CopyASCIItoUTF16(aMessage, mError);
+}
+~PostErrorEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+if (!mRequest->GetOwner()) {
+return NS_OK;
+}
+mRequest->FireError(mError);
+mRequest = nullptr;
+return NS_OK;
+}
+private:
+nsRefPtr<DOMRequest> mRequest;
+nsString mError;
+};
+ContinueCursorEvent::ContinueCursorEvent(already_AddRefed<DOMRequest> aRequest)
+: mRequest(aRequest)
+{
+}
+ContinueCursorEvent::ContinueCursorEvent(DOMRequest* aRequest)
+: mRequest(aRequest)
+{
+}
+already_AddRefed<DeviceStorageFile>
+ContinueCursorEvent::GetNextFile()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsDOMDeviceStorageCursor* cursor
+= static_cast<nsDOMDeviceStorageCursor*>(mRequest.get());
+nsString cursorStorageType;
+cursor->GetStorageType(cursorStorageType);
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return nullptr;
+}
+while (cursor->mFiles.Length() > 0) {
+nsRefPtr<DeviceStorageFile> file = cursor->mFiles[0];
+cursor->mFiles.RemoveElementAt(0);
+if (!typeChecker->Check(cursorStorageType, file->mFile)) {
+continue;
+}
+file->CalculateMimeType();
+return file.forget();
+}
+return nullptr;
+}
+ContinueCursorEvent::~ContinueCursorEvent() {}
+void
+ContinueCursorEvent::Continue()
+{
+if (XRE_GetProcessType() == GeckoProcessType_Default) {
+DebugOnly<nsresult> rv = NS_DispatchToMainThread(this);
+MOZ_ASSERT(NS_SUCCEEDED(rv));
+return;
+}
+nsRefPtr<DeviceStorageFile> file = GetNextFile();
+if (!file) {
+// done with enumeration.
+DebugOnly<nsresult> rv = NS_DispatchToMainThread(this);
+MOZ_ASSERT(NS_SUCCEEDED(rv));
+return;
+}
+nsDOMDeviceStorageCursor* cursor
+= static_cast<nsDOMDeviceStorageCursor*>(mRequest.get());
+nsString cursorStorageType;
+cursor->GetStorageType(cursorStorageType);
+DeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, file);
+child->SetCallback(cursor);
+DeviceStorageGetParams params(cursorStorageType,
+file->mStorageName,
+file->mRootDir,
+file->mPath);
+ContentChild::GetSingleton()->SendPDeviceStorageRequestConstructor(child,
+params);
+mRequest = nullptr;
+}
+NS_IMETHODIMP
+ContinueCursorEvent::Run()
+{
+nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
+if (!window) {
+return NS_OK;
+}
+nsRefPtr<DeviceStorageFile> file = GetNextFile();
+nsDOMDeviceStorageCursor* cursor
+= static_cast<nsDOMDeviceStorageCursor*>(mRequest.get());
+AutoJSContext cx;
+JS::Rooted<JS::Value> val(cx, nsIFileToJsval(window, file));
+if (file) {
+cursor->mOkToCallContinue = true;
+cursor->FireSuccess(val);
+} else {
+cursor->FireDone();
+}
+mRequest = nullptr;
+return NS_OK;
+}
+class InitCursorEvent : public nsRunnable
+{
+public:
+InitCursorEvent(DOMRequest* aRequest, DeviceStorageFile* aFile)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+}
+~InitCursorEvent() {}
+NS_IMETHOD Run() {
+MOZ_ASSERT(!NS_IsMainThread());
+if (mFile->mFile) {
+bool check;
+mFile->mFile->IsDirectory(&check);
+if (!check) {
+nsCOMPtr<nsIRunnable> event =
+new PostErrorEvent(mRequest.forget(),
+POST_ERROR_EVENT_FILE_NOT_ENUMERABLE);
+return NS_DispatchToMainThread(event);
+}
+}
+nsDOMDeviceStorageCursor* cursor
+= static_cast<nsDOMDeviceStorageCursor*>(mRequest.get());
+mFile->CollectFiles(cursor->mFiles, cursor->mSince);
+nsRefPtr<ContinueCursorEvent> event
+= new ContinueCursorEvent(mRequest.forget());
+event->Continue();
+return NS_OK;
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsDOMDeviceStorageCursor)
+NS_INTERFACE_MAP_ENTRY(nsIContentPermissionRequest)
+NS_INTERFACE_MAP_END_INHERITING(DOMCursor)
+NS_IMPL_ADDREF_INHERITED(nsDOMDeviceStorageCursor, DOMCursor)
+NS_IMPL_RELEASE_INHERITED(nsDOMDeviceStorageCursor, DOMCursor)
+nsDOMDeviceStorageCursor::nsDOMDeviceStorageCursor(nsPIDOMWindow* aWindow,
+nsIPrincipal* aPrincipal,
+DeviceStorageFile* aFile,
+PRTime aSince)
+: DOMCursor(aWindow, nullptr)
+, mOkToCallContinue(false)
+, mSince(aSince)
+, mFile(aFile)
+, mPrincipal(aPrincipal)
+{
+}
+nsDOMDeviceStorageCursor::~nsDOMDeviceStorageCursor()
+{
+}
+void
+nsDOMDeviceStorageCursor::GetStorageType(nsAString & aType)
+{
+aType = mFile->mStorageType;
+}
+NS_IMETHODIMP
+nsDOMDeviceStorageCursor::GetTypes(nsIArray** aTypes)
+{
+nsCString type;
+nsresult rv =
+DeviceStorageTypeChecker::GetPermissionForType(mFile->mStorageType, type);
+NS_ENSURE_SUCCESS(rv, rv);
+nsTArray<nsString> emptyOptions;
+return CreatePermissionArray(type,
+NS_LITERAL_CSTRING("read"),
+emptyOptions,
+aTypes);
+}
+NS_IMETHODIMP
+nsDOMDeviceStorageCursor::GetPrincipal(nsIPrincipal * *aRequestingPrincipal)
+{
+NS_IF_ADDREF(*aRequestingPrincipal = mPrincipal);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsDOMDeviceStorageCursor::GetWindow(nsIDOMWindow * *aRequestingWindow)
+{
+NS_IF_ADDREF(*aRequestingWindow = GetOwner());
+return NS_OK;
+}
+NS_IMETHODIMP
+nsDOMDeviceStorageCursor::GetElement(nsIDOMElement * *aRequestingElement)
+{
+*aRequestingElement = nullptr;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsDOMDeviceStorageCursor::Cancel()
+{
+nsCOMPtr<nsIRunnable> event
+= new PostErrorEvent(this, POST_ERROR_EVENT_PERMISSION_DENIED);
+return NS_DispatchToMainThread(event);
+}
+NS_IMETHODIMP
+nsDOMDeviceStorageCursor::Allow(JS::HandleValue aChoices)
+{
+MOZ_ASSERT(aChoices.isUndefined());
+if (!mFile->IsSafePath()) {
+nsCOMPtr<nsIRunnable> r
+= new PostErrorEvent(this, POST_ERROR_EVENT_PERMISSION_DENIED);
+return NS_DispatchToMainThread(r);
+}
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(this, mFile);
+DeviceStorageEnumerationParams params(mFile->mStorageType,
+mFile->mStorageName,
+mFile->mRootDir,
+mSince);
+ContentChild::GetSingleton()->SendPDeviceStorageRequestConstructor(child,
+params);
+return NS_OK;
+}
+nsCOMPtr<nsIEventTarget> target
+= do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
+MOZ_ASSERT(target);
+nsCOMPtr<nsIRunnable> event = new InitCursorEvent(this, mFile);
+target->Dispatch(event, NS_DISPATCH_NORMAL);
+return NS_OK;
+}
+void
+nsDOMDeviceStorageCursor::Continue(ErrorResult& aRv)
+{
+if (!mOkToCallContinue) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return;
+}
+if (mResult != JSVAL_VOID) {
+// We call onsuccess multiple times. Clear the last
+// result.
+mResult = JSVAL_VOID;
+mDone = false;
+}
+nsRefPtr<ContinueCursorEvent> event = new ContinueCursorEvent(this);
+event->Continue();
+mOkToCallContinue = false;
+}
+bool
+nsDOMDeviceStorageCursor::Recv__delete__(const bool& allow,
+const InfallibleTArray<PermissionChoice>& choices)
+{
+MOZ_ASSERT(choices.IsEmpty(), "DeviceStorageCursor doesn't support permission choice");
+if (allow) {
+Allow(JS::UndefinedHandleValue);
+}
+else {
+Cancel();
+}
+return true;
+}
+void
+nsDOMDeviceStorageCursor::IPDLRelease()
+{
+Release();
+}
+void
+nsDOMDeviceStorageCursor::RequestComplete()
+{
+MOZ_ASSERT(!mOkToCallContinue);
+mOkToCallContinue = true;
+}
+class PostAvailableResultEvent : public nsRunnable
+{
+public:
+PostAvailableResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mRequest);
+}
+~PostAvailableResultEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
+if (!window) {
+return NS_OK;
+}
+nsString state = NS_LITERAL_STRING("unavailable");
+if (mFile) {
+mFile->GetStatus(state);
+}
+AutoJSContext cx;
+JS::Rooted<JS::Value> result(cx, StringToJsval(window, state));
+mRequest->FireSuccess(result);
+mRequest = nullptr;
+return NS_OK;
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class PostStatusResultEvent : public nsRunnable
+{
+public:
+PostStatusResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mRequest);
+}
+~PostStatusResultEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
+if (!window) {
+return NS_OK;
+}
+nsString state = NS_LITERAL_STRING("undefined");
+if (mFile) {
+mFile->GetStorageStatus(state);
+}
+AutoJSContext cx;
+JS::Rooted<JS::Value> result(cx, StringToJsval(window, state));
+mRequest->FireSuccess(result);
+mRequest = nullptr;
+return NS_OK;
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class PostFormatResultEvent : public nsRunnable
+{
+public:
+PostFormatResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mRequest);
+}
+~PostFormatResultEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
+if (!window) {
+return NS_OK;
+}
+nsString state = NS_LITERAL_STRING("unavailable");
+if (mFile) {
+mFile->DoFormat(state);
+}
+AutoJSContext cx;
+JS::Rooted<JS::Value> result(cx, StringToJsval(window, state));
+mRequest->FireSuccess(result);
+mRequest = nullptr;
+return NS_OK;
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class PostMountResultEvent : public nsRunnable
+{
+public:
+PostMountResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mRequest);
+}
+~PostMountResultEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
+if (!window) {
+return NS_OK;
+}
+nsString state = NS_LITERAL_STRING("unavailable");
+if (mFile) {
+mFile->DoMount(state);
+}
+AutoJSContext cx;
+JS::Rooted<JS::Value> result(cx, StringToJsval(window, state));
+mRequest->FireSuccess(result);
+mRequest = nullptr;
+return NS_OK;
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class PostUnmountResultEvent : public nsRunnable
+{
+public:
+PostUnmountResultEvent(DeviceStorageFile *aFile, DOMRequest* aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mRequest);
+}
+~PostUnmountResultEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
+if (!window) {
+return NS_OK;
+}
+nsString state = NS_LITERAL_STRING("unavailable");
+if (mFile) {
+mFile->DoUnmount(state);
+}
+AutoJSContext cx;
+JS::Rooted<JS::Value> result(cx, StringToJsval(window, state));
+mRequest->FireSuccess(result);
+mRequest = nullptr;
+return NS_OK;
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class PostResultEvent : public nsRunnable
+{
+public:
+PostResultEvent(already_AddRefed<DOMRequest> aRequest,
+DeviceStorageFile* aFile)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mRequest);
+}
+PostResultEvent(already_AddRefed<DOMRequest> aRequest,
+const nsAString & aPath)
+: mPath(aPath)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mRequest);
+}
+PostResultEvent(already_AddRefed<DOMRequest> aRequest,
+const uint64_t aValue)
+: mValue(aValue)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mRequest);
+}
+~PostResultEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> window = mRequest->GetOwner();
+if (!window) {
+return NS_OK;
+}
+AutoJSContext cx;
+JS::Rooted<JS::Value> result(cx, JSVAL_NULL);
+if (mFile) {
+result = nsIFileToJsval(window, mFile);
+} else if (mPath.Length()) {
+result = StringToJsval(window, mPath);
+}
+else {
+result = JS_NumberValue(double(mValue));
+}
+mRequest->FireSuccess(result);
+mRequest = nullptr;
+return NS_OK;
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsString mPath;
+uint64_t mValue;
+nsRefPtr<DOMRequest> mRequest;
+};
+class CreateFdEvent : public nsRunnable
+{
+public:
+CreateFdEvent(DeviceStorageFileDescriptor* aDSFileDescriptor,
+already_AddRefed<DOMRequest> aRequest)
+: mDSFileDescriptor(aDSFileDescriptor)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mDSFileDescriptor);
+MOZ_ASSERT(mRequest);
+}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+DeviceStorageFile* dsFile = mDSFileDescriptor->mDSFile;
+MOZ_ASSERT(dsFile);
+nsString fullPath;
+dsFile->GetFullPath(fullPath);
+MOZ_ASSERT(!fullPath.IsEmpty());
+bool check = false;
+dsFile->mFile->Exists(&check);
+if (check) {
+nsCOMPtr<nsIRunnable> event =
+new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_FILE_EXISTS);
+return NS_DispatchToMainThread(event);
+}
+nsresult rv = dsFile->CreateFileDescriptor(mDSFileDescriptor->mFileDescriptor);
+if (NS_FAILED(rv)) {
+dsFile->mFile->Remove(false);
+nsCOMPtr<nsIRunnable> event =
+new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_UNKNOWN);
+return NS_DispatchToMainThread(event);
+}
+nsCOMPtr<nsIRunnable> event =
+new PostResultEvent(mRequest.forget(), fullPath);
+return NS_DispatchToMainThread(event);
+}
+private:
+nsRefPtr<DeviceStorageFileDescriptor> mDSFileDescriptor;
+nsRefPtr<DOMRequest> mRequest;
+};
+class WriteFileEvent : public nsRunnable
+{
+public:
+WriteFileEvent(nsIDOMBlob* aBlob,
+DeviceStorageFile *aFile,
+already_AddRefed<DOMRequest> aRequest)
+: mBlob(aBlob)
+, mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mFile);
+MOZ_ASSERT(mRequest);
+}
+~WriteFileEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+nsCOMPtr<nsIInputStream> stream;
+mBlob->GetInternalStream(getter_AddRefs(stream));
+bool check = false;
+mFile->mFile->Exists(&check);
+if (check) {
+nsCOMPtr<nsIRunnable> event =
+new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_FILE_EXISTS);
+return NS_DispatchToMainThread(event);
+}
+nsresult rv = mFile->Write(stream);
+if (NS_FAILED(rv)) {
+mFile->mFile->Remove(false);
+nsCOMPtr<nsIRunnable> event =
+new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_UNKNOWN);
+return NS_DispatchToMainThread(event);
+}
+nsString fullPath;
+mFile->GetFullPath(fullPath);
+nsCOMPtr<nsIRunnable> event =
+new PostResultEvent(mRequest.forget(), fullPath);
+return NS_DispatchToMainThread(event);
+}
+private:
+nsCOMPtr<nsIDOMBlob> mBlob;
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class ReadFileEvent : public nsRunnable
+{
+public:
+ReadFileEvent(DeviceStorageFile* aFile,
+already_AddRefed<DOMRequest> aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mFile);
+MOZ_ASSERT(mRequest);
+mFile->CalculateMimeType();
+}
+~ReadFileEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+nsCOMPtr<nsIRunnable> r;
+if (!mFile->mEditable) {
+bool check = false;
+mFile->mFile->Exists(&check);
+if (!check) {
+r = new PostErrorEvent(mRequest.forget(),
+POST_ERROR_EVENT_FILE_DOES_NOT_EXIST);
+}
+}
+if (!r) {
+nsresult rv = mFile->CalculateSizeAndModifiedDate();
+if (NS_FAILED(rv)) {
+r = new PostErrorEvent(mRequest.forget(), POST_ERROR_EVENT_UNKNOWN);
+}
+}
+if (!r) {
+r = new PostResultEvent(mRequest.forget(), mFile);
+}
+return NS_DispatchToMainThread(r);
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class DeleteFileEvent : public nsRunnable
+{
+public:
+DeleteFileEvent(DeviceStorageFile* aFile,
+already_AddRefed<DOMRequest> aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mFile);
+MOZ_ASSERT(mRequest);
+}
+~DeleteFileEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+mFile->Remove();
+nsCOMPtr<nsIRunnable> r;
+bool check = false;
+mFile->mFile->Exists(&check);
+if (check) {
+r = new PostErrorEvent(mRequest.forget(),
+POST_ERROR_EVENT_FILE_DOES_NOT_EXIST);
+}
+else {
+nsString fullPath;
+mFile->GetFullPath(fullPath);
+r = new PostResultEvent(mRequest.forget(), fullPath);
+}
+return NS_DispatchToMainThread(r);
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class UsedSpaceFileEvent : public nsRunnable
+{
+public:
+UsedSpaceFileEvent(DeviceStorageFile* aFile,
+already_AddRefed<DOMRequest> aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mFile);
+MOZ_ASSERT(mRequest);
+}
+~UsedSpaceFileEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+uint64_t picturesUsage = 0, videosUsage = 0, musicUsage = 0, totalUsage = 0;
+mFile->AccumDiskUsage(&picturesUsage, &videosUsage,
+&musicUsage, &totalUsage);
+nsCOMPtr<nsIRunnable> r;
+if (mFile->mStorageType.EqualsLiteral(DEVICESTORAGE_PICTURES)) {
+r = new PostResultEvent(mRequest.forget(), picturesUsage);
+}
+else if (mFile->mStorageType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
+r = new PostResultEvent(mRequest.forget(), videosUsage);
+}
+else if (mFile->mStorageType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
+r = new PostResultEvent(mRequest.forget(), musicUsage);
+} else {
+r = new PostResultEvent(mRequest.forget(), totalUsage);
+}
+return NS_DispatchToMainThread(r);
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class FreeSpaceFileEvent : public nsRunnable
+{
+public:
+FreeSpaceFileEvent(DeviceStorageFile* aFile,
+already_AddRefed<DOMRequest> aRequest)
+: mFile(aFile)
+, mRequest(aRequest)
+{
+MOZ_ASSERT(mFile);
+MOZ_ASSERT(mRequest);
+}
+~FreeSpaceFileEvent() {}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+int64_t freeSpace = 0;
+if (mFile) {
+mFile->GetDiskFreeSpace(&freeSpace);
+}
+nsCOMPtr<nsIRunnable> r;
+r = new PostResultEvent(mRequest.forget(),
+static_cast<uint64_t>(freeSpace));
+return NS_DispatchToMainThread(r);
+}
+private:
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+};
+class DeviceStorageRequest MOZ_FINAL
+: public nsIContentPermissionRequest
+, public nsIRunnable
+, public PCOMContentPermissionRequestChild
+{
+public:
+DeviceStorageRequest(const DeviceStorageRequestType aRequestType,
+nsPIDOMWindow* aWindow,
+nsIPrincipal* aPrincipal,
+DeviceStorageFile* aFile,
+DOMRequest* aRequest,
+nsDOMDeviceStorage* aDeviceStorage)
+: mRequestType(aRequestType)
+, mWindow(aWindow)
+, mPrincipal(aPrincipal)
+, mFile(aFile)
+, mRequest(aRequest)
+, mDeviceStorage(aDeviceStorage)
+{
+MOZ_ASSERT(mWindow);
+MOZ_ASSERT(mPrincipal);
+MOZ_ASSERT(mFile);
+MOZ_ASSERT(mRequest);
+MOZ_ASSERT(mDeviceStorage);
+}
+DeviceStorageRequest(const DeviceStorageRequestType aRequestType,
+nsPIDOMWindow* aWindow,
+nsIPrincipal* aPrincipal,
+DeviceStorageFile* aFile,
+DOMRequest* aRequest,
+nsIDOMBlob* aBlob = nullptr)
+: mRequestType(aRequestType)
+, mWindow(aWindow)
+, mPrincipal(aPrincipal)
+, mFile(aFile)
+, mRequest(aRequest)
+, mBlob(aBlob)
+{
+MOZ_ASSERT(mWindow);
+MOZ_ASSERT(mPrincipal);
+MOZ_ASSERT(mFile);
+MOZ_ASSERT(mRequest);
+}
+DeviceStorageRequest(const DeviceStorageRequestType aRequestType,
+nsPIDOMWindow* aWindow,
+nsIPrincipal* aPrincipal,
+DeviceStorageFile* aFile,
+DOMRequest* aRequest,
+DeviceStorageFileDescriptor* aDSFileDescriptor)
+: mRequestType(aRequestType)
+, mWindow(aWindow)
+, mPrincipal(aPrincipal)
+, mFile(aFile)
+, mRequest(aRequest)
+, mDSFileDescriptor(aDSFileDescriptor)
+{
+MOZ_ASSERT(mRequestType == DEVICE_STORAGE_REQUEST_CREATEFD);
+MOZ_ASSERT(mWindow);
+MOZ_ASSERT(mPrincipal);
+MOZ_ASSERT(mFile);
+MOZ_ASSERT(mRequest);
+MOZ_ASSERT(mDSFileDescriptor);
+}
+NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(DeviceStorageRequest,
+nsIContentPermissionRequest)
+NS_IMETHOD Run() {
+MOZ_ASSERT(NS_IsMainThread());
+if (mozilla::Preferences::GetBool("device.storage.prompt.testing", false)) {
+Allow(JS::UndefinedHandleValue);
+return NS_OK;
+}
+if (XRE_GetProcessType() == GeckoProcessType_Content) {
+// because owner implements nsITabChild, we can assume that it is
+// the one and only TabChild.
+TabChild* child = TabChild::GetFrom(mWindow->GetDocShell());
+if (!child) {
+return NS_OK;
+}
+// Retain a reference so the object isn't deleted without IPDL's
+// knowledge. Corresponding release occurs in
+// DeallocPContentPermissionRequest.
+AddRef();
+nsCString type;
+nsresult rv = DeviceStorageTypeChecker::GetPermissionForType(
+mFile->mStorageType, type);
+if (NS_FAILED(rv)) {
+return rv;
+}
+nsCString access;
+rv = DeviceStorageTypeChecker::GetAccessForRequest(
+DeviceStorageRequestType(mRequestType), access);
+if (NS_FAILED(rv)) {
+return rv;
+}
+nsTArray<PermissionRequest> permArray;
+nsTArray<nsString> emptyOptions;
+permArray.AppendElement(PermissionRequest(type, access, emptyOptions));
+child->SendPContentPermissionRequestConstructor(
+this, permArray, IPC::Principal(mPrincipal));
+Sendprompt();
+return NS_OK;
+}
+nsCOMPtr<nsIContentPermissionPrompt> prompt
+= do_CreateInstance(NS_CONTENT_PERMISSION_PROMPT_CONTRACTID);
+if (prompt) {
+prompt->Prompt(this);
+}
+return NS_OK;
+}
+NS_IMETHODIMP GetTypes(nsIArray** aTypes)
+{
+nsCString type;
+nsresult rv =
+DeviceStorageTypeChecker::GetPermissionForType(mFile->mStorageType, type);
+if (NS_FAILED(rv)) {
+return rv;
+}
+nsCString access;
+rv = DeviceStorageTypeChecker::GetAccessForRequest(
+DeviceStorageRequestType(mRequestType), access);
+if (NS_FAILED(rv)) {
+return rv;
+}
+nsTArray<nsString> emptyOptions;
+return CreatePermissionArray(type, access, emptyOptions, aTypes);
+}
+NS_IMETHOD GetPrincipal(nsIPrincipal * *aRequestingPrincipal)
+{
+NS_IF_ADDREF(*aRequestingPrincipal = mPrincipal);
+return NS_OK;
+}
+NS_IMETHOD GetWindow(nsIDOMWindow * *aRequestingWindow)
+{
+NS_IF_ADDREF(*aRequestingWindow = mWindow);
+return NS_OK;
+}
+NS_IMETHOD GetElement(nsIDOMElement * *aRequestingElement)
+{
+*aRequestingElement = nullptr;
+return NS_OK;
+}
+NS_IMETHOD Cancel()
+{
+nsCOMPtr<nsIRunnable> event
+= new PostErrorEvent(mRequest.forget(),
+POST_ERROR_EVENT_PERMISSION_DENIED);
+return NS_DispatchToMainThread(event);
+}
+NS_IMETHOD Allow(JS::HandleValue aChoices)
+{
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(aChoices.isUndefined());
+if (!mRequest) {
+return NS_ERROR_FAILURE;
+}
+nsCOMPtr<nsIRunnable> r;
+switch(mRequestType) {
+case DEVICE_STORAGE_REQUEST_CREATEFD:
+{
+if (!mFile->mFile) {
+return NS_ERROR_FAILURE;
+}
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return NS_OK;
+}
+if (!typeChecker->Check(mFile->mStorageType, mFile->mFile)) {
+r = new PostErrorEvent(mRequest.forget(),
+POST_ERROR_EVENT_ILLEGAL_TYPE);
+return NS_DispatchToCurrentThread(r);
+}
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+DeviceStorageCreateFdParams params;
+params.type() = mFile->mStorageType;
+params.storageName() = mFile->mStorageName;
+params.relpath() = mFile->mPath;
+mFile->Dump("DeviceStorageCreateFdParams");
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile,
+mDSFileDescriptor.get());
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+mDSFileDescriptor->mDSFile = mFile;
+r = new CreateFdEvent(mDSFileDescriptor.get(), mRequest.forget());
+break;
+}
+case DEVICE_STORAGE_REQUEST_CREATE:
+{
+if (!mBlob || !mFile->mFile) {
+return NS_ERROR_FAILURE;
+}
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return NS_OK;
+}
+if (!typeChecker->Check(mFile->mStorageType, mFile->mFile) ||
+!typeChecker->Check(mFile->mStorageType, mBlob)) {
+r = new PostErrorEvent(mRequest.forget(),
+POST_ERROR_EVENT_ILLEGAL_TYPE);
+return NS_DispatchToCurrentThread(r);
+}
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+BlobChild* actor
+= ContentChild::GetSingleton()->GetOrCreateActorForBlob(mBlob);
+if (!actor) {
+return NS_ERROR_FAILURE;
+}
+DeviceStorageAddParams params;
+params.blobChild() = actor;
+params.type() = mFile->mStorageType;
+params.storageName() = mFile->mStorageName;
+params.relpath() = mFile->mPath;
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new WriteFileEvent(mBlob, mFile, mRequest.forget());
+break;
+}
+case DEVICE_STORAGE_REQUEST_READ:
+case DEVICE_STORAGE_REQUEST_WRITE:
+{
+if (!mFile->mFile) {
+return NS_ERROR_FAILURE;
+}
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return NS_OK;
+}
+if (!typeChecker->Check(mFile->mStorageType, mFile->mFile)) {
+r = new PostErrorEvent(mRequest.forget(),
+POST_ERROR_EVENT_ILLEGAL_TYPE);
+return NS_DispatchToCurrentThread(r);
+}
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageGetParams params(mFile->mStorageType,
+mFile->mStorageName,
+mFile->mRootDir,
+mFile->mPath);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new ReadFileEvent(mFile, mRequest.forget());
+break;
+}
+case DEVICE_STORAGE_REQUEST_DELETE:
+{
+if (!mFile->mFile) {
+return NS_ERROR_FAILURE;
+}
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return NS_OK;
+}
+if (!typeChecker->Check(mFile->mStorageType, mFile->mFile)) {
+r = new PostErrorEvent(mRequest.forget(),
+POST_ERROR_EVENT_ILLEGAL_TYPE);
+return NS_DispatchToCurrentThread(r);
+}
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageDeleteParams params(mFile->mStorageType,
+mFile->mStorageName,
+mFile->mPath);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new DeleteFileEvent(mFile, mRequest.forget());
+break;
+}
+case DEVICE_STORAGE_REQUEST_FREE_SPACE:
+{
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageFreeSpaceParams params(mFile->mStorageType,
+mFile->mStorageName);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new FreeSpaceFileEvent(mFile, mRequest.forget());
+break;
+}
+case DEVICE_STORAGE_REQUEST_USED_SPACE:
+{
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageUsedSpaceParams params(mFile->mStorageType,
+mFile->mStorageName);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+// this needs to be dispatched to only one (1)
+// thread or we will do more work than required.
+DeviceStorageUsedSpaceCache* usedSpaceCache
+= DeviceStorageUsedSpaceCache::CreateOrGet();
+MOZ_ASSERT(usedSpaceCache);
+r = new UsedSpaceFileEvent(mFile, mRequest.forget());
+usedSpaceCache->Dispatch(r);
+return NS_OK;
+}
+case DEVICE_STORAGE_REQUEST_AVAILABLE:
+{
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageAvailableParams params(mFile->mStorageType,
+mFile->mStorageName);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new PostAvailableResultEvent(mFile, mRequest);
+return NS_DispatchToCurrentThread(r);
+}
+case DEVICE_STORAGE_REQUEST_STATUS:
+{
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageStatusParams params(mFile->mStorageType,
+mFile->mStorageName);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new PostStatusResultEvent(mFile, mRequest);
+return NS_DispatchToCurrentThread(r);
+}
+case DEVICE_STORAGE_REQUEST_WATCH:
+{
+mDeviceStorage->mAllowedToWatchFile = true;
+return NS_OK;
+}
+case DEVICE_STORAGE_REQUEST_FORMAT:
+{
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageFormatParams params(mFile->mStorageType,
+mFile->mStorageName);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new PostFormatResultEvent(mFile, mRequest);
+return NS_DispatchToCurrentThread(r);
+}
+case DEVICE_STORAGE_REQUEST_MOUNT:
+{
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageMountParams params(mFile->mStorageType,
+mFile->mStorageName);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new PostMountResultEvent(mFile, mRequest);
+return NS_DispatchToCurrentThread(r);
+}
+case DEVICE_STORAGE_REQUEST_UNMOUNT:
+{
+if (XRE_GetProcessType() != GeckoProcessType_Default) {
+PDeviceStorageRequestChild* child
+= new DeviceStorageRequestChild(mRequest, mFile);
+DeviceStorageUnmountParams params(mFile->mStorageType,
+mFile->mStorageName);
+ContentChild::GetSingleton()
+->SendPDeviceStorageRequestConstructor(child, params);
+return NS_OK;
+}
+r = new PostUnmountResultEvent(mFile, mRequest);
+return NS_DispatchToCurrentThread(r);
+}
+}
+if (r) {
+nsCOMPtr<nsIEventTarget> target
+= do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
+MOZ_ASSERT(target);
+target->Dispatch(r, NS_DISPATCH_NORMAL);
+}
+return NS_OK;
+}
+bool Recv__delete__(const bool& allow,
+const InfallibleTArray<PermissionChoice>& choices)
+{
+MOZ_ASSERT(choices.IsEmpty(), "DeviceStorage doesn't support permission choice");
+if (allow) {
+Allow(JS::UndefinedHandleValue);
+}
+else {
+Cancel();
+}
+return true;
+}
+void IPDLRelease()
+{
+Release();
+}
+private:
+int32_t mRequestType;
+nsCOMPtr<nsPIDOMWindow> mWindow;
+nsCOMPtr<nsIPrincipal> mPrincipal;
+nsRefPtr<DeviceStorageFile> mFile;
+nsRefPtr<DOMRequest> mRequest;
+nsCOMPtr<nsIDOMBlob> mBlob;
+nsRefPtr<nsDOMDeviceStorage> mDeviceStorage;
+nsRefPtr<DeviceStorageFileDescriptor> mDSFileDescriptor;
+};
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeviceStorageRequest)
+NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentPermissionRequest)
+NS_INTERFACE_MAP_ENTRY(nsIContentPermissionRequest)
+NS_INTERFACE_MAP_ENTRY(nsIRunnable)
+NS_INTERFACE_MAP_END
+NS_IMPL_CYCLE_COLLECTING_ADDREF(DeviceStorageRequest)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(DeviceStorageRequest)
+NS_IMPL_CYCLE_COLLECTION(DeviceStorageRequest,
+mRequest,
+mWindow,
+mBlob,
+mDeviceStorage)
+NS_INTERFACE_MAP_BEGIN(nsDOMDeviceStorage)
+NS_INTERFACE_MAP_ENTRY(nsIDOMDeviceStorage)
+NS_INTERFACE_MAP_ENTRY(nsIObserver)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+NS_IMPL_ADDREF_INHERITED(nsDOMDeviceStorage, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(nsDOMDeviceStorage, DOMEventTargetHelper)
+nsDOMDeviceStorage::nsDOMDeviceStorage(nsPIDOMWindow* aWindow)
+: DOMEventTargetHelper(aWindow)
+, mIsWatchingFile(false)
+, mAllowedToWatchFile(false)
+{
+}
+/* virtual */ JSObject*
+nsDOMDeviceStorage::WrapObject(JSContext* aCx)
+{
+return DeviceStorageBinding::Wrap(aCx, this);
+}
+nsresult
+nsDOMDeviceStorage::Init(nsPIDOMWindow* aWindow, const nsAString &aType,
+const nsAString &aVolName)
+{
+DebugOnly<FileUpdateDispatcher*> observer
+= FileUpdateDispatcher::GetSingleton();
+MOZ_ASSERT(observer);
+MOZ_ASSERT(aWindow);
+SetRootDirectoryForType(aType, aVolName);
+if (!mRootDirectory) {
+return NS_ERROR_NOT_AVAILABLE;
+}
+if (!mStorageName.IsEmpty()) {
+RegisterForSDCardChanges(this);
+}
+// Grab the principal of the document
+nsCOMPtr<nsIDocument> doc = aWindow->GetDoc();
+if (!doc) {
+return NS_ERROR_FAILURE;
+}
+mPrincipal = doc->NodePrincipal();
+// the 'apps' type is special.  We only want this exposed
+// if the caller has the "webapps-manage" permission.
+if (aType.EqualsLiteral(DEVICESTORAGE_APPS)) {
+nsCOMPtr<nsIPermissionManager> permissionManager
+= do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);
+NS_ENSURE_TRUE(permissionManager, NS_ERROR_FAILURE);
+uint32_t permission;
+nsresult rv
+= permissionManager->TestPermissionFromPrincipal(mPrincipal,
+"webapps-manage",
+&permission);
+if (NS_FAILED(rv) || permission != nsIPermissionManager::ALLOW_ACTION) {
+return NS_ERROR_NOT_AVAILABLE;
+}
+}
+return NS_OK;
+}
+nsDOMDeviceStorage::~nsDOMDeviceStorage()
+{
+}
+void
+nsDOMDeviceStorage::Shutdown()
+{
+MOZ_ASSERT(NS_IsMainThread());
+if (mFileSystem) {
+mFileSystem->Shutdown();
+mFileSystem = nullptr;
+}
+if (!mStorageName.IsEmpty()) {
+UnregisterForSDCardChanges(this);
+}
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->RemoveObserver(this, "file-watcher-update");
+obs->RemoveObserver(this, "disk-space-watcher");
+}
+StaticAutoPtr<nsTArray<nsString>> nsDOMDeviceStorage::sVolumeNameCache;
+// static
+void
+nsDOMDeviceStorage::GetOrderedVolumeNames(
+nsDOMDeviceStorage::VolumeNameArray &aVolumeNames)
+{
+if (sVolumeNameCache && sVolumeNameCache->Length() > 0) {
+aVolumeNames.AppendElements(*sVolumeNameCache);
+return;
+}
+#ifdef MOZ_WIDGET_GONK
+nsCOMPtr<nsIVolumeService> vs = do_GetService(NS_VOLUMESERVICE_CONTRACTID);
+if (vs) {
+vs->GetVolumeNames(aVolumeNames);
+// If the volume sdcard exists, then we want it to be first.
+VolumeNameArray::index_type sdcardIndex;
+sdcardIndex = aVolumeNames.IndexOf(NS_LITERAL_STRING("sdcard"));
+if (sdcardIndex != VolumeNameArray::NoIndex && sdcardIndex > 0) {
+aVolumeNames.RemoveElementAt(sdcardIndex);
+aVolumeNames.InsertElementAt(0, NS_LITERAL_STRING("sdcard"));
+}
+}
+#endif
+if (aVolumeNames.IsEmpty()) {
+aVolumeNames.AppendElement(EmptyString());
+}
+sVolumeNameCache = new nsTArray<nsString>;
+sVolumeNameCache->AppendElements(aVolumeNames);
+}
+// static
+void
+nsDOMDeviceStorage::CreateDeviceStorageFor(nsPIDOMWindow* aWin,
+const nsAString &aType,
+nsDOMDeviceStorage** aStore)
+{
+nsString storageName;
+if (!DeviceStorageTypeChecker::IsVolumeBased(aType)) {
+// The storage name will be the empty string
+storageName.Truncate();
+} else {
+GetDefaultStorageName(aType, storageName);
+}
+nsRefPtr<nsDOMDeviceStorage> ds = new nsDOMDeviceStorage(aWin);
+if (NS_FAILED(ds->Init(aWin, aType, storageName))) {
+*aStore = nullptr;
+return;
+}
+NS_ADDREF(*aStore = ds.get());
+}
+// static
+void
+nsDOMDeviceStorage::CreateDeviceStoragesFor(
+nsPIDOMWindow* aWin,
+const nsAString &aType,
+nsTArray<nsRefPtr<nsDOMDeviceStorage> > &aStores)
+{
+nsresult rv;
+if (!DeviceStorageTypeChecker::IsVolumeBased(aType)) {
+nsRefPtr<nsDOMDeviceStorage> storage = new nsDOMDeviceStorage(aWin);
+rv = storage->Init(aWin, aType, EmptyString());
+if (NS_SUCCEEDED(rv)) {
+aStores.AppendElement(storage);
+}
+return;
+}
+VolumeNameArray volNames;
+GetOrderedVolumeNames(volNames);
+VolumeNameArray::size_type numVolumeNames = volNames.Length();
+for (VolumeNameArray::index_type i = 0; i < numVolumeNames; i++) {
+nsRefPtr<nsDOMDeviceStorage> storage = new nsDOMDeviceStorage(aWin);
+rv = storage->Init(aWin, aType, volNames[i]);
+if (NS_FAILED(rv)) {
+break;
+}
+aStores.AppendElement(storage);
+}
+}
+// static
+bool
+nsDOMDeviceStorage::ParseFullPath(const nsAString& aFullPath,
+nsAString& aOutStorageName,
+nsAString& aOutStoragePath)
+{
+aOutStorageName.Truncate();
+aOutStoragePath.Truncate();
+NS_NAMED_LITERAL_STRING(slash, "/");
+nsDependentSubstring storageName;
+if (StringBeginsWith(aFullPath, slash)) {
+int32_t slashIndex = aFullPath.FindChar('/', 1);
+if (slashIndex == kNotFound) {
+// names of the form /filename are illegal
+return false;
+}
+storageName.Rebind(aFullPath, 1, slashIndex - 1);
+aOutStoragePath = Substring(aFullPath, slashIndex + 1);
+} else {
+aOutStoragePath = aFullPath;
+}
+// If no volume name was specified in aFullPath, then aOutStorageName
+// will wind up being the empty string. It's up to the caller to figure
+// out which storage name to actually use.
+aOutStorageName = storageName;
+return true;
+}
+already_AddRefed<nsDOMDeviceStorage>
+nsDOMDeviceStorage::GetStorage(const nsAString& aFullPath,
+nsAString& aOutStoragePath)
+{
+nsString storageName;
+if (!ParseFullPath(aFullPath, storageName, aOutStoragePath)) {
+return nullptr;
+}
+nsRefPtr<nsDOMDeviceStorage> ds;
+if (storageName.IsEmpty()) {
+ds = this;
+} else {
+ds = GetStorageByName(storageName);
+}
+return ds.forget();
+}
+already_AddRefed<nsDOMDeviceStorage>
+nsDOMDeviceStorage::GetStorageByName(const nsAString& aStorageName)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsRefPtr<nsDOMDeviceStorage> ds;
+if (mStorageName.Equals(aStorageName)) {
+ds = this;
+return ds.forget();
+}
+VolumeNameArray volNames;
+GetOrderedVolumeNames(volNames);
+VolumeNameArray::size_type numVolumes = volNames.Length();
+VolumeNameArray::index_type i;
+for (i = 0; i < numVolumes; i++) {
+if (volNames[i].Equals(aStorageName)) {
+ds = new nsDOMDeviceStorage(GetOwner());
+nsresult rv = ds->Init(GetOwner(), mStorageType, aStorageName);
+if (NS_FAILED(rv)) {
+return nullptr;
+}
+return ds.forget();
+}
+}
+return nullptr;
+}
+// static
+void
+nsDOMDeviceStorage::GetDefaultStorageName(const nsAString& aStorageType,
+nsAString& aStorageName)
+{
+// See if the preferred volume is available.
+nsRefPtr<nsDOMDeviceStorage> ds;
+nsAdoptingString prefStorageName =
+mozilla::Preferences::GetString("device.storage.writable.name");
+if (prefStorageName) {
+aStorageName = prefStorageName;
+return;
+}
+// No preferred storage, we'll use the first one (which should be sdcard).
+VolumeNameArray volNames;
+GetOrderedVolumeNames(volNames);
+if (volNames.Length() > 0) {
+aStorageName = volNames[0];
+return;
+}
+// No volumes available, return the empty string. This is normal for
+// b2g-desktop.
+aStorageName.Truncate();
+}
+bool
+nsDOMDeviceStorage::IsAvailable()
+{
+DeviceStorageFile dsf(mStorageType, mStorageName);
+return dsf.IsAvailable();
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::Add(nsIDOMBlob *aBlob, nsIDOMDOMRequest * *_retval)
+{
+ErrorResult rv;
+nsRefPtr<DOMRequest> request = Add(aBlob, rv);
+request.forget(_retval);
+return rv.ErrorCode();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::Add(nsIDOMBlob* aBlob, ErrorResult& aRv)
+{
+if (!aBlob) {
+return nullptr;
+}
+nsCOMPtr<nsIMIMEService> mimeSvc = do_GetService(NS_MIMESERVICE_CONTRACTID);
+if (!mimeSvc) {
+aRv.Throw(NS_ERROR_FAILURE);
+return nullptr;
+}
+// if mimeType isn't set, we will not get a correct
+// extension, and AddNamed() will fail.  This will post an
+// onerror to the requestee.
+nsString mimeType;
+aBlob->GetType(mimeType);
+nsCString extension;
+mimeSvc->GetPrimaryExtension(NS_LossyConvertUTF16toASCII(mimeType),
+EmptyCString(), extension);
+// if extension is null here, we will ignore it for now.
+// AddNamed() will check the file path and fail.  This
+// will post an onerror to the requestee.
+// possible race here w/ unique filename
+char buffer[32];
+NS_MakeRandomString(buffer, ArrayLength(buffer) - 1);
+nsAutoCString path;
+path.Assign(nsDependentCString(buffer));
+path.Append(".");
+path.Append(extension);
+return AddNamed(aBlob, NS_ConvertASCIItoUTF16(path), aRv);
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::AddNamed(nsIDOMBlob *aBlob,
+const nsAString & aPath,
+nsIDOMDOMRequest * *_retval)
+{
+ErrorResult rv;
+nsRefPtr<DOMRequest> request = AddNamed(aBlob, aPath, rv);
+request.forget(_retval);
+return rv.ErrorCode();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::AddNamed(nsIDOMBlob* aBlob, const nsAString& aPath,
+ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+// if the blob is null here, bail
+if (!aBlob) {
+return nullptr;
+}
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+aRv.Throw(NS_ERROR_FAILURE);
+return nullptr;
+}
+nsCOMPtr<nsIRunnable> r;
+nsresult rv;
+if (IsFullPath(aPath)) {
+nsString storagePath;
+nsRefPtr<nsDOMDeviceStorage> ds = GetStorage(aPath, storagePath);
+if (!ds) {
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+r = new PostErrorEvent(request, POST_ERROR_EVENT_UNKNOWN);
+rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+return ds->AddNamed(aBlob, storagePath, aRv);
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName,
+aPath);
+if (!dsf->IsSafePath()) {
+r = new PostErrorEvent(request, POST_ERROR_EVENT_PERMISSION_DENIED);
+} else if (!typeChecker->Check(mStorageType, dsf->mFile) ||
+!typeChecker->Check(mStorageType, aBlob)) {
+r = new PostErrorEvent(request, POST_ERROR_EVENT_ILLEGAL_TYPE);
+} else {
+r = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_CREATE,
+win, mPrincipal, dsf, request, aBlob);
+}
+rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::Get(const nsAString& aPath, nsIDOMDOMRequest** aRetval)
+{
+ErrorResult rv;
+nsRefPtr<DOMRequest> request = Get(aPath, rv);
+request.forget(aRetval);
+return rv.ErrorCode();
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::GetEditable(const nsAString& aPath,
+nsIDOMDOMRequest** aRetval)
+{
+ErrorResult rv;
+nsRefPtr<DOMRequest> request = GetEditable(aPath, rv);
+request.forget(aRetval);
+return rv.ErrorCode();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::GetInternal(const nsAString& aPath, bool aEditable,
+ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+if (IsFullPath(aPath)) {
+nsString storagePath;
+nsRefPtr<nsDOMDeviceStorage> ds = GetStorage(aPath, storagePath);
+if (!ds) {
+nsCOMPtr<nsIRunnable> r =
+new PostErrorEvent(request, POST_ERROR_EVENT_UNKNOWN);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+ds->GetInternal(win, storagePath, request, aEditable);
+return request.forget();
+}
+GetInternal(win, aPath, request, aEditable);
+return request.forget();
+}
+void
+nsDOMDeviceStorage::GetInternal(nsPIDOMWindow *aWin,
+const nsAString& aPath,
+DOMRequest* aRequest,
+bool aEditable)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName,
+aPath);
+dsf->SetEditable(aEditable);
+nsCOMPtr<nsIRunnable> r;
+if (!dsf->IsSafePath()) {
+r = new PostErrorEvent(aRequest, POST_ERROR_EVENT_PERMISSION_DENIED);
+} else {
+r = new DeviceStorageRequest(aEditable ? DEVICE_STORAGE_REQUEST_WRITE
+: DEVICE_STORAGE_REQUEST_READ,
+aWin, mPrincipal, dsf, aRequest);
+}
+DebugOnly<nsresult> rv = NS_DispatchToCurrentThread(r);
+MOZ_ASSERT(NS_SUCCEEDED(rv));
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::Delete(const nsAString& aPath, nsIDOMDOMRequest** aRetval)
+{
+ErrorResult rv;
+nsRefPtr<DOMRequest> request = Delete(aPath, rv);
+request.forget(aRetval);
+return rv.ErrorCode();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::Delete(const nsAString& aPath, ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+if (IsFullPath(aPath)) {
+nsString storagePath;
+nsRefPtr<nsDOMDeviceStorage> ds = GetStorage(aPath, storagePath);
+if (!ds) {
+nsCOMPtr<nsIRunnable> r =
+new PostErrorEvent(request, POST_ERROR_EVENT_UNKNOWN);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+ds->DeleteInternal(win, storagePath, request);
+return request.forget();
+}
+DeleteInternal(win, aPath, request);
+return request.forget();
+}
+void
+nsDOMDeviceStorage::DeleteInternal(nsPIDOMWindow *aWin,
+const nsAString& aPath,
+DOMRequest* aRequest)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsIRunnable> r;
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName,
+aPath);
+if (!dsf->IsSafePath()) {
+r = new PostErrorEvent(aRequest, POST_ERROR_EVENT_PERMISSION_DENIED);
+} else {
+r = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_DELETE,
+aWin, mPrincipal, dsf, aRequest);
+}
+DebugOnly<nsresult> rv = NS_DispatchToCurrentThread(r);
+MOZ_ASSERT(NS_SUCCEEDED(rv));
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::FreeSpace(nsIDOMDOMRequest** aRetval)
+{
+ErrorResult rv;
+nsRefPtr<DOMRequest> request = FreeSpace(rv);
+request.forget(aRetval);
+return rv.ErrorCode();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::FreeSpace(ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_FREE_SPACE,
+win, mPrincipal, dsf, request);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::UsedSpace(nsIDOMDOMRequest** aRetval)
+{
+ErrorResult rv;
+nsRefPtr<DOMRequest> request = UsedSpace(rv);
+request.forget(aRetval);
+return rv.ErrorCode();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::UsedSpace(ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+DebugOnly<DeviceStorageUsedSpaceCache*> usedSpaceCache
+= DeviceStorageUsedSpaceCache::CreateOrGet();
+MOZ_ASSERT(usedSpaceCache);
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_USED_SPACE,
+win, mPrincipal, dsf, request);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::Available(nsIDOMDOMRequest** aRetval)
+{
+ErrorResult rv;
+nsRefPtr<DOMRequest> request = Available(rv);
+request.forget(aRetval);
+return rv.ErrorCode();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::Available(ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_AVAILABLE,
+win, mPrincipal, dsf, request);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::StorageStatus(ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_STATUS,
+win, mPrincipal, dsf, request);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::Format(ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_FORMAT,
+win, mPrincipal, dsf, request);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::Mount(ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_MOUNT,
+win, mPrincipal, dsf, request);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+already_AddRefed<DOMRequest>
+nsDOMDeviceStorage::Unmount(ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_UNMOUNT,
+win, mPrincipal, dsf, request);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+return request.forget();
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::CreateFileDescriptor(const nsAString& aPath,
+DeviceStorageFileDescriptor* aDSFileDescriptor,
+nsIDOMDOMRequest** aRequest)
+{
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(aDSFileDescriptor);
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+return NS_ERROR_UNEXPECTED;
+}
+DeviceStorageTypeChecker* typeChecker
+= DeviceStorageTypeChecker::CreateOrGet();
+if (!typeChecker) {
+return NS_ERROR_FAILURE;
+}
+nsCOMPtr<nsIRunnable> r;
+nsresult rv;
+if (IsFullPath(aPath)) {
+nsString storagePath;
+nsRefPtr<nsDOMDeviceStorage> ds = GetStorage(aPath, storagePath);
+if (!ds) {
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+r = new PostErrorEvent(request, POST_ERROR_EVENT_UNKNOWN);
+rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+return rv;
+}
+request.forget(aRequest);
+return NS_OK;
+}
+return ds->CreateFileDescriptor(storagePath, aDSFileDescriptor, aRequest);
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName,
+aPath);
+if (!dsf->IsSafePath()) {
+r = new PostErrorEvent(request, POST_ERROR_EVENT_PERMISSION_DENIED);
+} else if (!typeChecker->Check(mStorageType, dsf->mFile)) {
+r = new PostErrorEvent(request, POST_ERROR_EVENT_ILLEGAL_TYPE);
+} else {
+r = new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_CREATEFD,
+win, mPrincipal, dsf, request,
+aDSFileDescriptor);
+}
+rv = NS_DispatchToCurrentThread(r);
+if (NS_FAILED(rv)) {
+return rv;
+}
+request.forget(aRequest);
+return NS_OK;
+}
+bool
+nsDOMDeviceStorage::Default()
+{
+nsString defaultStorageName;
+GetDefaultStorageName(mStorageType, defaultStorageName);
+return mStorageName.Equals(defaultStorageName);
+}
+already_AddRefed<Promise>
+nsDOMDeviceStorage::GetRoot()
+{
+if (!mFileSystem) {
+mFileSystem = new DeviceStorageFileSystem(mStorageType, mStorageName);
+mFileSystem->Init(this);
+}
+return mozilla::dom::Directory::GetRoot(mFileSystem);
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::GetDefault(bool* aDefault)
+{
+*aDefault = Default();
+return NS_OK;
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::GetStorageName(nsAString& aStorageName)
+{
+aStorageName = mStorageName;
+return NS_OK;
+}
+already_AddRefed<DOMCursor>
+nsDOMDeviceStorage::Enumerate(const nsAString& aPath,
+const EnumerationParameters& aOptions,
+ErrorResult& aRv)
+{
+return EnumerateInternal(aPath, aOptions, false, aRv);
+}
+already_AddRefed<DOMCursor>
+nsDOMDeviceStorage::EnumerateEditable(const nsAString& aPath,
+const EnumerationParameters& aOptions,
+ErrorResult& aRv)
+{
+return EnumerateInternal(aPath, aOptions, true, aRv);
+}
+already_AddRefed<DOMCursor>
+nsDOMDeviceStorage::EnumerateInternal(const nsAString& aPath,
+const EnumerationParameters& aOptions,
+bool aEditable, ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return nullptr;
+}
+PRTime since = 0;
+if (aOptions.mSince.WasPassed() && !aOptions.mSince.Value().IsUndefined()) {
+since = PRTime(aOptions.mSince.Value().TimeStamp());
+}
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName,
+aPath,
+EmptyString());
+dsf->SetEditable(aEditable);
+nsRefPtr<nsDOMDeviceStorageCursor> cursor
+= new nsDOMDeviceStorageCursor(win, mPrincipal, dsf, since);
+nsRefPtr<DeviceStorageCursorRequest> r
+= new DeviceStorageCursorRequest(cursor);
+if (mozilla::Preferences::GetBool("device.storage.prompt.testing", false)) {
+r->Allow(JS::UndefinedHandleValue);
+return cursor.forget();
+}
+if (XRE_GetProcessType() == GeckoProcessType_Content) {
+// because owner implements nsITabChild, we can assume that it is
+// the one and only TabChild.
+TabChild* child = TabChild::GetFrom(win->GetDocShell());
+if (!child) {
+return cursor.forget();
+}
+// Retain a reference so the object isn't deleted without IPDL's knowledge.
+// Corresponding release occurs in DeallocPContentPermissionRequest.
+r->AddRef();
+nsCString type;
+aRv = DeviceStorageTypeChecker::GetPermissionForType(mStorageType, type);
+if (aRv.Failed()) {
+return nullptr;
+}
+nsTArray<PermissionRequest> permArray;
+nsTArray<nsString> emptyOptions;
+permArray.AppendElement(PermissionRequest(type,
+NS_LITERAL_CSTRING("read"),
+emptyOptions));
+child->SendPContentPermissionRequestConstructor(r,
+permArray,
+IPC::Principal(mPrincipal));
+r->Sendprompt();
+return cursor.forget();
+}
+nsCOMPtr<nsIContentPermissionPrompt> prompt
+= do_CreateInstance(NS_CONTENT_PERMISSION_PROMPT_CONTRACTID);
+if (prompt) {
+prompt->Prompt(r);
+}
+return cursor.forget();
+}
+#ifdef MOZ_WIDGET_GONK
+void
+nsDOMDeviceStorage::DispatchMountChangeEvent(nsAString& aVolumeStatus)
+{
+if (aVolumeStatus == mLastStatus) {
+// We've already sent this status, don't bother sending it again.
+return;
+}
+mLastStatus = aVolumeStatus;
+nsCOMPtr<nsIDOMEvent> event;
+NS_NewDOMDeviceStorageChangeEvent(getter_AddRefs(event), this,
+nullptr, nullptr);
+nsCOMPtr<nsIDOMDeviceStorageChangeEvent> ce = do_QueryInterface(event);
+nsresult rv = ce->InitDeviceStorageChangeEvent(NS_LITERAL_STRING("change"),
+true, false,
+mStorageName,
+aVolumeStatus);
+if (NS_FAILED(rv)) {
+return;
+}
+bool ignore;
+DispatchEvent(ce, &ignore);
+}
+#endif
+NS_IMETHODIMP
+nsDOMDeviceStorage::Observe(nsISupports *aSubject,
+const char *aTopic,
+const char16_t *aData)
+{
+MOZ_ASSERT(NS_IsMainThread());
+if (!strcmp(aTopic, "file-watcher-update")) {
+DeviceStorageFile* file = static_cast<DeviceStorageFile*>(aSubject);
+Notify(NS_ConvertUTF16toUTF8(aData).get(), file);
+return NS_OK;
+}
+if (!strcmp(aTopic, "disk-space-watcher")) {
+// 'disk-space-watcher' notifications are sent when there is a modification
+// of a file in a specific location while a low device storage situation
+// exists or after recovery of a low storage situation. For Firefox OS,
+// these notifications are specific for apps storage.
+nsRefPtr<DeviceStorageFile> file =
+new DeviceStorageFile(mStorageType, mStorageName);
+if (!strcmp(NS_ConvertUTF16toUTF8(aData).get(), "full")) {
+Notify("low-disk-space", file);
+} else if (!strcmp(NS_ConvertUTF16toUTF8(aData).get(), "free")) {
+Notify("available-disk-space", file);
+}
+return NS_OK;
+}
+#ifdef MOZ_WIDGET_GONK
+else if (!strcmp(aTopic, NS_VOLUME_STATE_CHANGED)) {
+// We invalidate the used space cache for the volume that actually changed
+// state.
+nsCOMPtr<nsIVolume> vol = do_QueryInterface(aSubject);
+if (!vol) {
+return NS_OK;
+}
+nsString volName;
+vol->GetName(volName);
+DeviceStorageUsedSpaceCache* usedSpaceCache
+= DeviceStorageUsedSpaceCache::CreateOrGet();
+MOZ_ASSERT(usedSpaceCache);
+usedSpaceCache->Invalidate(volName);
+if (!volName.Equals(mStorageName)) {
+// Not our volume - we can ignore.
+return NS_OK;
+}
+DeviceStorageFile dsf(mStorageType, mStorageName);
+nsString status;
+dsf.GetStatus(status);
+DispatchMountChangeEvent(status);
+return NS_OK;
+}
+#endif
+return NS_OK;
+}
+nsresult
+nsDOMDeviceStorage::Notify(const char* aReason, DeviceStorageFile* aFile)
+{
+if (!mAllowedToWatchFile) {
+return NS_OK;
+}
+if (!mStorageType.Equals(aFile->mStorageType) ||
+!mStorageName.Equals(aFile->mStorageName)) {
+// Ignore this
+return NS_OK;
+}
+nsCOMPtr<nsIDOMEvent> event;
+NS_NewDOMDeviceStorageChangeEvent(getter_AddRefs(event), this,
+nullptr, nullptr);
+nsCOMPtr<nsIDOMDeviceStorageChangeEvent> ce = do_QueryInterface(event);
+nsString reason;
+reason.AssignWithConversion(aReason);
+nsString fullPath;
+aFile->GetFullPath(fullPath);
+nsresult rv = ce->InitDeviceStorageChangeEvent(NS_LITERAL_STRING("change"),
+true, false, fullPath,
+reason);
+NS_ENSURE_SUCCESS(rv, rv);
+bool ignore;
+DispatchEvent(ce, &ignore);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::AddEventListener(const nsAString & aType,
+nsIDOMEventListener *aListener,
+bool aUseCapture,
+bool aWantsUntrusted,
+uint8_t aArgc)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+return NS_ERROR_UNEXPECTED;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_WATCH,
+win, mPrincipal, dsf, request, this);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return rv;
+}
+return DOMEventTargetHelper::AddEventListener(aType, aListener, aUseCapture,
+aWantsUntrusted, aArgc);
+}
+void
+nsDOMDeviceStorage::AddEventListener(const nsAString & aType,
+EventListener *aListener,
+bool aUseCapture,
+const Nullable<bool>& aWantsUntrusted,
+ErrorResult& aRv)
+{
+MOZ_ASSERT(NS_IsMainThread());
+nsCOMPtr<nsPIDOMWindow> win = GetOwner();
+if (!win) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return;
+}
+nsRefPtr<DOMRequest> request = new DOMRequest(win);
+nsRefPtr<DeviceStorageFile> dsf = new DeviceStorageFile(mStorageType,
+mStorageName);
+nsCOMPtr<nsIRunnable> r
+= new DeviceStorageRequest(DEVICE_STORAGE_REQUEST_WATCH,
+win, mPrincipal, dsf, request, this);
+nsresult rv = NS_DispatchToCurrentThread(r);
+if (NS_WARN_IF(NS_FAILED(rv))) {
+return;
+}
+DOMEventTargetHelper::AddEventListener(aType, aListener, aUseCapture,
+aWantsUntrusted, aRv);
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::AddSystemEventListener(const nsAString & aType,
+nsIDOMEventListener *aListener,
+bool aUseCapture,
+bool aWantsUntrusted,
+uint8_t aArgc)
+{
+if (!mIsWatchingFile) {
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->AddObserver(this, "file-watcher-update", false);
+mIsWatchingFile = true;
+}
+return nsDOMDeviceStorage::AddEventListener(aType, aListener, aUseCapture,
+aWantsUntrusted, aArgc);
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::RemoveEventListener(const nsAString & aType,
+nsIDOMEventListener *aListener,
+bool aUseCapture)
+{
+DOMEventTargetHelper::RemoveEventListener(aType, aListener, false);
+if (mIsWatchingFile && !HasListenersFor(nsGkAtoms::onchange)) {
+mIsWatchingFile = false;
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->RemoveObserver(this, "file-watcher-update");
+}
+return NS_OK;
+}
+void
+nsDOMDeviceStorage::RemoveEventListener(const nsAString& aType,
+EventListener* aListener,
+bool aCapture,
+ErrorResult& aRv)
+{
+DOMEventTargetHelper::RemoveEventListener(aType, aListener, aCapture, aRv);
+if (mIsWatchingFile && !HasListenersFor(nsGkAtoms::onchange)) {
+mIsWatchingFile = false;
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+obs->RemoveObserver(this, "file-watcher-update");
+}
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::RemoveSystemEventListener(const nsAString & aType,
+nsIDOMEventListener *aListener,
+bool aUseCapture)
+{
+return nsDOMDeviceStorage::RemoveEventListener(aType, aListener, aUseCapture);
+}
+NS_IMETHODIMP
+nsDOMDeviceStorage::DispatchEvent(nsIDOMEvent *aEvt,
+bool *aRetval)
+{
+return DOMEventTargetHelper::DispatchEvent(aEvt, aRetval);
+}
+EventTarget*
+nsDOMDeviceStorage::GetTargetForDOMEvent()
+{
+return DOMEventTargetHelper::GetTargetForDOMEvent();
+}
+EventTarget *
+nsDOMDeviceStorage::GetTargetForEventTargetChain()
+{
+return DOMEventTargetHelper::GetTargetForEventTargetChain();
+}
+nsresult
+nsDOMDeviceStorage::PreHandleEvent(EventChainPreVisitor& aVisitor)
+{
+return DOMEventTargetHelper::PreHandleEvent(aVisitor);
+}
+nsresult
+nsDOMDeviceStorage::WillHandleEvent(EventChainPostVisitor& aVisitor)
+{
+return DOMEventTargetHelper::WillHandleEvent(aVisitor);
+}
+nsresult
+nsDOMDeviceStorage::PostHandleEvent(EventChainPostVisitor& aVisitor)
+{
+return DOMEventTargetHelper::PostHandleEvent(aVisitor);
+}
+nsresult
+nsDOMDeviceStorage::DispatchDOMEvent(WidgetEvent* aEvent,
+nsIDOMEvent* aDOMEvent,
+nsPresContext* aPresContext,
+nsEventStatus* aEventStatus)
+{
+return DOMEventTargetHelper::DispatchDOMEvent(aEvent,
+aDOMEvent,
+aPresContext,
+aEventStatus);
+}
+EventListenerManager*
+nsDOMDeviceStorage::GetOrCreateListenerManager()
+{
+return DOMEventTargetHelper::GetOrCreateListenerManager();
+}
+EventListenerManager*
+nsDOMDeviceStorage::GetExistingListenerManager() const
+{
+return DOMEventTargetHelper::GetExistingListenerManager();
+}
+nsIScriptContext *
+nsDOMDeviceStorage::GetContextForEventHandlers(nsresult *aRv)
+{
+return DOMEventTargetHelper::GetContextForEventHandlers(aRv);
+}
+JSContext *
+nsDOMDeviceStorage::GetJSContextForEventHandlers()
+{
+return DOMEventTargetHelper::GetJSContextForEventHandlers();
+}
+NS_IMPL_EVENT_HANDLER(nsDOMDeviceStorage, change)

The Tor Browser / file comparison

comparison: dom/devicestorage/nsDeviceStorage.cpp

dom/devicestorage/nsDeviceStorage.cpp