Chromoting: Rename ChromotocolConfig -> SessionConfig

BUG=none
TEST=build chrome, chromoting

Review URL: http://codereview.chromium.org/4446005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@65451 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 245 insertions, 0 deletions

diff --git a/remoting/protocol/session_config.cc b/remoting/protocol/session_config.cc
new file mode 100644
index 0000000..608510b
--- /dev/null
+++ b/remoting/protocol/session_config.cc
@@ -0,0 +1,245 @@
+// 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 "remoting/protocol/session_config.h"
+
+#include <algorithm>
+
+namespace remoting {
+namespace protocol {
+
+const int kDefaultStreamVersion = 1;
+
+namespace {
+const int kDefaultWidth = 800;
+const int kDefaultHeight = 600;
+}  // namespace
+
+ChannelConfig::ChannelConfig() {
+  Reset();
+}
+
+ChannelConfig::ChannelConfig(TransportType transport, int version, Codec codec)
+    : transport(transport),
+      version(version),
+      codec(codec) {
+}
+
+bool ChannelConfig::operator==(const ChannelConfig& b) const {
+  return transport == b.transport && version == b.version && codec == b.codec;
+}
+
+void ChannelConfig::Reset() {
+  transport = TRANSPORT_STREAM;
+  version = kDefaultStreamVersion;
+  codec = CODEC_UNDEFINED;
+}
+
+ScreenResolution::ScreenResolution()
+    : width(kDefaultWidth),
+      height(kDefaultHeight) {
+}
+
+ScreenResolution::ScreenResolution(int width, int height)
+    : width(width),
+      height(height) {
+}
+
+bool ScreenResolution::IsValid() const {
+  return width > 0 && height > 0;
+}
+
+SessionConfig::SessionConfig() { }
+
+SessionConfig::SessionConfig(const SessionConfig& config)
+    : control_config_(config.control_config_),
+      event_config_(config.event_config_),
+      video_config_(config.video_config_),
+      initial_resolution_(config.initial_resolution_) {
+}
+
+SessionConfig::~SessionConfig() { }
+
+void SessionConfig::SetControlConfig(const ChannelConfig& control_config) {
+  control_config_ = control_config;
+}
+void SessionConfig::SetEventConfig(const ChannelConfig& event_config) {
+  event_config_ = event_config;
+}
+void SessionConfig::SetVideoConfig(const ChannelConfig& video_config) {
+  video_config_ = video_config;
+}
+void SessionConfig::SetInitialResolution(const ScreenResolution& resolution) {
+  initial_resolution_ = resolution;
+}
+
+SessionConfig* SessionConfig::Clone() const {
+  return new SessionConfig(*this);
+}
+
+// static
+SessionConfig* SessionConfig::CreateDefault() {
+  SessionConfig* result = new SessionConfig();
+  result->SetControlConfig(ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
+                                         kDefaultStreamVersion,
+                                         ChannelConfig::CODEC_UNDEFINED));
+  result->SetEventConfig(ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
+                                       kDefaultStreamVersion,
+                                       ChannelConfig::CODEC_UNDEFINED));
+  result->SetVideoConfig(ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
+                                       kDefaultStreamVersion,
+                                       ChannelConfig::CODEC_ZIP));
+  return result;
+}
+
+CandidateSessionConfig::CandidateSessionConfig() { }
+
+CandidateSessionConfig::CandidateSessionConfig(
+    const CandidateSessionConfig& config)
+    : control_configs_(config.control_configs_),
+      event_configs_(config.event_configs_),
+      video_configs_(config.video_configs_),
+      initial_resolution_(config.initial_resolution_) {
+}
+
+CandidateSessionConfig::~CandidateSessionConfig() { }
+
+void CandidateSessionConfig::AddControlConfig(
+    const ChannelConfig& control_config) {
+  control_configs_.push_back(control_config);
+}
+
+void CandidateSessionConfig::AddEventConfig(
+    const ChannelConfig& event_config) {
+  event_configs_.push_back(event_config);
+}
+
+void CandidateSessionConfig::AddVideoConfig(
+    const ChannelConfig& video_config) {
+  video_configs_.push_back(video_config);
+}
+
+void CandidateSessionConfig::SetInitialResolution(
+    const ScreenResolution& resolution) {
+  initial_resolution_ = resolution;
+}
+
+SessionConfig* CandidateSessionConfig::Select(
+    const CandidateSessionConfig* client_config,
+    bool force_host_resolution) {
+  ChannelConfig control_config;
+  ChannelConfig event_config;
+  ChannelConfig video_config;
+  if (!SelectCommonChannelConfig(
+          control_configs_, client_config->control_configs_, &control_config) ||
+      !SelectCommonChannelConfig(
+          event_configs_, client_config->event_configs_, &event_config) ||
+      !SelectCommonChannelConfig(
+          video_configs_, client_config->video_configs_, &video_config)) {
+    return NULL;
+  }
+
+  SessionConfig* result = SessionConfig::CreateDefault();
+  result->SetControlConfig(control_config);
+  result->SetEventConfig(event_config);
+  result->SetVideoConfig(video_config);
+
+  if (force_host_resolution) {
+    result->SetInitialResolution(initial_resolution());
+  } else {
+    result->SetInitialResolution(client_config->initial_resolution());
+  }
+
+  return result;
+}
+
+bool CandidateSessionConfig::IsSupported(
+    const SessionConfig* config) const {
+  return
+      IsChannelConfigSupported(control_configs_, config->control_config()) &&
+      IsChannelConfigSupported(event_configs_, config->event_config()) &&
+      IsChannelConfigSupported(video_configs_, config->video_config()) &&
+      config->initial_resolution().IsValid();
+}
+
+SessionConfig* CandidateSessionConfig::GetFinalConfig() const {
+  if (control_configs_.size() != 1 ||
+      event_configs_.size() != 1 ||
+      video_configs_.size() != 1) {
+    return NULL;
+  }
+
+  SessionConfig* result = SessionConfig::CreateDefault();
+  result->SetControlConfig(control_configs_.front());
+  result->SetEventConfig(event_configs_.front());
+  result->SetVideoConfig(video_configs_.front());
+  result->SetInitialResolution(initial_resolution_);
+  return result;
+}
+
+// static
+bool CandidateSessionConfig::SelectCommonChannelConfig(
+    const std::vector<ChannelConfig>& host_configs,
+    const std::vector<ChannelConfig>& client_configs,
+    ChannelConfig* config) {
+  // Usually each of these vectors will contain just several elements,
+  // so iterating over all of them is not a problem.
+  std::vector<ChannelConfig>::const_iterator it;
+  for (it = client_configs.begin(); it != client_configs.end(); ++it) {
+    if (IsChannelConfigSupported(host_configs, *it)) {
+      *config = *it;
+      return true;
+    }
+  }
+  return false;
+}
+
+// static
+bool CandidateSessionConfig::IsChannelConfigSupported(
+    const std::vector<ChannelConfig>& vector,
+    const ChannelConfig& value) {
+  return std::find(vector.begin(), vector.end(), value) != vector.end();
+}
+
+CandidateSessionConfig* CandidateSessionConfig::Clone() const {
+  return new CandidateSessionConfig(*this);
+}
+
+// static
+CandidateSessionConfig* CandidateSessionConfig::CreateEmpty() {
+  return new CandidateSessionConfig();
+}
+
+// static
+CandidateSessionConfig* CandidateSessionConfig::CreateFrom(
+    const SessionConfig* config) {
+  CandidateSessionConfig* result = CreateEmpty();
+  result->AddControlConfig(config->control_config());
+  result->AddEventConfig(config->event_config());
+  result->AddVideoConfig(config->video_config());
+  result->SetInitialResolution(config->initial_resolution());
+  return result;
+}
+
+// static
+CandidateSessionConfig* CandidateSessionConfig::CreateDefault() {
+  CandidateSessionConfig* result = CreateEmpty();
+  result->AddControlConfig(ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
+                                         kDefaultStreamVersion,
+                                         ChannelConfig::CODEC_UNDEFINED));
+  result->AddEventConfig(ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
+                                          kDefaultStreamVersion,
+                                          ChannelConfig::CODEC_UNDEFINED));
+
+  result->AddVideoConfig(ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
+                                       kDefaultStreamVersion,
+                                       ChannelConfig::CODEC_ZIP));
+  result->AddVideoConfig(ChannelConfig(ChannelConfig::TRANSPORT_SRTP,
+                                       kDefaultStreamVersion,
+                                       ChannelConfig::CODEC_VP8));
+  return result;
+}
+
+}  // namespace protocol
+}  // namespace remoting