Set the initial resolution of an RDP session to the client screen resolution if it is available.

remoting/base/capabilities.cc

Index: remoting/base/capabilities.cc
diff --git a/remoting/base/capabilities.cc b/remoting/base/capabilities.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b70e3e9782b73d31dd918b93f71539605a6154fd
--- /dev/null
+++ b/remoting/base/capabilities.cc
@@ -0,0 +1,118 @@
+// Copyright 2013 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/base/capabilities.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "base/string_util.h"
+#include "base/values.h"
+#include "remoting/proto/control.pb.h"
+
+namespace remoting {
+
+namespace {
+
+bool isValidCapability(const std::string& capability) {
+  return !capability.empty() && capability.find(' ') == std::string::npos;
+}
+
+}  // namespace
+
+Capabilities::Capabilities() {
+}
+
+Capabilities::Capabilities(const std::string& value) {
+  FromString(value);
+}
+
+Capabilities::~Capabilities() {
+}
+
+bool Capabilities::HasCapability(const std::string& capability) const {
+  return capabilities_.find(capability) != capabilities_.end();
+}
+
+Capabilities Capabilities::Intersect(const Capabilities& other) const {
+  Capabilities result;
+
+  std::set<std::string>::iterator i = capabilities_.begin();
+  while (i != capabilities_.end()) {
+    if (other.HasCapability(*i))
+      result.capabilities_.insert(*i);
+    ++i;
+  }
+
+  return result;
+}
+
+bool Capabilities::FromListValue(const base::ListValue& value) {
+  std::set<std::string> capabilities;
+  for (size_t i = 0; i < value.GetSize(); ++i) {
+    std::string capability;
+    if (!value.GetString(i, &capability) || !isValidCapability(capability)) {
+      return false;
+    }
+
+    capabilities.insert(capability);
+  }
+
+  capabilities_.swap(capabilities);
+  return true;
+}
+
+bool Capabilities::FromProtocolMessage(const protocol::Capabilities& message) {
+  std::set<std::string> capabilities;
+  for (int i = 0; i < message.capability_size(); ++i) {
+    if (!isValidCapability(message.capability(i)))
+      return false;
+
+    capabilities.insert(message.capability(i));
+  }
+
+  capabilities_.swap(capabilities);
+  return true;
+}
+
+void Capabilities::FromString(const std::string& value) {
+  std::vector<std::string> tokens;
+  Tokenize(value, " ", &tokens);
+
+  std::set<std::string> capabilities;
+  capabilities.insert(tokens.begin(), tokens.end());
+  capabilities_.swap(capabilities);
+}
+
+scoped_ptr<base::ListValue> Capabilities::ToListValue() const {
+  scoped_ptr<base::ListValue> value(new base::ListValue());
+
+  std::set<std::string>::const_iterator i = capabilities_.begin();
+  while (i != capabilities_.end()) {
+    value->AppendString(*i);
+    ++i;
+  }
+
+  return value.Pass();
+}
+
+scoped_ptr<protocol::Capabilities> Capabilities::ToProtocolMessage() const {
+  scoped_ptr<protocol::Capabilities> message(new protocol::Capabilities());
+
+  std::set<std::string>::const_iterator i = capabilities_.begin();
+  while (i != capabilities_.end()) {
+    *(message->add_capability()) = *i;
+    ++i;
+  }
+
+  return message.Pass();
+}
+
+std::string Capabilities::ToString() const {
+  std::vector<std::string> tokens(capabilities_.size());
+  std::copy(capabilities_.begin(), capabilities_.end(), tokens.begin());
+  return JoinString(tokens, ' ');
+}
+
+}  // namespace remoting