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

remoting/webapp/client_plugin_async.js

 // 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.
 
 /**
  * @fileoverview
  * Class that wraps low-level details of interacting with the client plugin.
  *
  * This abstracts a <embed> element and controls the plugin which does
  * the actual remoting work. It also handles differences between
@@ skipping 23 matching lines @@
   /** @param {string} message Log message. */
   this.onDebugMessageHandler = function (message) {};
   /**
    * @param {number} state The connection state.
    * @param {number} error The error code, if any.
    */
   this.onConnectionStatusUpdateHandler = function(state, error) {};
   /** @param {boolean} ready Connection ready state. */
   this.onConnectionReadyHandler = function(ready) {};
   this.onDesktopSizeUpdateHandler = function () {};
+  /** @param {!Array.<string>} capabilities The negotiated capabilities. */
+  this.onSetCapabilitiesHandler = function (capabilities) {};
   this.fetchPinHandler = function () {};
 
   /** @type {number} */
   this.pluginApiVersion_ = -1;
   /** @type {Array.<string>} */
   this.pluginApiFeatures_ = [];
   /** @type {number} */
   this.pluginApiMinVersion_ = -1;
+  /** @type {!Array.<string>} */
+  this.capabilities_ = [];
   /** @type {boolean} */
   this.helloReceived_ = false;
   /** @type {function(boolean)|null} */
   this.onInitializedCallback_ = null;
 
   /** @type {remoting.ClientSession.PerfStats} */
   this.perfStats_ = new remoting.ClientSession.PerfStats();
 
   /** @type {remoting.ClientPluginAsync} */
   var that = this;
@@ skipping 29 matching lines @@
  */
 remoting.ClientPluginAsync.prototype.handleMessage_ = function(messageStr) {
   var message = /** @type {{method:string, data:Object.<string,string>}} */
       jsonParseSafe(messageStr);
 
   if (!message || !('method' in message) || !('data' in message)) {
     console.error('Received invalid message from the plugin: ' + messageStr);
     return;
   }
 
+  /**
+   * Splits a string into a list of words delimited by spaces.
+   * @param {string} str String that should be split.
+   * @return {!Array.<string>} List of words.
+   */
+  var tokenize = function(str) {
+    /** @type {Array.<string>} */
+    var tokens = str.match(/\S+/g);

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

would it be better to use .split(" ") here? at least it would be more readable?

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

Nope. "".split(" ") returns [""] while we want []. It does not handle well
multiple consecutive spaces too.

+    return tokens ? tokens : [];
+  };
+
   if (message.method == 'hello') {
     // Reset the size in case we had to enlarge it to support click-to-play.
     this.plugin.width = 0;
     this.plugin.height = 0;
     if (typeof message.data['apiVersion'] != 'number' ||
         typeof message.data['apiMinVersion'] != 'number') {
       console.error('Received invalid hello message: ' + messageStr);
       return;
     }
     this.pluginApiVersion_ = /** @type {number} */ message.data['apiVersion'];
+
+    // Negotiate capabilities.
+    if (this.pluginApiVersion_ >= 8) {

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

For new versions we normally use apiFeatures property, so there is no need to
increase API version here (We should actually remove API version - it doesn't
make sense anymore). But in this case you don't even need new apiFeature - you
can check the presence of the attributes to detect support for capabilities.

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

Done.

+      if (typeof message.data['requestedCapabilities'] != 'string' ||
+          typeof message.data['supportedCapabilities'] != 'string') {
+        console.error('Received invalid hello message: ' + messageStr);
+        return;
+      }
+
+      /** @type {!Array.<string>} */
+      var requestedCapabilities =
+          tokenize(message.data['requestedCapabilities']);
+
+      /** @type {!Array.<string>} */
+      var supportedCapabilities =
+          tokenize(message.data['supportedCapabilities']);
+
+      // At the moment the webapp does not recognize any of
+      // 'requestedCapabilities' capabilities (so they all should be disabled)
+      // and do not care about any of 'supportedCapabilities' capabilities (so
+      // they all can be enabled).
+      if (supportedCapabilities)
+        this.capabilities_ = supportedCapabilities;
+
+      // Let the host know that the webapp can be requested to always send
+      // the client's dimensions.
+      this.capabilities_.push(
+          remoting.ClientSession.Capability.SEND_INITIAL_RESOLUTION);
+    }
+
     if (this.pluginApiVersion_ >= 7) {
       if (typeof message.data['apiFeatures'] != 'string') {
         console.error('Received invalid hello message: ' + messageStr);
         return;
       }
       this.pluginApiFeatures_ =
-          /** @type {Array.<string>} */ message.data['apiFeatures'].split(' ');
+          /** @type {Array.<string>} */ tokenize(message.data['apiFeatures']);
     } else if (this.pluginApiVersion_ >= 6) {
       this.pluginApiFeatures_ = ['highQualityScaling', 'injectKeyEvent'];
     } else {
       this.pluginApiFeatures_ = ['highQualityScaling'];
     }
     this.pluginApiMinVersion_ =
         /** @type {number} */ message.data['apiMinVersion'];
     this.helloReceived_ = true;
     if (this.onInitializedCallback_ != null) {
       this.onInitializedCallback_(true);
@@ skipping 73 matching lines @@
     }
   } else if (message.method == 'onConnectionReady') {
     if (typeof message.data['ready'] != 'boolean') {
       console.error('Received incorrect onConnectionReady message.');
       return;
     }
     var ready = /** @type {boolean} */ message.data['ready'];
     this.onConnectionReadyHandler(ready);
   } else if (message.method == 'fetchPin') {
     this.fetchPinHandler();
+  } else if (message.method == 'setCapabilities') {
+    if (typeof message.data['capabilities'] != 'string') {
+      console.error('Received incorrect setCapabilities message.');
+      return;
+    }
+
+    /** @type {!Array.<string>} */
+    var capabilities = tokenize(message.data['capabilities']);
+    this.onSetCapabilitiesHandler(capabilities);
   }
 };
 
 /**
  * Deletes the plugin.
  */
 remoting.ClientPluginAsync.prototype.cleanup = function() {
   this.plugin.parentNode.removeChild(this.plugin);
 };
 
@@ skipping 78 matching lines @@
 remoting.ClientPluginAsync.prototype.connect = function(
     hostJid, hostPublicKey, localJid, sharedSecret,
     authenticationMethods, authenticationTag) {
   this.plugin.postMessage(JSON.stringify(
     { method: 'connect', data: {
         hostJid: hostJid,
         hostPublicKey: hostPublicKey,
         localJid: localJid,
         sharedSecret: sharedSecret,
         authenticationMethods: authenticationMethods,
-        authenticationTag: authenticationTag
+        authenticationTag: authenticationTag,
+        capabilities: this.capabilities_
       }
     }));
 };
 
 /**
  * Release all currently pressed keys.
  */
 remoting.ClientPluginAsync.prototype.releaseAllKeys = function() {
   this.plugin.postMessage(JSON.stringify(
       { method: 'releaseAllKeys', data: {} }));
@@ skipping 156 matching lines @@
     this.plugin.width = width;
     this.plugin.height = height;
     // Center the plugin just underneath the "Connnecting..." dialog.
     var parentNode = this.plugin.parentNode;
     var dialog = document.getElementById('client-dialog');
     var dialogRect = dialog.getBoundingClientRect();
     parentNode.style.top = (dialogRect.bottom + 16) + 'px';
     parentNode.style.left = (window.innerWidth - width) / 2 + 'px';
   }
 };