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

third_party/WebKit/Source/core/page/EventSource.cpp

 /*
  * Copyright (C) 2009, 2012 Ericsson AB. All rights reserved.
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Code Aurora Forum. 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
@@ skipping 95 matching lines @@
     ASSERT(m_state == CONNECTING);
     ASSERT(!m_loader);
 
     m_connectTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void EventSource::connect()
 {
     ASSERT(m_state == CONNECTING);
     ASSERT(!m_loader);
-    ASSERT(executionContext());
+    ASSERT(getExecutionContext());
 
-    ExecutionContext& executionContext = *this->executionContext();
+    ExecutionContext& executionContext = *this->getExecutionContext();
     ResourceRequest request(m_url);
     request.setHTTPMethod(HTTPNames::GET);
     request.setHTTPHeaderField(HTTPNames::Accept, "text/event-stream");
     request.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache");
     request.setRequestContext(WebURLRequest::RequestContextEventSource);
     request.setExternalRequestStateFromRequestorAddressSpace(executionContext.securityContext().addressSpace());
     if (m_parser && !m_parser->lastEventId().isEmpty()) {
         // HTTP headers are Latin-1 byte strings, but the Last-Event-ID header is encoded as UTF-8.
         // TODO(davidben): This should be captured in the type of setHTTPHeaderField's arguments.
         CString lastEventIdUtf8 = m_parser->lastEventId().utf8();
         request.setHTTPHeaderField(HTTPNames::Last_Event_ID, AtomicString(reinterpret_cast<const LChar*>(lastEventIdUtf8.data()), lastEventIdUtf8.length()));
     }
 
-    SecurityOrigin* origin = executionContext.securityOrigin();
+    SecurityOrigin* origin = executionContext.getSecurityOrigin();
 
     ThreadableLoaderOptions options;
     options.preflightPolicy = PreventPreflight;
     options.crossOriginRequestPolicy = UseAccessControl;
     options.contentSecurityPolicyEnforcement = ContentSecurityPolicy::shouldBypassMainWorld(&executionContext) ? DoNotEnforceContentSecurityPolicy : EnforceContentSecurityPolicy;
 
     ResourceLoaderOptions resourceLoaderOptions;
     resourceLoaderOptions.allowCredentials = (origin->canRequestNoSuborigin(m_url) || m_withCredentials) ? AllowStoredCredentials : DoNotAllowStoredCredentials;
     resourceLoaderOptions.credentialsRequested = m_withCredentials ? ClientRequestedCredentials : ClientDidNotRequestCredentials;
     resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
     resourceLoaderOptions.securityOrigin = origin;
 
     InspectorInstrumentation::willSendEventSourceRequest(&executionContext, this);
     // InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient will be called synchronously.
     m_loader = ThreadableLoader::create(executionContext, this, options, resourceLoaderOptions);
     m_loader->start(request);
 }
 
 void EventSource::networkRequestEnded()
 {
-    InspectorInstrumentation::didFinishEventSourceRequest(executionContext(), this);
+    InspectorInstrumentation::didFinishEventSourceRequest(getExecutionContext(), this);
 
     m_loader = nullptr;
 
     if (m_state != CLOSED)
         scheduleReconnect();
 }
 
 void EventSource::scheduleReconnect()
 {
     m_state = CONNECTING;
@@ skipping 42 matching lines @@
     }
 
     m_state = CLOSED;
 }
 
 const AtomicString& EventSource::interfaceName() const
 {
     return EventTargetNames::EventSource;
 }
 
-ExecutionContext* EventSource::executionContext() const
+ExecutionContext* EventSource::getExecutionContext() const
 {
-    return ContextLifecycleObserver::executionContext();
+    return ContextLifecycleObserver::getExecutionContext();
 }
 
 void EventSource::didReceiveResponse(unsigned long, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
     ASSERT_UNUSED(handle, !handle);
     ASSERT(m_state == CONNECTING);
     ASSERT(m_loader);
 
     m_eventStreamOrigin = SecurityOrigin::create(response.url())->toString();
     int statusCode = response.httpStatusCode();
     bool mimeTypeIsValid = response.mimeType() == "text/event-stream";
     bool responseIsValid = statusCode == 200 && mimeTypeIsValid;
     if (responseIsValid) {
         const String& charset = response.textEncodingName();
         // If we have a charset, the only allowed value is UTF-8 (case-insensitive).
         responseIsValid = charset.isEmpty() || equalIgnoringCase(charset, "UTF-8");
         if (!responseIsValid) {
             StringBuilder message;
             message.appendLiteral("EventSource's response has a charset (\"");
             message.append(charset);
             message.appendLiteral("\") that is not UTF-8. Aborting the connection.");
             // FIXME: We are missing the source line.
-            executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message.toString()));
+            getExecutionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message.toString()));
         }
     } else {
         // To keep the signal-to-noise ratio low, we only log 200-response with an invalid MIME type.
         if (statusCode == 200 && !mimeTypeIsValid) {
             StringBuilder message;
             message.appendLiteral("EventSource's response has a MIME type (\"");
             message.append(response.mimeType());
             message.appendLiteral("\") that is not \"text/event-stream\". Aborting the connection.");
             // FIXME: We are missing the source line.
-            executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message.toString()));
+            getExecutionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message.toString()));
         }
     }
 
     if (responseIsValid) {
         m_state = OPEN;
         AtomicString lastEventId;
         if (m_parser) {
             // The new parser takes over the event ID.
             lastEventId = m_parser->lastEventId();
         }
@@ skipping 30 matching lines @@
     if (error.isCancellation())
         m_state = CLOSED;
     networkRequestEnded();
 }
 
 void EventSource::didFailAccessControlCheck(const ResourceError& error)
 {
     ASSERT(m_loader);
 
     String message = "EventSource cannot load " + error.failingURL() + ". " + error.localizedDescription();
-    executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
+    getExecutionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
 
     abortConnectionAttempt();
 }
 
 void EventSource::didFailRedirectCheck()
 {
     ASSERT(m_loader);
 
     abortConnectionAttempt();
 }
 
 void EventSource::onMessageEvent(const AtomicString& eventType, const String& data, const AtomicString& lastEventId)
 {
     RefPtrWillBeRawPtr<MessageEvent> e = MessageEvent::create();
     e->initMessageEvent(eventType, false, false, SerializedScriptValueFactory::instance().create(data), m_eventStreamOrigin, lastEventId, 0, nullptr);
 
-    InspectorInstrumentation::willDispatchEventSourceEvent(executionContext(), this, eventType, lastEventId, data);
+    InspectorInstrumentation::willDispatchEventSourceEvent(getExecutionContext(), this, eventType, lastEventId, data);
     dispatchEvent(e);
 }
 
 void EventSource::onReconnectionTimeSet(unsigned long long reconnectionTime)
 {
     m_reconnectDelay = reconnectionTime;
 }
 
 void EventSource::abortConnectionAttempt()
 {
@@ skipping 18 matching lines @@
 
 DEFINE_TRACE(EventSource)
 {
     visitor->trace(m_parser);
     RefCountedGarbageCollectedEventTargetWithInlineData::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
     EventSourceParser::Client::trace(visitor);
 }
 
 } // namespace blink