service worker: Attribute purpose to start worker attempts for UMA

content/browser/service_worker/service_worker_version.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/service_worker_version.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <string>
@@ skipping 285 matching lines @@
 
 ServiceWorkerVersion::~ServiceWorkerVersion() {
   in_dtor_ = true;
 
   // The user may have closed the tab waiting for SW to start up.
   if (GetTickDuration(start_time_) >
       base::TimeDelta::FromSeconds(
           kDestructedStartingWorkerTimeoutThresholdSeconds)) {
     DCHECK(timeout_timer_.IsRunning());
     DCHECK(!embedded_worker_->devtools_attached());
-    RecordStartWorkerResult(SERVICE_WORKER_ERROR_TIMEOUT);
+
+    // RecordStartWorkerResult must be in start_callbacks_.
+    DCHECK(!start_callbacks_.empty());
+    RecordStartWorkerResult(ServiceWorkerMetrics::EventType::UNKNOWN,
+                            SERVICE_WORKER_ERROR_TIMEOUT);
   }
 
   if (context_)
     context_->RemoveLiveVersion(version_id_);
 
   if (running_status() == STARTING || running_status() == RUNNING)
     embedded_worker_->Stop();
   embedded_worker_->RemoveListener(this);
 }
 
@@ skipping 37 matching lines @@
   }
   if (!main_script_http_info_)
     return info;
   info.script_response_time = main_script_http_info_->response_time;
   if (main_script_http_info_->headers)
     main_script_http_info_->headers->GetLastModifiedValue(
         &info.script_last_modified);
   return info;
 }
 
