Update the AppBannerView appearance again

chrome/android/java/src/org/chromium/chrome/browser/banners/AppBannerView.java

 // Copyright 2014 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.chrome.browser.banners;
 
 import android.animation.ObjectAnimator;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.content.res.Resources;
-import android.graphics.Point;
 import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.view.LayoutInflater;
+import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.Button;
 import android.widget.ImageView;
 import android.widget.TextView;
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.chrome.R;
 import org.chromium.content.browser.ContentView;
 import org.chromium.ui.base.LocalizationUtils;
 
 /**
  * Lays out a banner for showing info about an app on the Play Store.
- * Rather than utilizing the Android RatingBar, which would require some nasty styling, a custom
- * View is used to paint a Drawable showing all the stars.  Showing different ratings is done by
- * adjusting the clipping rectangle width.
+ * The banner mimics the appearance of a Google Now card using a background Drawable with a shadow.
+ *
+ * PADDING CALCULATIONS
+ * The banner has three different types of padding that need to be accounted for:
+ * 1) The background Drawable of the banner looks like card with a drop shadow.  The Drawable
+ *    defines a padding around the card that solely encompasses the space occupied by the drop
+ *    shadow.
+ * 2) The card itself needs to have padding so that the widgets don't abut the borders of the card.
+ *    This is defined as mPaddingCard, and is equally applied to all four sides.
+ * 3) Controls other than the icon are further constrained by mPaddingControls, which applies only
+ *    to the bottom and end margins.
+ * See {@link #AppBannerView.onMeasure(int, int)} for details.
+ *
+ * MARGIN CALCULATIONS
+ * Margin calculations for the banner are complicated by the background Drawable's drop shadows,
+ * since the drop shadows are meant to be counted as being part of the margin.  To deal with this,
+ * the margins are calculated by deducting the background Drawable's padding from the margins
+ * defined by the XML files.
+ *
+ * EVEN MORE LAYOUT QUIRKS
+ * The layout of the banner, which includes its widget sizes, may change when the screen is rotated
+ * to account for less screen real estate.  This means that all of the View's widgets and cached
+ * dimensions must be rebuilt from scratch.
  */
 public class AppBannerView extends SwipableOverlayView implements View.OnClickListener {
     /**
      * Class that is alerted about things happening to the BannerView.
      */
     public static interface Observer {
         /**
          * Called when the banner is dismissed.
          * @param banner Banner being dismissed.
          */
         public void onBannerDismissed(AppBannerView banner);
 
         /**
          * Called when the install button has been clicked.
          * @param banner Banner firing the event.
          */
         public void onButtonClicked(AppBannerView banner);
 
         /**
          * Called when something other than the button is clicked.
          * @param banner Banner firing the event.
          */
         public void onBannerClicked(AppBannerView banner);
     }
 
+    // Number of milliseconds to wait before showing the card highlight.
+    private static final long MS_HIGHLIGHT_APPEARANCE = 150;
+
     // XML layout for the BannerView.
     private static final int BANNER_LAYOUT = R.layout.app_banner_view;
 
+    // Maximum distance the finger can travel before dismissing the highlight.
+    private static final float HIGHLIGHT_DISTANCE = 20;
+
     // True if the layout is in left-to-right layout mode (regular mode).
     private final boolean mIsLayoutLTR;
 
     // Class to alert about BannerView events.
     private AppBannerView.Observer mObserver;
 
     // Views comprising the app banner.
     private ImageView mIconView;
     private TextView mTitleView;
     private Button mButtonView;
     private RatingView mRatingView;
-    private ImageView mLogoView;
+    private View mLogoView;
+    private View mBannerHighlightView;
 
     // Information about the package.
     private AppData mAppData;
 
-    // Variables used during layout calculations and saved to avoid reallocations.
-    private final Point mSpaceMain;
-    private final Point mSpaceForLogo;
-    private final Point mSpaceForRating;
-    private final Point mSpaceForTitle;
-
     // Dimension values.
     private int mDefinedMaxWidth;
-    private int mPaddingContent;
-    private int mMarginSide;
+    private int mPaddingCard;
+    private int mPaddingControls;
+    private int mMarginLeft;
+    private int mMarginRight;
     private int mMarginBottom;
 
+    // Highlight variables.
+    private boolean mIsBannerPressed;
+    private float mInitialXForHighlight;
+
     // Initial padding values.
     private final Rect mBackgroundDrawablePadding;
 
     /**
      * Creates a BannerView and adds it to the given ContentView.
      * @param contentView ContentView to display the AppBannerView for.
      * @param observer    Class that is alerted for AppBannerView events.
      * @param data        Data about the app.
      * @return            The created banner.
      */
     public static AppBannerView create(ContentView contentView, Observer observer, AppData data) {
         Context context = contentView.getContext().getApplicationContext();
         AppBannerView banner =
                 (AppBannerView) LayoutInflater.from(context).inflate(BANNER_LAYOUT, null);
         banner.initialize(observer, data);
         banner.addToView(contentView);
         return banner;
     }
 
     /**
      * Creates a BannerView from an XML layout.
      */
     public AppBannerView(Context context, AttributeSet attrs) {
         super(context, attrs);
         mIsLayoutLTR = !LocalizationUtils.isSystemLayoutDirectionRtl();
-        mSpaceMain = new Point();
-        mSpaceForLogo = new Point();
-        mSpaceForRating = new Point();
-        mSpaceForTitle = new Point();
 
         // Store the background Drawable's padding.  The background used for banners is a 9-patch,
         // which means that it already defines padding.  We need to take it into account when adding
         // even more padding to the inside of it.
         mBackgroundDrawablePadding = new Rect();
         mBackgroundDrawablePadding.left = ApiCompatibilityUtils.getPaddingStart(this);
         mBackgroundDrawablePadding.right = ApiCompatibilityUtils.getPaddingEnd(this);
         mBackgroundDrawablePadding.top = getPaddingTop();
         mBackgroundDrawablePadding.bottom = getPaddingBottom();
     }
 
     /**
      * Initialize the banner with information about the package.
      * @param observer Class to alert about changes to the banner.
      * @param data     Information about the app being advertised.
      */
     private void initialize(Observer observer, AppData data) {
         mObserver = observer;
         mAppData = data;
         initializeControls();
     }
 
     private void initializeControls() {
         // Cache the banner dimensions, adjusting margins for drop shadows defined in the background
-        // Drawable.  The Drawable is defined to have the same margin on both the left and right.
+        // Drawable.
         Resources res = getResources();
         mDefinedMaxWidth = res.getDimensionPixelSize(R.dimen.app_banner_max_width);
-        mPaddingContent = res.getDimensionPixelSize(R.dimen.app_banner_padding_content);
-        mMarginSide = res.getDimensionPixelSize(R.dimen.app_banner_margin_sides)
+        mPaddingCard = res.getDimensionPixelSize(R.dimen.app_banner_padding);
+        mPaddingControls = res.getDimensionPixelSize(R.dimen.app_banner_padding_controls);
+        mMarginLeft = res.getDimensionPixelSize(R.dimen.app_banner_margin_sides)
                 - mBackgroundDrawablePadding.left;
+        mMarginRight = res.getDimensionPixelSize(R.dimen.app_banner_margin_sides)
+                - mBackgroundDrawablePadding.right;
         mMarginBottom = res.getDimensionPixelSize(R.dimen.app_banner_margin_bottom)
                 - mBackgroundDrawablePadding.bottom;
         if (getLayoutParams() != null) {
             MarginLayoutParams params = (MarginLayoutParams) getLayoutParams();
-            params.leftMargin = mMarginSide;
-            params.rightMargin = mMarginSide;
+            params.leftMargin = mMarginLeft;
+            params.rightMargin = mMarginRight;
             params.bottomMargin = mMarginBottom;
         }
 
-        // Add onto the padding defined by the Drawable's drop shadow.
-        int padding = res.getDimensionPixelSize(R.dimen.app_banner_padding);
-        int paddingStart = mBackgroundDrawablePadding.left + padding;
-        int paddingTop = mBackgroundDrawablePadding.top + padding;
-        int paddingEnd = mBackgroundDrawablePadding.right + padding;
-        int paddingBottom = mBackgroundDrawablePadding.bottom + padding;
-        ApiCompatibilityUtils.setPaddingRelative(
-                this, paddingStart, paddingTop, paddingEnd, paddingBottom);
-
         // Pull out all of the controls we are expecting.
         mIconView = (ImageView) findViewById(R.id.app_icon);
         mTitleView = (TextView) findViewById(R.id.app_title);
         mButtonView = (Button) findViewById(R.id.app_install_button);
         mRatingView = (RatingView) findViewById(R.id.app_rating);
-        mLogoView = (ImageView) findViewById(R.id.store_logo);
+        mLogoView = findViewById(R.id.store_logo);
+        mBannerHighlightView = findViewById(R.id.banner_highlight);
+
         assert mIconView != null;
         assert mTitleView != null;
         assert mButtonView != null;
         assert mLogoView != null;
         assert mRatingView != null;
+        assert mBannerHighlightView != null;
 
         // Set up the button to fire an event.
         mButtonView.setOnClickListener(this);
 
         // Configure the controls with the package information.
         mTitleView.setText(mAppData.title());
         mIconView.setImageDrawable(mAppData.icon());
         mRatingView.initialize(mAppData.rating());
 
         // Update the button state.
         updateButtonState();
     }
 
     @Override
     public void onClick(View view) {
         if (mObserver != null && view == mButtonView) mObserver.onButtonClicked(this);
     }
 
     @Override
     protected void onViewClicked() {
         if (mObserver != null) mObserver.onBannerClicked(this);
     }
 
     @Override
     protected ViewGroup.MarginLayoutParams createLayoutParams() {
         // Define the margin around the entire banner that accounts for the drop shadow.
         ViewGroup.MarginLayoutParams params = super.createLayoutParams();
-        params.setMargins(mMarginSide, 0, mMarginSide, mMarginBottom);
+        params.setMargins(mMarginLeft, 0, mMarginRight, mMarginBottom);
         return params;
     }
 
     /**
      * Removes this View from its parent and alerts any observers of the dismissal.
      * @return Whether or not the View was successfully dismissed.
      */
     @Override
     boolean removeFromParent() {
         boolean removed = super.removeFromParent();
         if (removed) mObserver.onBannerDismissed(this);
         return removed;
     }
 
     /**
      * Returns data for the app the banner is being shown for.
      * @return The AppData being used by the banner.
      */
     AppData getAppData() {
         return mAppData;
     }
 
     /**
      * Updates the text and color of the button displayed on the button.
      */
     void updateButtonState() {
         if (mButtonView == null) return;
 
-        int bgColor;
+        Resources res = getResources();
         int fgColor;
         String text;
         if (mAppData.installState() == AppData.INSTALL_STATE_INSTALLED) {
-            bgColor = getResources().getColor(R.color.app_banner_open_button_bg);
-            fgColor = getResources().getColor(R.color.app_banner_open_button_fg);
-            text = getResources().getString(R.string.app_banner_open);
+            ApiCompatibilityUtils.setBackgroundForView(mButtonView,
+                    res.getDrawable(R.drawable.app_banner_button_open));
+            fgColor = res.getColor(R.color.app_banner_open_button_fg);
+            text = res.getString(R.string.app_banner_open);
         } else {
-            bgColor = getResources().getColor(R.color.app_banner_install_button_bg);
-            fgColor = getResources().getColor(R.color.app_banner_install_button_fg);
+            ApiCompatibilityUtils.setBackgroundForView(mButtonView,
+                    res.getDrawable(R.drawable.app_banner_button_install));
+            fgColor = res.getColor(R.color.app_banner_install_button_fg);
             if (mAppData.installState() == AppData.INSTALL_STATE_NOT_INSTALLED) {
                 text = mAppData.installButtonText();
             } else {
-                text = getResources().getString(R.string.app_banner_installing);
+                text = res.getString(R.string.app_banner_installing);
             }
         }
 
-        mButtonView.setBackgroundColor(bgColor);
         mButtonView.setTextColor(fgColor);
         mButtonView.setText(text);
     }
 
     /**
      * Determine how big an icon needs to be for the Layout.
      * @param context Context to grab resources from.
      * @return        How big the icon is expected to be, in pixels.
      */
     static int getIconSize(Context context) {
         return context.getResources().getDimensionPixelSize(R.dimen.app_banner_icon_size);
     }
 
     /**
+     * Highlight the banner when the user has held it for long enough and doesn't move.
+     * Passes all touch events through to the parent.
+     */
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        int action = event.getActionMasked();
+        if (action == MotionEvent.ACTION_DOWN) {
+            mIsBannerPressed = true;
+            mInitialXForHighlight = event.getRawX();
+            getHandler().postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    // Highlight the banner if the user is still holding onto it.
+                    if (mIsBannerPressed) mBannerHighlightView.setVisibility(View.VISIBLE);
+                }
+            }, MS_HIGHLIGHT_APPEARANCE);
+        } else if (mIsBannerPressed) {
+            float xDifference = Math.abs(event.getRawX() - mInitialXForHighlight);
+            if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL
+                    || (action == MotionEvent.ACTION_MOVE && xDifference > HIGHLIGHT_DISTANCE)) {
+                mIsBannerPressed = false;
+                mBannerHighlightView.setVisibility(View.INVISIBLE);
+            }
+        }
+
+        return super.onTouchEvent(event);
+    }
+    /**
      * Fade the banner back into view.
      */
     @Override
     protected void onAttachedToWindow() {
         super.onAttachedToWindow();
         ObjectAnimator.ofFloat(this, "alpha", getAlpha(), 1.f).setDuration(
                 MS_ANIMATION_DURATION).start();
         setVisibility(VISIBLE);
     }
 
