Deleted OS_WIN and all Windows specific files from base.

base/process/process_util_unittest.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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 32 matching lines @@
 #include <errno.h>
 #include <fcntl.h>
 #include <sched.h>
 #include <signal.h>
 #include <sys/resource.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #endif
-#if defined(OS_WIN)
-#include <windows.h>
-#include "base/win/windows_version.h"
-#endif
 #if defined(OS_MACOSX)
 #include <mach/vm_param.h>
 #include <malloc/malloc.h>
 #include "base/mac/mac_util.h"
 #endif
 
 using base::FilePath;
 
 namespace {
 
 #if defined(OS_ANDROID)
 const char kShellPath[] = "/system/bin/sh";
 const char kPosixShell[] = "sh";
 #else
 const char kShellPath[] = "/bin/sh";
 const char kPosixShell[] = "bash";
 #endif
 
 const char kSignalFileSlow[] = "SlowChildProcess.die";
 const char kSignalFileKill[] = "KilledChildProcess.die";
 
 #if defined(OS_POSIX)
 const char kSignalFileTerm[] = "TerminatedChildProcess.die";
 #endif
 
-#if defined(OS_WIN)
-const int kExpectedStillRunningExitCode = 0x102;
-const int kExpectedKilledExitCode = 1;
-#else
 const int kExpectedStillRunningExitCode = 0;
-#endif
 
 // Sleeps until file filename is created.
 void WaitToDie(const char* filename) {
   FILE* fp;
   do {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
     fp = fopen(filename, "r");
   } while (!fp);
   fclose(fp);
 }
@@ skipping 95 matching lines @@
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
       WaitForChildTermination(process.Handle(), &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_NORMAL_TERMINATION, status);
   EXPECT_EQ(0, exit_code);
   remove(signal_file.c_str());
 }
 
-#if defined(OS_WIN)
-// TODO(cpu): figure out how to test this in other platforms.
-TEST_F(ProcessUtilTest, GetProcId) {
-  base::ProcessId id1 = base::GetProcId(GetCurrentProcess());
-  EXPECT_NE(0ul, id1);
-  base::Process process = SpawnChild("SimpleChildProcess");
-  ASSERT_TRUE(process.IsValid());
-  base::ProcessId id2 = process.Pid();
-  EXPECT_NE(0ul, id2);
-  EXPECT_NE(id1, id2);
-}
-#endif
-
 #if !defined(OS_MACOSX)
 // This test is disabled on Mac, since it's flaky due to ReportCrash
 // taking a variable amount of time to parse and load the debug and
 // symbol data for this unit test's executable before firing the
 // signal handler.
 //
 // TODO(gspencer): turn this test process into a very small program
 // with no symbols (instead of using the multiprocess testing
 // framework) to reduce the ReportCrash overhead.
 const char kSignalFileCrash[] = "CrashingChildProcess.die";
@@ skipping 29 matching lines @@
   EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
             base::GetTerminationStatus(process.Handle(), &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
       WaitForChildTermination(process.Handle(), &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_CRASHED, status);
 
-#if defined(OS_WIN)
-  EXPECT_EQ(0xc0000005, exit_code);
-#elif defined(OS_POSIX)
+#if defined(OS_POSIX)
   int signaled = WIFSIGNALED(exit_code);
   EXPECT_NE(0, signaled);
   int signal = WTERMSIG(exit_code);
   EXPECT_EQ(SIGSEGV, signal);
 #endif
 
   // Reset signal handlers back to "normal".
   base::debug::EnableInProcessStackDumping();
   remove(signal_file.c_str());
 }
 #endif  // !defined(OS_MACOSX)
 
 MULTIPROCESS_TEST_MAIN(KilledChildProcess) {
   WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileKill).c_str());
-#if defined(OS_WIN)
-  // Kill ourselves.
-  HANDLE handle = ::OpenProcess(PROCESS_ALL_ACCESS, 0, ::GetCurrentProcessId());
-  ::TerminateProcess(handle, kExpectedKilledExitCode);
-#elif defined(OS_POSIX)
+#if defined(OS_POSIX)
   // Send a SIGKILL to this process, just like the OOM killer would.
   ::kill(getpid(), SIGKILL);
 #endif
   return 1;
 }
 
 #if defined(OS_POSIX)
 MULTIPROCESS_TEST_MAIN(TerminatedChildProcess) {
   WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileTerm).c_str());
   // Send a SIGTERM to this process.
@@ skipping 17 matching lines @@
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
       WaitForChildTermination(process.Handle(), &exit_code);
 #if defined(OS_CHROMEOS)
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM, status);
 #else
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
 #endif
 
