chrome: Use stl utilities from the base namespace

chrome/browser/extensions/updater/extension_updater_unittest.cc

 // Copyright (c) 2012 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/updater/extension_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
@@ skipping 489 matching lines @@
   void AddFakeCrxInstaller(const std::string& id, CrxInstaller* crx_installer) {
     fake_crx_installers_[id] = crx_installer;
   }
 
   bool UpdateExtension(const CRXFileInfo& file,
                        bool file_ownership_passed,
                        CrxInstaller** out_crx_installer) override {
     extension_id_ = file.extension_id;
     install_path_ = file.path;
 
-    if (ContainsKey(fake_crx_installers_, extension_id_)) {
+    if (base::ContainsKey(fake_crx_installers_, extension_id_)) {
       *out_crx_installer = fake_crx_installers_[extension_id_];
       return true;
     }
 
     return false;
   }
 
   PendingExtensionManager* pending_extension_manager() override {
     return &pending_extension_manager_;
   }
@@ skipping 66 matching lines @@
     // We've found "x=<something>", now unescape <something> and look for
     // the "id=<id>&ping=<ping_value>" parameters within.
     std::string unescaped = net::UnescapeURLComponent(
         param.second,
         net::UnescapeRule::PATH_SEPARATORS |
             net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS);
     base::StringPairs extension_params;
     base::SplitStringIntoKeyValuePairs(unescaped, '=', '&', &extension_params);
     std::multimap<std::string, std::string> param_map;
     param_map.insert(extension_params.begin(), extension_params.end());
-    if (ContainsKey(param_map, "id") && ContainsKey(param_map, "ping")) {
+    if (base::ContainsKey(param_map, "id") &&
+        base::ContainsKey(param_map, "ping")) {
       std::string id = param_map.find("id")->second;
       result[id] = ParamsMap();
 
       // Pull the key=value pairs out of the ping parameter for this id and
       // put into the result.
       std::string ping = net::UnescapeURLComponent(
           param_map.find("ping")->second,
           net::UnescapeRule::PATH_SEPARATORS |
               net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS);
       base::StringPairs ping_params;
       base::SplitStringIntoKeyValuePairs(ping, '=', '&', &ping_params);
       for (const auto& ping_param : ping_params) {
-        if (!ContainsKey(result[id], ping_param.first))
+        if (!base::ContainsKey(result[id], ping_param.first))
           result[id][ping_param.first] = std::set<std::string>();
         result[id][ping_param.first].insert(ping_param.second);
       }
     }
   }
   return result;
 }
 
 static void VerifyQueryAndExtractParameters(
     const std::string& query,
@@ skipping 1080 matching lines @@
       url2_fetch_url = fetched_urls[0];
       url1_query = fetched_urls[1].query();
       url2_query = fetched_urls[0].query();
     } else {
       NOTREACHED();
     }
 
     std::map<std::string, ParamsMap> url1_ping_data =
         GetPingDataFromURL(url1_fetch_url);
     ParamsMap url1_params = ParamsMap();
-    if (!url1_ping_data.empty() && ContainsKey(url1_ping_data, id))
+    if (!url1_ping_data.empty() && base::ContainsKey(url1_ping_data, id))
       url1_params = url1_ping_data[id];
 
     // First make sure the non-google query had no ping parameter.
     EXPECT_TRUE(GetPingDataFromURL(url2_fetch_url).empty());
 
     // Now make sure the google query had the correct ping parameter.
     bool did_rollcall = false;
     if (rollcall_ping_days != 0) {
-      ASSERT_TRUE(ContainsKey(url1_params, "r"));
+      ASSERT_TRUE(base::ContainsKey(url1_params, "r"));
       ASSERT_EQ(1u, url1_params["r"].size());
       EXPECT_EQ(base::IntToString(rollcall_ping_days),
                 *url1_params["r"].begin());
       did_rollcall = true;
     }
     if (active_bit && active_ping_days != 0 && did_rollcall) {
-      ASSERT_TRUE(ContainsKey(url1_params, "a"));
+      ASSERT_TRUE(base::ContainsKey(url1_params, "a"));
       ASSERT_EQ(1u, url1_params["a"].size());
       EXPECT_EQ(base::IntToString(active_ping_days),
                 *url1_params["a"].begin());
     }
 
     // Make sure the non-google query has no brand parameter.
     const std::string brand_string = "brand%3D";
     EXPECT_TRUE(url2_query.find(brand_string) == std::string::npos);
 
 #if defined(GOOGLE_CHROME_BUILD)
@@ skipping 98 matching lines @@
     const GURL& url = fetcher->GetOriginalURL();
     EXPECT_FALSE(url.is_empty());
     EXPECT_TRUE(url.is_valid());
     EXPECT_TRUE(url.has_query());
 
     std::map<std::string, ParamsMap> all_pings = GetPingDataFromURL(url);
 
     // Make sure that all the enabled extensions have "e=1" in their ping
     // parameter.
     for (const auto& ext : enabled_extensions) {
-      ASSERT_TRUE(ContainsKey(all_pings, ext->id()));
+      ASSERT_TRUE(base::ContainsKey(all_pings, ext->id()));
       ParamsMap& ping = all_pings[ext->id()];
-      EXPECT_FALSE(ContainsKey(ping, "dr"));
-      ASSERT_TRUE(ContainsKey(ping, "e")) << url;
+      EXPECT_FALSE(base::ContainsKey(ping, "dr"));
+      ASSERT_TRUE(base::ContainsKey(ping, "e")) << url;
       std::set<std::string> e = ping["e"];
       ASSERT_EQ(1u, e.size()) << url;
       EXPECT_EQ(std::string("1"), *e.begin()) << url;
-      EXPECT_FALSE(ContainsKey(ping, "dr"));
+      EXPECT_FALSE(base::ContainsKey(ping, "dr"));
     }
 
     // Make sure that all the disable extensions have the appropriate
     // "dr=<num>" values in their ping parameter if metrics are on, or omit
     // it otherwise.
     ASSERT_EQ(disabled_extensions.size(), disabled.size());
     for (size_t i = 0; i < disabled.size(); i++) {
       scoped_refptr<const Extension>& ext = disabled_extensions[i];
       int disable_reasons = disabled[i];
-      ASSERT_TRUE(ContainsKey(all_pings, ext->id())) << url;
+      ASSERT_TRUE(base::ContainsKey(all_pings, ext->id())) << url;
       ParamsMap& ping = all_pings[ext->id()];
 
-      ASSERT_TRUE(ContainsKey(ping, "e")) << url;
+      ASSERT_TRUE(base::ContainsKey(ping, "e")) << url;
       std::set<std::string> e = ping["e"];
       ASSERT_EQ(1u, e.size()) << url;
       EXPECT_EQ(std::string("0"), *e.begin()) << url;
 
       if (disable_reasons == 0) {
-        EXPECT_FALSE(ContainsKey(ping, "dr"));
+        EXPECT_FALSE(base::ContainsKey(ping, "dr"));
       } else {
-        ASSERT_TRUE(ContainsKey(ping, "dr"));
+        ASSERT_TRUE(base::ContainsKey(ping, "dr"));
         int found_reasons = 0;
         for (const auto& reason_string : ping["dr"]) {
           int reason = 0;
           ASSERT_TRUE(base::StringToInt(reason_string, &reason));
           // Make sure it's a power of 2.
           ASSERT_TRUE(reason < 2 || !(reason & (reason - 1))) << reason;
           found_reasons |= reason;
         }
         EXPECT_EQ(disable_reasons, found_reasons);
       }
@@ skipping 377 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions