[Checkstyle] Fix misc style issues in Java files.

remoting/android/java/src/org/chromium/chromoting/TrackingInputHandler.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.view.GestureDetector;
@@ skipping 103 matching lines @@
         synchronized (mRenderData) {
             // Constrain cursor to the image area.
             if (newX < 0) newX = 0;
             if (newY < 0) newY = 0;
             if (newX > mRenderData.imageWidth) newX = mRenderData.imageWidth;
             if (newY > mRenderData.imageHeight) newY = mRenderData.imageHeight;
             mCursorPosition.set(newX, newY);
             repositionImage();
         }
 
-        mViewer.injectMouseEvent((int)newX, (int)newY, BUTTON_UNDEFINED, false);
+        mViewer.injectMouseEvent((int) newX, (int) newY, BUTTON_UNDEFINED, false);
     }
 
     /**
      * Repositions the image by translating it (without affecting the zoom level) to place the
      * cursor close to the center of the screen.
      */
     private void repositionImage() {
         synchronized (mRenderData) {
             // Get the current cursor position in screen coordinates.
             float[] cursorScreen = {mCursorPosition.x, mCursorPosition.y};
             mRenderData.transform.mapPoints(cursorScreen);
 
             // Translate so the cursor is displayed in the middle of the screen.
             mRenderData.transform.postTranslate(
-                    (float)mRenderData.screenWidth / 2 - cursorScreen[0],
-                    (float)mRenderData.screenHeight / 2 - cursorScreen[1]);
+                    (float) mRenderData.screenWidth / 2 - cursorScreen[0],
+                    (float) mRenderData.screenHeight / 2 - cursorScreen[1]);
 
             // Now the cursor is displayed in the middle of the screen, see if the image can be
             // panned so that more of it is visible. The primary goal is to show as much of the
             // image as possible. The secondary goal is to keep the cursor in the middle.
 
             // Get the coordinates of the desktop rectangle (top-left/bottom-right corners) in
             // screen coordinates. Order is: left, top, right, bottom.
             float[] rectScreen = {0, 0, mRenderData.imageWidth, mRenderData.imageHeight};
             mRenderData.transform.mapPoints(rectScreen);
 
@@ skipping 42 matching lines @@
                 return;
             }
 
             // Zoom out if the zoom level is too high.
             float currentZoomLevel = mRenderData.transform.mapRadius(1.0f);
             if (currentZoomLevel > MAX_ZOOM_FACTOR) {
                 mRenderData.transform.setScale(MAX_ZOOM_FACTOR, MAX_ZOOM_FACTOR);
             }
 
             // Get image size scaled to screen coordinates.
-            float[] imageSize = {(float)mRenderData.imageWidth, (float)mRenderData.imageHeight};
+            float[] imageSize = {mRenderData.imageWidth, mRenderData.imageHeight};

[Lambros, 2014/09/24 23:54:37]

