Use UUID for ServiceWorker Client identifier (2/3, chromium)

content/browser/service_worker/service_worker_version.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_VERSION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 295 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerVersionTest, KeepAlive);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerVersionTest, ListenerAvailability);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerFailToStartTest, Timeout);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerVersionBrowserTest,
                            TimeoutStartingWorker);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerVersionBrowserTest,
                            TimeoutWorkerInEvent);
   friend class ServiceWorkerVersionBrowserTest;
 
   typedef ServiceWorkerVersion self;
-  typedef std::map<ServiceWorkerProviderHost*, int> ControlleeMap;
-  typedef IDMap<ServiceWorkerProviderHost> ControlleeByIDMap;
 
   ~ServiceWorkerVersion() override;
 
   // EmbeddedWorkerInstance::Listener overrides:
   void OnScriptLoaded() override;
   void OnStarted() override;
   void OnStopped(EmbeddedWorkerInstance::Status old_status) override;
   void OnReportException(const base::string16& error_message,
                          int line_number,
                          int column_number,
@@ skipping 30 matching lines @@
   void OnPushEventFinished(int request_id,
                            blink::WebServiceWorkerEventResult result);
   void OnGeofencingEventFinished(int request_id);
   void OnCrossOriginConnectEventFinished(int request_id,
                                          bool accept_connection);
   void OnOpenWindow(int request_id, const GURL& url);
   void DidOpenWindow(int request_id,
                      int render_process_id,
                      int render_frame_id);
   void OnOpenWindowFinished(int request_id,
-                            int client_id,
+                            const std::string& client_uuid,
                             const ServiceWorkerClientInfo& client_info);
 
   void OnSetCachedMetadata(const GURL& url, const std::vector<char>& data);
   void OnSetCachedMetadataFinished(int64 callback_id, int result);
   void OnClearCachedMetadata(const GURL& url);
   void OnClearCachedMetadataFinished(int64 callback_id, int result);
 
-  void OnPostMessageToDocument(
-      int client_id,
+  void OnPostMessageToClient(
+      const std::string& client_uuid,
       const base::string16& message,
       const std::vector<TransferredMessagePort>& sent_message_ports);
-  void OnFocusClient(int request_id, int client_id);
+  void OnFocusClient(int request_id, const std::string& client_uuid);
   void OnSkipWaiting(int request_id);
   void OnClaimClients(int request_id);
   void OnPongFromWorker();
 
   void OnFocusClientFinished(int request_id,
-                             int client_id,
+                             const std::string& client_uuid,
                              const ServiceWorkerClientInfo& client);
 
   void DidSkipWaiting(int request_id);
   void DidClaimClients(int request_id, ServiceWorkerStatusCode status);
   void DidGetClients(
       int request_id, const std::vector<ServiceWorkerClientInfo>& clients);
 
   // The timeout timer periodically calls OnTimeoutTimer, which stops the worker
   // if it is excessively idle or unresponsive to ping.
   void StartTimeoutTimer();
@@ skipping 44 matching lines @@
   IDMap<FetchCallback, IDMapOwnPointer> fetch_callbacks_;
   IDMap<StatusCallback, IDMapOwnPointer> sync_callbacks_;
   IDMap<StatusCallback, IDMapOwnPointer> notification_click_callbacks_;
   IDMap<StatusCallback, IDMapOwnPointer> push_callbacks_;
   IDMap<StatusCallback, IDMapOwnPointer> geofencing_callbacks_;
   IDMap<CrossOriginConnectCallback, IDMapOwnPointer>
       cross_origin_connect_callbacks_;
 
   std::set<const ServiceWorkerURLRequestJob*> streaming_url_request_jobs_;
 
-  ControlleeMap controllee_map_;
-  ControlleeByIDMap controllee_by_id_;
+  std::map<std::string, ServiceWorkerProviderHost*> controllee_map_;
   // Will be null while shutting down.
   base::WeakPtr<ServiceWorkerContextCore> context_;
   ObserverList<Listener> listeners_;
   ServiceWorkerScriptCacheMap script_cache_map_;
   base::OneShotTimer<ServiceWorkerVersion> update_timer_;
 
   // Starts running when the script is loaded (which means it is about to begin
   // evaluation) and continues until the worker is stopped or a stop request is
   // ignored because DevTools is attached.
   base::RepeatingTimer<ServiceWorkerVersion> timeout_timer_;
@@ skipping 13 matching lines @@
   scoped_ptr<net::HttpResponseInfo> main_script_http_info_;
 
   base::WeakPtrFactory<ServiceWorkerVersion> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersion);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_