@@ skipping 20 matching lines @@
         if (mDefinedMaxWidth == newDefinedWidth) return;
 
         // Cannibalize another version of this layout to get Views using the new resources and
         // sizes.
         while (getChildCount() > 0) removeViewAt(0);
         mIconView = null;
         mTitleView = null;
         mButtonView = null;
         mRatingView = null;
         mLogoView = null;
+        mBannerHighlightView = null;
 
         AppBannerView cannibalized =
                 (AppBannerView) LayoutInflater.from(getContext()).inflate(BANNER_LAYOUT, null);
         while (cannibalized.getChildCount() > 0) {
             View child = cannibalized.getChildAt(0);
             cannibalized.removeViewAt(0);
             addView(child);
         }
         initializeControls();
         requestLayout();
     }
 
     /**
-     * Measurement for components of the banner are performed using the following procedure:
+     * Measures the banner and its children Views for the given space.
      *
-     * 00000000000000000000000000000000000000000000000000000
-     * 01111155555555555555555555555555555555555555555555550
-     * 01111155555555555555555555555555555555555555555555550
-     * 01111144444444444440000000000000000000000222222222220
-     * 01111133333333333330000000000000000000000222222222220
-     * 00000000000000000000000000000000000000000000000000000
+     * DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
+     * DPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPD
+     * DP......                               cPD
+     * DP...... TITLE-------------------------cPD
+     * DP.ICON. *****                         cPD
+     * DP...... LOGO                    BUTTONcPD
+     * DP...... cccccccccccccccccccccccccccccccPD
+     * DPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPD
+     * DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
      *
-     * 0) A maximum width is enforced on the banner, based on the smallest width of the screen,
-     *    then padding defined by the 9-patch background Drawable is subtracted from all sides.
-     * 1) The icon takes up the left side of the banner.
-     * 2) The install button occupies the bottom-right of the banner.
-     * 3) The Google Play logo occupies the space to the left of the button.
-     * 4) The rating is assigned space above the logo and below the title.
-     * 5) The title is assigned whatever space is left.  The maximum height of the banner is defined
-     *    by deducting the height of either the install button or the logo + rating, (which is
-     *    bigger).  If the title cannot fit two lines comfortably, it is shrunk down to one.
+     * The three paddings mentioned in the class Javadoc are denoted by:
+     * D) Drop shadow padding.
+     * P) Inner card padding.
+     * c) Control padding.
+     *
+     * Measurement for components of the banner are performed assuming that components are laid out
+     * inside of the banner's background as follows:
+     * 1) A maximum width is enforced on the banner to keep the whole thing on screen and keep it a
+     *    reasonable size.
+     * 2) The icon takes up the left side of the banner.
+     * 3) The install button occupies the bottom-right of the banner.
+     * 4) The Google Play logo occupies the space to the left of the button.
+     * 5) The rating is assigned space above the logo and below the title.
+     * 6) The title is assigned whatever space is left and sits on top of the tallest stack of
+     *    controls.
      *
      * See {@link #android.view.View.onMeasure(int, int)} for the parameters.
      */
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
-        // Enforce a maximum width on the banner.
+        // Enforce a maximum width on the banner, which is defined as the smallest of:
+        // 1) The smallest width for the device (in either landscape or portrait mode).
+        // 2) The defined maximum width in the dimens.xml files.
+        // 3) The width passed in through the MeasureSpec.
         Resources res = getResources();
         float density = res.getDisplayMetrics().density;
         int screenSmallestWidth = (int) (res.getConfiguration().smallestScreenWidthDp * density);
         int specWidth = MeasureSpec.getSize(widthMeasureSpec);
