Use a scrollable tab strip on tablets at small widths

chrome/android/java/src/org/chromium/chrome/browser/compositor/overlays/strip/StripLayoutHelperManager.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.compositor.overlays.strip;
 
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.RectF;
 
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.compositor.LayerTitleCache;
 import org.chromium.chrome.browser.compositor.layouts.LayoutRenderHost;
 import org.chromium.chrome.browser.compositor.layouts.LayoutUpdateHost;
 import org.chromium.chrome.browser.compositor.layouts.components.CompositorButton;
 import org.chromium.chrome.browser.compositor.layouts.components.VirtualView;
-import org.chromium.chrome.browser.compositor.layouts.content.TabContentManager;
 import org.chromium.chrome.browser.compositor.layouts.eventfilter.AreaGestureEventFilter;
 import org.chromium.chrome.browser.compositor.layouts.eventfilter.EventFilter;
 import org.chromium.chrome.browser.compositor.overlays.SceneOverlay;
 import org.chromium.chrome.browser.compositor.scene_layer.SceneOverlayLayer;
 import org.chromium.chrome.browser.compositor.scene_layer.TabStripSceneLayer;
+import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tabmodel.TabCreatorManager;
+import org.chromium.chrome.browser.tabmodel.TabModel;
 import org.chromium.chrome.browser.tabmodel.TabModelSelector;
+import org.chromium.ui.base.LocalizationUtils;
 import org.chromium.ui.resources.ResourceManager;
 
 import java.util.List;
 
 /**
  * This class handles managing which {@link StripLayoutHelper} is currently active and dispatches
  * all input and model events to the proper destination.
  */
 public class StripLayoutHelperManager implements SceneOverlay {
     // Caching Variables
     private final RectF mStripFilterArea = new RectF();
 
     // 1px border colors
     private static final float BORDER_OPACITY = 0.2f;
     private static final float BORDER_OPACITY_INCOGNITO = 0.4f;
 
     // Model selector buttons constants.
     private static final float MODEL_SELECTOR_BUTTON_Y_OFFSET_DP = 10.f;
-    private static final float MODEL_SELECTOR_BUTTON_RIGHT_PADDING_DP = 6.f;
-    private static final float MODEL_SELECTOR_BUTTON_LEFT_PADDING_DP = 3.f;
+    private static final float MODEL_SELECTOR_BUTTON_END_PADDING_DP = 6.f;
+    private static final float MODEL_SELECTOR_BUTTON_START_PADDING_DP = 3.f;
     private static final float MODEL_SELECTOR_BUTTON_WIDTH_DP = 24.f;
     private static final float MODEL_SELECTOR_BUTTON_HEIGHT_DP = 24.f;
 
     // External influences
     private TabModelSelector mTabModelSelector;
     private final LayoutUpdateHost mUpdateHost;
-    private final LayoutRenderHost mRenderHost;
 
     // Event Filters
     private final AreaGestureEventFilter mEventFilter;
 
     // Internal state
     private boolean mIsIncognito;
     private final StripLayoutHelper mNormalHelper;
     private final StripLayoutHelper mIncognitoHelper;
 
     // UI State
     private float mWidth;  // in dp units
     private final float mHeight;  // in dp units
     private int mOrientation;
     private final CompositorButton mModelSelectorButton;
 
     private TabStripSceneLayer mTabStripTreeProvider;
 
     /**
      * Creates an instance of the {@link StripLayoutHelperManager}.
      * @param context           The current Android {@link Context}.
      * @param updateHost        The parent {@link LayoutUpdateHost}.
      * @param renderHost        The {@link LayoutRenderHost}.
      */
     public StripLayoutHelperManager(Context context, LayoutUpdateHost updateHost,
             LayoutRenderHost renderHost, AreaGestureEventFilter eventFilter) {
         mUpdateHost = updateHost;
-        mRenderHost = renderHost;
         mTabStripTreeProvider = new TabStripSceneLayer(context);
 
         mEventFilter = eventFilter;
 
         mNormalHelper = new StripLayoutHelper(context, updateHost, renderHost, false);
         mIncognitoHelper = new StripLayoutHelper(context, updateHost, renderHost, true);
 
         mModelSelectorButton = new CompositorButton(
                 context, MODEL_SELECTOR_BUTTON_WIDTH_DP, MODEL_SELECTOR_BUTTON_HEIGHT_DP);
         mModelSelectorButton.setIncognito(false);
@@ skipping 19 matching lines @@
     public void destroy() {
         mTabStripTreeProvider.destroy();
         mTabStripTreeProvider = null;
     }
 
     @Override
     public SceneOverlayLayer getUpdatedSceneOverlayTree(LayerTitleCache layerTitleCache,
             ResourceManager resourceManager, float yOffset) {
         assert mTabStripTreeProvider != null;
 
+        Tab selectedTab = mTabModelSelector.getCurrentModel().getTabAt(
+                mTabModelSelector.getCurrentModel().index());
+        int selectedTabId = selectedTab == null ? TabModel.INVALID_TAB_INDEX : selectedTab.getId();
         mTabStripTreeProvider.pushAndUpdateStrip(this, layerTitleCache, resourceManager,
-                getActiveStripLayoutHelper().getStripLayoutTabsToRender(), yOffset);
+                getActiveStripLayoutHelper().getStripLayoutTabsToRender(), yOffset,
+                selectedTabId);
         return mTabStripTreeProvider;
     }
 
     @Override
     public EventFilter getEventFilter() {
         return mEventFilter;
     }
 
     @Override
     public void onSizeChanged(
             float width, float height, float visibleViewportOffsetY, int orientation) {
         mWidth = width;
         mOrientation = orientation;
-        mModelSelectorButton.setX(
-                mWidth - MODEL_SELECTOR_BUTTON_WIDTH_DP - MODEL_SELECTOR_BUTTON_RIGHT_PADDING_DP);
+        if (!LocalizationUtils.isLayoutRtl()) {
+            mModelSelectorButton.setX(
+                    mWidth - MODEL_SELECTOR_BUTTON_WIDTH_DP - MODEL_SELECTOR_BUTTON_END_PADDING_DP);
+        } else {
+            mModelSelectorButton.setX(MODEL_SELECTOR_BUTTON_END_PADDING_DP);
+        }
+
         mNormalHelper.onSizeChanged(mWidth, mHeight);
         mIncognitoHelper.onSizeChanged(mWidth, mHeight);
 
         mStripFilterArea.set(0, 0, mWidth, Math.min(getHeight(), visibleViewportOffsetY));
         mEventFilter.setEventArea(mStripFilterArea);
     }
 
     public CompositorButton getNewTabButton() {
         return getActiveStripLayoutHelper().getNewTabButton();
     }
 
     public CompositorButton getModelSelectorButton() {
         return mModelSelectorButton;
     }
 
     @Override
     public void getVirtualViews(List<VirtualView> views) {
         if (mModelSelectorButton.isVisible()) views.add(mModelSelectorButton);
         getActiveStripLayoutHelper().getVirtualViews(views);
     }
 
     @Override
     public boolean shouldHideAndroidTopControls() {
         return false;
     }
 
     /**
+     * @return The opacity to use for the fade on the left side of the tab strip.
+     */
+    public float getLeftFadeOpacity() {
+        return getActiveStripLayoutHelper().getLeftFadeOpacity();
+    }
+
+    /**
+     * @return The opacity to use for the fade on the right side of the tab strip.
+     */
+    public float getRightFadeOpacity() {
+        return getActiveStripLayoutHelper().getRightFadeOpacity();
+    }
+
+    /**
      * @return The brightness of background tabs in the tabstrip.
      */
     public float getBackgroundTabBrightness() {
         return getActiveStripLayoutHelper().getBackgroundTabBrightness();
     }
 
     /**
      * @param brightness Sets the brightness for the entire tabstrip.
      */
     public void setBrightness(float brightness) {
         getActiveStripLayoutHelper().setBrightness(brightness);
     }
 
     /**
      * @return The brightness of the entire tabstrip.
      */
     public float getBrightness() {
         return getActiveStripLayoutHelper().getBrightness();
     }
 
     /**
      * Sets the {@link TabModelSelector} that this {@link StripLayoutHelperManager} will visually
      * represent, and various objects associated with it.
      * @param modelSelector The {@link TabModelSelector} to visually represent.
      * @param tabCreatorManager The {@link TabCreatorManager}, used to create new tabs.
-     * @param tabContentManager The {@link TabContentManager}, used to provide display content for
-     *                          tabs.
      */
     public void setTabModelSelector(TabModelSelector modelSelector,
-            TabCreatorManager tabCreatorManager, TabContentManager tabContentManager) {
+            TabCreatorManager tabCreatorManager) {
         if (mTabModelSelector == modelSelector) return;
         mTabModelSelector = modelSelector;
-        mNormalHelper.setTabModel(mTabModelSelector.getModel(false), tabContentManager,
+        mNormalHelper.setTabModel(mTabModelSelector.getModel(false),
                 tabCreatorManager.getTabCreator(false));
-        mIncognitoHelper.setTabModel(mTabModelSelector.getModel(true), tabContentManager,
+        mIncognitoHelper.setTabModel(mTabModelSelector.getModel(true),
                 tabCreatorManager.getTabCreator(true));
         tabModelSwitched(mTabModelSelector.isIncognitoSelected());
     }
 
     @Override
     public void tabTitleChanged(int tabId, String title) {
         getActiveStripLayoutHelper().tabTitleChanged(tabId, title);
     }
 
     public float getHeight() {
@@ skipping 41 matching lines @@
 
         mUpdateHost.requestUpdate();
     }
 
     private void updateModelSwitcherButton() {
         mModelSelectorButton.setIncognito(mIsIncognito);
         if (mTabModelSelector != null) {
             boolean isVisible = mTabModelSelector.getModel(true).getCount() != 0;
             mModelSelectorButton.setVisible(isVisible);
 
-            float rightMargin = isVisible
-                    ? MODEL_SELECTOR_BUTTON_WIDTH_DP + MODEL_SELECTOR_BUTTON_RIGHT_PADDING_DP
-                            + MODEL_SELECTOR_BUTTON_LEFT_PADDING_DP
+            float endMargin = isVisible
+                    ? MODEL_SELECTOR_BUTTON_WIDTH_DP + MODEL_SELECTOR_BUTTON_END_PADDING_DP
+                            + MODEL_SELECTOR_BUTTON_START_PADDING_DP
                     : 0.0f;
-            mNormalHelper.setRightMargin(rightMargin);
-            mIncognitoHelper.setRightMargin(rightMargin);
+
+            mNormalHelper.setEndMargin(endMargin);
+            mIncognitoHelper.setEndMargin(endMargin);
         }
     }
 
     @Override
     public void tabSelected(long time, boolean incognito, int id, int prevId) {
         getStripLayoutHelper(incognito).tabSelected(time, id, prevId);
     }
 
     @Override
     public void tabMoved(long time, boolean incognito, int id, int oldIndex, int newIndex) {
@@ skipping 134 matching lines @@
      */
     @VisibleForTesting
     public StripLayoutHelper getActiveStripLayoutHelper() {
         return getStripLayoutHelper(mIsIncognito);
     }
 
     private StripLayoutHelper getInactiveStripLayoutHelper() {
         return mIsIncognito ? mNormalHelper : mIncognitoHelper;
     }
 }