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

content/browser/service_worker/service_worker_provider_host.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_provider_host.h"
 
 #include "base/guid.h"
 #include "base/stl_util.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
@@ skipping 13 matching lines @@
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 
 namespace content {
 
 namespace {
 
-ServiceWorkerClientInfo FocusOnUIThread(
-    int render_process_id,
-    int render_frame_id) {
+ServiceWorkerClientInfo FocusOnUIThread(int render_process_id, int route_id) {

[dcheng, 2015/06/17 23:21:13]

Nit: keep this named "render_frame_id"

[horo, 2015/06/17 23:51:07]

Done.

   RenderFrameHostImpl* render_frame_host =
-      RenderFrameHostImpl::FromID(render_process_id, render_frame_id);
+      RenderFrameHostImpl::FromID(render_process_id, route_id);
   WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
       WebContents::FromRenderFrameHost(render_frame_host));
 
   if (!render_frame_host || !web_contents)
     return ServiceWorkerClientInfo();
 
   FrameTreeNode* frame_tree_node = render_frame_host->frame_tree_node();
 
   // Focus the frame in the frame tree node, in case it has changed.
   frame_tree_node->frame_tree()->SetFocusedFrame(frame_tree_node);
 
   // Focus the frame's view to make sure the frame is now considered as focused.
   render_frame_host->GetView()->Focus();
 
   // Move the web contents to the foreground.
   web_contents->Activate();
 
   return ServiceWorkerProviderHost::GetWindowClientInfoOnUI(render_process_id,
-                                                            render_frame_id);
+                                                            route_id);
 }
 
 }  // anonymous namespace
 
 ServiceWorkerProviderHost::OneShotGetReadyCallback::OneShotGetReadyCallback(
     const GetRegistrationForReadyCallback& callback)
     : callback(callback),
       called(false) {
 }
 
 ServiceWorkerProviderHost::OneShotGetReadyCallback::~OneShotGetReadyCallback() {
 }
 
 ServiceWorkerProviderHost::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)
     : client_uuid_(base::GenerateGUID()),
       render_process_id_(render_process_id),
-      render_frame_id_(render_frame_id),
+      route_id_(route_id),
       render_thread_id_(kDocumentMainThreadId),
       provider_id_(provider_id),
       provider_type_(provider_type),
       context_(context),
       dispatcher_host_(dispatcher_host),
       allow_association_(true) {
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, render_process_id_);
   DCHECK_NE(SERVICE_WORKER_PROVIDER_UNKNOWN, provider_type_);
   if (provider_type_ == SERVICE_WORKER_PROVIDER_FOR_CONTROLLER) {
     // Actual thread id is set when the service worker context gets started.
@@ skipping 14 matching lines @@
 
   for (auto& key_registration : matching_registrations_) {
     DecreaseProcessReference(key_registration.second->pattern());
     key_registration.second->RemoveListener(this);
   }
 
   for (const GURL& pattern : associated_patterns_)
     DecreaseProcessReference(pattern);
 }
 
