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

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

 /*
  * Copyright (C) 2011, 2012 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/WorkerWebSocketChannel.h"
 
 #include <memory>
 #include "core/dom/DOMArrayBuffer.h"
-#include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/Blob.h"
+#include "core/loader/ThreadableLoadingContext.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "modules/websockets/DocumentWebSocketChannel.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/heap/SafePoint.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 #include "wtf/Functional.h"
@@ skipping 120 matching lines @@
       m_loaderProxy(loaderProxy),
       m_mainWebSocketChannel(nullptr) {
   DCHECK(isMainThread());
 }
 
 Peer::~Peer() {
   DCHECK(isMainThread());
 }
 
 bool Peer::initialize(std::unique_ptr<SourceLocation> location,
-                      ExecutionContext* context) {
+                      ThreadableLoadingContext* loadingContext) {
   DCHECK(isMainThread());
   if (wasContextDestroyedBeforeObserverCreation())
     return false;
-  Document* document = toDocument(context);
-  m_mainWebSocketChannel =
-      DocumentWebSocketChannel::create(document, this, std::move(location));
+  m_mainWebSocketChannel = DocumentWebSocketChannel::create(
+      loadingContext, this, std::move(location));
   return true;
 }
 
 bool Peer::connect(const KURL& url, const String& protocol) {
   DCHECK(isMainThread());
   if (!m_mainWebSocketChannel)
     return false;
   return m_mainWebSocketChannel->connect(url, protocol);
 }
 
@@ skipping 169 matching lines @@
 
 void Bridge::connectOnMainThread(
     std::unique_ptr<SourceLocation> location,
     RefPtr<WorkerLoaderProxy> loaderProxy,
     WorkerThreadLifecycleContext* workerThreadLifecycleContext,
     const KURL& url,
     const String& protocol,
     WebSocketChannelSyncHelper* syncHelper) {
   DCHECK(isMainThread());
   DCHECK(!m_peer);
-  ExecutionContext* loaderContext = loaderProxy->getLoaderExecutionContext();
-  if (!loaderContext)
+  ThreadableLoadingContext* loadingContext =
+      loaderProxy->getThreadableLoadingContext();
+  if (!loadingContext)
     return;
   Peer* peer = new Peer(this, m_loaderProxy, workerThreadLifecycleContext);
-  if (peer->initialize(std::move(location), loaderContext)) {
+  if (peer->initialize(std::move(location), loadingContext)) {
     m_peer = peer;
     syncHelper->setConnectRequestResult(m_peer->connect(url, protocol));
   }
   syncHelper->signalWorkerThread();
 }
 
 bool Bridge::connect(std::unique_ptr<SourceLocation> location,
                      const KURL& url,
                      const String& protocol) {
   // Wait for completion of the task on the main thread because the mixed
@@ skipping 78 matching lines @@
   m_peer = nullptr;
   m_workerGlobalScope.clear();
 }
 
 DEFINE_TRACE(Bridge) {
   visitor->trace(m_client);
   visitor->trace(m_workerGlobalScope);
 }
 
 }  // namespace blink