ServiceWorker: Convert ServiceWorkerDatabase::Status to string for logging

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/files/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 250 matching lines @@
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForDocument(document_url);
     ServiceWorkerStatusCode status = installing_registration.get() ?
         SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND;
     TRACE_EVENT_INSTANT2(
         "ServiceWorker",
         "ServiceWorkerStorage::FindRegistrationForDocument:CheckInstalling",
         TRACE_EVENT_SCOPE_THREAD,
         "URL", document_url.spec(),
-        "Status", (status == SERVICE_WORKER_OK) ? "Found" : "Not Found");
+        "Status", ServiceWorkerStatusToString(status));
     CompleteFindNow(installing_registration,
                     status,
                     callback);
     return;
   }
 
   // To connect this TRACE_EVENT with the callback, TimeTicks is used for
   // callback id.
   int64 callback_id = base::TimeTicks::Now().ToInternalValue();
   TRACE_EVENT_ASYNC_BEGIN1(
@@ skipping 469 matching lines @@
   DCHECK(data);
   DCHECK_EQ(INITIALIZING, state_);
 
   if (status == ServiceWorkerDatabase::STATUS_OK) {
     next_registration_id_ = data->next_registration_id;
     next_version_id_ = data->next_version_id;
     next_resource_id_ = data->next_resource_id;
     registered_origins_.swap(data->origins);
     state_ = INITIALIZED;
   } else {
-    // TODO(nhiroki): Stringify |status| using StatusToString() defined in
-    // service_worker_database.cc.
-    DVLOG(2) << "Failed to initialize: " << status;
+    DVLOG(2) << "Failed to initialize: "
+             << ServiceWorkerDatabase::StatusToString(status);
     ScheduleDeleteAndStartOver();
   }
 
   for (std::vector<base::Closure>::const_iterator it = pending_tasks_.begin();
        it != pending_tasks_.end(); ++it) {
     RunSoon(FROM_HERE, *it);
   }
   pending_tasks_.clear();
 }
 
 void ServiceWorkerStorage::DidFindRegistrationForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback,
     int64 callback_id,
     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",
         callback_id,
-        "Status", "OK");
+        "Status", ServiceWorkerDatabase::StatusToString(status));
     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(
+    ServiceWorkerStatusCode installing_status = installing_registration.get() ?
+        SERVICE_WORKER_OK : SERVICE_WORKER_ERROR_NOT_FOUND;
+    callback.Run(installing_status, installing_registration);
+    TRACE_EVENT_ASYNC_END2(
         "ServiceWorker",
         "ServiceWorkerStorage::FindRegistrationForDocument",
         callback_id,
-        "Status", status);
+        "Status", ServiceWorkerDatabase::StatusToString(status),
+        "Info",
+        (installing_status == SERVICE_WORKER_OK) ?
+            "Installing registration is found" :
+            "Any registrations are not found");
     return;
   }
 
   ScheduleDeleteAndStartOver();
   callback.Run(DatabaseStatusToStatusCode(status),
                scoped_refptr<ServiceWorkerRegistration>());
   TRACE_EVENT_ASYNC_END1(
       "ServiceWorker",
       "ServiceWorkerStorage::FindRegistrationForDocument",
       callback_id,
-      "Status", status);
+      "Status", ServiceWorkerDatabase::StatusToString(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 569 matching lines @@
   DVLOG(1) << "Schedule to delete the context and start over.";
   context_->ScheduleDeleteAndStartOver();
 }
 
 void ServiceWorkerStorage::DidDeleteDatabase(
     const StatusCallback& callback,
     ServiceWorkerDatabase::Status status) {
   DCHECK_EQ(DISABLED, state_);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     // Give up the corruption recovery until the browser restarts.
-    LOG(ERROR) << "Failed to delete the database: " << status;
+    LOG(ERROR) << "Failed to delete the database: "
+               << ServiceWorkerDatabase::StatusToString(status);
     callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDatabase successfully.";
 
   // Delete the disk cache on the cache thread.
   // TODO(nhiroki): What if there is a bunch of files in the cache directory?
   // Deleting the directory could take a long time and restart could be delayed.
   // We should probably rename the directory and delete it later.
   PostTaskAndReplyWithResult(
@@ skipping 12 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