Merge java_staging/src into java/src.

chrome/android/java_staging/src/org/chromium/chrome/browser/compositor/layouts/phone/stack/StackTab.java

Index: chrome/android/java_staging/src/org/chromium/chrome/browser/compositor/layouts/phone/stack/StackTab.java
diff --git a/chrome/android/java_staging/src/org/chromium/chrome/browser/compositor/layouts/phone/stack/StackTab.java b/chrome/android/java_staging/src/org/chromium/chrome/browser/compositor/layouts/phone/stack/StackTab.java
deleted file mode 100644
index 7cdf28408b5ec07481faebefbd3c645a72900ef7..0000000000000000000000000000000000000000
--- a/chrome/android/java_staging/src/org/chromium/chrome/browser/compositor/layouts/phone/stack/StackTab.java
+++ /dev/null
@@ -1,521 +0,0 @@
-// 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.layouts.phone.stack;
-
-import android.content.Context;
-import android.content.res.Resources;
-
-import org.chromium.base.annotations.SuppressFBWarnings;
-import org.chromium.chrome.R;
-import org.chromium.chrome.browser.compositor.layouts.ChromeAnimation;
-import org.chromium.chrome.browser.compositor.layouts.Layout.Orientation;
-import org.chromium.chrome.browser.compositor.layouts.components.LayoutTab;
-
-/**
- * StackTab is used to keep track of a thumbnail's bitmap and position and to
- * draw itself onto the GL canvas at the desired Y Offset.
- * @VisibleForTesting
- */
-@SuppressFBWarnings("MS_PKGPROTECT")
-public class StackTab implements ChromeAnimation.Animatable<StackTab.Property> {
-    /**
-     * Properties that can be animated by using a
-     * {@link org.chromium.chrome.browser.compositor.layouts.ChromeAnimation.Animatable}.
-     */
-    enum Property {
-        SCALE,
-        SCROLL_OFFSET,
-        ALPHA,
-        X_IN_STACK_INFLUENCE,
-        X_IN_STACK_OFFSET,
-        X_OUT_OF_STACK,
-        Y_IN_STACK_INFLUENCE,
-        Y_IN_STACK_OFFSET,
-        Y_OUT_OF_STACK,
-        DISCARD_AMOUNT
-    }
-
-    // Cached values from values/dimens.xml
-    public static float sStackedTabVisibleSize; // stacked_tab_visible_size
-    public static float sStackBufferWidth; // stack_buffer_width
-    public static float sStackBufferHeight; // stack_buffer_height
-
-    // Positioner selector
-    private float mXInStackInfluence = 1.0f;
-    private float mYInStackInfluence = 1.0f;
-
-    // In stack positioner
-    private float mScrollOffset = 0.0f;
-    private float mXInStackOffset = 0.0f;
-    private float mYInStackOffset = 0.0f;
-
-    // Out of stack positioner
-    private float mXOutOfStack = 0.0f;
-    private float mYOutOfStack = 0.0f;
-
-    // Values that get animated
-    private float mAlpha = 1.0f;
-    private float mScale = 1.0f;
-    private float mDiscardAmount = 0.0f; // This might alter position, rotation and alpha
-
-    // Discard states
-    private float mDiscardOriginX;
-    private float mDiscardOriginY;
-    private boolean mDiscardFromClick;
-
-    // The index of the tab in the stack
-    private int mIndex;
-
-    // True if the tab is currently being removed (while animating).
-    protected boolean mDying = false;
-
-    // The visibility sorting value is used to determine the importance of the tab for
-    // texture allocation. It is computed from the area and its position in the stack.
-    // Larger values will have more priority for acquiring texture. Negative values "often"
-    // means that the tab is not visible at all (but there are no guaranty and it's fine).
-    private float mCachedVisibleArea = 0; // Intermediate value
-    private float mCachedIndexDistance = 0; // Intermediate value
-    private float mCacheStackVisibility = 1.0f; // Intermediate value
-    private long mVisiblitySortingValue = 0; // Sorting value based on visible area.
-    private int mOrderSortingValue = 0; // Sorting value based on distance to selection.
-
-    private LayoutTab mLayoutTab;
-
-    /**
-     * @param tab The tab this instance is supposed to draw.
-     */
-    public StackTab(LayoutTab tab) {
-        mLayoutTab = tab;
-    }
-
-    /**
-     * @param index The new index in the stack layout.
-     */
-    public void setNewIndex(int index) {
-        mIndex = index;
-    }
-
-    /**
-     * @return The index in the stack layout.
-     */
-    public int getIndex() {
-        return mIndex;
-    }
-
-    /**
-     * @return The {@link LayoutTab} this instance is supposed to draw.
-     */
-    public LayoutTab getLayoutTab() {
-        return mLayoutTab;
-    }
-
-    /**
-     * Set the {@link LayoutTab} this instance is supposed to draw.
-     */
-    public void setLayoutTab(LayoutTab tab) {
-        mLayoutTab = tab;
-    }
-
-    /**
-     * @return The id of the tab, same as the id from the Tab in TabModel.
-     */
-    public int getId() {
-        return mLayoutTab.getId();
-    }
-
-    /**
-     * @param y The vertical translation to be applied after the placement in the stack.
-     */
-    public void setYInStackOffset(float y) {
-        mYInStackOffset = y;
-    }
-
-    /**
-     * @return The vertical translation applied after the placement in the stack.
-     */
-    public float getYInStackOffset() {
-        return mYInStackOffset;
-    }
-
-    /**
-     * @param x The horizontal translation to be applied after the placement in the stack.
-     */
-    public void setXInStackOffset(float x) {
-        mXInStackOffset = x;
-    }
-
-    /**
-     * @return The horizontal translation applied after the placement in the stack.
-     */
-    public float getXInStackOffset() {
-        return mXInStackOffset;
-    }
-
-    /**
-     * @param y The vertical absolute position when out of stack.
-     */
-    public void setYOutOfStack(float y) {
-        mYOutOfStack = y;
-    }
-
-    /**
-     * @return The vertical absolute position when out of stack.
-     */
-    public float getYOutOfStack() {
-        return mYOutOfStack;
-    }
-
-    /**
-     * @param x The horizontal absolute position when out of stack.
-     */
-    public void setXOutOfStack(float x) {
-        mXOutOfStack = x;
-    }
-
-    /**
-     * @return The horizontal absolute position when out of stack.
-     */
-    public float getXOutOfStack() {
-        return mXOutOfStack;
-    }
-
-    /**
-     * Set the transparency value for all of the tab (the contents,
-     * border, etc...).  For components that allow specifying
-     * their own alpha values, it will use the min of these two fields.
-     *
-     * @param f The transparency value for the tab.
-     */
-    public void setAlpha(float f) {
-        mAlpha = f;
-    }
-
-    /**
-     * @return The transparency value for all of the tab components.
-     */
-    public float getAlpha() {
-        return mAlpha;
-    }
-
-    /**
-     * @param xInStackInfluence The horizontal blend value between instack
-     *                          and out of stack pacement [0 .. 1].
-     */
-    public void setXInStackInfluence(float xInStackInfluence) {
-        mXInStackInfluence = xInStackInfluence;
-    }
-
-    /**
-     * @return The horizontal blend value between instack and out of stack pacement [0 .. 1].
-     */
-    public float getXInStackInfluence() {
-        return mXInStackInfluence;
-    }
-
-    /**
-     * @param yInStackInfluence The vertical blend value between instack
-     *                          and out of stack pacement [0 .. 1].
-     */
-    public void setYInStackInfluence(float yInStackInfluence) {
-        mYInStackInfluence = yInStackInfluence;
-    }
-
-    /**
-     * @return The verical blend value between instack and out of stack pacement [0 .. 1].
-     */
-    public float getYInStackInfluence() {
-        return mYInStackInfluence;
-    }
-
-    /**
-     * @param scale The scale to apply to the tab, compared to the parent.
-     */
-    public void setScale(float scale) {
-        mScale = scale;
-    }
-
-    /**
-     * @return The scale to apply to the tab, compared to the parent.
-     */
-    public float getScale() {
-        return mScale;
-    }
-
-    /**
-     * @param offset The offset of the tab along the scrolling direction in scroll space.
-     */
-    public void setScrollOffset(float offset) {
-        mScrollOffset = offset;
-    }
-
-    /**
-     * @return The offset of the tab along the scrolling direction in scroll space.
-     */
-    public float getScrollOffset() {
-        return mScrollOffset;
-    }
-
-    /**
-     * @param amount The amount of discard displacement. 0 is no discard. Negative is discard
-     *               on the left. Positive is discard on the right.
-     */
-    public void setDiscardAmount(float amount) {
-        mDiscardAmount = amount;
-    }
-
-    /**
-     * @param deltaAmount The amount of delta discard to be added to the current discard amount.
-     */
-    public void addToDiscardAmount(float deltaAmount) {
-        mDiscardAmount += deltaAmount;
-    }
-
-    /**
-     * @return The amount of discard displacement. 0 is no discard. Negative is discard
-     *         on the left. Positive is discard on the right.
-     */
-    public float getDiscardAmount() {
-        return mDiscardAmount;
-    }
-
-    /**
-     * @param x The x coordinate in tab space of where the discard transforms should originate.
-     */
-    public void setDiscardOriginX(float x) {
-        mDiscardOriginX = x;
-    }
-
-    /**
-     * @param y The y coordinate in tab space of where the discard transforms should originate.
-     */
-    public void setDiscardOriginY(float y) {
-        mDiscardOriginY = y;
-    }
-
-    /**
-     * @return The x coordinate in tab space of where the discard transforms should originate.
-     */
-    public float getDiscardOriginX() {
-        return mDiscardOriginX;
-    }
-
-    /**
-     * @return The y coordinate in tab space of where the discard transforms should originate.
-     */
-    public float getDiscardOriginY() {
-        return mDiscardOriginY;
-    }
-
-    /**
-     * @param fromClick Whether or not this discard was from a click event.
-     */
-    public void setDiscardFromClick(boolean fromClick) {
-        mDiscardFromClick = fromClick;
-    }
-
-    /**
-     * @return Whether or not this discard was from a click event.
-     */
-    public boolean getDiscardFromClick() {
-        return mDiscardFromClick;
-    }
-
-    /**
-     * @param dying True if the Tab/ContentView will be destroyed, and we are still animating its
-     *              visible representation.
-     */
-    public void setDying(boolean dying) {
-        mDying = dying;
-    }
-
-    /**
-     * @return True if the Tab/ContentView is destroyed, but we are still animating its
-     *         visible representation.
-     */
-    public boolean isDying() {
-        return mDying;
-    }
-
-    /**
-     * The scroll space does not map linearly to the screen so it creates a nice slow down
-     * effect at the top of the screen while scrolling.
-     * Warps x so it matches y(x) = x - warpSize on the positive side and 0 on the negative side
-     * with a smooth transition between [0, 2 * warpSize].
-     * @see #screenToScroll(float, float)
-     *
-     * [-oo, 0] -> 0
-     * [0, 2 * warpSize] -> warpSize * ((x-warpSize) / 2 * warpSize + 0.5) ^ 2.
-     * [2 * warpSize, +oo] -> x
-     * @param x        The offset in scroll space.
-     * @param warpSize The size in scroll space of the slow down effect.
-     * @return         The offset on screen corresponding to the scroll space offset.
-     */
-    public static float scrollToScreen(float x, float warpSize) {
-        if (x <= 0) return 0;
-        if (x >= 2 * warpSize) return x - warpSize;
-        x = (x - warpSize) / (2.0f * warpSize) + 0.5f;
-        return x * x * warpSize;
-    }
-
-    /**
-     * Unwarps x so it matches the above warp function.
-     * @see #scrollToScreen(float, float)
-     *
-     * [-oo, 0] -> -warpSize
-     * [0, warpSize] -> 2 * warpSize * sqrt(x / warpSize).
-     * [warpSize, +oo] -> x + warpSize
-     * @param x        The screen space offset.
-     * @param warpSize The size in scroll space of the slow down effect.
-     * @return         The offset in scroll space corresponding to the offset on screen.
-     */
-    public static float screenToScroll(float x, float warpSize) {
-        if (x <= 0) return 0;
-        if (x >= warpSize) return x + warpSize;
-        return (float) Math.sqrt(x * warpSize) * 2;
-    }
-
-    /**
-     * @param orientation The orientation to choose to get the size.
-     * @return            The size of the content along the provided orientation.
-     */
-    public float getSizeInScrollDirection(int orientation) {
-        if (orientation == Orientation.PORTRAIT) {
-            return mLayoutTab.getScaledContentHeight();
-        } else {
-            return mLayoutTab.getScaledContentWidth();
-        }
-    }
-
-    /**
-     * Helper function that gather the static constants from values/dimens.xml.
-     * @param context The Android Context.
-     */
-    public static void resetDimensionConstants(Context context) {
-        Resources res = context.getResources();
-        final float pxToDp = 1.0f / res.getDisplayMetrics().density;
-        sStackedTabVisibleSize =
-                res.getDimensionPixelOffset(R.dimen.stacked_tab_visible_size) * pxToDp;
-        sStackBufferWidth = res.getDimensionPixelOffset(R.dimen.stack_buffer_width) * pxToDp;
-        sStackBufferHeight = res.getDimensionPixelOffset(R.dimen.stack_buffer_height) * pxToDp;
-    }
-
-    /**
-     * Reset the offset to factory default.
-     */
-    public void resetOffset() {
-        mXInStackInfluence = 1.0f;
-        mYInStackInfluence = 1.0f;
-        mScrollOffset = 0.0f;
-        mXInStackOffset = 0.0f;
-        mYInStackOffset = 0.0f;
-        mXOutOfStack = 0.0f;
-        mYOutOfStack = 0.0f;
-        mDiscardOriginX = 0.f;
-        mDiscardOriginY = 0.f;
-        mDiscardFromClick = false;
-    }
-
-    /**
-     * Updates the cached visible area value to be used to sort tabs by visibility.
-     * @param referenceIndex The index that has the highest priority.
-     */
-    public void updateVisiblityValue(int referenceIndex) {
-        mCachedVisibleArea = mLayoutTab.computeVisibleArea();
-        mCachedIndexDistance = Math.abs(mIndex - referenceIndex);
-        mOrderSortingValue = computeOrderSortingValue(mCachedIndexDistance, mCacheStackVisibility);
-        mVisiblitySortingValue = computeVisibilitySortingValue(
-                mCachedVisibleArea, mOrderSortingValue, mCacheStackVisibility);
-    }
-
-    /**
-     * Updates the cached visible area value to be used to sort tabs by visibility.
-     * @param stackVisibility   Multiplier that represents how much the stack fills the screen.
-     */
-    public void updateStackVisiblityValue(float stackVisibility) {
-        mCacheStackVisibility = stackVisibility;
-        mOrderSortingValue = computeOrderSortingValue(mCachedIndexDistance, mCacheStackVisibility);
-        mVisiblitySortingValue = computeVisibilitySortingValue(
-                mCachedVisibleArea, mOrderSortingValue, mCacheStackVisibility);
-    }
-
-    /**
-     * Computes the visibility sorting value based on the tab visible area, its distance to the
-     * central index and the overall visibility of the stack.
-     * The '-index' index factor need to be smaller for stack that have small visibility.
-     * Multiplying by a small stackVisibility makes it bigger (because it is negative), hence the
-     * division. To avoid dividing by 0 it need to be offset a bit. 0.1f is the 'a bit' part of
-     * the explanation.
-     */
-    private static long computeVisibilitySortingValue(
-            float area, float orderSortingValue, float stackVisibility) {
-        return (long) (area * stackVisibility - orderSortingValue);
-    }
-
-    /**
-     * @return The cached visible sorting value. Call updateCachedVisibleArea to update it.
-     */
-    public long getVisiblitySortingValue() {
-        return mVisiblitySortingValue;
-    }
-
-    /**
-     * Computes the ordering value only based on the distance of the tab to the center one.
-     * Low values have higher priority.
-     */
-    private static int computeOrderSortingValue(float indexDistance, float stackVisibility) {
-        return (int) ((indexDistance + 1) / (0.1f + 0.9f * stackVisibility));
-    }
-
-    /**
-     * @return The cached order sorting value. Used to sort based on the tab ordering rather than
-     *         visible area.
-     */
-    public int getOrderSortingValue() {
-        return mOrderSortingValue;
-    }
-
-    /**
-     * Callback for
-     * {@link org.chromium.chrome.browser.compositor.layouts.ChromeAnimation.Animatable}
-     *
-     * @param prop The property to set
-     * @param val The value to set it to
-     */
-    @Override
-    public void setProperty(Property prop, float val) {
-        switch (prop) {
-            case SCALE:
-                setScale(val);
-                break;
-            case SCROLL_OFFSET:
-                setScrollOffset(val);
-                break;
-            case ALPHA:
-                setAlpha(val);
-                break;
-            case X_IN_STACK_INFLUENCE:
-                setXInStackInfluence(val);
-                break;
-            case X_IN_STACK_OFFSET:
-                setXInStackOffset(val);
-                break;
-            case X_OUT_OF_STACK:
-                setXOutOfStack(val);
-                break;
-            case Y_IN_STACK_INFLUENCE:
-                setYInStackInfluence(val);
-                break;
-            case Y_IN_STACK_OFFSET:
-                setYInStackOffset(val);
-                break;
-            case Y_OUT_OF_STACK:
-                setYOutOfStack(val);
-                break;
-            case DISCARD_AMOUNT:
-                setDiscardAmount(val);
-                break;
-        }
-    }
-}