Convert Pass()→std::move() on Windows

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 <stdint.h>
 
+#include <utility>
+
 #include "base/command_line.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
@@ skipping 97 matching lines @@
 
 }  // namespace
 
 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherInvalidHandleFailsInit) {
   ExitCodeWatcher watcher(kRegistryPath);
 
   // A waitable event has a non process-handle.
   base::Process event(::CreateEvent(NULL, false, false, NULL));
 
   // A non-process handle should fail.
-  EXPECT_FALSE(watcher.Initialize(event.Pass()));
+  EXPECT_FALSE(watcher.Initialize(std::move(event)));
 }
 
 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherNoAccessHandleFailsInit) {
   ExitCodeWatcher watcher(kRegistryPath);
 
   // Open a SYNCHRONIZE-only handle to this process.
   base::Process self = OpenSelfWithAccess(SYNCHRONIZE);
   ASSERT_TRUE(self.IsValid());
 
   // A process handle with insufficient access should fail.
-  EXPECT_FALSE(watcher.Initialize(self.Pass()));
+  EXPECT_FALSE(watcher.Initialize(std::move(self)));
 }
 
 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherSucceedsInit) {
   ExitCodeWatcher watcher(kRegistryPath);
 
   // Open a handle to this process with sufficient access for the watcher.
   base::Process self =
       OpenSelfWithAccess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION);
   ASSERT_TRUE(self.IsValid());
 
   // A process handle with sufficient access should succeed init.
-  EXPECT_TRUE(watcher.Initialize(self.Pass()));
+  EXPECT_TRUE(watcher.Initialize(std::move(self)));
 }
 
 TEST_F(ExitCodeWatcherTest, ExitCodeWatcherOnExitedProcess) {
   ScopedSleeperProcess sleeper;
   ASSERT_NO_FATAL_FAILURE(sleeper.Launch());
 
   ExitCodeWatcher watcher(kRegistryPath);
 
   EXPECT_TRUE(watcher.Initialize(sleeper.process().Duplicate()));
 
   // Verify that the watcher wrote a sentinel for the process.
   VerifyWroteExitCode(sleeper.process().Pid(), STILL_ACTIVE);
 
   // 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