Support fractional desktopScale values in choosePluginDimensions.

remoting/webapp/base/js/viewport.js

 // Copyright 2015 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
  * Provides shared view port management utilities.
  */
 
 /** @suppress {duplicate} */
@@ skipping 45 matching lines @@
   //  4. Avoid having huge "letterboxes" around the desktop, if it's really
   //     small.
   //  5. Compensate for mismatched DPIs, so that the behaviour of features like
   //     shrink-to-fit matches their "natural" rather than their pixel size.
   //     e.g. with shrink-to-fit active a 1024x768 low-DPI host on a 640x480
   //     high-DPI client will be up-scaled to 1280x960, rather than displayed
   //     at 1:1 host:physical client pixels.
   //
   // To determine the ideal size we follow a four-stage process:
   //  1. Determine the "natural" size at which to display the desktop.
-  //    a. Initially assume 1:1 mapping of desktop to client device pixels.
+  //    a. Initially assume 1:1 mapping of desktop to client device pixels,
+  //       adjusting for the specified desktopScale.
   //    b. If host DPI is less than the client's then up-scale accordingly.
-  //    c. If desktopScale is configured for the host then allow that to
-  //       reduce the amount of up-scaling from (b). e.g. if the client:host
-  //       DPIs are 2:1 then a desktopScale of 1.5 would reduce the up-scale
-  //       to 4:3, while a desktopScale of 3.0 would result in no up-scaling.
   //  2. If the natural size of the desktop is smaller than the client device
   //     then apply up-scaling by an integer scale factor to avoid excessive
   //     letterboxing.
   //  3. If shrink-to-fit is configured then:
   //     a. If the natural size exceeds the client size then apply down-scaling
   //        by an arbitrary scale factor.
   //     b. If we're in full-screen mode and the client & host aspect-ratios
   //        are radically different (e.g. the host is actually multi-monitor)
   //        then shrink-to-fit to the shorter dimension, rather than leaving
   //        huge letterboxes; the user can then bump-scroll around the desktop.
   //  4. If the overall scale factor is fractionally over an integer factor
   //     then reduce it to that integer factor, to avoid blurring.
 
-  // All calculations are performed in device pixels.
-  var clientWidth = clientSizeDips.width * clientPixelRatio;
-  var clientHeight = clientSizeDips.height * clientPixelRatio;
+  // All calculations are performed in client device pixels, but taking into
+  // account |desktopScale|.
+  var clientWidth = clientSizeDips.width * clientPixelRatio / desktopScale;
+  var clientHeight = clientSizeDips.height * clientPixelRatio / desktopScale;
 
   // 1. Determine a "natural" size at which to display the desktop.
   var scale = 1.0;
 
   // Determine the effective host device pixel ratio.
   // Note that we round up or down to the closest integer pixel ratio.
   var hostPixelRatioX = Math.round(desktopDpi.x / 96);
   var hostPixelRatioY = Math.round(desktopDpi.y / 96);
   var hostPixelRatio = Math.min(hostPixelRatioX, hostPixelRatioY);
 
   // Allow up-scaling to account for DPI.
   scale = Math.max(scale, clientPixelRatio / hostPixelRatio);
 
-  // Allow some or all of the up-scaling to be cancelled by the desktopScale.
-  if (desktopScale > 1.0) {
-    scale = Math.max(1.0, scale / desktopScale);
-  }
-
   // 2. If the host is still much smaller than the client, then up-scale to
   //    avoid wasting space, but only by an integer factor, to avoid blurring.
   if (desktopSize.width * scale <= clientWidth &&
       desktopSize.height * scale <= clientHeight) {
     var scaleX = Math.floor(clientWidth / desktopSize.width);
     var scaleY = Math.floor(clientHeight / desktopSize.height);
     scale = Math.min(scaleX, scaleY);
     console.assert(scale >= 1.0, 'Bad scale: ' + scale + '.');
   }
 
@@ skipping 26 matching lines @@
   // 4. Avoid blurring for close-to-integer up-scaling factors.
   if (scale > 1.0) {
     var scaleBlurriness = scale / Math.floor(scale);
     if (scaleBlurriness < 1.1) {
       scale = Math.floor(scale);
     }
   }
 
   // Return the necessary plugin dimensions in DIPs.
   scale = scale / clientPixelRatio;
+  scale = scale * desktopScale;
   var pluginWidth = Math.round(desktopSize.width * scale);
   var pluginHeight = Math.round(desktopSize.height * scale);
   return { width: pluginWidth, height: pluginHeight };
 };
 
 }());