Use scoped_ptr<>.Pass() to pass ownership in the remoting protocol code.

remoting/protocol/v2_authenticator_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 "remoting/protocol/v2_authenticator.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 68 matching lines @@
         host_cert_, *private_key_, host_secret));
     client_.reset(V2Authenticator::CreateForClient(client_secret));
   }
 
   void RunAuthExchange() {
     do {
       scoped_ptr<buzz::XmlElement> message;
 
       // Pass message from client to host.
       ASSERT_EQ(Authenticator::MESSAGE_READY, client_->state());
-      message.reset(client_->GetNextMessage());
+      message = client_->GetNextMessage();
       ASSERT_TRUE(message.get());
       ASSERT_NE(Authenticator::MESSAGE_READY, client_->state());
 
       ASSERT_EQ(Authenticator::WAITING_MESSAGE, host_->state());
       host_->ProcessMessage(message.get());
       ASSERT_NE(Authenticator::WAITING_MESSAGE, host_->state());
 
       // Are we done yet?
       if (host_->state() == Authenticator::ACCEPTED ||
           host_->state() == Authenticator::REJECTED) {
         break;
       }
 
       // Pass message from host to client.
       ASSERT_EQ(Authenticator::MESSAGE_READY, host_->state());
-      message.reset(host_->GetNextMessage());
+      message = host_->GetNextMessage();
       ASSERT_TRUE(message.get());
       ASSERT_NE(Authenticator::MESSAGE_READY, host_->state());
 
       ASSERT_EQ(Authenticator::WAITING_MESSAGE, client_->state());
       client_->ProcessMessage(message.get());
       ASSERT_NE(Authenticator::WAITING_MESSAGE, client_->state());
     } while (client_->state() != Authenticator::ACCEPTED &&
              client_->state() != Authenticator::REJECTED);
   }
 
@@ skipping 49 matching lines @@
 };
 
 TEST_F(V2AuthenticatorTest, SuccessfulAuth) {
   ASSERT_NO_FATAL_FAILURE(
       InitAuthenticators(kTestSharedSecret, kTestSharedSecret));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
 
   ASSERT_EQ(Authenticator::ACCEPTED, host_->state());
   ASSERT_EQ(Authenticator::ACCEPTED, client_->state());
 
-  client_auth_.reset(client_->CreateChannelAuthenticator());
-  host_auth_.reset(host_->CreateChannelAuthenticator());
+  client_auth_ = client_->CreateChannelAuthenticator();
+  host_auth_ = host_->CreateChannelAuthenticator();
   RunChannelAuth(false);
 
   EXPECT_TRUE(client_socket_.get() != NULL);
   EXPECT_TRUE(host_socket_.get() != NULL);
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
 
   tester.Start();
   message_loop_.Run();
@@ skipping 14 matching lines @@
   scoped_ptr<buzz::XmlElement> message(client_->GetNextMessage());
   ASSERT_TRUE(message.get());
 
   ASSERT_EQ(Authenticator::WAITING_MESSAGE, client_->state());
   host_->ProcessMessage(message.get());
   ASSERT_EQ(Authenticator::REJECTED, host_->state());
 }
 
 }  // namespace protocol
 }  // namespace remoting