content: Use stl utilities from the base namespace

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 <stddef.h>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 192 matching lines @@
                            "ServiceWorkerDispatcher::GetRegistrationForReady",
                            request_id);
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistrationForReady(
       CurrentWorkerId(), request_id, provider_id));
 }
 
 void ServiceWorkerDispatcher::AddProviderContext(
     ServiceWorkerProviderContext* provider_context) {
   DCHECK(provider_context);
   int provider_id = provider_context->provider_id();
-  DCHECK(!ContainsKey(provider_contexts_, provider_id));
+  DCHECK(!base::ContainsKey(provider_contexts_, provider_id));
   provider_contexts_[provider_id] = provider_context;
 }
 
 void ServiceWorkerDispatcher::RemoveProviderContext(
     ServiceWorkerProviderContext* provider_context) {
   DCHECK(provider_context);
-  DCHECK(ContainsKey(provider_contexts_, provider_context->provider_id()));
+  DCHECK(
+      base::ContainsKey(provider_contexts_, provider_context->provider_id()));
   provider_contexts_.erase(provider_context->provider_id());
 }
 
 void ServiceWorkerDispatcher::AddProviderClient(
     int provider_id,
     blink::WebServiceWorkerProviderClient* client) {
   DCHECK(client);
-  DCHECK(!ContainsKey(provider_clients_, provider_id));
+  DCHECK(!base::ContainsKey(provider_clients_, provider_id));
   provider_clients_[provider_id] = client;
 }
 
 void ServiceWorkerDispatcher::RemoveProviderClient(int provider_id) {
   // This could be possibly called multiple times to ensure termination.
-  if (ContainsKey(provider_clients_, provider_id))
+  if (base::ContainsKey(provider_clients_, provider_id))
     provider_clients_.erase(provider_id);
 }
 
 ServiceWorkerDispatcher*
 ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
     ThreadSafeSender* thread_safe_sender,
     base::SingleThreadTaskRunner* main_thread_task_runner) {
   if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
     NOTREACHED() << "Re-instantiating TLS ServiceWorkerDispatcher.";
     g_dispatcher_tls.Pointer()->Set(NULL);
@@ skipping 494 matching lines @@
       WebMessagePortChannelImpl::CreatePorts(
           params.message_ports, params.new_routing_ids,
           base::ThreadTaskRunnerHandle::Get());
 
   found->second->dispatchMessageEvent(
       WebServiceWorkerImpl::CreateHandle(worker), params.message, ports);
 }
 
 void ServiceWorkerDispatcher::AddServiceWorker(
     int handle_id, WebServiceWorkerImpl* worker) {
-  DCHECK(!ContainsKey(service_workers_, handle_id));
+  DCHECK(!base::ContainsKey(service_workers_, handle_id));
   service_workers_[handle_id] = worker;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorker(int handle_id) {
-  DCHECK(ContainsKey(service_workers_, handle_id));
+  DCHECK(base::ContainsKey(service_workers_, handle_id));
   service_workers_.erase(handle_id);
 }
 
 void ServiceWorkerDispatcher::AddServiceWorkerRegistration(
     int registration_handle_id,
     WebServiceWorkerRegistrationImpl* registration) {
-  DCHECK(!ContainsKey(registrations_, registration_handle_id));
+  DCHECK(!base::ContainsKey(registrations_, registration_handle_id));
   registrations_[registration_handle_id] = registration;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorkerRegistration(
     int registration_handle_id) {
-  DCHECK(ContainsKey(registrations_, registration_handle_id));
+  DCHECK(base::ContainsKey(registrations_, registration_handle_id));
   registrations_.erase(registration_handle_id);
 }
 
 std::unique_ptr<ServiceWorkerRegistrationHandleReference>
 ServiceWorkerDispatcher::Adopt(
     const ServiceWorkerRegistrationObjectInfo& info) {
   return ServiceWorkerRegistrationHandleReference::Adopt(
       info, thread_safe_sender_.get());
 }
 
 std::unique_ptr<ServiceWorkerHandleReference> ServiceWorkerDispatcher::Adopt(
     const ServiceWorkerObjectInfo& info) {
   return ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
 }
 
 }  // namespace content