Use Authenticator interface in Session and SessionManager

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 34 matching lines @@
 #ifndef REMOTING_PROTOCOL_SESSION_MANAGER_H_
 #define REMOTING_PROTOCOL_SESSION_MANAGER_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/non_thread_safe.h"
 #include "remoting/protocol/session.h"
 
-namespace crypto {
-class RSAPrivateKey;
-}  // namespace base
-
 namespace remoting {
 
 class SignalStrategy;
 
 namespace protocol {
 
+class Authenticator;
+class AuthenticatorFactory;
+
 // Generic interface for Chromoting session manager.
 //
 // TODO(sergeyu): Split this into two separate interfaces: one for the
 // client side and one for the host side.
 class SessionManager : public base::NonThreadSafe {
  public:
   SessionManager() { }
   virtual ~SessionManager() { }
 
   enum IncomingSessionResponse {
@@ skipping 31 matching lines @@
   // 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,
                     Listener* listener,
-                    crypto::RSAPrivateKey* private_key,
-                    const std::string& certificate,
                     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.
-  // |client_oauth_token| is a short-lived OAuth token identify the client.
+  // |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(
       const std::string& host_jid,
-      const std::string& host_public_key,
-      const std::string& client_token,
+      Authenticator* authenticator,
       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.
+  virtual void set_authenticator_factory(
+      AuthenticatorFactory* authenticator_factory) = 0;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(SessionManager);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_SESSION_MANAGER_H_