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

remoting/client/plugin/chromoting_instance.cc

 // 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 "remoting/client/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 121 matching lines @@
 logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 }  // namespace
 
 // String sent in the "hello" message to the plugin to describe features.
 const char ChromotingInstance::kApiFeatures[] =
     "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
     "notifyClientDimensions notifyClientResolution pauseVideo pauseAudio "
     "asyncPin thirdPartyAuth";
 
+const char ChromotingInstance::kRequestedCapabilities[] = "";
+const char ChromotingInstance::kSupportedCapabilities[] = "";
+
 bool ChromotingInstance::ParseAuthMethods(const std::string& auth_methods_str,
                                           ClientConfig* config) {
   std::vector<std::string> auth_methods;
   base::SplitString(auth_methods_str, ',', &auth_methods);
   for (std::vector<std::string>::iterator it = auth_methods.begin();
        it != auth_methods.end(); ++it) {
     protocol::AuthenticationMethod authentication_method =
         protocol::AuthenticationMethod::FromString(*it);
     if (authentication_method.is_valid())
       config->authentication_methods.push_back(authentication_method);
@@ skipping 28 matching lines @@
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 
   // Resister this instance to handle debug log messsages.
   RegisterLoggingInstance();
 
   // Send hello message.
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("apiVersion", kApiVersion);
   data->SetString("apiFeatures", kApiFeatures);
   data->SetInteger("apiMinVersion", kApiMinMessagingVersion);
+  data->SetString("requestedCapabilities", kRequestedCapabilities);

[Sergey Ulanov, 2013/04/16 08:38:53]

It's not clear to me what's the difference between these two attributes, and
client code doesn't make it clearer. Given that requestedCapabilities is ignored
by the webapp, do we need it at all?

[alexeypa (please no reviews), 2013/04/16 22:06:11]

"requested" capabilities are the ones that need to be supported by both plugin
and webapp to work. I.e. the intersection of "requested" capabilities supported
by the plugin and webapp will be sent to the host.

"supported" capabilities are the ones that do not require any special handling
in the webapp. The webapp will pass them through in most of the cases. The
reason they are passed to the webapp at all is that the latter should be able to
"veto" them in case if we need to fix anything after the client plugin has been
released. 
Declarations of both constants are documented. See chromoting_instance.h. 
We still need the webapp to be ready to handle them. We could remove them from
the plugin but it is just around five lines of code and it serves as
documentation/guidelines how the "requested" capabilities should be handled.

+  data->SetString("supportedCapabilities", kSupportedCapabilities);
+
   PostChromotingMessage("hello", data.Pass());
 }
 
 ChromotingInstance::~ChromotingInstance() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // Unregister this instance so that debug log messages will no longer be sent
   // to it. This will stop all logging in all Chromoting instances.
   UnregisterLoggingInstance();
 
@@ skipping 86 matching lines @@
                      this->AsWeakPtr());
     } else {
       std::string shared_secret;
       if (!data->GetString("sharedSecret", &shared_secret)) {
         LOG(ERROR) << "sharedSecret not specified in connect().";
         return;
       }
       config.fetch_secret_callback =
           base::Bind(&ChromotingInstance::FetchSecretFromString, shared_secret);
     }
+
+    // Read the list of capabilities, if any.
+    base::ListValue* capabilities = NULL;
+    if (data->GetList("capabilities", &capabilities)) {

[Sergey Ulanov, 2013/04/16 08:38:53]

Here capablities are represented as list, while requestedCapabilities and
supportedCapabilites are passed as strings.

[alexeypa (please no reviews), 2013/04/16 22:06:11]

Done.

+      if (!config.capabilities.FromListValue(*capabilities)) {
+        LOG(ERROR) << "capabilities are invalid in connect().";
+        return;
+      }
+    }
+
     Connect(config);
   } else if (method == "disconnect") {
     Disconnect();
   } else if (method == "incomingIq") {
     std::string iq;
     if (!data->GetString("iq", &iq)) {
       LOG(ERROR) << "Invalid onIq() data.";
       return;
     }
     OnIncomingIq(iq);
@@ skipping 161 matching lines @@
   data->SetString("scope", scope);
   PostChromotingMessage("fetchThirdPartyToken", data.Pass());
 }
 
 void ChromotingInstance::OnConnectionReady(bool ready) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetBoolean("ready", ready);
   PostChromotingMessage("onConnectionReady", data.Pass());
 }
 
+void ChromotingInstance::SetCapabilities(const std::string& capabilities) {
+  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  data->SetString("capabilities", capabilities);
+  PostChromotingMessage("setCapabilities", data.Pass());
+}
+
 void ChromotingInstance::FetchSecretFromDialog(
     const protocol::SecretFetchedCallback& secret_fetched_callback) {
   // Once the Session object calls this function, it won't continue the
   // authentication until the callback is called (or connection is canceled).
   // So, it's impossible to reach this with a callback already registered.
   DCHECK(secret_fetched_callback_.is_null());
   secret_fetched_callback_ = secret_fetched_callback;
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   PostChromotingMessage("fetchPin", data.Pass());
 }
@@ skipping 427 matching lines @@
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return host_connection_.get() &&
     (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting