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

content/browser/service_worker/service_worker_context_watcher.cc

 // Copyright 2015 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_context_watcher.h"
 
 #include "base/bind.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
@@ skipping 103 matching lines @@
                 scoped_ptr<ServiceWorkerRegistrationInfo>(
                     new ServiceWorkerRegistrationInfo(registration_info)));
   StoreVersionInfo(registration_info.active_version);
   StoreVersionInfo(registration_info.waiting_version);
   StoreVersionInfo(registration_info.installing_version);
 }
 
 void ServiceWorkerContextWatcher::StoreVersionInfo(
     const ServiceWorkerVersionInfo& version_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (version_info.version_id == kInvalidServiceWorkerVersionId)
+  if (!version_info.version_uuid.empty())
     return;
-  version_info_map_.set(version_info.version_id,
+  version_info_map_.set(version_info.version_uuid,
                         scoped_ptr<ServiceWorkerVersionInfo>(
                             new ServiceWorkerVersionInfo(version_info)));
 }
 
 void ServiceWorkerContextWatcher::SendRegistrationInfo(
     int64 registration_id,
     const GURL& pattern,
     ServiceWorkerRegistrationInfo::DeleteFlag delete_flag) {
   std::vector<ServiceWorkerRegistrationInfo> registrations;
   registrations.push_back(
@@ skipping 10 matching lines @@
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(version_callback_, versions));
 }
 
 void ServiceWorkerContextWatcher::OnNewLiveRegistration(int64 registration_id,
                                                         const GURL& pattern) {
   SendRegistrationInfo(registration_id, pattern,
                        ServiceWorkerRegistrationInfo::IS_NOT_DELETED);
 }
 
-void ServiceWorkerContextWatcher::OnNewLiveVersion(int64 version_id,
+void ServiceWorkerContextWatcher::OnNewLiveVersion(std::string version_uuid,
                                                    int64 registration_id,
                                                    const GURL& script_url) {
-  if (ServiceWorkerVersionInfo* version = version_info_map_.get(version_id)) {
+  if (ServiceWorkerVersionInfo* version = version_info_map_.get(version_uuid)) {
     DCHECK_EQ(version->registration_id, registration_id);
     DCHECK_EQ(version->script_url, script_url);
     return;
   }
 
   scoped_ptr<ServiceWorkerVersionInfo> version(new ServiceWorkerVersionInfo());
-  version->version_id = version_id;
+  version->version_uuid = version_uuid;
   version->registration_id = registration_id;
   version->script_url = script_url;
   SendVersionInfo(*version);
   if (!IsStoppedAndRedundant(*version))
-    version_info_map_.set(version_id, version.Pass());
+    version_info_map_.set(version_uuid, version.Pass());
 }
 
 void ServiceWorkerContextWatcher::OnRunningStateChanged(
-    int64 version_id,
+    std::string version_uuid,
     content::ServiceWorkerVersion::RunningStatus running_status) {
-  ServiceWorkerVersionInfo* version = version_info_map_.get(version_id);
+  ServiceWorkerVersionInfo* version = version_info_map_.get(version_uuid);
   DCHECK(version);
   if (version->running_status == running_status)
     return;
   version->running_status = running_status;
   SendVersionInfo(*version);
   if (IsStoppedAndRedundant(*version))
-    version_info_map_.erase(version_id);
+    version_info_map_.erase(version_uuid);
 }
 
 void ServiceWorkerContextWatcher::OnVersionStateChanged(
-    int64 version_id,
+    std::string version_uuid,
     content::ServiceWorkerVersion::Status status) {
-  ServiceWorkerVersionInfo* version = version_info_map_.get(version_id);
+  ServiceWorkerVersionInfo* version = version_info_map_.get(version_uuid);
   DCHECK(version);
   if (version->status == status)
     return;
   version->status = status;
   SendVersionInfo(*version);
   if (IsStoppedAndRedundant(*version))
-    version_info_map_.erase(version_id);
+    version_info_map_.erase(version_uuid);
 }
 
 void ServiceWorkerContextWatcher::OnMainScriptHttpResponseInfoSet(
-    int64 version_id,
+    std::string version_uuid,
     base::Time script_response_time,
     base::Time script_last_modified) {
-  ServiceWorkerVersionInfo* version = version_info_map_.get(version_id);
+  ServiceWorkerVersionInfo* version = version_info_map_.get(version_uuid);
   DCHECK(version);
   version->script_response_time = script_response_time;
   version->script_last_modified = script_last_modified;
   SendVersionInfo(*version);
 }
 
-void ServiceWorkerContextWatcher::OnErrorReported(int64 version_id,
+void ServiceWorkerContextWatcher::OnErrorReported(std::string version_uuid,
                                                   int process_id,
                                                   int thread_id,
                                                   const ErrorInfo& info) {
   int64 registration_id = kInvalidServiceWorkerRegistrationId;
-  if (ServiceWorkerVersionInfo* version = version_info_map_.get(version_id))
+  if (ServiceWorkerVersionInfo* version = version_info_map_.get(version_uuid))
     registration_id = version->registration_id;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(error_callback_, registration_id, version_id, info));
+      base::Bind(error_callback_, registration_id, version_uuid, info));
 }
 
 void ServiceWorkerContextWatcher::OnReportConsoleMessage(
-    int64 version_id,
+    std::string version_uuid,
     int process_id,
     int thread_id,
     const ConsoleMessage& message) {
   if (message.message_level != CONSOLE_MESSAGE_LEVEL_ERROR)
     return;
   int64 registration_id = kInvalidServiceWorkerRegistrationId;
-  if (ServiceWorkerVersionInfo* version = version_info_map_.get(version_id))
+  if (ServiceWorkerVersionInfo* version = version_info_map_.get(version_uuid))
     registration_id = version->registration_id;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(error_callback_, registration_id, version_id,
+      base::Bind(error_callback_, registration_id, version_uuid,
                  ErrorInfo(message.message, message.line_number, -1,
                            message.source_url)));
 }
 
 void ServiceWorkerContextWatcher::OnControlleeAdded(
-    int64 version_id,
+    std::string version_uuid,
     const std::string& uuid,
     int process_id,
     int route_id,
     ServiceWorkerProviderType type) {
-  ServiceWorkerVersionInfo* version = version_info_map_.get(version_id);
+  ServiceWorkerVersionInfo* version = version_info_map_.get(version_uuid);
   DCHECK(version);
   version->clients[uuid] =
       ServiceWorkerVersionInfo::ClientInfo(process_id, route_id, type);
   SendVersionInfo(*version);
 }
 
-void ServiceWorkerContextWatcher::OnControlleeRemoved(int64 version_id,
+void ServiceWorkerContextWatcher::OnControlleeRemoved(std::string version_uuid,
                                                       const std::string& uuid) {
-  ServiceWorkerVersionInfo* version = version_info_map_.get(version_id);
+  ServiceWorkerVersionInfo* version = version_info_map_.get(version_uuid);
   DCHECK(version);
   version->clients.erase(uuid);
   SendVersionInfo(*version);
 }
 
 void ServiceWorkerContextWatcher::OnRegistrationStored(int64 registration_id,
                                                        const GURL& pattern) {
   SendRegistrationInfo(registration_id, pattern,
                        ServiceWorkerRegistrationInfo::IS_NOT_DELETED);
 }
 
 void ServiceWorkerContextWatcher::OnRegistrationDeleted(int64 registration_id,
                                                         const GURL& pattern) {
   SendRegistrationInfo(registration_id, pattern,
                        ServiceWorkerRegistrationInfo::IS_DELETED);
 }
 
 }  // namespace content