import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

dom/base/FileReader.cpp

@@ -0,0 +1,790 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=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 "FileReader.h"
+
+#include "nsIEventTarget.h"
+#include "nsIGlobalObject.h"
+#include "nsITimer.h"
+#include "nsITransport.h"
+#include "nsIStreamTransportService.h"
+
+#include "mozilla/Base64.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/dom/DOMError.h"
+#include "mozilla/dom/EncodingUtils.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FileReaderBinding.h"
+#include "mozilla/dom/ProgressEvent.h"
+#include "nsContentUtils.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsDOMJSUtils.h"
+#include "nsError.h"
+#include "nsNetCID.h"
+#include "nsNetUtil.h"
+#include "xpcpublic.h"
+
+#include "WorkerPrivate.h"
+#include "WorkerScope.h"
+
+namespace mozilla {
+namespace dom {
+
+using namespace workers;
+
+#define ABORT_STR "abort"
+#define LOAD_STR "load"
+#define LOADSTART_STR "loadstart"
+#define LOADEND_STR "loadend"
+#define ERROR_STR "error"
+#define PROGRESS_STR "progress"
+
+const uint64_t kUnknownSize = uint64_t(-1);
+
+static NS_DEFINE_CID(kStreamTransportServiceCID, NS_STREAMTRANSPORTSERVICE_CID);
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(FileReader)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(FileReader,
+                                                  DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBlob)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mProgressNotifier)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mError)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(FileReader,
+                                                DOMEventTargetHelper)
+  tmp->Shutdown();
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBlob)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mProgressNotifier)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mError)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(FileReader,
+                                               DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mResultArrayBuffer)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(FileReader)
+  NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
+  NS_INTERFACE_MAP_ENTRY(nsIInputStreamCallback)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+NS_IMPL_ADDREF_INHERITED(FileReader, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(FileReader, DOMEventTargetHelper)
+
+class MOZ_RAII FileReaderDecreaseBusyCounter
+{
+  RefPtr<FileReader> mFileReader;
+public:
+  explicit FileReaderDecreaseBusyCounter(FileReader* aFileReader)
+    : mFileReader(aFileReader)
+  {}
+
+  ~FileReaderDecreaseBusyCounter()
+  {
+    mFileReader->DecreaseBusyCounter();
+  }
+};
+
+void
+FileReader::RootResultArrayBuffer()
+{
+  mozilla::HoldJSObjects(this);
+}
+
+//FileReader constructors/initializers
+
+FileReader::FileReader(nsIGlobalObject* aGlobal,
+                       WorkerPrivate* aWorkerPrivate)
+  : DOMEventTargetHelper(aGlobal)
+  , mFileData(nullptr)
+  , mDataLen(0)
+  , mDataFormat(FILE_AS_BINARY)
+  , mResultArrayBuffer(nullptr)
+  , mProgressEventWasDelayed(false)
+  , mTimerIsActive(false)
+  , mReadyState(EMPTY)
+  , mTotal(0)
+  , mTransferred(0)
+  , mTarget(do_GetCurrentThread())
+  , mBusyCount(0)
+  , mWorkerPrivate(aWorkerPrivate)
+{
+  MOZ_ASSERT(aGlobal);
+  MOZ_ASSERT(NS_IsMainThread() == !mWorkerPrivate);
+  SetDOMStringToNull(mResult);
+}
+
+FileReader::~FileReader()
+{
+  Shutdown();
+  DropJSObjects(this);
+}
+
+/* static */ already_AddRefed<FileReader>
+FileReader::Constructor(const GlobalObject& aGlobal, ErrorResult& aRv)
+{
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+  WorkerPrivate* workerPrivate = nullptr;
+
+  if (!NS_IsMainThread()) {
+    JSContext* cx = aGlobal.Context();
+    workerPrivate = GetWorkerPrivateFromContext(cx);
+    MOZ_ASSERT(workerPrivate);
+  }
+
+  RefPtr<FileReader> fileReader = new FileReader(global, workerPrivate);
+
+  return fileReader.forget();
+}
+
+// nsIInterfaceRequestor
+
+NS_IMETHODIMP
+FileReader::GetInterface(const nsIID & aIID, void **aResult)
+{
+  return QueryInterface(aIID, aResult);
+}
+
+void
+FileReader::GetResult(JSContext* aCx,
+                      JS::MutableHandle<JS::Value> aResult,
+                      ErrorResult& aRv)
+{
+  JS::Rooted<JS::Value> result(aCx);
+
+  if (mDataFormat == FILE_AS_ARRAYBUFFER) {
+    if (mReadyState == DONE && mResultArrayBuffer) {
+      result.setObject(*mResultArrayBuffer);
+    } else {
+      result.setNull();
+    }
+
+    if (!JS_WrapValue(aCx, &result)) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return;
+    }
+
+    aResult.set(result);
+    return;
+  }
+
+  nsString tmpResult = mResult;
+  if (!xpc::StringToJsval(aCx, tmpResult, aResult)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+}
+
+static nsresult
+ReadFuncBinaryString(nsIInputStream* in,
+                     void* closure,
+                     const char* fromRawSegment,
+                     uint32_t toOffset,
+                     uint32_t count,
+                     uint32_t *writeCount)
+{
+  char16_t* dest = static_cast<char16_t*>(closure) + toOffset;
+  char16_t* end = dest + count;
+  const unsigned char* source = (const unsigned char*)fromRawSegment;
+  while (dest != end) {
+    *dest = *source;
+    ++dest;
+    ++source;
+  }
+  *writeCount = count;
+
+  return NS_OK;
+}
+
+void
+FileReader::OnLoadEndArrayBuffer()
+{
+  AutoJSAPI jsapi;
+  if (!jsapi.Init(GetParentObject())) {
+    FreeDataAndDispatchError(NS_ERROR_FAILURE);
+    return;
+  }
+
+  RootResultArrayBuffer();
+
+  JSContext* cx = jsapi.cx();
+
+  mResultArrayBuffer = JS_NewArrayBufferWithContents(cx, mDataLen, mFileData);
+  if (mResultArrayBuffer) {
+    mFileData = nullptr; // Transfer ownership
+    FreeDataAndDispatchSuccess();
+    return;
+  }
+
+  // Let's handle the error status.
+
+  JS::Rooted<JS::Value> exceptionValue(cx);
+  if (!JS_GetPendingException(cx, &exceptionValue) ||
+      // This should not really happen, exception should always be an object.
+      !exceptionValue.isObject()) {
+    JS_ClearPendingException(jsapi.cx());
+    FreeDataAndDispatchError(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  JS_ClearPendingException(jsapi.cx());
+
+  JS::Rooted<JSObject*> exceptionObject(cx, &exceptionValue.toObject());
+  JSErrorReport* er = JS_ErrorFromException(cx, exceptionObject);
+  if (!er || er->message()) {
+    FreeDataAndDispatchError(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  nsAutoString errorName;
+  JSFlatString* name = js::GetErrorTypeName(cx, er->exnType);
+  if (name) {
+    AssignJSFlatString(errorName, name);
+  }
+
+  mError =
+    new DOMError(GetOwner(), errorName,
+                 NS_ConvertUTF8toUTF16(er->message().c_str()));
+
+  FreeDataAndDispatchError();
+}
+
+nsresult
+FileReader::DoAsyncWait()
+{
+  nsresult rv = IncreaseBusyCounter();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = mAsyncStream->AsyncWait(this,
+                               /* aFlags*/ 0,
+                               /* aRequestedCount */ 0,
+                               mTarget);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    DecreaseBusyCounter();
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+FileReader::DoReadData(uint64_t aCount)
+{
+  MOZ_ASSERT(mAsyncStream);
+
+  if (mDataFormat == FILE_AS_BINARY) {
+    //Continuously update our binary string as data comes in
+    uint32_t oldLen = mResult.Length();
+    NS_ASSERTION(mResult.Length() == mDataLen, "unexpected mResult length");
+    if (uint64_t(oldLen) + aCount > UINT32_MAX)
+      return NS_ERROR_OUT_OF_MEMORY;
+    char16_t *buf = nullptr;
+    mResult.GetMutableData(&buf, oldLen + aCount, fallible);
+    NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);
+
+    uint32_t bytesRead = 0;
+    mAsyncStream->ReadSegments(ReadFuncBinaryString, buf + oldLen, aCount,
+                               &bytesRead);
+    NS_ASSERTION(bytesRead == aCount, "failed to read data");
+  }
+  else {
+    CheckedInt<uint64_t> size = mDataLen;
+    size += aCount;
+
+    //Update memory buffer to reflect the contents of the file
+    if (!size.isValid() ||
+        // PR_Realloc doesn't support over 4GB memory size even if 64-bit OS
+        size.value() > UINT32_MAX ||
+        size.value() > mTotal) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if (mDataFormat != FILE_AS_ARRAYBUFFER) {
+      mFileData = (char *) realloc(mFileData, mDataLen + aCount);
+      NS_ENSURE_TRUE(mFileData, NS_ERROR_OUT_OF_MEMORY);
+    }
+
+    uint32_t bytesRead = 0;
+    MOZ_DIAGNOSTIC_ASSERT(mFileData);
+    mAsyncStream->Read(mFileData + mDataLen, aCount, &bytesRead);
+    NS_ASSERTION(bytesRead == aCount, "failed to read data");
+  }
+
+  mDataLen += aCount;
+  return NS_OK;
+}
+
+// Helper methods
+
+void
+FileReader::ReadFileContent(Blob& aBlob,
+                            const nsAString &aCharset,
+                            eDataFormat aDataFormat,
+                            ErrorResult& aRv)
+{
+  //Implicit abort to clear any other activity going on
+  ErrorResult error;
+  Abort(error);
+  error.SuppressException();
+
+  if (mReadyState == LOADING) {
+    // A nested ReadAsSomething() as been called during one of the events
+    // dispatched by Abort(). We have to terminate this operation in order to
+    // continue the nested one.
+    aRv.Throw(NS_ERROR_ABORT);
+    return;
+  }
+
+  mError = nullptr;
+  SetDOMStringToNull(mResult);
+  mTransferred = 0;
+  mTotal = 0;
+  mReadyState = EMPTY;
+  FreeFileData();
+
+  mBlob = &aBlob;
+  mDataFormat = aDataFormat;
+  CopyUTF16toUTF8(aCharset, mCharset);
+
+  nsresult rv;
+  nsCOMPtr<nsIStreamTransportService> sts =
+    do_GetService(kStreamTransportServiceCID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    aRv.Throw(rv);
+    return;
+  }
+
+  nsCOMPtr<nsIInputStream> stream;
+  mBlob->GetInternalStream(getter_AddRefs(stream), aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  nsCOMPtr<nsITransport> transport;
+  aRv = sts->CreateInputTransport(stream,
+                                  /* aStartOffset */ 0,
+                                  /* aReadLimit */ -1,
+                                  /* aCloseWhenDone */ true,
+                                  getter_AddRefs(transport));
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  nsCOMPtr<nsIInputStream> wrapper;
+  aRv = transport->OpenInputStream(/* aFlags */ 0,
+                                   /* aSegmentSize */ 0,
+                                   /* aSegmentCount */ 0,
+                                   getter_AddRefs(wrapper));
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  MOZ_ASSERT(!mAsyncStream);
+  mAsyncStream = do_QueryInterface(wrapper);
+  MOZ_ASSERT(mAsyncStream);
+
+  mTotal = mBlob->GetSize(aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  if (mDataFormat == FILE_AS_ARRAYBUFFER) {
+    mFileData = js_pod_malloc<char>(mTotal);
+    if (!mFileData) {
+      NS_WARNING("Preallocation failed for ReadFileData");
+      aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+      return;
+    }
+  }
+
+  aRv = DoAsyncWait();
+  if (NS_WARN_IF(aRv.Failed())) {
+    FreeFileData();
+    return;
+  }
+
+  //FileReader should be in loading state here
+  mReadyState = LOADING;
+  DispatchProgressEvent(NS_LITERAL_STRING(LOADSTART_STR));
+}
+
+nsresult
+FileReader::GetAsText(Blob *aBlob,
+                      const nsACString &aCharset,
+                      const char *aFileData,
+                      uint32_t aDataLen,
+                      nsAString& aResult)
+{
+  // The BOM sniffing is baked into the "decode" part of the Encoding
+  // Standard, which the File API references.
+  nsAutoCString encoding;
+  if (!nsContentUtils::CheckForBOM(
+        reinterpret_cast<const unsigned char *>(aFileData),
+        aDataLen,
+        encoding)) {
+    // BOM sniffing failed. Try the API argument.
+    if (!EncodingUtils::FindEncodingForLabel(aCharset,
+                                             encoding)) {
+      // API argument failed. Try the type property of the blob.
+      nsAutoString type16;
+      aBlob->GetType(type16);
+      NS_ConvertUTF16toUTF8 type(type16);
+      nsAutoCString specifiedCharset;
+      bool haveCharset;
+      int32_t charsetStart, charsetEnd;
+      NS_ExtractCharsetFromContentType(type,
+                                       specifiedCharset,
+                                       &haveCharset,
+                                       &charsetStart,
+                                       &charsetEnd);
+      if (!EncodingUtils::FindEncodingForLabel(specifiedCharset, encoding)) {
+        // Type property failed. Use UTF-8.
+        encoding.AssignLiteral("UTF-8");
+      }
+    }
+  }
+
+  nsDependentCSubstring data(aFileData, aDataLen);
+  return nsContentUtils::ConvertStringFromEncoding(encoding, data, aResult);
+}
+
+nsresult
+FileReader::GetAsDataURL(Blob *aBlob,
+                         const char *aFileData,
+                         uint32_t aDataLen,
+                         nsAString& aResult)
+{
+  aResult.AssignLiteral("data:");
+
+  nsAutoString contentType;
+  aBlob->GetType(contentType);
+  if (!contentType.IsEmpty()) {
+    aResult.Append(contentType);
+  } else {
+    aResult.AppendLiteral("application/octet-stream");
+  }
+  aResult.AppendLiteral(";base64,");
+
+  nsCString encodedData;
+  nsresult rv = Base64Encode(Substring(aFileData, aDataLen), encodedData);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!AppendASCIItoUTF16(encodedData, aResult, fallible)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return NS_OK;
+}
+
+/* virtual */ JSObject*
+FileReader::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return FileReaderBinding::Wrap(aCx, this, aGivenProto);
+}
+
+void
+FileReader::StartProgressEventTimer()
+{
+  if (!mProgressNotifier) {
+    mProgressNotifier = do_CreateInstance(NS_TIMER_CONTRACTID);
+  }
+
+  if (mProgressNotifier) {
+    mProgressEventWasDelayed = false;
+    mTimerIsActive = true;
+    mProgressNotifier->Cancel();
+    mProgressNotifier->SetTarget(mTarget);
+    mProgressNotifier->InitWithCallback(this, NS_PROGRESS_EVENT_INTERVAL,
+                                        nsITimer::TYPE_ONE_SHOT);
+  }
+}
+
+void
+FileReader::ClearProgressEventTimer()
+{
+  mProgressEventWasDelayed = false;
+  mTimerIsActive = false;
+  if (mProgressNotifier) {
+    mProgressNotifier->Cancel();
+  }
+}
+
+void
+FileReader::FreeDataAndDispatchSuccess()
+{
+  FreeFileData();
+  mResult.SetIsVoid(false);
+  mAsyncStream = nullptr;
+  mBlob = nullptr;
+
+  // Dispatch event to signify end of a successful operation
+  DispatchProgressEvent(NS_LITERAL_STRING(LOAD_STR));
+  DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
+}
+
+void
+FileReader::FreeDataAndDispatchError()
+{
+  MOZ_ASSERT(mError);
+
+  FreeFileData();
+  mResult.SetIsVoid(true);
+  mAsyncStream = nullptr;
+  mBlob = nullptr;
+
+  // Dispatch error event to signify load failure
+  DispatchProgressEvent(NS_LITERAL_STRING(ERROR_STR));
+  DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
+}
+
+void
+FileReader::FreeDataAndDispatchError(nsresult aRv)
+{
+  // Set the status attribute, and dispatch the error event
+  switch (aRv) {
+  case NS_ERROR_FILE_NOT_FOUND:
+    mError = new DOMError(GetOwner(), NS_LITERAL_STRING("NotFoundError"));
+    break;
+  case NS_ERROR_FILE_ACCESS_DENIED:
+    mError = new DOMError(GetOwner(), NS_LITERAL_STRING("SecurityError"));
+    break;
+  default:
+    mError = new DOMError(GetOwner(), NS_LITERAL_STRING("NotReadableError"));
+    break;
+  }
+
+  FreeDataAndDispatchError();
+}
+
+nsresult
+FileReader::DispatchProgressEvent(const nsAString& aType)
+{
+  ProgressEventInit init;
+  init.mBubbles = false;
+  init.mCancelable = false;
+  init.mLoaded = mTransferred;
+
+  if (mTotal != kUnknownSize) {
+    init.mLengthComputable = true;
+    init.mTotal = mTotal;
+  } else {
+    init.mLengthComputable = false;
+    init.mTotal = 0;
+  }
+  RefPtr<ProgressEvent> event =
+    ProgressEvent::Constructor(this, aType, init);
+  event->SetTrusted(true);
+
+  return DispatchDOMEvent(nullptr, event, nullptr, nullptr);
+}
+
+// nsITimerCallback
+NS_IMETHODIMP
+FileReader::Notify(nsITimer* aTimer)
+{
+  nsresult rv;
+  mTimerIsActive = false;
+
+  if (mProgressEventWasDelayed) {
+    rv = DispatchProgressEvent(NS_LITERAL_STRING("progress"));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    StartProgressEventTimer();
+  }
+
+  return NS_OK;
+}
+
+// InputStreamCallback
+NS_IMETHODIMP
+FileReader::OnInputStreamReady(nsIAsyncInputStream* aStream)
+{
+  if (mReadyState != LOADING || aStream != mAsyncStream) {
+    return NS_OK;
+  }
+
+  // We use this class to decrease the busy counter at the end of this method.
+  // In theory we can do it immediatelly but, for debugging reasons, we want to
+  // be 100% sure we have a workerHolder when OnLoadEnd() is called.
+  FileReaderDecreaseBusyCounter RAII(this);
+
+  uint64_t aCount;
+  nsresult rv = aStream->Available(&aCount);
+
+  if (NS_SUCCEEDED(rv) && aCount) {
+    rv = DoReadData(aCount);
+  }
+
+  if (NS_SUCCEEDED(rv)) {
+    rv = DoAsyncWait();
+  }
+
+  if (NS_FAILED(rv) || !aCount) {
+    if (rv == NS_BASE_STREAM_CLOSED) {
+      rv = NS_OK;
+    }
+    return OnLoadEnd(rv);
+  }
+
+  mTransferred += aCount;
+
+  //Notify the timer is the appropriate timeframe has passed
+  if (mTimerIsActive) {
+    mProgressEventWasDelayed = true;
+  } else {
+    rv = DispatchProgressEvent(NS_LITERAL_STRING(PROGRESS_STR));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    StartProgressEventTimer();
+  }
+
+  return NS_OK;
+}
+
+nsresult
+FileReader::OnLoadEnd(nsresult aStatus)
+{
+  // Cancel the progress event timer
+  ClearProgressEventTimer();
+
+  // FileReader must be in DONE stage after an operation
+  mReadyState = DONE;
+
+  // Quick return, if failed.
+  if (NS_FAILED(aStatus)) {
+    FreeDataAndDispatchError(aStatus);
+    return NS_OK;
+  }
+
+  // In case we read a different number of bytes, we can assume that the
+  // underlying storage has changed. We should not continue.
+  if (mDataLen != mTotal) {
+    FreeDataAndDispatchError(NS_ERROR_FAILURE);
+    return NS_OK;
+  }
+
+  // ArrayBuffer needs a custom handling.
+  if (mDataFormat == FILE_AS_ARRAYBUFFER) {
+    OnLoadEndArrayBuffer();
+    return NS_OK;
+  }
+
+  nsresult rv = NS_OK;
+
+  // We don't do anything special for Binary format.
+
+  if (mDataFormat == FILE_AS_DATAURL) {
+    rv = GetAsDataURL(mBlob, mFileData, mDataLen, mResult);
+  } else if (mDataFormat == FILE_AS_TEXT) {
+    if (!mFileData && mDataLen) {
+      rv = NS_ERROR_OUT_OF_MEMORY;
+    } else if (!mFileData) {
+      rv = GetAsText(mBlob, mCharset, "", mDataLen, mResult);
+    } else {
+      rv = GetAsText(mBlob, mCharset, mFileData, mDataLen, mResult);
+    }
+  }
+
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    FreeDataAndDispatchError(rv);
+    return NS_OK;
+  }
+
+  FreeDataAndDispatchSuccess();
+  return NS_OK;
+}
+
+void
+FileReader::Abort(ErrorResult& aRv)
+{
+  if (mReadyState != LOADING) {
+    // XXX The spec doesn't say this
+    aRv.Throw(NS_ERROR_DOM_FILE_ABORT_ERR);
+    return;
+  }
+
+  ClearProgressEventTimer();
+
+  mReadyState = DONE;
+
+  // XXX The spec doesn't say this
+  mError = new DOMError(GetOwner(), NS_LITERAL_STRING("AbortError"));
+
+  // Revert status and result attributes
+  SetDOMStringToNull(mResult);
+  mResultArrayBuffer = nullptr;
+
+  mAsyncStream = nullptr;
+  mBlob = nullptr;
+
+  //Clean up memory buffer
+  FreeFileData();
+
+  // Dispatch the events
+  DispatchProgressEvent(NS_LITERAL_STRING(ABORT_STR));
+  DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
+}
+
+nsresult
+FileReader::IncreaseBusyCounter()
+{
+  if (mWorkerPrivate && mBusyCount++ == 0 &&
+      !HoldWorker(mWorkerPrivate, Closing)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+void
+FileReader::DecreaseBusyCounter()
+{
+  MOZ_ASSERT_IF(mWorkerPrivate, mBusyCount);
+  if (mWorkerPrivate && --mBusyCount == 0) {
+    ReleaseWorker();
+  }
+}
+
+bool
+FileReader::Notify(Status aStatus)
+{
+  MOZ_ASSERT(mWorkerPrivate);
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (aStatus > Running) {
+    Shutdown();
+  }
+
+  return true;
+}
+
+void
+FileReader::Shutdown()
+{
+  mReadyState = DONE;
+
+  if (mAsyncStream) {
+    mAsyncStream->Close();
+    mAsyncStream = nullptr;
+  }
+
+  FreeFileData();
+  mResultArrayBuffer = nullptr;
+
+  if (mWorkerPrivate && mBusyCount != 0) {
+    ReleaseWorker();
+    mWorkerPrivate = nullptr;
+    mBusyCount = 0;
+  }
+}
+
+} // dom namespace
+} // mozilla namespace