Mojofy unittests: ServiceWorkerJobTest

content/browser/service_worker/embedded_worker_instance.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/browser/service_worker/embedded_worker_instance.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
@@ skipping 357 matching lines @@
                                  "OnSetupOnUICompleted");
 
     // Notify the instance that it is registered to the devtools manager.
     instance_->OnRegisteredToDevToolsManager(
         is_new_process, worker_devtools_agent_route_id, wait_for_debugger);
 
     params->worker_devtools_agent_route_id = worker_devtools_agent_route_id;
     params->wait_for_debugger = wait_for_debugger;
 
     if (ServiceWorkerUtils::IsMojoForServiceWorkerEnabled())
-      instance_->SendMojoStartWorker(std::move(params));
+      SendMojoStartWorker(std::move(params));
     else
       SendStartWorker(std::move(params));
   }
 
   void SendStartWorker(std::unique_ptr<EmbeddedWorkerStartParams> params) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     ServiceWorkerStatusCode status = instance_->registry_->SendStartWorker(
         std::move(params), instance_->process_id());
     TRACE_EVENT_ASYNC_STEP_PAST1(
         "ServiceWorker", "EmbeddedWorkerInstance::Start", this,
         "SendStartWorker", "Status", ServiceWorkerStatusToString(status));
     if (status != SERVICE_WORKER_OK) {
       StatusCallback callback = start_callback_;
       start_callback_.Reset();
       instance_->OnStartFailed(callback, status);
       // |this| may be destroyed.
       return;
     }
     instance_->OnStartWorkerMessageSent();
 
     // |start_callback_| will be called via RunStartCallback() when the script
     // is evaluated.
   }
 
+  void SendMojoStartWorker(std::unique_ptr<EmbeddedWorkerStartParams> params) {
+    ServiceWorkerStatusCode status =
+        instance_->SendMojoStartWorker(std::move(params));
+    if (status != SERVICE_WORKER_OK) {
+      StatusCallback callback = start_callback_;
+      start_callback_.Reset();
+      instance_->OnStartFailed(callback, status);
+      // |this| may be destroyed.
+      return;
+    }
+  }
+
   // |instance_| must outlive |this|.
   EmbeddedWorkerInstance* instance_;
 
   // Ownership is transferred by base::Passed() to a task after process
   // allocation.
   mojom::EmbeddedWorkerInstanceClientRequest request_;
 
   StatusCallback start_callback_;
   ProcessAllocationState state_;
 
@@ skipping 181 matching lines @@
   }
   if (wait_for_debugger) {
     // We don't measure the start time when wait_for_debugger flag is set. So
     // we set the NULL time here.
     step_time_ = base::TimeTicks();
   }
   for (auto& observer : listener_list_)
     observer.OnRegisteredToDevToolsManager();
 }
 
-void EmbeddedWorkerInstance::SendMojoStartWorker(
+ServiceWorkerStatusCode EmbeddedWorkerInstance::SendMojoStartWorker(
     std::unique_ptr<EmbeddedWorkerStartParams> params) {
+  if (!context_)
+    return SERVICE_WORKER_ERROR_ABORT;
   service_manager::mojom::InterfaceProviderPtr remote_interfaces;
   service_manager::mojom::InterfaceProviderRequest request =
       mojo::GetProxy(&remote_interfaces);
   remote_interfaces_->Bind(std::move(remote_interfaces));
   service_manager::mojom::InterfaceProviderPtr exposed_interfaces;
   interface_registry_->Bind(mojo::GetProxy(&exposed_interfaces));
   client_->StartWorker(*params, std::move(exposed_interfaces),
                        std::move(request));
   registry_->BindWorkerToProcess(process_id(), embedded_worker_id());
   TRACE_EVENT_ASYNC_STEP_PAST1("ServiceWorker", "EmbeddedWorkerInstance::Start",
                                this, "SendStartWorker", "Status", "mojo");
   OnStartWorkerMessageSent();
+  return SERVICE_WORKER_OK;
 }
 
 void EmbeddedWorkerInstance::OnStartWorkerMessageSent() {
   if (!step_time_.is_null()) {
     base::TimeDelta duration = UpdateStepTime();
     if (inflight_start_task_->is_installed()) {
       ServiceWorkerMetrics::RecordTimeToSendStartWorker(duration,
                                                         start_situation_);
     }
   }
@@ skipping 322 matching lines @@
     case SCRIPT_READ_FINISHED:
       return "Script read finished";
     case STARTING_PHASE_MAX_VALUE:
       NOTREACHED();
   }
   NOTREACHED() << phase;
   return std::string();
 }
 
 }  // namespace content