ServiceWorker: Support non-window clients in Clients.matchAll (1/2 chromium)

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 35 matching lines @@
 
   // 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::GetClientInfoOnUI(
-      render_process_id, render_frame_id);
+  return ServiceWorkerProviderHost::GetWindowClientInfoOnUI(render_process_id,
+                                                            render_frame_id);
 }
 
 }  // anonymous namespace
 
 ServiceWorkerProviderHost::OneShotGetReadyCallback::OneShotGetReadyCallback(
     const GetRegistrationForReadyCallback& callback)
     : callback(callback),
       called(false) {
 }
 
@@ skipping 107 matching lines @@
   if (previous_version.get())
     previous_version->RemoveControllee(this);
 
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   bool should_notify_controllerchange =
       is_claiming_ || (previous_version && version && version->skip_waiting());
 
   // SetController message should be sent only for controllees.
-  DCHECK_EQ(SERVICE_WORKER_PROVIDER_FOR_CONTROLLEE, provider_type_);
+  DCHECK_NE(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, provider_type_);
   Send(new ServiceWorkerMsg_SetControllerServiceWorker(
       render_thread_id_, provider_id(),
       CreateAndRegisterServiceWorkerHandle(version),
       should_notify_controllerchange));
 }
 
 bool ServiceWorkerProviderHost::SetHostedVersionId(int64 version_id) {
   if (!context_)
     return true;  // System is shutting down.
   if (active_version())
     return false;  // Unexpected bad message.
 
   ServiceWorkerVersion* live_version = context_->GetLiveVersion(version_id);
   if (!live_version)
     return true;  // Was deleted before it got started.
 
   ServiceWorkerVersionInfo info = live_version->GetInfo();
   if (info.running_status != ServiceWorkerVersion::STARTING ||
       info.process_id != render_process_id_) {
     // If we aren't trying to start this version in our process
     // something is amiss.
     return false;
   }
 
   running_hosted_version_ = live_version;
   return true;
 }
 
+blink::WebServiceWorkerClientType ServiceWorkerProviderHost::client_type()
+    const {
+  switch (provider_type_) {
+    case SERVICE_WORKER_PROVIDER_FOR_WINDOW:
+      return blink::WebServiceWorkerClientTypeWindow;
+    case SERVICE_WORKER_PROVIDER_FOR_WORKER:
+      return blink::WebServiceWorkerClientTypeWorker;
+    case SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER:
+      return blink::WebServiceWorkerClientTypeSharedWorker;
+    case SERVICE_WORKER_PROVIDER_FOR_CONTROLLER:
+    case SERVICE_WORKER_PROVIDER_UNKNOWN:
+      NOTREACHED() << provider_type_;
+  }
+  NOTREACHED() << provider_type_;
+  return blink::WebServiceWorkerClientTypeWindow;
+}
+
 void ServiceWorkerProviderHost::AssociateRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(CanAssociateRegistration(registration));
   associated_registration_ = registration;
   AddMatchingRegistration(registration);
   SendAssociateRegistrationMessage();
   SetControllerVersionAttribute(registration->active_version());
 }
 
 void ServiceWorkerProviderHost::DisassociateRegistration() {
   queued_events_.clear();
   if (!associated_registration_.get())
     return;
   associated_registration_ = NULL;
   SetControllerVersionAttribute(NULL);
 
   if (!dispatcher_host_)
     return;
 
   // Disassociation message should be sent only for controllees.
-  DCHECK_EQ(SERVICE_WORKER_PROVIDER_FOR_CONTROLLEE, provider_type_);
+  DCHECK_NE(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, provider_type_);
   Send(new ServiceWorkerMsg_DisassociateRegistration(
       render_thread_id_, provider_id()));
 }
 
 void ServiceWorkerProviderHost::AddMatchingRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(ServiceWorkerUtils::ScopeMatches(
         registration->pattern(), document_url_));
   size_t key = registration->pattern().spec().size();
   if (ContainsKey(matching_registrations_, key))
@@ skipping 102 matching lines @@
 
 void ServiceWorkerProviderHost::Focus(const GetClientInfoCallback& callback) {
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&FocusOnUIThread,
                  render_process_id_,
                  render_frame_id_),
       callback);
 }
 
-void ServiceWorkerProviderHost::GetClientInfo(
+void ServiceWorkerProviderHost::GetWindowClientInfo(
     const GetClientInfoCallback& callback) const {
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&ServiceWorkerProviderHost::GetClientInfoOnUI,
-                 render_process_id_,
-                 render_frame_id_),
+      base::Bind(&ServiceWorkerProviderHost::GetWindowClientInfoOnUI,
+                 render_process_id_, render_frame_id_),
       callback);
 }
 
 // static
-ServiceWorkerClientInfo ServiceWorkerProviderHost::GetClientInfoOnUI(
-    int render_process_id, int render_frame_id) {
+ServiceWorkerClientInfo ServiceWorkerProviderHost::GetWindowClientInfoOnUI(
+    int render_process_id,
+    int render_frame_id) {
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(render_process_id, render_frame_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(),
@@ skipping 181 matching lines @@
 
   ServiceWorkerVersionAttributes attrs;
   attrs.installing = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->installing_version());
   attrs.waiting = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->waiting_version());
   attrs.active = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->active_version());
 
   // Association message should be sent only for controllees.
-  DCHECK_EQ(SERVICE_WORKER_PROVIDER_FOR_CONTROLLEE, provider_type_);
+  DCHECK_NE(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, provider_type_);
   dispatcher_host_->Send(new ServiceWorkerMsg_AssociateRegistration(
       render_thread_id_, provider_id(), handle->GetObjectInfo(), attrs));
 }
 
 void ServiceWorkerProviderHost::IncreaseProcessReference(
     const GURL& pattern) {
   if (context_ && context_->process_manager()) {
     context_->process_manager()->AddProcessReferenceToPattern(
         pattern, render_process_id_);
   }
@@ skipping 29 matching lines @@
   return context_ != NULL;
 }
 
 void ServiceWorkerProviderHost::Send(IPC::Message* message) const {
   DCHECK(dispatcher_host_);
   DCHECK(IsReadyToSendMessages());
   dispatcher_host_->Send(message);
 }
 
 }  // namespace content