Refactor SignalStrategy so that it can be reused for multiple connections.

remoting/protocol/session_manager.h

 // 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.
 
 // 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 71 matching lines @@
     ACCEPT,
     INCOMPATIBLE,
     DECLINE,
   };
 
   class Listener {
    public:
     Listener() { }
     ~Listener() { }
 
-    // Called when the session manager has finished
-    // initialization. May be called from Init() or after Init()
-    // returns. Outgoing connections can be created after this method
-    // is called.
-    virtual void OnSessionManagerInitialized() = 0;
+    // Called when the session manager is ready. May be called from

[Wez, 2011/12/21 23:35:30]

nit: ready for what? Perhaps just merge this sentence with the one about
outgoing connections? Can we also accept incoming connections after this
notification?

[Sergey Ulanov, 2011/12/22 21:45:10]

Done
OnIncomingSession() may be called even before this method is called.

+    // Init() or after Init() returns. Outgoing connections can be
+    // created after this method is called.
+    virtual void OnSessionManagerReady() = 0;
 
     // Called when a new session is received. If the host decides to
     // accept the session it should set the |response| to
     // ACCEPT. Otherwise it should set it to DECLINE, or
     // 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|.
-  virtual void Init(const std::string& local_jid,
-                    SignalStrategy* signal_strategy,
+  virtual void Init(SignalStrategy* signal_strategy,
                     Listener* listener,
                     bool allow_nat_traversal) = 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.
@@ skipping 19 matching lines @@
       AuthenticatorFactory* authenticator_factory) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SessionManager);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_SESSION_MANAGER_H_