[Not for review] record detailed time breakdown of SW related requests.

content/browser/service_worker/service_worker_provider_host.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_provider_host.h"
 
 #include <utility>
 
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
@@ skipping 353 matching lines @@
 std::unique_ptr<ServiceWorkerRequestHandler>
 ServiceWorkerProviderHost::CreateRequestHandler(
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     FetchRedirectMode redirect_mode,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     scoped_refptr<ResourceRequestBodyImpl> body,
-    bool skip_service_worker) {
+    bool skip_service_worker,
+    base::TimeTicks request_start) {
   // |skip_service_worker| is meant to apply to requests that could be handled
   // by a service worker, as opposed to requests for the service worker script
   // itself. So ignore it here for the service worker script and its imported
   // scripts.
   // TODO(falken): Really it should be treated as an error to set
   // |skip_service_worker| for requests to start the service worker, but it's
   // difficult to fix that renderer-side, since we don't know whether a request
   // is for a service worker without access to IsHostToRunningServiceWorker() as
   // that state is stored browser-side.
   if (IsHostToRunningServiceWorker() &&
       (resource_type == RESOURCE_TYPE_SERVICE_WORKER ||
        resource_type == RESOURCE_TYPE_SCRIPT)) {
     skip_service_worker = false;
   }
   if (skip_service_worker) {
     if (!ServiceWorkerUtils::IsMainResourceType(resource_type))
       return std::unique_ptr<ServiceWorkerRequestHandler>();
     return base::MakeUnique<ServiceWorkerURLTrackingRequestHandler>(
         context_, AsWeakPtr(), blob_storage_context, resource_type);
   }
   if (IsHostToRunningServiceWorker()) {
     return base::MakeUnique<ServiceWorkerContextRequestHandler>(
-        context_, AsWeakPtr(), blob_storage_context, resource_type);
+        context_, AsWeakPtr(), blob_storage_context, resource_type,
+        request_start);
   }
   if (ServiceWorkerUtils::IsMainResourceType(resource_type) ||
       controlling_version()) {
     return base::MakeUnique<ServiceWorkerControlleeRequestHandler>(
         context_, AsWeakPtr(), blob_storage_context, request_mode,
         credentials_mode, redirect_mode, resource_type, request_context_type,
-        frame_type, body);
+        frame_type, body, request_start);
   }
   return std::unique_ptr<ServiceWorkerRequestHandler>();
 }
 
 ServiceWorkerObjectInfo
 ServiceWorkerProviderHost::GetOrCreateServiceWorkerHandle(
     ServiceWorkerVersion* version) {
   DCHECK(dispatcher_host_);
   if (!context_ || !version)
     return ServiceWorkerObjectInfo();
@@ skipping 315 matching lines @@
       Send(new ServiceWorkerMsg_SetControllerServiceWorker(
           render_thread_id_, provider_id(),
           GetOrCreateServiceWorkerHandle(
               associated_registration_->active_version()),
           false /* shouldNotifyControllerChange */));
     }
   }
 }
 
 }  // namespace content