-void ServiceWorkerVersion::StartWorker(const StatusCallback& callback) {
+void ServiceWorkerVersion::StartWorker(
+    const StatusCallback& callback,
+    ServiceWorkerMetrics::EventType purpose) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!context_) {
-    RecordStartWorkerResult(SERVICE_WORKER_ERROR_ABORT);
+    RecordStartWorkerResult(purpose, SERVICE_WORKER_ERROR_ABORT);
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_ABORT));
     return;
   }
   if (is_redundant()) {
-    RecordStartWorkerResult(SERVICE_WORKER_ERROR_REDUNDANT);
+    RecordStartWorkerResult(purpose, SERVICE_WORKER_ERROR_REDUNDANT);
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_REDUNDANT));
     return;
   }
   if (IsDisabled()) {
-    RecordStartWorkerResult(SERVICE_WORKER_ERROR_DISABLED_WORKER);
+    RecordStartWorkerResult(purpose, SERVICE_WORKER_ERROR_DISABLED_WORKER);
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_DISABLED_WORKER));
 
     // Show a message in DevTools for developers.
     ReportError(SERVICE_WORKER_ERROR_DISABLED_WORKER,
                 "The service worker is disabled because its start failure "
                 "count is too high.");
     return;
   }
 
   // Check that the worker is allowed to start on the given scope. Since this
   // worker might not be used for a specific frame/process, use -1.
   // resource_context() can return null in unit tests.
   if (context_->wrapper()->resource_context() &&
       !GetContentClient()->browser()->AllowServiceWorker(
           scope_, scope_, context_->wrapper()->resource_context(), -1, -1)) {
-    RecordStartWorkerResult(SERVICE_WORKER_ERROR_DISALLOWED);
+    RecordStartWorkerResult(purpose, SERVICE_WORKER_ERROR_DISALLOWED);
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_DISALLOWED));
     return;
   }
 
   prestart_status_ = status_;
 
   // Ensure the live registration during starting worker so that the worker can
   // get associated with it in SWDispatcherHost::OnSetHostedVersionId().
   context_->storage()->FindRegistrationForId(
-      registration_id_,
-      scope_.GetOrigin(),
+      registration_id_, scope_.GetOrigin(),
       base::Bind(&ServiceWorkerVersion::DidEnsureLiveRegistrationForStartWorker,
-                 weak_factory_.GetWeakPtr(),
-                 callback));
+                 weak_factory_.GetWeakPtr(), purpose, callback));
 }
 
 void ServiceWorkerVersion::StopWorker(const StatusCallback& callback) {
   if (running_status() == STOPPED) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
     return;
   }
   if (stop_callbacks_.empty()) {
     ServiceWorkerStatusCode status = embedded_worker_->Stop();
     if (status != SERVICE_WORKER_OK) {
@@ skipping 90 matching lines @@
   if (is_redundant()) {
     // The stop should be already scheduled, but try to stop immediately, in
     // order to release worker resources soon.
     StopWorkerIfIdle();
   }
   return true;
 }
 
 void ServiceWorkerVersion::RunAfterStartWorker(
     const base::Closure& task,
-    const StatusCallback& error_callback) {
+    const StatusCallback& error_callback,
+    ServiceWorkerMetrics::EventType purpose) {
   if (running_status() == RUNNING) {
     DCHECK(start_callbacks_.empty());
     task.Run();
     return;
   }
   StartWorker(base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
-                         error_callback, task));
+                         error_callback, task),
+              purpose);
 }
 
 void ServiceWorkerVersion::DispatchExtendableMessageEvent(
     ServiceWorkerProviderHost* sender_provider_host,
     const base::string16& message,
     const url::Origin& source_origin,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
   for (const TransferredMessagePort& port : sent_message_ports)
     MessagePortService::GetInstance()->HoldMessages(port.id);
@@ skipping 43 matching lines @@
   DispatchMessageEventInternal(message, sent_message_ports, callback);
 }
 
 void ServiceWorkerVersion::DispatchMessageEventInternal(
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
   OnBeginEvent();
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
-    StartWorker(base::Bind(
-        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
-        base::Bind(&RunErrorMessageCallback, sent_message_ports, callback),
-        base::Bind(&self::DispatchMessageEventInternal,
-                   weak_factory_.GetWeakPtr(), message, sent_message_ports,
-                   callback)));
+    StartWorker(base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
+                           base::Bind(&RunErrorMessageCallback,
+                                      sent_message_ports, callback),
+                           base::Bind(&self::DispatchMessageEventInternal,
+                                      weak_factory_.GetWeakPtr(), message,
+                                      sent_message_ports, callback)),
+                ServiceWorkerMetrics::EventType::MESSAGE);
     return;
   }
 
   // TODO(kinuko): Cleanup this (and corresponding unit test) when message
   // event becomes extendable, round-trip event. (crbug.com/498596)
   RestartTick(&idle_time_);
 
   MessagePortMessageFilter* filter =
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
   filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_MessageToWorker(
           message, sent_message_ports, new_routing_ids));
   RunSoon(base::Bind(callback, status));
 }
 
 void ServiceWorkerVersion::DispatchCrossOriginMessageEvent(
     const NavigatorConnectClient& client,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
   OnBeginEvent();
   // Unlike in the case of DispatchMessageEvent, here the caller is assumed to
   // have already put all the sent message ports on hold. So no need to do that
   // here again.
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
-    StartWorker(base::Bind(
-        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
-        base::Bind(&RunErrorMessageCallback, sent_message_ports, callback),
-        base::Bind(&self::DispatchCrossOriginMessageEvent,
-                   weak_factory_.GetWeakPtr(), client, message,
-                   sent_message_ports, callback)));
+    StartWorker(base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
+                           base::Bind(&RunErrorMessageCallback,
+                                      sent_message_ports, callback),
+                           base::Bind(&self::DispatchCrossOriginMessageEvent,
+                                      weak_factory_.GetWeakPtr(), client,
+                                      message, sent_message_ports, callback)),
+                ServiceWorkerMetrics::EventType::MESSAGE);
     return;
   }
 
   MessagePortMessageFilter* filter =
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
   filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_CrossOriginMessageToWorker(
           client, message, sent_message_ports, new_routing_ids));
