Split the constructor of ThreadableLoader into two methods (ctor and start())

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 51 matching lines @@
 const unsigned long long EventSource::defaultReconnectDelay = 3000;
 
 inline EventSource::EventSource(ExecutionContext* context, const KURL& url, const EventSourceInit& eventSourceInit)
     : ActiveDOMObject(context)
     , m_url(url)
     , m_withCredentials(eventSourceInit.withCredentials())
     , m_state(CONNECTING)
     , m_decoder(TextResourceDecoder::create("text/plain", "UTF-8"))
     , m_connectTimer(this, &EventSource::connectTimerFired)
     , m_discardTrailingNewline(false)
-    , m_requestInFlight(false)
     , m_reconnectDelay(defaultReconnectDelay)
 {
 }
 
 EventSource* EventSource::create(ExecutionContext* context, const String& url, const EventSourceInit& eventSourceInit, ExceptionState& exceptionState)
 {
     if (url.isEmpty()) {
         exceptionState.throwDOMException(SyntaxError, "Cannot open an EventSource to an empty URL.");
         return nullptr;
     }
@@ skipping 14 matching lines @@
     EventSource* source = new EventSource(context, fullURL, eventSourceInit);
 
     source->scheduleInitialConnect();
     source->suspendIfNeeded();
     return source;
 }
 
 EventSource::~EventSource()
 {
     ASSERT(m_state == CLOSED);
-    ASSERT(!m_requestInFlight);
+    ASSERT(!m_loader);
 }
 
 void EventSource::scheduleInitialConnect()
 {
     ASSERT(m_state == CONNECTING);
-    ASSERT(!m_requestInFlight);
+    ASSERT(!m_loader);
 
     m_connectTimer.startOneShot(0, FROM_HERE);
 }
 
 void EventSource::connect()
 {
     ASSERT(m_state == CONNECTING);
-    ASSERT(!m_requestInFlight);
+    ASSERT(!m_loader);
     ASSERT(executionContext());
 
     ExecutionContext& executionContext = *this->executionContext();
     ResourceRequest request(m_url);
     request.setHTTPMethod("GET");
     request.setHTTPHeaderField("Accept", "text/event-stream");
     request.setHTTPHeaderField("Cache-Control", "no-cache");
     request.setRequestContext(WebURLRequest::RequestContextEventSource);
     if (!m_lastEventId.isEmpty())
         request.setHTTPHeaderField("Last-Event-ID", m_lastEventId);
 
     SecurityOrigin* origin = executionContext.securityOrigin();
 
     ThreadableLoaderOptions options;
     options.preflightPolicy = PreventPreflight;
     options.crossOriginRequestPolicy = UseAccessControl;
     options.contentSecurityPolicyEnforcement = ContentSecurityPolicy::shouldBypassMainWorld(&executionContext) ? DoNotEnforceContentSecurityPolicy : EnforceConnectSrcDirective;
 
     ResourceLoaderOptions resourceLoaderOptions;
     resourceLoaderOptions.allowCredentials = (origin->canRequest(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, request, options, resourceLoaderOptions);
-
-    if (m_loader)
-        m_requestInFlight = true;
+    m_loader = ThreadableLoader::create(executionContext, this, options, resourceLoaderOptions);
+    m_loader->start(request);
 }
 
 void EventSource::networkRequestEnded()
 {
-    if (!m_requestInFlight)
-        return;
-
     InspectorInstrumentation::didFinishEventSourceRequest(executionContext(), this);
 
-    m_requestInFlight = false;
+    m_loader = nullptr;
 
     if (m_state != CLOSED)
         scheduleReconnect();
 }
 
 void EventSource::scheduleReconnect()
 {
     m_state = CONNECTING;
     m_connectTimer.startOneShot(m_reconnectDelay / 1000.0, FROM_HERE);
     dispatchEvent(Event::create(EventTypeNames::error));
@@ skipping 15 matching lines @@
 }
 
 EventSource::State EventSource::readyState() const
 {
     return m_state;
 }
 
 void EventSource::close()
 {
     if (m_state == CLOSED) {
-        ASSERT(!m_requestInFlight);
+        ASSERT(!m_loader);
         return;
     }
 
     // Stop trying to reconnect if EventSource was explicitly closed or if ActiveDOMObject::stop() was called.
     if (m_connectTimer.isActive()) {
         m_connectTimer.stop();
     }
 
-    if (m_requestInFlight)
+    if (m_loader) {
         m_loader->cancel();
+        m_loader = nullptr;
+    }
 
     m_state = CLOSED;
 }
 
 const AtomicString& EventSource::interfaceName() const
 {
     return EventTargetNames::EventSource;
 }
 
 ExecutionContext* EventSource::executionContext() const
 {
     return ActiveDOMObject::executionContext();
 }
 
 void EventSource::didReceiveResponse(unsigned long, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
     ASSERT_UNUSED(handle, !handle);
     ASSERT(m_state == CONNECTING);
-    ASSERT(m_requestInFlight);
+    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) {
@@ skipping 21 matching lines @@
         dispatchEvent(Event::create(EventTypeNames::open));
     } else {
         m_loader->cancel();
         dispatchEvent(Event::create(EventTypeNames::error));
     }
 }
 
 void EventSource::didReceiveData(const char* data, unsigned length)
 {
     ASSERT(m_state == OPEN);
-    ASSERT(m_requestInFlight);
+    ASSERT(m_loader);
 
     append(m_receiveBuf, m_decoder->decode(data, length));
     parseEventStream();
 }
 
 void EventSource::didFinishLoading(unsigned long, double)
 {
     ASSERT(m_state == OPEN);
-    ASSERT(m_requestInFlight);
+    ASSERT(m_loader);
 
     if (m_receiveBuf.size() > 0 || m_data.size() > 0) {
         parseEventStream();
 
         // Discard everything that has not been dispatched by now.
         m_receiveBuf.clear();
         m_data.clear();
         m_eventName = emptyAtom;
         m_currentlyParsedEventId = nullAtom;
     }
     networkRequestEnded();
 }
 
 void EventSource::didFail(const ResourceError& error)
 {
     ASSERT(m_state != CLOSED);
-    ASSERT(m_requestInFlight);
+    ASSERT(m_loader);
 
     if (error.isCancellation())
         m_state = CLOSED;
     networkRequestEnded();
 }
 
 void EventSource::didFailAccessControlCheck(const ResourceError& error)
 {
     String message = "EventSource cannot load " + error.failingURL() + ". " + error.localizedDescription();
     executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
 
     abortConnectionAttempt();
 }
 
 void EventSource::didFailRedirectCheck()
 {
     abortConnectionAttempt();
 }
 
 void EventSource::abortConnectionAttempt()
 {
     ASSERT(m_state == CONNECTING);
 
-    if (m_requestInFlight) {
-        m_loader->cancel();
-    } else {
-        m_state = CLOSED;
-    }
-
-    ASSERT(m_state == CLOSED);
+    m_loader = nullptr;
+    m_state = CLOSED;
+    networkRequestEnded();
     dispatchEvent(Event::create(EventTypeNames::error));
 }
 
 void EventSource::parseEventStream()
 {
     unsigned bufPos = 0;
     unsigned bufSize = m_receiveBuf.size();
     while (bufPos < bufSize) {
         if (m_discardTrailingNewline) {
             if (m_receiveBuf[bufPos] == '\n')
@@ skipping 81 matching lines @@
                 if (ok)
                     m_reconnectDelay = retry;
             }
         }
     }
 }
 
 void EventSource::stop()
 {
     close();
-
-    // (Non)Oilpan: In order to make Worker shutdowns clean,
-    // deref the loader. This will in turn deref its
-    // RefPtr<WorkerGlobalScope>.
-    //
-    // Worth doing regardless, it is no longer of use.
-    m_loader = nullptr;
 }
 
 bool EventSource::hasPendingActivity() const
 {
     return m_state != CLOSED;
 }
 
 PassRefPtrWillBeRawPtr<MessageEvent> EventSource::createMessageEvent()
 {
     RefPtrWillBeRawPtr<MessageEvent> event = MessageEvent::create();
     event->initMessageEvent(m_eventName.isEmpty() ? EventTypeNames::message : m_eventName, false, false, SerializedScriptValueFactory::instance().create(String(m_data)), m_eventStreamOrigin, m_lastEventId, 0, nullptr);
     m_data.clear();
     return event.release();
 }
 
 DEFINE_TRACE(EventSource)
 {
     RefCountedGarbageCollectedEventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink