Use only toolbar to transition from fakebox to real omnibox.

chrome/android/java/src/org/chromium/chrome/browser/toolbar/ToolbarPhone.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.chrome.browser.toolbar;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
 import android.animation.ValueAnimator;
 import android.animation.ValueAnimator.AnimatorUpdateListener;
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.res.ColorStateList;
 import android.content.res.Resources;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Point;
 import android.graphics.PorterDuff;
 import android.graphics.Rect;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.TransitionDrawable;
 import android.os.Build;
 import android.os.SystemClock;
+import android.support.v4.view.animation.FastOutSlowInInterpolator;
 import android.text.TextUtils;
 import android.util.AttributeSet;
 import android.util.Property;
 import android.view.Gravity;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.View.OnLongClickListener;
 import android.view.ViewDebug;
 import android.view.ViewGroup;
 import android.view.WindowManager;
+import android.view.animation.Interpolator;
 import android.view.animation.LinearInterpolator;
 import android.widget.FrameLayout;
 import android.widget.ImageView;
 import android.widget.PopupWindow.OnDismissListener;
 import android.widget.TextView;
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.SysUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.metrics.RecordUserAction;
@@ skipping 36 matching lines @@
     private static final int URL_CLEAR_FOCUS_TABSTACK_DELAY_MS = 200;
     private static final int URL_CLEAR_FOCUS_MENU_DELAY_MS = 250;
 
     private static final int TAB_SWITCHER_MODE_ENTER_ANIMATION_DURATION_MS = 200;
     private static final int TAB_SWITCHER_MODE_EXIT_NORMAL_ANIMATION_DURATION_MS = 200;
     private static final int TAB_SWITCHER_MODE_EXIT_FADE_ANIMATION_DURATION_MS = 100;
     private static final int TAB_SWITCHER_MODE_POST_EXIT_ANIMATION_DURATION_MS = 100;
 
     private static final float UNINITIALIZED_PERCENT = -1f;
 
-    private static final String TAG = "ToolbarPhone";
-
     static final int LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA = 51;
 
-    private LocationBarPhone mPhoneLocationBar;
+    private static final Interpolator NTP_SEARCH_BOX_EXPANSION_INTERPOLATOR =
+            new FastOutSlowInInterpolator();
+
+    private LocationBarPhone mLocationBar;
 
     private ViewGroup mToolbarButtonsContainer;
     private ImageView mToggleTabStackButton;
     private NewTabButton mNewTabButton;
     private TintedImageButton mReturnButton;
     private TintedImageButton mHomeButton;
     private TextView mUrlBar;
-    private View mUrlActionsContainer;
+    private View mUrlActionContainer;
     private ImageView mToolbarShadow;
 
     private final int mProgressBackBackgroundColorWhite;
 
     private ObjectAnimator mTabSwitcherModeAnimation;
     private ObjectAnimator mDelayedTabSwitcherModeAnimation;
 
     private final List<View> mTabSwitcherModeViews = new ArrayList<View>();
     private final Set<View> mBrowsingModeViews = new HashSet<View>();
     @ViewDebug.ExportedProperty(category = "chrome")
@@ skipping 49 matching lines @@
      */
     @ViewDebug.ExportedProperty(category = "chrome")
     private float mUrlExpansionPercent;
     private AnimatorSet mUrlFocusLayoutAnimator;
     private boolean mDisableLocationBarRelayout;
     private boolean mLayoutLocationBarInFocusedMode;
     private int mUnfocusedLocationBarLayoutWidth;
     private int mUnfocusedLocationBarLayoutLeft;
     private boolean mUnfocusedLocationBarUsesTransparentBg;
 
-    private int mUrlBackgroundAlpha = 255;
+    private int mLocationBarBackgroundAlpha = 255;
     private float mNtpSearchBoxScrollPercent = UNINITIALIZED_PERCENT;
     private ColorDrawable mToolbarBackground;
 
-    // The omnibox background (white with a shadow).
+    /** The omnibox background (white with a shadow). */
     private Drawable mLocationBarBackground;
+
     private boolean mForceDrawLocationBarBackground;
     private TabSwitcherDrawable mTabSwitcherButtonDrawable;
     private TabSwitcherDrawable mTabSwitcherButtonDrawableLight;
 
     private final int mLightModeDefaultColor;
     private final int mDarkModeDefaultColor;
 
-    private final Rect mUrlViewportBounds = new Rect();
-    private final Rect mUrlBackgroundPadding = new Rect();
+    /** The boundaries of the omnibox, without the NTP-specific offset applied. */
+    private final Rect mLocationBarBackgroundBounds = new Rect();
+
+    private final Rect mLocationBarBackgroundPadding = new Rect();
     private final Rect mBackgroundOverlayBounds = new Rect();
-    private final Rect mLocationBarBackgroundOffset = new Rect();
 
-    private final Rect mNtpSearchBoxOriginalBounds = new Rect();
-    private final Rect mNtpSearchBoxTransformedBounds = new Rect();
+    /** Offset applied to the bounds of the omnibox if we are showing a New Tab Page. */
+    private final Rect mLocationBarBackgroundNtpOffset = new Rect();
 
-    private final int mLocationBarInsets;
+    /**
+     * Offsets applied to the <i>contents</i> of the omnibox if we are showing a New Tab Page.
+     * This can be different from {@link #mLocationBarBackgroundNtpOffset} due to the fact that we
+     * extend the omnibox horizontally beyond the screen boundaries when focused, to hide its
+     * rounded corners.
+     */
+    private float mLocationBarNtpOffsetLeft;
+    private float mLocationBarNtpOffsetRight;
+
+    private final Rect mNtpSearchBoxBounds = new Rect();
+    private final Point mNtpSearchBoxTranslation = new Point();
+
     private final int mToolbarSidePadding;
+    private final int mLocationBarVerticalMargin;
+    private final int mLocationBarBackgroundCornerRadius;
 
     private ValueAnimator mBrandColorTransitionAnimation;
     private boolean mBrandColorTransitionActive;
 
     private View.OnClickListener mReturnButtonListener;
     private boolean mIsHomeButtonEnabled;
 
     private LayoutUpdateHost mLayoutUpdateHost;
 
     /** Callout for the tab switcher button. */
@@ skipping 60 matching lines @@
 
     /**
      * Constructs a ToolbarPhone object.
      * @param context The Context in which this View object is created.
      * @param attrs The AttributeSet that was specified with this View.
      */
     public ToolbarPhone(Context context, AttributeSet attrs) {
         super(context, attrs);
         mToolbarSidePadding = getResources().getDimensionPixelOffset(
                 R.dimen.toolbar_edge_padding);
-        // Insets used for the PhoneLocatioBar background drawable.
-        mLocationBarInsets = getResources().getDimensionPixelSize(R.dimen.location_bar_margin_top)
-                + getResources().getDimensionPixelSize(R.dimen.location_bar_margin_bottom);
+        mLocationBarVerticalMargin =
+                getResources().getDimensionPixelOffset(R.dimen.location_bar_vertical_margin);
+        mLocationBarBackgroundCornerRadius =
+                getResources().getDimensionPixelOffset(R.dimen.location_bar_corner_radius);
         mProgressBackBackgroundColorWhite = ApiCompatibilityUtils.getColor(getResources(),
                 R.color.progress_bar_background_white);
         mLightModeDefaultColor =
                 ApiCompatibilityUtils.getColor(getResources(), R.color.light_mode_tint);
         mDarkModeDefaultColor =
                 ApiCompatibilityUtils.getColor(getResources(), R.color.dark_mode_tint);
     }
 
     @Override
     public void onFinishInflate() {
         super.onFinishInflate();
-        mPhoneLocationBar = (LocationBarPhone) findViewById(R.id.location_bar);
+        mLocationBar = (LocationBarPhone) findViewById(R.id.location_bar);
 
         mToolbarButtonsContainer = (ViewGroup) findViewById(R.id.toolbar_buttons);
 
         mReturnButton = (TintedImageButton) findViewById(R.id.return_button);
         mHomeButton = (TintedImageButton) findViewById(R.id.home_button);
 
         mUrlBar = (TextView) findViewById(R.id.url_bar);
 
-        mUrlActionsContainer = findViewById(R.id.url_action_container);
+        mUrlActionContainer = findViewById(R.id.url_action_container);
 
-        mBrowsingModeViews.add(mPhoneLocationBar);
+        mBrowsingModeViews.add(mLocationBar);
 
         mToolbarBackground = new ColorDrawable(getToolbarColorForVisualState(VisualState.NORMAL));
         mTabSwitcherAnimationBgOverlay =
                 new ColorDrawable(getToolbarColorForVisualState(VisualState.NORMAL));
 
         mLocationBarBackground =
-                ApiCompatibilityUtils.getDrawable(getResources(), R.drawable.inset_textbox);
-        mLocationBarBackground.getPadding(mUrlBackgroundPadding);
-        mPhoneLocationBar.setPadding(
-                mUrlBackgroundPadding.left, mUrlBackgroundPadding.top,
-                mUrlBackgroundPadding.right, mUrlBackgroundPadding.bottom);
+                ApiCompatibilityUtils.getDrawable(getResources(), R.drawable.textbox);
+        mLocationBarBackground.getPadding(mLocationBarBackgroundPadding);
+        mLocationBar.setPadding(
+                mLocationBarBackgroundPadding.left, mLocationBarBackgroundPadding.top,
+                mLocationBarBackgroundPadding.right, mLocationBarBackgroundPadding.bottom);
 
         setLayoutTransition(null);
 
         mMenuButtonWrapper.setVisibility(shouldShowMenuButton() ? View.VISIBLE : View.GONE);
         if (FeatureUtilities.isDocumentMode(getContext())) {
             ApiCompatibilityUtils.setMarginEnd(
                     (MarginLayoutParams) mMenuButtonWrapper.getLayoutParams(),
                     getResources().getDimensionPixelSize(R.dimen.document_toolbar_menu_offset));
             hideTabSwitchingResources();
         } else {
@@ skipping 106 matching lines @@
                 return mToggleTabStackButton;
             }
 
             @Override
             protected boolean handleEnterKeyPress() {
                 return getMenuButtonHelper().onEnterKeyPress(mMenuButton);
             }
         });
         onHomeButtonUpdate(HomepageManager.isHomepageEnabled(getContext()));
 
