[base] Replace Contains{Key,Value} with Contains in //chrome

This change replaces usages of base::ContainsKey() and base::ContainsValue()
with base::Contains() in //chrome.

Reproduction:
 - sed -i 's/\bbase::ContainsKey\b/base::Contains/g'
 - sed -i 's/\bbase::ContainsValue\b/base::Contains/g'
 - git cl format

This CL was uploaded by git cl split.

R=thestig@chromium.org

Bug: 970209
Change-Id: Ifd6e5f730ab1f7cf38ffaa8ea3386056a74c099c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1648169
Auto-Submit: Jan Wilken Dörrie <jdoerrie@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
Cr-Commit-Position: refs/heads/master@{#666788}

chrome/browser/internal_auth.cc

@@ -110,8 +110,8 @@ bool IsVarSane(const std::string& var) {
       sizeof(kAllowedChars) == 26 + 26 + 10 + 1 + 1, "some mess with chars");
   // We must not allow kItemSeparator in anything used as an input to construct
   // message to sign.
-  DCHECK(!base::ContainsValue(kAllowedChars, kItemSeparator));
-  DCHECK(!base::ContainsValue(kAllowedChars, kVarValueSeparator));
+  DCHECK(!base::Contains(kAllowedChars, kItemSeparator));
+  DCHECK(!base::Contains(kAllowedChars, kVarValueSeparator));
   return !var.empty() &&
       var.size() <= kStringLengthLimit &&
       base::IsStringASCII(var) &&
@@ -381,7 +381,7 @@ class InternalAuthGenerationService : public base::ThreadChecker {
       int idx = static_cast<int>(used_ticks_.size()) -
           static_cast<int>(current_tick - tick + 1);
       if (idx < 0 || used_ticks_[idx] != tick) {
-        DCHECK(!base::ContainsValue(used_ticks_, tick));
+        DCHECK(!base::Contains(used_ticks_, tick));
         return tick;
       }
     }

chrome/browser/lifetime/browser_close_manager.cc

@@ -181,7 +181,7 @@ void BrowserCloseManager::CloseBrowsers() {
         browser->tab_strip_model()->DetachWebContentsAt(0);
       browser->window()->DestroyBrowser();
       // Destroying the browser should have removed it from the browser list.
-      DCHECK(!base::ContainsValue(*BrowserList::GetInstance(), browser));
+      DCHECK(!base::Contains(*BrowserList::GetInstance(), browser));
     }
   }
 

chrome/chrome_cleaner/chrome_utils/extensions_util.cc

