Identify service worker version at main resource load time.

content/renderer/service_worker/embedded_worker_context_client.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/service_worker/embedded_worker_context_client.h"
 
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/pickle.h"
 #include "base/threading/thread_local.h"
+#include "content/child/request_extra_data.h"
+#include "content/child/service_worker/service_worker_network_provider.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/worker_task_runner.h"
 #include "content/child/worker_thread_task_runner.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/public/renderer/document_state.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
 #include "content/renderer/service_worker/service_worker_script_context.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerResponse.h"
 #include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/web/WebDataSource.h"
+#include "third_party/WebKit/public/web/WebServiceWorkerNetworkProvider.h"
 
 namespace content {
 
 namespace {
 
 // For now client must be a per-thread instance.
 // TODO(kinuko): This needs to be refactored when we start using thread pool
 // or having multiple clients per one thread.
 base::LazyInstance<base::ThreadLocalPointer<EmbeddedWorkerContextClient> >::
     Leaky g_worker_client_tls = LAZY_INSTANCE_INITIALIZER;
 
 void CallWorkerContextDestroyedOnMainThread(int embedded_worker_id) {
   if (!RenderThreadImpl::current() ||
       !RenderThreadImpl::current()->embedded_worker_dispatcher())
     return;
   RenderThreadImpl::current()->embedded_worker_dispatcher()->
       WorkerContextDestroyed(embedded_worker_id);
 }
 
+// We store an instance of this class in the "extra data" of the WebDataSource
+// and attach a ServiceWorkerNetworkProvider to it as base::UserData.
+// (see createServiceWorkerNetworkProvider).
+class DataSourceExtraData
+    : public blink::WebDataSource::ExtraData,
+      public base::SupportsUserData {
+ public:
+  DataSourceExtraData() {}
+  virtual ~DataSourceExtraData() {}
+};
+
+// Called on the main thread only and blink owns it.
+class WebServiceWorkerNetworkProviderImpl
+    : public blink::WebServiceWorkerNetworkProvider {
+ public:
+  // Blink calls this method for each request starting with the main script,
+  // we tag them with the provider id.
+  virtual void willSendRequest(
+      blink::WebDataSource* data_source,
+      blink::WebURLRequest& request,
+      const blink::WebURLResponse& redirectResponse) {
+    ServiceWorkerNetworkProvider* provider =
+        ServiceWorkerNetworkProvider::FromDocumentState(
+            static_cast<DataSourceExtraData*>(data_source->extraData()));
+    request.setExtraData(new RequestExtraData(provider->provider_id()));
+  }
+};
+
 }  // namespace
 
 EmbeddedWorkerContextClient*
 EmbeddedWorkerContextClient::ThreadSpecificInstance() {
   return g_worker_client_tls.Pointer()->Get();
 }
 
 EmbeddedWorkerContextClient::EmbeddedWorkerContextClient(
     int embedded_worker_id,
     int64 service_worker_version_id,
     const GURL& script_url)
     : embedded_worker_id_(embedded_worker_id),
       service_worker_version_id_(service_worker_version_id),
       script_url_(script_url),
       sender_(ChildThread::current()->thread_safe_sender()),
       main_thread_proxy_(base::MessageLoopProxy::current()),
       weak_factory_(this) {
-  g_worker_client_tls.Pointer()->Set(this);
 }
 
 EmbeddedWorkerContextClient::~EmbeddedWorkerContextClient() {
   DCHECK(g_worker_client_tls.Pointer()->Get() != NULL);
   g_worker_client_tls.Pointer()->Set(NULL);
 }
 
 bool EmbeddedWorkerContextClient::OnMessageReceived(
     const IPC::Message& msg) {
   bool handled = true;
@@ skipping 69 matching lines @@
     const blink::WebServiceWorkerResponse& web_response) {
   DCHECK(script_context_);
   ServiceWorkerResponse response(web_response.statusCode(),
                                  web_response.statusText().utf8(),
                                  web_response.method().utf8(),
                                  std::map<std::string, std::string>());
   script_context_->DidHandleFetchEvent(
       request_id, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, response);
 }
 
+blink::WebServiceWorkerNetworkProvider*
+EmbeddedWorkerContextClient::createServiceWorkerNetworkProvider(
+    blink::WebDataSource* data_source) {
+  // Create a content::ServiceWorkerNetworkProvider for this data source so
+  // we can observe its requests.
+  scoped_ptr<ServiceWorkerNetworkProvider> provider(
+      new ServiceWorkerNetworkProvider());
+
+  // Tell the network provider about which version to load.
+  provider->SetServiceWorkerVersionId(service_worker_version_id_);
+
+  // The provider is kept around for the lifetime of the DataSource
+  // and ownership is transferred to the DataSource.
+  DataSourceExtraData* extra_data = new DataSourceExtraData();
+  data_source->setExtraData(extra_data);
+  ServiceWorkerNetworkProvider::AttachToDocumentState(
+      extra_data, provider.Pass());

[dcheng, 2014/03/17 22:12:10]

Who gets ownership of |extra_data|?

[michaeln, 2014/03/17 22:53:58]

It's in the code comment.
// and ownership is transferred to the DataSource.

[dcheng, 2014/03/18 04:05:49]

The comment sounds like it's referring to the provider that was created on line
185 though. But I missed a line earlier--I think data_source->setExtraData()
actually takes ownership of it.

+
+  // Blink is responsible for deleting the returned object.
+  return new WebServiceWorkerNetworkProviderImpl();
+}
+
 void EmbeddedWorkerContextClient::OnSendMessageToWorker(
     int thread_id,
     int embedded_worker_id,
     int request_id,
     const IPC::Message& message) {
   if (!script_context_)
     return;
   DCHECK_EQ(embedded_worker_id_, embedded_worker_id);
   script_context_->OnMessageReceived(request_id, message);
 }
 
 void EmbeddedWorkerContextClient::SendWorkerStarted() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   sender_->Send(new EmbeddedWorkerHostMsg_WorkerStarted(
       WorkerTaskRunner::Instance()->CurrentWorkerId(),
       embedded_worker_id_));
 }
 
 }  // namespace content