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/stl_util.h"
 #include "base/strings/string16.h"
@@ skipping 20 matching lines @@
 #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 {
 
 typedef ServiceWorkerVersion::StatusCallback StatusCallback;
 typedef ServiceWorkerVersion::MessageCallback MessageCallback;
 
-class ServiceWorkerVersion::GetClientDocumentsCallback
-    : public base::RefCounted<GetClientDocumentsCallback> {
+class ServiceWorkerVersion::GetClientsCallback
+    : public base::RefCounted<GetClientsCallback> {
  public:
-  GetClientDocumentsCallback(int request_id,
-                             ServiceWorkerVersion* version)
+  GetClientsCallback(int request_id, ServiceWorkerVersion* version)
       : request_id_(request_id),
         version_(version) {
     DCHECK(version_);
   }
 
   void AddClientInfo(int client_id, const ServiceWorkerClientInfo& info) {
     clients_.push_back(info);
     clients_.back().client_id = client_id;
   }
 
  private:
-  friend class base::RefCounted<GetClientDocumentsCallback>;
+  friend class base::RefCounted<GetClientsCallback>;
 
-  virtual ~GetClientDocumentsCallback() {
+  virtual ~GetClientsCallback() {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     if (version_->running_status() == RUNNING) {
       version_->embedded_worker_->SendMessage(
-          ServiceWorkerMsg_DidGetClientDocuments(request_id_, clients_));
+          ServiceWorkerMsg_DidGetClients(request_id_, clients_));
     }
   }
 
   std::vector<ServiceWorkerClientInfo> clients_;
   int request_id_;
   scoped_refptr<ServiceWorkerVersion> version_;
 
-  DISALLOW_COPY_AND_ASSIGN(GetClientDocumentsCallback);
+  DISALLOW_COPY_AND_ASSIGN(GetClientsCallback);
 };
 
 namespace {
 
 // Default delay for scheduled stop.
 // (Note that if all references to the version is dropped the worker
 // is also stopped without delay)
 const int64 kStopWorkerDelay = 30;  // 30 secs.
 
 // Delay for attempting to stop a doomed worker with in-flight requests.
@@ skipping 809 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 51 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;
   }
-  scoped_refptr<GetClientDocumentsCallback> callback(
-      new GetClientDocumentsCallback(request_id, this));
+  scoped_refptr<GetClientsCallback> callback(
+      new GetClientsCallback(request_id, this));
   ControlleeByIDMap::iterator it(&controllee_by_id_);
   TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerVersion::OnGetClientDocuments");
+               "ServiceWorkerVersion::OnGetClients");
   while (!it.IsAtEnd()) {
     // TODO(mlamouri): we could coalesce those requests into one.
     it.GetCurrentValue()->GetClientInfo(
         base::Bind(&ServiceWorkerVersion::DidGetClientInfo,
                    weak_factory_.GetWeakPtr(), it.GetCurrentKey(), callback));
     it.Advance();
   }
 }
 
 void ServiceWorkerVersion::OnActivateEventFinished(
@@ skipping 379 matching lines @@
         request_id, blink::WebServiceWorkerError::ErrorTypeAbort,
         base::ASCIIToUTF16(kClaimClientsShutdownErrorMesage)));
     return;
   }
   DCHECK(status == SERVICE_WORKER_OK);
   embedded_worker_->SendMessage(ServiceWorkerMsg_DidClaimClients(request_id));
 }
 
 void ServiceWorkerVersion::DidGetClientInfo(
     int client_id,
-    scoped_refptr<GetClientDocumentsCallback> callback,
+    scoped_refptr<GetClientsCallback> callback,
     const ServiceWorkerClientInfo& info) {
   // 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.
   if (info.IsEmpty())
     return;
 
   // We can get info for a frame that was navigating end ended up with a
   // different URL than expected. In such case, we should make sure to not
@@ skipping 102 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