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/process.h"
   9 #include "base/strings/string16.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "base/synchronization/waitable_event.h"
  13 #include "base/test/multiprocess_test.h"
  14 #include "base/test/test_reg_util_win.h"
  15 #include "base/threading/platform_thread.h"
  16 #include "base/time/time.h"
  17 #include "base/win/scoped_handle.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "testing/multiprocess_func_list.h"
  20
  21 namespace browser_watcher {
  22
  23 namespace {
  24
  25 const base::char16 kRegistryPath[] = L"Software\\ExitCodeWatcherTest";
  26
  27 MULTIPROCESS_TEST_MAIN(Sleeper) {
  28   // Sleep forever - the test harness will kill this process to give it an
  29   // exit code.
  30   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(INFINITE));
  31   return 1;
  32 }
  33
  34 class ScopedSleeperProcess {
  35  public:
  36    ScopedSleeperProcess() : is_killed_(false) {
  37   }
  38
  39   ~ScopedSleeperProcess() {
  40     if (process_.IsValid()) {
  41       process_.Terminate(-1, false);
  42       int exit_code = 0;
  43       EXPECT_TRUE(process_.WaitForExit(&exit_code));
  44     }
  45   }
  46
  47   void Launch() {
  48     ASSERT_FALSE(process_.IsValid());
  49
  50     base::CommandLine cmd_line(base::GetMultiProcessTestChildBaseCommandLine());
  51     base::LaunchOptions options;
  52     options.start_hidden = true;
  53     process_ = base::SpawnMultiProcessTestChild("Sleeper", cmd_line, options);
  54     ASSERT_TRUE(process_.IsValid());
  55   }
  56
  57   void Kill(int exit_code, bool wait) {
  58     ASSERT_TRUE(process_.IsValid());
  59     ASSERT_FALSE(is_killed_);
  60     process_.Terminate(exit_code, false);
  61     int seen_exit_code = 0;
  62     EXPECT_TRUE(process_.WaitForExit(&seen_exit_code));
  63     EXPECT_EQ(exit_code, seen_exit_code);
  64     is_killed_ = true;
  65   }
  66
  67   const base::Process& process() const { return process_; }
  68
  69  private:
  70   base::Process process_;
  71   bool is_killed_;
  72 };
  73
  74 class ExitCodeWatcherTest : public testing::Test {
  75  public:
  76   typedef testing::Test Super;
  77
  78   static const int kExitCode = 0xCAFEBABE;
  79
  80   ExitCodeWatcherTest() : cmd_line_(base::CommandLine::NO_PROGRAM) {}
  81
  82   void SetUp() override {
  83     Super::SetUp();
  84
  85     override_manager_.OverrideRegistry(HKEY_CURRENT_USER);
  86   }
  87
  88   base::Process OpenSelfWithAccess(uint32 access) {
  89     return base::Process::OpenWithAccess(base::GetCurrentProcId(), access);
  90   }
  91
  92   void VerifyWroteExitCode(base::ProcessId proc_id, int exit_code) {
  93     base::win::RegistryValueIterator it(
  94           HKEY_CURRENT_USER, kRegistryPath);
  95
  96     ASSERT_EQ(1, it.ValueCount());
  97     base::win::RegKey key(HKEY_CURRENT_USER,
  98                           kRegistryPath,
  99                           KEY_QUERY_VALUE);
 100
 101     // The value name should encode the process id at the start.
 102     EXPECT_TRUE(StartsWith(it.Name(),
 103                            base::StringPrintf(L"%d-", proc_id),
 104                            false));
 105     DWORD value = 0;
 106     ASSERT_EQ(ERROR_SUCCESS, key.ReadValueDW(it.Name(), &value));
 107     ASSERT_EQ(exit_code, value);
 108   }
 109
 110  protected:
 111   base::CommandLine cmd_line_;
 112   registry_util::RegistryOverrideManager override_manager_;
 113 };
 114
 115 }  // namespace
 116
 117 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherInvalidHandleFailsInit) {
 118   ExitCodeWatcher watcher(kRegistryPath);
 119
 120   // A waitable event has a non process-handle.
 121   base::Process event(::CreateEvent(NULL, false, false, NULL));
 122
 123   // A non-process handle should fail.
 124   EXPECT_FALSE(watcher.Initialize(event.Pass()));
 125 }
 126
 127 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherNoAccessHandleFailsInit) {
 128   ExitCodeWatcher watcher(kRegistryPath);
 129
 130   // Open a SYNCHRONIZE-only handle to this process.
 131   base::Process self = OpenSelfWithAccess(SYNCHRONIZE);
 132   ASSERT_TRUE(self.IsValid());
 133
 134   // A process handle with insufficient access should fail.
 135   EXPECT_FALSE(watcher.Initialize(self.Pass()));
 136 }
 137
 138 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherSucceedsInit) {
 139   ExitCodeWatcher watcher(kRegistryPath);
 140
 141   // Open a handle to this process with sufficient access for the watcher.
 142   base::Process self =
 143       OpenSelfWithAccess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION);
 144   ASSERT_TRUE(self.IsValid());
 145
 146   // A process handle with sufficient access should succeed init.
 147   EXPECT_TRUE(watcher.Initialize(self.Pass()));
 148 }
 149
 150 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherOnExitedProcess) {
 151   ScopedSleeperProcess sleeper;
 152   ASSERT_NO_FATAL_FAILURE(sleeper.Launch());
 153
 154   ExitCodeWatcher watcher(kRegistryPath);
 155
 156   EXPECT_TRUE(watcher.Initialize(sleeper.process().Duplicate()));
 157
 158   // Verify that the watcher wrote a sentinel for the process.
 159   VerifyWroteExitCode(sleeper.process().Pid(), STILL_ACTIVE);
 160
 161   // Kill the sleeper, and make sure it's exited before we continue.
 162   ASSERT_NO_FATAL_FAILURE(sleeper.Kill(kExitCode, true));
 163
 164   watcher.WaitForExit();
 165   EXPECT_EQ(kExitCode, watcher.exit_code());
 166
 167   VerifyWroteExitCode(sleeper.process().Pid(), kExitCode);
 168 }
 169
 170 }  // namespace browser_watcher