-        updateVisualsForToolbarState(mIsInTabSwitcherMode);
+        updateVisualsForToolbarState();
     }
 
     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
         // If the NTP is partially scrolled, prevent all touch events to the child views.  This
         // is to not allow a secondary touch event to trigger entering the tab switcher, which
         // can lead to really odd snapshots and transitions to the switcher.
         if (mNtpSearchBoxScrollPercent != 0f
                 && mNtpSearchBoxScrollPercent != 1f
                 && mNtpSearchBoxScrollPercent != UNINITIALIZED_PERCENT) {
@@ skipping 49 matching lines @@
             if (!changed) return;
         } else {
             updateUnfocusedLocationBarLayoutParams();
         }
 
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
     }
 
     private void updateUnfocusedLocationBarLayoutParams() {
         boolean hasVisibleViewPriorToUrlBar = false;
-        for (int i = 0; i < mPhoneLocationBar.getChildCount(); i++) {
-            View child = mPhoneLocationBar.getChildAt(i);
+        for (int i = 0; i < mLocationBar.getChildCount(); i++) {
+            View child = mLocationBar.getChildAt(i);
             if (child == mUrlBar) break;
             if (child.getVisibility() != GONE) {
                 hasVisibleViewPriorToUrlBar = true;
                 break;
             }
         }
 
         int leftViewBounds = getViewBoundsLeftOfLocationBar(mVisualState);
-        if (!hasVisibleViewPriorToUrlBar) leftViewBounds += mToolbarSidePadding;
         int rightViewBounds = getViewBoundsRightOfLocationBar(mVisualState);
 
-        if (!mPhoneLocationBar.hasVisibleViewsAfterUrlBarWhenUnfocused()) {
+        if (!hasVisibleViewPriorToUrlBar) {
+            if (ApiCompatibilityUtils.isLayoutRtl(mLocationBar)) {
+                rightViewBounds -= mToolbarSidePadding;
+            } else {
+                leftViewBounds += mToolbarSidePadding;
+            }
+        }
+
+        if (!mLocationBar.hasVisibleViewsAfterUrlBarWhenUnfocused()) {
             // Add spacing between the end of the URL and the edge of the omnibox drawable.
             // This only applies if there is no end aligned view that should be visible
             // while the omnibox is unfocused.
-            if (ApiCompatibilityUtils.isLayoutRtl(mPhoneLocationBar)) {
+            if (ApiCompatibilityUtils.isLayoutRtl(mLocationBar)) {
                 leftViewBounds += mToolbarSidePadding;
             } else {
                 rightViewBounds -= mToolbarSidePadding;
             }
         }
 
         mUnfocusedLocationBarLayoutWidth = rightViewBounds - leftViewBounds;
         mUnfocusedLocationBarLayoutLeft = leftViewBounds;
     }
 
@@ skipping 26 matching lines @@
 
         int width = 0;
         int leftMargin = 0;
 
         // Always update the unfocused layout params regardless of whether we are using
         // those in this current layout pass as they are needed for animations.
         updateUnfocusedLocationBarLayoutParams();
 
         if (mLayoutLocationBarInFocusedMode || mVisualState == VisualState.NEW_TAB_NORMAL) {
             int priorVisibleWidth = 0;
-            for (int i = 0; i < mPhoneLocationBar.getChildCount(); i++) {
-                View child = mPhoneLocationBar.getChildAt(i);
-                if (child == mPhoneLocationBar.getFirstViewVisibleWhenFocused()) break;
+            for (int i = 0; i < mLocationBar.getChildCount(); i++) {
+                View child = mLocationBar.getChildAt(i);
+                if (child == mLocationBar.getFirstViewVisibleWhenFocused()) break;
                 if (child.getVisibility() == GONE) continue;
                 priorVisibleWidth += child.getMeasuredWidth();
             }
 
             width = containerWidth - (2 * mToolbarSidePadding) + priorVisibleWidth;
-            if (ApiCompatibilityUtils.isLayoutRtl(mPhoneLocationBar)) {
+            if (ApiCompatibilityUtils.isLayoutRtl(mLocationBar)) {
                 leftMargin = mToolbarSidePadding;
             } else {
                 leftMargin = -priorVisibleWidth + mToolbarSidePadding;
             }
         } else {
             width = mUnfocusedLocationBarLayoutWidth;
             leftMargin = mUnfocusedLocationBarLayoutLeft;
         }
 
         boolean changed = false;
@@ skipping 74 matching lines @@
 
     @Override
     protected void dispatchDraw(Canvas canvas) {
         if (!mTextureCaptureMode && mToolbarBackground.getColor() != Color.TRANSPARENT) {
             // Update to compensate for orientation changes.
             mToolbarBackground.setBounds(0, 0, getWidth(), getHeight());
             mToolbarBackground.draw(canvas);
         }
 
         if (mLocationBarBackground != null
-                && (mPhoneLocationBar.getVisibility() == VISIBLE || mTextureCaptureMode)) {
-            updateUrlViewportBounds(mUrlViewportBounds, mVisualState, false);
+                && (mLocationBar.getVisibility() == VISIBLE || mTextureCaptureMode)) {
+            updateLocationBarBackgroundBounds(mLocationBarBackgroundBounds, mVisualState);
         }
 
         if (mTextureCaptureMode) {
             drawTabSwitcherAnimationOverlay(canvas, 0.f);
         } else {
             boolean tabSwitcherAnimationFinished = false;
             if (mTabSwitcherModeAnimation != null) {
                 tabSwitcherAnimationFinished = !mTabSwitcherModeAnimation.isRunning();
 
                 // Perform the fade logic before super.dispatchDraw(canvas) so that we can properly
@@ skipping 33 matching lines @@
                 && !getToolbarDataProvider().getNewTabPageForCurrentTab().isCardsUiEnabled()) {
             return;
         }
 
         mNtpSearchBoxScrollPercent = scrollPercentage;
         updateUrlExpansionPercent();
         updateUrlExpansionAnimation();
     }
 
     /**
-     * Calculate the bounds for UrlViewport and set them to out rect.
+     * Calculate the bounds for the location bar background and set them to {@code out}.
      */
-    private void updateUrlViewportBounds(Rect out, VisualState visualState,
-            boolean ignoreTranslationY) {
-        // Calculate the visible boundaries of the left and right most child views
-        // of the location bar.
+    private void updateLocationBarBackgroundBounds(Rect out, VisualState visualState) {
+        // Calculate the visible boundaries of the left and right most child views of the
+        // location bar.
+        float expansion = visualState == VisualState.NEW_TAB_NORMAL ? 1 : mUrlExpansionPercent;
         int leftViewPosition = (int) MathUtils.interpolate(
-                getViewBoundsLeftOfLocationBar(visualState), 0f, mUrlExpansionPercent)
-                - mUrlBackgroundPadding.left;
+                getViewBoundsLeftOfLocationBar(visualState),
+                -mLocationBarBackgroundCornerRadius,
+                expansion);
         int rightViewPosition = (int) MathUtils.interpolate(
-                getViewBoundsRightOfLocationBar(visualState), getWidth(), mUrlExpansionPercent)
-                + mUrlBackgroundPadding.right;
+                getViewBoundsRightOfLocationBar(visualState),
+                getWidth() + mLocationBarBackgroundCornerRadius,
+                expansion);
 
         // The bounds are set by the following:
         // - The left most visible location bar child view.
         // - The top of the viewport is aligned with the top of the location bar.
         // - The right most visible location bar child view.
         // - The bottom of the viewport is aligned with the bottom of the location bar.
         // Additional padding can be applied for use during animations.
-        float yOffset = ignoreTranslationY ? mPhoneLocationBar.getTop() : mPhoneLocationBar.getY();
-
+        int verticalMargin = (int) MathUtils.interpolate(mLocationBarVerticalMargin, 0, expansion);
         out.set(leftViewPosition,
-                (int) (yOffset - (mUrlBackgroundPadding.top * mUrlExpansionPercent)),
+                mLocationBar.getTop() + verticalMargin,
                 rightViewPosition,
-                (int) (yOffset + MathUtils.interpolate(mPhoneLocationBar.getMeasuredHeight(),
-                        getHeight() + mUrlBackgroundPadding.bottom, mUrlExpansionPercent)));
+                mLocationBar.getBottom() - verticalMargin);
     }
 
     /**
      * Updates percentage of current the URL focus change animation.
      * @param percent 1.0 is 100% focused, 0 is completely unfocused.
      */
     private void setUrlFocusChangePercent(float percent) {
         mUrlFocusChangePercent = percent;
         updateUrlExpansionPercent();
         updateUrlExpansionAnimation();
     }
 
     private void updateUrlExpansionPercent() {
         mUrlExpansionPercent = Math.max(mNtpSearchBoxScrollPercent, mUrlFocusChangePercent);
         assert mUrlExpansionPercent >= 0;
         assert mUrlExpansionPercent <= 1;
     }
 
+    /**
+     * Updates the parameters relating to expanding the location bar, as the result of either a
+     * focus change or scrolling the New Tab Page.
+     */
     private void updateUrlExpansionAnimation() {
         if (mIsInTabSwitcherMode || isTabSwitcherAnimationRunning()) {
             mToolbarButtonsContainer.setVisibility(VISIBLE);
             return;
         }
 
-        mLocationBarBackgroundOffset.setEmpty();
-
-        FrameLayout.LayoutParams locationBarLayoutParams =
-                getFrameLayoutParams(mPhoneLocationBar);
+        FrameLayout.LayoutParams locationBarLayoutParams = getFrameLayoutParams(mLocationBar);
         int currentLeftMargin = locationBarLayoutParams.leftMargin;
         int currentWidth = locationBarLayoutParams.width;
 
-        float inversePercent = 1f - mUrlExpansionPercent;
-        float locationBarTranslationX = mUnfocusedLocationBarLayoutLeft - currentLeftMargin;
-        boolean isLocationBarRtl = ApiCompatibilityUtils.isLayoutRtl(mPhoneLocationBar);
+        float locationBarBaseTranslationX = mUnfocusedLocationBarLayoutLeft - currentLeftMargin;
+        boolean isLocationBarRtl = ApiCompatibilityUtils.isLayoutRtl(mLocationBar);
         if (isLocationBarRtl) {
-            locationBarTranslationX += mUnfocusedLocationBarLayoutWidth - currentWidth;
+            locationBarBaseTranslationX += mUnfocusedLocationBarLayoutWidth - currentWidth;
         }
-        locationBarTranslationX *= inversePercent;
+        locationBarBaseTranslationX *= 1f - mUrlExpansionPercent;
 
-        mPhoneLocationBar.setTranslationX(locationBarTranslationX);
+        mLocationBarBackgroundNtpOffset.setEmpty();
+        mLocationBarNtpOffsetLeft = 0;
+        mLocationBarNtpOffsetRight = 0;
+
+        Tab currentTab = getToolbarDataProvider().getTab();
+        if (currentTab != null) {
+            NewTabPage ntp = getToolbarDataProvider().getNewTabPageForCurrentTab();
+            // Explicitly use the focus change percentage here because it applies scroll
+            // compensation that only applies during focus animations.
+            if (ntp != null && mUrlFocusChangeInProgress) {
+                ntp.setUrlFocusChangeAnimationPercent(mUrlFocusChangePercent);
+            }
+
+            if (isLocationBarShownInNTP()) {
+                updateNtpTransitionAnimation();
+            } else {
+                // Reset these values in case we transitioned to a different page during the
+                // transition.
+                resetNtpAnimationValues();
+            }
+        }
+
+        boolean isRtl = ApiCompatibilityUtils.isLayoutRtl(this);
+
+        float locationBarTranslationX;
+        // Get the padding straight from the location bar instead of
+        // |mLocationBarBackgroundPadding|, because it might be different in incognito mode.
+        if (isRtl) {
+            locationBarTranslationX = locationBarBaseTranslationX
+                    + mLocationBarNtpOffsetRight - mLocationBar.getPaddingRight();
+        } else {
+            locationBarTranslationX = locationBarBaseTranslationX
+                    + mLocationBarNtpOffsetLeft + mLocationBar.getPaddingLeft();
+        }
+        mLocationBar.setTranslationX(locationBarTranslationX);
 
         // Negate the location bar translation to keep the URL action container in the same
         // place during the focus expansion.
-        if (!isLocationBarRtl || ApiCompatibilityUtils.isLayoutRtl(this)) {
-            mUrlActionsContainer.setTranslationX(-locationBarTranslationX);
+        float urlActionsTranslationX = 0;
+        if (!isLocationBarRtl || isRtl) {
+            urlActionsTranslationX = -locationBarBaseTranslationX;
         }
 
-        mPhoneLocationBar.setUrlFocusChangePercent(mUrlExpansionPercent);
+        if (isRtl) {
+            urlActionsTranslationX += mLocationBarNtpOffsetLeft - mLocationBarNtpOffsetRight;
+        } else {
+            urlActionsTranslationX += mLocationBarNtpOffsetRight - mLocationBarNtpOffsetLeft;
+        }
+        mUrlActionContainer.setTranslationX(urlActionsTranslationX);
+
+        mLocationBar.setUrlFocusChangePercent(mUrlExpansionPercent);
 
         // Ensure the buttons are invisible after focusing the omnibox to prevent them from
         // accepting click events.
         int toolbarButtonVisibility = mUrlExpansionPercent == 1f ? INVISIBLE : VISIBLE;
         mToolbarButtonsContainer.setVisibility(toolbarButtonVisibility);
         if (mReturnButton.getVisibility() != GONE) {
             mReturnButton.setVisibility(toolbarButtonVisibility);
         }
         if (mHomeButton.getVisibility() != GONE) {
             mHomeButton.setVisibility(toolbarButtonVisibility);
         }
 
         // Force an invalidation of the location bar to properly handle the clipping of the URL
         // bar text as a result of the url action container translations.
-        mPhoneLocationBar.invalidate();
+        mLocationBar.invalidate();
         invalidate();
-
-        Tab currentTab = getToolbarDataProvider().getTab();
-        if (currentTab == null) return;
-
-        NewTabPage ntp = getToolbarDataProvider().getNewTabPageForCurrentTab();
-        // Explicitly use the focus change percentage here because it applies scroll compensation
-        // that only applies during focus animations.
-        if (ntp != null && mUrlFocusChangeInProgress) {
-            ntp.setUrlFocusChangeAnimationPercent(mUrlFocusChangePercent);
-        }
-
-        if (!isLocationBarShownInNTP()) {
-            // Reset these values in case we transitioned to a different page during the
-            // transition.
-            resetNtpAnimationValues();
-            return;
-        }
-
-        updateNtpTransitionAnimation();
     }
 
+    /**
+     * Reset the parameters for the New Tab Page transition animation (expanding the location bar as
+     * a result of scrolling the New Tab Page) to their default values.
+     */
     private void resetNtpAnimationValues() {
-        mLocationBarBackgroundOffset.setEmpty();
-        mPhoneLocationBar.setTranslationY(0);
+        mLocationBarBackgroundNtpOffset.setEmpty();
+        mLocationBar.setTranslationY(0);
         if (!mUrlFocusChangeInProgress) {
             mToolbarButtonsContainer.setTranslationY(0);
             mReturnButton.setTranslationY(0);
             mHomeButton.setTranslationY(0);
         }
         mToolbarShadow.setAlpha(1f);
-        mPhoneLocationBar.setAlpha(1);
+        mLocationBar.setAlpha(1);
         mForceDrawLocationBarBackground = false;
-        mUrlBackgroundAlpha = isIncognito()
-                || (mUnfocusedLocationBarUsesTransparentBg
-                        && !mUrlFocusChangeInProgress
-                        && !mPhoneLocationBar.hasFocus())
-                        ? LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA : 255;
+        mLocationBarBackgroundAlpha = 255;
+        if (isIncognito()
+                || (mUnfocusedLocationBarUsesTransparentBg && !mUrlFocusChangeInProgress
+                        && !mLocationBar.hasFocus())) {
+            mLocationBarBackgroundAlpha = LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA;
+        }
         setAncestorsShouldClipChildren(true);
         mNtpSearchBoxScrollPercent = UNINITIALIZED_PERCENT;
         updateUrlExpansionPercent();
     }
 
+    /**
+     * Updates the parameters of the New Tab Page transition animation (expanding the location bar
+     * as a result of scrolling the New Tab Page).
+     */
     private void updateNtpTransitionAnimation() {
         if (mIsInTabSwitcherMode) return;
 
-        NewTabPage ntp = getToolbarDataProvider().getNewTabPageForCurrentTab();
-
         setAncestorsShouldClipChildren(mUrlExpansionPercent == 0f);
         mToolbarShadow.setAlpha(0f);
 
-        float growthPercent = 0f;
-        if (ntp.isCardsUiEnabled() || mUrlExpansionPercent == 0f || mUrlExpansionPercent == 1f) {
-            growthPercent = 1f - mUrlExpansionPercent;
-        } else {
-            // During the transition from search box to omnibox, keep the omnibox drawing
-            // at the same size of the search box for first 40% of the scroll transition.
-            growthPercent = mUrlExpansionPercent <= 0.4f
-                    ? 1f : Math.min(1f, (1f - mUrlExpansionPercent) * 1.66667f);
-        }
-
-        int paddingTop = mPhoneLocationBar.getPaddingTop();
-        int paddingBottom = mPhoneLocationBar.getPaddingBottom();
-
-        ntp.getSearchBoxBounds(mNtpSearchBoxOriginalBounds, mNtpSearchBoxTransformedBounds);
-        float halfHeightDifference = (mNtpSearchBoxTransformedBounds.height()
-                - (mPhoneLocationBar.getMeasuredHeight() - paddingTop - paddingBottom
-                        + mLocationBarInsets)) / 2f;
-        mPhoneLocationBar.setTranslationY(growthPercent == 0f ? 0 : Math.max(0,
-                (mNtpSearchBoxTransformedBounds.top - mPhoneLocationBar.getTop()
-                        + halfHeightDifference)));
+        NewTabPage ntp = getToolbarDataProvider().getNewTabPageForCurrentTab();
+        ntp.getSearchBoxBounds(mNtpSearchBoxBounds, mNtpSearchBoxTranslation);
+        int locationBarTranslationY =
+                Math.max(0, (mNtpSearchBoxBounds.top - mLocationBar.getTop()));
+        mLocationBar.setTranslationY(locationBarTranslationY);
         if (!mUrlFocusChangeInProgress) {
             setButtonsTranslationY();
         }
 
-        mLocationBarBackgroundOffset.set(
-                (int) ((mNtpSearchBoxTransformedBounds.left - mUrlViewportBounds.left
-                        - mPhoneLocationBar.getPaddingLeft()) * growthPercent),
-                (int) ((-halfHeightDifference - paddingTop) * growthPercent),
-                (int) ((mNtpSearchBoxTransformedBounds.right - mUrlViewportBounds.right
-                        + mPhoneLocationBar.getPaddingRight()) * growthPercent),
-                (int) ((halfHeightDifference - paddingBottom + mLocationBarInsets)
-                        * growthPercent));
-
-        // The transparency of the location bar is dependent on how different its size is
-        // from the final value.  This is based on how much growth is applied between the
-        // desired size of the location bar to its drawn size.  The location bar then only
-        // starts becoming opaque once the growth is at least half done.
-        if (growthPercent >= 0.5f) {
-            mPhoneLocationBar.setAlpha(0);
+        // Linearly interpolate between the bounds of the search box on the NTP and the omnibox
+        // background bounds. |shrinkage| is the scaling factor for the offset -- if it's 1, we are
+        // shrinking the omnibox down to the size of the search box.
+        float shrinkage;
+        if (ntp.isCardsUiEnabled()) {
+            shrinkage = 1f
+                    - NTP_SEARCH_BOX_EXPANSION_INTERPOLATOR.getInterpolation(mUrlExpansionPercent);
         } else {
-            mPhoneLocationBar.setAlpha(1f - growthPercent * 2);
+            // During the transition from middle of the NTP to the top, keep the omnibox drawing
+            // at the same size of the search box for first 40% of the scroll transition.
+            shrinkage = Math.min(1f, (1f - mUrlExpansionPercent) * 1.66667f);
         }
 
-        // Go from a transparent url background to a fully opaque one in the first 40% of the
-        // scroll transition.
-        mUrlBackgroundAlpha =
-                mUrlExpansionPercent >= 0.4f ? 255 : (int) ((mUrlExpansionPercent * 2.5f) * 255);
-        if (mUrlExpansionPercent == 1f) mUrlBackgroundAlpha = 255;
-        mForceDrawLocationBarBackground = mUrlExpansionPercent != 0f;
+        int leftBoundDifference = mNtpSearchBoxBounds.left - mLocationBarBackgroundBounds.left;
+        int rightBoundDifference = mNtpSearchBoxBounds.right - mLocationBarBackgroundBounds.right;
+        mLocationBarBackgroundNtpOffset.set(
+                (int) Math.round(leftBoundDifference * shrinkage),
+                locationBarTranslationY,
+                (int) Math.round(rightBoundDifference * shrinkage),
+                locationBarTranslationY);
+
+        // The omnibox background bounds are outset by |mLocationBarBackgroundCornerRadius| in the
+        // fully expanded state (and only there!) to hide the rounded corners, so undo that before
+        // applying the shrinkage factor.
+        mLocationBarNtpOffsetLeft =
+                (leftBoundDifference - mLocationBarBackgroundCornerRadius) * shrinkage;
+        mLocationBarNtpOffsetRight =
+                (rightBoundDifference + mLocationBarBackgroundCornerRadius) * shrinkage;
+
+        mLocationBarBackgroundAlpha = mUrlExpansionPercent > 0f ? 255 : 0;
+        mForceDrawLocationBarBackground = mLocationBarBackgroundAlpha > 0;
+        float relativeAlpha = mLocationBarBackgroundAlpha / 255f;
+        mLocationBar.setAlpha(relativeAlpha);
+
+        // The search box on the NTP is visible if our omnibox is invisible, and vice-versa.
+        ntp.setSearchBoxAlpha(1f - relativeAlpha);
+
+        if (!ntp.isCardsUiEnabled()) {
+            ntp.setSearchProviderLogoAlpha(Math.max(1f - mUrlExpansionPercent * 2.5f, 0f));
+        }
     }
 
     private void setButtonsTranslationY() {
-        float searchBoxTranslationY =
-                mNtpSearchBoxTransformedBounds.top - mNtpSearchBoxOriginalBounds.top;
-        searchBoxTranslationY = Math.min(searchBoxTranslationY, 0);
+        int searchBoxTranslationY = Math.min(mNtpSearchBoxTranslation.y, 0);
         mToolbarButtonsContainer.setTranslationY(searchBoxTranslationY);
         mReturnButton.setTranslationY(searchBoxTranslationY);
         mHomeButton.setTranslationY(searchBoxTranslationY);
     }
 
     private void setAncestorsShouldClipChildren(boolean clip) {
         if (!isLocationBarShownInNTP()) return;
         ViewGroup parent = this;
         while (parent != null) {
             parent.setClipChildren(clip);
@@ skipping 36 matching lines @@
         }
         if (mHomeButton.getVisibility() != View.GONE) {
             // Draw the New Tab button used in the URL view.
             previousAlpha = mHomeButton.getAlpha();
             mHomeButton.setAlpha(previousAlpha * floatAlpha);
             drawChild(canvas, mHomeButton, SystemClock.uptimeMillis());
             mHomeButton.setAlpha(previousAlpha);
         }
 
         // Draw the location/URL bar.
-        previousAlpha = mPhoneLocationBar.getAlpha();
-        mPhoneLocationBar.setAlpha(previousAlpha * floatAlpha);
+        previousAlpha = mLocationBar.getAlpha();
+        mLocationBar.setAlpha(previousAlpha * floatAlpha);
         // If the location bar is now fully transparent, do not bother drawing it.
-        if (mPhoneLocationBar.getAlpha() != 0) {
-            drawChild(canvas, mPhoneLocationBar, SystemClock.uptimeMillis());
+        if (mLocationBar.getAlpha() != 0) {
+            drawChild(canvas, mLocationBar, SystemClock.uptimeMillis());
         }
-        mPhoneLocationBar.setAlpha(previousAlpha);
+        mLocationBar.setAlpha(previousAlpha);
 
         // Draw the tab stack button and associated text.
         translateCanvasToView(this, mToolbarButtonsContainer, canvas);
 
         if (mTabSwitcherAnimationTabStackDrawable != null && mToggleTabStackButton != null
                 && mUrlExpansionPercent != 1f) {
             // Draw the tab stack button image.
             canvas.save();
             translateCanvasToView(mToolbarButtonsContainer, mToggleTabStackButton, canvas);
 
@@ skipping 71 matching lines @@
             canvas.translate(to.getLeft(), to.getTop());
             if (!(to.getParent() instanceof View)) {
                 throw new IllegalArgumentException("View 'to' was not a desendent of 'from'.");
             }
             to = (View) to.getParent();
         }
     }
 
     @Override
     protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
-        if (child == mPhoneLocationBar) return drawLocationBar(canvas, drawingTime);
+        if (child == mLocationBar) return drawLocationBar(canvas, drawingTime);
         boolean clipped = false;
 
         if (mLocationBarBackground != null
                 && ((!mIsInTabSwitcherMode && !mTabSwitcherModeViews.contains(child))
                         || (mIsInTabSwitcherMode && mBrowsingModeViews.contains(child)))) {
             canvas.save();
-            if (mUrlExpansionPercent != 0f && mUrlViewportBounds.top < child.getBottom()) {
+
+            int translationY = (int) mLocationBar.getTranslationY();
+            int clipTop = mLocationBarBackgroundBounds.top - mLocationBarBackgroundPadding.top
+                    + translationY;
+            if (mUrlExpansionPercent != 0f && clipTop < child.getBottom()) {
                 // For other child views, use the inverse clipping of the URL viewport.
                 // Only necessary during animations.
                 // Hardware mode does not support unioned clip regions, so clip using the
                 // appropriate bounds based on whether the child is to the left or right of the
                 // location bar.
                 boolean isLeft = (child == mNewTabButton || child == mReturnButton
                         || child == mHomeButton) ^ LocalizationUtils.isLayoutRtl();
 
-                int clipTop = mUrlViewportBounds.top;
-                int clipBottom = mUrlViewportBounds.bottom;
+                int clipBottom = mLocationBarBackgroundBounds.bottom
+                        + mLocationBarBackgroundPadding.bottom + translationY;
                 boolean verticalClip = false;
-                if (mPhoneLocationBar.getTranslationY() > 0f) {
+                if (translationY > 0f) {
                     clipTop = child.getTop();
-                    clipBottom = mUrlViewportBounds.top;
+                    clipBottom = clipTop;
                     verticalClip = true;
                 }
 
                 if (isLeft) {
-                    canvas.clipRect(
-                            0, clipTop,
-                            verticalClip ? child.getMeasuredWidth() : mUrlViewportBounds.left,
-                            clipBottom);
+                    int clipRight = verticalClip ? child.getMeasuredWidth()
+                            : mLocationBarBackgroundBounds.left
+                                    - mLocationBarBackgroundPadding.left;
+                    canvas.clipRect(0, clipTop, clipRight, clipBottom);
                 } else {
-                    canvas.clipRect(
-                            verticalClip ? 0 : mUrlViewportBounds.right,
-                            clipTop, getMeasuredWidth(), clipBottom);
+                    int clipLeft = verticalClip ? 0 : mLocationBarBackgroundBounds.right
+                            + mLocationBarBackgroundPadding.right;
+                    canvas.clipRect(clipLeft, clipTop, getMeasuredWidth(), clipBottom);
                 }
             }
             clipped = true;
         }
         boolean retVal = super.drawChild(canvas, child, drawingTime);
         if (clipped) canvas.restore();
         return retVal;
     }
 
     private boolean drawLocationBar(Canvas canvas, long drawingTime) {
         boolean clipped = false;
 
         if (mLocationBarBackground != null && (!mIsInTabSwitcherMode || mTextureCaptureMode)) {
             canvas.save();
             int backgroundAlpha;
             if (mTabSwitcherModeAnimation != null) {
                 // Fade out/in the location bar towards the beginning of the animations to avoid
                 // large jumps of stark white.
                 backgroundAlpha =
-                        (int) (Math.pow(mPhoneLocationBar.getAlpha(), 3) * mUrlBackgroundAlpha);
+                        (int) (Math.pow(mLocationBar.getAlpha(), 3) * mLocationBarBackgroundAlpha);
             } else if (getToolbarDataProvider().isUsingBrandColor()
                     && !mBrandColorTransitionActive) {
                 backgroundAlpha = mUnfocusedLocationBarUsesTransparentBg
                         ? (int) (MathUtils.interpolate(LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA,
                                 255, mUrlExpansionPercent))
                         : 255;
             } else {
-                backgroundAlpha = mUrlBackgroundAlpha;
+                backgroundAlpha = mLocationBarBackgroundAlpha;
             }
             mLocationBarBackground.setAlpha(backgroundAlpha);
 
-            if ((mPhoneLocationBar.getAlpha() > 0 || mForceDrawLocationBarBackground)
+            if ((mLocationBar.getAlpha() > 0 || mForceDrawLocationBarBackground)
                     && !mTextureCaptureMode) {
                 mLocationBarBackground.setBounds(
-                        mUrlViewportBounds.left + mLocationBarBackgroundOffset.left,
-                        mUrlViewportBounds.top + mLocationBarBackgroundOffset.top,
-                        mUrlViewportBounds.right + mLocationBarBackgroundOffset.right,
-                        mUrlViewportBounds.bottom + mLocationBarBackgroundOffset.bottom);
+                        mLocationBarBackgroundBounds.left + mLocationBarBackgroundNtpOffset.left
+                                - mLocationBarBackgroundPadding.left,
+                        mLocationBarBackgroundBounds.top + mLocationBarBackgroundNtpOffset.top
+                                - mLocationBarBackgroundPadding.top,
+                        mLocationBarBackgroundBounds.right + mLocationBarBackgroundNtpOffset.right
+                                + mLocationBarBackgroundPadding.right,
+                        mLocationBarBackgroundBounds.bottom + mLocationBarBackgroundNtpOffset.bottom
+                                + mLocationBarBackgroundPadding.bottom);
                 mLocationBarBackground.draw(canvas);
             }
 
-            float locationBarClipLeft = mUrlViewportBounds.left
-                    + mPhoneLocationBar.getPaddingLeft() + mLocationBarBackgroundOffset.left;
-            float locationBarClipRight = mUrlViewportBounds.right
-                    - mPhoneLocationBar.getPaddingRight() + mLocationBarBackgroundOffset.right;
-            float locationBarClipTop = mUrlViewportBounds.top + mPhoneLocationBar.getPaddingTop()
-                    + mLocationBarBackgroundOffset.top;
-            float locationBarClipBottom = mUrlViewportBounds.bottom
-                    - mPhoneLocationBar.getPaddingBottom() + mLocationBarBackgroundOffset.bottom;
+            float locationBarClipLeft =
+                    mLocationBarBackgroundBounds.left + mLocationBarBackgroundNtpOffset.left;
+            float locationBarClipRight =
+                    mLocationBarBackgroundBounds.right + mLocationBarBackgroundNtpOffset.right;
+            float locationBarClipTop =
+                    mLocationBarBackgroundBounds.top + mLocationBarBackgroundNtpOffset.top;
+            float locationBarClipBottom =
+                    mLocationBarBackgroundBounds.bottom + mLocationBarBackgroundNtpOffset.bottom;
 
             // When unexpanded, the location bar's visible content boundaries are inset from the
             // viewport used to draw the background.  During expansion transitions, compensation
             // is applied to increase the clip regions such that when the location bar converts
             // to the narrower collapsed layout that the visible content is the same.
             if (mUrlExpansionPercent != 1f) {
                 int leftDelta = mUnfocusedLocationBarLayoutLeft
                         - getViewBoundsLeftOfLocationBar(mVisualState);
                 int rightDelta = getViewBoundsRightOfLocationBar(mVisualState)
                         - mUnfocusedLocationBarLayoutLeft
                         - mUnfocusedLocationBarLayoutWidth;
                 float inversePercent = 1f - mUrlExpansionPercent;
                 locationBarClipLeft += leftDelta * inversePercent;
                 locationBarClipRight -= rightDelta * inversePercent;
             }
 
             // Clip the location bar child to the URL viewport calculated in onDraw.
             canvas.clipRect(
                     locationBarClipLeft, locationBarClipTop,
                     locationBarClipRight, locationBarClipBottom);
             clipped = true;
         }
 
-        boolean retVal = super.drawChild(canvas, mPhoneLocationBar, drawingTime);
+        boolean retVal = super.drawChild(canvas, mLocationBar, drawingTime);
 
         if (clipped) canvas.restore();
         return retVal;
     }
 
     @Override
     protected void onSizeChanged(int w, int h, int oldw, int oldh) {
         mBackgroundOverlayBounds.set(0, 0, w, mToolbarHeightWithoutShadow);
         super.onSizeChanged(w, h, oldw, oldh);
     }
@@ skipping 76 matching lines @@
             mTabSwitcherModeAnimation = null;
         }
         if (mDelayedTabSwitcherModeAnimation != null) {
             mDelayedTabSwitcherModeAnimation.end();
             mDelayedTabSwitcherModeAnimation = null;
         }
 
         // The Android framework calls onAnimationEnd() on listeners before Animator#isRunning()
         // returns false. Sometimes this causes the progress bar visibility to be set incorrectly.
         // Update the visibility now that animations are set to null. (see crbug.com/606419)
-        updateProgressBarVisibility(mIsInTabSwitcherMode);
+        updateProgressBarVisibility();
     }
 
     @Override
     public void getLocationBarContentRect(Rect outRect) {
-        mLocationBarBackground.getPadding(outRect);
-        int paddingLeft = outRect.left;
-        int paddingTop = outRect.top;
-        int paddingRight = outRect.right;
-        int paddingBottom = outRect.bottom;
-
-        updateUrlViewportBounds(outRect, VisualState.NORMAL, true);
-
-        outRect.set(outRect.left + paddingLeft,
-                outRect.top + paddingTop,
-                outRect.right - paddingRight,
-                outRect.bottom - paddingBottom);
+        updateLocationBarBackgroundBounds(outRect, VisualState.NORMAL);
     }
 
     @Override
     protected void onHomeButtonUpdate(boolean homeButtonEnabled) {
         mIsHomeButtonEnabled = homeButtonEnabled;
         updateButtonVisibility();
     }
 
     @Override
     public void onWindowVisibilityChanged(int visibility) {
@@ skipping 44 matching lines @@
             final boolean animateNormalToolbar) {
         ObjectAnimator exitAnimation =
                 ObjectAnimator.ofFloat(this, mTabSwitcherModePercentProperty, 0.f);
         exitAnimation.setDuration(animateNormalToolbar
                 ? TAB_SWITCHER_MODE_EXIT_NORMAL_ANIMATION_DURATION_MS
                 : TAB_SWITCHER_MODE_EXIT_FADE_ANIMATION_DURATION_MS);
         exitAnimation.setInterpolator(new LinearInterpolator());
         exitAnimation.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
-                updateViewsForTabSwitcherMode(mIsInTabSwitcherMode);
+                updateViewsForTabSwitcherMode();
             }
         });
 
         return exitAnimation;
     }
 
     private ObjectAnimator createPostExitTabSwitcherAnimation() {
         ObjectAnimator exitAnimation = ObjectAnimator.ofFloat(
                 this, View.TRANSLATION_Y, -getHeight(), 0.f);
         exitAnimation.setDuration(TAB_SWITCHER_MODE_POST_EXIT_ANIMATION_DURATION_MS);
         exitAnimation.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
         exitAnimation.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
-                updateViewsForTabSwitcherMode(mIsInTabSwitcherMode);
+                updateViewsForTabSwitcherMode();
                 // On older builds, force an update to ensure the new visuals are used
                 // when bringing in the toolbar.  crbug.com/404571
                 if (Build.VERSION.SDK_INT == Build.VERSION_CODES.JELLY_BEAN) {
                     requestLayout();
                 }
             }
 
             @Override
             public void onAnimationEnd(Animator animation) {
                 mDelayedTabSwitcherModeAnimation = null;
-                updateShadowVisibility(mIsInTabSwitcherMode);
-                updateViewsForTabSwitcherMode(mIsInTabSwitcherMode);
+                updateShadowVisibility();
+                updateViewsForTabSwitcherMode();
             }
         });
 
         return exitAnimation;
     }
 
     @Override
     public void setTextureCaptureMode(boolean textureMode) {
         assert mTextureCaptureMode != textureMode;
         mTextureCaptureMode = textureMode;
         if (mTextureCaptureMode) {
             mToolbarShadow.setVisibility(VISIBLE);
             mPreTextureCaptureAlpha = getAlpha();
             setAlpha(1);
         } else {
             setAlpha(mPreTextureCaptureAlpha);
-            updateShadowVisibility(mIsInTabSwitcherMode);
+            updateShadowVisibility();
             mPreTextureCaptureAlpha = 1f;
         }
     }
 
     private boolean isTabSwitcherAnimationRunning() {
         return mUIAnimatingTabSwitcherTransition
                 || (mTabSwitcherModeAnimation != null && mTabSwitcherModeAnimation.isRunning())
                         || (mDelayedTabSwitcherModeAnimation != null
                                 && mDelayedTabSwitcherModeAnimation.isRunning());
     }
 
