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 ServiceWorkerProviderHost::GetClientInfoCallback& callback) {
+  RenderFrameHostImpl* render_frame_host = static_cast<RenderFrameHostImpl*>(
+      RenderFrameHost::FromID(render_process_id, render_frame_id));
+  DCHECK(render_frame_host);

[michaeln, 2015/01/26 22:09:46]

Its hard to be sure this is guaranteed to hold true, I suspect it is not.

Any number of messages could have been processed on the UI thread before this
one to get client info comes thru. Some of which probably could delete the frame
host.

Is there a GetClientInfoCallback return value that means N/A?

[mlamouri (slow - plz ping), 2015/01/27 15:03:08]

An empty ServiceWorkerClientInfo should do.

+
+  ServiceWorkerClientInfo client_info(
+      render_frame_host->GetVisibilityState(),
+      render_frame_host->IsFocused(),
+      render_frame_host->GetLastCommittedURL(),

[michaeln, 2015/01/26 22:09:46]

There's a chance frame can contain a different document at the time we get here.
The lifetimes of the old and new documents that reside in a frame being
navigated overlap. A couple different ways the mismatch can happen.

At the beginning of a docs life, the client association happens prior to the
document being committed, in that case the committed url can reflect the doc
that is being replaced by a new navigation.

At the end of a docs life, I think an old Document can linger after a new doc
has been committed to the frame. In that case, the url will reflect the new
page.

It might make sense to filter out 'uncommitted' documents from this list?

I think tightening up the Frame vs Document identity'isms could come later.

[mlamouri (slow - plz ping), 2015/01/27 15:03:08]

I'm not sure what you are suggesting I do here. Knowing if the frame is being
navigated would require observing it - do we want that? I could pass an
|expected_url| to the method and check that the committed url matches the
expected url. If it doesn't, it means that a navigation occurred in between. If
it does, it's probably good enough?

+      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_,
+                                     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