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

chrome/browser/extensions/api/messaging/native_message_process_host.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_path.h"
 #include "base/logging.h"
 #include "base/process/kill.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/messaging/native_messaging_host_manifest.h"
 #include "chrome/browser/extensions/api/messaging/native_process_launcher.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 22 matching lines @@
 
 namespace extensions {
 
 NativeMessageProcessHost::NativeMessageProcessHost(
     const std::string& source_extension_id,
     const std::string& native_host_name,
     scoped_ptr<NativeProcessLauncher> launcher)
     : client_(NULL),
       source_extension_id_(source_extension_id),
       native_host_name_(native_host_name),
-      launcher_(launcher.Pass()),
+      launcher_(std::move(launcher)),
       closed_(false),
 #if defined(OS_POSIX)
       read_file_(-1),
 #endif
       read_pending_(false),
       write_pending_(false),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
       content::BrowserThread::IO);
 }
 
 NativeMessageProcessHost::~NativeMessageProcessHost() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (process_.IsValid()) {
     // Kill the host process if necessary to make sure we don't leave zombies.
     // On OSX base::EnsureProcessTerminated() may block, so we have to post a
     // task on the blocking pool.
 #if defined(OS_MACOSX)
     content::BrowserThread::PostBlockingPoolTask(
         FROM_HERE,
         base::Bind(&base::EnsureProcessTerminated, Passed(&process_)));
 #else
-    base::EnsureProcessTerminated(process_.Pass());
+    base::EnsureProcessTerminated(std::move(process_));
 #endif
   }
 }
 
 // static
 scoped_ptr<NativeMessageHost> NativeMessageHost::Create(
     gfx::NativeView native_view,
     const std::string& source_extension_id,
     const std::string& native_host_name,
     bool allow_user_level,
     std::string* error_message) {
   return NativeMessageProcessHost::CreateWithLauncher(
       source_extension_id,
       native_host_name,
       NativeProcessLauncher::CreateDefault(allow_user_level, native_view));
 }
 
 // static
 scoped_ptr<NativeMessageHost> NativeMessageProcessHost::CreateWithLauncher(
     const std::string& source_extension_id,
     const std::string& native_host_name,
     scoped_ptr<NativeProcessLauncher> launcher) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  scoped_ptr<NativeMessageHost> process(
-      new NativeMessageProcessHost(source_extension_id,
-                                   native_host_name,
-                                   launcher.Pass()));
+  scoped_ptr<NativeMessageHost> process(new NativeMessageProcessHost(
+      source_extension_id, native_host_name, std::move(launcher)));
 
-  return process.Pass();
+  return process;
 }
 
 void NativeMessageProcessHost::LaunchHostProcess() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   GURL origin(std::string(kExtensionScheme) + "://" + source_extension_id_);
   launcher_->Launch(origin, native_host_name_,
                     base::Bind(&NativeMessageProcessHost::OnHostProcessLaunched,
                                weak_factory_.GetWeakPtr()));
 }
@@ skipping 15 matching lines @@
     case NativeProcessLauncher::RESULT_FORBIDDEN:
       Close(kForbiddenError);
       return;
     case NativeProcessLauncher::RESULT_FAILED_TO_START:
       Close(kFailedToStartError);
       return;
     case NativeProcessLauncher::RESULT_SUCCESS:
       break;
   }
 
-  process_ = process.Pass();
+  process_ = std::move(process);
 #if defined(OS_POSIX)
   // This object is not the owner of the file so it should not keep an fd.
   read_file_ = read_file.GetPlatformFile();
 #endif
 
   scoped_refptr<base::TaskRunner> task_runner(
       content::BrowserThread::GetBlockingPool()->
           GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
 
-  read_stream_.reset(new net::FileStream(read_file.Pass(), task_runner));
-  write_stream_.reset(new net::FileStream(write_file.Pass(), task_runner));
+  read_stream_.reset(new net::FileStream(std::move(read_file), task_runner));
+  write_stream_.reset(new net::FileStream(std::move(write_file), task_runner));
 
   WaitRead();
   DoWrite();
 }
 
 void NativeMessageProcessHost::OnMessage(const std::string& json) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (closed_)
     return;
@@ skipping 194 matching lines @@
 
   if (!closed_) {
     closed_ = true;
     read_stream_.reset();
     write_stream_.reset();
     client_->CloseChannel(error_message);
   }
 }
 
 }  // namespace extensions