-        int maxWidth = Math.min(Math.min(specWidth, mDefinedMaxWidth), screenSmallestWidth);
-        int maxHeight = MeasureSpec.getSize(heightMeasureSpec);
+        int bannerWidth = Math.min(Math.min(specWidth, mDefinedMaxWidth), screenSmallestWidth);
 
-        // Track how much space is available for the banner content.
-        mSpaceMain.x = maxWidth - ApiCompatibilityUtils.getPaddingStart(this)
-                - ApiCompatibilityUtils.getPaddingEnd(this);
-        mSpaceMain.y = maxHeight - getPaddingTop() - getPaddingBottom();
+        // Track how much space is available inside the banner's card-shaped background Drawable.
+        // To calculate this, we need to account for both the padding of the background (which
+        // is occupied by the card's drop shadows) as well as the padding defined on the inside of
+        // the card.
+        int bgPaddingWidth = mBackgroundDrawablePadding.left + mBackgroundDrawablePadding.right;
+        int bgPaddingHeight = mBackgroundDrawablePadding.top + mBackgroundDrawablePadding.bottom;
+        final int maxControlWidth = bannerWidth - bgPaddingWidth - (mPaddingCard * 2);
 
-        // Measure the icon, which hugs the banner's starting edge and defines the banner's height.
-        measureChildForSpace(mIconView, mSpaceMain);
-        mSpaceMain.x -= getChildWidthWithMargins(mIconView);
-        mSpaceMain.y = getChildHeightWithMargins(mIconView) + getPaddingTop() + getPaddingBottom();
+        // Control height is constrained to provide a reasonable aspect ratio.
+        // In practice, the only controls which can cause an issue are the title and the install
+        // button, since they have strings that can change size according to user preference.  The
+        // other controls are all defined to be a certain height.
+        int specHeight = MeasureSpec.getSize(heightMeasureSpec);
+        int reasonableHeight = maxControlWidth / 4;
+        int paddingHeight = bgPaddingHeight + (mPaddingCard * 2);
+        final int maxControlHeight = Math.min(specHeight, reasonableHeight) - paddingHeight;
+        final int maxStackedControlHeight = maxControlWidth / 3;
 
