blob: 3a4bcefeefe474a3b435850e83d6cb24a370b807 [file] [log] [blame]
// 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.
#include <list>
#include <memory>
#include <string>
namespace remoting {
namespace protocol {
extern const int kDefaultStreamVersion;
// Struct for configuration parameters of a single channel.
// Some channels (like video) may have multiple underlying sockets that need
// to be configured simultaneously.
struct ChannelConfig {
enum TransportType {
enum Codec {
CODEC_UNDEFINED, // Used for event and control channels.
// Creates a config with transport field set to TRANSPORT_NONE which indicates
// that corresponding channel is disabled.
static ChannelConfig None();
// Default constructor. Equivalent to None().
ChannelConfig() = default;
// Creates a channel config with the specified parameters.
ChannelConfig(TransportType transport, int version, Codec codec);
// operator== is overloaded so that std::find() works with
// std::list<ChannelConfig>.
bool operator==(const ChannelConfig& b) const;
TransportType transport = TRANSPORT_NONE;
int version = 0;
Codec codec = CODEC_UNDEFINED;
class CandidateSessionConfig;
// SessionConfig is used to represent negotiated session configuration. Note
// that it's useful mainly for the legacy protocol. When using the new
// WebRTC-based protocol the using_webrtc() flag is set to true and all other
// fields should be ignored.
class SessionConfig {
enum class Protocol {
// Current ICE-based protocol.
// New WebRTC-based protocol.
// Selects session configuration that is supported by both participants.
// nullptr is returned if such configuration doesn't exist. When selecting
// channel configuration priority is given to the configs listed first
// in |client_config|.
static std::unique_ptr<SessionConfig> SelectCommon(
const CandidateSessionConfig* client_config,
const CandidateSessionConfig* host_config);
// Extracts final protocol configuration. Must be used for the description
// received in the session-accept stanza. If the selection is ambiguous
// (e.g. there is more than one configuration for one of the channel)
// or undefined (e.g. no configurations for a channel) then nullptr is
// returned.
static std::unique_ptr<SessionConfig> GetFinalConfig(
const CandidateSessionConfig* candidate_config);
// Returns a suitable session configuration for use in tests.
static std::unique_ptr<SessionConfig> ForTest();
static std::unique_ptr<SessionConfig> ForTestWithAudio();
static std::unique_ptr<SessionConfig> ForTestWithVerbatimVideo();
static std::unique_ptr<SessionConfig> ForTestWithWebrtc();
Protocol protocol() const { return protocol_; }
// All fields below should be ignored when protocol() is set to WEBRTC.
const ChannelConfig& control_config() const;
const ChannelConfig& event_config() const;
const ChannelConfig& video_config() const;
const ChannelConfig& audio_config() const;
bool is_audio_enabled() const {
return audio_config_.transport != ChannelConfig::TRANSPORT_NONE;
SessionConfig(Protocol protocol);
const Protocol protocol_;
ChannelConfig control_config_;
ChannelConfig event_config_;
ChannelConfig video_config_;
ChannelConfig audio_config_;
// Defines session description that is sent from client to the host in the
// session-initiate message. It is different from the regular Config
// because it allows one to specify multiple configurations for each channel.
class CandidateSessionConfig {
static std::unique_ptr<CandidateSessionConfig> CreateEmpty();
static std::unique_ptr<CandidateSessionConfig> CreateFrom(
const SessionConfig& config);
static std::unique_ptr<CandidateSessionConfig> CreateDefault();
bool webrtc_supported() const { return webrtc_supported_; }
void set_webrtc_supported(bool webrtc_supported) {
webrtc_supported_ = webrtc_supported;
bool ice_supported() const { return ice_supported_; }
void set_ice_supported(bool ice_supported) { ice_supported_ = ice_supported; }
const std::list<ChannelConfig>& control_configs() const {
return control_configs_;
std::list<ChannelConfig>* mutable_control_configs() {
return &control_configs_;
const std::list<ChannelConfig>& event_configs() const {
return event_configs_;
std::list<ChannelConfig>* mutable_event_configs() {
return &event_configs_;
const std::list<ChannelConfig>& video_configs() const {
return video_configs_;
std::list<ChannelConfig>* mutable_video_configs() {
return &video_configs_;
const std::list<ChannelConfig>& audio_configs() const {
return audio_configs_;
std::list<ChannelConfig>* mutable_audio_configs() {
return &audio_configs_;
// Old clients always list VP9 as supported and preferred even though they
// shouldn't have it enabled yet. I.e. the host cannot trust VP9 codec
// preference received from the client. To workaround this issue the client
// adds a hint in the session-initiate message to indicate that it actually
// wants VP9 to be enabled.
// TODO(sergeyu): Remove this kludge as soon as VP9 is enabled by default.
bool vp9_experiment_enabled() const { return vp9_experiment_enabled_; }
void set_vp9_experiment_enabled(bool value) {
vp9_experiment_enabled_ = value;
bool h264_experiment_enabled() const { return h264_experiment_enabled_; }
void set_h264_experiment_enabled(bool value) {
h264_experiment_enabled_ = value;
// Returns true if |config| is supported.
bool IsSupported(const SessionConfig& config) const;
std::unique_ptr<CandidateSessionConfig> Clone() const;
// Helpers for enabling/disabling specific features.
void DisableAudioChannel();
void PreferTransport(ChannelConfig::TransportType transport);
explicit CandidateSessionConfig(const CandidateSessionConfig& config);
CandidateSessionConfig& operator=(const CandidateSessionConfig& b);
bool webrtc_supported_ = false;
bool ice_supported_ = false;
std::list<ChannelConfig> control_configs_;
std::list<ChannelConfig> event_configs_;
std::list<ChannelConfig> video_configs_;
std::list<ChannelConfig> audio_configs_;
bool vp9_experiment_enabled_ = false;
bool h264_experiment_enabled_ = false;
} // namespace protocol
} // namespace remoting