content: Use stl utilities from the base namespace

content/browser/shared_worker/shared_worker_service_impl.cc

 // Copyright 2014 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/shared_worker/shared_worker_service_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 328 matching lines @@
   if (SharedWorkerHost* host =
           FindSharedWorkerHost(filter->render_process_id(), worker_route_id))
     host->WorkerContextClosed();
 }
 
 void SharedWorkerServiceImpl::WorkerContextDestroyed(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   ScopedWorkerDependencyChecker checker(this);
   ProcessRouteIdPair key(filter->render_process_id(), worker_route_id);
-  if (!ContainsKey(worker_hosts_, key))
+  if (!base::ContainsKey(worker_hosts_, key))
     return;
   std::unique_ptr<SharedWorkerHost> host(worker_hosts_[key].release());
   worker_hosts_.erase(key);
   host->WorkerContextDestroyed();
 }
 
 void SharedWorkerServiceImpl::WorkerReadyForInspection(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   if (SharedWorkerHost* host =
           FindSharedWorkerHost(filter->render_process_id(), worker_route_id))
     host->WorkerReadyForInspection();
 }
 
 void SharedWorkerServiceImpl::WorkerScriptLoaded(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   if (SharedWorkerHost* host =
           FindSharedWorkerHost(filter->render_process_id(), worker_route_id))
     host->WorkerScriptLoaded();
 }
 
 void SharedWorkerServiceImpl::WorkerScriptLoadFailed(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   ScopedWorkerDependencyChecker checker(this);
   ProcessRouteIdPair key(filter->render_process_id(), worker_route_id);
-  if (!ContainsKey(worker_hosts_, key))
+  if (!base::ContainsKey(worker_hosts_, key))
     return;
   std::unique_ptr<SharedWorkerHost> host(worker_hosts_[key].release());
   worker_hosts_.erase(key);
   host->WorkerScriptLoadFailed();
 }
 
 void SharedWorkerServiceImpl::WorkerConnected(
     int message_port_id,
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
@@ skipping 135 matching lines @@
     int worker_route_id,
     bool is_new_worker,
     bool pause_on_start) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // To offset the TryIncrementWorkerRefCount called for the reservation,
   // calls DecrementWorkerRefCount after CheckWorkerDependency in
   // ScopeWorkerDependencyChecker's destructor.
   ScopedWorkerDependencyChecker checker(
       this, base::Bind(&DecrementWorkerRefCount, worker_process_id));
 
-  if (!ContainsKey(pending_instances_, pending_instance_id))
+  if (!base::ContainsKey(pending_instances_, pending_instance_id))
     return;
   std::unique_ptr<SharedWorkerPendingInstance> pending_instance(
       pending_instances_[pending_instance_id].release());
   pending_instances_.erase(pending_instance_id);
 
   if (!is_new_worker) {
     SharedWorkerHost* host =
         FindSharedWorkerHost(worker_process_id, worker_route_id);
     if (!host) {
       // Retry reserving a renderer process if the existed Shared Worker was
@@ skipping 30 matching lines @@
       observers_,
       WorkerCreated(url, name, worker_process_id, worker_route_id));
 }
 
 void SharedWorkerServiceImpl::RenderProcessReserveFailedCallback(
     int pending_instance_id,
     int worker_process_id,
     int worker_route_id,
     bool is_new_worker) {
   worker_hosts_.erase(std::make_pair(worker_process_id, worker_route_id));
-  if (!ContainsKey(pending_instances_, pending_instance_id))
+  if (!base::ContainsKey(pending_instances_, pending_instance_id))
     return;
   std::unique_ptr<SharedWorkerPendingInstance> pending_instance(
       pending_instances_[pending_instance_id].release());
   pending_instances_.erase(pending_instance_id);
   pending_instance->RemoveRequest(worker_process_id);
   // Retry reserving a renderer process.
   ReserveRenderProcessToCreateWorker(std::move(pending_instance));
 }
 
 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
     int render_process_id,
     int worker_route_id) {
   ProcessRouteIdPair key = std::make_pair(render_process_id, worker_route_id);
-  if (!ContainsKey(worker_hosts_, key))
+  if (!base::ContainsKey(worker_hosts_, key))
     return nullptr;
   return worker_hosts_[key].get();
 }
 
 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
     const SharedWorkerInstance& instance) {
   for (const auto& iter : worker_hosts_) {
     SharedWorkerHost* host = iter.second.get();
     if (host->IsAvailable() && host->instance()->Matches(instance))
       return host;
@@ skipping 46 matching lines @@
     UpdateWorkerDependencyFunc new_func) {
   update_worker_dependency_ = new_func;
 }
 
 void SharedWorkerServiceImpl::ChangeTryIncrementWorkerRefCountFuncForTesting(
     bool (*new_func)(int)) {
   s_try_increment_worker_ref_count_ = new_func;
 }
 
 }  // namespace content