-        // Additional padding is defined by the mock for non-icon content on the end and bottom.
-        mSpaceMain.x -= mPaddingContent;
-        mSpaceMain.y -= mPaddingContent;
+        // Determine how big each component wants to be.  The icon is measured separately because
+        // it is not stacked with the other controls.
+        measureChildForSpace(mIconView, maxControlWidth, maxControlHeight);
+        for (int i = 0; i < getChildCount(); i++) {
+            if (getChildAt(i) != mIconView) {
+                measureChildForSpace(getChildAt(i), maxControlWidth, maxStackedControlHeight);
+            }
+        }
 
-        // Measure the install button, which sits in the bottom-right corner.
-        measureChildForSpace(mButtonView, mSpaceMain);
+        // Determine how tall the banner needs to be to fit everything by calculating the combined
+        // height of the stacked controls.  There are three competing stacks to measure:
+        // 1) The icon.
+        // 2) The app title + control padding + star rating + store logo.
+        // 3) The app title + control padding + install button.
+        // The control padding is extra padding that applies only to the non-icon widgets.
+        int iconStackHeight = getHeightWithMargins(mIconView);
+        int logoStackHeight = getHeightWithMargins(mTitleView) + mPaddingControls
+                + getHeightWithMargins(mRatingView) + getHeightWithMargins(mLogoView);
+        int buttonStackHeight = getHeightWithMargins(mTitleView) + mPaddingControls
+                + getHeightWithMargins(mButtonView);
+        int biggestStackHeight =
+                Math.max(iconStackHeight, Math.max(logoStackHeight, buttonStackHeight));
 
