Update from https://crrev.com/307330

base/test/launcher/test_launcher.cc

 // Copyright 2013 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 "base/test/launcher/test_launcher.h"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #endif
 
@@ skipping 210 matching lines @@
   for (CommandLine::SwitchMap::const_iterator iter = switches.begin();
        iter != switches.end(); ++iter) {
     new_command_line.AppendSwitchNative((*iter).first, (*iter).second);
   }
 
   // Prepend wrapper after last CommandLine quasi-copy operation. CommandLine
   // does not really support removing switches well, and trying to do that
   // on a CommandLine with a wrapper is known to break.
   // TODO(phajdan.jr): Give it a try to support CommandLine removing switches.
 #if defined(OS_WIN)
-  new_command_line.PrependWrapper(ASCIIToWide(wrapper));
+  new_command_line.PrependWrapper(ASCIIToUTF16(wrapper));
 #elif defined(OS_POSIX)
   new_command_line.PrependWrapper(wrapper);
 #endif
 
   return new_command_line;
 }
 
 // Launches a child process using |command_line|. If the child process is still
 // running after |timeout|, it is terminated and |*was_timeout| is set to true.
 // Returns exit code of the process.
 int LaunchChildTestProcessWithOptions(const CommandLine& command_line,
                                       const LaunchOptions& options,
                                       int flags,
-                                      base::TimeDelta timeout,
+                                      TimeDelta timeout,
                                       bool* was_timeout) {
 #if defined(OS_POSIX)
   // Make sure an option we rely on is present - see LaunchChildGTestProcess.
   DCHECK(options.new_process_group);
 #endif
 
   LaunchOptions new_options(options);
 
 #if defined(OS_WIN)
   DCHECK(!new_options.job_handle);
@@ skipping 24 matching lines @@
   }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_LINUX)
   // To prevent accidental privilege sharing to an untrusted child, processes
   // are started with PR_SET_NO_NEW_PRIVS. Do not set that here, since this
   // new child will be privileged and trusted.
   new_options.allow_new_privs = true;
 #endif
 
-  base::ProcessHandle process_handle;
+  ProcessHandle process_handle;
 
   {
     // Note how we grab the lock before the process possibly gets created.
     // This ensures that when the lock is held, ALL the processes are registered
     // in the set.
     AutoLock lock(g_live_processes_lock.Get());
 
-    if (!base::LaunchProcess(command_line, new_options, &process_handle))
+    if (!LaunchProcess(command_line, new_options, &process_handle))
       return -1;
 
     g_live_processes.Get().insert(std::make_pair(process_handle, command_line));
   }
 
   int exit_code = 0;
