ServiceWorker: Rename ScriptClientMap to ProviderClientMap

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"
@@ skipping 167 matching lines @@
     ServiceWorkerProviderContext* provider_context) {
   DCHECK(provider_context);
   DCHECK(ContainsKey(provider_contexts_, provider_context->provider_id()));
   provider_contexts_.erase(provider_context->provider_id());
   worker_to_provider_.erase(provider_context->installing_handle_id());
   worker_to_provider_.erase(provider_context->waiting_handle_id());
   worker_to_provider_.erase(provider_context->active_handle_id());
   worker_to_provider_.erase(provider_context->controller_handle_id());
 }
 
-void ServiceWorkerDispatcher::AddScriptClient(
+void ServiceWorkerDispatcher::AddProviderClient(
     int provider_id,
     blink::WebServiceWorkerProviderClient* client) {
   DCHECK(client);
-  DCHECK(!ContainsKey(script_clients_, provider_id));
-  script_clients_[provider_id] = client;
+  DCHECK(!ContainsKey(provider_clients_, provider_id));
+  provider_clients_[provider_id] = client;
 }
 
-void ServiceWorkerDispatcher::RemoveScriptClient(int provider_id) {
+void ServiceWorkerDispatcher::RemoveProviderClient(int provider_id) {
   // This could be possibly called multiple times to ensure termination.
-  if (ContainsKey(script_clients_, provider_id))
-    script_clients_.erase(provider_id);
+  if (ContainsKey(provider_clients_, provider_id))
+    provider_clients_.erase(provider_id);
 }
 
 ServiceWorkerDispatcher*
 ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
     ThreadSafeSender* thread_safe_sender) {
   if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
     NOTREACHED() << "Re-instantiating TLS ServiceWorkerDispatcher.";
     g_dispatcher_tls.Pointer()->Set(NULL);
   }
   if (g_dispatcher_tls.Pointer()->Get())
@@ skipping 373 matching lines @@
 void ServiceWorkerDispatcher::SetReadyRegistration(
     int provider_id,
     int registration_handle_id) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider == provider_contexts_.end() ||
       provider->second->registration_handle_id() != registration_handle_id ||
       provider->second->active_handle_id() == kInvalidServiceWorkerHandleId) {
     return;
   }
 
-  ScriptClientMap::iterator client = script_clients_.find(provider_id);
-  if (client == script_clients_.end())
+  ProviderClientMap::iterator client = provider_clients_.find(provider_id);
+  if (client == provider_clients_.end())
     return;
 
   ServiceWorkerRegistrationObjectInfo info =
       provider->second->registration()->info();
   WebServiceWorkerRegistrationImpl* registration =
       FindServiceWorkerRegistration(info, false);
   if (!registration) {
     registration = CreateServiceWorkerRegistration(info, false);
     ServiceWorkerVersionAttributes attrs =
         provider->second->GetVersionAttributes();
@@ skipping 17 matching lines @@
                "Provider ID", provider_id);
 
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider != provider_contexts_.end()) {
     worker_to_provider_.erase(provider->second->controller_handle_id());
     if (info.handle_id != kInvalidServiceWorkerHandleId)
       worker_to_provider_[info.handle_id] = provider->second;
     provider->second->OnSetControllerServiceWorker(info);
   }
 
-  ScriptClientMap::iterator found = script_clients_.find(provider_id);
-  if (found != script_clients_.end()) {
+  ProviderClientMap::iterator found = provider_clients_.find(provider_id);
+  if (found != provider_clients_.end()) {
     // Populate the .controller field with the new worker object.
     found->second->setController(GetServiceWorker(info, false),
                                  should_notify_controllerchange);
   }
 }
 
 void ServiceWorkerDispatcher::OnPostMessage(
     int thread_id,
     int provider_id,
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids,
     const std::vector<int>& new_routing_ids) {
   // Make sure we're on the main document thread. (That must be the only
   // thread we get this message)
   DCHECK(ChildThread::current());
   TRACE_EVENT1("ServiceWorker",
                "ServiceWorkerDispatcher::OnPostMessage",
                "Thread ID", thread_id);
 
-  ScriptClientMap::iterator found = script_clients_.find(provider_id);
-  if (found == script_clients_.end()) {
+  ProviderClientMap::iterator found = provider_clients_.find(provider_id);
+  if (found == provider_clients_.end()) {
     // For now we do no queueing for messages sent to nonexistent / unattached
     // client.
     return;
   }
 
   std::vector<WebMessagePortChannelImpl*> ports;
   if (!sent_message_port_ids.empty()) {
     ports.resize(sent_message_port_ids.size());
     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);
+  ProviderClientMap::iterator found = provider_clients_.find(provider_id);
   // TODO(ksakamoto): Could we track these values in the browser side? Except
   // for |isFocused|, it would be pretty easy.
-  if (found != script_clients_.end() && found->second->getClientInfo(&info)) {
+  if (found != provider_clients_.end() && found->second->getClientInfo(&info)) {
     ServiceWorkerClientInfo result;
     result.client_id = info.clientID;
     result.page_visibility_state = info.pageVisibilityState;
     result.is_focused = info.isFocused;
     result.url = info.url;
     result.frame_type = static_cast<RequestContextFrameType>(info.frameType);
 
     thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetClientInfoSuccess(
         embedded_worker_id, request_id, result));
   } else {
@@ skipping 44 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