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

remoting/protocol/pepper_session.cc

 // Copyright (c) 2011 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/pepper_session.h"
 
 #include "base/bind.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 38 matching lines @@
   state_change_callback_ = callback;
 }
 
 Session::Error PepperSession::error() {
   DCHECK(CalledOnValidThread());
   return error_;
 }
 
 void PepperSession::StartConnection(
     const std::string& peer_jid,
-    Authenticator* authenticator,
-    CandidateSessionConfig* config,
+    scoped_ptr<Authenticator> authenticator,
+    scoped_ptr<CandidateSessionConfig> config,
     const StateChangeCallback& state_change_callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(authenticator);
+  DCHECK(authenticator.get());
   DCHECK_EQ(authenticator->state(), Authenticator::MESSAGE_READY);
 
   peer_jid_ = peer_jid;
-  authenticator_.reset(authenticator);
-  candidate_config_.reset(config);
+  authenticator_ = authenticator.Pass();
+  candidate_config_ = config.Pass();
   state_change_callback_ = state_change_callback;
 
   // Generate random session ID. There are usually not more than 1
   // concurrent session per host, so a random 64-bit integer provides
   // enough entropy. In the worst case connection will fail when two
   // clients generate the same session ID concurrently.
   session_id_ = base::Int64ToString(base::RandGenerator(kint64max));
 
   // Send session-initiate message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_INITIATE,
@@ skipping 27 matching lines @@
 void PepperSession::OnError(Error error) {
   error_ = error;
   CloseInternal(true);
 }
 
 void PepperSession::CreateStreamChannel(
       const std::string& name,
       const StreamChannelCallback& callback) {
   DCHECK(!channels_[name]);
 
-  ChannelAuthenticator* channel_authenticator =
+  scoped_ptr<ChannelAuthenticator> channel_authenticator =
       authenticator_->CreateChannelAuthenticator();
   PepperStreamChannel* channel = new PepperStreamChannel(
       this, name, callback);
   channels_[name] = channel;
   channel->Connect(session_manager_->pp_instance_,
                    session_manager_->transport_config_,
-                   channel_authenticator);
+                   channel_authenticator.Pass());
 }
 
 void PepperSession::CreateDatagramChannel(
     const std::string& name,
     const DatagramChannelCallback& callback) {
   // TODO(sergeyu): Implement datagram channel support.
   NOTREACHED();
 }
 
 void PepperSession::CancelChannelCreation(const std::string& name) {
@@ skipping 193 matching lines @@
   }
 
   return true;
 }
 
 void PepperSession::ProcessAuthenticationStep() {
   DCHECK_EQ(state_, CONNECTED);
 
   if (authenticator_->state() == Authenticator::MESSAGE_READY) {
     JingleMessage message(peer_jid_, JingleMessage::SESSION_INFO, session_id_);
-    message.info.reset(authenticator_->GetNextMessage());
+    message.info = authenticator_->GetNextMessage();
     DCHECK(message.info.get());
 
     session_info_request_.reset(session_manager_->iq_sender()->SendIq(
         message.ToXml(), base::Bind(
             &PepperSession::OnSessionInfoResponse,
             base::Unretained(this))));
   }
   DCHECK_NE(authenticator_->state(), Authenticator::MESSAGE_READY);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
@@ skipping 76 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (!state_change_callback_.is_null())
       state_change_callback_.Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting