ServiceWorker: plumbing for ClientQueryOptions (2/2, chromium)

content/browser/service_worker/service_worker_version.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_version.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 19 matching lines @@
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "net/http/http_response_info.h"
 
 namespace content {
 
 using StatusCallback = ServiceWorkerVersion::StatusCallback;
-using GetClientDocumentsCallback =
+using GetClientsCallback =
     base::Callback<void(const std::vector<ServiceWorkerClientInfo>&)>;
 
 namespace {
 
 // Delay between the timeout timer firing.
 const int kTimeoutTimerDelaySeconds = 30;
 
 // Time to wait until stopping an idle worker.
 const int kIdleWorkerTimeoutSeconds = 30;
 
@@ skipping 204 matching lines @@
 void RestartTick(base::TimeTicks* time) {
   *time = base::TimeTicks().Now();
 }
 
 base::TimeDelta GetTickDuration(const base::TimeTicks& time) {
   if (time.is_null())
     return base::TimeDelta();
   return base::TimeTicks().Now() - time;
 }
 
-void OnGetClientDocumentsFromUI(
+void OnGetClientsFromUI(
     // The tuple contains process_id, frame_id, client_id.
     const std::vector<Tuple<int,int,int>>& clients_info,
     const GURL& script_url,
-    const GetClientDocumentsCallback& callback) {
+    const GetClientsCallback& callback) {
   std::vector<ServiceWorkerClientInfo> clients;
 
   for (const auto& it : clients_info) {
     ServiceWorkerClientInfo info =
         ServiceWorkerProviderHost::GetClientInfoOnUI(get<0>(it), get<1>(it));
 
     // If the request to the provider_host returned an empty
     // ServiceWorkerClientInfo, that means that it wasn't possible to associate
     // it with a valid RenderFrameHost. It might be because the frame was killed
     // or navigated in between.
@@ skipping 633 matching lines @@
                                            source_identifier,
                                            message_level,
                                            message,
                                            line_number,
                                            source_url));
 }
 
 bool ServiceWorkerVersion::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerVersion, message)
-    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GetClientDocuments,
-                        OnGetClientDocuments)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GetClients,
+                        OnGetClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ActivateEventFinished,
                         OnActivateEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_InstallEventFinished,
                         OnInstallEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FetchEventFinished,
                         OnFetchEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SyncEventFinished,
                         OnSyncEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_NotificationClickEventFinished,
                         OnNotificationClickEventFinished)
@@ skipping 50 matching lines @@
 
   int request_id = activate_callbacks_.Add(new StatusCallback(callback));
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_ActivateEvent(request_id));
   if (status != SERVICE_WORKER_OK) {
     activate_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
-void ServiceWorkerVersion::OnGetClientDocuments(int request_id) {
+void ServiceWorkerVersion::OnGetClients(
+    int request_id,
+    const ServiceWorkerClientQueryOptions& /* options */) {
+  // TODO(kinuko): Handle ClientQueryOptions. (crbug.com/455241, 460415 etc)
   if (controllee_by_id_.IsEmpty()) {
     if (running_status() == RUNNING) {
       embedded_worker_->SendMessage(
-          ServiceWorkerMsg_DidGetClientDocuments(request_id,
+          ServiceWorkerMsg_DidGetClients(request_id,
               std::vector<ServiceWorkerClientInfo>()));
     }
     return;
   }
 
   TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerVersion::OnGetClientDocuments");
+               "ServiceWorkerVersion::OnGetClients");
 
   std::vector<Tuple<int,int,int>> clients_info;
   for (ControlleeByIDMap::iterator it(&controllee_by_id_); !it.IsAtEnd();
        it.Advance()) {
     int process_id = it.GetCurrentValue()->process_id();
     int frame_id = it.GetCurrentValue()->frame_id();
     int client_id = it.GetCurrentKey();
 
     clients_info.push_back(MakeTuple(process_id, frame_id, client_id));
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&OnGetClientDocumentsFromUI, clients_info, script_url_,
-                 base::Bind(&ServiceWorkerVersion::DidGetClientDocuments,
+      base::Bind(&OnGetClientsFromUI, clients_info, script_url_,
+                 base::Bind(&ServiceWorkerVersion::DidGetClients,
                             weak_factory_.GetWeakPtr(),
                             request_id)));
 
 }
 
 void ServiceWorkerVersion::OnActivateEventFinished(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
   DCHECK(ACTIVATING == status() ||
          REDUNDANT == status()) << status();
@@ skipping 371 matching lines @@
   if (status == SERVICE_WORKER_ERROR_ABORT) {
     embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError(
         request_id, blink::WebServiceWorkerError::ErrorTypeAbort,
         base::ASCIIToUTF16(kClaimClientsShutdownErrorMesage)));
     return;
   }
   DCHECK(status == SERVICE_WORKER_OK);
   embedded_worker_->SendMessage(ServiceWorkerMsg_DidClaimClients(request_id));
 }
 
-void ServiceWorkerVersion::DidGetClientDocuments(
+void ServiceWorkerVersion::DidGetClients(
     int request_id,
     const std::vector<ServiceWorkerClientInfo>& clients) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (running_status() != RUNNING)
     return;
 
   embedded_worker_->SendMessage(
-      ServiceWorkerMsg_DidGetClientDocuments(request_id, clients));
+      ServiceWorkerMsg_DidGetClients(request_id, clients));
 }
 
 void ServiceWorkerVersion::StartTimeoutTimer() {
   DCHECK(!timeout_timer_.IsRunning());
   ClearTick(&idle_time_);
   ClearTick(&ping_time_);
   ping_timed_out_ = false;
   timeout_timer_.Start(FROM_HERE,
                        base::TimeDelta::FromSeconds(kTimeoutTimerDelaySeconds),
                        this, &ServiceWorkerVersion::OnTimeoutTimer);
@@ skipping 155 matching lines @@
     int request_id) {
   callbacks->Remove(request_id);
   if (is_doomed_) {
     // The stop should be already scheduled, but try to stop immediately, in
     // order to release worker resources soon.
     StopWorkerIfIdle();
   }
 }
 
 }  // namespace content