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

remoting/webapp/client_session.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 handling creation and teardown of a remoting client session.
  *
  * The ClientSession class controls lifetime of the client plugin
  * object and provides the plugin with the functionality it needs to
@@ skipping 210 matching lines @@
     remoting.ClientSession.ConnectionError.NONE;
 
 /**
  * The id of the client plugin
  *
  * @const
  */
 remoting.ClientSession.prototype.PLUGIN_ID = 'session-client-plugin';
 
 /**
+ * Set of capabilities for which hasCapability_() can be used to test.
+ *
+ * @enum {string}
+ */
+remoting.ClientSession.Capability = {
+  ALWAYS_RESIZE_TO_CLIENT: 'alwaysResizeToClient'
+};
+
+/**
+ * The set of capabilities negotiated between the client and host.
+ * @type {!Array.<string>}

[Jamie, 2013/04/15 22:14:11]

You've declared this type as being never null, then defaulted it to null. You
also have null checks elsewhere. I think defaulting to [] would be better, in
which case you can probably lose the null checks.

[alexeypa (please no reviews), 2013/04/15 23:18:53]

Done.

+ * @private
+ */
+remoting.ClientSession.prototype.capabilities_ = null;
+
+/**
+ * @param {remoting.ClientSession.Capability} capability The capability to test
+ *     for.
+ * @return {boolean} True if the capability has been negotiated between
+ *     the client and host.
+ * @private
+ */
+remoting.ClientSession.prototype.hasCapability_ = function(capability) {
+  if (this.capabilities_ == null)
+    return false;
+
+  return this.capabilities_.indexOf(capability) > -1;
+};
+
+/**
  * @param {Element} container The element to add the plugin to.
  * @param {string} id Id to use for the plugin element .
  * @return {remoting.ClientPlugin} Create plugin object for the locally
  * installed plugin.
  */
 remoting.ClientSession.prototype.createClientPlugin_ = function(container, id) {
   var plugin = /** @type {remoting.ViewerPlugin} */
       document.createElement('embed');
 
   plugin.id = id;
@@ skipping 121 matching lines @@
   this.plugin.onDebugMessageHandler = function(msg) {
     console.log('plugin: ' + msg);
   };
 
   this.plugin.onConnectionStatusUpdateHandler =
       this.onConnectionStatusUpdate_.bind(this);
   this.plugin.onConnectionReadyHandler =
       this.onConnectionReady_.bind(this);
   this.plugin.onDesktopSizeUpdateHandler =
       this.onDesktopSizeChanged_.bind(this);
+  this.plugin.onSetCapabilitiesHandler =
+      this.onSetCapabilities_.bind(this);
 
   this.connectPluginToWcs_();
 };
 
 /**
  * Deletes the <embed> element from the container, without sending a
  * session_terminate request.  This is to be called when the session was
  * disconnected by the Host.
  *
  * @return {void} Nothing.
@@ skipping 172 matching lines @@
   if (event.target == this.shrinkToFitButton_) {
     shrinkToFit = !shrinkToFit;
   }
   if (event.target == this.resizeToClientButton_) {
     resizeToClient = !resizeToClient;
   }
   this.setScreenMode_(shrinkToFit, resizeToClient);
 };
 
 /**
+ * @return {boolean} True if resize-to-client is enabled.
+ * @private
+ */
+remoting.ClientSession.prototype.isResizingToClient_ = function() {
+  return this.resizeToClient_ || this.hasCapability_(
+      remoting.ClientSession.Capability.ALWAYS_RESIZE_TO_CLIENT);
+}
+
+/**
  * Set the shrink-to-fit and resize-to-client flags and save them if this is
  * a Me2Me connection.
  *
  * @param {boolean} shrinkToFit True if the remote desktop should be scaled
  *     down if it is larger than the client window; false if scroll-bars
  *     should be added in this case.
  * @param {boolean} resizeToClient True if window resizes should cause the
  *     host to attempt to resize its desktop to match the client window size;
  *     false to disable this behaviour for subsequent window resizes--the
  *     current host desktop size is not restored in this case.
  * @return {void} Nothing.
  * @private
  */
 remoting.ClientSession.prototype.setScreenMode_ =
     function(shrinkToFit, resizeToClient) {
-  if (resizeToClient && !this.resizeToClient_) {
+  if (resizeToClient && !this.isResizingToClient_()) {
     this.plugin.notifyClientResolution(window.innerWidth,
                                        window.innerHeight,
                                        window.devicePixelRatio);
   }
 
   // If enabling shrink, reset bump-scroll offsets.
   var needsScrollReset = shrinkToFit && !this.shrinkToFit_;
 
   this.shrinkToFit_ = shrinkToFit;
   this.resizeToClient_ = resizeToClient;
@@ skipping 137 matching lines @@
  *
  * @private
  * @param {number} status The plugin's status.
  * @param {number} error The plugin's error state, if any.
  */
 remoting.ClientSession.prototype.onConnectionStatusUpdate_ =
     function(status, error) {
   if (status == remoting.ClientSession.State.CONNECTED) {
     this.setFocusHandlers_();
     this.onDesktopSizeChanged_();
-    if (this.resizeToClient_) {
+    if (this.isResizingToClient_()) {
       this.plugin.notifyClientResolution(window.innerWidth,
                                          window.innerHeight,
                                          window.devicePixelRatio);
     }
   } else if (status == remoting.ClientSession.State.FAILED) {
     this.error_ = /** @type {remoting.ClientSession.ConnectionError} */ (error);
   }
   this.setState_(/** @type {remoting.ClientSession.State} */ (status));
 };
 
 /**
  * Callback that the plugin invokes to indicate when the connection is
  * ready.
  *
  * @private
  * @param {boolean} ready True if the connection is ready.
  */
 remoting.ClientSession.prototype.onConnectionReady_ = function(ready) {
   if (!ready) {
     this.plugin.element().classList.add("session-client-inactive");
   } else {
     this.plugin.element().classList.remove("session-client-inactive");
   }
 }
 
 /**
+ * This is a callback that gets called when the plugin report capabilities
+ * negotiated with the host.
+ *
+ * @param {Array.<string>} capabilities The set of capabilities negotiated
+ *     between the client and host.
+ * @return {void} Nothing.
+ * @private
+ */
+remoting.ClientSession.prototype.onSetCapabilities_ = function(capabilities) {
+  if (this.capabilities_ != null) {
+    console.error('ERROR: onSetCapabilities_() is called more than once');
+    return;
+  }
+
+  this.capabilities_ = capabilities;
+  if (this.isResizingToClient_()) {
+    this.onDesktopSizeChanged_();
+    this.plugin.notifyClientResolution(window.innerWidth,
+                                       window.innerHeight,
+                                       window.devicePixelRatio);
+  }
+};
+
+/**
  * @private
  * @param {remoting.ClientSession.State} newState The new state for the session.
  * @return {void} Nothing.
  */
 remoting.ClientSession.prototype.setState_ = function(newState) {
   var oldState = this.state;
   this.state = newState;
   var state = this.state;
   if (oldState == remoting.ClientSession.State.CONNECTING) {
     if (this.state == remoting.ClientSession.State.CLOSED) {
@@ skipping 24 matching lines @@
 remoting.ClientSession.prototype.onResize = function() {
   this.updateDimensions();
 
   if (this.notifyClientResolutionTimer_) {
     window.clearTimeout(this.notifyClientResolutionTimer_);
     this.notifyClientResolutionTimer_ = null;
   }
 
   // Defer notifying the host of the change until the window stops resizing, to
   // avoid overloading the control channel with notifications.
-  if (this.resizeToClient_) {
+  if (this.isResizingToClient_()) {
     this.notifyClientResolutionTimer_ = window.setTimeout(
         this.plugin.notifyClientResolution.bind(this.plugin,
                                                 window.innerWidth,
                                                 window.innerHeight,
                                                 window.devicePixelRatio),
         1000);
   }
 
   // If bump-scrolling is enabled, adjust the plugin margins to fully utilize
   // the new window area.
@@ skipping 311 matching lines @@
       var lateAdjustment = 1 + (now - expected) / timeout;
       if (!that.scroll_(lateAdjustment * dx, lateAdjustment * dy)) {
         that.bumpScrollTimer_ = window.setTimeout(
             function() { repeatScroll(now + timeout); },
             timeout);
       }
     };
     repeatScroll(new Date().getTime());
   }
 };