The Tor Browser / file revision

 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */

 /* vim: set ts=2 et sw=2 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 "GetFileOrDirectoryTask.h"

 #include "js/Value.h"

 #include "mozilla/dom/Directory.h"

 #include "mozilla/dom/FileSystemBase.h"

 #include "mozilla/dom/FileSystemUtils.h"

 #include "mozilla/dom/Promise.h"

 #include "nsDOMFile.h"

 #include "nsIFile.h"

 #include "nsStringGlue.h"

 namespace mozilla {

 namespace dom {

 GetFileOrDirectoryTask::GetFileOrDirectoryTask(

   FileSystemBase* aFileSystem,

   const nsAString& aTargetPath,

   bool aDirectoryOnly)

   : FileSystemTaskBase(aFileSystem)

   , mTargetRealPath(aTargetPath)

   , mIsDirectory(aDirectoryOnly)

 {

   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");

   MOZ_ASSERT(aFileSystem);

   nsCOMPtr<nsIGlobalObject> globalObject =

     do_QueryInterface(aFileSystem->GetWindow());

   if (!globalObject) {

     return;

   }

   mPromise = new Promise(globalObject);

 }

 GetFileOrDirectoryTask::GetFileOrDirectoryTask(

   FileSystemBase* aFileSystem,

   const FileSystemGetFileOrDirectoryParams& aParam,

   FileSystemRequestParent* aParent)

   : FileSystemTaskBase(aFileSystem, aParam, aParent)

   , mIsDirectory(false)

 {

   MOZ_ASSERT(FileSystemUtils::IsParentProcess(),

              "Only call from parent process!");

   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");

   MOZ_ASSERT(aFileSystem);

   mTargetRealPath = aParam.realPath();

 }

 GetFileOrDirectoryTask::~GetFileOrDirectoryTask()

 {

   MOZ_ASSERT(!mPromise || NS_IsMainThread(),

              "mPromise should be released on main thread!");

 }

 already_AddRefed<Promise>

 GetFileOrDirectoryTask::GetPromise()

 {

   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");

   return nsRefPtr<Promise>(mPromise).forget();

 }

 FileSystemParams

 GetFileOrDirectoryTask::GetRequestParams(const nsString& aFileSystem) const

 {

   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");

   return FileSystemGetFileOrDirectoryParams(aFileSystem, mTargetRealPath);

 }

 FileSystemResponseValue

 GetFileOrDirectoryTask::GetSuccessRequestResult() const

 {

   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");

   if (mIsDirectory) {

     return FileSystemDirectoryResponse(mTargetRealPath);

   }

   BlobParent* actor = GetBlobParent(mTargetFile);

   if (!actor) {

     return FileSystemErrorResponse(NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR);

   }

   FileSystemFileResponse response;

   response.blobParent() = actor;

   return response;

 }

 void

 GetFileOrDirectoryTask::SetSuccessRequestResult(const FileSystemResponseValue& aValue)

 {

   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");

   switch (aValue.type()) {

     case FileSystemResponseValue::TFileSystemFileResponse: {

       FileSystemFileResponse r = aValue;

       BlobChild* actor = static_cast<BlobChild*>(r.blobChild());

       nsCOMPtr<nsIDOMBlob> blob = actor->GetBlob();

       mTargetFile = do_QueryInterface(blob);

       mIsDirectory = false;

       break;

     }

     case FileSystemResponseValue::TFileSystemDirectoryResponse: {

       FileSystemDirectoryResponse r = aValue;

       mTargetRealPath = r.realPath();

       mIsDirectory = true;

       break;

     }

     default: {

       NS_RUNTIMEABORT("not reached");

       break;

     }

   }

 }

 nsresult

 GetFileOrDirectoryTask::Work()

 {

   MOZ_ASSERT(FileSystemUtils::IsParentProcess(),

              "Only call from parent process!");

   MOZ_ASSERT(!NS_IsMainThread(), "Only call on worker thread!");

   if (mFileSystem->IsShutdown()) {

     return NS_ERROR_FAILURE;

   }

   // Whether we want to get the root directory.

   bool getRoot = mTargetRealPath.IsEmpty();

   nsCOMPtr<nsIFile> file = mFileSystem->GetLocalFile(mTargetRealPath);

   if (!file) {

     return NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR;

   }

   bool exists;

   nsresult rv = file->Exists(&exists);

   if (NS_WARN_IF(NS_FAILED(rv))) {

     return rv;

   }

   if (!exists) {

     if (!getRoot) {

       return NS_ERROR_DOM_FILE_NOT_FOUND_ERR;

     }

     // If the root directory doesn't exit, create it.

     rv = file->Create(nsIFile::DIRECTORY_TYPE, 0777);

     if (NS_WARN_IF(NS_FAILED(rv))) {

       return rv;

     }

   }

   // Get isDirectory.

   rv = file->IsDirectory(&mIsDirectory);

   if (NS_WARN_IF(NS_FAILED(rv))) {

     return rv;

   }

   if (mIsDirectory) {

     return NS_OK;

   }

   // Check if the root is a directory.

   if (getRoot) {

     return NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR;

   }

   bool isFile;

   // Get isFile

   rv = file->IsFile(&isFile);

   if (NS_WARN_IF(NS_FAILED(rv))) {

     return rv;

   }

   if (!isFile) {

     // Neither directory or file.

     return NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR;

   }

   if (!mFileSystem->IsSafeFile(file)) {

     return NS_ERROR_DOM_SECURITY_ERR;

   }

   mTargetFile = new nsDOMFileFile(file);

   return NS_OK;

 }

 void

 GetFileOrDirectoryTask::HandlerCallback()

 {

   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");

   if (mFileSystem->IsShutdown()) {

     mPromise = nullptr;

     return;

   }

   if (HasError()) {

     nsRefPtr<DOMError> domError = new DOMError(mFileSystem->GetWindow(),

       mErrorValue);

     mPromise->MaybeReject(domError);

     mPromise = nullptr;

     return;

   }

   if (mIsDirectory) {

     nsRefPtr<Directory> dir = new Directory(mFileSystem, mTargetRealPath);

     mPromise->MaybeResolve(dir);

     mPromise = nullptr;

     return;

   }

   mPromise->MaybeResolve(mTargetFile);

   mPromise = nullptr;

 }

 void

 GetFileOrDirectoryTask::GetPermissionAccessType(nsCString& aAccess) const

 {

   aAccess.AssignLiteral("read");

 }

 } // namespace dom

 } // namespace mozilla