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

remoting/protocol/jingle_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/jingle_session.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
@@ skipping 15 matching lines @@
 #include "third_party/libjingle/source/talk/p2p/base/transport.h"
 
 using cricket::BaseSession;
 
 namespace remoting {
 namespace protocol {
 
 JingleSession::JingleSession(
     JingleSessionManager* jingle_session_manager,
     cricket::Session* cricket_session,
-    Authenticator* authenticator)
+    scoped_ptr<Authenticator> authenticator)
     : jingle_session_manager_(jingle_session_manager),
-      authenticator_(authenticator),
+      authenticator_(authenticator.Pass()),
       state_(INITIALIZING),
       error_(OK),
       closing_(false),
       cricket_session_(cricket_session),
       config_set_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   jid_ = cricket_session_->remote_name();
   cricket_session_->SignalState.connect(this, &JingleSession::OnSessionState);
   cricket_session_->SignalError.connect(this, &JingleSession::OnSessionError);
   cricket_session_->SignalInfoMessage.connect(
       this, &JingleSession::OnSessionInfoMessage);
   cricket_session_->SignalReceivedTerminateReason.connect(
       this, &JingleSession::OnTerminateReason);
 }
 
 JingleSession::~JingleSession() {
   // Reset the callback so that it's not called from Close().
   state_change_callback_.Reset();
   Close();
   jingle_session_manager_->SessionDestroyed(this);
   DCHECK(channel_connectors_.empty());
 }
 
 void JingleSession::SendSessionInitiate() {
   DCHECK_EQ(authenticator_->state(), Authenticator::MESSAGE_READY);
   cricket_session_->Initiate(
-      jid_, CreateSessionDescription(candidate_config()->Clone(),
-                                     authenticator_->GetNextMessage()));
+      jid_, CreateSessionDescription(
+          candidate_config()->Clone(),
+          authenticator_->GetNextMessage()).release());

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

Is this another up-cast issue, or should this be a Pass()?

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

No, cricket::Session::Initiate() is in libjingle, we cannot change it, and it
accepts a pointer, not scoped_ptr. So this must be release() 

[Wez, 2012/01/19 23:56:57]

