[ServiceWorker] Add EmbeddedWorkerInstanceHost Interface.

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 453 matching lines @@
 ServiceWorkerContextClient::ThreadSpecificInstance() {
   return g_worker_client_tls.Pointer()->Get();
 }
 
 ServiceWorkerContextClient::ServiceWorkerContextClient(
     int embedded_worker_id,
     int64_t service_worker_version_id,
     const GURL& service_worker_scope,
     const GURL& script_url,
     mojom::ServiceWorkerEventDispatcherRequest dispatcher_request,
+    mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host,
     std::unique_ptr<EmbeddedWorkerInstanceClientImpl> embedded_worker_client)
     : embedded_worker_id_(embedded_worker_id),
       service_worker_version_id_(service_worker_version_id),
       service_worker_scope_(service_worker_scope),
       script_url_(script_url),
       sender_(ChildThreadImpl::current()->thread_safe_sender()),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       proxy_(nullptr),
       pending_dispatcher_request_(std::move(dispatcher_request)),
       embedded_worker_client_(std::move(embedded_worker_client)) {
+  instance_host_ =
+      mojom::ThreadSafeEmbeddedWorkerInstanceHostAssociatedPtr::Create(
+          std::move(instance_host), main_thread_task_runner_);
   TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
                            "ServiceWorkerContextClient::StartingWorkerContext",
                            this);
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerContextClient::StartingWorkerContext",
       this,
       "PrepareWorker");
 }
 
@@ skipping 67 matching lines @@
   std::vector<char> copy(data, data + size);
   Send(new ServiceWorkerHostMsg_SetCachedMetadata(GetRoutingID(), url, copy));
 }
 
 void ServiceWorkerContextClient::clearCachedMetadata(
     const blink::WebURL& url) {
   Send(new ServiceWorkerHostMsg_ClearCachedMetadata(GetRoutingID(), url));
 }
 
 void ServiceWorkerContextClient::workerReadyForInspection() {
-  Send(new EmbeddedWorkerHostMsg_WorkerReadyForInspection(embedded_worker_id_));
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
+  (*instance_host_)->OnReadyForInspection();
 }
 
 void ServiceWorkerContextClient::workerContextFailedToStart() {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!proxy_);
 
-  Send(new EmbeddedWorkerHostMsg_WorkerScriptLoadFailed(embedded_worker_id_));
+  (*instance_host_)->OnScriptLoadFailed();
+  (*instance_host_)->OnStopped();
 
   RenderThreadImpl::current()->embedded_worker_dispatcher()->
       WorkerContextDestroyed(embedded_worker_id_);
 }
 
 void ServiceWorkerContextClient::workerScriptLoaded() {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!proxy_);
 
