Service Worker: Add metrics and timeout for starting a Service Worker.

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/lazy_instance.h"
@@ skipping 190 matching lines @@
   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(),
       provider_context_->provider_id()));
 
-  // 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,
-                 weak_factory_.GetWeakPtr()));
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "EmbeddedWorkerContextClient::StartingWorkerContext",
       this,
       "ExecuteScript");
 }
 
 void EmbeddedWorkerContextClient::didEvaluateWorkerScript(bool success) {
   Send(new EmbeddedWorkerHostMsg_WorkerScriptEvaluated(
       embedded_worker_id_, 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(&EmbeddedWorkerContextClient::SendWorkerStarted,
+                            weak_factory_.GetWeakPtr()));

[kinuko, 2015/03/02 03:19:33]

Did you need to move this method? Could you explain a bit?

[falken, 2015/03/02 04:19:17]

It's just a cleanup. It was pretty confusing to reason about the message order
with the current code. Now it should be more clear the order is ScriptLoaded,
ScriptEvaluated, WorkerStarted.

[kinuko, 2015/03/02 06:13:19]

I see. We probably don't need to call the SendWorkerStarted asynchronously in
the new code?

[falken, 2015/03/02 06:33:16]

Yes I think the only reason we'd send async is if something happens
synchronously after evaluate() that we want to make sure finishes, which
probably isn't the case. I think WorkerScriptEvaluated and WorkerStarted could
probably be combined to the same message.

 }
 
 void EmbeddedWorkerContextClient::willDestroyWorkerContext() {
   // At this point OnWorkerRunLoopStopped is already called, so
   // worker_task_runner_->RunsTasksOnCurrentThread() returns false
   // (while we're still on the worker thread).
   script_context_.reset();
 
   // This also lets the message filter stop dispatching messages to
   // this client.
@@ skipping 229 matching lines @@
   registration->SetWaiting(
       dispatcher->GetServiceWorker(attrs.waiting, false));
   registration->SetActive(
       dispatcher->GetServiceWorker(attrs.active, false));
 
   script_context_->SetRegistrationInServiceWorkerGlobalScope(
       registration.Pass());
 }
 
 }  // namespace content