Speculatively launch Service Workers on mouse/touch events. [4/5]

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 <limits>
 #include <map>
@@ skipping 183 matching lines @@
 
 const int ServiceWorkerVersion::kTimeoutTimerDelaySeconds = 30;
 const int ServiceWorkerVersion::kStartInstalledWorkerTimeoutSeconds = 60;
 const int ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kRequestTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kStopWorkerTimeoutSeconds = 5;
 
 class ServiceWorkerVersion::Metrics {
  public:
   using EventType = ServiceWorkerMetrics::EventType;
-  explicit Metrics(ServiceWorkerVersion* owner) : owner_(owner) {}
+  explicit Metrics(ServiceWorkerVersion* owner, EventType start_worker_purpose)
+      : owner_(owner), start_worker_purpose_(start_worker_purpose) {}
   ~Metrics() {
     if (owner_->should_exclude_from_uma_)
       return;
     for (const auto& ev : event_stats_) {
       ServiceWorkerMetrics::RecordEventHandledRatio(
           ev.first, ev.second.handled_events, ev.second.fired_events);
     }
+    if (ServiceWorkerMetrics::IsNavigationHintEvent(start_worker_purpose_)) {
+      ServiceWorkerMetrics::RecordNavigationHintPrecision(
+          start_worker_purpose_, !event_stats_.empty());

[nhiroki, 2016/07/28 05:38:37]

Regarding |event_fired|, we might want to filter out events other than
FETCH_MAIN_FRAME because we mean to speculatively launch a worker for main
resource navigation, and counting other events could be noisy.

[horo, 2016/07/28 08:15:48]

Done.

+    }
   }
 
   void RecordEventHandledStatus(EventType event, bool handled) {
     event_stats_[event].fired_events++;
     if (handled)
       event_stats_[event].handled_events++;
   }
 
  private:
   struct EventStat {
     size_t fired_events = 0;
     size_t handled_events = 0;
   };
 
   ServiceWorkerVersion* owner_;
   std::map<EventType, EventStat> event_stats_;
+  const EventType start_worker_purpose_;
 
   DISALLOW_COPY_AND_ASSIGN(Metrics);
 };
 
 // A controller for periodically sending a ping to the worker to see
 // if the worker is not stalling.
 class ServiceWorkerVersion::PingController {
  public:
   explicit PingController(ServiceWorkerVersion* version) : version_(version) {}
   ~PingController() {}
@@ skipping 533 matching lines @@
 void ServiceWorkerVersion::OnStarting() {
   FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
 }
 
 void ServiceWorkerVersion::OnStarted() {
   DCHECK_EQ(EmbeddedWorkerStatus::RUNNING, running_status());
   RestartTick(&idle_time_);
 
   // Fire all start callbacks.
   scoped_refptr<ServiceWorkerVersion> protect(this);
-  RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_OK);
+  FinishStartWorker(SERVICE_WORKER_OK);
   FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
 }
 
 void ServiceWorkerVersion::OnStopping() {
   DCHECK(stop_time_.is_null());
   RestartTick(&stop_time_);
   TRACE_EVENT_ASYNC_BEGIN2("ServiceWorker", "ServiceWorkerVersion::StopWorker",
                            stop_time_.ToInternalValue(), "Script",
                            script_url_.spec(), "Version Status",
                            VersionStatusToString(status_));
@@ skipping 88 matching lines @@
                         OnRegisterForeignFetchScopes)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ServiceWorkerVersion::OnStartSentAndScriptEvaluated(
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK) {
     scoped_refptr<ServiceWorkerVersion> protect(this);
-    RunCallbacks(this, &start_callbacks_,
-                 DeduceStartWorkerFailureReason(status));
+    FinishStartWorker(DeduceStartWorkerFailureReason(status));
   }
 }
 
 void ServiceWorkerVersion::OnGetClient(int request_id,
                                        const std::string& client_uuid) {
   if (!context_)
     return;
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker", "ServiceWorkerVersion::OnGetClient",
                            request_id, "client_uuid", client_uuid);
   ServiceWorkerProviderHost* provider_host =
