components/browser_watcher/exit_code_watcher_win_unittest.cc

   1 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/browser_watcher/exit_code_watcher_win.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/process/kill.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/synchronization/waitable_event.h"
  12 #include "base/test/multiprocess_test.h"
  13 #include "base/test/test_reg_util_win.h"
  14 #include "base/threading/platform_thread.h"
  15 #include "base/time/time.h"
  16 #include "base/win/scoped_handle.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "testing/multiprocess_func_list.h"
  19
  20 namespace browser_watcher {
  21
  22 namespace {
  23
  24 const wchar_t kRegistryPath[] = L"Software\\BrowserWatcherTest";
  25
  26 MULTIPROCESS_TEST_MAIN(Sleeper) {
  27   // Sleep forever - the test harness will kill this process to give it an
  28   // exit code.
  29   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(INFINITE));
  30   return 1;
  31 }
  32
  33 class ScopedSleeperProcess {
  34  public:
  35    ScopedSleeperProcess() :
  36       process_(base::kNullProcessHandle),
  37       process_id_(base::kNullProcessId),
  38       is_killed_(false) {
  39   }
  40
  41   ~ScopedSleeperProcess() {
  42     if (process_ != base::kNullProcessHandle) {
  43       base::KillProcess(process_, -1, true);
  44       base::CloseProcessHandle(process_);
  45     }
  46   }
  47
  48   void Launch() {
  49     ASSERT_EQ(base::kNullProcessHandle, process_);
  50
  51     base::CommandLine cmd_line(base::GetMultiProcessTestChildBaseCommandLine());
  52     base::LaunchOptions options;
  53     options.start_hidden = true;
  54     process_ = base::SpawnMultiProcessTestChild("Sleeper", cmd_line, options);
  55     process_id_ = base::GetProcId(process_);
  56     ASSERT_NE(base::kNullProcessHandle, process_);
  57   }
  58
  59   void Kill(int exit_code, bool wait) {
  60     ASSERT_NE(process_, base::kNullProcessHandle);
  61     ASSERT_FALSE(is_killed_);
  62     ASSERT_TRUE(base::KillProcess(process_, exit_code, wait));
  63     is_killed_ = true;
  64   }
  65
  66   void GetNewHandle(base::ProcessHandle* output) {
  67     ASSERT_NE(process_, base::kNullProcessHandle);
  68
  69     ASSERT_TRUE(DuplicateHandle(::GetCurrentProcess(),
  70                                 process_,
  71                                 ::GetCurrentProcess(),
  72                                 output,
  73                                 0,
  74                                 FALSE,
  75                                 DUPLICATE_SAME_ACCESS));
  76   }
  77
  78   base::ProcessHandle process() const { return process_; }
  79   base::ProcessId process_id() const { return process_id_; }
  80
  81  private:
  82   base::ProcessHandle process_;
  83   base::ProcessId process_id_;
  84   bool is_killed_;
  85 };
  86
  87 class BrowserWatcherTest : public testing::Test {
  88  public:
  89   typedef testing::Test Super;
  90
  91   static const int kExitCode = 0xCAFEBABE;
  92
  93   BrowserWatcherTest() :
  94       cmd_line_(base::CommandLine::NO_PROGRAM),
  95       process_(base::kNullProcessHandle) {
  96   }
  97
  98   virtual void SetUp() override {
  99     Super::SetUp();
 100
 101     override_manager_.OverrideRegistry(HKEY_CURRENT_USER);
 102   }
 103
 104   virtual void TearDown() override {
 105     if (process_ != base::kNullProcessHandle) {
 106       base::CloseProcessHandle(process_);
 107       process_ = base::kNullProcessHandle;
 108     }
 109
 110     Super::TearDown();
 111   }
 112
 113   void OpenSelfWithAccess(uint32 access) {
 114     ASSERT_EQ(base::kNullProcessHandle, process_);
 115     ASSERT_TRUE(base::OpenProcessHandleWithAccess(
 116         base::GetCurrentProcId(), access, &process_));
 117   }
 118
 119   void VerifyWroteExitCode(base::ProcessId proc_id, int exit_code) {
 120     base::win::RegistryValueIterator it(
 121           HKEY_CURRENT_USER, kRegistryPath);
 122
 123     ASSERT_EQ(1, it.ValueCount());
 124     base::win::RegKey key(HKEY_CURRENT_USER,
 125                           kRegistryPath,
 126                           KEY_QUERY_VALUE);
 127
 128     // The value name should encode the process id at the start.
 129     EXPECT_TRUE(StartsWith(it.Name(),
 130                            base::StringPrintf(L"%d-", proc_id),
 131                            false));
 132     DWORD value = 0;
 133     ASSERT_EQ(ERROR_SUCCESS, key.ReadValueDW(it.Name(), &value));
 134     ASSERT_EQ(exit_code, value);
 135   }
 136
 137  protected:
 138   base::CommandLine cmd_line_;
 139   base::ProcessHandle process_;
 140   registry_util::RegistryOverrideManager override_manager_;
 141 };
 142
 143 }  // namespace
 144
 145 TEST_F(BrowserWatcherTest, ExitCodeWatcherInvalidCmdLineFailsInit) {
 146   ExitCodeWatcher watcher(kRegistryPath);
 147
 148   // An empty command line should fail.
 149   EXPECT_FALSE(watcher.ParseArguments(cmd_line_));
 150
 151   // A non-numeric parent-handle argument should fail.
 152   cmd_line_.AppendSwitchASCII(ExitCodeWatcher::kParenthHandleSwitch, "asdf");
 153   EXPECT_FALSE(watcher.ParseArguments(cmd_line_));
 154 }
 155
 156 TEST_F(BrowserWatcherTest, ExitCodeWatcherInvalidHandleFailsInit) {
 157   ExitCodeWatcher watcher(kRegistryPath);
 158
 159   // A waitable event has a non process-handle.
 160   base::WaitableEvent event(false, false);
 161
 162   // A non-process handle should fail.
 163   cmd_line_.AppendSwitchASCII(ExitCodeWatcher::kParenthHandleSwitch,
 164                               base::StringPrintf("%d", event.handle()));
 165   EXPECT_FALSE(watcher.ParseArguments(cmd_line_));
 166 }
 167
 168 TEST_F(BrowserWatcherTest, ExitCodeWatcherNoAccessHandleFailsInit) {
 169   ExitCodeWatcher watcher(kRegistryPath);
 170
 171   // Open a SYNCHRONIZE-only handle to this process.
 172   ASSERT_NO_FATAL_FAILURE(OpenSelfWithAccess(SYNCHRONIZE));
 173
 174   // A process handle with insufficient access should fail.
 175   cmd_line_.AppendSwitchASCII(ExitCodeWatcher::kParenthHandleSwitch,
 176                               base::StringPrintf("%d", process_));
 177   EXPECT_FALSE(watcher.ParseArguments(cmd_line_));
 178 }
 179
 180 TEST_F(BrowserWatcherTest, ExitCodeWatcherSucceedsInit) {
 181   ExitCodeWatcher watcher(kRegistryPath);
 182
 183   // Open a handle to this process with sufficient access for the watcher.
 184   ASSERT_NO_FATAL_FAILURE(
 185       OpenSelfWithAccess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION));
 186
 187   // A process handle with sufficient access should succeed init.
 188   cmd_line_.AppendSwitchASCII(ExitCodeWatcher::kParenthHandleSwitch,
 189                               base::StringPrintf("%d", process_));
 190   EXPECT_TRUE(watcher.ParseArguments(cmd_line_));
 191
 192   ASSERT_EQ(process_, watcher.process());
 193
 194   // The watcher takes ownership of the handle, make sure it's not
 195   // double-closed.
 196   process_ = base::kNullProcessHandle;
 197 }
 198
 199 TEST_F(BrowserWatcherTest, ExitCodeWatcherOnExitedProcess) {
 200   ScopedSleeperProcess sleeper;
 201   ASSERT_NO_FATAL_FAILURE(sleeper.Launch());
 202
 203   // Create a new handle to the sleeper process. This handle will leak in
 204   // the case this test fails. A ScopedHandle cannot be used here, as the
 205   // ownership would momentarily be held by two of them, which is disallowed.
 206   base::ProcessHandle sleeper_handle;
 207   sleeper.GetNewHandle(&sleeper_handle);
 208
 209   ExitCodeWatcher watcher(kRegistryPath);
 210
 211   cmd_line_.AppendSwitchASCII(ExitCodeWatcher::kParenthHandleSwitch,
 212                               base::StringPrintf("%d", sleeper_handle));
 213   EXPECT_TRUE(watcher.ParseArguments(cmd_line_));
 214   ASSERT_EQ(sleeper_handle, watcher.process());
 215
 216   // Verify that the watcher wrote a sentinel for the process.
 217   VerifyWroteExitCode(sleeper.process_id(), STILL_ACTIVE);
 218
 219   // Kill the sleeper, and make sure it's exited before we continue.
 220   ASSERT_NO_FATAL_FAILURE(sleeper.Kill(kExitCode, true));
 221
 222   watcher.WaitForExit();
 223
 224   VerifyWroteExitCode(sleeper.process_id(), kExitCode);
 225 }
 226
 227 }  // namespace browser_watcher