Yes, of course; I mis-counted the brackets...

 }
 
 void JingleSession::CloseInternal(int result, Error error) {
   DCHECK(CalledOnValidThread());
 
   if (state_ != FAILED && state_ != CLOSED && !closing_) {
     closing_ = true;
 
     // Tear down the cricket session, including the cricket transport channels.
     if (cricket_session_) {
@@ skipping 88 matching lines @@
   return jid_;
 }
 
 const CandidateSessionConfig* JingleSession::candidate_config() {
   DCHECK(CalledOnValidThread());
   DCHECK(candidate_config_.get());
   return candidate_config_.get();
 }
 
 void JingleSession::set_candidate_config(
-    const CandidateSessionConfig* candidate_config) {
+    scoped_ptr<CandidateSessionConfig> candidate_config) {
   DCHECK(CalledOnValidThread());
   DCHECK(!candidate_config_.get());
-  DCHECK(candidate_config);
-  candidate_config_.reset(candidate_config);
+  DCHECK(candidate_config.get());
+  candidate_config_ = candidate_config.Pass();
 }
 
 const SessionConfig& JingleSession::config() {
   DCHECK(CalledOnValidThread());
   DCHECK(config_set_);
   return config_;
 }
 
 void JingleSession::set_config(const SessionConfig& config) {
   DCHECK(CalledOnValidThread());
@@ skipping 187 matching lines @@
   SetState(CONNECTING);
 
   const cricket::SessionDescription* session_description =
       cricket_session_->remote_description();
   const cricket::ContentInfo* content =
       session_description->FirstContentByType(kChromotingXmlNamespace);
 
   CHECK(content);
   const ContentDescription* content_description =
       static_cast<const ContentDescription*>(content->description);
-  candidate_config_.reset(content_description->config()->Clone());
+  candidate_config_ = content_description->config()->Clone();
 
   SessionManager::IncomingSessionResponse response =
       jingle_session_manager_->AcceptConnection(this);
   if (response != SessionManager::ACCEPT) {
     if (response == SessionManager::INCOMPATIBLE) {
       cricket_session_->TerminateWithReason(
           cricket::STR_TERMINATE_INCOMPATIBLE_PARAMETERS);
     } else {
       cricket_session_->TerminateWithReason(cricket::STR_TERMINATE_DECLINE);
     }
     Close();
     // Release session so that JingleSessionManager::SessionDestroyed()
     // doesn't try to call cricket::SessionManager::DestroySession() for it.
     ReleaseSession();
     delete this;
     return;
   }
 
   const buzz::XmlElement* auth_message =
       content_description->authenticator_message();
   if (!auth_message) {
     DLOG(WARNING) << "Received session-initiate without authenticator message.";
     CloseInternal(net::ERR_CONNECTION_FAILED, INCOMPATIBLE_PROTOCOL);
     return;
   }
 
-  authenticator_.reset(
-      jingle_session_manager_->CreateAuthenticator(jid(), auth_message));
+  authenticator_ =
+      jingle_session_manager_->CreateAuthenticator(jid(), auth_message);
   if (!authenticator_.get()) {
     CloseInternal(net::ERR_CONNECTION_FAILED, INCOMPATIBLE_PROTOCOL);
     return;
   }
 
   DCHECK(authenticator_->state() == Authenticator::WAITING_MESSAGE);
   authenticator_->ProcessMessage(auth_message);
   if (authenticator_->state() == Authenticator::REJECTED) {
     CloseInternal(net::ERR_CONNECTION_FAILED, AUTHENTICATION_FAILED);
     return;
   }
 
   // Connection must be configured by the AcceptConnection() callback.
-  CandidateSessionConfig* candidate_config =
+  scoped_ptr<CandidateSessionConfig> candidate_config =
       CandidateSessionConfig::CreateFrom(config());
 
-  buzz::XmlElement* auth_reply = NULL;
+  scoped_ptr<buzz::XmlElement> auth_reply;
   if (authenticator_->state() == Authenticator::MESSAGE_READY)
     auth_reply = authenticator_->GetNextMessage();
   DCHECK_NE(authenticator_->state(), Authenticator::MESSAGE_READY);
   cricket_session_->Accept(
-      CreateSessionDescription(candidate_config, auth_reply));
+      CreateSessionDescription(candidate_config.Pass(),
+                               auth_reply.Pass()).release());
 }
 
 void JingleSession::ProcessAuthenticationStep() {
   DCHECK_EQ(state_, CONNECTED);
 
   if (authenticator_->state() == Authenticator::MESSAGE_READY) {
-    buzz::XmlElement* auth_message = authenticator_->GetNextMessage();
+    scoped_ptr<buzz::XmlElement> auth_message =
+        authenticator_->GetNextMessage();
     cricket::XmlElements message;
-    message.push_back(auth_message);
+    message.push_back(auth_message.release());
     cricket_session_->SendInfoMessage(message);
   }
   DCHECK_NE(authenticator_->state(), Authenticator::MESSAGE_READY);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     SetState(AUTHENTICATED);
   } else if (authenticator_->state() == Authenticator::REJECTED) {
     CloseInternal(net::ERR_CONNECTION_ABORTED, AUTHENTICATION_FAILED);
   }
 }
 
 void JingleSession::AddChannelConnector(
     const std::string& name, JingleChannelConnector* connector) {
   DCHECK(channel_connectors_.find(name) == channel_connectors_.end());
 
   const std::string& content_name = GetContentInfo()->name;
   cricket::TransportChannel* raw_channel =
       cricket_session_->CreateChannel(content_name, name);
 
   if (!jingle_session_manager_->allow_nat_traversal_ &&
       !cricket_session_->initiator()) {
     // Don't make outgoing connections from the host to client when
     // NAT traversal is disabled.
     raw_channel->GetP2PChannel()->set_incoming_only(true);
   }
 
   channel_connectors_[name] = connector;
-  ChannelAuthenticator* authenticator =
+  scoped_ptr<ChannelAuthenticator> authenticator =
       authenticator_->CreateChannelAuthenticator();
-  connector->Connect(authenticator, raw_channel);
+  connector->Connect(authenticator.Pass(), raw_channel);
 
   // Workaround bug in libjingle - it doesn't connect channels if they
   // are created after the session is accepted. See crbug.com/89384.
   // TODO(sergeyu): Fix the bug and remove this line.
   cricket_session_->GetTransport(content_name)->ConnectChannels();
 }
 
 void JingleSession::OnChannelConnectorFinished(
     const std::string& name, JingleChannelConnector* connector) {
   DCHECK(CalledOnValidThread());
@@ skipping 23 matching lines @@
     DCHECK_NE(state_, CLOSED);
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (!state_change_callback_.is_null())
       state_change_callback_.Run(new_state);
   }
 }
 
 // static
-cricket::SessionDescription* JingleSession::CreateSessionDescription(
-    const CandidateSessionConfig* config,
-    const buzz::XmlElement* authenticator_message) {
-  cricket::SessionDescription* desc = new cricket::SessionDescription();
+scoped_ptr<cricket::SessionDescription> JingleSession::CreateSessionDescription(
+    scoped_ptr<CandidateSessionConfig> config,
+    scoped_ptr<buzz::XmlElement> authenticator_message) {
+  scoped_ptr<cricket::SessionDescription> desc(
+      new cricket::SessionDescription());
   desc->AddContent(
       ContentDescription::kChromotingContentName, kChromotingXmlNamespace,
-      new ContentDescription(config, authenticator_message));
-  return desc;
+      new ContentDescription(config.Pass(), authenticator_message.Pass()));
+  return desc.Pass();
 }
 
 }  // namespace protocol
 }  // namespace remoting