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

third_party/WebKit/Source/modules/presentation/PresentationConnection.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/presentation/PresentationConnection.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
 #include "core/dom/Document.h"
@@ skipping 76 matching lines @@
 }
 
 } // namespace
 
 class PresentationConnection::BlobLoader final : public GarbageCollectedFinalized<PresentationConnection::BlobLoader>, public FileReaderLoaderClient {
 public:
     BlobLoader(PassRefPtr<BlobDataHandle> blobDataHandle, PresentationConnection* PresentationConnection)
         : m_PresentationConnection(PresentationConnection)
         , m_loader(FileReaderLoader::ReadAsArrayBuffer, this)
     {
-        m_loader.start(m_PresentationConnection->executionContext(), blobDataHandle);
+        m_loader.start(m_PresentationConnection->getExecutionContext(), blobDataHandle);
     }
     ~BlobLoader() override { }
 
     // FileReaderLoaderClient functions.
     void didStartLoading() override { }
     void didReceiveData() override { }
     void didFinishLoading() override
     {
         m_PresentationConnection->didFinishLoadingBlob(m_loader.arrayBufferResult());
     }
@@ skipping 30 matching lines @@
 {
     ASSERT(!m_blobLoader);
 }
 
 // static
 PresentationConnection* PresentationConnection::take(ScriptPromiseResolver* resolver, PassOwnPtr<WebPresentationConnectionClient> client, PresentationRequest* request)
 {
     ASSERT(resolver);
     ASSERT(client);
     ASSERT(request);
-    ASSERT(resolver->executionContext()->isDocument());
+    ASSERT(resolver->getExecutionContext()->isDocument());
 
-    Document* document = toDocument(resolver->executionContext());
+    Document* document = toDocument(resolver->getExecutionContext());
     if (!document->frame())
         return nullptr;
 
     PresentationController* controller = PresentationController::from(*document->frame());
     if (!controller)
         return nullptr;
 
     return take(controller, client, request);
 }
 
 // static
 PresentationConnection* PresentationConnection::take(PresentationController* controller, PassOwnPtr<WebPresentationConnectionClient> client, PresentationRequest* request)
 {
     ASSERT(controller);
     ASSERT(request);
 
     PresentationConnection* connection = new PresentationConnection(controller->frame(), client->getId(), client->getUrl());
     controller->registerConnection(connection);
     request->dispatchEvent(PresentationConnectionAvailableEvent::create(EventTypeNames::connectionavailable, connection));
 
     return connection;
 }
 
 const AtomicString& PresentationConnection::interfaceName() const
 {
     return EventTargetNames::PresentationConnection;
 }
 
-ExecutionContext* PresentationConnection::executionContext() const
+ExecutionContext* PresentationConnection::getExecutionContext() const
 {
     if (!frame())
         return nullptr;
     return frame()->document();
 }
 
 bool PresentationConnection::addEventListenerInternal(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener> listener, const EventListenerOptions& options)
 {
     if (eventType == EventTypeNames::statechange)
-        Deprecation::countDeprecation(executionContext(), UseCounter::PresentationConnectionStateChangeEventListener);
+        Deprecation::countDeprecation(getExecutionContext(), UseCounter::PresentationConnectionStateChangeEventListener);
     else if (eventType == EventTypeNames::connect)
-        UseCounter::count(executionContext(), UseCounter::PresentationConnectionConnectEventListener);
+        UseCounter::count(getExecutionContext(), UseCounter::PresentationConnectionConnectEventListener);
     else if (eventType == EventTypeNames::close)
-        UseCounter::count(executionContext(), UseCounter::PresentationConnectionCloseEventListener);
+        UseCounter::count(getExecutionContext(), UseCounter::PresentationConnectionCloseEventListener);
     else if (eventType == EventTypeNames::terminate)
-        UseCounter::count(executionContext(), UseCounter::PresentationConnectionTerminateEventListener);
+        UseCounter::count(getExecutionContext(), UseCounter::PresentationConnectionTerminateEventListener);
     else if (eventType == EventTypeNames::message)
-        UseCounter::count(executionContext(), UseCounter::PresentationConnectionMessageEventListener);
+        UseCounter::count(getExecutionContext(), UseCounter::PresentationConnectionMessageEventListener);
 
     return EventTarget::addEventListenerInternal(eventType, listener, options);
 }
 
 DEFINE_TRACE(PresentationConnection)
 {
     visitor->trace(m_blobLoader);
     RefCountedGarbageCollectedEventTargetWithInlineData<PresentationConnection>::trace(visitor);
     DOMWindowProperty::trace(visitor);
 }
@@ skipping 43 matching lines @@
 }
 
 bool PresentationConnection::canSendMessage(ExceptionState& exceptionState)
 {
     if (m_state != WebPresentationConnectionState::Connected) {
         throwPresentationDisconnectedError(exceptionState);
         return false;
     }
 
     // The connection can send a message if there is a client available.
-    return !!presentationClient(executionContext());
+    return !!presentationClient(getExecutionContext());
 }
 
 void PresentationConnection::handleMessageQueue()
 {
-    WebPresentationClient* client = presentationClient(executionContext());
+    WebPresentationClient* client = presentationClient(getExecutionContext());
     if (!client)
         return;
 
     while (!m_messages.isEmpty() && !m_blobLoader) {
         Message* message = m_messages.first().get();
         switch (message->type) {
         case MessageTypeText:
             client->sendString(m_url, m_id, message->text);
             m_messages.removeFirst();
             break;
@@ skipping 60 matching lines @@
         dispatchEvent(MessageEvent::create(buffer.release()));
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
 void PresentationConnection::close()
 {
     if (m_state != WebPresentationConnectionState::Connected)
         return;
-    WebPresentationClient* client = presentationClient(executionContext());
+    WebPresentationClient* client = presentationClient(getExecutionContext());
     if (client)
         client->closeSession(m_url, m_id);
 
     tearDown();
 }
 
 void PresentationConnection::terminate()
 {
     if (m_state != WebPresentationConnectionState::Connected)
         return;
-    WebPresentationClient* client = presentationClient(executionContext());
+    WebPresentationClient* client = presentationClient(getExecutionContext());
     if (client)
         client->terminateSession(m_url, m_id);
 
     tearDown();
 }
 
 bool PresentationConnection::matches(WebPresentationConnectionClient* client) const
 {
     return client && m_url == static_cast<String>(client->getUrl()) && m_id == static_cast<String>(client->getId());
 }
@@ skipping 26 matching lines @@
 
     m_state = WebPresentationConnectionState::Closed;
     dispatchEvent(PresentationConnectionCloseEvent::create(EventTypeNames::close, connectionCloseReasonToString(reason), message));
 }
 
 void PresentationConnection::didFinishLoadingBlob(PassRefPtr<DOMArrayBuffer> buffer)
 {
     ASSERT(!m_messages.isEmpty() && m_messages.first()->type == MessageTypeBlob);
     ASSERT(buffer && buffer->buffer());
     // Send the loaded blob immediately here and continue processing the queue.
-    WebPresentationClient* client = presentationClient(executionContext());
+    WebPresentationClient* client = presentationClient(getExecutionContext());
     if (client)
         client->sendBlobData(m_url, m_id, static_cast<const uint8_t*>(buffer->data()), buffer->byteLength());
 
     m_messages.removeFirst();
     m_blobLoader.clear();
     handleMessageQueue();
 }
 
 void PresentationConnection::didFailLoadingBlob(FileError::ErrorCode errorCode)
 {
@@ skipping 12 matching lines @@
         m_blobLoader->cancel();
         m_blobLoader.clear();
     }
 
     // Clear message queue.
     Deque<OwnPtr<Message>> empty;
     m_messages.swap(empty);
 }
 
 } // namespace blink