components: Use stl utilities from the base namespace

components/flags_ui/flags_state.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 <memory>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 386 matching lines @@
 #else
     const std::string& existing_value_utf8 = existing_value;
 #endif
 
     std::vector<std::string> features =
         base::FeatureList::SplitFeatureListString(existing_value_utf8);
     std::vector<std::string> remaining_features;
     // For any featrue name in |features| that is not in |switch_added_values| -
     // i.e. it wasn't added by about_flags code, add it to |remaining_features|.
     for (const std::string& feature : features) {
-      if (!ContainsKey(switch_added_values, feature))
+      if (!base::ContainsKey(switch_added_values, feature))
         remaining_features.push_back(feature);
     }
 
     // Either remove the flag entirely if |remaining_features| is empty, or set
     // the new list.
     if (remaining_features.empty()) {
       switch_list->erase(switch_name);
     } else {
       std::string switch_value = base::JoinString(remaining_features, ",");
 #if defined(OS_WIN)
@@ skipping 167 matching lines @@
   }
 
   return result;
 }
 
 void FlagsState::AddSwitchMapping(
     const std::string& key,
     const std::string& switch_name,
     const std::string& switch_value,
     std::map<std::string, SwitchEntry>* name_to_switch_map) {
-  DCHECK(!ContainsKey(*name_to_switch_map, key));
+  DCHECK(!base::ContainsKey(*name_to_switch_map, key));
 
   SwitchEntry* entry = &(*name_to_switch_map)[key];
   entry->switch_name = switch_name;
   entry->switch_value = switch_value;
 }
 
 void FlagsState::AddFeatureMapping(
     const std::string& key,
     const std::string& feature_name,
     bool feature_state,
     std::map<std::string, SwitchEntry>* name_to_switch_map) {
-  DCHECK(!ContainsKey(*name_to_switch_map, key));
+  DCHECK(!base::ContainsKey(*name_to_switch_map, key));
 
   SwitchEntry* entry = &(*name_to_switch_map)[key];
   entry->feature_name = feature_name;
   entry->feature_state = feature_state;
 }
 
 void FlagsState::AddSwitchesToCommandLine(
     const std::set<std::string>& enabled_entries,
     const std::map<std::string, SwitchEntry>& name_to_switch_map,
     SentinelsMode sentinels,
@@ skipping 40 matching lines @@
 void FlagsState::MergeFeatureCommandLineSwitch(
     const std::map<std::string, bool>& feature_switches,
     const char* switch_name,
     bool feature_state,
     base::CommandLine* command_line) {
   std::string original_switch_value =
       command_line->GetSwitchValueASCII(switch_name);
   std::vector<std::string> features =
       base::FeatureList::SplitFeatureListString(original_switch_value);
   // Only add features that don't already exist in the lists.
-  // Note: The ContainsValue() call results in O(n^2) performance, but in
+  // Note: The base::ContainsValue() call results in O(n^2) performance, but in
   // practice n should be very small.
   for (const auto& entry : feature_switches) {
     if (entry.second == feature_state &&
-        !ContainsValue(features, entry.first)) {
+        !base::ContainsValue(features, entry.first)) {
       features.push_back(entry.first);
       appended_switches_[switch_name].insert(entry.first);
     }
   }
   // Update the switch value only if it didn't change. This avoids setting an
   // empty list or duplicating the same list (since AppendSwitch() adds the
   // switch to the end but doesn't remove previous ones).
   std::string switch_value = base::JoinString(features, ",");
   if (switch_value != original_switch_value)
     command_line->AppendSwitchASCII(switch_name, switch_value);
@@ skipping 43 matching lines @@
   }
 
   std::set<std::string> new_enabled_entries =
       base::STLSetIntersection<std::set<std::string>>(platform_entries,
                                                       *result);
 
   result->swap(new_enabled_entries);
 }
 
 }  // namespace flags_ui