Implement ServiceWorkerClient attributes [2/3]

content/child/service_worker/service_worker_dispatcher.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/child/service_worker/service_worker_dispatcher.h"
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
 #include "content/child/child_thread.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
 #include "content/child/service_worker/service_worker_registration_handle_reference.h"
 #include "content/child/service_worker/web_service_worker_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/common/url_utils.h"
+#include "third_party/WebKit/public/platform/WebServiceWorkerClientsInfo.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerProviderClient.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 
 using blink::WebServiceWorkerError;
 using blink::WebServiceWorkerProvider;
 using base::ThreadLocalPointer;
 
 namespace content {
 
 namespace {
@@ skipping 41 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerStateChanged,
                         OnServiceWorkerStateChanged)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetVersionAttributes,
                         OnSetVersionAttributes)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_UpdateFound,
                         OnUpdateFound)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetControllerServiceWorker,
                         OnSetControllerServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToDocument,
                         OnPostMessage)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_GetClientInfo,
+                        OnGetClientInfo)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 bool ServiceWorkerDispatcher::Send(IPC::Message* msg) {
   return thread_safe_sender_->Send(msg);
 }
 
 void ServiceWorkerDispatcher::RegisterServiceWorker(
@@ skipping 589 matching lines @@
     for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
       ports[i] = new WebMessagePortChannelImpl(
           new_routing_ids[i], sent_message_port_ids[i],
           base::MessageLoopProxy::current());
     }
   }
 
   found->second->dispatchMessageEvent(message, ports);
 }
 
+void ServiceWorkerDispatcher::OnGetClientInfo(int thread_id,
+                                              int embedded_worker_id,
+                                              int request_id,
+                                              int provider_id) {
+  blink::WebServiceWorkerClientInfo info;
+  ScriptClientMap::iterator found = script_clients_.find(provider_id);
+  if (found != script_clients_.end() && found->second->getClientInfo(&info)) {
+    ServiceWorkerClientInfo result;
+    result.client_id = info.clientID;
+    result.visibility_state = info.visibilityState.utf8();
+    result.is_focused = info.isFocused;
+    result.url = info.url;
+    result.frame_type = static_cast<RequestContextFrameType>(info.frameType);

[mlamouri (slow - plz ping), 2014/12/08 10:56:28]

Now that ServiceWorkerProviderHost is aware of the render_frame_id, how much of
those attributes you could get directly from the browser process? It could be
interesting if we could save a browser->renderer->browser ipc loop.

[Kunihiko Sakamoto, 2014/12/09 02:05:43]

We have URL in browser process, and it'd be easy to save frameType in browser
since it doesn't change.

For visibilityState and focused, I don't think browser process has complete
information to calculate them.

So browser->renderer->browser IPC loop is inevitable here.

[dcheng, 2014/12/10 06:37:52]

re focused:
We definitely don't have enough browser-side state for focus atm, but the
out-of-process work requires that we move some parts of focus tracking to the
browser process. It's conceivable we could add enough bits to satisfy the use
case for SW as well.

re visibilityState:
I'm pretty sure this is browser-driven, so theoretically, we could track this in
the browser pretty easy (after all, the embedder has to tell Blink what the
visiblity state).

[Kunihiko Sakamoto, 2014/12/10 09:10:47]

Thanks for the info. Added a TODO comment so that we can revisit it later.

+
+    thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetClientInfoSuccess(
+        embedded_worker_id, request_id, result));
+  } else {
+    thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetClientInfoError(
+        embedded_worker_id, request_id));
+  }
+}
+
 void ServiceWorkerDispatcher::AddServiceWorker(
     int handle_id, WebServiceWorkerImpl* worker) {
   DCHECK(!ContainsKey(service_workers_, handle_id));
   service_workers_[handle_id] = worker;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorker(int handle_id) {
   DCHECK(ContainsKey(service_workers_, handle_id));
   service_workers_.erase(handle_id);
 }
@@ skipping 29 matching lines @@
         attrs.installing, thread_safe_sender_.get());
     ServiceWorkerHandleReference::Adopt(
         attrs.waiting, thread_safe_sender_.get());
     ServiceWorkerHandleReference::Adopt(
         attrs.active, thread_safe_sender_.get());
   }
   return registration;
 }
 
 }  // namespace content