[Remoting Android] Remove Synchronizations on RenderData

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

 // Copyright 2013 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.content.Context;
 import android.graphics.Matrix;
 import android.graphics.PointF;
 import android.graphics.Rect;
@@ skipping 86 matching lines @@
      * This class implements fling animation for cursor
      */
     private class CursorAnimationJob extends FlingAnimationJob {
         public CursorAnimationJob(Context context) {
             super(context);
         }
 
         @Override
         protected void processAction(float deltaX, float deltaY) {
             float[] delta = {deltaX, deltaY};
-            synchronized (mRenderData) {
-                Matrix canvasToImage = new Matrix();
-                mRenderData.transform.invert(canvasToImage);
-                canvasToImage.mapVectors(delta);
-            }
+            Matrix canvasToImage = new Matrix();
+            mRenderData.transform.invert(canvasToImage);
+            canvasToImage.mapVectors(delta);
 
             moveViewportByOffset(-delta[0], -delta[1]);
         }
     }
 
     /**
      * This class implements fling animation for scrolling
      */
     private class ScrollAnimationJob extends FlingAnimationJob {
         public ScrollAnimationJob(Context context) {
@@ skipping 171 matching lines @@
                 // Unreachable, but required by Google Java style and findbugs.
                 assert false : "Unreached";
         }
 
         // Ensure the cursor state is updated appropriately.
         mViewer.cursorVisibilityChanged();
     }
 
     private void handleSystemUiVisibilityChanged(
             SystemUiVisibilityChangedEventParameter parameter) {
-        synchronized (mRenderData) {
-            if (parameter.softInputMethodVisible) {
-                mDesktopCanvas.setSystemUiOffsetValues(parameter.left, parameter.top,
-                        mRenderData.screenWidth - parameter.right,
-                        mRenderData.screenHeight - parameter.bottom);
-            } else {
-                mDesktopCanvas.setSystemUiOffsetValues(0, 0, 0, 0);
-            }
+        if (parameter.softInputMethodVisible) {
+            mDesktopCanvas.setSystemUiOffsetValues(parameter.left, parameter.top,
+                    mRenderData.screenWidth - parameter.right,
+                    mRenderData.screenHeight - parameter.bottom);
+        } else {
+            mDesktopCanvas.setSystemUiOffsetValues(0, 0, 0, 0);
         }
 
         mDesktopCanvas.repositionImage(true);
     }
 
     private boolean handleTouchEvent(MotionEvent event) {
         // Give the underlying input strategy a chance to observe the current motion event before
         // passing it to the gesture detectors.  This allows the input strategy to react to the
         // event or save the payload for use in recreating the gesture remotely.
         mInputStrategy.onMotionEvent(event);
@@ skipping 29 matching lines @@
                 mEdgeSlopInPx, mEdgeSlopInPx, width - mEdgeSlopInPx, height - mEdgeSlopInPx);
         resizeImageToFitScreen();
     }
 
     private void handleHostSizeChanged(int width, int height) {
         resizeImageToFitScreen();
     }
 
     private void resizeImageToFitScreen() {
         mDesktopCanvas.resizeImageToFitScreen();
-        float screenCenterX;
-        float screenCenterY;
-        synchronized (mRenderData) {
-            screenCenterX = (float) mRenderData.screenWidth / 2;
-            screenCenterY = (float) mRenderData.screenHeight / 2;
 
-            float[] imagePoint = mapScreenPointToImagePoint(screenCenterX, screenCenterY);
-            mDesktopCanvas.setViewportPosition(imagePoint[0], imagePoint[1]);
-        }
+        float screenCenterX = (float) mRenderData.screenWidth / 2;
+        float screenCenterY = (float) mRenderData.screenHeight / 2;
+
+        float[] imagePoint = mapScreenPointToImagePoint(screenCenterX, screenCenterY);
+        mDesktopCanvas.setViewportPosition(imagePoint[0], imagePoint[1]);
+
         moveCursorToScreenPoint(screenCenterX, screenCenterY);
         mDesktopCanvas.repositionImage(true);
     }
 
     private void setInputStrategy(InputStrategyInterface inputStrategy) {
         // Since the rules for flinging differ between input modes, we want to stop running the
         // current fling animation when the mode changes to prevent a wonky experience.
         mCursorAnimationJob.abortAnimation();
         mScrollAnimationJob.abortAnimation();
         mInputStrategy = inputStrategy;
@@ skipping 24 matching lines @@
     }
 
     /** Moves the cursor to the specified position on the screen. */
     private void moveCursorToScreenPoint(float screenX, float screenY) {
         float[] imagePoint = mapScreenPointToImagePoint(screenX, screenY);
         moveCursor(imagePoint[0], imagePoint[1]);
     }
 
     /** Moves the cursor to the specified position on the remote host. */
     private void moveCursor(float newX, float newY) {
-        synchronized (mRenderData) {
-            boolean cursorMoved = mRenderData.setCursorPosition(newX, newY);
-            if (cursorMoved) {
-                mInputStrategy.injectCursorMoveEvent((int) newX, (int) newY);
-            }
+        boolean cursorMoved = mRenderData.setCursorPosition(newX, newY);
+        if (cursorMoved) {
+            mInputStrategy.injectCursorMoveEvent((int) newX, (int) newY);
         }
+
         mViewer.cursorMoved();
     }
 
     /** Processes a (multi-finger) swipe gesture. */
     private boolean onSwipe() {
         if (mTotalMotionY > mSwipeThreshold) {
             // Swipe down occurred.
             mViewer.showActionBar();
         } else if (mTotalMotionY < -mSwipeThreshold) {
             // Swipe up occurred.
             mViewer.showKeyboard();
         } else {
             return false;
         }
 
         mSuppressCursorMovement = true;
         mSuppressFling = true;
         mSwipeCompleted = true;
         return true;
     }
 
     /** Translates a point in screen coordinates to a location on the desktop image. */
     private float[] mapScreenPointToImagePoint(float screenX, float screenY) {
         float[] mappedPoints = {screenX, screenY};
         Matrix screenToImage = new Matrix();
-        synchronized (mRenderData) {
-            mRenderData.transform.invert(screenToImage);
-        }
+
+        mRenderData.transform.invert(screenToImage);
+
         screenToImage.mapPoints(mappedPoints);
 
         return mappedPoints;
     }
 
     /** Responds to touch events filtered by the gesture detectors. */
     private class GestureListener extends GestureDetector.SimpleOnGestureListener
             implements ScaleGestureDetector.OnScaleGestureListener,
                        TapGestureDetector.OnTapListener {
         /**
@@ skipping 31 matching lines @@
                 mSuppressCursorMovement = true;
                 mScrollFling = true;
                 return true;
             }
 
             if (pointerCount != 1 || mSuppressCursorMovement) {
                 return false;
             }
 
             float[] delta = {distanceX, distanceY};
-            synchronized (mRenderData) {
-                Matrix canvasToImage = new Matrix();
-                mRenderData.transform.invert(canvasToImage);
-                canvasToImage.mapVectors(delta);
-            }
+
+            Matrix canvasToImage = new Matrix();
+            mRenderData.transform.invert(canvasToImage);
+            canvasToImage.mapVectors(delta);
 
             moveViewportByOffset(delta[0], delta[1]);
             if (!mInputStrategy.isIndirectInputMode() && mIsDragging) {
                 // Ensure the cursor follows the user's finger when the user is dragging under
                 // direct input mode.
                 moveCursorToScreenPoint(e2.getX(), e2.getY());
             }
             return true;
         }
 
@@ skipping 26 matching lines @@
         }
 
         /** Called when the user is in the process of pinch-zooming. */
         @Override
         public boolean onScale(ScaleGestureDetector detector) {
             if (!mSwipePinchDetector.isPinching()) {
                 return false;
             }
 
             float scaleFactor = detector.getScaleFactor();
-            synchronized (mRenderData) {
-                mRenderData.transform.postScale(
-                        scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
-            }
+
+            mRenderData.transform.postScale(
+                    scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
+
             // For indirect input modes we want to zoom using the cursor as the focal point, for
             // direct modes we use the actual focal point of the gesture.
             mDesktopCanvas.repositionImageWithZoom(mInputStrategy.isIndirectInputMode());
 
             return true;
         }
 
         /** Called whenever a gesture starts. Always accepts the gesture so it isn't ignored. */
         @Override
         public boolean onDown(MotionEvent e) {
@@ skipping 24 matching lines @@
             }
 
             if (!mInputStrategy.isIndirectInputMode()) {
                 if (screenPointLiesOutsideImageBoundary(x, y)) {
                     return false;
                 }
                 moveCursorToScreenPoint(x, y);
             }
 
             if (mInputStrategy.onTap(button)) {
-                PointF pos;
-                synchronized (mRenderData) {
-                    pos = mRenderData.getCursorPosition();
-                }
+                PointF pos = mRenderData.getCursorPosition();
+
                 mViewer.showInputFeedback(mInputStrategy.getShortPressFeedbackType(), pos);
             }
             return true;
         }
 
         /** Called when a long-press is triggered for one or more fingers. */
         @Override
         public void onLongPress(int pointerCount, float x, float y) {
             int button = mouseButtonFromPointerCount(pointerCount);
             if (button == InputStub.BUTTON_UNDEFINED) {
                 return;
             }
 
             if (!mInputStrategy.isIndirectInputMode()) {
                 if (screenPointLiesOutsideImageBoundary(x, y)) {
                     return;
                 }
                 moveCursorToScreenPoint(x, y);
             }
 
             if (mInputStrategy.onPressAndHold(button)) {
-                PointF pos;
-                synchronized (mRenderData) {
-                    pos = mRenderData.getCursorPosition();
-                }
+                PointF pos = mRenderData.getCursorPosition();
+
                 mViewer.showInputFeedback(mInputStrategy.getLongPressFeedbackType(), pos);
                 mSuppressFling = true;
                 mIsDragging = true;
             }
         }
 
         /** Maps the number of fingers in a tap or long-press gesture to a mouse-button. */
         private int mouseButtonFromPointerCount(int pointerCount) {
             switch (pointerCount) {
                 case 1:
                     return InputStub.BUTTON_LEFT;
                 case 2:
                     return InputStub.BUTTON_RIGHT;
                 case 3:
                     return InputStub.BUTTON_MIDDLE;
                 default:
                     return InputStub.BUTTON_UNDEFINED;
             }
         }
 
         /** Determines whether the given screen point lies outside the desktop image. */
         private boolean screenPointLiesOutsideImageBoundary(float screenX, float screenY) {
             float[] mappedPoints = mapScreenPointToImagePoint(screenX, screenY);
-            float imageWidth;
-            float imageHeight;
-            synchronized (mRenderData) {
-                imageWidth = (float) mRenderData.imageWidth + EPSILON;
-                imageHeight = (float) mRenderData.imageHeight + EPSILON;
-            }
+
+            float imageWidth = (float) mRenderData.imageWidth + EPSILON;
+            float imageHeight = (float) mRenderData.imageHeight + EPSILON;
 
             return mappedPoints[0] < -EPSILON || mappedPoints[0] > imageWidth
                     || mappedPoints[1] < -EPSILON || mappedPoints[1] > imageHeight;
         }
     }
 }