Convert Pass()→std::move() in //chrome/browser/extensions

chrome/browser/extensions/api/messaging/native_message_process_host_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/messaging/native_message_process_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 27 matching lines @@
 
 const char kTestMessage[] = "{\"text\": \"Hello.\"}";
 
 }  // namespace
 
 namespace extensions {
 
 class FakeLauncher : public NativeProcessLauncher {
  public:
   FakeLauncher(base::File read_file, base::File write_file)
-      : read_file_(read_file.Pass()),
-        write_file_(write_file.Pass()) {
-  }
+      : read_file_(std::move(read_file)), write_file_(std::move(write_file)) {}
 
   static scoped_ptr<NativeProcessLauncher> Create(base::FilePath read_file,
                                                   base::FilePath write_file) {
     int read_flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
     int write_flags = base::File::FLAG_CREATE | base::File::FLAG_WRITE;
 #if !defined(OS_POSIX)
     read_flags |= base::File::FLAG_ASYNC;
     write_flags |= base::File::FLAG_ASYNC;
 #endif
     return scoped_ptr<NativeProcessLauncher>(new FakeLauncher(
         base::File(read_file, read_flags),
         base::File(write_file, write_flags)));
   }
 
   static scoped_ptr<NativeProcessLauncher> CreateWithPipeInput(
       base::File read_pipe,
       base::FilePath write_file) {
     int write_flags = base::File::FLAG_CREATE | base::File::FLAG_WRITE;
 #if !defined(OS_POSIX)
     write_flags |= base::File::FLAG_ASYNC;
 #endif
 
     return scoped_ptr<NativeProcessLauncher>(new FakeLauncher(
-        read_pipe.Pass(),
-        base::File(write_file, write_flags)));
+        std::move(read_pipe), base::File(write_file, write_flags)));
   }
 
   void Launch(const GURL& origin,
               const std::string& native_host_name,
               const LaunchedCallback& callback) const override {
-    callback.Run(NativeProcessLauncher::RESULT_SUCCESS,
-                 base::Process(), read_file_.Pass(), write_file_.Pass());
+    callback.Run(NativeProcessLauncher::RESULT_SUCCESS, base::Process(),
+                 std::move(read_file_), std::move(write_file_));
   }
 
  private:
   mutable base::File read_file_;
   mutable base::File write_file_;
 };
 
 class NativeMessagingTest : public ::testing::Test,
                             public NativeMessageHost::Client,
                             public base::SupportsWeakPtr<NativeMessagingTest> {
@@ skipping 13 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   void PostMessageFromNativeHost(const std::string& message) override {
     last_message_ = message;
 
     // Parse the message.
     scoped_ptr<base::DictionaryValue> dict_value =
         base::DictionaryValue::From(base::JSONReader::Read(message));
     if (dict_value) {
-      last_message_parsed_ = dict_value.Pass();
+      last_message_parsed_ = std::move(dict_value);
     } else {
       LOG(ERROR) << "Failed to parse " << message;
       last_message_parsed_.reset();
     }
 
     if (run_loop_)
       run_loop_->Quit();
   }
 
   void CloseChannel(const std::string& error_message) override {
@@ skipping 34 matching lines @@
   bool channel_closed_;
 };
 
 // Read a single message from a local file.
 TEST_F(NativeMessagingTest, SingleSendMessageRead) {
   base::FilePath temp_output_file = temp_dir_.path().AppendASCII("output");
   base::FilePath temp_input_file = CreateTempFileWithMessage(kTestMessage);
   ASSERT_FALSE(temp_input_file.empty());
 
   scoped_ptr<NativeProcessLauncher> launcher =
-      FakeLauncher::Create(temp_input_file, temp_output_file).Pass();
+      FakeLauncher::Create(temp_input_file, temp_output_file);
   native_message_host_ = NativeMessageProcessHost::CreateWithLauncher(
-      ScopedTestNativeMessagingHost::kExtensionId,
-      "empty_app.py",
-      launcher.Pass());
+      ScopedTestNativeMessagingHost::kExtensionId, "empty_app.py",
+      std::move(launcher));
   native_message_host_->Start(this);
   ASSERT_TRUE(native_message_host_.get());
   run_loop_.reset(new base::RunLoop());
   run_loop_->RunUntilIdle();
 
   if (last_message_.empty()) {
     run_loop_.reset(new base::RunLoop());
     scoped_ptr<NativeMessageProcessHost> native_message_process_host_(
         static_cast<NativeMessageProcessHost*>(native_message_host_.release()));
     native_message_process_host_->ReadNowForTesting();
@@ skipping 24 matching lines @@
 
   read_file = read_handle.Pass();
 #else  // defined(OS_WIN)
   base::PlatformFile pipe_handles[2];
   ASSERT_EQ(0, pipe(pipe_handles));
   read_file = base::File(pipe_handles[0]);
   base::File write_file(pipe_handles[1]);
 #endif  // !defined(OS_WIN)
 
   scoped_ptr<NativeProcessLauncher> launcher =
-      FakeLauncher::CreateWithPipeInput(read_file.Pass(),
-                                        temp_output_file).Pass();
+      FakeLauncher::CreateWithPipeInput(std::move(read_file), temp_output_file);
   native_message_host_ = NativeMessageProcessHost::CreateWithLauncher(
-      ScopedTestNativeMessagingHost::kExtensionId,
-      "empty_app.py",
-      launcher.Pass());
+      ScopedTestNativeMessagingHost::kExtensionId, "empty_app.py",
+      std::move(launcher));
   native_message_host_->Start(this);
   ASSERT_TRUE(native_message_host_.get());
   base::RunLoop().RunUntilIdle();
 
   native_message_host_->OnMessage(kTestMessage);
   base::RunLoop().RunUntilIdle();
 
   std::string output;
   base::TimeTicks start_time = base::TimeTicks::Now();
   while (base::TimeTicks::Now() - start_time < TestTimeouts::action_timeout()) {
@@ skipping 85 matching lines @@
   native_message_host_->Start(this);
   ASSERT_TRUE(native_message_host_.get());
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
   // The host should fail to start.
   ASSERT_TRUE(channel_closed_);
 }
 
 }  // namespace extensions