storage: Use stl utilities from the base namespace

storage/browser/quota/client_usage_tracker.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 "storage/browser/quota/client_usage_tracker.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
@@ skipping 28 matching lines @@
 
   if (found->second.empty())
     origins_by_host->erase(host);
   return true;
 }
 
 bool OriginSetContainsOrigin(const OriginSetByHost& origins,
                              const std::string& host,
                              const GURL& origin) {
   OriginSetByHost::const_iterator itr = origins.find(host);
-  return itr != origins.end() && ContainsKey(itr->second, origin);
+  return itr != origins.end() && base::ContainsKey(itr->second, origin);
 }
 
 void DidGetGlobalUsageForLimitedGlobalUsage(const UsageCallback& callback,
                                             int64_t total_global_usage,
                                             int64_t global_unlimited_usage) {
   callback.Run(total_global_usage - global_unlimited_usage);
 }
 
 }  // namespace
 
@@ skipping 55 matching lines @@
     return;
   }
 
   client_->GetOriginsForType(type_, base::Bind(
       &ClientUsageTracker::DidGetOriginsForGlobalUsage, AsWeakPtr(),
       callback));
 }
 
 void ClientUsageTracker::GetHostUsage(
     const std::string& host, const UsageCallback& callback) {
-  if (ContainsKey(cached_hosts_, host) &&
-      !ContainsKey(non_cached_limited_origins_by_host_, host) &&
-      !ContainsKey(non_cached_unlimited_origins_by_host_, host)) {
+  if (base::ContainsKey(cached_hosts_, host) &&
+      !base::ContainsKey(non_cached_limited_origins_by_host_, host) &&
+      !base::ContainsKey(non_cached_unlimited_origins_by_host_, host)) {
     // TODO(kinuko): Drop host_usage_map_ cache periodically.
     callback.Run(GetCachedHostUsage(host));
     return;
   }
 
   if (!host_usage_accumulators_.Add(
           host, base::Bind(&DidGetHostUsage, callback)))
     return;
   client_->GetOriginsForHost(type_, host, base::Bind(
       &ClientUsageTracker::DidGetOriginsForHostUsage, AsWeakPtr(), host));
@@ skipping 322 matching lines @@
 }
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   if (type_ == kStorageTypeSyncable)
     return false;
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace storage