-        // Measure the logo, which sits in the bottom-left corner next to the icon.
-        mSpaceForLogo.x = mSpaceMain.x - getChildWidthWithMargins(mButtonView);
-        mSpaceForLogo.y = mSpaceMain.y;
-        measureChildForSpace(mLogoView, mSpaceForLogo);
+        // The icon hugs the banner's starting edge, from the top of the banner to the bottom.
+        final int iconSize = biggestStackHeight;
+        measureChildForSpaceExactly(mIconView, iconSize, iconSize);
+
+        // The rest of the content is laid out to the right of the icon.
+        // Additional padding is defined for non-icon content on the end and bottom.
+        final int contentWidth =
+                maxControlWidth - getWidthWithMargins(mIconView) - mPaddingControls;
+        final int contentHeight = biggestStackHeight - mPaddingControls;
+        measureChildForSpace(mButtonView, contentWidth, contentHeight);
+        measureChildForSpace(mLogoView, contentWidth, contentHeight);
 
         // Measure the star rating, which sits below the title and above the logo.
-        mSpaceForRating.x = mSpaceForLogo.x;
-        mSpaceForRating.y = mSpaceForLogo.y - getChildHeightWithMargins(mLogoView);
-        measureChildForSpace(mRatingView, mSpaceForRating);
+        final int ratingWidth = contentWidth;
+        final int ratingHeight = contentHeight - getHeightWithMargins(mLogoView);
+        measureChildForSpace(mRatingView, ratingWidth, ratingHeight);
 
