dom/filesystem/RemoveTask.cpp

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "RemoveTask.h"
   8
   9 #include "DOMError.h"
  10 #include "mozilla/dom/FileSystemBase.h"
  11 #include "mozilla/dom/FileSystemUtils.h"
  12 #include "mozilla/dom/Promise.h"
  13 #include "nsDOMFile.h"
  14 #include "nsIFile.h"
  15 #include "nsStringGlue.h"
  16
  17 namespace mozilla {
  18 namespace dom {
  19
  20 RemoveTask::RemoveTask(FileSystemBase* aFileSystem,
  21                        const nsAString& aDirPath,
  22                        DOMFileImpl* aTargetFile,
  23                        const nsAString& aTargetPath,
  24                        bool aRecursive,
  25                        ErrorResult& aRv)
  26   : FileSystemTaskBase(aFileSystem)
  27   , mDirRealPath(aDirPath)
  28   , mTargetFileImpl(aTargetFile)
  29   , mTargetRealPath(aTargetPath)
  30   , mRecursive(aRecursive)
  31   , mReturnValue(false)
  32 {
  33   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
  34   MOZ_ASSERT(aFileSystem);
  35   nsCOMPtr<nsIGlobalObject> globalObject =
  36     do_QueryInterface(aFileSystem->GetWindow());
  37   if (!globalObject) {
  38     return;
  39   }
  40   mPromise = Promise::Create(globalObject, aRv);
  41 }
  42
  43 RemoveTask::RemoveTask(FileSystemBase* aFileSystem,
  44                        const FileSystemRemoveParams& aParam,
  45                        FileSystemRequestParent* aParent)
  46   : FileSystemTaskBase(aFileSystem, aParam, aParent)
  47   , mRecursive(false)
  48   , mReturnValue(false)
  49 {
  50   MOZ_ASSERT(FileSystemUtils::IsParentProcess(),
  51              "Only call from parent process!");
  52   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
  53   MOZ_ASSERT(aFileSystem);
  54
  55   mDirRealPath = aParam.directory();
  56
  57   mRecursive = aParam.recursive();
  58
  59   const FileSystemPathOrFileValue& target = aParam.target();
  60
  61   if (target.type() == FileSystemPathOrFileValue::TnsString) {
  62     mTargetRealPath = target;
  63     return;
  64   }
  65
  66   BlobParent* bp = static_cast<BlobParent*>(static_cast<PBlobParent*>(target));
  67   nsCOMPtr<nsIDOMBlob> blob = bp->GetBlob();
  68   MOZ_ASSERT(blob);
  69   mTargetFileImpl = static_cast<DOMFile*>(blob.get())->Impl();
  70 }
  71
  72 RemoveTask::~RemoveTask()
  73 {
  74   MOZ_ASSERT(!mPromise || NS_IsMainThread(),
  75              "mPromise should be released on main thread!");
  76 }
  77
  78 already_AddRefed<Promise>
  79 RemoveTask::GetPromise()
  80 {
  81   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
  82   return nsRefPtr<Promise>(mPromise).forget();
  83 }
  84
  85 FileSystemParams
  86 RemoveTask::GetRequestParams(const nsString& aFileSystem) const
  87 {
  88   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
  89   FileSystemRemoveParams param;
  90   param.filesystem() = aFileSystem;
  91   param.directory() = mDirRealPath;
  92   param.recursive() = mRecursive;
  93   if (mTargetFileImpl) {
  94     nsRefPtr<DOMFile> file = new DOMFile(mTargetFileImpl);
  95     BlobChild* actor
  96       = ContentChild::GetSingleton()->GetOrCreateActorForBlob(file);
  97     if (actor) {
  98       param.target() = actor;
  99     }
 100   } else {
 101     param.target() = mTargetRealPath;
 102   }
 103   return param;
 104 }
 105
 106 FileSystemResponseValue
 107 RemoveTask::GetSuccessRequestResult() const
 108 {
 109   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
 110   return FileSystemBooleanResponse(mReturnValue);
 111 }
 112
 113 void
 114 RemoveTask::SetSuccessRequestResult(const FileSystemResponseValue& aValue)
 115 {
 116   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
 117   FileSystemBooleanResponse r = aValue;
 118   mReturnValue = r.success();
 119 }
 120
 121 nsresult
 122 RemoveTask::Work()
 123 {
 124   MOZ_ASSERT(FileSystemUtils::IsParentProcess(),
 125              "Only call from parent process!");
 126   MOZ_ASSERT(!NS_IsMainThread(), "Only call on worker thread!");
 127
 128   if (mFileSystem->IsShutdown()) {
 129     return NS_ERROR_FAILURE;
 130   }
 131
 132   // Get the DOM path if a DOMFile is passed as the target.
 133   if (mTargetFileImpl) {
 134     if (!mFileSystem->GetRealPath(mTargetFileImpl, mTargetRealPath)) {
 135       return NS_ERROR_DOM_SECURITY_ERR;
 136     }
 137     if (!FileSystemUtils::IsDescendantPath(mDirRealPath, mTargetRealPath)) {
 138       return NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR;
 139     }
 140   }
 141
 142   nsCOMPtr<nsIFile> file = mFileSystem->GetLocalFile(mTargetRealPath);
 143   if (!file) {
 144     return NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR;
 145   }
 146
 147   bool exists = false;
 148   nsresult rv = file->Exists(&exists);
 149   if (NS_WARN_IF(NS_FAILED(rv))) {
 150     return rv;
 151   }
 152
 153   if (!exists) {
 154     mReturnValue = false;
 155     return NS_OK;
 156   }
 157
 158   bool isFile = false;
 159   rv = file->IsFile(&isFile);
 160   if (NS_WARN_IF(NS_FAILED(rv))) {
 161     return rv;
 162   }
 163
 164   if (isFile && !mFileSystem->IsSafeFile(file)) {
 165     return NS_ERROR_DOM_SECURITY_ERR;
 166   }
 167
 168   rv = file->Remove(mRecursive);
 169   if (NS_WARN_IF(NS_FAILED(rv))) {
 170     return rv;
 171   }
 172
 173   mReturnValue = true;
 174
 175   return NS_OK;
 176 }
 177
 178 void
 179 RemoveTask::HandlerCallback()
 180 {
 181   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
 182   if (mFileSystem->IsShutdown()) {
 183     mPromise = nullptr;
 184     return;
 185   }
 186
 187   if (HasError()) {
 188     nsRefPtr<DOMError> domError = new DOMError(mFileSystem->GetWindow(),
 189       mErrorValue);
 190     mPromise->MaybeRejectBrokenly(domError);
 191     mPromise = nullptr;
 192     return;
 193   }
 194
 195   mPromise->MaybeResolve(mReturnValue);
 196   mPromise = nullptr;
 197 }
 198
 199 void
 200 RemoveTask::GetPermissionAccessType(nsCString& aAccess) const
 201 {
 202   aAccess.AssignLiteral("write");
 203 }
 204
 205 } // namespace dom
 206 } // namespace mozilla