[3/5 chromium] Shows the clients which are controlled by ServiceWorker in DevTools.

content/browser/service_worker/service_worker_provider_host.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_PROVIDER_HOST_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_HOST_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 33 matching lines @@
 // case it will observe resource loads made directly by the service worker.
 class CONTENT_EXPORT ServiceWorkerProviderHost
     : public NON_EXPORTED_BASE(ServiceWorkerRegistration::Listener),
       public base::SupportsWeakPtr<ServiceWorkerProviderHost> {
  public:
   using GetClientInfoCallback =
       base::Callback<void(const ServiceWorkerClientInfo&)>;
   using GetRegistrationForReadyCallback =
       base::Callback<void(ServiceWorkerRegistration* reigstration)>;
 
-  // If |render_frame_id| is MSG_ROUTING_NONE, this provider host works for the
-  // worker context, i.e. ServiceWorker or SharedWorker.
+  // When this provider host is for a Service Worker context, |route_id| is
+  // MSG_ROUTING_NONE. When this provider host is for a Document,
+  // |route_id| is the frame ID of the Document. When this provider host is for
+  // a Shared Worker, |route_id| is the Shared Worker route ID.
   // |provider_type| gives additional information whether the provider is
   // created for controller (ServiceWorker) or controllee (Document or
   // SharedWorker).
   ServiceWorkerProviderHost(int render_process_id,
-                            int render_frame_id,
+                            int route_id,
                             int provider_id,
                             ServiceWorkerProviderType provider_type,
                             base::WeakPtr<ServiceWorkerContextCore> context,
                             ServiceWorkerDispatcherHost* dispatcher_host);
   virtual ~ServiceWorkerProviderHost();
 
   const std::string& client_uuid() const { return client_uuid_; }
   int process_id() const { return render_process_id_; }
   int provider_id() const { return provider_id_; }
-  int frame_id() const { return render_frame_id_; }
+  int frame_id() const;
+  int route_id() const { return route_id_; }
 
   bool IsHostToRunningServiceWorker() {
     return running_hosted_version_.get() != NULL;
   }
 
   ServiceWorkerVersion* controlling_version() const {
     return controlling_version_.get();
   }
   ServiceWorkerVersion* active_version() const {
     return associated_registration_.get() ?
@@ skipping 71 matching lines @@
   // Returns true if the context referred to by this host (i.e. |context_|) is
   // still alive.
   bool IsContextAlive();
 
   // Dispatches message event to the document.
   void PostMessage(
       const base::string16& message,
       const std::vector<TransferredMessagePort>& sent_message_ports);
 
   // Activates the WebContents associated with
-  // { render_process_id_, render_frame_id_ }.
+  // { render_process_id_, route_id_ }.
   // Runs the |callback| with the updated ServiceWorkerClientInfo in parameter.
   void Focus(const GetClientInfoCallback& callback);
 
   // Asks the renderer to send back the document information.
   void GetWindowClientInfo(const GetClientInfoCallback& callback) const;
 
   // Same as above but has to be called from the UI thread.
   // It is taking the process and frame ids in parameter because |this| is meant
   // to live on the IO thread.
   static ServiceWorkerClientInfo GetWindowClientInfoOnUI(int render_process_id,
-                                                         int render_frame_id);
+                                                         int route_id);
 
   // Adds reference of this host's process to the |pattern|, the reference will
   // be removed in destructor.
   void AddScopedProcessReferenceToPattern(const GURL& pattern);
 
   // |registration| claims the document to be controlled.
   void ClaimedByRegistration(ServiceWorkerRegistration* registration);
 
   // Called by dispatcher host to get the registration for the "ready" property.
   // Returns false if there's a completed or ongoing request for the document.
@@ skipping 91 matching lines @@
   void IncreaseProcessReference(const GURL& pattern);
   void DecreaseProcessReference(const GURL& pattern);
 
   void ReturnRegistrationForReadyIfNeeded();
 
   bool IsReadyToSendMessages() const;
   void Send(IPC::Message* message) const;
 
   std::string client_uuid_;
   int render_process_id_;
-  int render_frame_id_;
+  int route_id_;
   int render_thread_id_;
   int provider_id_;
   ServiceWorkerProviderType provider_type_;
   GURL document_url_;
   GURL topmost_frame_url_;
 
   std::vector<GURL> associated_patterns_;
   scoped_refptr<ServiceWorkerRegistration> associated_registration_;
 
   // Keyed by registration scope URL length.
@@ skipping 11 matching lines @@
   bool allow_association_;
 
   std::vector<base::Closure> queued_events_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerProviderHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_HOST_H_