chrome: Use stl utilities from the base namespace

chrome/browser/extensions/install_verifier.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 "chrome/browser/extensions/install_verifier.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 253 matching lines @@
 }
 
 base::Time InstallVerifier::SignatureTimestamp() {
   if (signature_.get())
     return signature_->timestamp;
   else
     return base::Time();
 }
 
 bool InstallVerifier::IsKnownId(const std::string& id) const {
-  return signature_.get() && (ContainsKey(signature_->ids, id) ||
-                              ContainsKey(signature_->invalid_ids, id));
+  return signature_.get() && (base::ContainsKey(signature_->ids, id) ||
+                              base::ContainsKey(signature_->invalid_ids, id));
 }
 
 bool InstallVerifier::IsInvalid(const std::string& id) const {
-  return ((signature_.get() && ContainsKey(signature_->invalid_ids, id)));
+  return ((signature_.get() && base::ContainsKey(signature_->invalid_ids, id)));
 }
 
 void InstallVerifier::VerifyExtension(const std::string& extension_id) {
   ExtensionIdSet ids;
   ids.insert(extension_id);
   AddMany(ids, ADD_SINGLE);
 }
 
 void InstallVerifier::AddMany(const ExtensionIdSet& ids, OperationType type) {
   if (!ShouldFetchSignature()) {
@@ skipping 31 matching lines @@
   ids.insert(id);
   RemoveMany(ids);
 }
 
 void InstallVerifier::RemoveMany(const ExtensionIdSet& ids) {
   if (!signature_.get() || !ShouldFetchSignature())
     return;
 
   bool found_any = false;
   for (ExtensionIdSet::const_iterator i = ids.begin(); i != ids.end(); ++i) {
-    if (ContainsKey(signature_->ids, *i) ||
-        ContainsKey(signature_->invalid_ids, *i)) {
+    if (base::ContainsKey(signature_->ids, *i) ||
+        base::ContainsKey(signature_->invalid_ids, *i)) {
       found_any = true;
       break;
     }
   }
   if (!found_any)
     return;
 
   InstallVerifier::PendingOperation* operation =
       new InstallVerifier::PendingOperation(InstallVerifier::REMOVE);
   operation->ids = ids;
@@ skipping 56 matching lines @@
     MustRemainDisabledHistogram(COMPONENT);
     return false;
   }
   if (AllowedByEnterprisePolicy(extension->id())) {
     MustRemainDisabledHistogram(ENTERPRISE_POLICY_ALLOWED);
     return false;
   }
 
   bool verified = true;
   MustRemainDisabledOutcome outcome = VERIFIED;
-  if (ContainsKey(InstallSigner::GetForcedNotFromWebstore(), extension->id())) {
+  if (base::ContainsKey(InstallSigner::GetForcedNotFromWebstore(),
+                        extension->id())) {
     verified = false;
     outcome = FORCED_NOT_VERIFIED;
   } else if (!IsFromStore(*extension)) {
     verified = false;
     outcome = NOT_FROM_STORE;
   } else if (signature_.get() == NULL &&
              (!bootstrap_check_complete_ || GetStatus() < ENFORCE_STRICT)) {
     // If we don't have a signature yet, we'll temporarily consider every
     // extension from the webstore verified to avoid false positives on existing
     // profiles hitting this code for the first time. The InstallVerifier
     // will bootstrap itself once the ExtensionsSystem is ready.
     outcome = NO_SIGNATURE;
   } else if (!IsVerified(extension->id())) {
     if (signature_.get() &&
-        !ContainsKey(signature_->invalid_ids, extension->id())) {
+        !base::ContainsKey(signature_->invalid_ids, extension->id())) {
       outcome = NOT_VERIFIED_BUT_UNKNOWN_ID;
     } else {
       verified = false;
       outcome = NOT_VERIFIED;
     }
   }
   if (!verified && !ShouldEnforce()) {
     verified = true;
     outcome = NOT_VERIFIED_BUT_NOT_ENFORCING;
   }
@@ skipping 106 matching lines @@
     ExtensionIdSet::iterator found = leftovers.find(*i);
     if (found != leftovers.end())
       leftovers.erase(found);
   }
   if (!leftovers.empty()) {
     RemoveMany(leftovers);
   }
 }
 
 bool InstallVerifier::IsVerified(const std::string& id) const {
-  return ((signature_.get() && ContainsKey(signature_->ids, id)) ||
-          ContainsKey(provisional_, id));
+  return ((signature_.get() && base::ContainsKey(signature_->ids, id)) ||
+          base::ContainsKey(provisional_, id));
 }
 
 void InstallVerifier::BeginFetch() {
   DCHECK(ShouldFetchSignature());
 
   // TODO(asargent) - It would be possible to coalesce all operations in the
   // queue into one fetch - we'd probably just need to change the queue to
   // hold (set of ids, list of operation type) pairs.
   CHECK(!operation_queue_.empty());
   const PendingOperation& operation = *operation_queue_.front();
 
   ExtensionIdSet ids_to_sign;
   if (signature_.get()) {
     ids_to_sign.insert(signature_->ids.begin(), signature_->ids.end());
   }
   if (operation.type == InstallVerifier::REMOVE) {
     for (ExtensionIdSet::const_iterator i = operation.ids.begin();
          i != operation.ids.end(); ++i) {
-      if (ContainsKey(ids_to_sign, *i))
+      if (base::ContainsKey(ids_to_sign, *i))
         ids_to_sign.erase(*i);
     }
   } else {  // All other operation types are some form of "ADD".
     ids_to_sign.insert(operation.ids.begin(), operation.ids.end());
   }
 
   signer_.reset(new InstallSigner(
       content::BrowserContext::GetDefaultStoragePartition(context_)->
           GetURLRequestContext(),
       ids_to_sign));
@@ skipping 88 matching lines @@
 ScopedInstallVerifierBypassForTest::~ScopedInstallVerifierBypassForTest() {
   g_bypass_for_test = old_value_;
 }
 
 // static
 bool ScopedInstallVerifierBypassForTest::ShouldBypass() {
   return g_bypass_for_test;
 }
 
 }  // namespace extensions