@@ -238,7 +238,7 @@ void GetDefaultExtensionsFromParsedJson(
       base::WrapRefCounted(new RefValue(json->Clone()));
   for (const auto& entry : *default_extensions) {
     base::string16 extension_id = base::UTF8ToUTF16(entry.first);
-    if (!base::ContainsValue(default_extension_whitelist, extension_id)) {
+    if (!base::Contains(default_extension_whitelist, extension_id)) {
       policies->emplace_back(extension_id, extensions_file, saved_json);
     }
   }

chrome/chrome_cleaner/engines/target/test_engine_delegate.cc

@@ -174,8 +174,8 @@ uint32_t ScanForUwS(
     scoped_refptr<EngineFileRequestsProxy> privileged_file_calls,
     scoped_refptr<EngineScanResultsProxy> report_result_calls) {
   // Only check the Startup folder, assuming it's enabled
-  if (!base::ContainsValue(enabled_trace_locations,
-                           UwS_TraceLocation_FOUND_IN_SHELL)) {
+  if (!base::Contains(enabled_trace_locations,
+                      UwS_TraceLocation_FOUND_IN_SHELL)) {
     return EngineResultCode::kSuccess;
   }
 

chrome/chrome_cleaner/os/disk_util.cc

@@ -476,7 +476,7 @@ base::string16 FileInformationToString(
 }
 
 bool IsCompanyOnIgnoredReportingList(const base::string16& company_name) {
-  return base::ContainsValue(kCompanyIgnoredReportingList, company_name);
+  return base::Contains(kCompanyIgnoredReportingList, company_name);
 }
 
 bool IsExecutableOnIgnoredReportingList(const base::FilePath& file_path) {

chrome/chrome_cleaner/os/disk_util_unittest.cc

@@ -390,7 +390,7 @@ TEST(DiskUtilTests, CollectMatchingPathsNoWildcards) {
   base::FilePath no_wildcard_path(sub_dir.GetPath());
   CollectMatchingPaths(no_wildcard_path, &matches);
   EXPECT_EQ(1UL, matches.size());
-  EXPECT_TRUE(base::ContainsValue(matches, sub_dir.GetPath()));
+  EXPECT_TRUE(base::Contains(matches, sub_dir.GetPath()));
 }
 
 TEST(DiskUtilTests, CollectExecutableMatchingPaths) {

chrome/chrome_cleaner/os/task_scheduler_unittest.cc

@@ -207,8 +207,8 @@ TEST_F(TaskSchedulerTests, GetTaskNameList) {
 
   std::vector<base::string16> task_names;
   EXPECT_TRUE(task_scheduler_->GetTaskNameList(&task_names));
-  EXPECT_TRUE(base::ContainsValue(task_names, kTaskName1));
-  EXPECT_TRUE(base::ContainsValue(task_names, kTaskName2));
+  EXPECT_TRUE(base::Contains(task_names, kTaskName1));
+  EXPECT_TRUE(base::Contains(task_names, kTaskName2));
 
   EXPECT_TRUE(task_scheduler_->DeleteTask(kTaskName1));
   EXPECT_TRUE(task_scheduler_->DeleteTask(kTaskName2));
@@ -228,7 +228,7 @@ TEST_F(TaskSchedulerTests, GetTasksIncludesHidden) {
 
   std::vector<base::string16> task_names;
   EXPECT_TRUE(task_scheduler_->GetTaskNameList(&task_names));
-  EXPECT_TRUE(base::ContainsValue(task_names, kTaskName1));
+  EXPECT_TRUE(base::Contains(task_names, kTaskName1));
 
   EXPECT_TRUE(task_scheduler_->DeleteTask(kTaskName1));
 }

chrome/chrome_cleaner/parsers/json_parser/json_splicer_unittest.cc

@@ -49,13 +49,13 @@ bool IsDaysOfWeek(const base::DictionaryValue* dictionary) {
 }
 
 bool IsDaysOfWeek(const std::vector<base::Value>& list) {
-  return base::ContainsValue(list, base::Value("sunday")) &&
-         base::ContainsValue(list, base::Value("monday")) &&
-         base::ContainsValue(list, base::Value("tuesday")) &&
-         base::ContainsValue(list, base::Value("wednesday")) &&
-         base::ContainsValue(list, base::Value("thursday")) &&
-         base::ContainsValue(list, base::Value("friday")) &&
-         base::ContainsValue(list, base::Value("saturday"));
+  return base::Contains(list, base::Value("sunday")) &&
+         base::Contains(list, base::Value("monday")) &&
+         base::Contains(list, base::Value("tuesday")) &&
+         base::Contains(list, base::Value("wednesday")) &&
+         base::Contains(list, base::Value("thursday")) &&
+         base::Contains(list, base::Value("friday")) &&
+         base::Contains(list, base::Value("saturday"));
 }
 
 class JsonSplicerImplTest : public testing::Test {

chrome/chrome_cleaner/pup_data/pup_data_unittest.cc

@@ -654,9 +654,9 @@ TEST_F(PUPDataTest, GetUwSIds) {
 
   const std::vector<UwSId>* pup_ids = PUPData::GetUwSIds();
   EXPECT_EQ(pup_ids->size(), 2UL);
-  EXPECT_TRUE(base::ContainsValue(*pup_ids, k24ID));
-  EXPECT_TRUE(base::ContainsValue(*pup_ids, k42ID));
-  EXPECT_FALSE(base::ContainsValue(*pup_ids, k12ID));
+  EXPECT_TRUE(base::Contains(*pup_ids, k24ID));
+  EXPECT_TRUE(base::Contains(*pup_ids, k42ID));
+  EXPECT_FALSE(base::Contains(*pup_ids, k12ID));
 }
 
 TEST_F(PUPDataTest, InitializeTest) {

chrome/chrome_cleaner/test/test_scoped_service_handle.cc

@@ -171,7 +171,7 @@ AssertionResult EnsureNoTestServicesRunning() {
   for (const ServiceStatus& service : services) {
     base::string16 service_name = service.service_name;
     base::ProcessId pid = service.service_status_process.dwProcessId;
-    if (base::ContainsValue(process_ids, pid)) {
+    if (base::Contains(process_ids, pid)) {
       if (!StopService(service_name.c_str()))
         return AssertionFailure() << "Could not stop service " << service_name;
       stopped_service_names.push_back(service_name);

chrome/common/extensions/command_unittest.cc

@@ -67,7 +67,7 @@ void CheckParse(const ConstCommandsTestData& data,
   if (data.key[0] != '\0') {
     std::string current_platform = extensions::Command::CommandPlatform();
     if (platform_specific_only &&
-        !base::ContainsValue(platforms, current_platform)) {
+        !base::Contains(platforms, current_platform)) {
       // Given a |current_platform| without a |suggested_key|, |default| is
       // used. However, some keys, such as Search on Chrome OS, are only valid
       // for platform specific entries. Skip the test in this case.

chrome/installer/util/delete_old_versions.cc

@@ -87,7 +87,7 @@ bool DeleteDirectoriesWithoutMatchingExecutable(
   bool success = true;
   for (const base::FilePath& directory_name : directories) {
     // Delete the directory if it doesn't have a matching executable.
-    if (!base::ContainsKey(executables, directory_name)) {
+    if (!base::Contains(executables, directory_name)) {
       const base::FilePath directory_path = install_dir.Append(directory_name);
       LOG(WARNING) << "Attempting to delete stray directory "
                    << directory_path.value();
@@ -113,7 +113,7 @@ bool DeleteExecutablesWithoutMatchingDirectory(
     const auto& executables_for_version = version_and_executables.second;
 
     // Don't delete the executables if they have a matching directory.
-    if (base::ContainsKey(directories, version_dir_name))
+    if (base::Contains(directories, version_dir_name))
       continue;
 
     // Delete executables for version |version_dir_name|.

chrome/renderer/content_settings_observer.cc

@@ -165,8 +165,8 @@ bool ContentSettingsObserver::IsPluginTemporarilyAllowed(
     const std::string& identifier) {
   // If the empty string is in here, it means all plugins are allowed.
   // TODO(bauerb): Remove this once we only pass in explicit identifiers.
-  return base::ContainsKey(temporarily_allowed_plugins_, identifier) ||
-         base::ContainsKey(temporarily_allowed_plugins_, std::string());
+  return base::Contains(temporarily_allowed_plugins_, identifier) ||
+         base::Contains(temporarily_allowed_plugins_, std::string());
 }
 
 void ContentSettingsObserver::DidBlockContentType(

chrome/renderer/media/chrome_key_systems.cc

@@ -282,22 +282,22 @@ static void AddWidevine(
 #endif
 
   // Session types.
-  bool cdm_supports_temporary_session = base::ContainsValue(
+  bool cdm_supports_temporary_session = base::Contains(
       capability->session_types, media::CdmSessionType::kTemporary);
   if (!cdm_supports_temporary_session) {
     DVLOG(1) << "Temporary session must be supported.";
     return;
   }
 
-  bool cdm_supports_persistent_license = base::ContainsValue(
+  bool cdm_supports_persistent_license = base::Contains(
       capability->session_types, media::CdmSessionType::kPersistentLicense);
   auto persistent_license_support =
       GetPersistentLicenseSupport(cdm_supports_persistent_license);
 
   // TODO(xhwang): Check more conditions as needed.
   auto persistent_usage_record_support =
-      base::ContainsValue(capability->session_types,
-                          media::CdmSessionType::kPersistentUsageRecord)
+      base::Contains(capability->session_types,
+                     media::CdmSessionType::kPersistentUsageRecord)
           ? EmeSessionTypeSupport::SUPPORTED
           : EmeSessionTypeSupport::NOT_SUPPORTED;
 

chrome/renderer/page_load_metrics/page_timing_metrics_sender.cc

@@ -127,7 +127,7 @@ void PageTimingMetricsSender::DidStartResponse(
     const network::ResourceResponseHead& response_head,
     content::ResourceType resource_type,
     content::PreviewsState previews_state) {
-  DCHECK(!base::ContainsKey(page_resource_data_use_, resource_id));
+  DCHECK(!base::Contains(page_resource_data_use_, resource_id));
 
   auto resource_it = page_resource_data_use_.emplace(
       std::piecewise_construct, std::forward_as_tuple(resource_id),

chrome/renderer/pepper/pepper_uma_host.cc

@@ -117,11 +117,11 @@ bool PepperUMAHost::IsHistogramAllowed(const std::string& histogram) {
   }
 
   if (IsPluginWhitelisted() &&
-      base::ContainsKey(allowed_histogram_prefixes_, HashPrefix(histogram))) {
+      base::Contains(allowed_histogram_prefixes_, HashPrefix(histogram))) {
     return true;
   }
 
-  if (base::ContainsKey(allowed_plugin_base_names_, plugin_base_name_.value()))
+  if (base::Contains(allowed_plugin_base_names_, plugin_base_name_.value()))
     return true;
 
   LOG(ERROR) << "Host or histogram name is not allowed to use the UMA API.";

chrome/service/cloud_print/cloud_print_service_helpers.cc

@@ -82,7 +82,7 @@ std::string GetPostDataForPrinterInfo(
 }
 
 bool IsDryRunJob(const std::vector<std::string>& tags) {
-  return base::ContainsValue(tags, kCloudPrintServiceTagDryRunFlag);
+  return base::Contains(tags, kCloudPrintServiceTagDryRunFlag);
 }
 
 std::string GetCloudPrintAuthHeaderFromStore() {

chrome/services/cups_proxy/printer_installer_unittest.cc

@@ -39,15 +39,15 @@ class FakeServiceDelegate
 
   // Service delegate overrides.
   bool IsPrinterInstalled(const Printer& printer) override {
-    if (!base::ContainsKey(installed_printers_, printer.id())) {
+    if (!base::Contains(installed_printers_, printer.id())) {
       return false;
     }
 
     return installed_printers_.at(printer.id());
   }
 
   base::Optional<Printer> GetPrinter(const std::string& id) override {
-    if (!base::ContainsKey(installed_printers_, id)) {
+    if (!base::Contains(installed_printers_, id)) {
       return base::nullopt;
     }
 

chrome/test/base/ui_test_utils.cc

@@ -94,7 +94,7 @@ Browser* WaitForBrowserNotInSet(std::set<Browser*> excluded_browsers) {
     BrowserAddedObserver observer;
     new_browser = observer.WaitForSingleNewBrowser();
     // The new browser should never be in |excluded_browsers|.
-    DCHECK(!base::ContainsKey(excluded_browsers, new_browser));
+    DCHECK(!base::Contains(excluded_browsers, new_browser));
   }
   return new_browser;
 }

chrome/test/chromedriver/capabilities_unittest.cc

@@ -509,8 +509,8 @@ TEST(ParseCapabilities, ExcludeSwitches) {
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, capabilities.exclude_switches.size());
   const std::set<std::string>& switches = capabilities.exclude_switches;
-  ASSERT_TRUE(base::ContainsKey(switches, "switch1"));
-  ASSERT_TRUE(base::ContainsKey(switches, "switch2"));
+  ASSERT_TRUE(base::Contains(switches, "switch1"));
+  ASSERT_TRUE(base::Contains(switches, "switch2"));
 }
 
 TEST(ParseCapabilities, UseRemoteBrowser) {

chrome/test/chromedriver/chrome/device_manager.cc

@@ -218,7 +218,7 @@ Status DeviceManager::AcquireSpecificDevice(const std::string& device_serial,
   if (status.IsError())
     return status;
 
-  if (!base::ContainsValue(devices, device_serial))
+  if (!base::Contains(devices, device_serial))
     return Status(kUnknownError,
         "Device " + device_serial + " is not online");
 
@@ -246,5 +246,5 @@ Device* DeviceManager::LockDevice(const std::string& device_serial) {
 }
 
 bool DeviceManager::IsDeviceLocked(const std::string& device_serial) {
-  return base::ContainsValue(active_devices_, device_serial);
+  return base::Contains(active_devices_, device_serial);
 }

chrome/test/chromedriver/chrome/devtools_http_client.cc

@@ -155,7 +155,7 @@ const DeviceMetrics* DevToolsHttpClient::device_metrics() {
 }
 
 bool DevToolsHttpClient::IsBrowserWindow(const WebViewInfo& view) const {
-  return base::ContainsKey(*window_types_, view.type) ||
+  return base::Contains(*window_types_, view.type) ||
          (view.type == WebViewInfo::kOther &&
           (view.url == "chrome://print/" ||
            view.url == "chrome://media-router/"));

chrome/test/chromedriver/commands.cc

@@ -272,7 +272,7 @@ void ExecuteSessionCommandOnSessionThread(
               status_tmp.code() != kChromeNotReachable) {
             status.AddDetails("failed to check if window was closed: " +
                               status_tmp.message());
-          } else if (!base::ContainsValue(web_view_ids, session->window)) {
+          } else if (!base::Contains(web_view_ids, session->window)) {
             status = Status(kOk);
           }
         }

chrome/test/chromedriver/server/chromedriver_server.cc

@@ -202,7 +202,7 @@ void HandleRequestOnCmdThread(
     const HttpResponseSenderFunc& send_response_func) {
   if (!whitelisted_ips.empty()) {
     const net::IPAddress& peer_address = request.peer.address();
-    if (!base::ContainsValue(whitelisted_ips, peer_address)) {
+    if (!base::Contains(whitelisted_ips, peer_address)) {
       LOG(WARNING) << "unauthorized access from " << request.peer.ToString();
       std::unique_ptr<net::HttpServerResponseInfo> response(
           new net::HttpServerResponseInfo(net::HTTP_UNAUTHORIZED));

chrome/test/media_router/media_router_e2e_browsertest.cc

@@ -109,7 +109,7 @@ void MediaRouterE2EBrowserTest::StopMediaRoute() {
 }
 
 bool MediaRouterE2EBrowserTest::IsSinkDiscovered() const {
-  return base::ContainsKey(observer_->sink_map, receiver_);
+  return base::Contains(observer_->sink_map, receiver_);
 }
 
 bool MediaRouterE2EBrowserTest::IsRouteCreated() const {

chrome/utility/importer/ie_importer_win.cc

@@ -520,7 +520,7 @@ void IEImporter::ImportHistory() {
 
       GURL url(url_string);
       // Skips the URLs that are invalid or have other schemes.
-      if (!url.is_valid() || !base::ContainsValue(kSchemes, url.scheme()))
+      if (!url.is_valid() || !base::Contains(kSchemes, url.scheme()))
         continue;
 
       ImporterURLRow row(url);