-    private void updateViewsForTabSwitcherMode(boolean isInTabSwitcherMode) {
-        int tabSwitcherViewsVisibility = isInTabSwitcherMode ? VISIBLE : INVISIBLE;
-        int browsingViewsVisibility = isInTabSwitcherMode ? INVISIBLE : VISIBLE;
+    private void updateViewsForTabSwitcherMode() {
+        int tabSwitcherViewsVisibility = mIsInTabSwitcherMode ? VISIBLE : INVISIBLE;
+        int browsingViewsVisibility = mIsInTabSwitcherMode ? INVISIBLE : VISIBLE;
 
         for (View view : mTabSwitcherModeViews) {
             view.setVisibility(tabSwitcherViewsVisibility);
         }
         for (View view : mBrowsingModeViews) {
             view.setVisibility(browsingViewsVisibility);
         }
         if (mShowMenuBadge) {
-            setMenuButtonContentDescription(!isInTabSwitcherMode);
+            setMenuButtonContentDescription(!mIsInTabSwitcherMode);
         }
 
-        updateProgressBarVisibility(isInTabSwitcherMode);
-        updateVisualsForToolbarState(isInTabSwitcherMode);
+        updateProgressBarVisibility();
+        updateVisualsForToolbarState();
     }
 
-    private void updateProgressBarVisibility(boolean isInTabSwitcherMode) {
+    private void updateProgressBarVisibility() {
         getProgressBar().setVisibility(
-                isInTabSwitcherMode || isTabSwitcherAnimationRunning() ? INVISIBLE : VISIBLE);
+                mIsInTabSwitcherMode || isTabSwitcherAnimationRunning() ? INVISIBLE : VISIBLE);
     }
 
     @Override
     protected void setContentAttached(boolean attached) {
-        updateVisualsForToolbarState(mIsInTabSwitcherMode);
+        updateVisualsForToolbarState();
     }
 
     @Override
     protected void setTabSwitcherMode(
             boolean inTabSwitcherMode, boolean showToolbar, boolean delayAnimation) {
         if (mIsInTabSwitcherMode == inTabSwitcherMode) return;
+        mIsInTabSwitcherMode = inTabSwitcherMode;
 
         finishAnimations();
 
         mDelayingTabSwitcherAnimation = delayAnimation;
 
         if (inTabSwitcherMode) {
             if (mUrlFocusLayoutAnimator != null && mUrlFocusLayoutAnimator.isRunning()) {
                 mUrlFocusLayoutAnimator.end();
                 mUrlFocusLayoutAnimator = null;
                 // After finishing the animation, force a re-layout of the location bar,
                 // so that the final translation position is correct (since onMeasure updates
                 // won't happen in tab switcher mode). crbug.com/518795.
                 layoutLocationBar(getMeasuredWidth());
                 updateUrlExpansionAnimation();
             }
             mNewTabButton.setEnabled(true);
-            updateViewsForTabSwitcherMode(true);
+            updateViewsForTabSwitcherMode();
             mTabSwitcherModeAnimation = createEnterTabSwitcherModeAnimation();
         } else {
             if (!mDelayingTabSwitcherAnimation) {
                 mTabSwitcherModeAnimation = createExitTabSwitcherAnimation(showToolbar);
             }
             mUIAnimatingTabSwitcherTransition = true;
         }
 
         mAnimateNormalToolbar = showToolbar;
-        mIsInTabSwitcherMode = inTabSwitcherMode;
         if (mTabSwitcherModeAnimation != null) mTabSwitcherModeAnimation.start();
 
         if (SysUtils.isLowEndDevice()) finishAnimations();
 
         postInvalidateOnAnimation();
     }
 
     @Override
     protected void onTabSwitcherTransitionFinished() {
         setAlpha(1.f);
         mClipRect = null;
         mUIAnimatingTabSwitcherTransition = false;
         mTabSwitcherModePercent = mIsInTabSwitcherMode ? 1.0f : 0.0f;
 
         if (!mAnimateNormalToolbar) {
             finishAnimations();
-            updateVisualsForToolbarState(mIsInTabSwitcherMode);
+            updateVisualsForToolbarState();
         }
 
         if (mDelayingTabSwitcherAnimation) {
             mDelayingTabSwitcherAnimation = false;
             mDelayedTabSwitcherModeAnimation = createPostExitTabSwitcherAnimation();
             mDelayedTabSwitcherModeAnimation.start();
         } else {
-            updateViewsForTabSwitcherMode(mIsInTabSwitcherMode);
+            updateViewsForTabSwitcherMode();
         }
     }
 
-    private void updateOverlayDrawables(boolean isInTabSwitcherMode) {
+    private void updateOverlayDrawables() {
         if (!isNativeLibraryReady()) return;
 
         VisualState overlayState = computeVisualState(false);
         boolean visualStateChanged = mOverlayDrawablesVisualState != overlayState;
 
         if (!visualStateChanged && mVisualState == VisualState.BRAND_COLOR
                 && getToolbarDataProvider().getPrimaryColor()
                         != mTabSwitcherAnimationBgOverlay.getColor()) {
             visualStateChanged = true;
         }
         if (!visualStateChanged) return;
 
         mOverlayDrawablesVisualState = overlayState;
         mTabSwitcherAnimationBgOverlay.setColor(getToolbarColorForVisualState(
                 mOverlayDrawablesVisualState));
 
         setTabSwitcherAnimationMenuDrawable();
         setUseLightDrawablesForTextureCapture();
 
-        if (!isInTabSwitcherMode && !mTextureCaptureMode && mLayoutUpdateHost != null) {
+        if (!mIsInTabSwitcherMode && !mTextureCaptureMode && mLayoutUpdateHost != null) {
             // Request a layout update to trigger a texture capture if the tint color is changing
             // and we're not already in texture capture mode. This is necessary if the tab switcher
             // is entered immediately after a change to the tint color without any user interactions
             // that would normally trigger a texture capture.
             mLayoutUpdateHost.requestUpdate();
         }
     }
 
     @Override
     public void destroy() {
@@ skipping 45 matching lines @@
             }
         };
     }
 
     private void populateUrlFocusingAnimatorSet(List<Animator> animators) {
         Animator animator = ObjectAnimator.ofFloat(this, mUrlFocusChangePercentProperty, 1f);
         animator.setDuration(URL_FOCUS_CHANGE_ANIMATION_DURATION_MS);
         animator.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
         animators.add(animator);
 
-        for (int i = 0; i < mPhoneLocationBar.getChildCount(); i++) {
-            View childView = mPhoneLocationBar.getChildAt(i);
-            if (childView == mPhoneLocationBar.getFirstViewVisibleWhenFocused()) break;
+        for (int i = 0; i < mLocationBar.getChildCount(); i++) {
+            View childView = mLocationBar.getChildAt(i);
+            if (childView == mLocationBar.getFirstViewVisibleWhenFocused()) break;
             animator = ObjectAnimator.ofFloat(childView, ALPHA, 0);
             animator.setDuration(URL_FOCUS_CHANGE_ANIMATION_DURATION_MS);
             animator.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
             animators.add(animator);
         }
 
         float density = getContext().getResources().getDisplayMetrics().density;
         boolean isRtl = ApiCompatibilityUtils.isLayoutRtl(this);
         float toolbarButtonTranslationX = MathUtils.flipSignIf(
                 URL_FOCUS_TOOLBAR_BUTTONS_TRANSLATION_X_DP, isRtl) * density;
@@ skipping 48 matching lines @@
             animator.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
             animators.add(animator);
 
             animator = ObjectAnimator.ofFloat(mToggleTabStackButton, ALPHA, 1);
             animator.setDuration(URL_FOCUS_TOOLBAR_BUTTONS_DURATION_MS);
             animator.setStartDelay(URL_CLEAR_FOCUS_TABSTACK_DELAY_MS);
             animator.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
             animators.add(animator);
         }
 
-        for (int i = 0; i < mPhoneLocationBar.getChildCount(); i++) {
-            View childView = mPhoneLocationBar.getChildAt(i);
-            if (childView == mPhoneLocationBar.getFirstViewVisibleWhenFocused()) break;
+        for (int i = 0; i < mLocationBar.getChildCount(); i++) {
+            View childView = mLocationBar.getChildAt(i);
+            if (childView == mLocationBar.getFirstViewVisibleWhenFocused()) break;
             animator = ObjectAnimator.ofFloat(childView, ALPHA, 1);
             animator.setStartDelay(URL_FOCUS_TOOLBAR_BUTTONS_DURATION_MS);
             animator.setDuration(URL_CLEAR_FOCUS_MENU_DELAY_MS);
             animator.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
             animators.add(animator);
         }
 
         if (isLocationBarShownInNTP() && mNtpSearchBoxScrollPercent == 0f) return;
 
         // The call to getLayout() can return null briefly during text changes, but as it
         // is only needed for RTL calculations, we proceed if the location bar is showing
         // LTR content.
-        boolean isLocationBarRtl = ApiCompatibilityUtils.isLayoutRtl(mPhoneLocationBar);
+        boolean isLocationBarRtl = ApiCompatibilityUtils.isLayoutRtl(mLocationBar);
         if (!isLocationBarRtl || mUrlBar.getLayout() != null) {
             int urlBarStartScrollX = 0;
             if (isLocationBarRtl) {
                 urlBarStartScrollX = (int) mUrlBar.getLayout().getPrimaryHorizontal(0);
                 urlBarStartScrollX -= mUrlBar.getWidth();
             }
 
             // If the scroll position matches the current scroll position, do not trigger
             // this animation as it will cause visible jumps when going from cleared text
             // back to page URLs (despite it continually calling setScrollX with the same
             // number).
             if (mUrlBar.getScrollX() != urlBarStartScrollX) {
-                animator = ObjectAnimator.ofInt(
-                        mUrlBar,
-                        buildUrlScrollProperty(mPhoneLocationBar, isLocationBarRtl),
-                        urlBarStartScrollX);
+                animator = ObjectAnimator.ofInt(mUrlBar,
+                        buildUrlScrollProperty(mLocationBar, isLocationBarRtl), urlBarStartScrollX);
                 animator.setDuration(URL_FOCUS_CHANGE_ANIMATION_DURATION_MS);
                 animator.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
                 animators.add(animator);
             }
         }
     }
 
     @Override
     public void onUrlFocusChange(final boolean hasFocus) {
         super.onUrlFocusChange(hasFocus);
@@ skipping 55 matching lines @@
 
             @Override
             public void onAnimationEnd(Animator animation) {
                 if (mCanceled) return;
 
                 if (!hasFocus) {
                     mDisableLocationBarRelayout = false;
                     mLayoutLocationBarInFocusedMode = false;
                     requestLayout();
                 }
-                mPhoneLocationBar.finishUrlFocusChange(hasFocus);
+                mLocationBar.finishUrlFocusChange(hasFocus);
                 mUrlFocusChangeInProgress = false;
             }
         });
         mUrlFocusLayoutAnimator.start();
     }
 
     @Override
     protected boolean shouldShowMenuButton() {
         // Even in Document mode, the toolbar menu button will be shown while on the NTP.  This
         // allows the menu to translate off the screen on scroll to match the tabbed behavior.
         if (mVisualState == VisualState.NEW_TAB_NORMAL) return true;
 
-        return !mPhoneLocationBar.showMenuButtonInOmnibox() && super.shouldShowMenuButton();
+        return !mLocationBar.showMenuButtonInOmnibox() && super.shouldShowMenuButton();
     }
 
     @Override
     protected void updateTabCountVisuals(int numberOfTabs) {
         if (mReturnButton != null) mReturnButton.setEnabled(true);
         if (mHomeButton != null) mHomeButton.setEnabled(true);
 
         if (mToggleTabStackButton == null) return;
 
         mToggleTabStackButton.setEnabled(numberOfTabs >= 1);
@@ skipping 28 matching lines @@
         if (mTabSwitcherAnimationTabStackDrawable != null) {
             mTabSwitcherAnimationTabStackDrawable.updateForTabCount(
                     numberOfTabs, isIncognito());
         }
     }
 
     @Override
     protected void onTabContentViewChanged() {
         super.onTabContentViewChanged();
         updateNtpAnimationState();
-        updateVisualsForToolbarState(mIsInTabSwitcherMode);
+        updateVisualsForToolbarState();
     }
 
     @Override
     protected void onTabOrModelChanged() {
         super.onTabOrModelChanged();
         updateNtpAnimationState();
-        updateVisualsForToolbarState(mIsInTabSwitcherMode);
+        updateVisualsForToolbarState();
 
         if (mHasCheckedIfTabSwitcherCalloutIsNecessary) {
             dismissTabSwitcherCallout();
         } else {
             mHasCheckedIfTabSwitcherCalloutIsNecessary = true;
             showTabSwitcherCalloutIfNecessary();
         }
     }
 
     private static boolean isVisualStateValidForBrandColorTransition(VisualState state) {
         return state == VisualState.NORMAL || state == VisualState.BRAND_COLOR;
     }
 
     @Override
     protected void onPrimaryColorChanged(boolean shouldAnimate) {
         super.onPrimaryColorChanged(shouldAnimate);
         if (mBrandColorTransitionActive) mBrandColorTransitionAnimation.cancel();
         if (!shouldAnimate || !isVisualStateValidForBrandColorTransition(mVisualState)) {
             return;
         }
         final int initialColor = mToolbarBackground.getColor();
         final int finalColor = getToolbarDataProvider().getPrimaryColor();
         if (initialColor == finalColor) return;
 
         boolean shouldUseOpaque = ColorUtils.shouldUseOpaqueTextboxBackground(finalColor);
-        final int initialAlpha = mUrlBackgroundAlpha;
+        final int initialAlpha = mLocationBarBackgroundAlpha;
         final int finalAlpha =
                 shouldUseOpaque ? 255 : LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA;
         final boolean shouldAnimateAlpha = initialAlpha != finalAlpha;
         mBrandColorTransitionAnimation = ValueAnimator.ofFloat(0, 1)
                 .setDuration(THEME_COLOR_TRANSITION_DURATION);
         mBrandColorTransitionAnimation.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
         mBrandColorTransitionAnimation.addUpdateListener(new AnimatorUpdateListener() {
             @Override
             public void onAnimationUpdate(ValueAnimator animation) {
                 float fraction = animation.getAnimatedFraction();
                 if (shouldAnimateAlpha) {
-                    mUrlBackgroundAlpha =
+                    mLocationBarBackgroundAlpha =
                             (int) (MathUtils.interpolate(initialAlpha, finalAlpha, fraction));
                 }
                 updateToolbarBackground(
                         ColorUtils.getColorWithOverlay(initialColor, finalColor, fraction));
             }
         });
         mBrandColorTransitionAnimation.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
                 mBrandColorTransitionActive = false;
-                updateVisualsForToolbarState(mIsInTabSwitcherMode);
+                updateVisualsForToolbarState();
             }
         });
         mBrandColorTransitionAnimation.start();
         mBrandColorTransitionActive = true;
     }
 
     private void updateNtpAnimationState() {
         // Store previous NTP scroll before calling reset as that clears this value.
         boolean wasShowingNtp = mVisibleNewTabPage != null;
         float previousNtpScrollPercent = mNtpSearchBoxScrollPercent;
@@ skipping 25 matching lines @@
         super.onDefaultSearchEngineChanged();
         // Post an update for the toolbar state, which will allow all other listeners
         // for the search engine change to update before we check on the state of the
         // world for a UI update.
         // TODO(tedchoc): Move away from updating based on the search engine change and instead
         //                add the toolbar as a listener to the NewTabPage and udpate only when
         //                it notifies the listeners that it has changed its state.
         post(new Runnable() {
             @Override
             public void run() {
-                updateVisualsForToolbarState(mIsInTabSwitcherMode);
+                updateVisualsForToolbarState();
                 updateNtpAnimationState();
             }
         });
     }
 
     @Override
     protected void handleFindToolbarStateChange(boolean showing) {
         setVisibility(showing ? View.GONE : View.VISIBLE);
         TransitionDrawable shadowDrawable = (TransitionDrawable) mToolbarShadow.getDrawable();
         if (showing) {
             shadowDrawable.startTransition(URL_FOCUS_CHANGE_ANIMATION_DURATION_MS);
         } else {
             shadowDrawable.reverseTransition(URL_FOCUS_CHANGE_ANIMATION_DURATION_MS);
         }
     }
 
     private boolean isLocationBarShownInNTP() {
         NewTabPage ntp = getToolbarDataProvider().getNewTabPageForCurrentTab();
         return ntp != null && ntp.isLocationBarShownInNTP();
     }
 
