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 119 matching lines @@
 base::LazyInstance<scoped_refptr<base::SingleThreadTaskRunner> >::Leaky
     g_logging_task_runner = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<base::WeakPtr<ChromotingInstance> >::Leaky
     g_logging_instance = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<base::Lock>::Leaky
     g_logging_lock = LAZY_INSTANCE_INITIALIZER;
 logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 }  // namespace
 
-// String sent in the "hello" message to the plugin to describe features.
+// String sent in the "hello" message to the webapp 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);
+  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.
+    if (data->HasKey("capabilities")) {
+      if (!data->GetString("capabilities", &config.capabilities)) {
+        LOG(ERROR) << "Invalid connect() data.";
+        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