-        // The app title spans the top of the banner.
-        mSpaceForTitle.x = mSpaceMain.x;
-        mSpaceForTitle.y = mSpaceMain.y - getChildHeightWithMargins(mLogoView)
-                - getChildHeightWithMargins(mRatingView);
-        measureChildForSpace(mTitleView, mSpaceForTitle);
+        // The app title spans the top of the banner and sits on top of the other controls.
+        int biggerStack = Math.max(getHeightWithMargins(mButtonView),
+                getHeightWithMargins(mLogoView) + getHeightWithMargins(mRatingView));
+        final int titleWidth = contentWidth;
+        final int titleHeight = contentHeight - biggerStack;
+        measureChildForSpace(mTitleView, titleWidth, titleHeight);
 
-        // Set the measured dimensions for the banner.
-        int measuredHeight = mIconView.getMeasuredHeight() + getPaddingTop() + getPaddingBottom();
-        setMeasuredDimension(maxWidth, measuredHeight);
+        // Set the measured dimensions for the banner.  The banner's height is defined by the
+        // tallest stack of components, the padding of the banner's card background, and the extra
+        // padding around the banner's components.
+        int bannerPadding = mBackgroundDrawablePadding.top + mBackgroundDrawablePadding.bottom
+                + (mPaddingCard * 2);
+        int bannerHeight = biggestStackHeight + bannerPadding;
+        setMeasuredDimension(bannerWidth, bannerHeight);
+
+        // Make the banner highlight view be the exact same size as the banner's card background.
+        final int cardWidth = bannerWidth - bgPaddingWidth;
+        final int cardHeight = bannerHeight - bgPaddingHeight;
+        measureChildForSpaceExactly(mBannerHighlightView, cardWidth, cardHeight);
     }
 
     /**
      * Lays out the controls according to the algorithm in {@link #onMeasure}.
      * See {@link #android.view.View.onLayout(boolean, int, int, int, int)} for the parameters.
      */
     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         super.onLayout(changed, l, t, r, b);