@@ skipping 309 matching lines @@
     RunErrorMessageCallback(sent_message_ports, callback,
                             SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   RunAfterStartWorker(
       base::Bind(
           &ServiceWorkerVersion::DispatchExtendableMessageEventAfterStartWorker,
           weak_factory_.GetWeakPtr(), message, source_origin,
           sent_message_ports, ExtendableMessageEventSource(source_info),
           callback),
-      base::Bind(&RunErrorMessageCallback, sent_message_ports, callback));
+      base::Bind(&RunErrorMessageCallback, sent_message_ports, callback),
+      ServiceWorkerMetrics::EventType::MESSAGE);
 }
 
 void ServiceWorkerVersion::DispatchExtendableMessageEventAfterStartWorker(
     const base::string16& message,
     const url::Origin& source_origin,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const ExtendableMessageEventSource& source,
     const StatusCallback& callback) {
   int request_id =
       StartRequest(ServiceWorkerMetrics::EventType::MESSAGE, callback);
@@ skipping 396 matching lines @@
           base::Bind(&KillEmbeddedWorkerProcess, embedded_worker_->process_id(),
                      RESULT_CODE_KILLED_BAD_MESSAGE));
       return;
     }
   }
   set_foreign_fetch_scopes(sub_scopes);
   set_foreign_fetch_origins(origins);
 }
 
 void ServiceWorkerVersion::DidEnsureLiveRegistrationForStartWorker(
+    ServiceWorkerMetrics::EventType purpose,
     const StatusCallback& callback,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   scoped_refptr<ServiceWorkerRegistration> protect = registration;
   if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
     // When the registration has already been deleted from the storage but its
     // active worker is still controlling clients, the event should be
     // dispatched on the worker. However, the storage cannot find the
     // registration. To handle the case, check the live registrations here.
     protect = context_->GetLiveRegistration(registration_id_);
     if (protect) {
       DCHECK(protect->is_deleted());
       status = SERVICE_WORKER_OK;
     }
   }
   if (status != SERVICE_WORKER_OK) {
-    RecordStartWorkerResult(status);
+    RecordStartWorkerResult(purpose, status);
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
     return;
   }
   if (is_redundant()) {
-    RecordStartWorkerResult(SERVICE_WORKER_ERROR_REDUNDANT);
+    RecordStartWorkerResult(purpose, SERVICE_WORKER_ERROR_REDUNDANT);
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_REDUNDANT));
     return;
   }
 
   MarkIfStale();
 
   switch (running_status()) {
     case RUNNING:
       RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
       return;
     case STARTING:
       DCHECK(!start_callbacks_.empty());
       break;
     case STOPPING:
     case STOPPED:
       if (start_callbacks_.empty()) {
         start_callbacks_.push_back(
             base::Bind(&ServiceWorkerVersion::RecordStartWorkerResult,
-                       weak_factory_.GetWeakPtr()));
+                       weak_factory_.GetWeakPtr(), purpose));
       }
       break;
   }
 
   // Keep the live registration while starting the worker.
   start_callbacks_.push_back(
       base::Bind(&RunStartWorkerCallback, callback, protect));
 
   if (running_status() == STOPPED)
     StartWorkerInternal();
@@ skipping 171 matching lines @@
   }
 
   embedded_worker_->StopIfIdle();
 }
 
 bool ServiceWorkerVersion::HasInflightRequests() const {
   return !custom_requests_.IsEmpty() || !streaming_url_request_jobs_.empty();
 }
 
 void ServiceWorkerVersion::RecordStartWorkerResult(
+    ServiceWorkerMetrics::EventType purpose,
     ServiceWorkerStatusCode status) {
   base::TimeTicks start_time = start_time_;
   ClearTick(&start_time_);
 
   if (context_)
     context_->UpdateVersionFailureCount(version_id_, status);
 
-  ServiceWorkerMetrics::RecordStartWorkerStatus(status,
+  ServiceWorkerMetrics::RecordStartWorkerStatus(status, purpose,
                                                 IsInstalled(prestart_status_));
 
   if (status == SERVICE_WORKER_OK && !start_time.is_null() &&
       !skip_recording_startup_time_) {
     ServiceWorkerMetrics::RecordStartWorkerTime(GetTickDuration(start_time),
                                                 IsInstalled(prestart_status_));
   }
 
   if (status != SERVICE_WORKER_ERROR_TIMEOUT)
     return;
@@ skipping 164 matching lines @@
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ || running_status() != RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 }  // namespace content