blob: 9d7b844e96f334218d1cc6e0866f91bd5bac082e [file] [log] [blame]
// 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.
#include <string>
#include "base/waitable_event.h"
#include "remoting/jingle_glue/jingle_channel.h"
#include "third_party/libjingle/source/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 {
class IqRequest;
class JingleClient : public base::RefCountedThreadSafe<JingleClient>,
public sigslot::has_slots<> {
enum State {
START, // Initial state.
class Callback {
virtual ~Callback() {}
// Called when state of the connection is changed.
virtual void OnStateChange(JingleClient* client, State state) = 0;
// Called when a client attempts to connect to the machine. If the
// connection should be accepted, must return true and must set
// channel_callback to the callback for the new channel.
virtual bool OnAcceptConnection(
JingleClient* client, const std::string& jid,
JingleChannel::Callback** channel_callback) = 0;
// Called when a new client connects to the host. Ownership of the |channel|
// is transfered to the callee.
virtual void OnNewConnection(JingleClient* client,
scoped_refptr<JingleChannel> channel) = 0;
// Creates a JingleClient object that executes on |thread|. This does not
// take ownership of |thread| and expects that the thread is started before
// the constructor is called, and only stopped after the JingleClient object
// has been destructed.
explicit JingleClient(JingleThread* thread);
virtual ~JingleClient();
// Starts the XMPP connection initialization. Must be called only once.
// |callback| specifies callback object for the client and must not be NULL.
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
// object is destroyed. If specified, |closed_task| is executed after the
// connection is successfully closed.
void Close();
void Close(Task* closed_task);
// Returns JID with resource ID. Empty string is returned if full JID is not
// known yet, i.e. authentication hasn't finished.
std::string GetFullJid();
// Creates new IqRequest for this client. Ownership for of the created object
// is transfered to the caller.
virtual IqRequest* CreateIqRequest();
// Current connection state of the client.
State state() { return state_; }
// Returns XmppClient object for the xmpp connection or NULL if not connected.
buzz::XmppClient* xmpp_client() { return client_; }
// Message loop used by this object to execute tasks.
MessageLoop* message_loop();
friend class HeartbeatSenderTest;
friend class JingleClientTest;
void OnConnectionStateChanged(buzz::XmppEngine::State state);
void OnIncomingTunnel(cricket::TunnelSessionClient* client, buzz::Jid jid,
std::string description, cricket::Session* session);
void DoInitialize(const std::string& username,
const std::string& auth_token,
const std::string& auth_token_service);
// Used by Connect().
void DoConnect(scoped_refptr<JingleChannel> channel,
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);
// JingleThread used for the connection. Set in the constructor.
JingleThread* thread_;
// Callback for this object. Callback must not be called if closed_ == true.
Callback* callback_;
// The XmppClient and its state and jid.
buzz::XmppClient* client_;
State state_;
Lock full_jid_lock_;
std::string full_jid_;
// Current state of the object.
Lock state_lock_; // Must be locked when accessing initialized_ or closed_.
bool initialized_;
bool closed_;
scoped_ptr<Task> closed_task_;
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_;
} // namespace remoting