+        int top = mBackgroundDrawablePadding.top;
+        int bottom = getMeasuredHeight() - mBackgroundDrawablePadding.bottom;
+        int start = mBackgroundDrawablePadding.left;
+        int end = getMeasuredWidth() - mBackgroundDrawablePadding.right;
 
-        int top = getPaddingTop();
-        int bottom = getMeasuredHeight() - getPaddingBottom();
-        int start = ApiCompatibilityUtils.getPaddingStart(this);
-        int end = getMeasuredWidth() - ApiCompatibilityUtils.getPaddingEnd(this);
+        // The highlight overlay covers the entire banner (minus drop shadow padding).
+        mBannerHighlightView.layout(start, top, end, bottom);
+
+        // Apply the padding for the rest of the widgets.
+        top += mPaddingCard;
+        bottom -= mPaddingCard;
+        start += mPaddingCard;
+        end -= mPaddingCard;
 
         // Lay out the icon.
         int iconWidth = mIconView.getMeasuredWidth();
         int iconLeft = mIsLayoutLTR ? start : (getMeasuredWidth() - start - iconWidth);
         mIconView.layout(iconLeft, top, iconLeft + iconWidth, top + mIconView.getMeasuredHeight());
-        start += getChildWidthWithMargins(mIconView);
+        start += getWidthWithMargins(mIconView);
 
-        // Factor in the additional padding.
-        end -= mPaddingContent;
-        bottom -= mPaddingContent;
+        // Factor in the additional padding, which is only tacked onto the end and bottom.
+        end -= mPaddingControls;
+        bottom -= mPaddingControls;
 
         // Lay out the app title text.
         int titleWidth = mTitleView.getMeasuredWidth();
         int titleTop = top + ((MarginLayoutParams) mTitleView.getLayoutParams()).topMargin;
         int titleBottom = titleTop + mTitleView.getMeasuredHeight();
         int titleLeft = mIsLayoutLTR ? start : (getMeasuredWidth() - start - titleWidth);
         mTitleView.layout(titleLeft, titleTop, titleLeft + titleWidth, titleBottom);
 
         // The mock shows the margin eating into the descender area of the TextView.
         int textBaseline = mTitleView.getLineBounds(mTitleView.getLineCount() - 1, null);
