Remove uses of CloseProcessHandle.

components/browser_watcher/watcher_client_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/watcher_client_win.h"
 
 #include <string>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
-#include "base/process/process_handle.h"
 #include "base/process/kill.h"
+#include "base/process/process.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "components/browser_watcher/exit_code_watcher_win.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
@@ skipping 109 matching lines @@
   WatcherClient::CommandLineGenerator GetBaseCommandLineGenerator(
       HandlePolicy handle_policy) {
     return base::Bind(&WatcherClientTest::GetBaseCommandLine,
                       base::Unretained(this), handle_policy);
   }
 
   void AssertSuccessfulExitCode(base::ProcessHandle handle) {
     ASSERT_NE(base::kNullProcessHandle, handle);
 
     // Duplicate the process handle to work around the fact that
     // WaitForExitCode closes it(!!!).

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

Stale comment. 
I think the dupe is still necessary, but only because the client has an accessor
to process_.Handle() - this is for testing only IIRC.
Maybe cleaner to change the accessor to return a const Process& and use
Duplicate() to draw a new Process instance?

If you don't want to do this in this CL, I can take care of it - leave me a TODO
or a bug in that case, please?

PS: thanks for cleaning up ProcessHandle ownership - the old way drove me nuts!

[rvargas (doing something else), 2015/02/02 20:57:00]

Done.

-    base::ProcessHandle dupe = NULL;
+    base::ProcessHandle duped_handle = NULL;
     ASSERT_TRUE(::DuplicateHandle(base::GetCurrentProcessHandle(),
                                   handle,
                                   base::GetCurrentProcessHandle(),
-                                  &dupe,
+                                  &duped_handle,
                                   SYNCHRONIZE | PROCESS_QUERY_INFORMATION,
                                   FALSE,
                                   0));
-    ASSERT_NE(base::kNullProcessHandle, dupe);
+    base::Process duped_process(duped_handle);
+    ASSERT_TRUE(duped_process.IsValid());
     int exit_code = 0;
-    if (!base::WaitForExitCode(dupe, &exit_code)) {
-      base::CloseProcessHandle(dupe);
-      FAIL() << "WaitForExitCode failed.";
+    if (!duped_process.WaitForExit(&exit_code)) {
+      FAIL() << "WaitForExit failed.";
     }
     ASSERT_EQ(0, exit_code);
   }
 
   // Inheritable process handle used for testing.
   base::win::ScopedHandle self_;
 };
 
 }  // namespace
 
@@ skipping 34 matching lines @@
   // it works on Windows XP.
   WatcherClient client(GetBaseCommandLineGenerator(LEAK_HANDLE));
   ASSERT_TRUE(client.use_legacy_launch());
 
   client.LaunchWatcher();
 
   ASSERT_NO_FATAL_FAILURE(AssertSuccessfulExitCode(client.process()));
 }
 
 }  // namespace browser_watcher