+int ServiceWorkerProviderHost::frame_id() const {
+  if (provider_type_ == SERVICE_WORKER_PROVIDER_FOR_WINDOW)
+    return route_id_;
+  return MSG_ROUTING_NONE;
+}
+
 void ServiceWorkerProviderHost::OnVersionAttributesChanged(
     ServiceWorkerRegistration* registration,
     ChangedVersionAttributesMask changed_mask,
     const ServiceWorkerRegistrationInfo& info) {
   if (!get_ready_callback_ || get_ready_callback_->called)
     return;
   if (changed_mask.active_changed() && registration->active_version()) {
     // Wait until the state change so we don't send the get for ready
     // registration complete message before set version attributes message.
     registration->active_version()->RegisterStatusChangeCallback(base::Bind(
@@ skipping 254 matching lines @@
                                       &new_routing_ids);
 
   Send(new ServiceWorkerMsg_MessageToDocument(
       kDocumentMainThreadId, provider_id(),
       message,
       sent_message_ports,
       new_routing_ids));
 }
 
 void ServiceWorkerProviderHost::Focus(const GetClientInfoCallback& callback) {
+  if (provider_type_ != SERVICE_WORKER_PROVIDER_FOR_WINDOW) {
+    callback.Run(ServiceWorkerClientInfo());
+    return;
+  }
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&FocusOnUIThread,
-                 render_process_id_,
-                 render_frame_id_),
-      callback);
+      base::Bind(&FocusOnUIThread, render_process_id_, route_id_), callback);
 }
 
 void ServiceWorkerProviderHost::GetWindowClientInfo(
     const GetClientInfoCallback& callback) const {
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerProviderHost::GetWindowClientInfoOnUI,
-                 render_process_id_, render_frame_id_),
+                 render_process_id_, route_id_),
       callback);
 }
 
 // static
 ServiceWorkerClientInfo ServiceWorkerProviderHost::GetWindowClientInfoOnUI(
     int render_process_id,
-    int render_frame_id) {
+    int route_id) {
   RenderFrameHostImpl* render_frame_host =
-      RenderFrameHostImpl::FromID(render_process_id, render_frame_id);
+      RenderFrameHostImpl::FromID(render_process_id, route_id);
   if (!render_frame_host)
     return ServiceWorkerClientInfo();
 
   // TODO(mlamouri,michaeln): it is possible to end up collecting information
   // for a frame that is actually being navigated and isn't exactly what we are
   // expecting.
   return ServiceWorkerClientInfo(
       render_frame_host->GetVisibilityState(),
       render_frame_host->IsFocused(),
       render_frame_host->GetLastCommittedURL(),
@@ skipping 24 matching lines @@
     const GetRegistrationForReadyCallback& callback) {
   if (get_ready_callback_)
     return false;
   get_ready_callback_.reset(new OneShotGetReadyCallback(callback));
   ReturnRegistrationForReadyIfNeeded();
   return true;
 }
 
 void ServiceWorkerProviderHost::PrepareForCrossSiteTransfer() {
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, render_process_id_);
-  DCHECK_NE(MSG_ROUTING_NONE, render_frame_id_);
+  DCHECK_NE(MSG_ROUTING_NONE, route_id_);
   DCHECK_EQ(kDocumentMainThreadId, render_thread_id_);
   DCHECK_NE(SERVICE_WORKER_PROVIDER_UNKNOWN, provider_type_);
 
   for (const GURL& pattern : associated_patterns_)
     DecreaseProcessReference(pattern);
 
   for (auto& key_registration : matching_registrations_)
     DecreaseProcessReference(key_registration.second->pattern());
 
   if (associated_registration_.get()) {
     if (dispatcher_host_) {
       Send(new ServiceWorkerMsg_DisassociateRegistration(
           render_thread_id_, provider_id()));
     }
   }
 
   render_process_id_ = ChildProcessHost::kInvalidUniqueID;
-  render_frame_id_ = MSG_ROUTING_NONE;
+  route_id_ = MSG_ROUTING_NONE;
   render_thread_id_ = kInvalidEmbeddedWorkerThreadId;
   provider_id_ = kInvalidServiceWorkerProviderId;
   provider_type_ = SERVICE_WORKER_PROVIDER_UNKNOWN;
   dispatcher_host_ = nullptr;
 }
 
 void ServiceWorkerProviderHost::CompleteCrossSiteTransfer(
     int new_process_id,
     int new_frame_id,
     int new_provider_id,
     ServiceWorkerProviderType new_provider_type,
     ServiceWorkerDispatcherHost* new_dispatcher_host) {
   DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, render_process_id_);
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, new_process_id);
   DCHECK_NE(MSG_ROUTING_NONE, new_frame_id);
 
   render_process_id_ = new_process_id;
-  render_frame_id_ = new_frame_id;
+  route_id_ = new_frame_id;
   render_thread_id_ = kDocumentMainThreadId;
   provider_id_ = new_provider_id;
   provider_type_ = new_provider_type;
   dispatcher_host_ = new_dispatcher_host;
 
   for (const GURL& pattern : associated_patterns_)
     IncreaseProcessReference(pattern);
 
   for (auto& key_registration : matching_registrations_)
     IncreaseProcessReference(key_registration.second->pattern());
@@ skipping 147 matching lines @@
   return context_ != NULL;
 }
 
 void ServiceWorkerProviderHost::Send(IPC::Message* message) const {
   DCHECK(dispatcher_host_);
   DCHECK(IsReadyToSendMessages());
   dispatcher_host_->Send(message);
 }
 
 }  // namespace content