Use std::move() instead of .Pass() in remoting/host

remoting/host/native_messaging/native_messaging_reader.cc

 // Copyright 2013 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 "remoting/host/native_messaging/native_messaging_reader.h"
 
 #include <stdint.h>
 
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 43 matching lines @@
   scoped_refptr<base::SequencedTaskRunner> read_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 NativeMessagingReader::Core::Core(
     base::File file,
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SequencedTaskRunner> read_task_runner,
     base::WeakPtr<NativeMessagingReader> reader)
-    : read_stream_(file.Pass()),
+    : read_stream_(std::move(file)),
       reader_(reader),
       caller_task_runner_(caller_task_runner),
       read_task_runner_(read_task_runner) {
 }
 
 NativeMessagingReader::Core::~Core() {}
 
 void NativeMessagingReader::Core::ReadMessage() {
   DCHECK(read_task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 47 matching lines @@
   caller_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&NativeMessagingReader::InvokeEofCallback, reader_));
 }
 
 NativeMessagingReader::NativeMessagingReader(base::File file)
     : reader_thread_("Reader"),
       weak_factory_(this) {
   reader_thread_.Start();
   read_task_runner_ = reader_thread_.task_runner();
-  core_.reset(new Core(file.Pass(), base::ThreadTaskRunnerHandle::Get(),
+  core_.reset(new Core(std::move(file), base::ThreadTaskRunnerHandle::Get(),
                        read_task_runner_, weak_factory_.GetWeakPtr()));
 }
 
 NativeMessagingReader::~NativeMessagingReader() {
   read_task_runner_->DeleteSoon(FROM_HERE, core_.release());
 }
 
 void NativeMessagingReader::Start(MessageCallback message_callback,
                                   base::Closure eof_callback) {
   message_callback_ = message_callback;
   eof_callback_ = eof_callback;
 
   // base::Unretained is safe since |core_| is only deleted via the
   // DeleteSoon task which is posted from this class's dtor.
   read_task_runner_->PostTask(
       FROM_HERE, base::Bind(&NativeMessagingReader::Core::ReadMessage,
                             base::Unretained(core_.get())));
 }
 
 void NativeMessagingReader::InvokeMessageCallback(
     scoped_ptr<base::Value> message) {
-  message_callback_.Run(message.Pass());
+  message_callback_.Run(std::move(message));
 }
 
 void NativeMessagingReader::InvokeEofCallback() {
   eof_callback_.Run();
 }
 
 }  // namespace remoting