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

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 <algorithm>
 #include <utility>
 
 #include "base/bind_helpers.h"
@@ skipping 127 matching lines @@
                                    const GURL& script_url,
                                    bool pause_after_download,
                                    const StatusCallback& callback) {
   if (!context_) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
   DCHECK(status_ == STOPPED);
   start_timing_ = base::TimeTicks::Now();
   status_ = STARTING;
+  starting_phase_ = ALLOCATE_PROCESS;
   network_accessed_for_script_ = false;
   scoped_ptr<EmbeddedWorkerMsg_StartWorker_Params> params(
       new EmbeddedWorkerMsg_StartWorker_Params());
   TRACE_EVENT_ASYNC_BEGIN2("ServiceWorker",
                            "EmbeddedWorkerInstance::ProcessAllocate",
                            params.get(),
                            "Scope", scope.spec(),
                            "Script URL", script_url.spec());
   params->embedded_worker_id = embedded_worker_id_;
   params->service_worker_version_id = service_worker_version_id;
@@ skipping 53 matching lines @@
     base::WeakPtr<ServiceWorkerContextCore> context,
     int embedded_worker_id)
     : context_(context),
       registry_(context->embedded_worker_registry()),
       embedded_worker_id_(embedded_worker_id),
       status_(STOPPED),
       process_id_(-1),
       thread_id_(kInvalidEmbeddedWorkerThreadId),
       devtools_attached_(false),
       network_accessed_for_script_(false),
       weak_factory_(this) {

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

initializing starting_phase_ here?

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

Done.

 }
 
 // static
 void EmbeddedWorkerInstance::RunProcessAllocated(
     base::WeakPtr<EmbeddedWorkerInstance> instance,
     base::WeakPtr<ServiceWorkerContextCore> context,
     scoped_ptr<EmbeddedWorkerMsg_StartWorker_Params> params,
     const EmbeddedWorkerInstance::StatusCallback& callback,
     ServiceWorkerStatusCode status,
     int process_id) {
@@ skipping 27 matching lines @@
     status_ = STOPPED;
     callback.Run(status);
     return;
   }
   const int64 service_worker_version_id = params->service_worker_version_id;
   process_id_ = process_id;
   GURL script_url(params->script_url);
 
   // Register this worker to DevToolsManager on UI thread, then continue to
   // call SendStartWorker on IO thread.
+  starting_phase_ = REGISTER_TO_DEVTOOLS;
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(RegisterToWorkerDevToolsManagerOnUI,
                  process_id_,
                  context_.get(),
                  context_,
                  service_worker_version_id,
                  script_url,
                  base::Bind(&EmbeddedWorkerInstance::SendStartWorker,
@@ skipping 19 matching lines @@
     // wait_for_debugger flag is set. So we set the NULL time here.
     start_timing_ = base::TimeTicks();
   } else {
     DCHECK(!start_timing_.is_null());
     UMA_HISTOGRAM_TIMES("EmbeddedWorkerInstance.ProcessAllocation",
                         base::TimeTicks::Now() - start_timing_);
     // Reset |start_timing_| to measure the time excluding the process
     // allocation time.
     start_timing_ = base::TimeTicks::Now();
   }
+
+  starting_phase_ = SEND_START_WORKER;
   ServiceWorkerStatusCode status =
       registry_->SendStartWorker(params.Pass(), process_id_);
   if (status != SERVICE_WORKER_OK) {
     callback.Run(status);
     return;
   }
   DCHECK(start_callback_.is_null());
   start_callback_ = callback;
 }
 
 void EmbeddedWorkerInstance::OnReadyForInspection() {
   if (devtools_proxy_)
     devtools_proxy_->NotifyWorkerReadyForInspection();
 }
 
 void EmbeddedWorkerInstance::OnScriptLoaded(int thread_id) {
+  starting_phase_ = SCRIPT_LOADED;
   if (!start_timing_.is_null()) {
     if (network_accessed_for_script_) {
       UMA_HISTOGRAM_TIMES("EmbeddedWorkerInstance.ScriptLoadWithNetworkAccess",
                           base::TimeTicks::Now() - start_timing_);
     } else {
       UMA_HISTOGRAM_TIMES(
           "EmbeddedWorkerInstance.ScriptLoadWithoutNetworkAccess",
           base::TimeTicks::Now() - start_timing_);
     }
     // Reset |start_timing_| to measure the time excluding the process
     // allocation time and the script loading time.
     start_timing_ = base::TimeTicks::Now();
   }
   thread_id_ = thread_id;
   FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoaded());
 }
 
 void EmbeddedWorkerInstance::OnScriptLoadFailed() {
 }
 
 void EmbeddedWorkerInstance::OnScriptEvaluated(bool success) {
+  starting_phase_ = SCRIPT_EVALUATED;
   if (success && !start_timing_.is_null()) {
     UMA_HISTOGRAM_TIMES("EmbeddedWorkerInstance.ScriptEvaluate",
                         base::TimeTicks::Now() - start_timing_);
   }
   DCHECK(!start_callback_.is_null());
   start_callback_.Run(success ? SERVICE_WORKER_OK
                               : SERVICE_WORKER_ERROR_START_WORKER_FAILED);
   start_callback_.Reset();
 }
 
@@ skipping 72 matching lines @@
 
 void EmbeddedWorkerInstance::AddListener(Listener* listener) {
   listener_list_.AddObserver(listener);
 }
 
 void EmbeddedWorkerInstance::RemoveListener(Listener* listener) {
   listener_list_.RemoveObserver(listener);
 }
 
 void EmbeddedWorkerInstance::OnNetworkAccessedForScriptLoad() {
+  starting_phase_ = SCRIPT_DOWNLOAD;
   network_accessed_for_script_ = true;
 }
 
+// static
+std::string EmbeddedWorkerInstance::StatusToString(Status status) {
+  switch (status) {
+    case STOPPED:
+      return "STOPPED";
+    case STARTING:
+      return "STARTING";
+    case RUNNING:
+      return "RUNNING";
+    case STOPPING:
+      return "STOPPING";
+  }
+  NOTREACHED() << status;
+  return std::string();
+}
+
+// static
+std::string EmbeddedWorkerInstance::StartingPhaseToString(StartingPhase phase) {
+  switch (phase) {
+    case NOT_STARTING:
+      return "Not in STARTING status";
+    case ALLOCATE_PROCESS:
+      return "Allocate process";
+    case REGISTER_TO_DEVTOOLS:
+      return "Register to DevTools";
+    case SEND_START_WORKER:
+      return "Send StartWorker message to renderer";
+    case SCRIPT_DOWNLOAD:

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

nit: This one looks slightly inconsistent from others...
SCRIPT_DOWNLOADING? DOWNLOAD_SCRIPT?

Also for the ones that use imperative forms using -ing form might be more
understandable? (Just wondering, up to you)

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

Adjusted the names a bit, how's this?

+      return "Script download";
+    case SCRIPT_LOADED:
+      return "Script loaded";
+    case SCRIPT_EVALUATED:
+      return "Script evaluated";
+    case STARTING_PHASE_MAX_VALUE:
+      NOTREACHED();
+  }
+  NOTREACHED() << phase;
+  return std::string();
+}
+
 }  // namespace content