-  Send(new EmbeddedWorkerHostMsg_WorkerScriptLoaded(embedded_worker_id_));
+  (*instance_host_)->OnScriptLoaded();
 }
 
 bool ServiceWorkerContextClient::hasAssociatedRegistration() {
   return provider_context_ && provider_context_->HasAssociatedRegistration();
 }
 
 void ServiceWorkerContextClient::workerContextStarted(
     blink::WebServiceWorkerContextProxy* proxy) {
   DCHECK(!worker_task_runner_.get());
   DCHECK_NE(0, WorkerThread::GetCurrentId());
@@ skipping 17 matching lines @@
   DCHECK_NE(registration_info.registration_id,
             kInvalidServiceWorkerRegistrationId);
 
   DCHECK(pending_dispatcher_request_.is_pending());
   DCHECK(!context_->event_dispatcher_binding.is_bound());
   context_->event_dispatcher_binding.Bind(
       std::move(pending_dispatcher_request_));
 
   SetRegistrationInServiceWorkerGlobalScope(registration_info, version_attrs);
 
-  Send(new EmbeddedWorkerHostMsg_WorkerThreadStarted(
-      embedded_worker_id_, WorkerThread::GetCurrentId(),
-      provider_context_->provider_id()));
+  (*instance_host_)
+      ->OnThreadStarted(WorkerThread::GetCurrentId(),
+                        provider_context_->provider_id());
 
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerContextClient::StartingWorkerContext",
       this,
       "ExecuteScript");
 }
 
 void ServiceWorkerContextClient::didEvaluateWorkerScript(bool success) {
-  Send(new EmbeddedWorkerHostMsg_WorkerScriptEvaluated(
-      embedded_worker_id_, success));
+  DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
+  (*instance_host_)->OnScriptEvaluated(success);
 
   // Schedule a task to send back WorkerStarted asynchronously,
   // so that at the time we send it we can be sure that the
   // worker run loop has been started.
   worker_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ServiceWorkerContextClient::SendWorkerStarted,
                             GetWeakPtr()));
 }
 
 void ServiceWorkerContextClient::didInitializeWorkerContext(
@@ skipping 42 matching lines @@
   // Check if mojo is enabled
   if (ServiceWorkerUtils::IsMojoForServiceWorkerEnabled()) {
     DCHECK(embedded_worker_client_);
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&EmbeddedWorkerInstanceClientImpl::StopWorkerCompleted,
                    base::Passed(&embedded_worker_client_)));
     return;
   }
 
+  (*instance_host_)->OnStopped();
+
   // Now we should be able to free the WebEmbeddedWorker container on the
   // main thread.
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CallWorkerContextDestroyedOnMainThread,
                  embedded_worker_id_));
 }
 
 void ServiceWorkerContextClient::countFeature(uint32_t feature) {
   Send(new EmbeddedWorkerHostMsg_CountFeature(service_worker_version_id_,
                                               feature));
 }
 
 void ServiceWorkerContextClient::reportException(
     const blink::WebString& error_message,
     int line_number,
     int column_number,
     const blink::WebString& source_url) {
-  Send(new EmbeddedWorkerHostMsg_ReportException(
-      embedded_worker_id_, error_message.utf16(), line_number, column_number,
-      blink::WebStringToGURL(source_url)));
+  (*instance_host_)
+      ->OnReportException(error_message.utf16(), line_number, column_number,
+                          blink::WebStringToGURL(source_url));
 }
 
 void ServiceWorkerContextClient::reportConsoleMessage(
     int source,
     int level,
     const blink::WebString& message,
     int line_number,
     const blink::WebString& source_url) {
-  EmbeddedWorkerHostMsg_ReportConsoleMessage_Params params;
-  params.source_identifier = source;
-  params.message_level = level;
-  params.message = message.utf16();
-  params.line_number = line_number;
-  params.source_url = blink::WebStringToGURL(source_url);
-
-  Send(new EmbeddedWorkerHostMsg_ReportConsoleMessage(
-      embedded_worker_id_, params));
+  (*instance_host_)
+      ->OnReportConsoleMessage(source, level, message.utf16(), line_number,
+                               blink::WebStringToGURL(source_url));
 }
 
 void ServiceWorkerContextClient::sendDevToolsMessage(
     int session_id,
     int call_id,
     const blink::WebString& message,
     const blink::WebString& state_cookie) {
   // Return if this context has been stopped.
   if (!embedded_worker_client_)
     return;
@@ skipping 315 matching lines @@
 
 void ServiceWorkerContextClient::Send(IPC::Message* message) {
   sender_->Send(message);
 }
 
 void ServiceWorkerContextClient::SendWorkerStarted() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerContextClient::StartingWorkerContext",
                          this);
-  Send(new EmbeddedWorkerHostMsg_WorkerStarted(embedded_worker_id_));
+  (*instance_host_)->OnStarted();
 }
 
 void ServiceWorkerContextClient::SetRegistrationInServiceWorkerGlobalScope(
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   ServiceWorkerDispatcher* dispatcher =
       ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
           sender_.get(), main_thread_task_runner_.get());
 
@@ skipping 417 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content