FileReader shouldn't mark itself as inactive before firing events

third_party/WebKit/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 27 matching lines @@
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/ProgressEvent.h"
 #include "core/fileapi/File.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "platform/Logging.h"
 #include "platform/Supplementable.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/Deque.h"
 #include "wtf/HashSet.h"
+#include "wtf/TemporaryChange.h"
 #include "wtf/text/CString.h"
 
 namespace blink {
 
 namespace {
 
 const CString utf8BlobUUID(Blob* blob)
 {
     return blob->uuid().utf8();
 }
@@ skipping 134 matching lines @@
     FileReader* fileReader = new FileReader(context);
     fileReader->suspendIfNeeded();
     return fileReader;
 }
 
 FileReader::FileReader(ExecutionContext* context)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(context)
     , m_state(EMPTY)
     , m_loadingState(LoadingStateNone)
+    , m_stillFiringEvents(false)
     , m_readType(FileReaderLoader::ReadAsBinaryString)
     , m_lastProgressNotificationTimeMS(0)
 {
 }
 
 FileReader::~FileReader()
 {
     terminate();
 }
 
 const AtomicString& FileReader::interfaceName() const
 {
     return EventTargetNames::FileReader;
 }
 
 void FileReader::stop()
 {
     // The delayed abort task tidies up and advances to the DONE state.
     if (m_loadingState == LoadingStateAborted)
         return;
 
     if (hasPendingActivity())
         ThrottlingController::finishReader(getExecutionContext(), this, ThrottlingController::removeReader(getExecutionContext(), this));
     terminate();
 }
 
 bool FileReader::hasPendingActivity() const
 {
-    return m_state == LOADING;
+    return m_state == LOADING || m_stillFiringEvents;
 }
 
 void FileReader::readAsArrayBuffer(Blob* blob, ExceptionState& exceptionState)
 {
     ASSERT(blob);
     DVLOG(1) << "reading as array buffer: " << utf8BlobUUID(blob).data() << " " << utf8FilePath(blob).data();
 
     readInternal(blob, FileReaderLoader::ReadAsArrayBuffer, exceptionState);
 }
 
@@ skipping 93 matching lines @@
     m_loadingState = LoadingStateAborted;
 
     // Schedule to have the abort done later since abort() might be called from the event handler and we do not want the resource loading code to be in the stack.
     getExecutionContext()->postTask(
         BLINK_FROM_HERE, createSameThreadTask(&delayedAbort, wrapPersistent(this)));
 }
 
 void FileReader::doAbort()
 {
     ASSERT(m_state != DONE);
+    TemporaryChange<bool> firingEvents(m_stillFiringEvents, true);
 
     terminate();
 
     m_error = FileError::create(FileError::ABORT_ERR);
 
     // Unregister the reader.
     ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(getExecutionContext(), this);
 
     fireEvent(EventTypeNames::error);
     fireEvent(EventTypeNames::abort);
@@ skipping 19 matching lines @@
     if (m_loader) {
         m_loader->cancel();
         m_loader = nullptr;
     }
     m_state = DONE;
     m_loadingState = LoadingStateNone;
 }
 
 void FileReader::didStartLoading()
 {
+    TemporaryChange<bool> firingEvents(m_stillFiringEvents, true);
     fireEvent(EventTypeNames::loadstart);
 }
 
 void FileReader::didReceiveData()
 {
     // Fire the progress event at least every 50ms.
     double now = currentTimeMS();
     if (!m_lastProgressNotificationTimeMS) {
         m_lastProgressNotificationTimeMS = now;
     } else if (now - m_lastProgressNotificationTimeMS > progressNotificationIntervalMS) {
+        TemporaryChange<bool> firingEvents(m_stillFiringEvents, true);
         fireEvent(EventTypeNames::progress);
         m_lastProgressNotificationTimeMS = now;
     }
 }
 
 void FileReader::didFinishLoading()
 {
     if (m_loadingState == LoadingStateAborted)
         return;
     ASSERT(m_loadingState == LoadingStateLoading);
 
+    // TODO(jochen): When we set m_state to DONE below, we still need to fire
+    // the load and loadend events. To avoid GC to collect this FileReader, we
+    // use this separate variable to keep the wrapper of this FileReader alive.
+    // An alternative would be to keep any active DOM object alive that is on
+    // the stack.
+    TemporaryChange<bool> firingEvents(m_stillFiringEvents, true);
+
     // It's important that we change m_loadingState before firing any events
     // 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(getExecutionContext(), this);
 
     fireEvent(EventTypeNames::load);
     fireEvent(EventTypeNames::loadend);
 
     // All possible events have fired and we're done, no more pending activity.
     ThrottlingController::finishReader(getExecutionContext(), this, finalStep);
 }
 
 void FileReader::didFail(FileError::ErrorCode errorCode)
 {
     if (m_loadingState == LoadingStateAborted)
         return;
+
+    TemporaryChange<bool> firingEvents(m_stillFiringEvents, true);
+
     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(getExecutionContext(), this);
@@ skipping 20 matching lines @@
 }
 
 DEFINE_TRACE(FileReader)
 {
     visitor->trace(m_error);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink