Service Worker: Migrate to version_uuid and surface ServiceWorker.id. (Chromium 2/3)

content/browser/service_worker/service_worker_internals_ui.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_internals_ui.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
     internals->web_ui()->CallJavascriptFunction(
         "serviceworker.onOperationComplete",
         FundamentalValue(static_cast<int>(status)),
         FundamentalValue(callback_id));
   }
 }
 
 void CallServiceWorkerVersionMethodWithVersionID(
     ServiceWorkerInternalsUI::ServiceWorkerVersionMethod method,
     scoped_refptr<ServiceWorkerContextWrapper> context,
-    int64 version_id,
+    std::string version_uuid,
     const ServiceWorkerInternalsUI::StatusCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(CallServiceWorkerVersionMethodWithVersionID,
-                   method,
-                   context,
-                   version_id,
-                   callback));
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(CallServiceWorkerVersionMethodWithVersionID, method, context,
+                   version_uuid, callback));
     return;
   }
 
   scoped_refptr<ServiceWorkerVersion> version =
-      context->GetLiveVersion(version_id);
+      context->GetLiveVersion(version_uuid);
   if (!version.get()) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
   (*version.get().*method)(callback);
 }
 
 void DispatchPushEventWithVersionID(
     scoped_refptr<ServiceWorkerContextWrapper> context,
-    int64 version_id,
+    std::string version_uuid,
     const ServiceWorkerInternalsUI::StatusCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(DispatchPushEventWithVersionID,
-                   context,
-                   version_id,
-                   callback));
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(DispatchPushEventWithVersionID, context,
+                                       version_uuid, callback));
     return;
   }
 
   scoped_refptr<ServiceWorkerVersion> version =
-      context->GetLiveVersion(version_id);
+      context->GetLiveVersion(version_uuid);
   if (!version.get()) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
   std::string data = "Test push message from ServiceWorkerInternals.";
   version->DispatchPushEvent(callback, data);
 }
 
 void UpdateVersionInfo(const ServiceWorkerVersionInfo& version,
                        DictionaryValue* info) {
@@ skipping 26 matching lines @@
       info->SetString("status", "ACTIVATING");
       break;
     case ServiceWorkerVersion::ACTIVATED:
       info->SetString("status", "ACTIVATED");
       break;
     case ServiceWorkerVersion::REDUNDANT:
       info->SetString("status", "REDUNDANT");
       break;
   }
   info->SetString("script_url", version.script_url.spec());
-  info->SetString("version_id", base::Int64ToString(version.version_id));
+  info->SetString("version_uuid", version.version_uuid);
   info->SetInteger("process_id", version.process_id);
   info->SetInteger("thread_id", version.thread_id);
   info->SetInteger("devtools_agent_route_id", version.devtools_agent_route_id);
 }
 
 ListValue* GetRegistrationListValue(
     const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
   ListValue* result = new ListValue();
   for (std::vector<ServiceWorkerRegistrationInfo>::const_iterator it =
            registrations.begin();
        it != registrations.end();
        ++it) {
     const ServiceWorkerRegistrationInfo& registration = *it;
     DictionaryValue* registration_info = new DictionaryValue();
     registration_info->SetString("scope", registration.pattern.spec());
     registration_info->SetString(
         "registration_id", base::Int64ToString(registration.registration_id));
 
-    if (registration.active_version.version_id !=
-        kInvalidServiceWorkerVersionId) {
+    if (!registration.active_version.version_uuid.empty()) {
       DictionaryValue* active_info = new DictionaryValue();
       UpdateVersionInfo(registration.active_version, active_info);
       registration_info->Set("active", active_info);
     }
 
-    if (registration.waiting_version.version_id !=
-        kInvalidServiceWorkerVersionId) {
+    if (!registration.waiting_version.version_uuid.empty()) {
       DictionaryValue* waiting_info = new DictionaryValue();
       UpdateVersionInfo(registration.waiting_version, waiting_info);
       registration_info->Set("waiting", waiting_info);
     }
 
     result->Append(registration_info);
   }
   return result;
 }
 
@@ skipping 53 matching lines @@
 
 }  // namespace
 
 class ServiceWorkerInternalsUI::PartitionObserver
     : public ServiceWorkerContextObserver {
  public:
   PartitionObserver(int partition_id, WebUI* web_ui)
       : partition_id_(partition_id), web_ui_(web_ui) {}
   ~PartitionObserver() override {}
   // ServiceWorkerContextObserver overrides:
-  void OnRunningStateChanged(int64 version_id,
+  void OnRunningStateChanged(std::string version_uuid,
                              ServiceWorkerVersion::RunningStatus) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    web_ui_->CallJavascriptFunction(
-        "serviceworker.onRunningStateChanged", FundamentalValue(partition_id_),
-        StringValue(base::Int64ToString(version_id)));
+    web_ui_->CallJavascriptFunction("serviceworker.onRunningStateChanged",
+                                    FundamentalValue(partition_id_),
+                                    StringValue(version_uuid));
   }
-  void OnVersionStateChanged(int64 version_id,
+  void OnVersionStateChanged(std::string version_uuid,
                              ServiceWorkerVersion::Status) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    web_ui_->CallJavascriptFunction(
-        "serviceworker.onVersionStateChanged",
-        FundamentalValue(partition_id_),
-        StringValue(base::Int64ToString(version_id)));
+    web_ui_->CallJavascriptFunction("serviceworker.onVersionStateChanged",
+                                    FundamentalValue(partition_id_),
+                                    StringValue(version_uuid));
   }
-  void OnErrorReported(int64 version_id,
+  void OnErrorReported(std::string version_uuid,
                        int process_id,
                        int thread_id,
                        const ErrorInfo& info) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     ScopedVector<const Value> args;
     args.push_back(new FundamentalValue(partition_id_));
-    args.push_back(new StringValue(base::Int64ToString(version_id)));
+    args.push_back(new StringValue(version_uuid));
     args.push_back(new FundamentalValue(process_id));
     args.push_back(new FundamentalValue(thread_id));
     scoped_ptr<DictionaryValue> value(new DictionaryValue());
     value->SetString("message", info.error_message);
     value->SetInteger("lineNumber", info.line_number);
     value->SetInteger("columnNumber", info.column_number);
     value->SetString("sourceURL", info.source_url.spec());
     args.push_back(value.release());
     web_ui_->CallJavascriptFunction("serviceworker.onErrorReported",
                                     args.get());
   }
-  void OnReportConsoleMessage(int64 version_id,
+  void OnReportConsoleMessage(std::string version_uuid,
                               int process_id,
                               int thread_id,
                               const ConsoleMessage& message) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     ScopedVector<const Value> args;
     args.push_back(new FundamentalValue(partition_id_));
-    args.push_back(new StringValue(base::Int64ToString(version_id)));
+    args.push_back(new StringValue(version_uuid));
     args.push_back(new FundamentalValue(process_id));
     args.push_back(new FundamentalValue(thread_id));
     scoped_ptr<DictionaryValue> value(new DictionaryValue());
     value->SetInteger("sourceIdentifier", message.source_identifier);
     value->SetInteger("message_level", message.message_level);
     value->SetString("message", message.message);
     value->SetInteger("lineNumber", message.line_number);
     value->SetString("sourceURL", message.source_url.spec());
     args.push_back(value.release());
     web_ui_->CallJavascriptFunction("serviceworker.onConsoleMessageReported",
@@ skipping 182 matching lines @@
 }
 
 void ServiceWorkerInternalsUI::CallServiceWorkerVersionMethod(
     ServiceWorkerVersionMethod method,
     const ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int callback_id;
   const DictionaryValue* cmd_args = NULL;
   int partition_id;
   scoped_refptr<ServiceWorkerContextWrapper> context;
-  std::string version_id_string;
-  int64 version_id = 0;
+  std::string version_uuid;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
       !cmd_args->GetInteger("partition_id", &partition_id) ||
       !GetServiceWorkerContext(partition_id, &context) ||
-      !cmd_args->GetString("version_id", &version_id_string) ||
-      !base::StringToInt64(version_id_string, &version_id)) {
+      !cmd_args->GetString("version_uuid", &version_uuid)) {
     return;
   }
 
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
-  CallServiceWorkerVersionMethodWithVersionID(
-      method, context, version_id, callback);
+  CallServiceWorkerVersionMethodWithVersionID(method, context, version_uuid,
+                                              callback);
 }
 
 void ServiceWorkerInternalsUI::DispatchPushEvent(
     const ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int callback_id;
   int partition_id;
-  int64 version_id = 0;
-  std::string version_id_string;
+  std::string version_uuid = 0;
   const DictionaryValue* cmd_args = NULL;
   scoped_refptr<ServiceWorkerContextWrapper> context;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
       !cmd_args->GetInteger("partition_id", &partition_id) ||
       !GetServiceWorkerContext(partition_id, &context) ||
-      !cmd_args->GetString("version_id", &version_id_string) ||
-      !base::StringToInt64(version_id_string, &version_id)) {
+      !cmd_args->GetString("version_uuid", &version_uuid)) {
     return;
   }
 
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
-  DispatchPushEventWithVersionID(context, version_id, callback);
+  DispatchPushEventWithVersionID(context, version_uuid, callback);
 }
 
 void ServiceWorkerInternalsUI::InspectWorker(const ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int callback_id;
   const DictionaryValue* cmd_args = NULL;
   int process_id = 0;
   int devtools_agent_route_id = 0;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
@@ skipping 70 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
 
   // ServiceWorkerContextWrapper::UnregisterServiceWorker doesn't work here
   // because that reduces a status code to boolean.
   context->context()->UnregisterServiceWorker(scope, callback);
 }
 
 }  // namespace content