-    private void updateShadowVisibility(boolean isInTabSwitcherMode) {
-        boolean shouldDrawShadow = !isInTabSwitcherMode && !isTabSwitcherAnimationRunning();
+    private void updateShadowVisibility() {
+        boolean shouldDrawShadow = !mIsInTabSwitcherMode && !isTabSwitcherAnimationRunning();
         int shadowVisibility = shouldDrawShadow ? View.VISIBLE : View.INVISIBLE;
 
         if (mToolbarShadow.getVisibility() != shadowVisibility) {
             mToolbarShadow.setVisibility(shadowVisibility);
         }
     }
 
     private VisualState computeVisualState(boolean isInTabSwitcherMode) {
         if (isInTabSwitcherMode && isIncognito()) return VisualState.TAB_SWITCHER_INCOGNITO;
         if (isInTabSwitcherMode && !isIncognito()) return VisualState.TAB_SWITCHER_NORMAL;
         if (isLocationBarShownInNTP()) return VisualState.NEW_TAB_NORMAL;
         if (isIncognito()) return VisualState.INCOGNITO;
         if (getToolbarDataProvider().isUsingBrandColor()) return VisualState.BRAND_COLOR;
         return VisualState.NORMAL;
     }
 
-    private void updateVisualsForToolbarState(boolean isInTabSwitcherMode) {
+    private void updateVisualsForToolbarState() {
         final boolean isIncognito = isIncognito();
 
-        VisualState newVisualState = computeVisualState(isInTabSwitcherMode);
+        VisualState newVisualState = computeVisualState(mIsInTabSwitcherMode);
 
         // If we are navigating to or from a brand color, allow the transition animation
         // to run to completion as it will handle the triggering this path again and committing
         // the proper visual state when it finishes.  Brand color transitions are only valid
         // between normal non-incognito pages and brand color pages, so if the visual states
         // do not match then cancel the animation below.
         if (mBrandColorTransitionActive
                 && isVisualStateValidForBrandColorTransition(mVisualState)
                 && isVisualStateValidForBrandColorTransition(newVisualState)) {
             return;
@@ skipping 24 matching lines @@
                             != mUnfocusedLocationBarUsesTransparentBg) {
                 visualStateChanged = true;
             } else {
                 updateToolbarBackground(VisualState.BRAND_COLOR);
                 getProgressBar().setThemeColor(themeColorForProgressBar, isIncognito());
             }
         }
 
         mVisualState = newVisualState;
 
-        updateOverlayDrawables(isInTabSwitcherMode);
-        updateShadowVisibility(isInTabSwitcherMode);
+        updateOverlayDrawables();
+        updateShadowVisibility();
+        updateUrlExpansionAnimation();
         if (!visualStateChanged) {
             if (mVisualState == VisualState.NEW_TAB_NORMAL) {
                 updateNtpTransitionAnimation();
             }
             return;
         }
 
         mUseLightToolbarDrawables = false;
         mUnfocusedLocationBarUsesTransparentBg = false;
-        mUrlBackgroundAlpha = 255;
+        mLocationBarBackgroundAlpha = 255;
         updateToolbarBackground(mVisualState);
         getProgressBar().setThemeColor(themeColorForProgressBar, isIncognito());
 
-        if (isInTabSwitcherMode) {
+        if (mIsInTabSwitcherMode) {
             mUseLightToolbarDrawables = true;
-            mUrlBackgroundAlpha = LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA;
+            mLocationBarBackgroundAlpha = LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA;
             getProgressBar().setBackgroundColor(mProgressBackBackgroundColorWhite);
             getProgressBar().setForegroundColor(ApiCompatibilityUtils.getColor(getResources(),
                     R.color.progress_bar_foreground_white));
         } else if (isIncognito()) {
             mUseLightToolbarDrawables = true;
-            mUrlBackgroundAlpha = LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA;
+            mLocationBarBackgroundAlpha = LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA;
         } else if (mVisualState == VisualState.BRAND_COLOR) {
             mUseLightToolbarDrawables =
                     ColorUtils.shouldUseLightForegroundOnBackground(currentPrimaryColor);
             mUnfocusedLocationBarUsesTransparentBg =
                     !ColorUtils.shouldUseOpaqueTextboxBackground(currentPrimaryColor);
-            mUrlBackgroundAlpha = mUnfocusedLocationBarUsesTransparentBg
-                    ? LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA : 255;
+            mLocationBarBackgroundAlpha = mUnfocusedLocationBarUsesTransparentBg
+                    ? LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA
+                    : 255;
         }
 
         if (mToggleTabStackButton != null) {
             mToggleTabStackButton.setImageDrawable(mUseLightToolbarDrawables
                     ? mTabSwitcherButtonDrawableLight : mTabSwitcherButtonDrawable);
             if (mTabSwitcherAnimationTabStackDrawable != null) {
                 mTabSwitcherAnimationTabStackDrawable.setTint(
                         mUseLightToolbarDrawables ? mLightModeTint : mDarkModeTint);
             }
         }
 
         if (shouldShowMenuButton()) {
             mMenuButton.setTint(mUseLightToolbarDrawables ? mLightModeTint : mDarkModeTint);
 
-            if (mShowMenuBadge && !isInTabSwitcherMode) {
+            if (mShowMenuBadge && !mIsInTabSwitcherMode) {
                 setAppMenuUpdateBadgeDrawable(mUseLightToolbarDrawables);
             }
         }
         ColorStateList tint = mUseLightToolbarDrawables ? mLightModeTint : mDarkModeTint;
         if (isReturnButtonVisible()) mReturnButton.setTint(tint);
         if (mIsHomeButtonEnabled) mHomeButton.setTint(tint);
 
-        mPhoneLocationBar.updateVisualsForState();
+        mLocationBar.updateVisualsForState();
         // Remove the side padding for incognito to ensure the badge icon aligns correctly with the
         // background of the location bar.
         if (isIncognito) {
-            mPhoneLocationBar.setPadding(
-                    0, mUrlBackgroundPadding.top, 0, mUrlBackgroundPadding.bottom);
+            mLocationBar.setPadding(
+                    0, mLocationBarBackgroundPadding.top, 0, mLocationBarBackgroundPadding.bottom);
         } else {
-            mPhoneLocationBar.setPadding(
-                    mUrlBackgroundPadding.left, mUrlBackgroundPadding.top,
-                    mUrlBackgroundPadding.right, mUrlBackgroundPadding.bottom);
+            mLocationBar.setPadding(
+                    mLocationBarBackgroundPadding.left, mLocationBarBackgroundPadding.top,
+                    mLocationBarBackgroundPadding.right, mLocationBarBackgroundPadding.bottom);
         }
 
         // We update the alpha before comparing the visual state as we need to change
         // its value when entering and exiting TabSwitcher mode.
-        if (isLocationBarShownInNTP() && !isInTabSwitcherMode) {
+        if (isLocationBarShownInNTP() && !mIsInTabSwitcherMode) {
             updateNtpTransitionAnimation();
         }
 
-        if (isInTabSwitcherMode) mNewTabButton.setIsIncognito(isIncognito);
+        if (mIsInTabSwitcherMode) mNewTabButton.setIsIncognito(isIncognito);
 
         CharSequence newTabContentDescription = getResources().getText(
                 isIncognito ? R.string.accessibility_toolbar_btn_new_incognito_tab :
                         R.string.accessibility_toolbar_btn_new_tab);
         if (mNewTabButton != null
                 && !newTabContentDescription.equals(mNewTabButton.getContentDescription())) {
             mNewTabButton.setContentDescription(newTabContentDescription);
         }
 
         getMenuButtonWrapper().setVisibility(shouldShowMenuButton() ? View.VISIBLE : View.GONE);
     }
 
     @Override
     public LocationBar getLocationBar() {
-        return mPhoneLocationBar;
+        return mLocationBar;
     }
 
     @Override
     public void showAppMenuUpdateBadge() {
         super.showAppMenuUpdateBadge();
 
         // Set up variables.
         if (!mBrowsingModeViews.contains(mMenuBadge)) {
             mBrowsingModeViews.add(mMenuBadge);
         }
 
         // Finish any in-progress animations and set the TabSwitcherAnimationMenuBadgeDrawables.
         finishAnimations();
         setTabSwitcherAnimationMenuBadgeDrawable();
 
         // Show the badge.
         if (!mIsInTabSwitcherMode && shouldShowMenuButton()) {
             if (mUseLightToolbarDrawables) {
                 setAppMenuUpdateBadgeDrawable(mUseLightToolbarDrawables);
             }
             setAppMenuUpdateBadgeToVisible(true);
         }
 
-        mPhoneLocationBar.showAppMenuUpdateBadge(true);
+        mLocationBar.showAppMenuUpdateBadge(true);
     }
 
     @Override
     public void removeAppMenuUpdateBadge(boolean animate) {
         super.removeAppMenuUpdateBadge(animate);
 
         if (mBrowsingModeViews.contains(mMenuBadge)) {
             mBrowsingModeViews.remove(mMenuBadge);
             mTabSwitcherAnimationMenuBadgeDarkDrawable = null;
             mTabSwitcherAnimationMenuBadgeLightDrawable = null;
         }
 
-        mPhoneLocationBar.removeAppMenuUpdateBadge(animate);
+        mLocationBar.removeAppMenuUpdateBadge(animate);
     }
 
     private void setTabSwitcherAnimationMenuDrawable() {
         if (!shouldShowMenuButton()) return;
         mTabSwitcherAnimationMenuDrawable = ApiCompatibilityUtils.getDrawable(getResources(),
                 R.drawable.btn_menu);
         mTabSwitcherAnimationMenuDrawable.mutate();
         mTabSwitcherAnimationMenuDrawable.setColorFilter(
                 isIncognito() ? mLightModeDefaultColor : mDarkModeDefaultColor,
                 PorterDuff.Mode.SRC_IN);
@@ skipping 66 matching lines @@
         });
 
         if (mFullscreenManager != null) {
             mFullscreenCalloutToken =
                     mFullscreenManager.showControlsPersistentAndClearOldToken(
                             mFullscreenCalloutToken);
         }
     }
 }