Introduce ServiceWorker.EventDispatchingDelay UMA

content/browser/service_worker/service_worker_fetch_dispatcher.cc

 // Copyright 2014 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_fetch_dispatcher.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
+#include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_utils.h"
 
 namespace content {
 
 namespace {
 
 using EventType = ServiceWorkerMetrics::EventType;
 EventType ResourceTypeToEventType(ResourceType resource_type) {
@@ skipping 46 matching lines @@
   return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL;
 }
 
 }  // namespace
 
 // Helper to receive the fetch event response even if
 // ServiceWorkerFetchDispatcher has been destroyed.
 class ServiceWorkerFetchDispatcher::ResponseCallback {
  public:
   ResponseCallback(base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher,
-                   ServiceWorkerVersion* version)
-      : fetch_dispatcher_(fetch_dispatcher), version_(version) {}
+                   ServiceWorkerVersion* version,
+                   const base::Time& start_time)
+      : fetch_dispatcher_(fetch_dispatcher),
+        version_(version),
+        start_time_(start_time) {}
 
   void Run(int request_id,
            ServiceWorkerFetchEventResult fetch_result,
-           const ServiceWorkerResponse& response) {
+           const ServiceWorkerResponse& response,
+           base::Time event_dispatch_time) {
+    ServiceWorkerMetrics::RecordFetchEventDispatchingDelay(
+        event_dispatch_time - start_time_, version_->site_for_uma());
+
     const bool handled =
         (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE);
     if (!version_->FinishRequest(request_id, handled))
       NOTREACHED() << "Should only receive one reply per event";
 
     // |fetch_dispatcher| is null if the URLRequest was killed.
     if (fetch_dispatcher_)
       fetch_dispatcher_->DidFinish(request_id, fetch_result, response);
   }
 
  private:
   base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
   // Owns |this|.
   ServiceWorkerVersion* version_;
+  base::Time start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(ResponseCallback);
 };
 
 ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     ServiceWorkerVersion* version,
     ResourceType resource_type,
     const net::BoundNetLog& net_log,
     const base::Closure& prepare_callback,
@@ skipping 81 matching lines @@
 
   net_log_.BeginEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT);
   int response_id = version_->StartRequest(
       GetEventType(),
       base::Bind(&ServiceWorkerFetchDispatcher::DidFailToDispatch,
                  weak_factory_.GetWeakPtr()));
   int event_finish_id = version_->StartRequest(
       FetchTypeToWaitUntilEventType(request_->fetch_type),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 
-  ResponseCallback* response_callback =
-      new ResponseCallback(weak_factory_.GetWeakPtr(), version_.get());
+  ResponseCallback* response_callback = new ResponseCallback(
+      weak_factory_.GetWeakPtr(), version_.get(), base::Time::Now());
   version_->RegisterRequestCallback<ServiceWorkerHostMsg_FetchEventResponse>(
       response_id,
       base::Bind(&ServiceWorkerFetchDispatcher::ResponseCallback::Run,
                  base::Owned(response_callback)));
   version_->RegisterSimpleRequest<ServiceWorkerHostMsg_FetchEventFinished>(
       event_finish_id);
   version_->DispatchEvent({response_id, event_finish_id},
                           ServiceWorkerMsg_FetchEvent(
                               response_id, event_finish_id, *request_.get()));
 }
@@ skipping 36 matching lines @@
 }
 
 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType()
     const {
   if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH;
   return ResourceTypeToEventType(resource_type_);
 }
 
 }  // namespace content