ServiceWorker: Expose registration within ServiceWorkerGlobalScope [2/3]

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 <map>
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/pickle.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_local.h"
 #include "content/child/request_extra_data.h"
+#include "content/child/service_worker/service_worker_dispatcher.h"
 #include "content/child/service_worker/service_worker_network_provider.h"
+#include "content/child/service_worker/service_worker_provider_context.h"
+#include "content/child/service_worker/service_worker_registration_handle_reference.h"
+#include "content/child/service_worker/web_service_worker_impl.h"
+#include "content/child/service_worker/web_service_worker_registration_impl.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/devtools_messages.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"
@@ skipping 140 matching lines @@
   worker_task_runner_ = new WorkerThreadTaskRunner(
       WorkerTaskRunner::Instance()->CurrentWorkerId());
   DCHECK_NE(0, WorkerTaskRunner::Instance()->CurrentWorkerId());
   // g_worker_client_tls.Pointer()->Get() could return NULL if this context
   // gets deleted before workerContextStarted() is called.
   DCHECK(g_worker_client_tls.Pointer()->Get() == NULL);
   DCHECK(!script_context_);
   g_worker_client_tls.Pointer()->Set(this);
   script_context_.reset(new ServiceWorkerScriptContext(this, proxy));
 
+  SetRegistrationInServiceWorkerGlobalScope();
+
   Send(new EmbeddedWorkerHostMsg_WorkerScriptLoaded(
       embedded_worker_id_,
       WorkerTaskRunner::Instance()->CurrentWorkerId()));
 
   // Schedule a task to send back WorkerStarted asynchronously,
   // so that at the time we send it we can be sure that the worker
   // script has been evaluated and worker run loop has been started.
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&EmbeddedWorkerContextClient::SendWorkerStarted,
@@ skipping 152 matching lines @@
     int request_id,
     bool accept_connection) {
   DCHECK(script_context_);
   script_context_->DidHandleCrossOriginConnectEvent(request_id,
                                                     accept_connection);
 }
 
 blink::WebServiceWorkerNetworkProvider*
 EmbeddedWorkerContextClient::createServiceWorkerNetworkProvider(
     blink::WebDataSource* data_source) {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
+
   // Create a content::ServiceWorkerNetworkProvider for this data source so
   // we can observe its requests.
   scoped_ptr<ServiceWorkerNetworkProvider> provider(
       new ServiceWorkerNetworkProvider(MSG_ROUTING_NONE));
+  provider_context_ = provider->context();
 
   // 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());
@@ skipping 43 matching lines @@
 }
 
 void EmbeddedWorkerContextClient::SendWorkerStarted() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "EmbeddedWorkerContextClient::StartingWorkerContext",
                          this);
   Send(new EmbeddedWorkerHostMsg_WorkerStarted(embedded_worker_id_));
 }
 
+void EmbeddedWorkerContextClient::SetRegistrationInServiceWorkerGlobalScope() {
+  DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(provider_context_);
+  DCHECK(script_context_);
+
+  ServiceWorkerDispatcher* dispatcher =
+      ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
+          thread_safe_sender());
+
+  // Register a registration with the dispatcher living on the worker thread.
+  scoped_ptr<WebServiceWorkerRegistrationImpl> registration(
+      dispatcher->CreateServiceWorkerRegistration(
+          provider_context_->registration()->info(), false));
+
+  // Register workers with the dispatcher living on the worker thread.
+  ServiceWorkerVersionAttributes attrs =
+      provider_context_->GetVersionAttributes();

[kinuko, 2015/01/22 08:05:44]

It feels it's a bit odd to call two locked methods (registration() and
GetVersionAttributes()) separately, though it should be ok

[nhiroki, 2015/01/22 09:09:16]

Agree. I'll make a followup patch (probably we can merge them?)

+  registration->SetInstalling(
+      dispatcher->GetServiceWorker(attrs.installing, false));
+  registration->SetWaiting(
+      dispatcher->GetServiceWorker(attrs.waiting, false));
+  registration->SetActive(
+      dispatcher->GetServiceWorker(attrs.active, false));
+
+  script_context_->SetRegistrationInServiceWorkerGlobalScope(
+      registration.Pass());
+}
+
 }  // namespace content