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

third_party/WebKit/Source/modules/indexeddb/IDBRequest.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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 42 matching lines @@
 {
     IDBRequest* request = new IDBRequest(scriptState, source, transaction);
     request->suspendIfNeeded();
     // Requests associated with IDBFactory (open/deleteDatabase/getDatabaseNames) are not associated with transactions.
     if (transaction)
         transaction->registerRequest(request);
     return request;
 }
 
 IDBRequest::IDBRequest(ScriptState* scriptState, IDBAny* source, IDBTransaction* transaction)
-    : ActiveDOMObject(scriptState->executionContext())
+    : ActiveDOMObject(scriptState->getExecutionContext())
     , m_transaction(transaction)
     , m_scriptState(scriptState)
     , m_source(source)
 {
 }
 
 IDBRequest::~IDBRequest()
 {
-    ASSERT(m_readyState == DONE || m_readyState == EarlyDeath || !executionContext());
+    ASSERT(m_readyState == DONE || m_readyState == EarlyDeath || !getExecutionContext());
 }
 
 DEFINE_TRACE(IDBRequest)
 {
     visitor->trace(m_transaction);
     visitor->trace(m_source);
     visitor->trace(m_result);
     visitor->trace(m_error);
     visitor->trace(m_enqueuedEvents);
     visitor->trace(m_pendingCursor);
     visitor->trace(m_cursorKey);
     visitor->trace(m_cursorPrimaryKey);
     RefCountedGarbageCollectedEventTargetWithInlineData<IDBRequest>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 ScriptValue IDBRequest::result(ExceptionState& exceptionState)
 {
     if (m_readyState != DONE) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
         return ScriptValue();
     }
-    if (m_contextStopped || !executionContext())
+    if (m_contextStopped || !getExecutionContext())
         return ScriptValue();
     m_resultDirty = false;
     ScriptValue value = ScriptValue::from(m_scriptState.get(), m_result);
     return value;
 }
 
 DOMException* IDBRequest::error(ExceptionState& exceptionState) const
 {
     if (m_readyState != DONE) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
         return nullptr;
     }
     return m_error;
 }
 
 ScriptValue IDBRequest::source() const
 {
-    if (m_contextStopped || !executionContext())
+    if (m_contextStopped || !getExecutionContext())
         return ScriptValue();
 
     return ScriptValue::from(m_scriptState.get(), m_source);
 }
 
 const String& IDBRequest::readyState() const
 {
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
 
     if (m_readyState == PENDING)
         return IndexedDBNames::pending;
 
     return IndexedDBNames::done;
 }
 
 void IDBRequest::abort()
 {
     ASSERT(!m_requestAborted);
-    if (m_contextStopped || !executionContext())
+    if (m_contextStopped || !getExecutionContext())
         return;
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
     if (m_readyState == DONE)
         return;
 
-    EventQueue* eventQueue = executionContext()->eventQueue();
+    EventQueue* eventQueue = getExecutionContext()->getEventQueue();
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
         ASSERT_UNUSED(removed, removed);
     }
     m_enqueuedEvents.clear();
 
     m_error.clear();
     m_result.clear();
     onError(DOMException::create(AbortError, "The transaction was aborted, so the request cannot be fulfilled."));
     m_requestAborted = true;
 }
 
 void IDBRequest::setCursorDetails(IndexedDB::CursorType cursorType, WebIDBCursorDirection direction)
 {
     ASSERT(m_readyState == PENDING);
     ASSERT(!m_pendingCursor);
     m_cursorType = cursorType;
     m_cursorDirection = direction;
 }
 
 void IDBRequest::setPendingCursor(IDBCursor* cursor)
 {
     ASSERT(m_readyState == DONE);
-    ASSERT(executionContext());
+    ASSERT(getExecutionContext());
     ASSERT(m_transaction);
     ASSERT(!m_pendingCursor);
     ASSERT(cursor == getResultCursor());
 
     m_hasPendingActivity = true;
     m_pendingCursor = cursor;
     setResult(nullptr);
     m_readyState = PENDING;
     m_error.clear();
     m_transaction->registerRequest(this);
@@ skipping 31 matching lines @@
 }
 
 void IDBRequest::ackReceivedBlobs(const Vector<RefPtr<IDBValue>>& values)
 {
     for (size_t i = 0; i < values.size(); ++i)
         ackReceivedBlobs(values[i].get());
 }
 
 bool IDBRequest::shouldEnqueueEvent() const
 {
-    if (m_contextStopped || !executionContext())
+    if (m_contextStopped || !getExecutionContext())
         return false;
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
     if (m_requestAborted)
         return false;
     ASSERT(m_readyState == PENDING);
     ASSERT(!m_error && !m_result);
     return true;
 }
 
 void IDBRequest::onError(DOMException* error)
@@ skipping 173 matching lines @@
         m_result->contextWillBeDestroyed();
     if (m_pendingCursor)
         m_pendingCursor->contextWillBeDestroyed();
 }
 
 const AtomicString& IDBRequest::interfaceName() const
 {
     return EventTargetNames::IDBRequest;
 }
 
-ExecutionContext* IDBRequest::executionContext() const
+ExecutionContext* IDBRequest::getExecutionContext() const
 {
-    return ActiveDOMObject::executionContext();
+    return ActiveDOMObject::getExecutionContext();
 }
 
 DispatchEventResult IDBRequest::dispatchEventInternal(PassRefPtrWillBeRawPtr<Event> event)
 {
     IDB_TRACE("IDBRequest::dispatchEvent");
-    if (m_contextStopped || !executionContext())
+    if (m_contextStopped || !getExecutionContext())
         return DispatchEventResult::CanceledBeforeDispatch;
     ASSERT(m_readyState == PENDING);
     ASSERT(m_hasPendingActivity);
     ASSERT(m_enqueuedEvents.size());
     ASSERT(event->target() == this);
 
     ScriptState::Scope scope(m_scriptState.get());
 
     if (event->type() != EventTypeNames::blocked)
         m_readyState = DONE;
@@ skipping 66 matching lines @@
         m_transaction->abort(IGNORE_EXCEPTION);
     }
 }
 
 void IDBRequest::transactionDidFinishAndDispatch()
 {
     ASSERT(m_transaction);
     ASSERT(m_transaction->isVersionChange());
     ASSERT(m_didFireUpgradeNeededEvent);
     ASSERT(m_readyState == DONE);
-    ASSERT(executionContext());
+    ASSERT(getExecutionContext());
     m_transaction.clear();
 
     if (m_contextStopped)
         return;
 
     m_readyState = PENDING;
 }
 
 void IDBRequest::enqueueEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
 
-    if (m_contextStopped || !executionContext())
+    if (m_contextStopped || !getExecutionContext())
         return;
 
     ASSERT_WITH_MESSAGE(m_readyState == PENDING || m_didFireUpgradeNeededEvent, "When queueing event %s, m_readyState was %d", event->type().utf8().data(), m_readyState);
 
-    EventQueue* eventQueue = executionContext()->eventQueue();
+    EventQueue* eventQueue = getExecutionContext()->getEventQueue();
     event->setTarget(this);
 
     // Keep track of enqueued events in case we need to abort prior to dispatch,
     // in which case these must be cancelled. If the events not dispatched for
     // other reasons they must be removed from this list via dequeueEvent().
     if (eventQueue->enqueueEvent(event.get()))
         m_enqueuedEvents.append(event);
 }
 
 void IDBRequest::dequeueEvent(Event* event)
 {
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         if (m_enqueuedEvents[i].get() == event)
             m_enqueuedEvents.remove(i);
     }
 }
 
 } // namespace blink