Does this still compile if you remove the (float) casts here? IIRC, implicit
int->double works OK, but not sure about implicit int->float because it's lossy?

             mRenderData.transform.mapVectors(imageSize);
 
             if (imageSize[0] < mRenderData.screenWidth && imageSize[1] < mRenderData.screenHeight) {
                 // 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);
+                float scale = Math.min((float) mRenderData.screenWidth / mRenderData.imageWidth,
+                                       (float) mRenderData.screenHeight / mRenderData.imageHeight);
                 mRenderData.transform.setScale(scale, scale);
             }
 
             repositionImage();
         }
     }
 
     /** Injects a button event using the current cursor location. */
     private void injectButtonEvent(int button, boolean pressed) {
-        mViewer.injectMouseEvent((int)mCursorPosition.x, (int)mCursorPosition.y, button, pressed);
+        mViewer.injectMouseEvent((int) mCursorPosition.x, (int) mCursorPosition.y, button, pressed);
     }
 
     /** 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();
@@ skipping 50 matching lines @@
     public void onScreenConfigurationChanged() {
     }
 
     @Override
     public void onClientSizeChanged(int width, int height) {
         repositionImageWithZoom();
     }
 
     @Override
     public void onHostSizeChanged(int width, int height) {
-        moveCursor((float)width / 2, (float)height / 2);
+        moveCursor((float) width / 2, (float) height / 2);
         repositionImageWithZoom();
     }
 
     @Override
     public void processAnimation() {
         int previousX = mFlingScroller.getCurrX();
         int previousY = mFlingScroller.getCurrY();
         if (!mFlingScroller.computeScrollOffset()) {
             mViewer.setAnimationEnabled(false);
             return;
         }
         int deltaX = mFlingScroller.getCurrX() - previousX;
         int deltaY = mFlingScroller.getCurrY() - previousY;
-        float[] delta = {(float)deltaX, (float)deltaY};
+        float[] delta = {deltaX, deltaY};

[Lambros, 2014/09/24 23:54:37]

Ditto.

         synchronized (mRenderData) {
             Matrix canvasToImage = new Matrix();
             mRenderData.transform.invert(canvasToImage);
             canvasToImage.mapVectors(delta);
         }
 
         moveCursor(mCursorPosition.x + delta[0], mCursorPosition.y + delta[1]);
     }
 
     /** Responds to touch events filtered by the gesture detectors. */
     private class GestureListener extends GestureDetector.SimpleOnGestureListener
             implements ScaleGestureDetector.OnScaleGestureListener,
                        TapGestureDetector.OnTapListener {
         /**
          * Called when the user drags one or more fingers across the touchscreen.
          */
         @Override
         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
             int pointerCount = e2.getPointerCount();
             if (pointerCount == 3 && !mSwipeCompleted) {
                 // Note that distance values are reversed. For example, dragging a finger in the
                 // direction of increasing Y coordinate (downwards) results in distanceY being
                 // negative.
                 mTotalMotionY -= distanceY;
                 return onSwipe();
             }
 
             if (pointerCount == 2 && mSwipePinchDetector.isSwiping()) {
-                mViewer.injectMouseWheelDeltaEvent(-(int)distanceX, -(int)distanceY);
+                mViewer.injectMouseWheelDeltaEvent(-(int) distanceX, -(int) distanceY);
 
                 // Prevent the cursor being moved or flung by the gesture.
                 mSuppressCursorMovement = true;
                 return true;
             }
 
             if (pointerCount != 1 || mSuppressCursorMovement) {
                 return false;
             }
 
@@ skipping 21 matching lines @@
             }
 
             // The fling physics calculation is based on screen coordinates, so that it will
             // behave consistently at different zoom levels (and will work nicely at high zoom
             // levels, since |mFlingScroller| outputs integer coordinates). However, the desktop
             // will usually be panned as the cursor is moved across the desktop, which means the
             // transformation mapping from screen to desktop coordinates will change. To deal with
             // this, the cursor movement is computed from relative coordinate changes from
             // |mFlingScroller|. This means the fling can be started at (0, 0) with no bounding
             // constraints - the cursor is already constrained by the desktop size.
-            mFlingScroller.fling(0, 0, (int)velocityX, (int)velocityY, Integer.MIN_VALUE,
+            mFlingScroller.fling(0, 0, (int) velocityX, (int) velocityY, Integer.MIN_VALUE,
                     Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE);
             // Initialize the scroller's current offset coordinates, since they are used for
             // calculating the delta values.
             mFlingScroller.computeScrollOffset();
             mViewer.setAnimationEnabled(true);
             return true;
         }
 
         /** Called when the user is in the process of pinch-zooming. */
         @Override
@@ skipping 68 matching lines @@
         public void onLongPress(int pointerCount) {
             mHeldButton = mouseButtonFromPointerCount(pointerCount);
             if (mHeldButton != BUTTON_UNDEFINED) {
                 injectButtonEvent(mHeldButton, true);
                 mViewer.showLongPressFeedback();
                 mSuppressFling = true;
             }
         }
     }
 }