-#if defined(OS_WIN)
-  EXPECT_EQ(kExpectedKilledExitCode, exit_code);
-#elif defined(OS_POSIX)
+#if defined(OS_POSIX)
   int signaled = WIFSIGNALED(exit_code);
   EXPECT_NE(0, signaled);
   int signal = WTERMSIG(exit_code);
   EXPECT_EQ(SIGKILL, signal);
 #endif
   remove(signal_file.c_str());
 }
 
 #if defined(OS_POSIX)
 TEST_F(ProcessUtilTest, GetTerminationStatusSigTerm) {
@@ skipping 15 matching lines @@
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
 
   int signaled = WIFSIGNALED(exit_code);
   EXPECT_NE(0, signaled);
   int signal = WTERMSIG(exit_code);
   EXPECT_EQ(SIGTERM, signal);
   remove(signal_file.c_str());
 }
 #endif
 
-#if defined(OS_WIN)
-// TODO(estade): if possible, port this test.
-TEST_F(ProcessUtilTest, GetAppOutput) {
-  // Let's create a decently long message.
-  std::string message;
-  for (int i = 0; i < 1025; i++) {  // 1025 so it does not end on a kilo-byte
-                                    // boundary.
-    message += "Hello!";
-  }
-  // cmd.exe's echo always adds a \r\n to its output.
-  std::string expected(message);
-  expected += "\r\n";
-
-  FilePath cmd(L"cmd.exe");
-  base::CommandLine cmd_line(cmd);
-  cmd_line.AppendArg("/c");
-  cmd_line.AppendArg("echo " + message + "");
-  std::string output;
-  ASSERT_TRUE(base::GetAppOutput(cmd_line, &output));
-  EXPECT_EQ(expected, output);
-
-  // Let's make sure stderr is ignored.
-  base::CommandLine other_cmd_line(cmd);
-  other_cmd_line.AppendArg("/c");
-  // http://msdn.microsoft.com/library/cc772622.aspx
-  cmd_line.AppendArg("echo " + message + " >&2");
-  output.clear();
-  ASSERT_TRUE(base::GetAppOutput(other_cmd_line, &output));
-  EXPECT_EQ("", output);
-}
-
-// TODO(estade): if possible, port this test.
-TEST_F(ProcessUtilTest, LaunchAsUser) {
-  base::UserTokenHandle token;
-  ASSERT_TRUE(OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &token));
-  base::LaunchOptions options;
-  options.as_user = token;
-  EXPECT_TRUE(base::LaunchProcess(MakeCmdLine("SimpleChildProcess"),
-                                  options).IsValid());
-}
-
-static const char kEventToTriggerHandleSwitch[] = "event-to-trigger-handle";
-
-MULTIPROCESS_TEST_MAIN(TriggerEventChildProcess) {
-  std::string handle_value_string =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          kEventToTriggerHandleSwitch);
-  CHECK(!handle_value_string.empty());
-
-  uint64 handle_value_uint64;
-  CHECK(base::StringToUint64(handle_value_string, &handle_value_uint64));
-  // Give ownership of the handle to |event|.
-  base::WaitableEvent event(base::win::ScopedHandle(
-      reinterpret_cast<HANDLE>(handle_value_uint64)));
-
-  event.Signal();
-
-  return 0;
-}
-
-TEST_F(ProcessUtilTest, InheritSpecifiedHandles) {
-  // Manually create the event, so that it can be inheritable.
-  SECURITY_ATTRIBUTES security_attributes = {};
-  security_attributes.nLength = static_cast<DWORD>(sizeof(security_attributes));
-  security_attributes.lpSecurityDescriptor = NULL;
-  security_attributes.bInheritHandle = true;
-
-  // Takes ownership of the event handle.
-  base::WaitableEvent event(base::win::ScopedHandle(
-      CreateEvent(&security_attributes, true, false, NULL)));
-  base::HandlesToInheritVector handles_to_inherit;
-  handles_to_inherit.push_back(event.handle());
-  base::LaunchOptions options;
-  options.handles_to_inherit = &handles_to_inherit;
-
-  base::CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess");
-  cmd_line.AppendSwitchASCII(kEventToTriggerHandleSwitch,
-      base::Uint64ToString(reinterpret_cast<uint64>(event.handle())));
-
-  // This functionality actually requires Vista or later. Make sure that it
-  // fails properly on XP.
-  if (base::win::GetVersion() < base::win::VERSION_VISTA) {
-    EXPECT_FALSE(base::LaunchProcess(cmd_line, options).IsValid());
-    return;
-  }
-
-  // Launch the process and wait for it to trigger the event.
-  ASSERT_TRUE(base::LaunchProcess(cmd_line, options).IsValid());
-  EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
-}
-#endif  // defined(OS_WIN)
-
 #if defined(OS_POSIX)
 
 namespace {
 
 // Returns the maximum number of files that a process can have open.
 // Returns 0 on error.
 int GetMaxFilesOpenInProcess() {
   struct rlimit rlim;
   if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) {
     return 0;
@@ skipping 639 matching lines @@
   options.current_directory = base::FilePath("/dev/null");
 
   base::Process process(SpawnChildWithOptions("SimpleChildProcess", options));
   ASSERT_TRUE(process.IsValid());
 
   int exit_code = kSuccess;
   EXPECT_TRUE(process.WaitForExit(&exit_code));
   EXPECT_NE(kSuccess, exit_code);
 }
 #endif