@@ skipping 16 matching lines @@
 
         // Lay out the install button in the bottom-right corner.
         int buttonHeight = mButtonView.getMeasuredHeight();
         int buttonWidth = mButtonView.getMeasuredWidth();
         int buttonRight = mIsLayoutLTR ? end : (getMeasuredWidth() - end + buttonWidth);
         int buttonLeft = buttonRight - buttonWidth;
         mButtonView.layout(buttonLeft, bottom - buttonHeight, buttonRight, bottom);
     }
 
     /**
+     * Measures a child for the given space, accounting for defined heights and margins.
+     * @param child           View to measure.
+     * @param availableWidth  Available width for the view.
+     * @param availableHeight Available height for the view.
+     */
+    private void measureChildForSpace(View child, int availableWidth, int availableHeight) {
+        // Handle margins.
+        availableWidth -= getMarginWidth(child);
+        availableHeight -= getMarginHeight(child);
+
+        // Account for any layout-defined dimensions for the view.
+        int childWidth = child.getLayoutParams().width;
+        int childHeight = child.getLayoutParams().height;
+        if (childWidth >= 0) availableWidth = Math.min(availableWidth, childWidth);
+        if (childHeight >= 0) availableHeight = Math.min(availableHeight, childHeight);
+
+        int widthSpec = MeasureSpec.makeMeasureSpec(availableWidth, MeasureSpec.AT_MOST);
+        int heightSpec = MeasureSpec.makeMeasureSpec(availableHeight, MeasureSpec.AT_MOST);
+        child.measure(widthSpec, heightSpec);
+    }
+
+    /**
+     * Forces a child to exactly occupy the given space.
+     * @param child           View to measure.
+     * @param availableWidth  Available width for the view.
+     * @param availableHeight Available height for the view.
+     */
+    private void measureChildForSpaceExactly(View child, int availableWidth, int availableHeight) {
+        int widthSpec = MeasureSpec.makeMeasureSpec(availableWidth, MeasureSpec.EXACTLY);
+        int heightSpec = MeasureSpec.makeMeasureSpec(availableHeight, MeasureSpec.EXACTLY);
+        child.measure(widthSpec, heightSpec);
+    }
+
+    /**
+     * Calculates how wide the margins are for the given View.
+     * @param view View to measure.
+     * @return     Measured width of the margins.
+     */
+    private static int getMarginWidth(View view) {
+        MarginLayoutParams params = (MarginLayoutParams) view.getLayoutParams();
+        return params.leftMargin + params.rightMargin;
+    }
+
+    /**
      * Calculates how wide the given View has been measured to be, including its margins.
-     * @param child Child to measure.
-     * @return      Measured width of the child plus its margins.
+     * @param view View to measure.
+     * @return     Measured width of the view plus its margins.
      */
-    private int getChildWidthWithMargins(View child) {
-        MarginLayoutParams params = (MarginLayoutParams) child.getLayoutParams();
-        return child.getMeasuredWidth() + ApiCompatibilityUtils.getMarginStart(params)
-                + ApiCompatibilityUtils.getMarginEnd(params);
+    private static int getWidthWithMargins(View view) {
+        return view.getMeasuredWidth() + getMarginWidth(view);
+    }
+
+    /**
+     * Calculates how tall the margins are for the given View.
+     * @param view View to measure.
+     * @return     Measured height of the margins.
+     */
+    private static int getMarginHeight(View view) {
+        MarginLayoutParams params = (MarginLayoutParams) view.getLayoutParams();
+        return params.topMargin + params.bottomMargin;
     }
 
     /**
      * Calculates how tall the given View has been measured to be, including its margins.
-     * @param child Child to measure.
-     * @return Measured height of the child plus its margins.
+     * @param view View to measure.
+     * @return     Measured height of the view plus its margins.
      */
-    private static int getChildHeightWithMargins(View child) {
-        MarginLayoutParams params = (MarginLayoutParams) child.getLayoutParams();
-        return child.getMeasuredHeight() + params.topMargin + params.bottomMargin;
-    }
-
-    /**
-     * Measures a child so that it fits within the given space, taking into account heights defined
-     * in the layout.
-     * @param child     View to measure.
-     * @param available Available space, with width stored in the x coordinate and height in the y.
-     */
-    private void measureChildForSpace(View child, Point available) {
-        int childHeight = child.getLayoutParams().height;
-        int maxHeight = childHeight > 0 ? Math.min(available.y, childHeight) : available.y;
-        int widthSpec = MeasureSpec.makeMeasureSpec(available.x, MeasureSpec.AT_MOST);
-        int heightSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.AT_MOST);
-        measureChildWithMargins(child, widthSpec, 0, heightSpec, 0);
+    private static int getHeightWithMargins(View view) {
+        return view.getMeasuredHeight() + getMarginHeight(view);
     }
 }