Introduce ThreadableLoadingContext: make threaded loading code one step away from Document

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

 /*
  * Copyright (C) 2013 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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/websockets/DocumentWebSocketChannel.h"
 
 #include <memory>
 #include "core/dom/DOMArrayBuffer.h"
-#include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/FileReaderLoader.h"
 #include "core/fileapi/FileReaderLoaderClient.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/MixedContentChecker.h"
+#include "core/loader/ThreadableLoadingContext.h"
 #include "modules/websockets/InspectorWebSocketEvents.h"
 #include "modules/websockets/WebSocketChannelClient.h"
 #include "modules/websockets/WebSocketFrame.h"
 #include "modules/websockets/WebSocketHandleImpl.h"
 #include "platform/WebFrameScheduler.h"
 #include "platform/loader/fetch/UniqueIdentifier.h"
 #include "platform/network/NetworkLog.h"
 #include "platform/network/WebSocketHandshakeRequest.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/InterfaceProvider.h"
@@ skipping 46 matching lines @@
   unsigned short code;
   String reason;
 };
 
 DocumentWebSocketChannel::BlobLoader::BlobLoader(
     PassRefPtr<BlobDataHandle> blobDataHandle,
     DocumentWebSocketChannel* channel)
     : m_channel(channel),
       m_loader(
           FileReaderLoader::create(FileReaderLoader::ReadAsArrayBuffer, this)) {
+  // TODO(kinuko): Remove dependency to document.
   m_loader->start(channel->document(), std::move(blobDataHandle));
 }
 
 void DocumentWebSocketChannel::BlobLoader::cancel() {
   m_loader->cancel();
   // didFail will be called immediately.
   // |this| is deleted here.
 }
 
 void DocumentWebSocketChannel::BlobLoader::didFinishLoading() {
   m_channel->didFinishLoadingBlob(m_loader->arrayBufferResult());
   // |this| is deleted here.
 }
 
 void DocumentWebSocketChannel::BlobLoader::didFail(
     FileError::ErrorCode errorCode) {
   m_channel->didFailLoadingBlob(errorCode);
   // |this| is deleted here.
 }
 
 DocumentWebSocketChannel::DocumentWebSocketChannel(
-    Document* document,
+    ThreadableLoadingContext* loadingContext,
     WebSocketChannelClient* client,
     std::unique_ptr<SourceLocation> location,
     WebSocketHandle* handle)
     : m_handle(WTF::wrapUnique(handle ? handle : new WebSocketHandleImpl())),
       m_client(client),
       m_identifier(createUniqueIdentifier()),
-      m_document(document),
+      m_loadingContext(loadingContext),
       m_sendingQuota(0),
       m_receivedDataSizeForFlowControl(
           receivedDataSizeForFlowControlHighWaterMark * 2),  // initial quota
       m_sentSizeOfTopMessage(0),
       m_locationAtConstruction(std::move(location)) {}
 
 DocumentWebSocketChannel::~DocumentWebSocketChannel() {
   DCHECK(!m_blobLoader);
 }
 
 bool DocumentWebSocketChannel::connect(const KURL& url,
                                        const String& protocol) {
   NETWORK_DVLOG(1) << this << " connect()";
   if (!m_handle)
     return false;
 
-  if (document()->frame()) {
-    if (MixedContentChecker::shouldBlockWebSocket(document()->frame(), url))
-      return false;
-  }
-  if (MixedContentChecker::isMixedContent(document()->getSecurityOrigin(),
-                                          url)) {
-    String message =
-        "Connecting to a non-secure WebSocket server from a secure origin is "
-        "deprecated.";
-    document()->addConsoleMessage(
-        ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
-  }
+  if (document()) {
+    if (document()->frame()) {
+      if (MixedContentChecker::shouldBlockWebSocket(document()->frame(), url))
+        return false;
+    }
+    if (MixedContentChecker::isMixedContent(document()->getSecurityOrigin(),
+                                            url)) {
+      String message =
+          "Connecting to a non-secure WebSocket server from a secure origin is "
+          "deprecated.";
+      document()->addConsoleMessage(ConsoleMessage::create(
+          JSMessageSource, WarningMessageLevel, message));
+    }
 
-  if (document()->frame()) {
-    connection_handle_for_scheduler_ =
-        document()->frame()->frameScheduler()->onActiveConnectionCreated();
+    if (document()->frame()) {
+      connection_handle_for_scheduler_ =
+          document()->frame()->frameScheduler()->onActiveConnectionCreated();
+    }
   }
 
   m_url = url;
   Vector<String> protocols;
   // Avoid placing an empty token in the Vector when the protocol string is
   // empty.
   if (!protocol.isEmpty()) {
     // Since protocol is already verified and escaped, we can simply split
     // it.
     protocol.split(", ", true, protocols);
   }
 
-  if (document()->frame() &&
+  // TODO(kinuko): document() should return nullptr if we don't
+  // have valid document/frame that returns non-empty interface provider.
+  if (document() && document()->frame() &&
       document()->frame()->interfaceProvider() !=
           InterfaceProvider::getEmptyInterfaceProvider()) {
     // Initialize the WebSocketHandle with the frame's InterfaceProvider to
     // provide the WebSocket implementation with context about this frame.
     // This is important so that the browser can show UI associated with
     // the WebSocket (e.g., for certificate errors).
     m_handle->initialize(document()->frame()->interfaceProvider());
   } else {
     m_handle->initialize(Platform::current()->interfaceProvider());
   }
-  m_handle->connect(url, protocols, document()->getSecurityOrigin(),
-                    document()->firstPartyForCookies(), document()->userAgent(),
-                    this);
+  m_handle->connect(url, protocols, m_loadingContext->getSecurityOrigin(),
+                    m_loadingContext->firstPartyForCookies(),
+                    m_loadingContext->userAgent(), this);
 
   flowControlIfNecessary();
   TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketCreate",
                        TRACE_EVENT_SCOPE_THREAD, "data",
                        InspectorWebSocketCreateEvent::data(
                            document(), m_identifier, url, protocol));
   InspectorInstrumentation::didCreateWebSocket(document(), m_identifier, url,
                                                protocol);
   return true;
 }
@@ skipping 81 matching lines @@
 }
 
 void DocumentWebSocketChannel::fail(const String& reason,
                                     MessageLevel level,
                                     std::unique_ptr<SourceLocation> location) {
   NETWORK_DVLOG(1) << this << " fail(" << reason << ")";
   // m_handle and m_client can be null here.
 
   connection_handle_for_scheduler_.reset();
 
-  InspectorInstrumentation::didReceiveWebSocketFrameError(document(),
-                                                          m_identifier, reason);
-  const String message = "WebSocket connection to '" + m_url.elidedString() +
-                         "' failed: " + reason;
-  document()->addConsoleMessage(ConsoleMessage::create(
-      JSMessageSource, level, message, std::move(location)));
+  if (document()) {
+    InspectorInstrumentation::didReceiveWebSocketFrameError(
+        document(), m_identifier, reason);
+    const String message = "WebSocket connection to '" + m_url.elidedString() +
+                           "' failed: " + reason;
+    document()->addConsoleMessage(ConsoleMessage::create(
+        JSMessageSource, level, message, std::move(location)));
+  }
 
   if (m_client)
     m_client->didError();
   // |reason| is only for logging and should not be provided for scripts,
   // hence close reason must be empty.
   handleDidClose(false, CloseEventCodeAbnormalClosure, String());
   // handleDidClose may delete this object.
 }
 
 void DocumentWebSocketChannel::disconnect() {
@@ skipping 135 matching lines @@
   }
   WebSocketChannelClient* client = m_client;
   m_client = nullptr;
   WebSocketChannelClient::ClosingHandshakeCompletionStatus status =
       wasClean ? WebSocketChannelClient::ClosingHandshakeComplete
                : WebSocketChannelClient::ClosingHandshakeIncomplete;
   client->didClose(status, code, reason);
   // client->didClose may delete this object.
 }
 
+ThreadableLoadingContext* DocumentWebSocketChannel::loadingContext() {
+  return m_loadingContext;
+}
+
 Document* DocumentWebSocketChannel::document() {
-  return m_document;
+  return m_loadingContext->getLoadingDocument();
 }
 
 void DocumentWebSocketChannel::didConnect(WebSocketHandle* handle,
                                           const String& selectedProtocol,
                                           const String& extensions) {
   NETWORK_DVLOG(1) << this << " didConnect(" << handle << ", "
                    << String(selectedProtocol) << ", " << String(extensions)
                    << ")";
 
   DCHECK(m_handle);
   DCHECK_EQ(handle, m_handle.get());
   DCHECK(m_client);
 
   m_client->didConnect(selectedProtocol, extensions);
 }
 
 void DocumentWebSocketChannel::didStartOpeningHandshake(
     WebSocketHandle* handle,
     PassRefPtr<WebSocketHandshakeRequest> request) {
   NETWORK_DVLOG(1) << this << " didStartOpeningHandshake(" << handle << ")";
 
   DCHECK(m_handle);
   DCHECK_EQ(handle, m_handle.get());
 
-  TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketSendHandshakeRequest",
-                       TRACE_EVENT_SCOPE_THREAD, "data",
-                       InspectorWebSocketEvent::data(document(), m_identifier));
-  InspectorInstrumentation::willSendWebSocketHandshakeRequest(
-      document(), m_identifier, request.get());
+  if (document()) {
+    TRACE_EVENT_INSTANT1(
+        "devtools.timeline", "WebSocketSendHandshakeRequest",
+        TRACE_EVENT_SCOPE_THREAD, "data",
+        InspectorWebSocketEvent::data(document(), m_identifier));
+    InspectorInstrumentation::willSendWebSocketHandshakeRequest(
+        document(), m_identifier, request.get());
+  }
   m_handshakeRequest = request;
 }
 
 void DocumentWebSocketChannel::didFinishOpeningHandshake(
     WebSocketHandle* handle,
     const WebSocketHandshakeResponse* response) {
   NETWORK_DVLOG(1) << this << " didFinishOpeningHandshake(" << handle << ")";
 
   DCHECK(m_handle);
   DCHECK_EQ(handle, m_handle.get());
 
-  TRACE_EVENT_INSTANT1("devtools.timeline", "WebSocketReceiveHandshakeResponse",
-                       TRACE_EVENT_SCOPE_THREAD, "data",
-                       InspectorWebSocketEvent::data(document(), m_identifier));
-  InspectorInstrumentation::didReceiveWebSocketHandshakeResponse(
-      document(), m_identifier, m_handshakeRequest.get(), response);
+  if (document()) {
+    TRACE_EVENT_INSTANT1(
+        "devtools.timeline", "WebSocketReceiveHandshakeResponse",
+        TRACE_EVENT_SCOPE_THREAD, "data",
+        InspectorWebSocketEvent::data(document(), m_identifier));
+    InspectorInstrumentation::didReceiveWebSocketHandshakeResponse(
+        document(), m_identifier, m_handshakeRequest.get(), response);
+  }
   m_handshakeRequest.clear();
 }
 
 void DocumentWebSocketChannel::didFail(WebSocketHandle* handle,
                                        const String& message) {
   NETWORK_DVLOG(1) << this << " didFail(" << handle << ", " << String(message)
                    << ")";
 
   connection_handle_for_scheduler_.reset();
 
@@ skipping 42 matching lines @@
   if (!fin) {
     return;
   }
   // FIXME: Change the inspector API to show the entire message instead
   // of individual frames.
   WebSocketFrame::OpCode opcode = m_receivingMessageTypeIsText
                                       ? WebSocketFrame::OpCodeText
                                       : WebSocketFrame::OpCodeBinary;
   WebSocketFrame frame(opcode, m_receivingMessageData.data(),
                        m_receivingMessageData.size(), WebSocketFrame::Final);
-  InspectorInstrumentation::didReceiveWebSocketFrame(
-      document(), m_identifier, frame.opCode, frame.masked, frame.payload,
-      frame.payloadLength);
+  if (document()) {
+    InspectorInstrumentation::didReceiveWebSocketFrame(
+        document(), m_identifier, frame.opCode, frame.masked, frame.payload,
+        frame.payloadLength);
+  }
   if (m_receivingMessageTypeIsText) {
     String message = m_receivingMessageData.isEmpty()
                          ? emptyString
                          : String::fromUTF8(m_receivingMessageData.data(),
                                             m_receivingMessageData.size());
     m_receivingMessageData.clear();
     if (message.isNull()) {
       failAsError("Could not decode a text frame as UTF-8.");
       // failAsError may delete this object.
     } else {
@@ skipping 14 matching lines @@
   NETWORK_DVLOG(1) << this << " didClose(" << handle << ", " << wasClean << ", "
                    << code << ", " << String(reason) << ")";
 
   connection_handle_for_scheduler_.reset();
 
   DCHECK(m_handle);
   DCHECK_EQ(handle, m_handle.get());
 
   m_handle.reset();
 
-  if (m_identifier) {
+  if (m_identifier && document()) {
     TRACE_EVENT_INSTANT1(
         "devtools.timeline", "WebSocketDestroy", TRACE_EVENT_SCOPE_THREAD,
         "data", InspectorWebSocketEvent::data(document(), m_identifier));
     InspectorInstrumentation::didCloseWebSocket(document(), m_identifier);
     m_identifier = 0;
   }
 
   handleDidClose(wasClean, code, reason);
   // handleDidClose may delete this object.
 }
@@ skipping 42 matching lines @@
   }
   // FIXME: Generate human-friendly reason message.
   failAsError("Failed to load Blob: error code = " + String::number(errorCode));
   // |this| can be deleted here.
 }
 
 DEFINE_TRACE(DocumentWebSocketChannel) {
   visitor->trace(m_blobLoader);
   visitor->trace(m_messages);
   visitor->trace(m_client);
-  visitor->trace(m_document);
+  visitor->trace(m_loadingContext);
   WebSocketChannel::trace(visitor);
 }
 
 std::ostream& operator<<(std::ostream& ostream,
                          const DocumentWebSocketChannel* channel) {
   return ostream << "DocumentWebSocketChannel "
                  << static_cast<const void*>(channel);
 }
 
 }  // namespace blink