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

third_party/WebKit/Source/modules/websockets/DOMWebSocket.cpp

 /*
  * Copyright (C) 2011 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 58 matching lines @@
     , m_target(target)
     , m_resumeTimer(this, &EventQueue::resumeTimerFired) { }
 
 DOMWebSocket::EventQueue::~EventQueue() { stop(); }
 
 void DOMWebSocket::EventQueue::dispatch(PassRefPtrWillBeRawPtr<Event> event)
 {
     switch (m_state) {
     case Active:
         ASSERT(m_events.isEmpty());
-        ASSERT(m_target->executionContext());
+        ASSERT(m_target->getExecutionContext());
         m_target->dispatchEvent(event);
         break;
     case Suspended:
         m_events.append(event);
         break;
     case Stopped:
         ASSERT(m_events.isEmpty());
         // Do nothing.
         break;
     }
@@ skipping 35 matching lines @@
 {
     if (m_state != Active)
         return;
 
     WillBeHeapDeque<RefPtrWillBeMember<Event>> events;
     events.swap(m_events);
     while (!events.isEmpty()) {
         if (m_state == Stopped || m_state == Suspended)
             break;
         ASSERT(m_state == Active);
-        ASSERT(m_target->executionContext());
+        ASSERT(m_target->getExecutionContext());
         m_target->dispatchEvent(events.takeFirst());
         // |this| can be stopped here.
     }
     if (m_state == Suspended) {
         while (!m_events.isEmpty())
             events.append(m_events.takeFirst());
         events.swap(m_events);
     }
 }
 
@@ skipping 85 matching lines @@
 {
 }
 
 DOMWebSocket::~DOMWebSocket()
 {
     ASSERT(!m_channel);
 }
 
 void DOMWebSocket::logError(const String& message)
 {
-    executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
+    getExecutionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
 }
 
 DOMWebSocket* DOMWebSocket::create(ExecutionContext* context, const String& url, ExceptionState& exceptionState)
 {
     StringOrStringSequence protocols;
     return create(context, url, protocols, exceptionState);
 }
 
 DOMWebSocket* DOMWebSocket::create(ExecutionContext* context, const String& url, const StringOrStringSequence& protocols, ExceptionState& exceptionState)
 {
@@ skipping 18 matching lines @@
     }
 
     if (exceptionState.hadException())
         return nullptr;
 
     return webSocket;
 }
 
 void DOMWebSocket::connect(const String& url, const Vector<String>& protocols, ExceptionState& exceptionState)
 {
-    UseCounter::count(executionContext(), UseCounter::WebSocket);
+    UseCounter::count(getExecutionContext(), UseCounter::WebSocket);
 
     WTF_LOG(Network, "WebSocket %p connect() url='%s'", this, url.utf8().data());
     m_url = KURL(KURL(), url);
 
-    if (executionContext()->securityContext().getInsecureRequestsPolicy() == SecurityContext::InsecureRequestsUpgrade && m_url.protocol() == "ws") {
-        UseCounter::count(executionContext(), UseCounter::UpgradeInsecureRequestsUpgradedRequest);
+    if (getExecutionContext()->securityContext().getInsecureRequestsPolicy() == SecurityContext::InsecureRequestsUpgrade && m_url.protocol() == "ws") {
+        UseCounter::count(getExecutionContext(), UseCounter::UpgradeInsecureRequestsUpgradedRequest);
         m_url.setProtocol("wss");
         if (m_url.port() == 80)
             m_url.setPort(443);
     }
 
     if (!m_url.isValid()) {
         m_state = CLOSED;
         exceptionState.throwDOMException(SyntaxError, "The URL '" + url + "' is invalid.");
         return;
     }
     if (!m_url.protocolIs("ws") && !m_url.protocolIs("wss")) {
         m_state = CLOSED;
         exceptionState.throwDOMException(SyntaxError, "The URL's scheme must be either 'ws' or 'wss'. '" + m_url.protocol() + "' is not allowed.");
         return;
     }
 
     if (m_url.hasFragmentIdentifier()) {
         m_state = CLOSED;
         exceptionState.throwDOMException(SyntaxError, "The URL contains a fragment identifier ('" + m_url.fragmentIdentifier() + "'). Fragment identifiers are not allowed in WebSocket URLs.");
         return;
     }
 
     if (!Platform::current()->portAllowed(m_url)) {
         m_state = CLOSED;
         exceptionState.throwSecurityError("The port " + String::number(m_url.port()) + " is not allowed.");
         return;
     }
 
     // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
-    if (!ContentSecurityPolicy::shouldBypassMainWorld(executionContext()) && !executionContext()->contentSecurityPolicy()->allowConnectToSource(m_url)) {
+    if (!ContentSecurityPolicy::shouldBypassMainWorld(getExecutionContext()) && !getExecutionContext()->contentSecurityPolicy()->allowConnectToSource(m_url)) {
         m_state = CLOSED;
         // The URL is safe to expose to JavaScript, as this check happens synchronously before redirection.
         exceptionState.throwSecurityError("Refused to connect to '" + m_url.elidedString() + "' because it violates the document's Content Security Policy.");
         return;
     }
 
     // Fail if not all elements in |protocols| are valid.
     for (size_t i = 0; i < protocols.size(); ++i) {
         if (!isValidSubprotocolString(protocols[i])) {
             m_state = CLOSED;
             exceptionState.throwDOMException(SyntaxError, "The subprotocol '" + encodeSubprotocolString(protocols[i]) + "' is invalid.");
             return;
         }
     }
 
     // Fail if there're duplicated elements in |protocols|.
     HashSet<String> visited;
     for (size_t i = 0; i < protocols.size(); ++i) {
         if (!visited.add(protocols[i]).isNewEntry) {
             m_state = CLOSED;
             exceptionState.throwDOMException(SyntaxError, "The subprotocol '" + encodeSubprotocolString(protocols[i]) + "' is duplicated.");
             return;
         }
     }
 
     String protocolString;
     if (!protocols.isEmpty())
         protocolString = joinStrings(protocols, subprotocolSeperator());
 
-    m_channel = createChannel(executionContext(), this);
+    m_channel = createChannel(getExecutionContext(), this);
 
     if (!m_channel->connect(m_url, protocolString)) {
         m_state = CLOSED;
         exceptionState.throwSecurityError("An insecure WebSocket connection may not be initiated from a page loaded over HTTPS.");
         releaseChannel();
         return;
     }
 }
 
 void DOMWebSocket::updateBufferedAmountAfterClose(uint64_t payloadSize)
@@ skipping 212 matching lines @@
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
 const AtomicString& DOMWebSocket::interfaceName() const
 {
     return EventTargetNames::DOMWebSocket;
 }
 
-ExecutionContext* DOMWebSocket::executionContext() const
+ExecutionContext* DOMWebSocket::getExecutionContext() const
 {
-    return ActiveDOMObject::executionContext();
+    return ActiveDOMObject::getExecutionContext();
 }
 
 void DOMWebSocket::contextDestroyed()
 {
     WTF_LOG(Network, "WebSocket %p contextDestroyed()", this);
     ASSERT(!m_channel);
     ASSERT(m_state == CLOSED);
     ActiveDOMObject::contextDestroyed();
 }
 
@@ skipping 121 matching lines @@
 DEFINE_TRACE(DOMWebSocket)
 {
     visitor->trace(m_channel);
     visitor->trace(m_eventQueue);
     WebSocketChannelClient::trace(visitor);
     RefCountedGarbageCollectedEventTargetWithInlineData<DOMWebSocket>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink