The Tor Browser: dom/devicestorage/DeviceStorageRequestParent.cpp@129ffea94266 (annotated)

dom/devicestorage/DeviceStorageRequestParent.cpp@129ffea94266 (annotated)

dom/devicestorage/DeviceStorageRequestParent.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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 "DeviceStorageRequestParent.h"
 #include "nsDOMFile.h"
 #include "nsIMIMEService.h"
 #include "nsCExternalHandlerService.h"
 #include "mozilla/unused.h"
 #include "mozilla/dom/ipc/Blob.h"
 #include "ContentParent.h"
 #include "nsProxyRelease.h"
 #include "AppProcessChecker.h"
 #include "mozilla/Preferences.h"
 #include "nsNetCID.h"
 namespace mozilla {
 namespace dom {
 namespace devicestorage {
 DeviceStorageRequestParent::DeviceStorageRequestParent(
   const DeviceStorageParams& aParams)
   : mParams(aParams)
   , mMutex("DeviceStorageRequestParent::mMutex")
   , mActorDestoryed(false)
 {
   MOZ_COUNT_CTOR(DeviceStorageRequestParent);
   DebugOnly<DeviceStorageUsedSpaceCache*> usedSpaceCache
     = DeviceStorageUsedSpaceCache::CreateOrGet();
   MOZ_ASSERT(usedSpaceCache);
 }
 void
 DeviceStorageRequestParent::Dispatch()
 {
   switch (mParams.type()) {
     case DeviceStorageParams::TDeviceStorageAddParams:
     {
       DeviceStorageAddParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName(), p.relpath());
       BlobParent* bp = static_cast<BlobParent*>(p.blobParent());
       nsCOMPtr<nsIDOMBlob> blob = bp->GetBlob();
       nsCOMPtr<nsIInputStream> stream;
       blob->GetInternalStream(getter_AddRefs(stream));
       nsRefPtr<CancelableRunnable> r = new WriteFileEvent(this, dsf, stream);
       nsCOMPtr<nsIEventTarget> target
         = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
       MOZ_ASSERT(target);
       target->Dispatch(r, NS_DISPATCH_NORMAL);
       break;
     }
     case DeviceStorageParams::TDeviceStorageCreateFdParams:
     {
       DeviceStorageCreateFdParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName(), p.relpath());
       nsRefPtr<CancelableRunnable> r = new CreateFdEvent(this, dsf);
       nsCOMPtr<nsIEventTarget> target
         = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
       MOZ_ASSERT(target);
       target->Dispatch(r, NS_DISPATCH_NORMAL);
       break;
     }
     case DeviceStorageParams::TDeviceStorageGetParams:
     {
       DeviceStorageGetParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName(),
                               p.rootDir(), p.relpath());
       nsRefPtr<CancelableRunnable> r = new ReadFileEvent(this, dsf);
       nsCOMPtr<nsIEventTarget> target
         = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
       MOZ_ASSERT(target);
       target->Dispatch(r, NS_DISPATCH_NORMAL);
       break;
     }
     case DeviceStorageParams::TDeviceStorageDeleteParams:
     {
       DeviceStorageDeleteParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName(), p.relpath());
       nsRefPtr<CancelableRunnable> r = new DeleteFileEvent(this, dsf);
       nsCOMPtr<nsIEventTarget> target
         = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
       MOZ_ASSERT(target);
       target->Dispatch(r, NS_DISPATCH_NORMAL);
       break;
     }
     case DeviceStorageParams::TDeviceStorageFreeSpaceParams:
     {
       DeviceStorageFreeSpaceParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName());
       nsRefPtr<FreeSpaceFileEvent> r = new FreeSpaceFileEvent(this, dsf);
       nsCOMPtr<nsIEventTarget> target
         = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
       MOZ_ASSERT(target);
       target->Dispatch(r, NS_DISPATCH_NORMAL);
       break;
     }
     case DeviceStorageParams::TDeviceStorageUsedSpaceParams:
     {
       DeviceStorageUsedSpaceCache* usedSpaceCache
         = DeviceStorageUsedSpaceCache::CreateOrGet();
       MOZ_ASSERT(usedSpaceCache);
       DeviceStorageUsedSpaceParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName());
       nsRefPtr<UsedSpaceFileEvent> r = new UsedSpaceFileEvent(this, dsf);
       usedSpaceCache->Dispatch(r);
       break;
     }
     case DeviceStorageParams::TDeviceStorageAvailableParams:
     {
       DeviceStorageAvailableParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName());
       nsRefPtr<PostAvailableResultEvent> r
         = new PostAvailableResultEvent(this, dsf);
       DebugOnly<nsresult> rv = NS_DispatchToMainThread(r);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
       break;
     }
     case DeviceStorageParams::TDeviceStorageStatusParams:
     {
       DeviceStorageStatusParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName());
       nsRefPtr<PostStatusResultEvent> r
         = new PostStatusResultEvent(this, dsf);
       DebugOnly<nsresult> rv = NS_DispatchToMainThread(r);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
       break;
     }
     case DeviceStorageParams::TDeviceStorageFormatParams:
     {
       DeviceStorageFormatParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName());
       nsRefPtr<PostFormatResultEvent> r
         = new PostFormatResultEvent(this, dsf);
       DebugOnly<nsresult> rv = NS_DispatchToMainThread(r);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
       break;
     }
     case DeviceStorageParams::TDeviceStorageMountParams:
     {
       DeviceStorageMountParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName());
       nsRefPtr<PostMountResultEvent> r
         = new PostMountResultEvent(this, dsf);
       DebugOnly<nsresult> rv = NS_DispatchToMainThread(r);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
       break;
     }
     case DeviceStorageParams::TDeviceStorageUnmountParams:
     {
       DeviceStorageUnmountParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf =
         new DeviceStorageFile(p.type(), p.storageName());
       nsRefPtr<PostUnmountResultEvent> r
         = new PostUnmountResultEvent(this, dsf);
       DebugOnly<nsresult> rv = NS_DispatchToMainThread(r);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
       break;
     }
     case DeviceStorageParams::TDeviceStorageEnumerationParams:
     {
       DeviceStorageEnumerationParams p = mParams;
       nsRefPtr<DeviceStorageFile> dsf
         = new DeviceStorageFile(p.type(), p.storageName(),
                                 p.rootdir(), NS_LITERAL_STRING(""));
       nsRefPtr<CancelableRunnable> r
         = new EnumerateFileEvent(this, dsf, p.since());
       nsCOMPtr<nsIEventTarget> target
         = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
       MOZ_ASSERT(target);
       target->Dispatch(r, NS_DISPATCH_NORMAL);
       break;
     }
     default:
     {
       NS_RUNTIMEABORT("not reached");
       break;
     }
   }
 }
 bool
 DeviceStorageRequestParent::EnsureRequiredPermissions(
   mozilla::dom::ContentParent* aParent)
 {
   if (mozilla::Preferences::GetBool("device.storage.testing", false)) {
     return true;
   }
   nsString type;
   DeviceStorageRequestType requestType;
   switch (mParams.type())
   {
     case DeviceStorageParams::TDeviceStorageAddParams:
     {
       DeviceStorageAddParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_CREATE;
       break;
     }
     case DeviceStorageParams::TDeviceStorageCreateFdParams:
     {
       DeviceStorageCreateFdParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_CREATEFD;
       break;
     }
     case DeviceStorageParams::TDeviceStorageGetParams:
     {
       DeviceStorageGetParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_READ;
       break;
     }
     case DeviceStorageParams::TDeviceStorageDeleteParams:
     {
       DeviceStorageDeleteParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_DELETE;
       break;
     }
     case DeviceStorageParams::TDeviceStorageFreeSpaceParams:
     {
       DeviceStorageFreeSpaceParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_FREE_SPACE;
       break;
     }
     case DeviceStorageParams::TDeviceStorageUsedSpaceParams:
     {
       DeviceStorageUsedSpaceParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_FREE_SPACE;
       break;
     }
     case DeviceStorageParams::TDeviceStorageAvailableParams:
     {
       DeviceStorageAvailableParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_AVAILABLE;
       break;
     }
     case DeviceStorageParams::TDeviceStorageStatusParams:
     {
       DeviceStorageStatusParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_STATUS;
       break;
     }
     case DeviceStorageParams::TDeviceStorageFormatParams:
     {
       DeviceStorageFormatParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_FORMAT;
       break;
     }
     case DeviceStorageParams::TDeviceStorageMountParams:
     {
       DeviceStorageMountParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_MOUNT;
       break;
     }
     case DeviceStorageParams::TDeviceStorageUnmountParams:
     {
       DeviceStorageUnmountParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_UNMOUNT;
       break;
     }
     case DeviceStorageParams::TDeviceStorageEnumerationParams:
     {
       DeviceStorageEnumerationParams p = mParams;
       type = p.type();
       requestType = DEVICE_STORAGE_REQUEST_READ;
       break;
     }
     default:
     {
       return false;
     }
   }
   // The 'apps' type is special.  We only want this exposed
   // if the caller has the "webapps-manage" permission.
   if (type.EqualsLiteral("apps")) {
     if (!AssertAppProcessPermission(aParent, "webapps-manage")) {
       return false;
     }
   }
   nsAutoCString permissionName;
   nsresult rv = DeviceStorageTypeChecker::GetPermissionForType(type,
                                                                permissionName);
   if (NS_FAILED(rv)) {
     return false;
   }
   nsCString access;
   rv = DeviceStorageTypeChecker::GetAccessForRequest(requestType, access);
   if (NS_FAILED(rv)) {
     return false;
   }
   permissionName.AppendLiteral("-");
   permissionName.Append(access);
   if (!AssertAppProcessPermission(aParent, permissionName.get())) {
     return false;
   }
   return true;
 }
 DeviceStorageRequestParent::~DeviceStorageRequestParent()
 {
   MOZ_COUNT_DTOR(DeviceStorageRequestParent);
 }
 NS_IMPL_ADDREF(DeviceStorageRequestParent)
 NS_IMPL_RELEASE(DeviceStorageRequestParent)
 void
 DeviceStorageRequestParent::ActorDestroy(ActorDestroyReason)
 {
   MutexAutoLock lock(mMutex);
   mActorDestoryed = true;
   int32_t count = mRunnables.Length();
   for (int32_t index = 0; index < count; index++) {
     mRunnables[index]->Cancel();
   }
 }
 DeviceStorageRequestParent::PostFreeSpaceResultEvent::PostFreeSpaceResultEvent(
   DeviceStorageRequestParent* aParent,
   uint64_t aFreeSpace)
   : CancelableRunnable(aParent)
   , mFreeSpace(aFreeSpace)
 {
 }
 DeviceStorageRequestParent::PostFreeSpaceResultEvent::
   ~PostFreeSpaceResultEvent() {}
 nsresult
 DeviceStorageRequestParent::PostFreeSpaceResultEvent::CancelableRun() {
   MOZ_ASSERT(NS_IsMainThread());
   FreeSpaceStorageResponse response(mFreeSpace);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostUsedSpaceResultEvent::
   PostUsedSpaceResultEvent(DeviceStorageRequestParent* aParent,
                              const nsAString& aType,
                              uint64_t aUsedSpace)
   : CancelableRunnable(aParent)
   , mType(aType)
   , mUsedSpace(aUsedSpace)
 {
 }
 DeviceStorageRequestParent::PostUsedSpaceResultEvent::
   ~PostUsedSpaceResultEvent() {}
 nsresult
 DeviceStorageRequestParent::PostUsedSpaceResultEvent::CancelableRun() {
   MOZ_ASSERT(NS_IsMainThread());
   UsedSpaceStorageResponse response(mUsedSpace);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostErrorEvent::
   PostErrorEvent(DeviceStorageRequestParent* aParent, const char* aError)
   : CancelableRunnable(aParent)
 {
   CopyASCIItoUTF16(aError, mError);
 }
 DeviceStorageRequestParent::PostErrorEvent::~PostErrorEvent() {}
 nsresult
 DeviceStorageRequestParent::PostErrorEvent::CancelableRun() {
   MOZ_ASSERT(NS_IsMainThread());
   ErrorResponse response(mError);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostSuccessEvent::
   PostSuccessEvent(DeviceStorageRequestParent* aParent)
   : CancelableRunnable(aParent)
 {
 }
 DeviceStorageRequestParent::PostSuccessEvent::~PostSuccessEvent() {}
 nsresult
 DeviceStorageRequestParent::PostSuccessEvent::CancelableRun() {
   MOZ_ASSERT(NS_IsMainThread());
   SuccessResponse response;
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostBlobSuccessEvent::
   PostBlobSuccessEvent(DeviceStorageRequestParent* aParent,
                        DeviceStorageFile* aFile,
                        uint32_t aLength,
                        nsACString& aMimeType,
                        uint64_t aLastModifiedDate)
   : CancelableRunnable(aParent)
   , mLength(aLength)
   , mLastModificationDate(aLastModifiedDate)
   , mFile(aFile)
   , mMimeType(aMimeType)
 {
 }
 DeviceStorageRequestParent::PostBlobSuccessEvent::~PostBlobSuccessEvent() {}
 nsresult
 DeviceStorageRequestParent::PostBlobSuccessEvent::CancelableRun() {
   MOZ_ASSERT(NS_IsMainThread());
   nsString mime;
   CopyASCIItoUTF16(mMimeType, mime);
   nsString fullPath;
   mFile->GetFullPath(fullPath);
   nsCOMPtr<nsIDOMBlob> blob = new nsDOMFileFile(fullPath, mime, mLength,
                                                 mFile->mFile,
                                                 mLastModificationDate);
   ContentParent* cp = static_cast<ContentParent*>(mParent->Manager());
   BlobParent* actor = cp->GetOrCreateActorForBlob(blob);
   if (!actor) {
     ErrorResponse response(NS_LITERAL_STRING(POST_ERROR_EVENT_UNKNOWN));
     unused << mParent->Send__delete__(mParent, response);
     return NS_OK;
   }
   BlobResponse response;
   response.blobParent() = actor;
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostEnumerationSuccessEvent::
   PostEnumerationSuccessEvent(DeviceStorageRequestParent* aParent,
                               const nsAString& aStorageType,
                               const nsAString& aRelPath,
                               InfallibleTArray<DeviceStorageFileValue>& aPaths)
   : CancelableRunnable(aParent)
   , mStorageType(aStorageType)
   , mRelPath(aRelPath)
   , mPaths(aPaths)
 {
 }
 DeviceStorageRequestParent::PostEnumerationSuccessEvent::
   ~PostEnumerationSuccessEvent() {}
 nsresult
 DeviceStorageRequestParent::PostEnumerationSuccessEvent::CancelableRun() {
   MOZ_ASSERT(NS_IsMainThread());
   EnumerationResponse response(mStorageType, mRelPath, mPaths);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::CreateFdEvent::
   CreateFdEvent(DeviceStorageRequestParent* aParent,
                  DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::CreateFdEvent::~CreateFdEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::CreateFdEvent::CancelableRun()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   nsCOMPtr<nsIRunnable> r;
   bool check = false;
   mFile->mFile->Exists(&check);
   if (check) {
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_FILE_EXISTS);
     return NS_DispatchToMainThread(r);
   }
   FileDescriptor fileDescriptor;
   nsresult rv = mFile->CreateFileDescriptor(fileDescriptor);
   if (NS_FAILED(rv)) {
     NS_WARNING("CreateFileDescriptor failed");
     mFile->Dump("CreateFileDescriptor failed");
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_UNKNOWN);
   }
   else {
     r = new PostFileDescriptorResultEvent(mParent, fileDescriptor);
   }
   return NS_DispatchToMainThread(r);
 }
 DeviceStorageRequestParent::WriteFileEvent::
   WriteFileEvent(DeviceStorageRequestParent* aParent,
                  DeviceStorageFile* aFile,
                  nsIInputStream* aInputStream)
   : CancelableRunnable(aParent)
   , mFile(aFile)
   , mInputStream(aInputStream)
 {
 }
 DeviceStorageRequestParent::WriteFileEvent::~WriteFileEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::WriteFileEvent::CancelableRun()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   nsCOMPtr<nsIRunnable> r;
   if (!mInputStream) {
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_UNKNOWN);
     return NS_DispatchToMainThread(r);
   }
   bool check = false;
   mFile->mFile->Exists(&check);
   if (check) {
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_FILE_EXISTS);
     return NS_DispatchToMainThread(r);
   }
   nsresult rv = mFile->Write(mInputStream);
   if (NS_FAILED(rv)) {
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_UNKNOWN);
   }
   else {
     r = new PostPathResultEvent(mParent, mFile->mPath);
   }
   return NS_DispatchToMainThread(r);
 }
 DeviceStorageRequestParent::DeleteFileEvent::
   DeleteFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::DeleteFileEvent::~DeleteFileEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::DeleteFileEvent::CancelableRun()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   mFile->Remove();
   nsCOMPtr<nsIRunnable> r;
   bool check = false;
   mFile->mFile->Exists(&check);
   if (check) {
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_UNKNOWN);
   }
   else {
     r = new PostPathResultEvent(mParent, mFile->mPath);
   }
   return NS_DispatchToMainThread(r);
 }
 DeviceStorageRequestParent::FreeSpaceFileEvent::
   FreeSpaceFileEvent(DeviceStorageRequestParent* aParent,
                      DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::FreeSpaceFileEvent::~FreeSpaceFileEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::FreeSpaceFileEvent::CancelableRun()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   int64_t freeSpace = 0;
   if (mFile) {
     mFile->GetDiskFreeSpace(&freeSpace);
   }
   nsCOMPtr<nsIRunnable> r;
   r = new PostFreeSpaceResultEvent(mParent, static_cast<uint64_t>(freeSpace));
   return NS_DispatchToMainThread(r);
 }
 DeviceStorageRequestParent::UsedSpaceFileEvent::
   UsedSpaceFileEvent(DeviceStorageRequestParent* aParent,
                      DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::UsedSpaceFileEvent::~UsedSpaceFileEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::UsedSpaceFileEvent::CancelableRun()
 {
   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 PostUsedSpaceResultEvent(mParent, mFile->mStorageType,
                                      picturesUsage);
   }
   else if (mFile->mStorageType.EqualsLiteral(DEVICESTORAGE_VIDEOS)) {
     r = new PostUsedSpaceResultEvent(mParent, mFile->mStorageType, videosUsage);
   }
   else if (mFile->mStorageType.EqualsLiteral(DEVICESTORAGE_MUSIC)) {
     r = new PostUsedSpaceResultEvent(mParent, mFile->mStorageType, musicUsage);
   } else {
     r = new PostUsedSpaceResultEvent(mParent, mFile->mStorageType, totalUsage);
   }
   return NS_DispatchToMainThread(r);
 }
 DeviceStorageRequestParent::ReadFileEvent::
   ReadFileEvent(DeviceStorageRequestParent* aParent, DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
   nsCOMPtr<nsIMIMEService> mimeService
     = do_GetService(NS_MIMESERVICE_CONTRACTID);
   if (mimeService) {
     nsresult rv = mimeService->GetTypeFromFile(mFile->mFile, mMimeType);
     if (NS_FAILED(rv)) {
       mMimeType.Truncate();
     }
   }
 }
 DeviceStorageRequestParent::ReadFileEvent::~ReadFileEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::ReadFileEvent::CancelableRun()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   nsCOMPtr<nsIRunnable> r;
   bool check = false;
   mFile->mFile->Exists(&check);
   if (!check) {
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_FILE_DOES_NOT_EXIST);
     return NS_DispatchToMainThread(r);
   }
   int64_t fileSize;
   nsresult rv = mFile->mFile->GetFileSize(&fileSize);
   if (NS_FAILED(rv)) {
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_UNKNOWN);
     return NS_DispatchToMainThread(r);
   }
   PRTime modDate;
   rv = mFile->mFile->GetLastModifiedTime(&modDate);
   if (NS_FAILED(rv)) {
     r = new PostErrorEvent(mParent, POST_ERROR_EVENT_UNKNOWN);
     return NS_DispatchToMainThread(r);
   }
   r = new PostBlobSuccessEvent(mParent, mFile, static_cast<uint64_t>(fileSize),
                                mMimeType, modDate);
   return NS_DispatchToMainThread(r);
 }
 DeviceStorageRequestParent::EnumerateFileEvent::
   EnumerateFileEvent(DeviceStorageRequestParent* aParent,
                      DeviceStorageFile* aFile,
                      uint64_t aSince)
   : CancelableRunnable(aParent)
   , mFile(aFile)
   , mSince(aSince)
 {
 }
 DeviceStorageRequestParent::EnumerateFileEvent::~EnumerateFileEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::EnumerateFileEvent::CancelableRun()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   nsCOMPtr<nsIRunnable> r;
   if (mFile->mFile) {
     bool check = false;
     mFile->mFile->Exists(&check);
     if (!check) {
       r = new PostErrorEvent(mParent, POST_ERROR_EVENT_FILE_DOES_NOT_EXIST);
       return NS_DispatchToMainThread(r);
     }
   }
   nsTArray<nsRefPtr<DeviceStorageFile> > files;
   mFile->CollectFiles(files, mSince);
   InfallibleTArray<DeviceStorageFileValue> values;
   uint32_t count = files.Length();
   for (uint32_t i = 0; i < count; i++) {
     DeviceStorageFileValue dsvf(files[i]->mStorageName, files[i]->mPath);
     values.AppendElement(dsvf);
   }
   r = new PostEnumerationSuccessEvent(mParent, mFile->mStorageType,
                                       mFile->mRootDir, values);
   return NS_DispatchToMainThread(r);
 }
 DeviceStorageRequestParent::PostPathResultEvent::
   PostPathResultEvent(DeviceStorageRequestParent* aParent,
                       const nsAString& aPath)
   : CancelableRunnable(aParent)
   , mPath(aPath)
 {
 }
 DeviceStorageRequestParent::PostPathResultEvent::~PostPathResultEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::PostPathResultEvent::CancelableRun()
 {
   MOZ_ASSERT(NS_IsMainThread());
   SuccessResponse response;
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostFileDescriptorResultEvent::
   PostFileDescriptorResultEvent(DeviceStorageRequestParent* aParent,
                                 const FileDescriptor& aFileDescriptor)
   : CancelableRunnable(aParent)
   , mFileDescriptor(aFileDescriptor)
 {
 }
 DeviceStorageRequestParent::PostFileDescriptorResultEvent::
   ~PostFileDescriptorResultEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::PostFileDescriptorResultEvent::CancelableRun()
 {
   MOZ_ASSERT(NS_IsMainThread());
   FileDescriptorResponse response(mFileDescriptor);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostAvailableResultEvent::
   PostAvailableResultEvent(DeviceStorageRequestParent* aParent,
                            DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::PostAvailableResultEvent::
   ~PostAvailableResultEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::PostAvailableResultEvent::CancelableRun()
 {
   MOZ_ASSERT(NS_IsMainThread());
   nsString state = NS_LITERAL_STRING("unavailable");
   if (mFile) {
     mFile->GetStatus(state);
   }
   AvailableStorageResponse response(state);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostStatusResultEvent::
   PostStatusResultEvent(DeviceStorageRequestParent* aParent,
                            DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::PostStatusResultEvent::
   ~PostStatusResultEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::PostStatusResultEvent::CancelableRun()
 {
   MOZ_ASSERT(NS_IsMainThread());
   nsString state = NS_LITERAL_STRING("undefined");
   if (mFile) {
     mFile->GetStorageStatus(state);
   }
   StorageStatusResponse response(state);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostFormatResultEvent::
   PostFormatResultEvent(DeviceStorageRequestParent* aParent,
                            DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::PostFormatResultEvent::
   ~PostFormatResultEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::PostFormatResultEvent::CancelableRun()
 {
   MOZ_ASSERT(NS_IsMainThread());
   nsString state = NS_LITERAL_STRING("unavailable");
   if (mFile) {
     mFile->DoFormat(state);
   }
   FormatStorageResponse response(state);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostMountResultEvent::
   PostMountResultEvent(DeviceStorageRequestParent* aParent,
                            DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::PostMountResultEvent::
   ~PostMountResultEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::PostMountResultEvent::CancelableRun()
 {
   MOZ_ASSERT(NS_IsMainThread());
   nsString state = NS_LITERAL_STRING("unavailable");
   if (mFile) {
     mFile->DoMount(state);
   }
   MountStorageResponse response(state);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 DeviceStorageRequestParent::PostUnmountResultEvent::
   PostUnmountResultEvent(DeviceStorageRequestParent* aParent,
                            DeviceStorageFile* aFile)
   : CancelableRunnable(aParent)
   , mFile(aFile)
 {
 }
 DeviceStorageRequestParent::PostUnmountResultEvent::
   ~PostUnmountResultEvent()
 {
 }
 nsresult
 DeviceStorageRequestParent::PostUnmountResultEvent::CancelableRun()
 {
   MOZ_ASSERT(NS_IsMainThread());
   nsString state = NS_LITERAL_STRING("unavailable");
   if (mFile) {
     mFile->DoUnmount(state);
   }
   UnmountStorageResponse response(state);
   unused << mParent->Send__delete__(mParent, response);
   return NS_OK;
 }
 } // namespace devicestorage
 } // namespace dom
 } // namespace mozilla

The Tor Browser / annotate

dom/devicestorage/DeviceStorageRequestParent.cpp@129ffea94266 (annotated)

dom/devicestorage/DeviceStorageRequestParent.cpp