@@ skipping 419 matching lines @@
       DCHECK(!start_callbacks_.empty());
       break;
     case EmbeddedWorkerStatus::STOPPING:
     case EmbeddedWorkerStatus::STOPPED:
       if (start_callbacks_.empty()) {
         int trace_id = NextTraceId();
         TRACE_EVENT_ASYNC_BEGIN2(
             "ServiceWorker", "ServiceWorkerVersion::StartWorker", trace_id,
             "Script", script_url_.spec(), "Purpose",
             ServiceWorkerMetrics::EventTypeToString(purpose));
+        DCHECK(!start_worker_first_purpose_);
+        start_worker_first_purpose_.reset(
+            new ServiceWorkerMetrics::EventType(purpose));
         start_callbacks_.push_back(
             base::Bind(&ServiceWorkerVersion::RecordStartWorkerResult,
                        weak_factory_.GetWeakPtr(), purpose, prestart_status,
                        trace_id, is_browser_startup_complete));
       }
       break;
   }
 
   // Keep the live registration while starting the worker.
   start_callbacks_.push_back(
       base::Bind(&RunStartWorkerCallback, callback, protect));
 
   if (running_status() == EmbeddedWorkerStatus::STOPPED)
     StartWorkerInternal();
   DCHECK(timeout_timer_.IsRunning());
 }
 
 void ServiceWorkerVersion::StartWorkerInternal() {
   DCHECK_EQ(EmbeddedWorkerStatus::STOPPED, running_status());
 
   DCHECK(!metrics_);
-  metrics_.reset(new Metrics(this));
+  DCHECK(start_worker_first_purpose_);
+  metrics_.reset(new Metrics(this, *start_worker_first_purpose_));
+
+  // We don't clear |start_worker_first_purpose_| here but clear in
+  // FinishStartWorker. This is because StartWorkerInternal may be called
+  // again from OnStoppedInternal if StopWorker is called before OnStarted.
 
   StartTimeoutTimer();
 
   std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params(
       new EmbeddedWorkerMsg_StartWorker_Params());
   params->service_worker_version_id = version_id_;
   params->scope = scope_;
   params->script_url = script_url_;
   params->is_installed = IsInstalled(status_);
   params->pause_after_download = pause_after_download_;
@@ skipping 94 matching lines @@
   // Starting a worker hasn't finished within a certain period.
   const base::TimeDelta start_limit =
       IsInstalled(status())
           ? base::TimeDelta::FromSeconds(kStartInstalledWorkerTimeoutSeconds)
           : base::TimeDelta::FromMinutes(kStartNewWorkerTimeoutMinutes);
   if (GetTickDuration(start_time_) > start_limit) {
     DCHECK(running_status() == EmbeddedWorkerStatus::STARTING ||
            running_status() == EmbeddedWorkerStatus::STOPPING)
         << static_cast<int>(running_status());
     scoped_refptr<ServiceWorkerVersion> protect(this);
-    RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_ERROR_TIMEOUT);
+    FinishStartWorker(SERVICE_WORKER_ERROR_TIMEOUT);
     if (running_status() == EmbeddedWorkerStatus::STARTING)
       embedded_worker_->Stop();
     return;
   }
 
   // Requests have not finished before their expiration.
   bool stop_for_timeout = false;
   while (!timeout_queue_.empty()) {
     RequestInfo info = timeout_queue_.top();
     if (!RequestExpired(info.expiration))
@@ skipping 211 matching lines @@
                            should_restart);
     ClearTick(&stop_time_);
   }
   StopTimeoutTimer();
 
   // Fire all stop callbacks.
   RunCallbacks(this, &stop_callbacks_, SERVICE_WORKER_OK);
 
   if (!should_restart) {
     // Let all start callbacks fail.
-    RunCallbacks(this, &start_callbacks_,
-                 DeduceStartWorkerFailureReason(
-                     SERVICE_WORKER_ERROR_START_WORKER_FAILED));
+    FinishStartWorker(DeduceStartWorkerFailureReason(
+        SERVICE_WORKER_ERROR_START_WORKER_FAILED));
   }
 
   // Let all message callbacks fail (this will also fire and clear all
   // callbacks for events).
   // TODO(kinuko): Consider if we want to add queue+resend mechanism here.
   IDMap<PendingRequest, IDMapOwnPointer>::iterator iter(&pending_requests_);
   while (!iter.IsAtEnd()) {
     TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::Request",
                            iter.GetCurrentValue(), "Error", "Worker Stopped");
     iter.GetCurrentValue()->error_callback.Run(SERVICE_WORKER_ERROR_FAILED);
@@ skipping 24 matching lines @@
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ ||
       running_status() != EmbeddedWorkerStatus::RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
+void ServiceWorkerVersion::FinishStartWorker(ServiceWorkerStatusCode status) {
+  start_worker_first_purpose_.reset();
+  RunCallbacks(this, &start_callbacks_, status);
+}
+
 }  // namespace content