Change Viewport calculations to use screen size without System UI

remoting/android/java/src/org/chromium/chromoting/DesktopCanvas.java

 // 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.
 
 package org.chromium.chromoting;
 
 import android.graphics.Matrix;
 import android.graphics.PointF;
 import android.graphics.Rect;
 import android.graphics.RectF;
@@ skipping 69 matching lines @@
      * Sets the desired center position of the viewport.
      *
      * @param newX The new x coordinate value for the desired center position.
      * @param newY The new y coordinate value for the desired center position.
      */
     public void setViewportPosition(float newX, float newY) {
         mViewportPosition.set(newX, newY);
     }
 
     /**
-     * Returns the current size of the viewport.  This size includes the offset calculations for
-     * any visible system UI.
-     *
-     * @return A point representing the current size of the viewport.
-     */
-    private PointF getViewportSize() {
-        float adjustedScreenWidth = mRenderData.screenWidth - mSystemUiOffsetPixels.right;
-        float adjustedScreenHeight = mRenderData.screenHeight - mSystemUiOffsetPixels.bottom;
-
-        return new PointF(adjustedScreenWidth, adjustedScreenHeight);
-    }
-
-    /**
      * Returns the true center position of the viewport (in image coordinates).
      *
      * @return A point representing the true center position of the viewport.
      */
     private PointF getTrueViewportCenter() {
-        PointF viewportSize = getViewportSize();
-
         // Find the center point of the viewport on the screen.
-        float[] viewportPosition = {((float) viewportSize.x / 2), ((float) viewportSize.y / 2)};
+        float[] viewportPosition = {
+                ((float) mRenderData.screenWidth / 2), ((float) mRenderData.screenHeight / 2)};
 
         // Convert the screen position to an image position.
         Matrix screenToImage = new Matrix();
         mRenderData.transform.invert(screenToImage);
         screenToImage.mapPoints(viewportPosition);
         return new PointF(viewportPosition[0], viewportPosition[1]);
     }
 
     /**
      * Sets the offset values used to calculate the space used by system UI.
@@ skipping 27 matching lines @@
         repositionImage(false);
     }
 
     /**
      * Repositions the image by translating it (without affecting the zoom level).
      *
      * @param centerViewport Determines whether the viewport will be translated to the desired
      *                       center position before being adjusted to fit the screen boundaries.
      */
     public void repositionImage(boolean centerViewport) {
-        PointF viewportSize = getViewportSize();
         // The goal of the code below is to position the viewport as close to the desired center
         // position as possible whilst keeping as much of the desktop in view as possible.
         // To achieve these goals, we first position the desktop image at the desired center
         // point and then re-position it to maximize the viewable area.
         if (centerViewport) {
             // Map the current viewport position to screen coordinates.
             float[] viewportPosition = {mViewportPosition.x, mViewportPosition.y};
             mRenderData.transform.mapPoints(viewportPosition);
 
+            float viewportTransX = ((float) mRenderData.screenWidth / 2) - viewportPosition[0];
+            float viewportTransY = ((float) mRenderData.screenHeight / 2) - viewportPosition[1];
+
             // Translate so the viewport is displayed in the middle of the screen.
-            mRenderData.transform.postTranslate(
-                    ((float) viewportSize.x / 2) - viewportPosition[0],
-                    ((float) viewportSize.y / 2) - viewportPosition[1]);
+            mRenderData.transform.postTranslate(viewportTransX, viewportTransY);
         }
 
         // Get the coordinates of the desktop rectangle (top-left/bottom-right corners) in
         // screen coordinates. Order is: left, top, right, bottom.
         RectF rectScreen = new RectF(0, 0, mRenderData.imageWidth, mRenderData.imageHeight);
         mRenderData.transform.mapRect(rectScreen);
 
         float leftDelta = rectScreen.left;
         float rightDelta =
                 rectScreen.right - mRenderData.screenWidth + mSystemUiOffsetPixels.right;
         float topDelta = rectScreen.top;
         float bottomDelta =
                 rectScreen.bottom - mRenderData.screenHeight + mSystemUiOffsetPixels.bottom;
         float xAdjust = 0;
         float yAdjust = 0;
 
-        if (rectScreen.right - rectScreen.left < viewportSize.x) {
+        if (rectScreen.right - rectScreen.left < mRenderData.screenWidth) {
             // Image is narrower than the screen, so center it.
             xAdjust = -(rightDelta + leftDelta) / 2;
         } else if (leftDelta > 0 && rightDelta > 0) {
             // Panning the image left will show more of it.
             xAdjust = -Math.min(leftDelta, rightDelta);
         } else if (leftDelta < 0 && rightDelta < 0) {
             // Pan the image right.
             xAdjust = Math.min(-leftDelta, -rightDelta);
         }
 
         // Apply similar logic for yAdjust.
-        if (rectScreen.bottom - rectScreen.top < viewportSize.y) {
+        if (rectScreen.bottom - rectScreen.top < mRenderData.screenHeight) {
             yAdjust = -(bottomDelta + topDelta) / 2;
         } else if (topDelta > 0 && bottomDelta > 0) {
             yAdjust = -Math.min(topDelta, bottomDelta);
         } else if (topDelta < 0 && bottomDelta < 0) {
             yAdjust = Math.min(-topDelta, -bottomDelta);
         }
 
         mRenderData.transform.postTranslate(xAdjust, yAdjust);
 
         mRenderStub.setTransformation(mRenderData.transform);
@@ skipping 28 matching lines @@
             // Displayed image is too small in both directions, so apply the minimum zoom
             // level needed to fit either the width or height.
             float scale = Math.min((float) mRenderData.screenWidth / mRenderData.imageWidth,
                                    (float) mRenderData.screenHeight / mRenderData.imageHeight);
             mRenderData.transform.setScale(scale, scale);
         }
 
         repositionImage(centerViewport);
     }
 }