Gather the ServiceWorker client information in the browser process.

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/stl_util.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_request_handler.h"
 #include "content/browser/service_worker/service_worker_controllee_request_handler.h"
 #include "content/browser/service_worker/service_worker_dispatcher_host.h"
 #include "content/browser/service_worker/service_worker_handle.h"
 #include "content/browser/service_worker/service_worker_registration_handle.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/resource_request_body.h"
@@ skipping 18 matching lines @@
 
   if (web_contents && web_contents->GetDelegate()) {
     result = true;
     web_contents->GetDelegate()->ActivateContents(web_contents);
   }
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, result));
 }
 
+void GetClientInfoOnUIThread(
+    int render_process_id,
+    int render_frame_id,
+    const GURL& expected_url,
+    const ServiceWorkerProviderHost::GetClientInfoCallback& callback) {
+  RenderFrameHostImpl* render_frame_host = static_cast<RenderFrameHostImpl*>(
+      RenderFrameHost::FromID(render_process_id, render_frame_id));
+  if (!render_frame_host ||
+      render_frame_host->GetLastCommittedURL() != expected_url) {

[michaeln, 2015/01/27 23:12:56]

Not sure this works in history.pushState() use cases, does a pushState'd url get
committed? The value of the expected_url is the url that brought the document
into being.
I hadn't suggested anything, was just noticing the raciness. I think for the
time being don't even try to handle it (at least not in this CL). If we knew the
provider_id on the UI thread, that would be great, we could use that value
instead of the docurl value. We'd only get 'infos' back about the currently
committed clients and we'd only get 'infos' back about clients we actually are
interested in.

[mlamouri (slow - plz ping), 2015/01/28 11:35:05]

As far as I know, we commit history.pushState() indeed. I've removed that check
and left a TODO.
I've also added a check in SWVersion because I guess we might end up having a
navigation that got committed and the frame URL would no longer be the one we
are expecting. I think it's no big deal if we return a non controlled but same
origin WindowClient but we shouldn't return a cross origin one.

+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(callback, ServiceWorkerClientInfo()));
+  }
+
+  ServiceWorkerClientInfo client_info(
+      render_frame_host->GetVisibilityState(),
+      render_frame_host->IsFocused(),
+      render_frame_host->GetLastCommittedURL(),
+      render_frame_host->GetParent() ? REQUEST_CONTEXT_FRAME_TYPE_NESTED
+                                     : REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL);
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(callback, client_info));
+}
+
 }  // anonymous namespace
 
 ServiceWorkerProviderHost::ServiceWorkerProviderHost(
     int render_process_id, int render_frame_id, int provider_id,
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerDispatcherHost* dispatcher_host)
     : render_process_id_(render_process_id),
       render_frame_id_(render_frame_id),
       provider_id_(provider_id),
       context_(context),
@@ skipping 195 matching lines @@
 void ServiceWorkerProviderHost::Focus(const FocusCallback& callback) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&FocusOnUIThread,
                  render_process_id_,
                  render_frame_id_,
                  callback));
 }
 
 void ServiceWorkerProviderHost::GetClientInfo(
-    int embedded_worker_id,
-    int request_id) {
-  dispatcher_host_->Send(new ServiceWorkerMsg_GetClientInfo(
-      kDocumentMainThreadId, embedded_worker_id, request_id, provider_id()));
+    const GetClientInfoCallback& callback) {
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&GetClientInfoOnUIThread,
+                                     render_process_id_,
+                                     render_frame_id_,
+                                     document_url_,
+                                     callback));
 }
 
 void ServiceWorkerProviderHost::AddScopedProcessReferenceToPattern(
     const GURL& pattern) {
   associated_patterns_.push_back(pattern);
   IncreaseProcessReference(pattern);
 }
 
 void ServiceWorkerProviderHost::PrepareForCrossSiteTransfer() {
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, render_process_id_);
@@ skipping 127 matching lines @@
     context_->process_manager()->RemoveProcessReferenceFromPattern(
         pattern, render_process_id_);
   }
 }
 
 bool ServiceWorkerProviderHost::IsContextAlive() {
   return context_ != NULL;
 }
 
 }  // namespace content