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

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

 /*
  * 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 18 matching lines @@
  */
 
 #ifndef DocumentWebSocketChannel_h
 #define DocumentWebSocketChannel_h
 
 #include <stdint.h>
 #include <memory>
 #include "bindings/core/v8/SourceLocation.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/FileError.h"
+#include "core/loader/ThreadableLoadingContext.h"
 #include "modules/ModulesExport.h"
 #include "modules/websockets/WebSocketChannel.h"
 #include "modules/websockets/WebSocketHandle.h"
 #include "modules/websockets/WebSocketHandleClient.h"
 #include "platform/WebFrameScheduler.h"
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/Deque.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
-class Document;
+class ThreadableLoadingContext;
 class WebSocketHandshakeRequest;
 
 // This class is a WebSocketChannel subclass that works with a Document in a
 // DOMWindow (i.e. works in the main thread).
 class MODULES_EXPORT DocumentWebSocketChannel final
     : public WebSocketChannel,
       public WebSocketHandleClient {
  public:
   // You can specify the source file and the line number information
   // explicitly by passing the last parameter.
   // In the usual case, they are set automatically and you don't have to
   // pass it.
   // Specify handle explicitly only in tests.
   static DocumentWebSocketChannel* create(
       Document* document,
       WebSocketChannelClient* client,
       std::unique_ptr<SourceLocation> location,
       WebSocketHandle* handle = 0) {
-    return new DocumentWebSocketChannel(document, client, std::move(location),
-                                        handle);
+    DCHECK(document);
+    return create(ThreadableLoadingContext::create(*document), client,
+                  std::move(location), handle);
+  }
+  static DocumentWebSocketChannel* create(
+      ThreadableLoadingContext* loadingContext,
+      WebSocketChannelClient* client,
+      std::unique_ptr<SourceLocation> location,
+      WebSocketHandle* handle = 0) {
+    return new DocumentWebSocketChannel(loadingContext, client,
+                                        std::move(location), handle);
   }
   ~DocumentWebSocketChannel() override;
 
   // WebSocketChannel functions.
   bool connect(const KURL&, const String& protocol) override;
   void send(const CString& message) override;
   void send(const DOMArrayBuffer&,
             unsigned byteOffset,
             unsigned byteLength) override;
   void send(PassRefPtr<BlobDataHandle>) override;
@@ skipping 20 matching lines @@
     MessageTypeTextAsCharVector,
     MessageTypeBinaryAsCharVector,
     MessageTypeClose,
   };
 
   struct ReceivedMessage {
     bool isMessageText;
     Vector<char> data;
   };
 
-  DocumentWebSocketChannel(Document*,
+  DocumentWebSocketChannel(ThreadableLoadingContext*,
                            WebSocketChannelClient*,
                            std::unique_ptr<SourceLocation>,
                            WebSocketHandle*);
   void sendInternal(WebSocketHandle::MessageType,
                     const char* data,
                     size_t totalSize,
                     uint64_t* consumedBufferedAmount);
   void processSendQueue();
   void flowControlIfNecessary();
   void failAsError(const String& reason) {
     fail(reason, ErrorMessageLevel, m_locationAtConstruction->clone());
   }
   void abortAsyncOperations();
   void handleDidClose(bool wasClean, unsigned short code, const String& reason);
+  ThreadableLoadingContext* loadingContext();
+
+  // This may return nullptr.
+  // TODO(kinuko): Remove dependency to document.
   Document* document();
 
   // WebSocketHandleClient functions.
   void didConnect(WebSocketHandle*,
                   const String& selectedProtocol,
                   const String& extensions) override;
   void didStartOpeningHandshake(WebSocketHandle*,
                                 PassRefPtr<WebSocketHandshakeRequest>) override;
   void didFinishOpeningHandshake(WebSocketHandle*,
                                  const WebSocketHandshakeResponse*) override;
@@ skipping 20 matching lines @@
 
   // m_client can be deleted while this channel is alive, but this class
   // expects that disconnect() is called before the deletion.
   Member<WebSocketChannelClient> m_client;
   KURL m_url;
   // m_identifier > 0 means calling scriptContextExecution() returns a Document.
   unsigned long m_identifier;
   Member<BlobLoader> m_blobLoader;
   HeapDeque<Member<Message>> m_messages;
   Vector<char> m_receivingMessageData;
-  Member<Document> m_document;
+  Member<ThreadableLoadingContext> m_loadingContext;
 
   bool m_receivingMessageTypeIsText;
   uint64_t m_sendingQuota;
   uint64_t m_receivedDataSizeForFlowControl;
   size_t m_sentSizeOfTopMessage;
   std::unique_ptr<WebFrameScheduler::ActiveConnectionHandle>
       connection_handle_for_scheduler_;
 
   std::unique_ptr<SourceLocation> m_locationAtConstruction;
   RefPtr<WebSocketHandshakeRequest> m_handshakeRequest;
 
   static const uint64_t receivedDataSizeForFlowControlHighWaterMark = 1 << 15;
 };
 
 std::ostream& operator<<(std::ostream&, const DocumentWebSocketChannel*);
 
 }  // namespace blink
 
 #endif  // DocumentWebSocketChannel_h