Token-based authentication for chromoting.

remoting/jingle_glue/jingle_client.h

 // Copyright (c) 2010 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.
 
 #ifndef REMOTING_JINGLE_GLUE_JINGLE_CLIENT_H_
 #define REMOTING_JINGLE_GLUE_JINGLE_CLIENT_H_
 
 #include <string>
 
 #include "remoting/jingle_glue/jingle_channel.h"
 #include "talk/xmpp/xmppclient.h"
 
 class MessageLoop;
 
 namespace talk_base {
 class NetworkManager;
 }  // namespace talk_base
 
+namespace buzz {
+class PreXmppAuth;
+}  // namespace buzz
+
 namespace cricket {
 class BasicPortAllocator;
 class SessionManager;
 class TunnelSessionClient;
 class SessionManagerTask;
 class Session;
 }  // namespace cricket
 
 namespace remoting {
 
@@ skipping 27 matching lines @@
                                  scoped_refptr<JingleChannel> channel) = 0;
   };
 
   JingleClient();
   virtual ~JingleClient();
 
   // Starts jingle thread and XMPP connection inialization. Must be called
   // only once. message_loop() is guaranteed to exist after this method returns,
   // but the connection may not be open yet. |callback| specifies callback
   // object for the client and must not be NULL.
-  // TODO(sergeyu): Replace password with a token.
-  void Init(const std::string& username, const std::string& password,
-            Callback* callback);
+  void Init(const std::string& username, const std::string& auth_token,
+            const std::string& auth_token_service, Callback* callback);
 
   // Creates new JingleChannel connected to the host with the specified jid.
   // The result is returned immediately but the channel fails if the host
   // rejects connection. |host_jid| must be a full jid (includes resource ID).
   // Ownership of the result is transfered to the caller. The channel must
   // be closed/destroyed before JingleClient is destroyed.
   JingleChannel* Connect(const std::string& host_jid,
                          JingleChannel::Callback* callback);
 
   // Closes XMPP connection and stops the thread. Must be called before the
@@ skipping 15 matching lines @@
 
  private:
   // Used by Connect().
   class ConnectRequest;
 
   void OnConnectionStateChanged(buzz::XmppEngine::State state);
 
   void OnIncomingTunnel(cricket::TunnelSessionClient* client, buzz::Jid jid,
                         std::string description, cricket::Session* session);
 
-  void DoInitialize();
+  void DoInitialize(const std::string& username,
+                    const std::string& auth_token,
+                    const std::string& auth_token_service);
 
   // Used by Connect().
   void DoConnect(ConnectRequest* request,
                  const std::string& host_jid,
                  JingleChannel::Callback* callback);
 
   // Used by Close().
   void DoClose();
 
   // Updates current state of the connection. Must be called only in
   // the jingle thread.
   void UpdateState(State new_state);
 
+  buzz::PreXmppAuth* CreatePreXmppAuth(
+      const buzz::XmppClientSettings& settings);
+
+
   buzz::XmppClient* client_;
   scoped_ptr<JingleThread> thread_;
   State state_;
   Callback* callback_;
 
-  std::string username_;
-  std::string password_;
   Lock full_jid_lock_;
   std::string full_jid_;
 
   scoped_ptr<talk_base::NetworkManager> network_manager_;
   scoped_ptr<cricket::BasicPortAllocator> port_allocator_;
   scoped_ptr<cricket::SessionManager> session_manager_;
   scoped_ptr<cricket::TunnelSessionClient> tunnel_session_client_;
   cricket::SessionManagerTask* receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(JingleClient);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_JINGLE_GLUE_JINGLE_CLIENT_H_