content: Use stl utilities from the base namespace

content/public/test/test_launcher.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 "content/public/test/test_launcher.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 218 matching lines @@
   user_data_dir_map_.clear();
 
   // Number of additional tests to run because of dependencies.
   size_t additional_tests_to_run_count = 0;
 
   // Compute dependencies of tests to be run.
   for (size_t i = 0; i < test_names.size(); i++) {
     std::string full_name(test_names[i]);
     std::string pre_test_name(GetPreTestName(full_name));
 
-    while (ContainsKey(all_test_names_, pre_test_name)) {
+    while (base::ContainsKey(all_test_names_, pre_test_name)) {
       additional_tests_to_run_count++;
 
-      DCHECK(!ContainsKey(dependent_test_map_, pre_test_name));
+      DCHECK(!base::ContainsKey(dependent_test_map_, pre_test_name));
       dependent_test_map_[pre_test_name] = full_name;
 
-      DCHECK(!ContainsKey(reverse_dependent_test_map_, full_name));
+      DCHECK(!base::ContainsKey(reverse_dependent_test_map_, full_name));
       reverse_dependent_test_map_[full_name] = pre_test_name;
 
       full_name = pre_test_name;
       pre_test_name = GetPreTestName(pre_test_name);
     }
   }
 
   for (size_t i = 0; i < test_names.size(); i++) {
     std::string full_name(test_names[i]);
 
     // Make sure no PRE_ tests were requested explicitly.
     DCHECK_EQ(full_name, RemoveAnyPrePrefixes(full_name));
 
-    if (!ContainsKey(user_data_dir_map_, full_name)) {
+    if (!base::ContainsKey(user_data_dir_map_, full_name)) {
       base::FilePath temp_dir;
       CHECK(base::CreateTemporaryDirInDir(temp_dir_.path(),
                                           FILE_PATH_LITERAL("d"), &temp_dir));
       user_data_dir_map_[full_name] = temp_dir;
     }
 
     // If the test has any dependencies, get to the root and start with that.
-    while (ContainsKey(reverse_dependent_test_map_, full_name))
+    while (base::ContainsKey(reverse_dependent_test_map_, full_name))
       full_name = GetPreTestName(full_name);
 
     std::vector<std::string> test_list;
     test_list.push_back(full_name);
     DoRunTests(test_launcher, test_list);
   }
 
   return test_names.size() + additional_tests_to_run_count;
 }
 
 size_t WrapperTestLauncherDelegate::RetryTests(
     base::TestLauncher* test_launcher,
     const std::vector<std::string>& test_names) {
   // List of tests we can kick off right now, depending on no other tests.
   std::vector<std::string> tests_to_run_now;
 
   // We retry at least the tests requested to retry.
   std::set<std::string> test_names_set(test_names.begin(), test_names.end());
 
   // In the face of PRE_ tests, we need to retry the entire chain of tests,
   // from the very first one.
   for (size_t i = 0; i < test_names.size(); i++) {
     std::string test_name(test_names[i]);
-    while (ContainsKey(reverse_dependent_test_map_, test_name)) {
+    while (base::ContainsKey(reverse_dependent_test_map_, test_name)) {
       test_name = reverse_dependent_test_map_[test_name];
       test_names_set.insert(test_name);
     }
   }
 
   // Discard user data directories from any previous runs. Start with
   // fresh state.
   for (UserDataDirMap::const_iterator i = user_data_dir_map_.begin();
        i != user_data_dir_map_.end();
        ++i) {
     // Delete temporary directories now to avoid using too much space in /tmp.
     if (!base::DeleteFile(i->second, true)) {
       LOG(WARNING) << "Failed to delete " << i->second.value();
     }
   }
   user_data_dir_map_.clear();
 
   for (std::set<std::string>::const_iterator i = test_names_set.begin();
        i != test_names_set.end();
        ++i) {
     std::string full_name(*i);
 
     // Make sure PRE_ tests and tests that depend on them share the same
     // data directory - based it on the test name without prefixes.
     std::string test_name_no_pre(RemoveAnyPrePrefixes(full_name));
-    if (!ContainsKey(user_data_dir_map_, test_name_no_pre)) {
+    if (!base::ContainsKey(user_data_dir_map_, test_name_no_pre)) {
       base::FilePath temp_dir;
       CHECK(base::CreateTemporaryDirInDir(temp_dir_.path(),
                                           FILE_PATH_LITERAL("d"), &temp_dir));
       user_data_dir_map_[test_name_no_pre] = temp_dir;
     }
 
     size_t dot_pos = full_name.find('.');
     CHECK_NE(dot_pos, std::string::npos);
     std::string test_case_name = full_name.substr(0, dot_pos);
     std::string test_name = full_name.substr(dot_pos + 1);
     std::string pre_test_name(
         test_case_name + "." + kPreTestPrefix + test_name);
-    if (!ContainsKey(test_names_set, pre_test_name))
+    if (!base::ContainsKey(test_names_set, pre_test_name))
       tests_to_run_now.push_back(full_name);
   }
 
   DoRunTests(test_launcher, tests_to_run_now);
 
   return test_names_set.size();
 }
 
 void WrapperTestLauncherDelegate::DoRunTests(
     base::TestLauncher* test_launcher,
@@ skipping 55 matching lines @@
     std::vector<std::string> test_list;
     test_list.push_back(test_name);
     DoRunTests(test_launcher, test_list);
   } else {
     // Otherwise skip the test.
     base::TestResult test_result;
     test_result.full_name = test_name;
     test_result.status = base::TestResult::TEST_SKIPPED;
     test_launcher->OnTestFinished(test_result);
 
-    if (ContainsKey(dependent_test_map_, test_name)) {
+    if (base::ContainsKey(dependent_test_map_, test_name)) {
       RunDependentTest(test_launcher,
                        dependent_test_map_[test_name],
                        test_result);
     }
   }
 }
 
 void WrapperTestLauncherDelegate::GTestCallback(
     base::TestLauncher* test_launcher,
     const std::vector<std::string>& test_names,
@@ skipping 11 matching lines @@
     result.status = base::TestResult::TEST_SUCCESS;
   else if (was_timeout)
     result.status = base::TestResult::TEST_TIMEOUT;
   else
     result.status = base::TestResult::TEST_FAILURE;
 
   result.elapsed_time = elapsed_time;
 
   result.output_snippet = GetTestOutputSnippet(result, output);
 
-  if (ContainsKey(dependent_test_map_, test_name)) {
+  if (base::ContainsKey(dependent_test_map_, test_name)) {
     RunDependentTest(test_launcher, dependent_test_map_[test_name], result);
   } else {
     // No other tests depend on this, we can delete the temporary directory now.
     // Do so to avoid too many temporary files using lots of disk space.
     std::string test_name_no_pre(RemoveAnyPrePrefixes(test_name));
-    if (ContainsKey(user_data_dir_map_, test_name_no_pre)) {
+    if (base::ContainsKey(user_data_dir_map_, test_name_no_pre)) {
       if (!base::DeleteFile(user_data_dir_map_[test_name_no_pre], true)) {
         LOG(WARNING) << "Failed to delete "
                      << user_data_dir_map_[test_name_no_pre].value();
       }
       user_data_dir_map_.erase(test_name_no_pre);
     }
   }
 
   test_launcher->OnTestFinished(result);
 
@@ skipping 95 matching lines @@
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 ContentMainParams* GetContentMainParams() {
   return g_params;
 }
 
 }  // namespace content