components: Use stl utilities from the base namespace

components/flags_ui/flags_state_unittest.cc

 // Copyright 2015 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/flags_ui/flags_state.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 391 matching lines @@
   switch_list[kSwitch1] = base::CommandLine::StringType();
   switch_list[switches::kFlagSwitchesBegin] = base::CommandLine::StringType();
   switch_list[switches::kFlagSwitchesEnd] = base::CommandLine::StringType();
   switch_list["foo"] = base::CommandLine::StringType();
 
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, kFlags1, true);
 
   // This shouldn't do anything before ConvertFlagsToSwitches() wasn't called.
   flags_state_->RemoveFlagsSwitches(&switch_list);
   ASSERT_EQ(4u, switch_list.size());
-  EXPECT_TRUE(ContainsKey(switch_list, kSwitch1));
-  EXPECT_TRUE(ContainsKey(switch_list, switches::kFlagSwitchesBegin));
-  EXPECT_TRUE(ContainsKey(switch_list, switches::kFlagSwitchesEnd));
-  EXPECT_TRUE(ContainsKey(switch_list, "foo"));
+  EXPECT_TRUE(base::ContainsKey(switch_list, kSwitch1));
+  EXPECT_TRUE(base::ContainsKey(switch_list, switches::kFlagSwitchesBegin));
+  EXPECT_TRUE(base::ContainsKey(switch_list, switches::kFlagSwitchesEnd));
+  EXPECT_TRUE(base::ContainsKey(switch_list, "foo"));
 
   // Call ConvertFlagsToSwitches(), then RemoveFlagsSwitches() again.
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch("foo");
   flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                        kAddSentinels, kEnableFeatures,
                                        kDisableFeatures);
   flags_state_->RemoveFlagsSwitches(&switch_list);
 
   // Now the about:flags-related switch should have been removed.
   ASSERT_EQ(1u, switch_list.size());
-  EXPECT_TRUE(ContainsKey(switch_list, "foo"));
+  EXPECT_TRUE(base::ContainsKey(switch_list, "foo"));
 }
 
 TEST_F(FlagsStateTest, RemoveFlagSwitches_Features) {
   struct {
     int enabled_choice;  // 0: default, 1: enabled, 2: disabled.
     const char* existing_enable_features;
     const char* existing_disable_features;
     const char* expected_enable_features;
     const char* expected_disable_features;
   } cases[] = {
@@ skipping 30 matching lines @@
 
     const std::string entry_name = base::StringPrintf(
         "%s%s%d", kFlags7, testing::kMultiSeparator, cases[i].enabled_choice);
     flags_state_->SetFeatureEntryEnabled(&flags_storage_, entry_name, true);
 
     flags_state_->ConvertFlagsToSwitches(&flags_storage_, &command_line,
                                          kAddSentinels, kEnableFeatures,
                                          kDisableFeatures);
     auto switch_list = command_line.GetSwitches();
     EXPECT_EQ(cases[i].expected_enable_features != nullptr,
-              ContainsKey(switch_list, kEnableFeatures));
+              base::ContainsKey(switch_list, kEnableFeatures));
     if (cases[i].expected_enable_features)
       EXPECT_EQ(CreateSwitch(cases[i].expected_enable_features),
                 switch_list[kEnableFeatures]);
 
     EXPECT_EQ(cases[i].expected_disable_features != nullptr,
-              ContainsKey(switch_list, kDisableFeatures));
+              base::ContainsKey(switch_list, kDisableFeatures));
     if (cases[i].expected_disable_features)
       EXPECT_EQ(CreateSwitch(cases[i].expected_disable_features),
                 switch_list[kDisableFeatures]);
 
     // RemoveFlagsSwitches() should result in the original values for these
     // switches.
     switch_list = command_line.GetSwitches();
     flags_state_->RemoveFlagsSwitches(&switch_list);
     EXPECT_EQ(cases[i].existing_enable_features != nullptr,
-              ContainsKey(switch_list, kEnableFeatures));
+              base::ContainsKey(switch_list, kEnableFeatures));
     if (cases[i].existing_enable_features)
       EXPECT_EQ(CreateSwitch(cases[i].existing_enable_features),
                 switch_list[kEnableFeatures]);
     EXPECT_EQ(cases[i].existing_disable_features != nullptr,
-              ContainsKey(switch_list, kEnableFeatures));
+              base::ContainsKey(switch_list, kEnableFeatures));
     if (cases[i].existing_disable_features)
       EXPECT_EQ(CreateSwitch(cases[i].existing_disable_features),
                 switch_list[kDisableFeatures]);
   }
 }
 
 // Tests enabling entries that aren't supported on the current platform.
 TEST_F(FlagsStateTest, PersistAndPrune) {
   // Enable entries 1 and 3.
   flags_state_->SetFeatureEntryEnabled(&flags_storage_, kFlags1, true);
@@ skipping 271 matching lines @@
                                       &supported_entries, &unsupported_entries,
                                       base::Bind(&SkipFeatureEntry));
   // All |kEntries| except for |kFlags3| should be supported.
   EXPECT_EQ(7u, supported_entries.GetSize());
   EXPECT_EQ(1u, unsupported_entries.GetSize());
   EXPECT_EQ(arraysize(kEntries),
             supported_entries.GetSize() + unsupported_entries.GetSize());
 }
 
 }  // namespace flags_ui