The Tor Browser: dom/file/FileHelper.cpp@ac0c01689b40 (annotated)

dom/file/FileHelper.cpp@ac0c01689b40 (annotated)

dom/file/FileHelper.cpp

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

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

dom/file/FileHelper.cpp@ac0c01689b40 (annotated)

dom/file/FileHelper.cpp