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_ = ALLOCATING_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 49 matching lines @@
                              thread_id_, embedded_worker_id_, message));
 }
 
 EmbeddedWorkerInstance::EmbeddedWorkerInstance(
     base::WeakPtr<ServiceWorkerContextCore> context,
     int embedded_worker_id)
     : context_(context),
       registry_(context->embedded_worker_registry()),
       embedded_worker_id_(embedded_worker_id),
       status_(STOPPED),
+      starting_phase_(NOT_STARTING),
       process_id_(-1),
       thread_id_(kInvalidEmbeddedWorkerThreadId),
       devtools_attached_(false),
       network_accessed_for_script_(false),
       weak_factory_(this) {
 }
 
 // static
 void EmbeddedWorkerInstance::RunProcessAllocated(
     base::WeakPtr<EmbeddedWorkerInstance> instance,
@@ skipping 32 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_ = REGISTERING_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_ = SENT_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_DOWNLOADING;
   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 ALLOCATING_PROCESS:
+      return "Allocating process";
+    case REGISTERING_TO_DEVTOOLS:
+      return "Registering to DevTools";
+    case SENT_START_WORKER:
+      return "Sent StartWorker message to renderer";
+    case SCRIPT_DOWNLOADING:
+      return "Script downloading";
+    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