Gracefully handle FileReader() read operations when in a detached state.

Source/core/fileapi/FileReader.cpp

 /*
  * Copyright (C) 2010 Google Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 57 matching lines @@
 #endif
 
 } // namespace
 
 // Embedders like chromium limit the number of simultaneous requests to avoid
 // excessive IPC congestion. We limit this to 100 per thread to throttle the
 // requests (the value is arbitrarily chosen).
 static const size_t kMaxOutstandingRequestsPerThread = 100;
 static const double progressNotificationIntervalMS = 50;
 
+// FIXME: Oilpan: if ExecutionContext is moved to the heap, consider
+// making this object an ExecutionContext supplement (only.)
 class FileReader::ThrottlingController FINAL : public NoBaseWillBeGarbageCollectedFinalized<FileReader::ThrottlingController>, public WillBeHeapSupplement<LocalFrame>, public WillBeHeapSupplement<WorkerClients> {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(FileReader::ThrottlingController);
 public:
     static ThrottlingController* from(ExecutionContext* context)
     {
+        if (!context)
+            return 0;
+
         if (context->isDocument()) {
             Document* document = toDocument(context);
             if (!document->frame())
                 return 0;
 
             ThrottlingController* controller = static_cast<ThrottlingController*>(WillBeHeapSupplement<LocalFrame>::from(document->frame(), supplementName()));
             if (controller)
                 return controller;
 
             controller = new ThrottlingController();
             WillBeHeapSupplement<LocalFrame>::provideTo(*document->frame(), supplementName(), adoptPtrWillBeNoop(controller));
             return controller;
         }
         ASSERT(!isMainThread());
         ASSERT(context->isWorkerGlobalScope());
         WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(context);
         ThrottlingController* controller = static_cast<ThrottlingController*>(WillBeHeapSupplement<WorkerClients>::from(workerGlobalScope->clients(), supplementName()));
         if (controller)
             return controller;
 
         controller = new ThrottlingController();
         WillBeHeapSupplement<WorkerClients>::provideTo(*workerGlobalScope->clients(), supplementName(), adoptPtrWillBeNoop(controller));
         return controller;
     }
 
     ~ThrottlingController() { }
 
     enum FinishReaderType { DoNotRunPendingReaders, RunPendingReaders };
 
+    static void pushReader(ExecutionContext* context, FileReader* reader)
+    {
+        ThrottlingController* controller = from(context);
+        if (!controller)
+            return;
+
+        controller->pushReader(reader);
+    }
+
+    static FinishReaderType removeReader(ExecutionContext* context, FileReader* reader)
+    {
+        ThrottlingController* controller = from(context);
+        if (!controller)
+            return DoNotRunPendingReaders;
+
+        return controller->removeReader(reader);
+    }
+
+    static void finishReader(ExecutionContext* context, FileReader* reader, FinishReaderType nextStep)
+    {
+        ThrottlingController* controller = from(context);
+        if (!controller)
+            return;
+
+        controller->finishReader(reader, nextStep);
+    }
+
+    void trace(Visitor* visitor)
+    {
+#if ENABLE(OILPAN)
+        visitor->trace(m_pendingReaders);
+        visitor->trace(m_runningReaders);
+#endif
+        WillBeHeapSupplement<LocalFrame>::trace(visitor);
+        WillBeHeapSupplement<WorkerClients>::trace(visitor);
+    }
+
+private:
+    ThrottlingController()
+        : m_maxRunningReaders(kMaxOutstandingRequestsPerThread)
+    {
+    }
+
     void pushReader(FileReader* reader)
     {
         if (m_pendingReaders.isEmpty()
             && m_runningReaders.size() < m_maxRunningReaders) {
             reader->executePendingRead();
             ASSERT(!m_runningReaders.contains(reader));
             m_runningReaders.add(reader);
             return;
         }
         m_pendingReaders.append(reader);
@@ skipping 16 matching lines @@
         }
         return DoNotRunPendingReaders;
     }
 
     void finishReader(FileReader* reader, FinishReaderType nextStep)
     {
         if (nextStep == RunPendingReaders)
             executeReaders();
     }
 
-    void trace(Visitor* visitor)
-    {
-#if ENABLE(OILPAN)
-        visitor->trace(m_pendingReaders);
-        visitor->trace(m_runningReaders);
-#endif
-        WillBeHeapSupplement<LocalFrame>::trace(visitor);
-        WillBeHeapSupplement<WorkerClients>::trace(visitor);
-    }
-
-private:
-    ThrottlingController()
-        : m_maxRunningReaders(kMaxOutstandingRequestsPerThread)
-    {
-    }
-
     void executeReaders()
     {
         while (m_runningReaders.size() < m_maxRunningReaders) {
             if (m_pendingReaders.isEmpty())
                 return;
             FileReader* reader = m_pendingReaders.takeFirst();
             reader->executePendingRead();
             m_runningReaders.add(reader);
         }
     }
@@ skipping 28 matching lines @@
 }
 
 const AtomicString& FileReader::interfaceName() const
 {
     return EventTargetNames::FileReader;
 }
 
 void FileReader::stop()
 {
     if (hasPendingActivity())
-        throttlingController()->finishReader(this, throttlingController()->removeReader(this));
+        ThrottlingController::finishReader(executionContext(), this, ThrottlingController::removeReader(executionContext(), this));
     terminate();
 }
 
 bool FileReader::hasPendingActivity() const
 {
     return m_state == LOADING;
 }
 
 void FileReader::readAsArrayBuffer(Blob* blob, ExceptionState& exceptionState)
 {
@@ skipping 55 matching lines @@
     if (m_state == LOADING) {
         exceptionState.throwDOMException(InvalidStateError, "The object is already busy reading Blobs.");
         return;
     }
 
     if (blob->hasBeenClosed()) {
         exceptionState.throwDOMException(InvalidStateError, String(blob->isFile() ? "File" : "Blob") + " has been closed.");
         return;
     }
 
+    if (!ThrottlingController::from(executionContext())) {
+        exceptionState.throwDOMException(InvalidStateError, "Reading from a Document-detached FileReader is not supported.");

[haraken, 2014/07/18 01:01:53]

Looks like kinuko-san prefers AbortError?

[nhiroki, 2014/07/18 01:54:42]

I'd prefer AbortError, too.

[sof, 2014/07/18 05:26:37]

ok, let's throw that instead. Switched over.

+        return;
+    }
+
     // "Snapshot" the Blob data rather than the Blob itself as ongoing
     // read operations should not be affected if close() is called on
     // the Blob being read.
     m_blobDataHandle = blob->blobDataHandle();
     m_blobType = blob->type();
     m_readType = type;
     m_state = LOADING;
     m_loadingState = LoadingStatePending;
     m_error = nullptr;
-    throttlingController()->pushReader(this);
+    ThrottlingController::pushReader(executionContext(), this);
 }
 
 void FileReader::executePendingRead()
 {
     ASSERT(m_loadingState == LoadingStatePending);
     m_loadingState = LoadingStateLoading;
 
     m_loader = adoptPtr(new FileReaderLoader(m_readType, this));
     m_loader->setEncoding(m_encoding);
     m_loader->setDataType(m_blobType);
@@ skipping 23 matching lines @@
 
 void FileReader::doAbort()
 {
     ASSERT(m_state != DONE);
 
     terminate();
 
     m_error = FileError::create(FileError::ABORT_ERR);
 
     // Unregister the reader.
-    ThrottlingController::FinishReaderType finalStep = throttlingController()->removeReader(this);
+    ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(executionContext(), this);
 
     fireEvent(EventTypeNames::error);
     fireEvent(EventTypeNames::abort);
     fireEvent(EventTypeNames::loadend);
 
     // All possible events have fired and we're done, no more pending activity.
-    throttlingController()->finishReader(this, finalStep);
+    ThrottlingController::finishReader(executionContext(), this, finalStep);
 }
 
 void FileReader::terminate()
 {
     if (m_loader) {
         m_loader->cancel();
         m_loader = nullptr;
     }
     m_state = DONE;
     m_loadingState = LoadingStateNone;
@@ skipping 26 matching lines @@
     // since any of the events could call abort(), which internally checks
     // if we're still loading (therefore we need abort process) or not.
     m_loadingState = LoadingStateNone;
 
     fireEvent(EventTypeNames::progress);
 
     ASSERT(m_state != DONE);
     m_state = DONE;
 
     // Unregister the reader.
-    ThrottlingController::FinishReaderType finalStep = throttlingController()->removeReader(this);
+    ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(executionContext(), this);
 
     fireEvent(EventTypeNames::load);
     fireEvent(EventTypeNames::loadend);
 
     // All possible events have fired and we're done, no more pending activity.
-    throttlingController()->finishReader(this, finalStep);
+    ThrottlingController::finishReader(executionContext(), this, finalStep);
 }
 
 void FileReader::didFail(FileError::ErrorCode errorCode)
 {
     if (m_loadingState == LoadingStateAborted)
         return;
     ASSERT(m_loadingState == LoadingStateLoading);
     m_loadingState = LoadingStateNone;
 
     ASSERT(m_state != DONE);
     m_state = DONE;
 
     m_error = FileError::create(static_cast<FileError::ErrorCode>(errorCode));
 
     // Unregister the reader.
-    ThrottlingController::FinishReaderType finalStep = throttlingController()->removeReader(this);
+    ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(executionContext(), this);
 
     fireEvent(EventTypeNames::error);
     fireEvent(EventTypeNames::loadend);
 
     // All possible events have fired and we're done, no more pending activity.
-    throttlingController()->finishReader(this, finalStep);
+    ThrottlingController::finishReader(executionContext(), this, finalStep);
 }
 
 void FileReader::fireEvent(const AtomicString& type)
 {
     if (!m_loader) {
         dispatchEvent(ProgressEvent::create(type, false, 0, 0));
         return;
     }
 
     if (m_loader->totalBytes() >= 0)
         dispatchEvent(ProgressEvent::create(type, true, m_loader->bytesLoaded(), m_loader->totalBytes()));
     else
         dispatchEvent(ProgressEvent::create(type, false, m_loader->bytesLoaded(), 0));
 }
 
-FileReader::ThrottlingController* FileReader::throttlingController()
-{
-    return FileReader::ThrottlingController::from(executionContext());
-}
-
 PassRefPtr<ArrayBuffer> FileReader::arrayBufferResult() const
 {
     if (!m_loader || m_error)
         return nullptr;
     return m_loader->arrayBufferResult();
 }
 
 String FileReader::stringResult()
 {
     if (!m_loader || m_error)
         return String();
     return m_loader->stringResult();
 }
 
 void FileReader::trace(Visitor* visitor)
 {
     visitor->trace(m_error);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace WebCore