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

content/browser/service_worker/service_worker_context_core.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_CORE_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_CORE_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 174 matching lines @@
 
   // This class maintains collections of live instances, this class
   // does not own these object or influence their lifetime.
   ServiceWorkerRegistration* GetLiveRegistration(int64 registration_id);
   void AddLiveRegistration(ServiceWorkerRegistration* registration);
   void RemoveLiveRegistration(int64 registration_id);
   const std::map<int64, ServiceWorkerRegistration*>& GetLiveRegistrations()
       const {
     return live_registrations_;
   }
-  ServiceWorkerVersion* GetLiveVersion(int64 version_id);
+  ServiceWorkerVersion* GetLiveVersion(std::string version_uuid);
   void AddLiveVersion(ServiceWorkerVersion* version);
-  void RemoveLiveVersion(int64 registration_id);
-  const std::map<int64, ServiceWorkerVersion*>& GetLiveVersions() const {
+  void RemoveLiveVersion(std::string version_uuid);
+  const std::map<std::string, ServiceWorkerVersion*>& GetLiveVersions() const {
     return live_versions_;
   }
 
   std::vector<ServiceWorkerRegistrationInfo> GetAllLiveRegistrationInfo();
   std::vector<ServiceWorkerVersionInfo> GetAllLiveVersionInfo();
 
   // ProtectVersion holds a reference to |version| until UnprotectVersion is
   // called.
   void ProtectVersion(const scoped_refptr<ServiceWorkerVersion>& version);
-  void UnprotectVersion(int64 version_id);
+  void UnprotectVersion(std::string version_uuid);
 
   // Returns new context-local unique ID.
   int GetNewServiceWorkerHandleId();
   int GetNewRegistrationHandleId();
 
   void ScheduleDeleteAndStartOver() const;
 
   // Deletes all files on disk and restarts the system. This leaves the system
   // in a disabled state until it's done.
   void DeleteAndStartOver(const StatusCallback& callback);
 
   // Methods to support cross site navigations.
   scoped_ptr<ServiceWorkerProviderHost> TransferProviderHostOut(
       int process_id,
       int provider_id);
   void TransferProviderHostIn(
       int new_process_id,
       int new_host_id,
       scoped_ptr<ServiceWorkerProviderHost> provider_host);
 
   base::WeakPtr<ServiceWorkerContextCore> AsWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
  private:
   friend class ServiceWorkerContext;
   typedef std::map<int64, ServiceWorkerRegistration*> RegistrationsMap;
-  typedef std::map<int64, ServiceWorkerVersion*> VersionMap;
+  typedef std::map<std::string, ServiceWorkerVersion*> VersionMap;
 
   ProviderMap* GetProviderMapForProcess(int process_id) {
     return providers_->Lookup(process_id);
   }
 
   void RegistrationComplete(const GURL& pattern,
                             const RegistrationCallback& callback,
                             ServiceWorkerStatusCode status,
                             const std::string& status_message,
                             ServiceWorkerRegistration* registration);
@@ skipping 11 matching lines @@
   // It's safe to store a raw pointer instead of a scoped_refptr to |wrapper_|
   // because the Wrapper::Shutdown call that hops threads to destroy |this| uses
   // Bind() to hold a reference to |wrapper_| until |this| is fully destroyed.
   ServiceWorkerContextWrapper* wrapper_;
   scoped_ptr<ProcessToProviderMap> providers_;
   scoped_ptr<ProviderByClientUUIDMap> provider_by_uuid_;
   scoped_ptr<ServiceWorkerStorage> storage_;
   scoped_refptr<EmbeddedWorkerRegistry> embedded_worker_registry_;
   scoped_ptr<ServiceWorkerJobCoordinator> job_coordinator_;
   std::map<int64, ServiceWorkerRegistration*> live_registrations_;
-  std::map<int64, ServiceWorkerVersion*> live_versions_;
-  std::map<int64, scoped_refptr<ServiceWorkerVersion>> protected_versions_;
+  std::map<std::string, ServiceWorkerVersion*> live_versions_;
+  std::map<std::string, scoped_refptr<ServiceWorkerVersion>>
+      protected_versions_;
   int next_handle_id_;
   int next_registration_handle_id_;
   scoped_refptr<base::ObserverListThreadSafe<ServiceWorkerContextObserver>>
       observer_list_;
   base::WeakPtrFactory<ServiceWorkerContextCore> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerContextCore);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_CORE_H_