The Tor Browser / file comparison
comparison: dom/filesystem/FileSystemTaskBase.cpp
dom/filesystem/FileSystemTaskBase.cpp
- changeset 2
- 7e26c7da4463
equal
deleted
inserted
replaced
| -1:000000000000 | 0:e4d5c2591aad |
|---|---|
| 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 "mozilla/dom/FileSystemTaskBase.h" | |
| 8 | |
| 9 #include "nsNetUtil.h" // Stream transport service. | |
| 10 #include "mozilla/dom/ContentChild.h" | |
| 11 #include "mozilla/dom/FileSystemBase.h" | |
| 12 #include "mozilla/dom/FileSystemRequestParent.h" | |
| 13 #include "mozilla/dom/FileSystemUtils.h" | |
| 14 #include "mozilla/dom/Promise.h" | |
| 15 #include "mozilla/dom/PContent.h" | |
| 16 #include "mozilla/unused.h" | |
| 17 #include "nsDOMFile.h" | |
| 18 | |
| 19 namespace mozilla { | |
| 20 namespace dom { | |
| 21 | |
| 22 FileSystemTaskBase::FileSystemTaskBase(FileSystemBase* aFileSystem) | |
| 23 : mErrorValue(NS_OK) | |
| 24 , mFileSystem(aFileSystem) | |
| 25 { | |
| 26 MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!"); | |
| 27 MOZ_ASSERT(aFileSystem, "aFileSystem should not be null."); | |
| 28 } | |
| 29 | |
| 30 FileSystemTaskBase::FileSystemTaskBase(FileSystemBase* aFileSystem, | |
| 31 const FileSystemParams& aParam, | |
| 32 FileSystemRequestParent* aParent) | |
| 33 : mErrorValue(NS_OK) | |
| 34 , mFileSystem(aFileSystem) | |
| 35 , mRequestParent(aParent) | |
| 36 { | |
| 37 MOZ_ASSERT(FileSystemUtils::IsParentProcess(), | |
| 38 "Only call from parent process!"); | |
| 39 MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!"); | |
| 40 MOZ_ASSERT(aFileSystem, "aFileSystem should not be null."); | |
| 41 } | |
| 42 | |
| 43 FileSystemTaskBase::~FileSystemTaskBase() | |
| 44 { | |
| 45 } | |
| 46 | |
| 47 FileSystemBase* | |
| 48 FileSystemTaskBase::GetFileSystem() const | |
| 49 { | |
| 50 return mFileSystem.get(); | |
| 51 } | |
| 52 | |
| 53 void | |
| 54 FileSystemTaskBase::Start() | |
| 55 { | |
| 56 MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!"); | |
| 57 | |
| 58 if (HasError()) { | |
| 59 NS_DispatchToMainThread(this); | |
| 60 return; | |
| 61 } | |
| 62 | |
| 63 if (FileSystemUtils::IsParentProcess()) { | |
| 64 // Run in parent process. | |
| 65 // Start worker thread. | |
| 66 nsCOMPtr<nsIEventTarget> target | |
| 67 = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); | |
| 68 NS_ASSERTION(target, "Must have stream transport service."); | |
| 69 target->Dispatch(this, NS_DISPATCH_NORMAL); | |
| 70 return; | |
| 71 } | |
| 72 | |
| 73 // Run in child process. | |
| 74 if (mFileSystem->IsShutdown()) { | |
| 75 return; | |
| 76 } | |
| 77 | |
| 78 // Retain a reference so the task object isn't deleted without IPDL's | |
| 79 // knowledge. The reference will be released by | |
| 80 // mozilla::dom::ContentChild::DeallocPFileSystemRequestChild. | |
| 81 NS_ADDREF_THIS(); | |
| 82 ContentChild::GetSingleton()->SendPFileSystemRequestConstructor(this, | |
| 83 GetRequestParams(mFileSystem->ToString())); | |
| 84 } | |
| 85 | |
| 86 NS_IMETHODIMP | |
| 87 FileSystemTaskBase::Run() | |
| 88 { | |
| 89 if (!NS_IsMainThread()) { | |
| 90 // Run worker thread tasks | |
| 91 nsresult rv = Work(); | |
| 92 if (NS_FAILED(rv)) { | |
| 93 SetError(rv); | |
| 94 } | |
| 95 // Dispatch itself to main thread | |
| 96 NS_DispatchToMainThread(this); | |
| 97 return NS_OK; | |
| 98 } | |
| 99 | |
| 100 // Run main thread tasks | |
| 101 HandleResult(); | |
| 102 return NS_OK; | |
| 103 } | |
| 104 | |
| 105 void | |
| 106 FileSystemTaskBase::HandleResult() | |
| 107 { | |
| 108 MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!"); | |
| 109 if (mFileSystem->IsShutdown()) { | |
| 110 return; | |
| 111 } | |
| 112 if (mRequestParent && mRequestParent->IsRunning()) { | |
| 113 unused << mRequestParent->Send__delete__(mRequestParent, | |
| 114 GetRequestResult()); | |
| 115 } else { | |
| 116 HandlerCallback(); | |
| 117 } | |
| 118 } | |
| 119 | |
| 120 FileSystemResponseValue | |
| 121 FileSystemTaskBase::GetRequestResult() const | |
| 122 { | |
| 123 MOZ_ASSERT(FileSystemUtils::IsParentProcess(), | |
| 124 "Only call from parent process!"); | |
| 125 MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!"); | |
| 126 if (HasError()) { | |
| 127 return FileSystemErrorResponse(mErrorValue); | |
| 128 } else { | |
| 129 return GetSuccessRequestResult(); | |
| 130 } | |
| 131 } | |
| 132 | |
| 133 void | |
| 134 FileSystemTaskBase::SetRequestResult(const FileSystemResponseValue& aValue) | |
| 135 { | |
| 136 MOZ_ASSERT(!FileSystemUtils::IsParentProcess(), | |
| 137 "Only call from child process!"); | |
| 138 MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!"); | |
| 139 if (aValue.type() == FileSystemResponseValue::TFileSystemErrorResponse) { | |
| 140 FileSystemErrorResponse r = aValue; | |
| 141 mErrorValue = r.error(); | |
| 142 } else { | |
| 143 SetSuccessRequestResult(aValue); | |
| 144 } | |
| 145 } | |
| 146 | |
| 147 bool | |
| 148 FileSystemTaskBase::Recv__delete__(const FileSystemResponseValue& aValue) | |
| 149 { | |
| 150 SetRequestResult(aValue); | |
| 151 HandlerCallback(); | |
| 152 return true; | |
| 153 } | |
| 154 | |
| 155 BlobParent* | |
| 156 FileSystemTaskBase::GetBlobParent(nsIDOMFile* aFile) const | |
| 157 { | |
| 158 MOZ_ASSERT(FileSystemUtils::IsParentProcess(), | |
| 159 "Only call from parent process!"); | |
| 160 MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!"); | |
| 161 MOZ_ASSERT(aFile); | |
| 162 | |
| 163 // Load the lazy dom file data from the parent before sending to the child. | |
| 164 nsString mimeType; | |
| 165 aFile->GetType(mimeType); | |
| 166 uint64_t fileSize; | |
| 167 aFile->GetSize(&fileSize); | |
| 168 uint64_t lastModifiedDate; | |
| 169 aFile->GetMozLastModifiedDate(&lastModifiedDate); | |
| 170 | |
| 171 ContentParent* cp = static_cast<ContentParent*>(mRequestParent->Manager()); | |
| 172 return cp->GetOrCreateActorForBlob(aFile); | |
| 173 } | |
| 174 | |
| 175 void | |
| 176 FileSystemTaskBase::SetError(const nsresult& aErrorValue) | |
| 177 { | |
| 178 uint16_t module = NS_ERROR_GET_MODULE(aErrorValue); | |
| 179 if (module == NS_ERROR_MODULE_DOM_FILESYSTEM || | |
| 180 module == NS_ERROR_MODULE_DOM_FILE || | |
| 181 module == NS_ERROR_MODULE_DOM) { | |
| 182 mErrorValue = aErrorValue; | |
| 183 return; | |
| 184 } | |
| 185 | |
| 186 switch (aErrorValue) { | |
| 187 case NS_OK: | |
| 188 mErrorValue = NS_OK; | |
| 189 return; | |
| 190 | |
| 191 case NS_ERROR_FILE_INVALID_PATH: | |
| 192 case NS_ERROR_FILE_UNRECOGNIZED_PATH: | |
| 193 mErrorValue = NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR; | |
| 194 return; | |
| 195 | |
| 196 case NS_ERROR_FILE_DESTINATION_NOT_DIR: | |
| 197 mErrorValue = NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR; | |
| 198 return; | |
| 199 | |
| 200 case NS_ERROR_FILE_ACCESS_DENIED: | |
| 201 case NS_ERROR_FILE_DIR_NOT_EMPTY: | |
| 202 mErrorValue = NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR; | |
| 203 return; | |
| 204 | |
| 205 case NS_ERROR_FILE_TARGET_DOES_NOT_EXIST: | |
| 206 case NS_ERROR_NOT_AVAILABLE: | |
| 207 mErrorValue = NS_ERROR_DOM_FILE_NOT_FOUND_ERR; | |
| 208 return; | |
| 209 | |
| 210 case NS_ERROR_FILE_ALREADY_EXISTS: | |
| 211 mErrorValue = NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR; | |
| 212 return; | |
| 213 | |
| 214 case NS_ERROR_FILE_NOT_DIRECTORY: | |
| 215 mErrorValue = NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR; | |
| 216 return; | |
| 217 | |
| 218 case NS_ERROR_UNEXPECTED: | |
| 219 default: | |
| 220 mErrorValue = NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR; | |
| 221 return; | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 } // namespace dom | |
| 226 } // namespace mozilla |
