Deleted OS_WIN and all Windows specific files from base.

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 27 matching lines @@
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
-#if defined(OS_WIN)
-#include "base/win/windows_version.h"
-#endif
-
 namespace base {
 
 // See https://groups.google.com/a/chromium.org/d/msg/chromium-dev/nkdTP7sstSc/uT3FaE_sgkAJ .
 using ::operator<<;
 
 // The environment variable name for the total number of test shards.
 const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
 // The environment variable name for the test shard index.
 const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
 
@@ skipping 161 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(ASCIIToUTF16(wrapper));
-#elif defined(OS_POSIX)
+#if 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,
                                       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);
-
-  win::ScopedHandle job_handle;
-  if (flags & TestLauncher::USE_JOB_OBJECTS) {
-    job_handle.Set(CreateJobObject(NULL, NULL));
-    if (!job_handle.IsValid()) {
-      LOG(ERROR) << "Could not create JobObject.";
-      return -1;
-    }
-
-    DWORD job_flags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
-
-    // Allow break-away from job since sandbox and few other places rely on it
-    // on Windows versions prior to Windows 8 (which supports nested jobs).
-    if (win::GetVersion() < win::VERSION_WIN8 &&
-        flags & TestLauncher::ALLOW_BREAKAWAY_FROM_JOB) {
-      job_flags |= JOB_OBJECT_LIMIT_BREAKAWAY_OK;
-    }
-
-    if (!SetJobObjectLimitFlags(job_handle.Get(), job_flags)) {
-      LOG(ERROR) << "Could not SetJobObjectLimitFlags.";
-      return -1;
-    }
-
-    new_options.job_handle = job_handle.Get();
-  }
-#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
 
   Process process;
 
@@ skipping 59 matching lines @@
     bool redirect_stdio,
     SingleThreadTaskRunner* task_runner,
     const TestLauncher::LaunchChildGTestProcessCallback& callback) {
   TimeTicks start_time = TimeTicks::Now();
 
   // Redirect child process output to a 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)
+#if defined(OS_POSIX)
   options.new_process_group = true;
 #if defined(OS_LINUX)
   options.kill_on_parent_death = true;
 #endif  // defined(OS_LINUX)
 
   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)
+#if defined(OS_POSIX)
     output_file_fd.reset();
 #endif
   }
 
   std::string output_file_contents;
   CHECK(ReadFileToString(output_file, &output_file_contents));
 
   if (!DeleteFile(output_file, false)) {
     // This needs to be non-fatal at least for Windows.
     LOG(WARNING) << "Failed to delete " << output_file.AsUTF8Unsafe();
@@ skipping 444 matching lines @@
 #endif
 
 #if defined(OS_POSIX)
   results_tracker_.AddGlobalTag("OS_POSIX");
 #endif
 
 #if defined(OS_SOLARIS)
   results_tracker_.AddGlobalTag("OS_SOLARIS");
 #endif
 
-#if defined(OS_WIN)
-  results_tracker_.AddGlobalTag("OS_WIN");
-#endif
-
   // CPU-related tags.
 #if defined(ARCH_CPU_32_BITS)
   results_tracker_.AddGlobalTag("CPU_32_BITS");
 #endif
 
 #if defined(ARCH_CPU_64_BITS)
   results_tracker_.AddGlobalTag("CPU_64_BITS");
 #endif
 
   return true;
@@ skipping 132 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   AutoLock lock(g_live_processes_lock.Get());
 
   fprintf(stdout, "Still waiting for the following processes to finish:\n");
 
   for (std::map<ProcessHandle, CommandLine>::iterator i =
            g_live_processes.Get().begin();
        i != g_live_processes.Get().end();
        ++i) {
-#if defined(OS_WIN)
-    fwprintf(stdout, L"\t%s\n", i->second.GetCommandLineString().c_str());
-#else
     fprintf(stdout, "\t%s\n", i->second.GetCommandLineString().c_str());
-#endif
   }
 
   fflush(stdout);
 
   // Arm the timer again - otherwise it would fire only once.
   watchdog_timer_.Reset();
 }
 
 std::string GetTestOutputSnippet(const TestResult& result,
                                  const std::string& full_output) {
@@ skipping 20 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