Expose WebServiceWorkerNetworkProvider on DataSource

third_party/WebKit/Source/web/WebSharedWorkerImpl.cpp

 /*
  * Copyright (C) 2009 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 41 matching lines @@
 #include "platform/heap/Persistent.h"
 #include "platform/network/ContentSecurityPolicyParsers.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebMessagePortChannel.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLRequest.h"
+#include "public/platform/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 #include "public/web/WebDevToolsAgent.h"
 #include "public/web/WebFrame.h"
 #include "public/web/WebSettings.h"
 #include "public/web/WebView.h"
 #include "public/web/WebWorkerContentSettingsClientProxy.h"
-#include "public/web/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 #include "web/IndexedDBClientImpl.h"
 #include "web/LocalFileSystemClient.h"
 #include "web/WebDataSourceImpl.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WorkerContentSettingsClient.h"
 #include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
@@ skipping 85 matching lines @@
   CString content("");
   RefPtr<SharedBuffer> buffer(
       SharedBuffer::create(content.data(), content.length()));
   m_mainFrame->frame()->loader().load(
       FrameLoadRequest(0, ResourceRequest(m_url),
                        SubstituteData(buffer, "text/html", "UTF-8", KURL())));
 }
 
 void WebSharedWorkerImpl::willSendRequest(WebLocalFrame* frame,
                                           WebURLRequest& request) {
-  DCHECK(isMainThread());
-  if (m_networkProvider)
-    m_networkProvider->willSendRequest(frame->dataSource(), request);
+  auto networkProvider = frame->dataSource()->getServiceWorkerNetworkProvider();

[dcheng, 2017/03/10 04:48:38]

Nit: auto* (this is checked automatically in Chrome code, but isn't yet enabled
in Blink)

[kinuko, 2017/03/10 05:52:29]

Done.

+  if (networkProvider)
+    networkProvider->willSendRequest(request);
 }
 
 void WebSharedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame) {
   DCHECK(isMainThread());
   DCHECK(!m_loadingDocument);
   DCHECK(!m_mainScriptLoader);
-  m_networkProvider = WTF::wrapUnique(
-      m_client->createServiceWorkerNetworkProvider(frame->dataSource()));
+  frame->dataSource()->setServiceWorkerNetworkProvider(
+      WTF::wrapUnique(m_client->createServiceWorkerNetworkProvider()));
   m_mainScriptLoader = WorkerScriptLoader::create();
   m_mainScriptLoader->setRequestContext(
       WebURLRequest::RequestContextSharedWorker);
   m_loadingDocument = toWebLocalFrameImpl(frame)->frame()->document();
 
   CrossOriginRequestPolicy crossOriginRequestPolicy =
       (static_cast<KURL>(m_url)).protocolIsData() ? AllowCrossOriginRequests
                                                   : DenyCrossOriginRequests;
 
   m_mainScriptLoader->loadAsynchronously(
       *m_loadingDocument.get(), m_url, crossOriginRequestPolicy,
       m_creationAddressSpace,
       bind(&WebSharedWorkerImpl::didReceiveScriptLoaderResponse,
            WTF::unretained(this)),
       bind(&WebSharedWorkerImpl::onScriptLoaderFinished,
            WTF::unretained(this)));
   // Do nothing here since onScriptLoaderFinished() might have been already
   // invoked and |this| might have been deleted at this point.
 }
 
-bool WebSharedWorkerImpl::isControlledByServiceWorker(
-    WebDataSource& dataSource) {
-  DCHECK(isMainThread());
-  return m_networkProvider &&
-         m_networkProvider->isControlledByServiceWorker(dataSource);
-}
-
-int64_t WebSharedWorkerImpl::serviceWorkerID(WebDataSource& dataSource) {
-  DCHECK(isMainThread());
-  if (!m_networkProvider)
-    return -1;
-  return m_networkProvider->serviceWorkerID(dataSource);
-}
-
 void WebSharedWorkerImpl::sendProtocolMessage(int sessionId,
                                               int callId,
                                               const WebString& message,
                                               const WebString& state) {
   DCHECK(isMainThread());
   m_client->sendDevToolsMessage(sessionId, callId, message, state);
 }
 
 void WebSharedWorkerImpl::resumeStartup() {
   DCHECK(isMainThread());
@@ skipping 211 matching lines @@
   if (devtoolsAgent)
     devtoolsAgent->dispatchOnInspectorBackend(sessionId, callId, method,
                                               message);
 }
 
 WebSharedWorker* WebSharedWorker::create(WebSharedWorkerClient* client) {
   return new WebSharedWorkerImpl(client);
 }
 
 }  // namespace blink