components: Use stl utilities from the base namespace

components/signin/core/browser/account_tracker_service.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 "components/signin/core/browser/account_tracker_service.h"
 
 #include <stddef.h>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 167 matching lines @@
 }
 
 void AccountTrackerService::NotifyAccountRemoved(const AccountState& state) {
   DCHECK(!state.info.gaia.empty());
   FOR_EACH_OBSERVER(
       Observer, observer_list_, OnAccountRemoved(state.info));
 }
 
 void AccountTrackerService::StartTrackingAccount(
     const std::string& account_id) {
-  if (!ContainsKey(accounts_, account_id)) {
+  if (!base::ContainsKey(accounts_, account_id)) {
     DVLOG(1) << "StartTracking " << account_id;
     AccountState state;
     state.info.account_id = account_id;
     state.info.is_child_account = false;
     accounts_.insert(make_pair(account_id, state));
   }
 }
 
 void AccountTrackerService::StopTrackingAccount(const std::string& account_id) {
   DVLOG(1) << "StopTracking " << account_id;
-  if (ContainsKey(accounts_, account_id)) {
+  if (base::ContainsKey(accounts_, account_id)) {
     AccountState& state = accounts_[account_id];
     RemoveFromPrefs(state);
     if (!state.info.gaia.empty())
       NotifyAccountRemoved(state);
 
     accounts_.erase(account_id);
   }
 }
 
 void AccountTrackerService::SetAccountStateFromUserInfo(
     const std::string& account_id,
     const base::DictionaryValue* user_info) {
-  DCHECK(ContainsKey(accounts_, account_id));
+  DCHECK(base::ContainsKey(accounts_, account_id));
   AccountState& state = accounts_[account_id];
 
   std::string gaia_id;
   std::string email;
   if (user_info->GetString("id", &gaia_id) &&
       user_info->GetString("email", &email)) {
     state.info.gaia = gaia_id;
     state.info.email = email;
 
     std::string hosted_domain;
@@ skipping 14 matching lines @@
       state.info.picture_url = kNoPictureURLFound;
     }
   }
   if (state.info.IsValid())
     NotifyAccountUpdated(state);
   SaveToPrefs(state);
 }
 
 void AccountTrackerService::SetIsChildAccount(const std::string& account_id,
                                               const bool& is_child_account) {
-  DCHECK(ContainsKey(accounts_, account_id));
+  DCHECK(base::ContainsKey(accounts_, account_id));
   AccountState& state = accounts_[account_id];
   if (state.info.is_child_account == is_child_account)
     return;
   state.info.is_child_account = is_child_account;
   if (state.info.IsValid())
     NotifyAccountUpdated(state);
   SaveToPrefs(state);
 }
 
 bool AccountTrackerService::IsMigratable() const {
@@ skipping 14 matching lines @@
 void AccountTrackerService::MigrateToGaiaId() {
   std::set<std::string> to_remove;
   std::map<std::string, AccountState> migrated_accounts;
   for (std::map<std::string, AccountState>::const_iterator it =
            accounts_.begin();
        it != accounts_.end(); ++it) {
     const AccountState& state = it->second;
     std::string account_id = it->first;
     if (account_id != state.info.gaia) {
       std::string new_account_id = state.info.gaia;
-      if (!ContainsKey(accounts_, new_account_id)) {
+      if (!base::ContainsKey(accounts_, new_account_id)) {
         AccountState new_state = state;
         new_state.info.account_id = new_account_id;
         migrated_accounts.insert(make_pair(new_account_id, new_state));
         SaveToPrefs(new_state);
       }
       to_remove.insert(account_id);
     }
   }
 
   // Remove any obsolete account.
   for (auto account_id : to_remove) {
-    if (ContainsKey(accounts_, account_id)) {
+    if (base::ContainsKey(accounts_, account_id)) {
       AccountState& state = accounts_[account_id];
       RemoveFromPrefs(state);
       accounts_.erase(account_id);
     }
   }
 
   for (std::map<std::string, AccountState>::const_iterator it =
            migrated_accounts.begin();
        it != migrated_accounts.end(); ++it) {
     accounts_.insert(*it);
@@ skipping 157 matching lines @@
       return gaia;
     default:
       NOTREACHED();
       return email;
   }
 }
 
 std::string AccountTrackerService::SeedAccountInfo(const std::string& gaia,
                                                    const std::string& email) {
   const std::string account_id = PickAccountIdForAccount(gaia, email);
-  const bool already_exists = ContainsKey(accounts_, account_id);
+  const bool already_exists = base::ContainsKey(accounts_, account_id);
   StartTrackingAccount(account_id);
   AccountState& state = accounts_[account_id];
   DCHECK(!already_exists || state.info.gaia.empty() || state.info.gaia == gaia);
   state.info.gaia = gaia;
   state.info.email = email;
   SaveToPrefs(state);
 
   DVLOG(1) << "AccountTrackerService::SeedAccountInfo"
            << " account_id=" << account_id
            << " gaia_id=" << gaia
            << " email=" << email;
 
   return account_id;
 }
 
 std::string AccountTrackerService::SeedAccountInfo(AccountInfo info) {
   info.account_id = PickAccountIdForAccount(info.gaia, info.email);
 
-  if (!ContainsKey(accounts_, info.account_id)) {
+  if (!base::ContainsKey(accounts_, info.account_id)) {
     StartTrackingAccount(info.account_id);
   }
 
   AccountState& state = accounts_[info.account_id];
   // Update the missing fields in |state.info| with |info|.
   if (state.info.UpdateWith(info)) {
     if (state.info.IsValid()) {
       // Notify only if the account info is fully updated, as it is equivalent
       // to having the account fully fetched.
       NotifyAccountUpdated(state);
     }
     SaveToPrefs(state);
   }
   return info.account_id;
 }
 
 void AccountTrackerService::RemoveAccount(const std::string& account_id) {
   StopTrackingAccount(account_id);
 }