Change WTF::TemporaryChange to be an alias for AutoReset

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 24 matching lines @@
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/Document.h"
 #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/AutoReset.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 277 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);
+    AutoReset<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);
+    AutoReset<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);
+        AutoReset<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);
+    AutoReset<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);
+    AutoReset<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.
@@ skipping 21 matching lines @@
 }
 
 DEFINE_TRACE(FileReader)
 {
     visitor->trace(m_error);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink