The Tor Browser: comparison dom/file/FileHelper.cpp

--1:000000000000
+:918fa8e942dc
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "FileHelper.h"
+#include "nsIFileStorage.h"
+#include "nsError.h"
+#include "nsProxyRelease.h"
+#include "FileHandle.h"
+#include "FileRequest.h"
+#include "FileService.h"
+#include "nsIRequest.h"
+#include "nsThreadUtils.h"
+USING_FILE_NAMESPACE
+namespace {
+LockedFile* gCurrentLockedFile = nullptr;
+} // anonymous namespace
+FileHelper::FileHelper(LockedFile* aLockedFile,
+FileRequest* aFileRequest)
+: mFileStorage(aLockedFile->mFileHandle->mFileStorage),
+mLockedFile(aLockedFile),
+mFileRequest(aFileRequest),
+mResultCode(NS_OK),
+mFinished(false)
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+}
+FileHelper::~FileHelper()
+{
+NS_ASSERTION(!mFileStorage && !mLockedFile && !mFileRequest && !mListener &&
+!mRequest, "Should have cleared this!");
+}
+NS_IMPL_ISUPPORTS(FileHelper, nsIRequestObserver)
+nsresult
+FileHelper::Enqueue()
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+FileService* service = FileService::GetOrCreate();
+NS_ENSURE_TRUE(service, NS_ERROR_FAILURE);
+nsresult rv = service->Enqueue(mLockedFile, this);
+NS_ENSURE_SUCCESS(rv, rv);
+if (mLockedFile) {
+mLockedFile->OnNewRequest();
+}
+return NS_OK;
+}
+nsresult
+FileHelper::AsyncRun(FileHelperListener* aListener)
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+// Assign the listener early, so we can use it synchronously if the code
+// below fails.
+mListener = aListener;
+nsresult rv;
+nsCOMPtr<nsISupports> stream;
+if (mLockedFile->mRequestMode == LockedFile::PARALLEL) {
+rv = mLockedFile->CreateParallelStream(getter_AddRefs(stream));
+}
+else {
+rv = mLockedFile->GetOrCreateStream(getter_AddRefs(stream));
+}
+if (NS_SUCCEEDED(rv)) {
+NS_ASSERTION(stream, "This should never be null!");
+rv = DoAsyncRun(stream);
+}
+if (NS_FAILED(rv)) {
+mResultCode = NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR;
+Finish();
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+FileHelper::OnStartRequest(nsIRequest* aRequest, nsISupports* aCtxt)
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+return NS_OK;
+}
+NS_IMETHODIMP
+FileHelper::OnStopRequest(nsIRequest* aRequest, nsISupports* aCtxt,
+nsresult aStatus)
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+if (NS_FAILED(aStatus)) {
+if (aStatus == NS_ERROR_FILE_NO_DEVICE_SPACE) {
+mResultCode = NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR;
+}
+else {
+mResultCode = NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR;
+}
+}
+Finish();
+return NS_OK;
+}
+void
+FileHelper::OnStreamProgress(uint64_t aProgress, uint64_t aProgressMax)
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+if (mLockedFile->IsAborted()) {
+NS_ASSERTION(mRequest, "Should have a request!\n");
+nsresult rv = mRequest->Cancel(NS_BINDING_ABORTED);
+if (NS_FAILED(rv)) {
+NS_WARNING("Failed to cancel the request!");
+}
+return;
+}
+if (mFileRequest) {
+mFileRequest->OnProgress(aProgress, aProgressMax);
+}
+}
+// static
+LockedFile*
+FileHelper::GetCurrentLockedFile()
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+return gCurrentLockedFile;
+}
+nsresult
+FileHelper::GetSuccessResult(JSContext* aCx,
+JS::MutableHandle<JS::Value> aVal)
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+aVal.setUndefined();
+return NS_OK;
+}
+void
+FileHelper::ReleaseObjects()
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+mFileStorage = nullptr;
+mLockedFile = nullptr;
+mFileRequest = nullptr;
+mListener = nullptr;
+mRequest = nullptr;
+}
+void
+FileHelper::Finish()
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+if (mFinished) {
+return;
+}
+mFinished = true;
+if (mLockedFile->IsAborted()) {
+// Always fire a "error" event with ABORT_ERR if the transaction was
+// aborted, even if the request succeeded or failed with another error.
+mResultCode = NS_ERROR_DOM_FILEHANDLE_ABORT_ERR;
+}
+LockedFile* oldLockedFile = gCurrentLockedFile;
+gCurrentLockedFile = mLockedFile;
+if (mFileRequest) {
+nsresult rv = mFileRequest->NotifyHelperCompleted(this);
+if (NS_SUCCEEDED(mResultCode) && NS_FAILED(rv)) {
+mResultCode = rv;
+}
+}
+NS_ASSERTION(gCurrentLockedFile == mLockedFile, "Should be unchanged!");
+gCurrentLockedFile = oldLockedFile;
+mLockedFile->OnRequestFinished();
+mListener->OnFileHelperComplete(this);
+ReleaseObjects();
+NS_ASSERTION(!(mFileStorage || mLockedFile || mFileRequest || mListener ||
+mRequest), "Subclass didn't call FileHelper::ReleaseObjects!");
+}
+void
+FileHelper::OnStreamClose()
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+Finish();
+}
+void
+FileHelper::OnStreamDestroy()
+{
+NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+Finish();
+}

The Tor Browser / file comparison

comparison: dom/file/FileHelper.cpp

dom/file/FileHelper.cpp