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 57 matching lines @@
     std::vector<uint8> key_vector(
         reinterpret_cast<const uint8*>(key_string.data()),
         reinterpret_cast<const uint8*>(key_string.data() +
                                        key_string.length()));
     private_key_.reset(
         crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
   }
 
   void InitAuthenticators(const std::string& client_secret,
                           const std::string& host_secret) {
-    host_.reset(V2Authenticator::CreateForHost(
-        host_cert_, *private_key_, host_secret));
-    client_.reset(V2Authenticator::CreateForClient(client_secret));
+    host_ = V2Authenticator::CreateForHost(
+        host_cert_, *private_key_, host_secret);
+    client_ = 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 27 matching lines @@
     message_loop_.RunAllPending();
 
     client_socket_.reset(client_socket);
     host_socket_.reset(host_socket);
   }
 
   MessageLoop message_loop_;
 
   scoped_ptr<crypto::RSAPrivateKey> private_key_;
   std::string host_cert_;
-  scoped_ptr<V2Authenticator> host_;
-  scoped_ptr<V2Authenticator> client_;
+  scoped_ptr<Authenticator> host_;
+  scoped_ptr<Authenticator> client_;
   scoped_ptr<FakeSocket> client_fake_socket_;
   scoped_ptr<FakeSocket> host_fake_socket_;
   scoped_ptr<ChannelAuthenticator> client_auth_;
   scoped_ptr<ChannelAuthenticator> host_auth_;
   MockChannelDoneCallback client_callback_;
   MockChannelDoneCallback host_callback_;
   scoped_ptr<net::StreamSocket> client_socket_;
   scoped_ptr<net::StreamSocket> host_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(V2AuthenticatorTest);
 };
 
 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();
   tester.CheckResults();
 }
 
 // Verify that connection is rejected when secrets don't match.
 TEST_F(V2AuthenticatorTest, InvalidSecret) {
   ASSERT_NO_FATAL_FAILURE(
       InitAuthenticators(kTestSharedSecretBad, kTestSharedSecret));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
 
   ASSERT_EQ(Authenticator::REJECTED, client_->state());
 
-  // Change |client_| so that we can get the laste message.
-  client_->state_ = Authenticator::MESSAGE_READY;
+  // Change |client_| so that we can get the last message.
+  reinterpret_cast<V2Authenticator*>(client_.get())->state_ =

[Wez, 2012/01/19 23:23:41]

All this up/down-casting complication seems unfortunate.  We should chase that
up with Albert et al and see if there's any way to improve matters.

[Sergey Ulanov, 2012/01/19 23:50:26]

I already talked about it with Albert. The best possible solution is to add some
helper for it, e.g. PassAs<>(). He doesn't have much time left to make it
happen, but I think it should be rather simple fix, so I'll try to add this
method tomorrow, or maybe next week.

+      Authenticator::MESSAGE_READY;
 
   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