Remove uses of CloseProcessHandle.

components/browser_watcher/exit_code_watcher_win_unittest.cc

 // Copyright (c) 2014 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 "components/browser_watcher/exit_code_watcher_win.h"
 
 #include "base/command_line.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
@@ skipping 59 matching lines @@
   base::Process process_;
   bool is_killed_;
 };
 
 class ExitCodeWatcherTest : public testing::Test {
  public:
   typedef testing::Test Super;
 
   static const int kExitCode = 0xCAFEBABE;
 
-  ExitCodeWatcherTest() :
-      cmd_line_(base::CommandLine::NO_PROGRAM),
-      process_(base::kNullProcessHandle) {
-  }
+  ExitCodeWatcherTest() : cmd_line_(base::CommandLine::NO_PROGRAM) {}
 
   virtual void SetUp() override {
     Super::SetUp();
 
     override_manager_.OverrideRegistry(HKEY_CURRENT_USER);
   }
 
-  virtual void TearDown() override {
-    if (process_ != base::kNullProcessHandle) {

[Sigurður Ásgeirsson, 2015/01/26 14:21:28]

Ah - that was pretty redundant - thanks for the cleanup!

-      base::CloseProcessHandle(process_);
-      process_ = base::kNullProcessHandle;
-    }
-
-    Super::TearDown();
-  }
-
   base::Process OpenSelfWithAccess(uint32 access) {
     return base::Process::OpenWithAccess(base::GetCurrentProcId(), access);
   }
 
   void VerifyWroteExitCode(base::ProcessId proc_id, int exit_code) {
     base::win::RegistryValueIterator it(
           HKEY_CURRENT_USER, kRegistryPath);
 
     ASSERT_EQ(1, it.ValueCount());
     base::win::RegKey key(HKEY_CURRENT_USER,
                           kRegistryPath,
                           KEY_QUERY_VALUE);
 
     // The value name should encode the process id at the start.
     EXPECT_TRUE(StartsWith(it.Name(),
                            base::StringPrintf(L"%d-", proc_id),
                            false));
     DWORD value = 0;
     ASSERT_EQ(ERROR_SUCCESS, key.ReadValueDW(it.Name(), &value));
     ASSERT_EQ(exit_code, value);
   }
 
  protected:
   base::CommandLine cmd_line_;
-  base::ProcessHandle process_;
   registry_util::RegistryOverrideManager override_manager_;
 };
 
 }  // namespace
 
 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherInvalidHandleFailsInit) {
   ExitCodeWatcher watcher(kRegistryPath);
 
   // A waitable event has a non process-handle.
   base::Process event(::CreateEvent(NULL, false, false, NULL));
@@ skipping 39 matching lines @@
   // Kill the sleeper, and make sure it's exited before we continue.
   ASSERT_NO_FATAL_FAILURE(sleeper.Kill(kExitCode, true));
 
   watcher.WaitForExit();
   EXPECT_EQ(kExitCode, watcher.exit_code());
 
   VerifyWroteExitCode(sleeper.process().Pid(), kExitCode);
 }
 
 }  // namespace browser_watcher