Add a per-host desktopScale option, available via the JS console.

remoting/webapp/crd/js/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 111 matching lines @@
   /** @private */
   this.sessionId_ = '';
   /** @type {remoting.ClientPlugin}
     * @private */
   this.plugin_ = null;
   /** @private */
   this.shrinkToFit_ = true;
   /** @private */
   this.resizeToClient_ = true;
   /** @private */
+  this.desktopScale_ = 1.0;
+  /** @private */
   this.remapKeys_ = '';
   /** @private */
   this.hasReceivedFrame_ = false;
   this.logToServer = new remoting.LogToServer(signalStrategy, mode);
 
   /** @private */
   this.signalStrategy_ = signalStrategy;
   base.debug.assert(this.signalStrategy_.getState() ==
                     remoting.SignalStrategy.State.CONNECTED);
   this.signalStrategy_.setIncomingStanzaCallback(
@@ skipping 228 matching lines @@
 remoting.ClientSession.STATS_KEY_CAPTURE_LATENCY = 'captureLatency';
 remoting.ClientSession.STATS_KEY_ENCODE_LATENCY = 'encodeLatency';
 remoting.ClientSession.STATS_KEY_DECODE_LATENCY = 'decodeLatency';
 remoting.ClientSession.STATS_KEY_RENDER_LATENCY = 'renderLatency';
 remoting.ClientSession.STATS_KEY_ROUNDTRIP_LATENCY = 'roundtripLatency';
 
 // Keys for per-host settings.
 remoting.ClientSession.KEY_REMAP_KEYS = 'remapKeys';
 remoting.ClientSession.KEY_RESIZE_TO_CLIENT = 'resizeToClient';
 remoting.ClientSession.KEY_SHRINK_TO_FIT = 'shrinkToFit';
+remoting.ClientSession.KEY_DESKTOP_SCALE = 'desktopScale';
 
 /**
  * Set of capabilities for which hasCapability_() can be used to test.
  *
  * @enum {string}
  */
 remoting.ClientSession.Capability = {
   // When enabled this capability causes the client to send its screen
   // resolution to the host once connection has been established. See
   // this.plugin_.notifyClientResolution().
@@ skipping 105 matching lines @@
           'boolean') {
     this.resizeToClient_ = /** @type {boolean} */
         options[remoting.ClientSession.KEY_RESIZE_TO_CLIENT];
   }
   if (remoting.ClientSession.KEY_SHRINK_TO_FIT in options &&
       typeof(options[remoting.ClientSession.KEY_SHRINK_TO_FIT]) ==
           'boolean') {
     this.shrinkToFit_ = /** @type {boolean} */
         options[remoting.ClientSession.KEY_SHRINK_TO_FIT];
   }
+  if (remoting.ClientSession.KEY_DESKTOP_SCALE in options &&
+      typeof(options[remoting.ClientSession.KEY_DESKTOP_SCALE]) ==
+          'number') {
+    this.desktopScale_ = /** @type {number} */
+        options[remoting.ClientSession.KEY_DESKTOP_SCALE];
+  }
 
   /** @param {boolean} result */
   this.plugin_.initialize(this.onPluginInitialized_.bind(this));
 };
 
 /**
  * Constrains the focus to the plugin element.
  * @private
  */
 remoting.ClientSession.prototype.setFocusHandlers_ = function() {
@@ skipping 250 matching lines @@
  * Sends a Print Screen keypress to the remoting client.
  *
  * @return {void} Nothing.
  */
 remoting.ClientSession.prototype.sendPrintScreen = function() {
   console.log('Sending Print Screen.');
   this.sendKeyCombination_([0x070046]);
 }
 
 /**
+ * Sets and stores the scale factor to apply to host sizing requests.
+ * The desktopScale applies to the dimensions reported to the host, not
+ * to the client DPI reported to it.
+ *
+ * @param {number} desktopScale Scale factor to apply.
+ */
+remoting.ClientSession.prototype.setDesktopScale =
+    function(desktopScale) {

[Jamie, 2014/12/15 23:18:55]

Nit: Looks like this will fit on the previous line.

+  this.desktopScale_ = desktopScale;
+
+  // onResize() will update the plugin size and scrollbars for the new
+  // scaled plugin dimensions, and send a client resolution notification.
+  this.onResize();
+
+  // Save the new desktop scale setting.
+  var options = {};
+  options[remoting.ClientSession.KEY_DESKTOP_SCALE] = this.desktopScale_;
+  remoting.HostSettings.save(this.hostId_, options);
+}
+
+/**
  * Sets and stores the key remapping setting for the current host.
  *
  * @param {string} remappings Comma separated list of key remappings.
  */
 remoting.ClientSession.prototype.setRemapKeys = function(remappings) {
   // Cancel any existing remappings and apply the new ones.
   this.applyRemapKeys_(false);
   this.remapKeys_ = remappings;
   this.applyRemapKeys_(true);
 
@@ skipping 50 matching lines @@
  *     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.
  */
 remoting.ClientSession.prototype.setScreenMode =
     function(shrinkToFit, resizeToClient) {
   if (resizeToClient && !this.resizeToClient_) {
-    var clientArea = this.getClientArea_();
-    this.plugin_.notifyClientResolution(clientArea.width,
-                                        clientArea.height,
-                                        window.devicePixelRatio);
+    this.notifyClientResolution_();
   }
 
   // If enabling shrink, reset bump-scroll offsets.
   var needsScrollReset = shrinkToFit && !this.shrinkToFit_;
 
   this.shrinkToFit_ = shrinkToFit;
   this.resizeToClient_ = resizeToClient;
   this.updateScrollbarVisibility();
 
   if (this.hostId_ != '') {
@@ skipping 142 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_) {
-      var clientArea = this.getClientArea_();
-      this.plugin_.notifyClientResolution(clientArea.width,
-                                          clientArea.height,
-                                          window.devicePixelRatio);
+      this.notifyClientResolution_();
     }
     // Activate full-screen related UX.
     remoting.fullscreen.addListener(this.callOnFullScreenChanged_);
     this.updateClientSessionUi_(this);
     this.container_.addEventListener('mousemove',
                                      this.updateMouseCursorPosition_,
                                      true);
 
   } else if (status == remoting.ClientSession.State.FAILED) {
     switch (error) {
@@ skipping 72 matching lines @@
  */
 remoting.ClientSession.prototype.onSetCapabilities_ = function(capabilities) {
   if (this.capabilities_ != null) {
     console.error('onSetCapabilities_() is called more than once');
     return;
   }
 
   this.capabilities_ = capabilities;
   if (this.hasCapability_(
       remoting.ClientSession.Capability.SEND_INITIAL_RESOLUTION)) {
-    var clientArea = this.getClientArea_();
-    this.plugin_.notifyClientResolution(clientArea.width,
-                                        clientArea.height,
-                                        window.devicePixelRatio);
+    this.notifyClientResolution_();
   }
   if (this.hasCapability_(remoting.ClientSession.Capability.GOOGLE_DRIVE)) {
     this.sendGoogleDriveAccessToken_();
   }
   if (this.hasCapability_(
       remoting.ClientSession.Capability.VIDEO_RECORDER)) {
     this.videoFrameRecorder_ = new remoting.VideoFrameRecorder(this.plugin_);
   }
 };
 
@@ skipping 48 matching lines @@
   // Defer notifying the host of the change until the window stops resizing, to
   // avoid overloading the control channel with notifications.
   if (this.resizeToClient_) {
     var kResizeRateLimitMs = 1000;
     if (this.hasCapability_(
         remoting.ClientSession.Capability.RATE_LIMIT_RESIZE_REQUESTS)) {
       kResizeRateLimitMs = 250;
     }
     var clientArea = this.getClientArea_();
     this.notifyClientResolutionTimer_ = window.setTimeout(
-        this.plugin_.notifyClientResolution.bind(this.plugin_,
-                                                 clientArea.width,
-                                                 clientArea.height,
-                                                 window.devicePixelRatio),
+        this.notifyClientResolution_.bind(this),
         kResizeRateLimitMs);
   }
 
   // If bump-scrolling is enabled, adjust the plugin margins to fully utilize
   // the new window area.
   this.resetScroll_();
 
   this.updateScrollbarVisibility();
 };
 
@@ skipping 87 matching lines @@
   // We specify the plugin dimensions in Density-Independent Pixels, so to
   // render pixel-for-pixel we need to down-scale the host dimensions by the
   // devicePixelRatio of the client. To match the host pixel density, we choose
   // an initial scale factor based on the client devicePixelRatio and host DPI.
 
   // Determine the effective device pixel ratio of the host, based on DPI.
   var hostPixelRatioX = Math.ceil(this.plugin_.getDesktopXDpi() / 96);
   var hostPixelRatioY = Math.ceil(this.plugin_.getDesktopYDpi() / 96);
   var hostPixelRatio = Math.min(hostPixelRatioX, hostPixelRatioY);
 
+  // Include the desktopScale in the hostPixelRatio before comparing it with
+  // the client devicePixelRatio to determine the "natural" scale to use.
+  hostPixelRatio *= this.desktopScale_;
+
   // Down-scale by the smaller of the client and host ratios.
   var scale = 1.0 / Math.min(window.devicePixelRatio, hostPixelRatio);
 
   if (this.shrinkToFit_) {
     // Reduce the scale, if necessary, to fit the whole desktop in the window.
     var scaleFitWidth = Math.min(scale, 1.0 * clientArea.width / desktopWidth);
     var scaleFitHeight =
         Math.min(scale, 1.0 * clientArea.height / desktopHeight);
     scale = Math.min(scaleFitHeight, scaleFitWidth);
 
@@ skipping 326 matching lines @@
  *     borders used by the latter.
  * @private
  */
 remoting.ClientSession.prototype.getClientArea_ = function() {
   return remoting.windowFrame ?
       remoting.windowFrame.getClientArea() :
       { 'width': window.innerWidth, 'height': window.innerHeight };
 };
 
 /**
+ * Notifies the host of the client's current dimensions and DPI.
+ * Also takes into account per-host scaling factor, if configured.
+ * @private
+ */
+remoting.ClientSession.prototype.notifyClientResolution_ = function() {
+  var clientArea = this.getClientArea_();
+  this.plugin_.notifyClientResolution(clientArea.width * this.desktopScale_,
+                                      clientArea.height * this.desktopScale_,
+                                      window.devicePixelRatio);
+}
+
+/**
  * @param {string} url
  * @param {number} hotspotX
  * @param {number} hotspotY
  */
 remoting.ClientSession.prototype.updateMouseCursorImage_ =
     function(url, hotspotX, hotspotY) {
   this.mouseCursorOverlay_.hidden = !url;
   if (url) {
     this.mouseCursorOverlay_.style.marginLeft = '-' + hotspotX + 'px';
     this.mouseCursorOverlay_.style.marginTop = '-' + hotspotY + 'px';
@@ skipping 85 matching lines @@
  * @param {string} data Contents of the extension message.
  * @return {boolean} True if the message was recognized, false otherwise.
  */
 remoting.ClientSession.prototype.handleExtensionMessage =
     function(type, data) {
   if (this.videoFrameRecorder_) {
     return this.videoFrameRecorder_.handleMessage(type, data);
   }
   return false;
 }