Use std::move() instead of scoped_ptr<>::Pass().

remoting/protocol/fake_authenticator.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 "remoting/protocol/fake_authenticator.h"
 
 #include "base/base64.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
@@ skipping 15 matching lines @@
       did_write_bytes_(false),
       weak_factory_(this) {
 }
 
 FakeChannelAuthenticator::~FakeChannelAuthenticator() {
 }
 
 void FakeChannelAuthenticator::SecureAndAuthenticate(
     scoped_ptr<P2PStreamSocket> socket,
     const DoneCallback& done_callback) {
-  socket_ = socket.Pass();
+  socket_ = std::move(socket);
 
   if (async_) {
     done_callback_ = done_callback;
 
     if (result_ != net::OK) {
       // Don't write anything if we are going to reject auth to make test
       // ordering deterministic.
       did_write_bytes_ = true;
     } else {
       scoped_refptr<net::IOBuffer> write_buf = new net::IOBuffer(1);
@@ skipping 33 matching lines @@
   EXPECT_EQ(1, result);
   EXPECT_FALSE(did_read_bytes_);
   did_read_bytes_ = true;
   if (did_write_bytes_)
     CallDoneCallback();
 }
 
 void FakeChannelAuthenticator::CallDoneCallback() {
   if (result_ != net::OK)
     socket_.reset();
-  base::ResetAndReturn(&done_callback_).Run(result_, socket_.Pass());
+  base::ResetAndReturn(&done_callback_).Run(result_, std::move(socket_));
 }
 
 FakeAuthenticator::FakeAuthenticator(Type type,
                                      int round_trips,
                                      Action action,
                                      bool async)
     : type_(type),
       round_trips_(round_trips),
       action_(action),
       async_(async),
@@ skipping 77 matching lines @@
     auth_key_ =  base::RandBytesAsString(16);
     buzz::XmlElement* key = new buzz::XmlElement(
         buzz::QName(kChromotingXmlNamespace, "key"));
     std::string key_base64;
     base::Base64Encode(auth_key_, &key_base64);
     key->AddText(key_base64);
     result->AddElement(key);
   }
 
   ++messages_;
-  return result.Pass();
+  return result;
 }
 
 const std::string& FakeAuthenticator::GetAuthKey() const {
   EXPECT_EQ(ACCEPTED, state());
   return auth_key_;
 }
 
 scoped_ptr<ChannelAuthenticator>
 FakeAuthenticator::CreateChannelAuthenticator() const {
   EXPECT_EQ(ACCEPTED, state());
   return make_scoped_ptr(
       new FakeChannelAuthenticator(action_ != REJECT_CHANNEL, async_));
 }
 
 FakeHostAuthenticatorFactory::FakeHostAuthenticatorFactory(
     int round_trips, int messages_till_started,
     FakeAuthenticator::Action action, bool async)
     : round_trips_(round_trips),
       messages_till_started_(messages_till_started),
       action_(action), async_(async) {
 }
 
 FakeHostAuthenticatorFactory::~FakeHostAuthenticatorFactory() {
 }
 
 scoped_ptr<Authenticator> FakeHostAuthenticatorFactory::CreateAuthenticator(
     const std::string& local_jid,
     const std::string& remote_jid,
     const buzz::XmlElement* first_message) {
-  FakeAuthenticator* authenticator = new FakeAuthenticator(
-      FakeAuthenticator::HOST, round_trips_, action_, async_);
+  scoped_ptr<FakeAuthenticator> authenticator(new FakeAuthenticator(
+      FakeAuthenticator::HOST, round_trips_, action_, async_));
   authenticator->set_messages_till_started(messages_till_started_);
-
-  scoped_ptr<Authenticator> result(authenticator);
-  return result.Pass();
+  return std::move(authenticator);

[Jamie, 2015/12/22 12:23:36]

I don't think you need move here
(https://www.chromium.org/rvalue-references#TOC-11.-Don-t-return-references.-D...)

[Sergey Ulanov, 2015/12/22 18:07:35]

This return statement requires upcast from FakeAuthenticator to Authenticator,
so it doesn't compile without move(). It's mentioned on the same page:

   However, if the types of the variable and the return type do 
   not match exactly, then you will have to use std::move() in 
   order to convert without creating an extra temporary.

 }
 
 }  // namespace protocol
 }  // namespace remoting