-  if (!base::WaitForExitCodeWithTimeout(process_handle,
-                                        &exit_code,
-                                        timeout)) {
+  if (!WaitForExitCodeWithTimeout(process_handle, &exit_code, timeout)) {
     *was_timeout = true;
     exit_code = -1;  // Set a non-zero exit code to signal a failure.
 
     // Ensure that the process terminates.
-    base::KillProcess(process_handle, -1, true);
+    KillProcess(process_handle, -1, true);
   }
 
   {
     // Note how we grab the log before issuing a possibly broad process kill.
     // Other code parts that grab the log kill processes, so avoid trying
     // to do that twice and trigger all kinds of log messages.
     AutoLock lock(g_live_processes_lock.Get());
 
 #if defined(OS_POSIX)
     if (exit_code != 0) {
       // On POSIX, in case the test does not exit cleanly, either due to a crash
       // or due to it timing out, we need to clean up any child processes that
       // it might have created. On Windows, child processes are automatically
       // cleaned up using JobObjects.
-      base::KillProcessGroup(process_handle);
+      KillProcessGroup(process_handle);
     }
 #endif
 
     g_live_processes.Get().erase(process_handle);
   }
 
-  base::CloseProcessHandle(process_handle);
+  CloseProcessHandle(process_handle);
 
   return exit_code;
 }
 
 void RunCallback(
     const TestLauncher::LaunchChildGTestProcessCallback& callback,
     int exit_code,
     const TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   callback.Run(exit_code, elapsed_time, was_timeout, output);
 }
 
 void DoLaunchChildTestProcess(
     const CommandLine& command_line,
-    base::TimeDelta timeout,
+    TimeDelta timeout,
     int flags,
     bool redirect_stdio,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const TestLauncher::LaunchChildGTestProcessCallback& callback) {
   TimeTicks start_time = TimeTicks::Now();
 
   // Redirect child process output to a file.
-  base::FilePath output_file;
-  CHECK(base::CreateTemporaryFile(&output_file));
+  FilePath output_file;
+  CHECK(CreateTemporaryFile(&output_file));
 
   LaunchOptions options;
 #if defined(OS_WIN)
   win::ScopedHandle handle;
 
   if (redirect_stdio) {
     // Make the file handle inheritable by the child.
     SECURITY_ATTRIBUTES sa_attr;
     sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
     sa_attr.lpSecurityDescriptor = NULL;
     sa_attr.bInheritHandle = TRUE;
 
     handle.Set(CreateFile(output_file.value().c_str(),
                           GENERIC_WRITE,
                           FILE_SHARE_READ | FILE_SHARE_DELETE,
                           &sa_attr,
                           OPEN_EXISTING,
                           FILE_ATTRIBUTE_TEMPORARY,
                           NULL));
     CHECK(handle.IsValid());
     options.inherit_handles = true;
     options.stdin_handle = INVALID_HANDLE_VALUE;
     options.stdout_handle = handle.Get();
     options.stderr_handle = handle.Get();
   }
 #elif defined(OS_POSIX)
   options.new_process_group = true;
 
-  base::FileHandleMappingVector fds_mapping;
-  base::ScopedFD output_file_fd;
+  FileHandleMappingVector fds_mapping;
+  ScopedFD output_file_fd;
 
   if (redirect_stdio) {
     output_file_fd.reset(open(output_file.value().c_str(), O_RDWR));
     CHECK(output_file_fd.is_valid());
 
     fds_mapping.push_back(std::make_pair(output_file_fd.get(), STDOUT_FILENO));
     fds_mapping.push_back(std::make_pair(output_file_fd.get(), STDERR_FILENO));
     options.fds_to_remap = &fds_mapping;
   }
 #endif
 
   bool was_timeout = false;
   int exit_code = LaunchChildTestProcessWithOptions(
       command_line, options, flags, timeout, &was_timeout);
 
   if (redirect_stdio) {
 #if defined(OS_WIN)
     FlushFileBuffers(handle.Get());
     handle.Close();
 #elif defined(OS_POSIX)
     output_file_fd.reset();
 #endif
   }
 
   std::string output_file_contents;
-  CHECK(base::ReadFileToString(output_file, &output_file_contents));
+  CHECK(ReadFileToString(output_file, &output_file_contents));
 
-  if (!base::DeleteFile(output_file, false)) {
+  if (!DeleteFile(output_file, false)) {
     // This needs to be non-fatal at least for Windows.
     LOG(WARNING) << "Failed to delete " << output_file.AsUTF8Unsafe();
   }
 
   // Run target callback on the thread it was originating from, not on
   // a worker pool thread.
   message_loop_proxy->PostTask(
       FROM_HERE,
       Bind(&RunCallback,
            callback,
@@ skipping 84 matching lines @@
     results_tracker_.PrintSummaryOfAllIterations();
 
   MaybeSaveSummaryAsJSON();
 
   return run_result_;
 }
 
 void TestLauncher::LaunchChildGTestProcess(
     const CommandLine& command_line,
     const std::string& wrapper,
-    base::TimeDelta timeout,
+    TimeDelta timeout,
     int flags,
     const LaunchChildGTestProcessCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Record the exact command line used to launch the child.
   CommandLine new_command_line(
       PrepareCommandLineForGTest(command_line, wrapper));
 
   // When running in parallel mode we need to redirect stdio to avoid mixed-up
   // output. We also always redirect on the bots to get the test output into
@@ skipping 405 matching lines @@
     bool excluded = false;
     for (size_t k = 0; k < negative_test_filter_.size(); ++k) {
       if (MatchPattern(test_name, negative_test_filter_[k])) {
         excluded = true;
         break;
       }
     }
     if (excluded)
       continue;
 
-    if (base::Hash(test_name) % total_shards_ !=
-        static_cast<uint32>(shard_index_)) {
+    if (Hash(test_name) % total_shards_ != static_cast<uint32>(shard_index_))
       continue;
-    }
 
     test_names.push_back(test_name);
   }
 
   test_started_count_ = launcher_delegate_->RunTests(this, test_names);
 
   if (test_started_count_ == 0) {
     fprintf(stdout, "0 tests run\n");
     fflush(stdout);
 
@@ skipping 122 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base