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

remoting/protocol/v2_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/v2_authenticator.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "crypto/rsa_private_key.h"
 #include "remoting/base/constants.h"
@@ skipping 17 matching lines @@
                                             "certificate" };
 
 }  // namespace
 
 // static
 bool V2Authenticator::IsEkeMessage(const buzz::XmlElement* message) {
   return message->FirstNamed(kEkeTag) != NULL;
 }
 
 // static
-V2Authenticator* V2Authenticator::CreateForClient(
+scoped_ptr<Authenticator> V2Authenticator::CreateForClient(
       const std::string& shared_secret) {
-  return new V2Authenticator(
-      P224EncryptedKeyExchange::kPeerTypeClient, shared_secret);
+  return scoped_ptr<Authenticator>(new V2Authenticator(
+      P224EncryptedKeyExchange::kPeerTypeClient, shared_secret));
 }
 
 // static
-V2Authenticator* V2Authenticator::CreateForHost(
+scoped_ptr<Authenticator> V2Authenticator::CreateForHost(
     const std::string& local_cert,
     const crypto::RSAPrivateKey& local_private_key,
     const std::string& shared_secret) {
   V2Authenticator* result = new V2Authenticator(
       P224EncryptedKeyExchange::kPeerTypeServer, shared_secret);
   result->local_cert_ = local_cert;
   result->local_private_key_.reset(local_private_key.Copy());
   result->state_ = WAITING_MESSAGE;
-  return result;
+  return scoped_ptr<Authenticator>(result);
 }
 
 V2Authenticator::V2Authenticator(
     crypto::P224EncryptedKeyExchange::PeerType type,
     const std::string& shared_secret)
     : certificate_sent_(false),
       key_exchange_impl_(type, shared_secret),
       state_(MESSAGE_READY) {
   pending_messages_.push(key_exchange_impl_.GetMessage());
 }
@@ skipping 57 matching lines @@
       case P224EncryptedKeyExchange::kResultSuccess:
         auth_key_ = key_exchange_impl_.GetKey();
         state_ = ACCEPTED;
         return;
     }
   }
 
   state_ = MESSAGE_READY;
 }
 
-buzz::XmlElement* V2Authenticator::GetNextMessage() {
+scoped_ptr<buzz::XmlElement> V2Authenticator::GetNextMessage() {
   DCHECK_EQ(state(), MESSAGE_READY);
 
-  buzz::XmlElement* message = CreateEmptyAuthenticatorMessage();
+  scoped_ptr<buzz::XmlElement> message = CreateEmptyAuthenticatorMessage();
 
   DCHECK(!pending_messages_.empty());
   while (!pending_messages_.empty()) {
     const std::string& spake_message = pending_messages_.front();
     std::string base64_message;
     if (!base::Base64Encode(spake_message, &base64_message)) {
       LOG(DFATAL) << "Cannot perform base64 encode on certificate";
       continue;
     }
 
@@ skipping 10 matching lines @@
     if (!base::Base64Encode(local_cert_, &base64_cert)) {
       LOG(DFATAL) << "Cannot perform base64 encode on certificate";
     }
     certificate_tag->SetBodyText(base64_cert);
     message->AddElement(certificate_tag);
   }
 
   if (state_ != ACCEPTED) {
     state_ = WAITING_MESSAGE;
   }
-  return message;
+  return message.Pass();
 }
 
-ChannelAuthenticator* V2Authenticator::CreateChannelAuthenticator() const {
+scoped_ptr<ChannelAuthenticator>
+V2Authenticator::CreateChannelAuthenticator() const {
   DCHECK_EQ(state(), ACCEPTED);
   CHECK(!auth_key_.empty());
 
   if (is_host_side()) {
-    return SslHmacChannelAuthenticator::CreateForHost(
-        local_cert_, local_private_key_.get(), auth_key_);
+    return scoped_ptr<ChannelAuthenticator>(
+        SslHmacChannelAuthenticator::CreateForHost(
+            local_cert_, local_private_key_.get(), auth_key_).Pass());
   } else {
-    return SslHmacChannelAuthenticator::CreateForClient(
-        remote_cert_, auth_key_);
+    return scoped_ptr<ChannelAuthenticator>(
+        SslHmacChannelAuthenticator::CreateForClient(
+            remote_cert_, auth_key_).Pass());
   }
 }
 
 bool V2Authenticator::is_host_side() const {
   return local_private_key_.get() != NULL;
 }
 
 }  // namespace protocol
 }  // namespace remoting