blink: Rename modules/ method to prefix with get when they collide.

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 208 matching lines @@
     return EventTargetNames::FileReader;
 }
 
 void FileReader::contextDestroyed()
 {
     // The delayed abort task tidies up and advances to the DONE state.
     if (m_loadingState == LoadingStateAborted)
         return;
 
     if (hasPendingActivity())
-        ThrottlingController::finishReader(executionContext(), this, ThrottlingController::removeReader(executionContext(), this));
+        ThrottlingController::finishReader(getExecutionContext(), this, ThrottlingController::removeReader(getExecutionContext(), this));
     terminate();
 }
 
 bool FileReader::hasPendingActivity() const
 {
     return m_state == LOADING;
 }
 
 void FileReader::readAsArrayBuffer(Blob* blob, ExceptionState& exceptionState)
 {
@@ skipping 39 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;
     }
 
-    ExecutionContext* context = executionContext();
+    ExecutionContext* context = getExecutionContext();
     if (!context) {
         exceptionState.throwDOMException(AbortError, "Reading from a detached FileReader is not supported.");
         return;
     }
 
     // A document loader will not load new resources once the Document has detached from its frame.
     if (context->isDocument() && !toDocument(context)->frame()) {
         exceptionState.throwDOMException(AbortError, "Reading from a Document-detached FileReader is not supported.");
         return;
     }
@@ skipping 12 matching lines @@
 }
 
 void FileReader::executePendingRead()
 {
     ASSERT(m_loadingState == LoadingStatePending);
     m_loadingState = LoadingStateLoading;
 
     m_loader = FileReaderLoader::create(m_readType, this);
     m_loader->setEncoding(m_encoding);
     m_loader->setDataType(m_blobType);
-    m_loader->start(executionContext(), m_blobDataHandle);
+    m_loader->start(getExecutionContext(), m_blobDataHandle);
     m_blobDataHandle = nullptr;
 }
 
 static void delayedAbort(FileReader* reader)
 {
     reader->doAbort();
 }
 
 void FileReader::abort()
 {
     WTF_LOG(FileAPI, "FileReader: aborting\n");
 
     if (m_loadingState != LoadingStateLoading
         && m_loadingState != LoadingStatePending) {
         return;
     }
     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.
-    executionContext()->postTask(
+    getExecutionContext()->postTask(
         BLINK_FROM_HERE, createSameThreadTask(&delayedAbort, this));
 }
 
 void FileReader::doAbort()
 {
     ASSERT(m_state != DONE);
 
     terminate();
 
     m_error = FileError::create(FileError::ABORT_ERR);
 
     // Unregister the reader.
-    ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(executionContext(), this);
+    ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(getExecutionContext(), 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(executionContext(), this, finalStep);
+    ThrottlingController::finishReader(getExecutionContext(), this, finalStep);
 }
 
 void FileReader::result(StringOrArrayBuffer& resultAttribute) const
 {
     if (!m_loader || m_error)
         return;
 
     if (m_readType == FileReaderLoader::ReadAsArrayBuffer)
         resultAttribute.setArrayBuffer(m_loader->arrayBufferResult());
     else
@@ skipping 37 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(executionContext(), this);
+    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(executionContext(), this, finalStep);
+    ThrottlingController::finishReader(getExecutionContext(), 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(executionContext(), this);
+    ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(getExecutionContext(), this);
 
     fireEvent(EventTypeNames::error);
     fireEvent(EventTypeNames::loadend);
 
     // All possible events have fired and we're done, no more pending activity.
-    ThrottlingController::finishReader(executionContext(), this, finalStep);
+    ThrottlingController::finishReader(getExecutionContext(), this, finalStep);
 }
 
 void FileReader::fireEvent(const AtomicString& type)
 {
-    InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncCallbackStarting(executionContext(), m_asyncOperationId);
+    InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncCallbackStarting(getExecutionContext(), m_asyncOperationId);
     if (!m_loader) {
         dispatchEvent(ProgressEvent::create(type, false, 0, 0));
         InspectorInstrumentation::traceAsyncCallbackCompleted(cookie);
         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));
 
     InspectorInstrumentation::traceAsyncCallbackCompleted(cookie);
 }
 
 DEFINE_TRACE(FileReader)
 {
     visitor->trace(m_error);
     RefCountedGarbageCollectedEventTargetWithInlineData<FileReader>::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink