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

remoting/protocol/v1_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/v1_authenticator.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 69 matching lines @@
         host_cert_, *private_key_, host_secret, kClientJid));
     client_.reset(new V1ClientAuthenticator(kClientJid, 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 (host_->state() != Authenticator::ACCEPTED &&
              host_->state() != Authenticator::REJECTED);
   }
 
@@ skipping 53 matching lines @@
 
 TEST_F(V1AuthenticatorTest, SuccessfulAuth) {
   {
     SCOPED_TRACE("RunAuthExchange");
     InitAuthenticators(kTestSharedSecret, kTestSharedSecret);
     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();
   tester.CheckResults();
 }
 
 // Verify that connection is rejected when secrets don't match.
 TEST_F(V1AuthenticatorTest, InvalidSecret) {
   {
     SCOPED_TRACE("RunAuthExchange");
     InitAuthenticators(kTestSharedSecretBad, kTestSharedSecret);
     RunAuthExchange();
   }
   ASSERT_EQ(Authenticator::REJECTED, host_->state());
 }
 
 }  // namespace protocol
 }  // namespace remoting