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

remoting/protocol/session_manager.h

 // 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.
 
 // The purpose of SessionManager is to facilitate creation of chromotocol
 // sessions. Both host and client use it to establish chromotocol
 // sessions. JingleChromotocolServer implements this inteface using
 // libjingle.
 //
 // OUTGOING SESSIONS
@@ skipping 110 matching lines @@
     // INCOMPATIBLE. INCOMPATIBLE indicates that the session has
     // incompatible configuration, and cannot be accepted. If the
     // callback accepts the |session| then it must also set
     // configuration for the |session| using Session::set_config().
     // The callback must take ownership of the |session| if it ACCEPTs it.
     virtual void OnIncomingSession(Session* session,
                                    IncomingSessionResponse* response) = 0;
   };
 
   // Initializes the session client. Caller retains ownership of the
-  // |signal_strategy| and |listener|. |allow_nat_traversal| must be
-  // set to true to enable NAT traversal. STUN/Relay servers are not
-  // used when NAT traversal is disabled, so P2P connection will work
-  // only when both peers are on the same network. If this object is
-  // used in server mode, then |private_key| and |certificate| are
-  // used to establish a secured communication with the client. It
-  // will also take ownership of these objects. On the client side
-  // pass in NULL for |private_key| and empty string for
-  // |certificate|.
+  // |signal_strategy| and |listener|.
   virtual void Init(SignalStrategy* signal_strategy,
                     Listener* listener,
                     const NetworkSettings& network_settings) = 0;
 
   // Tries to create a session to the host |jid|. Must be called only
   // after initialization has finished successfully, i.e. after
   // Listener::OnInitialized() has been called.
   //
   // |host_jid| is the full jid of the host to connect to.
-  // |host_public_key| is used to for authentication.
   // |authenticator| is a client authenticator for the session.
   // |config| contains the session configurations that the client supports.
   // |state_change_callback| is called when the connection state changes.
-  //
-  // Ownership of the |config| is passed to the new session.
-  virtual Session* Connect(
+  virtual scoped_ptr<Session> Connect(
       const std::string& host_jid,
-      Authenticator* authenticator,
-      CandidateSessionConfig* config,
+      scoped_ptr<Authenticator> authenticator,
+      scoped_ptr<CandidateSessionConfig> config,
       const Session::StateChangeCallback& state_change_callback) = 0;
 
   // Close session manager. Can be called only after all corresponding
   // sessions are destroyed. No callbacks are called after this method
   // returns.
   virtual void Close() = 0;
 
   // Set authenticator factory that should be used to authenticate
   // incoming connection. No connections will be accepted if
   // authenticator factory isn't set. Must not be called more than
   // once per SessionManager because it may not be safe to delete
   // factory before all authenticators it created are deleted.
   virtual void set_authenticator_factory(
       scoped_ptr<AuthenticatorFactory> authenticator_factory) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SessionManager);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_SESSION_MANAGER_H_