// 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.
#ifndef REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_
#define REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_
#include <set>
#include <string>
#include "base/callback_forward.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/threading/non_thread_safe.h"
#include "remoting/jingle_glue/signal_strategy.h"
#include "remoting/proto/internal.pb.h"
#include "remoting/protocol/clipboard_filter.h"
#include "remoting/protocol/errors.h"
#include "remoting/protocol/input_filter.h"
#include "remoting/protocol/message_reader.h"
#include "remoting/protocol/session.h"
#include "remoting/protocol/session_manager.h"
namespace pp {
class Instance;
} // namespace pp
namespace remoting {
class XmppProxy;
class VideoPacket;
namespace protocol {
class AudioReader;
class AudioStub;
class Authenticator;
class ClientControlDispatcher;
class ClientEventDispatcher;
class ClientStub;
class ClipboardStub;
class HostStub;
class InputStub;
class SessionConfig;
class TransportFactory;
class VideoReader;
class VideoStub;
class ConnectionToHost : public SignalStrategy::Listener,
public SessionManager::Listener,
public Session::EventHandler,
public base::NonThreadSafe {
public:
// The UI implementations maintain corresponding definitions of this
// enumeration in webapp/client_session.js and
// android/java/res/values/strings.xml. The Android app also includes a
// constant in android/java/src/org/chromium/chromoting/jni/JniInterface.java
// that tracks the numeric value of the CONNECTED state. Be sure to update
// these locations to match this one if you make any changes to the ordering.
enum State {
INITIALIZING,
CONNECTING,
AUTHENTICATED,
CONNECTED,
FAILED,
CLOSED,
};
class HostEventCallback {
public:
virtual ~HostEventCallback() {}
// Called when state of the connection changes.
virtual void OnConnectionState(State state, ErrorCode error) = 0;
// Called when ready state of the connection changes. When |ready|
// is set to false some data sent by the peers may be
// delayed. This is used to indicate in the UI when connection is
// temporarily broken.
virtual void OnConnectionReady(bool ready) = 0;
};
ConnectionToHost(bool allow_nat_traversal);
virtual ~ConnectionToHost();
// |signal_strategy| must outlive connection. |audio_stub| may be
// null, in which case audio will not be requested.
virtual void Connect(SignalStrategy* signal_strategy,
const std::string& host_jid,
const std::string& host_public_key,
scoped_ptr<TransportFactory> transport_factory,
scoped_ptr<Authenticator> authenticator,
HostEventCallback* event_callback,
ClientStub* client_stub,
ClipboardStub* clipboard_stub,
VideoStub* video_stub,
AudioStub* audio_stub);
virtual const SessionConfig& config();
// Stubs for sending data to the host.
virtual ClipboardStub* clipboard_stub();
virtual HostStub* host_stub();
virtual InputStub* input_stub();
// SignalStrategy::StatusObserver interface.
virtual void OnSignalStrategyStateChange(
SignalStrategy::State state) OVERRIDE;
virtual bool OnSignalStrategyIncomingStanza(
const buzz::XmlElement* stanza) OVERRIDE;
// SessionManager::Listener interface.
virtual void OnSessionManagerReady() OVERRIDE;
virtual void OnIncomingSession(
Session* session,
SessionManager::IncomingSessionResponse* response) OVERRIDE;
// Session::EventHandler interface.
virtual void OnSessionStateChange(Session::State state) OVERRIDE;
virtual void OnSessionRouteChange(const std::string& channel_name,
const TransportRoute& route) OVERRIDE;
virtual void OnSessionChannelReady(const std::string& channel_name,
bool ready) OVERRIDE;
// Return the current state of ConnectionToHost.
State state() const;
private:
// Callbacks for channel initialization
void OnChannelInitialized(bool successful);
void NotifyIfChannelsReady();
void CloseOnError(ErrorCode error);
// Stops writing in the channels.
void CloseChannels();
void SetState(State state, ErrorCode error);
bool allow_nat_traversal_;
std::string host_jid_;
std::string host_public_key_;
scoped_ptr<Authenticator> authenticator_;
HostEventCallback* event_callback_;
// Stub for incoming messages.
ClientStub* client_stub_;
ClipboardStub* clipboard_stub_;
VideoStub* video_stub_;
AudioStub* audio_stub_;
SignalStrategy* signal_strategy_;
scoped_ptr<SessionManager> session_manager_;
scoped_ptr<Session> session_;
scoped_ptr<VideoReader> video_reader_;
scoped_ptr<AudioReader> audio_reader_;
scoped_ptr<ClientControlDispatcher> control_dispatcher_;
scoped_ptr<ClientEventDispatcher> event_dispatcher_;
ClipboardFilter clipboard_forwarder_;
InputFilter event_forwarder_;
// Internal state of the connection.
State state_;
ErrorCode error_;
// List of channels that are not currently ready.
std::set<std::string> not_ready_channels_;
private:
DISALLOW_COPY_AND_ASSIGN(ConnectionToHost);
};
} // namespace protocol
} // namespace remoting
#endif // REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_