Improve performance in onDraw() by creating RectF object only once.

content/public/android/java/src/org/chromium/content/browser/PopupZoomer.java

 // Copyright 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.
 
 package org.chromium.content.browser;
 
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
@@ skipping 104 matching lines @@
 
     // Since we sometimes overflow the bounds of the mViewClipRect, we need to allow scrolling.
     // Current scroll position.
     private float mPopupScrollX, mPopupScrollY;
     // Scroll bounds.
     private float mMinScrollX, mMaxScrollX;
     private float mMinScrollY, mMaxScrollY;
 
     private GestureDetector mGestureDetector;
 
+    // These bounds are computed in onDraw().

[Yaron, 2014/09/10 01:37:16]

perhaps update to say:
// These bounds are computed and valid for one execution of onDraw. Extracted to
a member variable to save unnecessary allocations on each invocation

(with appropriate line-breaks at 80 cols :)

[wajahat, 2014/09/10 11:34:52]

Done.

+    private RectF mDrawRect;
+
     private static float getOverlayCornerRadius(Context context) {
         if (sOverlayCornerRadius == 0) {
             try {
                 sOverlayCornerRadius = context.getResources().getDimension(
                         R.dimen.link_preview_overlay_radius);
             } catch (Resources.NotFoundException e) {
                 Log.w(LOGTAG, "No corner radius resource for PopupZoomer overlay found.");
                 sOverlayCornerRadius = 1.0f;
             }
         }
@@ skipping 320 matching lines @@
         // i.e. scale grows from 1/mScale to 1. Note that extrusion values are already zoomed
         // with mScale.
         float scale = fractionAnimation * (mScale - 1.0f) / mScale + 1.0f / mScale;
 
         // Since we want the content to appear directly above its counterpart on the
         // page, we need to remove the mShiftX/Y effect at the beginning of the animation.
         // The unshifting decreases with the animation.
         float unshiftX = -mShiftX * (1.0f - fractionAnimation) / mScale;
         float unshiftY = -mShiftY * (1.0f - fractionAnimation) / mScale;
 
-        // Compute the rect to show.
-        RectF rect = new RectF();
-        rect.left = mTouch.x - mLeftExtrusion * scale + unshiftX;
-        rect.top = mTouch.y - mTopExtrusion * scale + unshiftY;
-        rect.right = mTouch.x + mRightExtrusion * scale + unshiftX;
-        rect.bottom = mTouch.y + mBottomExtrusion * scale + unshiftY;
-        canvas.clipRect(rect);
+        // Compute the |mDrawRect| to show.
+        mDrawRect.left = mTouch.x - mLeftExtrusion * scale + unshiftX;
+        mDrawRect.top = mTouch.y - mTopExtrusion * scale + unshiftY;
+        mDrawRect.right = mTouch.x + mRightExtrusion * scale + unshiftX;
+        mDrawRect.bottom = mTouch.y + mBottomExtrusion * scale + unshiftY;
+        canvas.clipRect(mDrawRect);
 
         // Since the canvas transform APIs all pre-concat the transformations, this is done in
         // reverse order. The canvas is first scaled up, then shifted the appropriate amount of
         // pixels.
-        canvas.scale(scale, scale, rect.left, rect.top);
+        canvas.scale(scale, scale, mDrawRect.left, mDrawRect.top);
         canvas.translate(mPopupScrollX, mPopupScrollY);
-        canvas.drawBitmap(mZoomedBitmap, rect.left, rect.top, null);
+        canvas.drawBitmap(mZoomedBitmap, mDrawRect.left, mDrawRect.top, null);
         canvas.restore();
         Drawable overlayNineTile = getOverlayDrawable(getContext());
-        overlayNineTile.setBounds((int) rect.left - sOverlayPadding.left,
-                (int) rect.top - sOverlayPadding.top,
-                (int) rect.right + sOverlayPadding.right,
-                (int) rect.bottom + sOverlayPadding.bottom);
+        overlayNineTile.setBounds((int) mDrawRect.left - sOverlayPadding.left,
+                (int) mDrawRect.top - sOverlayPadding.top,
+                (int) mDrawRect.right + sOverlayPadding.right,
+                (int) mDrawRect.bottom + sOverlayPadding.bottom);
         // TODO(nileshagrawal): We should use time here instead of fractionAnimation
         // as fractionAnimaton is interpolated and can go over 1.
         int alpha = constrain((int) (fractionAnimation * 255), 0, 255);
         overlayNineTile.setAlpha(alpha);
         overlayNineTile.draw(canvas);
         canvas.restore();
     }
 
     /**
      * Show the PopupZoomer view with given target bounds.
@@ skipping 51 matching lines @@
         }
 
         @Override
         public float getInterpolation(float input) {
             input = 1.0f - input;
             if (mInterpolator == null) return input;
             return mInterpolator.getInterpolation(input);
         }
     }
 }