The Tor Browser / file revision

 /* -*- 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