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

content/browser/service_worker/service_worker_context_core.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_context_core.h"
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
@@ skipping 373 matching lines @@
     observer_list_->Notify(FROM_HERE,
                            &ServiceWorkerContextObserver::OnNewLiveRegistration,
                            registration->id(), registration->pattern());
   }
 }
 
 void ServiceWorkerContextCore::RemoveLiveRegistration(int64 id) {
   live_registrations_.erase(id);
 }
 
-ServiceWorkerVersion* ServiceWorkerContextCore::GetLiveVersion(
-    int64 id) {
+ServiceWorkerVersion* ServiceWorkerContextCore::GetLiveVersion(std::string id) {
   VersionMap::iterator it = live_versions_.find(id);
   return (it != live_versions_.end()) ? it->second : NULL;
 }
 
 void ServiceWorkerContextCore::AddLiveVersion(ServiceWorkerVersion* version) {
-  DCHECK(!GetLiveVersion(version->version_id()));
-  live_versions_[version->version_id()] = version;
+  DCHECK(!GetLiveVersion(version->version_uuid()));
+  live_versions_[version->version_uuid()] = version;
   version->AddListener(this);
   if (observer_list_.get()) {
     observer_list_->Notify(FROM_HERE,
                            &ServiceWorkerContextObserver::OnNewLiveVersion,
-                           version->version_id(), version->registration_id(),
+                           version->version_uuid(), version->registration_id(),
                            version->script_url());
   }
 }
 
-void ServiceWorkerContextCore::RemoveLiveVersion(int64 id) {
-  live_versions_.erase(id);
+void ServiceWorkerContextCore::RemoveLiveVersion(std::string version_uuid) {
+  live_versions_.erase(version_uuid);
 }
 
 std::vector<ServiceWorkerRegistrationInfo>
 ServiceWorkerContextCore::GetAllLiveRegistrationInfo() {
   std::vector<ServiceWorkerRegistrationInfo> infos;
   for (std::map<int64, ServiceWorkerRegistration*>::const_iterator iter =
            live_registrations_.begin();
        iter != live_registrations_.end();
        ++iter) {
     infos.push_back(iter->second->GetInfo());
   }
   return infos;
 }
 
 std::vector<ServiceWorkerVersionInfo>
 ServiceWorkerContextCore::GetAllLiveVersionInfo() {
   std::vector<ServiceWorkerVersionInfo> infos;
-  for (std::map<int64, ServiceWorkerVersion*>::const_iterator iter =
+  for (std::map<std::string, ServiceWorkerVersion*>::const_iterator iter =
            live_versions_.begin();
-       iter != live_versions_.end();
-       ++iter) {
+       iter != live_versions_.end(); ++iter) {
     infos.push_back(iter->second->GetInfo());
   }
   return infos;
 }
 
 void ServiceWorkerContextCore::ProtectVersion(
     const scoped_refptr<ServiceWorkerVersion>& version) {
-  DCHECK(protected_versions_.find(version->version_id()) ==
+  DCHECK(protected_versions_.find(version->version_uuid()) ==
          protected_versions_.end());
-  protected_versions_[version->version_id()] = version;
+  protected_versions_[version->version_uuid()] = version;
 }
 
-void ServiceWorkerContextCore::UnprotectVersion(int64 version_id) {
-  DCHECK(protected_versions_.find(version_id) != protected_versions_.end());
-  protected_versions_.erase(version_id);
+void ServiceWorkerContextCore::UnprotectVersion(std::string version_uuid) {
+  DCHECK(protected_versions_.find(version_uuid) != protected_versions_.end());
+  protected_versions_.erase(version_uuid);
 }
 
 int ServiceWorkerContextCore::GetNewServiceWorkerHandleId() {
   return next_handle_id_++;
 }
 
 int ServiceWorkerContextCore::GetNewRegistrationHandleId() {
   return next_registration_handle_id_++;
 }
 
@@ skipping 41 matching lines @@
   map->Replace(new_provider_id, transferee.release());
   delete temp;
 }
 
 void ServiceWorkerContextCore::OnRunningStateChanged(
     ServiceWorkerVersion* version) {
   if (!observer_list_)
     return;
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnRunningStateChanged,
-                         version->version_id(), version->running_status());
+                         version->version_uuid(), version->running_status());
 }
 
 void ServiceWorkerContextCore::OnVersionStateChanged(
     ServiceWorkerVersion* version) {
   if (!observer_list_)
     return;
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnVersionStateChanged,
-                         version->version_id(), version->status());
+                         version->version_uuid(), version->status());
 }
 
 void ServiceWorkerContextCore::OnMainScriptHttpResponseInfoSet(
     ServiceWorkerVersion* version) {
   if (!observer_list_)
     return;
   const net::HttpResponseInfo* info = version->GetMainScriptHttpResponseInfo();
   DCHECK(info);
   base::Time lastModified;
   if (info->headers)
     info->headers->GetLastModifiedValue(&lastModified);
   observer_list_->Notify(
       FROM_HERE, &ServiceWorkerContextObserver::OnMainScriptHttpResponseInfoSet,
-      version->version_id(), info->response_time, lastModified);
+      version->version_uuid(), info->response_time, lastModified);
 }
 
 void ServiceWorkerContextCore::OnErrorReported(
     ServiceWorkerVersion* version,
     const base::string16& error_message,
     int line_number,
     int column_number,
     const GURL& source_url) {
   if (!observer_list_)
     return;
   observer_list_->Notify(
       FROM_HERE, &ServiceWorkerContextObserver::OnErrorReported,
-      version->version_id(), version->embedded_worker()->process_id(),
+      version->version_uuid(), version->embedded_worker()->process_id(),
       version->embedded_worker()->thread_id(),
       ServiceWorkerContextObserver::ErrorInfo(error_message, line_number,
                                               column_number, source_url));
 }
 
 void ServiceWorkerContextCore::OnReportConsoleMessage(
     ServiceWorkerVersion* version,
     int source_identifier,
     int message_level,
     const base::string16& message,
     int line_number,
     const GURL& source_url) {
   if (!observer_list_)
     return;
   observer_list_->Notify(
       FROM_HERE, &ServiceWorkerContextObserver::OnReportConsoleMessage,
-      version->version_id(), version->embedded_worker()->process_id(),
+      version->version_uuid(), version->embedded_worker()->process_id(),
       version->embedded_worker()->thread_id(),
       ServiceWorkerContextObserver::ConsoleMessage(
           source_identifier, message_level, message, line_number, source_url));
 }
 
 void ServiceWorkerContextCore::OnControlleeAdded(
     ServiceWorkerVersion* version,
     ServiceWorkerProviderHost* provider_host) {
   if (!observer_list_)
     return;
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnControlleeAdded,
-                         version->version_id(), provider_host->client_uuid(),
+                         version->version_uuid(), provider_host->client_uuid(),
                          provider_host->process_id(), provider_host->route_id(),
                          provider_host->provider_type());
 }
 
 void ServiceWorkerContextCore::OnControlleeRemoved(
     ServiceWorkerVersion* version,
     ServiceWorkerProviderHost* provider_host) {
   if (!observer_list_)
     return;
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnControlleeRemoved,
-                         version->version_id(), provider_host->client_uuid());
+                         version->version_uuid(), provider_host->client_uuid());
 }
 
 ServiceWorkerProcessManager* ServiceWorkerContextCore::process_manager() {
   return wrapper_->process_manager();
 }
 
 }  // namespace content