ServiceWorker: Insert TRACE_EVENT to watch a breakdown of the ServiceWorker's performance on chome:…

content/browser/service_worker/service_worker_storage.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_storage.h"
 
 #include <string>
 
 #include "base/bind_helpers.h"
+#include "base/debug/trace_event.h"
 #include "base/file_util.h"
+#include "base/hash.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
@@ skipping 222 matching lines @@
                                context,
                                old_storage->database_task_runner_,
                                old_storage->disk_cache_thread_,
                                old_storage->quota_manager_proxy_.get()));
 }
 
 void ServiceWorkerStorage::FindRegistrationForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback) {
   DCHECK(!document_url.has_ref());
+  TRACE_EVENT_ASYNC_BEGIN1(
+      "ServiceWorker",
+      "ServiceWorkerStorage::FindRegistrationForDocument",
+      base::Hash(document_url.spec()),

[horo, 2014/09/05 11:02:32]

I think we can use the pointer of callback as ID.

[shimazu, 2014/09/08 07:04:46]

I think so, too.
But the pointer is different between in FindRegistrationForDocument and in
DidFindRegistrationForDocument. I don't know the internal implementation of
base::Bind well, so I used the document_url.spec() as better solution.
Do you have any idea of this?

+      "URL", document_url.spec());
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForDocument,
           weak_factory_.GetWeakPtr(), document_url, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindNow(scoped_refptr<ServiceWorkerRegistration>(),
                       SERVICE_WORKER_ERROR_FAILED, callback);
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
@@ skipping 497 matching lines @@
 }
 
 void ServiceWorkerStorage::DidFindRegistrationForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources,
     ServiceWorkerDatabase::Status status) {
   if (status == ServiceWorkerDatabase::STATUS_OK) {
     ReturnFoundRegistration(callback, data, resources);
+    TRACE_EVENT_ASYNC_END1(
+        "ServiceWorker",
+        "ServiceWorkerStorage::FindRegistrationForDocument -> "
+        "ServiceWorkerStorage::DidFindRegistrationForDocument",
+        base::Hash(document_url.spec()),
+        "Status", "OK");
     return;
   }
 
   if (status == ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForDocument(document_url);
     callback.Run(installing_registration.get() ? SERVICE_WORKER_OK
                                                : SERVICE_WORKER_ERROR_NOT_FOUND,
                  installing_registration);
+    TRACE_EVENT_ASYNC_END1(
+        "ServiceWorker",
+        "ServiceWorkerStorage::FindRegistrationForDocument -> "
+        "ServiceWorkerStorage::DidFindRegistrationForDocument",
+        base::Hash(document_url.spec()),
+        "Status", status);
     return;
   }
 
   ScheduleDeleteAndStartOver();
   callback.Run(DatabaseStatusToStatusCode(status),
                scoped_refptr<ServiceWorkerRegistration>());
+  TRACE_EVENT_ASYNC_END1(
+      "ServiceWorker",
+      "ServiceWorkerStorage::FindRegistrationForDocument -> "
+      "ServiceWorkerStorage::DidFindRegistrationForDocument",
+      base::Hash(document_url.spec()),
+      "Status", status);
 }
 
 void ServiceWorkerStorage::DidFindRegistrationForPattern(
     const GURL& scope,
     const FindRegistrationCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources,
     ServiceWorkerDatabase::Status status) {
   if (status == ServiceWorkerDatabase::STATUS_OK) {
     ReturnFoundRegistration(callback, data, resources);
@@ skipping 602 matching lines @@
     // Give up the corruption recovery until the browser restarts.
     LOG(ERROR) << "Failed to delete the diskcache.";
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content