// 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;

import static org.chromium.base.test.util.Restriction.RESTRICTION_TYPE_NON_LOW_END_DEVICE;

import android.content.DialogInterface;
import android.content.pm.ActivityInfo;
import android.os.Debug;
import android.os.SystemClock;
import android.support.test.filters.LargeTest;
import android.support.test.filters.MediumTest;
import android.support.test.filters.SmallTest;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.View;

import org.chromium.base.ThreadUtils;
import org.chromium.base.annotations.SuppressFBWarnings;
import org.chromium.base.test.util.CallbackHelper;
import org.chromium.base.test.util.CommandLineFlags;
import org.chromium.base.test.util.DisabledTest;
import org.chromium.base.test.util.Feature;
import org.chromium.base.test.util.FlakyTest;
import org.chromium.base.test.util.Restriction;
import org.chromium.base.test.util.RetryOnFailure;
import org.chromium.base.test.util.UrlUtils;
import org.chromium.chrome.R;
import org.chromium.chrome.browser.compositor.CompositorViewHolder;
import org.chromium.chrome.browser.compositor.layouts.Layout;
import org.chromium.chrome.browser.compositor.layouts.LayoutManager;
import org.chromium.chrome.browser.compositor.layouts.LayoutManagerChrome;
import org.chromium.chrome.browser.compositor.layouts.LayoutManagerChromePhone;
import org.chromium.chrome.browser.compositor.layouts.StaticLayout;
import org.chromium.chrome.browser.compositor.layouts.components.LayoutTab;
import org.chromium.chrome.browser.compositor.layouts.eventfilter.EdgeSwipeEventFilter.ScrollDirection;
import org.chromium.chrome.browser.compositor.layouts.eventfilter.EdgeSwipeHandler;
import org.chromium.chrome.browser.compositor.layouts.phone.StackLayout;
import org.chromium.chrome.browser.compositor.layouts.phone.stack.Stack;
import org.chromium.chrome.browser.compositor.layouts.phone.stack.StackTab;
import org.chromium.chrome.browser.tab.Tab;
import org.chromium.chrome.browser.tabmodel.EmptyTabModelObserver;
import org.chromium.chrome.browser.tabmodel.EmptyTabModelSelectorObserver;
import org.chromium.chrome.browser.tabmodel.TabModel;
import org.chromium.chrome.browser.tabmodel.TabModel.TabSelectionType;
import org.chromium.chrome.browser.tabmodel.TabModelObserver;
import org.chromium.chrome.browser.tabmodel.TabModelSelector;
import org.chromium.chrome.browser.tabmodel.TabModelSelectorImpl;
import org.chromium.chrome.browser.tabmodel.TabModelUtils;
import org.chromium.chrome.browser.tabmodel.TabbedModeTabPersistencePolicy;
import org.chromium.chrome.browser.toolbar.ToolbarPhone;
import org.chromium.chrome.test.ChromeTabbedActivityTestBase;
import org.chromium.chrome.test.util.ApplicationTestUtils;
import org.chromium.chrome.test.util.ChromeRestriction;
import org.chromium.chrome.test.util.ChromeTabUtils;
import org.chromium.chrome.test.util.MenuUtils;
import org.chromium.chrome.test.util.NewTabPageTestUtils;
import org.chromium.chrome.test.util.OverviewModeBehaviorWatcher;
import org.chromium.content.browser.ContentViewCore;
import org.chromium.content.browser.test.util.Criteria;
import org.chromium.content.browser.test.util.CriteriaHelper;
import org.chromium.content.browser.test.util.DOMUtils;
import org.chromium.content.browser.test.util.JavaScriptUtils;
import org.chromium.content.browser.test.util.UiUtils;
import org.chromium.content.common.ContentSwitches;
import org.chromium.content_public.browser.WebContents;
import org.chromium.content_public.browser.WebContentsObserver;
import org.chromium.net.test.EmbeddedTestServer;

import java.io.File;
import java.util.Locale;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;

/**
 * General Tab tests.
 */
public class TabsTest extends ChromeTabbedActivityTestBase {

    private static final String TEST_FILE_PATH =
            "/chrome/test/data/android/tabstest/tabs_test.html";
    private static final String TEST_PAGE_FILE_PATH = "/chrome/test/data/google/google.html";

    private EmbeddedTestServer mTestServer;

    private float mPxToDp = 1.0f;
    private float mTabsViewHeightDp;
    private float mTabsViewWidthDp;

    private boolean mNotifyChangedCalled;

    private static final int SWIPE_TO_RIGHT_DIRECTION = 1;
    private static final int SWIPE_TO_LEFT_DIRECTION = -1;

    private static final long WAIT_RESIZE_TIMEOUT_MS = 3000;

    private static final int STRESSFUL_TAB_COUNT = 100;

    private static final String INITIAL_SIZE_TEST_URL = UrlUtils.encodeHtmlDataUri(
            "<html><head><meta name=\"viewport\" content=\"width=device-width\">"
            + "<script>"
            + "  document.writeln(window.innerWidth + ',' + window.innerHeight);"
            + "</script></head>"
            + "<body>"
            + "</body></html>");

    private static final String RESIZE_TEST_URL = UrlUtils.encodeHtmlDataUri(
            "<html><head><script>"
            + "  var resizeHappened = false;"
            + "  function onResize() {"
            + "    resizeHappened = true;"
            + "    document.getElementById('test').textContent ="
            + "       window.innerWidth + 'x' + window.innerHeight;"
            + "  }"
            + "</script></head>"
            + "<body onresize=\"onResize()\">"
            + "  <div id=\"test\">No resize event has been received yet.</div>"
            + "</body></html>");

    @Override
    protected void tearDown() throws Exception {
        if (mTestServer != null) {
            mTestServer.stopAndDestroyServer();
        }
        super.tearDown();
    }

    /**
     * Verify that spawning a popup from a background tab in a different model works properly.
     * @throws InterruptedException
     * @throws TimeoutException
     */
    @LargeTest
    @Feature({"Navigation"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @CommandLineFlags.Add(ContentSwitches.DISABLE_POPUP_BLOCKING)
    @RetryOnFailure
    public void testSpawnPopupOnBackgroundTab() throws InterruptedException, TimeoutException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        loadUrl(mTestServer.getURL(TEST_FILE_PATH));
        final Tab tab = getActivity().getActivityTab();

        newIncognitoTabFromMenu();

        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                tab.getWebContents().evaluateJavaScriptForTests(
                        "(function() {"
                        + "  window.open('www.google.com');"
                        + "})()",
                        null);
            }
        });

        CriteriaHelper.pollUiThread(Criteria.equals(2, new Callable<Integer>() {
            @Override
            public Integer call() {
                return getActivity().getTabModelSelector().getModel(false).getCount();
            }
        }));
    }

    @MediumTest
    @RetryOnFailure
    public void testAlertDialogDoesNotChangeActiveModel() throws InterruptedException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        newIncognitoTabFromMenu();
        loadUrl(mTestServer.getURL(TEST_FILE_PATH));
        final Tab tab = getActivity().getActivityTab();
        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                tab.getWebContents().evaluateJavaScriptForTests(
                        "(function() {"
                        + "  alert('hi');"
                        + "})()",
                        null);
            }
        });

        final AtomicReference<JavascriptAppModalDialog> dialog =
                new AtomicReference<>();

        CriteriaHelper.pollInstrumentationThread(new Criteria() {
            @Override
            public boolean isSatisfied() {
                dialog.set(JavascriptAppModalDialog.getCurrentDialogForTest());

                return dialog.get() != null;
            }
        });

        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                dialog.get().onClick(null, DialogInterface.BUTTON_POSITIVE);
            }
        });

        dialog.set(null);

        CriteriaHelper.pollInstrumentationThread(new Criteria() {
            @Override
            public boolean isSatisfied() {
                return JavascriptAppModalDialog.getCurrentDialogForTest() == null;
            }
        });

        assertTrue("Incognito model was not selected",
                getActivity().getTabModelSelector().isIncognitoSelected());
    }

    /**
     * Verify New Tab Open and Close Event not from the context menu.
     * @throws InterruptedException
     *
     * https://crbug.com/490473
     * @LargeTest
     * @Feature({"Android-TabSwitcher"})
     * @Restriction(RESTRICTION_TYPE_PHONE)
     */
    @DisabledTest
    public void testOpenAndCloseNewTabButton() throws InterruptedException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        startMainActivityWithURL(mTestServer.getURL(TEST_FILE_PATH));
        getInstrumentation().runOnMainSync(new Runnable() {
            @Override
            public void run() {
                String title = getActivity().getCurrentTabModel().getTabAt(0).getTitle();
                assertEquals("Data file for TabsTest", title);
            }
        });
        final int tabCount = getActivity().getCurrentTabModel().getCount();
        OverviewModeBehaviorWatcher overviewModeWatcher = new OverviewModeBehaviorWatcher(
                getActivity().getLayoutManager(), true, false);
        View tabSwitcherButton = getActivity().findViewById(R.id.tab_switcher_button);
        assertNotNull("'tab_switcher_button' view is not found", tabSwitcherButton);
        singleClickView(tabSwitcherButton);
        overviewModeWatcher.waitForBehavior();
        overviewModeWatcher = new OverviewModeBehaviorWatcher(
                getActivity().getLayoutManager(), false, true);
        View newTabButton = getActivity().findViewById(R.id.new_tab_button);
        assertNotNull("'new_tab_button' view is not found", newTabButton);
        singleClickView(newTabButton);
        overviewModeWatcher.waitForBehavior();

        getInstrumentation().runOnMainSync(new Runnable() {
            @Override
            public void run() {
                assertEquals("The tab count is wrong",
                        tabCount + 1, getActivity().getCurrentTabModel().getCount());
            }
        });

        CriteriaHelper.pollUiThread(new Criteria() {
            @Override
            public boolean isSatisfied() {
                Tab tab = getActivity().getCurrentTabModel().getTabAt(1);
                String title = tab.getTitle().toLowerCase(Locale.US);
                String expectedTitle = "new tab";
                return title.startsWith(expectedTitle);
            }
        });

        ChromeTabUtils.closeCurrentTab(getInstrumentation(), getActivity());
        getInstrumentation().runOnMainSync(new Runnable() {
            @Override
            public void run() {
                assertEquals(tabCount, getActivity().getCurrentTabModel().getCount());
            }
        });
    }

    private void assertWaitForKeyboardStatus(final boolean show) throws InterruptedException {
        CriteriaHelper.pollUiThread(new Criteria() {
            @Override
            public boolean isSatisfied() {
                updateFailureReason("expected keyboard show: " + show);
                return show
                        == org.chromium.ui.UiUtils.isKeyboardShowing(
                                   getActivity(), getActivity().getTabsView());
            }
        });
    }

    /**
     * Verify that opening a new tab, switching to an existing tab and closing current tab hide
     * keyboard.
     */
    @LargeTest
    @Restriction(ChromeRestriction.RESTRICTION_TYPE_TABLET)
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testHideKeyboard() throws Exception {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());

        // Open a new tab(The 1st tab) and click node.
        ChromeTabUtils.fullyLoadUrlInNewTab(
                getInstrumentation(), getActivity(), mTestServer.getURL(TEST_FILE_PATH), false);
        assertEquals("Failed to click node.", true,
                DOMUtils.clickNode(
                        this, getActivity().getActivityTab().getContentViewCore(), "input_text"));
        assertWaitForKeyboardStatus(true);

        // Open a new tab(the 2nd tab).
        ChromeTabUtils.fullyLoadUrlInNewTab(
                getInstrumentation(), getActivity(), mTestServer.getURL(TEST_FILE_PATH), false);
        assertWaitForKeyboardStatus(false);

        // Click node in the 2nd tab.
        DOMUtils.clickNode(this, getActivity().getActivityTab().getContentViewCore(), "input_text");
        assertWaitForKeyboardStatus(true);

        // Switch to the 1st tab.
        ChromeTabUtils.switchTabInCurrentTabModel(getActivity(), 1);
        assertWaitForKeyboardStatus(false);

        // Click node in the 1st tab.
        DOMUtils.clickNode(this, getActivity().getActivityTab().getContentViewCore(), "input_text");
        assertWaitForKeyboardStatus(true);

        // Close current tab(the 1st tab).
        ChromeTabUtils.closeCurrentTab(getInstrumentation(), getActivity());
        assertWaitForKeyboardStatus(false);
    }

    /**
     * Verify that opening a new window hides keyboard.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testHideKeyboardWhenOpeningWindow() throws Exception {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        // Open a new tab and click an editable node.
        ChromeTabUtils.fullyLoadUrlInNewTab(
                getInstrumentation(), getActivity(), mTestServer.getURL(TEST_FILE_PATH), false);
        assertEquals("Failed to click textarea.", true,
                DOMUtils.clickNode(
                        this, getActivity().getActivityTab().getContentViewCore(), "textarea"));
        assertWaitForKeyboardStatus(true);

        // Click the button to open a new window.
        assertEquals("Failed to click button.", true,
                DOMUtils.clickNode(
                        this, getActivity().getActivityTab().getContentViewCore(), "button"));
        assertWaitForKeyboardStatus(false);
    }

    /**
     * Verify that opening a new tab and navigating immediately sets a size on the newly created
     * renderer. https://crbug.com/434477.
     * @throws InterruptedException
     * @throws TimeoutException
     */
    @SmallTest
    @RetryOnFailure
    public void testNewTabSetsContentViewSize() throws InterruptedException, TimeoutException {
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        getInstrumentation().waitForIdleSync();

        // Make sure we're on the NTP
        Tab tab = getActivity().getActivityTab();
        NewTabPageTestUtils.waitForNtpLoaded(tab);

        loadUrl(INITIAL_SIZE_TEST_URL);

        final WebContents webContents = tab.getWebContents();
        String innerText = JavaScriptUtils.executeJavaScriptAndWaitForResult(
                webContents, "document.body.innerText").replace("\"", "");

        DisplayMetrics metrics = getActivity().getResources().getDisplayMetrics();

        // For non-integer pixel ratios like the N7v1 (1.333...), the layout system will actually
        // ceil the width.
        int expectedWidth = (int) Math.ceil(metrics.widthPixels / metrics.density);

        String[] nums = innerText.split(",");
        assertTrue(nums.length == 2);
        int innerWidth = Integer.parseInt(nums[0]);
        int innerHeight = Integer.parseInt(nums[1]);

        assertEquals(expectedWidth, innerWidth);

        // Height can be affected by browser controls so just make sure it's non-0.
        assertTrue("innerHeight was not set by page load time", innerHeight > 0);
    }

    static class SimulateClickOnMainThread implements Runnable {
        private final LayoutManagerChrome mLayoutManager;
        private final float mX;
        private final float mY;

        public SimulateClickOnMainThread(LayoutManagerChrome layoutManager, float x, float y) {
            mLayoutManager = layoutManager;
            mX = x;
            mY = y;
        }

        @Override
        public void run() {
            mLayoutManager.simulateClick(mX, mY);
        }
    }

    static class SimulateTabSwipeOnMainThread implements Runnable {
        private final LayoutManagerChrome mLayoutManager;
        private final float mX;
        private final float mY;
        private final float mDeltaX;
        private final float mDeltaY;

        public SimulateTabSwipeOnMainThread(LayoutManagerChrome layoutManager, float x, float y,
                float dX, float dY) {
            mLayoutManager = layoutManager;
            mX = x;
            mY = y;
            mDeltaX = dX;
            mDeltaY = dY;
        }

        @Override
        public void run() {
            mLayoutManager.simulateDrag(mX, mY, mDeltaX, mDeltaY);
        }
    }

    /**
     * Verify that the provided click position closes a tab.
     * @throws InterruptedException
     */
    private void checkCloseTabAtPosition(final float x, final float y)
            throws InterruptedException {
        getActivity();

        int initialTabCount = getActivity().getCurrentTabModel().getCount();
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        getInstrumentation().waitForIdleSync();
        View button = getActivity().findViewById(R.id.tab_switcher_button);
        OverviewModeBehaviorWatcher overviewModeWatcher = new OverviewModeBehaviorWatcher(
                getActivity().getLayoutManager(), true, false);
        singleClickView(button);
        overviewModeWatcher.waitForBehavior();
        assertTrue("Expected: " + (initialTabCount + 1) + " tab Got: "
                + getActivity().getCurrentTabModel().getCount(),
                (initialTabCount + 1) == getActivity().getCurrentTabModel().getCount());
        getInstrumentation().waitForIdleSync();
        final LayoutManagerChrome layoutManager = updateTabsViewSize();
        ChromeTabUtils.closeTabWithAction(getInstrumentation(), getActivity(), new Runnable() {
            @Override
            public void run() {
                getInstrumentation().runOnMainSync(
                        new SimulateClickOnMainThread(layoutManager, x, y));
            }
        });
        assertTrue("Expected: " + initialTabCount + " tab Got: "
                + getActivity().getCurrentTabModel().getCount(),
                initialTabCount == getActivity().getCurrentTabModel().getCount());
    }

    /**
     * Verify close button works in the TabSwitcher in portrait mode.
     * This code does not handle properly different screen densities.
     * @throws InterruptedException
     */
    @LargeTest
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testTabSwitcherPortraitCloseButton() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        int portraitWidth = Math.min(getActivity().getResources().getDisplayMetrics().widthPixels,
                getActivity().getResources().getDisplayMetrics().heightPixels);
        // Hard-coded coordinates of the close button on the top right of the screen.
        // If the coordinates need to be updated, the easiest is to take a screenshot and measure.
        // Note that starting from the right of the screen should cover any screen size.
        checkCloseTabAtPosition(portraitWidth * mPxToDp - 32, 70);
    }

    /**
     * Verify close button works in the TabSwitcher in landscape mode.
     * This code does not handle properly different screen densities.
     * @throws InterruptedException
     * @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     * @LargeTest
     * @Feature({"Android-TabSwitcher"})
     */
    @FlakyTest(message = "crbug.com/170179")
    public void testTabSwitcherLandscapeCloseButton() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        // Hard-coded coordinates of the close button on the bottom left of the screen.
        // If the coordinates need to be updated, the easiest is to take a screenshot and measure.
        checkCloseTabAtPosition(31 * mPxToDp, 31 * mPxToDp);
    }

    /**
     * Verify that we can open a large number of tabs without running out of
     * memory. This test waits for the NTP to load before opening the next one.
     * This is a LargeTest but because we're doing it "slowly", we need to further scale
     * the timeout for adb am instrument and the various events.
     */
    /*
     * @EnormousTest
     * @TimeoutScale(10)
     * @Feature({"Android-TabSwitcher"})
     * Bug crbug.com/166208
     */
    @DisabledTest
    public void testOpenManyTabsSlowly() throws InterruptedException {
        int startCount = getActivity().getCurrentTabModel().getCount();
        for (int i = 1; i <= STRESSFUL_TAB_COUNT; ++i) {
            ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
            getInstrumentation().waitForIdleSync();
            assertEquals(startCount + i, getActivity().getCurrentTabModel().getCount());
        }
    }

    /**
     * Verify that we can open a large number of tabs without running out of
     * memory. This test hammers the "new tab" button quickly to stress the app.
     *
     * @LargeTest
     * @TimeoutScale(10)
     * @Feature({"Android-TabSwitcher"})
     *
     */
    @FlakyTest
    public void testOpenManyTabsQuickly() {
        int startCount = getActivity().getCurrentTabModel().getCount();
        for (int i = 1; i <= STRESSFUL_TAB_COUNT; ++i) {
            MenuUtils.invokeCustomMenuActionSync(getInstrumentation(), getActivity(),
                    R.id.new_tab_menu_id);
            assertEquals(startCount + i, getActivity().getCurrentTabModel().getCount());
        }
    }

    /**
     * Verify that we can open a burst of new tabs, even when there are already
     * a large number of tabs open.
     * Bug: crbug.com/180718
     * @EnormousTest
     * @TimeoutScale(30)
     * @Feature({"Navigation"})
     */
    @FlakyTest
    public void testOpenManyTabsInBursts() throws InterruptedException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        final int burstSize = 5;
        final String url = mTestServer.getURL(TEST_PAGE_FILE_PATH);
        final int startCount = getActivity().getCurrentTabModel().getCount();
        for (int tabCount = startCount; tabCount < STRESSFUL_TAB_COUNT; tabCount += burstSize)  {
            loadUrlInManyNewTabs(url, burstSize);
            assertEquals(tabCount + burstSize, getActivity().getCurrentTabModel().getCount());
        }
    }

    /**
     * Verify opening 10 tabs at once and that each tab loads when selected.
     */
    /*
     * @EnormousTest
     * @TimeoutScale(30)
     * @Feature({"Navigation"})
     */
    @FlakyTest(message = "crbug.com/223110")
    public void testOpenManyTabsAtOnce10() throws InterruptedException {
        openAndVerifyManyTestTabs(10);
    }

    /**
     * Verify that we can open a large number of tabs all at once and that each
     * tab loads when selected.
     */
    private void openAndVerifyManyTestTabs(final int num) throws InterruptedException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        final String url = mTestServer.getURL(TEST_PAGE_FILE_PATH);
        int startCount = getActivity().getCurrentTabModel().getCount();
        loadUrlInManyNewTabs(url, num);
        assertEquals(startCount + num,
                     getActivity().getCurrentTabModel().getCount());
    }

    class ClickOptionButtonOnMainThread implements Runnable {
        @Override
        public void run() {
            // This is equivalent to clickById(R.id.tab_switcher_button) but does not rely on the
            // event pipeline.
            View button = getActivity().findViewById(R.id.tab_switcher_button);
            assertNotNull("Could not find view R.id.tab_switcher_button", button);
            View toolbar = getActivity().findViewById(R.id.toolbar);
            assertNotNull("Could not find view R.id.toolbar", toolbar);
            assertTrue("R.id.toolbar is not a ToolbarPhone", toolbar instanceof ToolbarPhone);
            ((ToolbarPhone) toolbar).onClick(button);
        }
    }

    /**
     * Displays the tabSwitcher mode and wait for it to settle.
     */
    private void showOverviewAndWaitForAnimation() throws InterruptedException {
        OverviewModeBehaviorWatcher overviewModeWatcher = new OverviewModeBehaviorWatcher(
                getActivity().getLayoutManager(), true, false);
        // For some unknown reasons calling clickById(R.id.tab_switcher_button) sometimes hang.
        // The following is verbose but more reliable.
        getInstrumentation().runOnMainSync(new ClickOptionButtonOnMainThread());
        overviewModeWatcher.waitForBehavior();
    }

    /**
     * Exits the tabSwitcher mode and wait for it to settle.
     */
    private void hideOverviewAndWaitForAnimation() throws InterruptedException {
        OverviewModeBehaviorWatcher overviewModeWatcher = new OverviewModeBehaviorWatcher(
                getActivity().getLayoutManager(), false, true);
        getInstrumentation().runOnMainSync(new ClickOptionButtonOnMainThread());
        overviewModeWatcher.waitForBehavior();
    }

    /**
     * Opens tabs to populate the model to a given count.
     * @param targetTabCount The desired number of tabs in the model.
     * @param waitToLoad     Whether the tabs need to be fully loaded.
     * @return               The new number of tabs in the model.
     * @throws InterruptedException
     */
    private int openTabs(final int targetTabCount, boolean waitToLoad) throws InterruptedException {
        int tabCount = getActivity().getCurrentTabModel().getCount();
        while (tabCount < targetTabCount) {
            ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
            tabCount++;
            assertEquals("The tab count is wrong",
                    tabCount, getActivity().getCurrentTabModel().getCount());
            Tab tab = TabModelUtils.getCurrentTab(getActivity().getCurrentTabModel());
            while (waitToLoad && tab.isLoading()) {
                Thread.yield();
            }
        }
        return tabCount;
    }

    /**
     * Verifies that when more than 9 tabs are open only at most 8 are drawn. Basically it verifies
     * that the tab culling mechanism works properly.
     */
    /*
       @LargeTest
       @Feature({"Android-TabSwitcher"})
    */
    @DisabledTest(message = "crbug.com/156746")
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    public void testTabsCulling() throws InterruptedException {
        // Open one more tabs than maxTabsDrawn.
        final int maxTabsDrawn = 8;
        int tabCount = openTabs(maxTabsDrawn + 1, false);
        showOverviewAndWaitForAnimation();

        // Check counts.
        LayoutManagerChromePhone layoutManager =
                (LayoutManagerChromePhone) getActivity().getLayoutManager();
        int drawnCount = layoutManager.getOverviewLayout().getLayoutTabsToRender().length;
        int drawnExpected = Math.min(tabCount, maxTabsDrawn);
        assertEquals("The number of drawn tab is wrong", drawnExpected, drawnCount);
    }

    /**
     * Checks the stacked tabs in the stack are visible.
     * @throws InterruptedException
     */
    private void checkTabsStacking() throws InterruptedException {
        final int count = getActivity().getCurrentTabModel().getCount();
        assertEquals("The number of tab in the stack should match the number of tabs in the model",
                count, getLayoutTabInStackCount(false));

        assertTrue("The selected tab should always be visible",
                stackTabIsVisible(false, getActivity().getCurrentTabModel().index()));
        for (int i = 0; i < Stack.MAX_NUMBER_OF_STACKED_TABS_TOP && i < count; i++) {
            assertTrue("The stacked tab " + i + " from the top should always be visible",
                    stackTabIsVisible(false, i));
        }
        for (int i = 0; i < Stack.MAX_NUMBER_OF_STACKED_TABS_BOTTOM && i < count; i++) {
            assertTrue("The stacked tab " + i + " from the bottom should always be visible",
                    stackTabIsVisible(false, count - 1 - i));
        }
    }

    /**
     * Verifies that the tab are actually stacking at the bottom and top of the screen.
     */
    /**
     * @LargeTest
     * @Feature({"Android-TabSwitcher"})
     */
    @FlakyTest(message = "crbug.com/170179")
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    public void testTabsStacking() throws InterruptedException {
        final int count = openTabs(12, false);

        // Selecting the first tab to scroll all the way to the top.
        getInstrumentation().runOnMainSync(new Runnable() {
            @Override
            public void run() {
                TabModelUtils.setIndex(getActivity().getCurrentTabModel(), 0);
            }
        });
        showOverviewAndWaitForAnimation();
        checkTabsStacking();

        // Selecting the last tab to scroll all the way to the bottom.
        hideOverviewAndWaitForAnimation();
        getInstrumentation().runOnMainSync(new Runnable() {
            @Override
            public void run() {
                TabModelUtils.setIndex(getActivity().getCurrentTabModel(), count - 1);
            }
        });
        showOverviewAndWaitForAnimation();
        checkTabsStacking();
    }

    /**
     * @return A stable read of allocated size (native + dalvik) after gc.
     */
    @SuppressFBWarnings("DM_GC")
    private long getStableAllocatedSize() {
        // Measure the equivalent of allocated size native + dalvik in:
        // adb shell dumpsys meminfo | grep chrome -A 20
        int maxTries = 8;
        int tries = 0;
        long threshold = 512; // bytes
        long lastAllocatedSize = Long.MAX_VALUE;
        long currentAllocatedSize = 0;
        while (tries < maxTries && Math.abs(currentAllocatedSize - lastAllocatedSize) > threshold) {
            System.gc();
            try {
                Thread.sleep(1000 + tries * 500); // Memory measurement is not an exact science...
                lastAllocatedSize = currentAllocatedSize;
                currentAllocatedSize = Debug.getNativeHeapAllocatedSize()
                        + Runtime.getRuntime().totalMemory();
                //Log.w("MEMORY_MEASURE", "[" + tries + "/" + maxTries + "]" +
                //        "currentAllocatedSize " + currentAllocatedSize);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tries++;
        }
        assertTrue("Could not have a stable read on native allocated size even after "
                + tries + " gc.", tries < maxTries);
        return currentAllocatedSize;
    }

    /**
     * Verify that switching back and forth to the tabswitcher does not leak memory.
     */
    /**
     * @LargeTest
     * @Feature({"Android-TabSwitcher"})
     */
    @FlakyTest(message = "crbug.com/303319")
    @Restriction(ChromeRestriction.RESTRICTION_TYPE_PHONE)
    public void testTabSwitcherMemoryLeak() throws InterruptedException {
        openTabs(4, true);

        int maxTries = 10;
        int tries = 0;
        long threshold = 1024; // bytes
        long lastAllocatedSize = 0;
        long currentAllocatedSize = 2 * threshold;
        while (tries < maxTries && (lastAllocatedSize + threshold) < currentAllocatedSize) {
            showOverviewAndWaitForAnimation();

            lastAllocatedSize = currentAllocatedSize;
            currentAllocatedSize = getStableAllocatedSize();
            //Log.w("MEMORY_TEST", "[" + tries + "/" + maxTries + "]" +
            //        "currentAllocatedSize " + currentAllocatedSize);

            hideOverviewAndWaitForAnimation();
            tries++;
        }

        assertTrue("Native heap allocated size keeps increasing even after "
                + tries + " iterations", tries < maxTries);
    }

    /**
     * Verify that switching back and forth stay stable. This test last for at least 8 seconds.
     */
    @LargeTest
    @Restriction(ChromeRestriction.RESTRICTION_TYPE_PHONE)
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testTabSwitcherStability() throws InterruptedException {
        openTabs(8, true);

        // This is about as fast as you can ever click.
        final long fastestUserInput = 20; // ms
        for (int i = 0; i < 200; i++) {
            // Show overview
            getInstrumentation().runOnMainSync(new ClickOptionButtonOnMainThread());
            Thread.sleep(fastestUserInput);

            // hide overview
            getInstrumentation().runOnMainSync(new ClickOptionButtonOnMainThread());
            Thread.sleep(fastestUserInput);
        }
    }

    @LargeTest
    @Feature({"Android-TabSwitcher"})
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    public void testTabSelectionPortrait() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        checkTabSelection(2, 0, false);

        // Ensure all tabs following the selected tab are off the screen when the animation is
        // complete.
        final int count = getLayoutTabInStackCount(false);
        for (int i = 1; i < count; i++) {
            float y = getLayoutTabInStackXY(false, i)[1];
            assertTrue(
                    String.format(Locale.US,
                            "Tab %d's final draw Y, %f, should exceed the view height, %f.",
                            i, y, mTabsViewHeightDp),
                    y >= mTabsViewHeightDp);
        }
    }

    /**
     * @LargeTest
     * @Feature({"Android-TabSwitcher"})
     */
    @FlakyTest(message = "crbug.com/170179")
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    public void testTabSelectionLandscape() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        checkTabSelection(2, 0, true);

        // Ensure all tabs following the selected tab are off the screen when the animation is
        // complete.
        final int count = getLayoutTabInStackCount(false);
        for (int i = 1; i < count; i++) {
            float x = getLayoutTabInStackXY(false, i)[0];
            assertTrue(
                    String.format(Locale.US,
                            "Tab %d's final draw X, %f, should exceed the view width, %f.",
                            i, x, mTabsViewWidthDp),
                    x >= mTabsViewWidthDp);
        }
    }

    /**
     * Verify that we don't crash and show the overview mode after closing the last tab.
     */
    @SmallTest
    @Restriction(ChromeRestriction.RESTRICTION_TYPE_PHONE)
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testCloseLastTabFromMain() throws InterruptedException {
        OverviewModeBehaviorWatcher overviewModeWatcher = new OverviewModeBehaviorWatcher(
                getActivity().getLayoutManager(), true, false);
        ChromeTabUtils.closeCurrentTab(getInstrumentation(), getActivity());
        getInstrumentation().waitForIdleSync();
        overviewModeWatcher.waitForBehavior();
    }

    private LayoutManagerChrome updateTabsViewSize() {
        View tabsView = getActivity().getTabsView();
        mTabsViewHeightDp = tabsView.getHeight() * mPxToDp;
        mTabsViewWidthDp = tabsView.getWidth() * mPxToDp;
        return getActivity().getLayoutManager();
    }

    private Stack getStack(final LayoutManagerChrome layoutManager, boolean isIncognito) {
        assertTrue("getStack must be executed on the ui thread",
                ThreadUtils.runningOnUiThread());
        LayoutManagerChromePhone layoutManagerPhone = (LayoutManagerChromePhone) layoutManager;
        StackLayout layout = (StackLayout) layoutManagerPhone.getOverviewLayout();
        return (layout).getTabStack(isIncognito);
    }

    private int getLayoutTabInStackCount(final boolean isIncognito) {
        final LayoutManagerChrome layoutManager = updateTabsViewSize();
        final int[] count = new int[1];
        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                Stack stack = getStack(layoutManager, isIncognito);
                count[0] = stack.getTabs().length;
            }
        });
        return count[0];
    }

    private boolean stackTabIsVisible(final boolean isIncognito, final int index) {
        final LayoutManagerChrome layoutManager = updateTabsViewSize();
        final boolean[] isVisible = new boolean[1];
        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                Stack stack = getStack(layoutManager, isIncognito);
                isVisible[0] = (stack.getTabs())[index].getLayoutTab().isVisible();
            }
        });
        return isVisible[0];
    }

    private float[] getLayoutTabInStackXY(final boolean isIncognito, final int index) {
        final LayoutManagerChrome layoutManager = updateTabsViewSize();
        final float[] xy = new float[2];
        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                Stack stack = getStack(layoutManager, isIncognito);
                xy[0] = (stack.getTabs())[index].getLayoutTab().getX();
                xy[1] = (stack.getTabs())[index].getLayoutTab().getY();
            }
        });
        return xy;
    }

    private float[] getStackTabClickTarget(final int tabIndexToSelect, final boolean isIncognito,
            final boolean isLandscape) {
        final LayoutManagerChrome layoutManager = updateTabsViewSize();
        final float[] target = new float[2];
        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                Stack stack = getStack(layoutManager, isIncognito);
                StackTab[] tabs = stack.getTabs();
                // The position of the click is expressed from the top left corner of the content.
                // The aim is to find an offset that is inside the content but not on the close
                // button.  For this, we calculate the center of the visible tab area.
                LayoutTab layoutTab = tabs[tabIndexToSelect].getLayoutTab();
                LayoutTab nextLayoutTab = (tabIndexToSelect + 1) < tabs.length
                        ? tabs[tabIndexToSelect + 1].getLayoutTab() : null;

                float tabOffsetX = layoutTab.getX();
                float tabOffsetY = layoutTab.getY();
                float tabRightX, tabBottomY;
                if (isLandscape) {
                    tabRightX = nextLayoutTab != null
                            ? nextLayoutTab.getX()
                            : tabOffsetX + layoutTab.getScaledContentWidth();
                    tabBottomY = tabOffsetY + layoutTab.getScaledContentHeight();
                } else {
                    tabRightX = tabOffsetX + layoutTab.getScaledContentWidth();
                    tabBottomY = nextLayoutTab != null
                            ? nextLayoutTab.getY()
                            : tabOffsetY + layoutTab.getScaledContentHeight();
                }
                tabRightX = Math.min(tabRightX, mTabsViewWidthDp);
                tabBottomY = Math.min(tabBottomY, mTabsViewHeightDp);

                target[0] = (tabOffsetX + tabRightX) / 2.0f;
                target[1] = (tabOffsetY + tabBottomY) / 2.0f;
            }
        });
        return target;
    }

    private void checkTabSelection(int additionalTabsToOpen, int tabIndexToSelect,
            boolean isLandscape) throws InterruptedException {
        for (int i = 0; i < additionalTabsToOpen; i++) {
            ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        }
        assertEquals("Number of open tabs does not match",
                additionalTabsToOpen + 1 , getActivity().getCurrentTabModel().getCount());
        showOverviewAndWaitForAnimation();

        float[] coordinates = getStackTabClickTarget(tabIndexToSelect, false, isLandscape);
        float clickX = coordinates[0];
        float clickY = coordinates[1];

        OverviewModeBehaviorWatcher overviewModeWatcher = new OverviewModeBehaviorWatcher(
                getActivity().getLayoutManager(), false, true);

        final LayoutManagerChrome layoutManager = updateTabsViewSize();
        getInstrumentation().runOnMainSync(new SimulateClickOnMainThread(layoutManager,
                (int) clickX, (int) clickY));
        overviewModeWatcher.waitForBehavior();

        // Make sure we did not accidentally close a tab.
        assertEquals("Number of open tabs does not match",
                additionalTabsToOpen + 1 , getActivity().getCurrentTabModel().getCount());
    }

    public void swipeToCloseTab(final int tabIndexToClose, final boolean isLandscape,
            final boolean isIncognito, final int swipeDirection) throws InterruptedException {
        final LayoutManagerChrome layoutManager = updateTabsViewSize();
        float[] coordinates = getStackTabClickTarget(tabIndexToClose, isIncognito, isLandscape);
        final float clickX = coordinates[0];
        final float clickY = coordinates[1];
        Log.v("ChromeTest", String.format("clickX %f clickY %f", clickX, clickY));

        ChromeTabUtils.closeTabWithAction(getInstrumentation(), getActivity(), new Runnable() {
            @Override
            public void run() {
                if (isLandscape) {
                    getInstrumentation().runOnMainSync(new SimulateTabSwipeOnMainThread(
                            layoutManager, clickX, clickY, 0, swipeDirection * mTabsViewWidthDp));
                } else {
                    getInstrumentation().runOnMainSync(new SimulateTabSwipeOnMainThread(
                            layoutManager, clickX, clickY, swipeDirection * mTabsViewHeightDp, 0));
                }
            }
        });

        CriteriaHelper.pollUiThread(new Criteria("Did not finish animation") {
            @Override
            public boolean isSatisfied() {
                Layout layout = getActivity().getLayoutManager().getActiveLayout();
                return !layout.isLayoutAnimating();
            }
        });
    }

    private void swipeToCloseNTabs(int number, boolean isLandscape, boolean isIncognito,
            int swipeDirection)
            throws InterruptedException {

        for (int i = number - 1; i >= 0; i--) {
            swipeToCloseTab(i, isLandscape, isIncognito, swipeDirection);
        }
    }

    /**
     * Test closing few tabs by swiping them in Overview portrait mode.
     */
    @MediumTest
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @Feature({"Android-TabSwitcher", "Main"})
    @RetryOnFailure
    public void testCloseTabPortrait() throws InterruptedException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        startMainActivityWithURL(mTestServer.getURL("/chrome/test/data/android/test.html"));

        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

        int tabCount = getActivity().getCurrentTabModel().getCount();
        ChromeTabUtils.newTabsFromMenu(getInstrumentation(), getActivity(), 3);
        assertEquals("wrong count after new tabs", tabCount + 3,
                getActivity().getCurrentTabModel().getCount());

        showOverviewAndWaitForAnimation();
        swipeToCloseNTabs(3, false, false, SWIPE_TO_LEFT_DIRECTION);

        assertEquals("Wrong tab counts after closing a few of them",
                tabCount, getActivity().getCurrentTabModel().getCount());
    }

    /**
     * Test closing few tabs by swiping them in Overview landscape mode.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher", "Main"})
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @RetryOnFailure
    public void testCloseTabLandscape() throws InterruptedException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        startMainActivityWithURL(mTestServer.getURL("/chrome/test/data/android/test.html"));

        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

        int tabCount = getActivity().getCurrentTabModel().getCount();
        ChromeTabUtils.newTabsFromMenu(getInstrumentation(), getActivity(), 3);
        assertEquals("wrong count after new tabs", tabCount + 3,
                getActivity().getCurrentTabModel().getCount());

        showOverviewAndWaitForAnimation();
        swipeToCloseTab(0, true, false, SWIPE_TO_LEFT_DIRECTION);
        swipeToCloseTab(0, true, false, SWIPE_TO_LEFT_DIRECTION);
        swipeToCloseTab(0, true, false, SWIPE_TO_LEFT_DIRECTION);

        assertEquals("Wrong tab counts after closing a few of them",
                tabCount, getActivity().getCurrentTabModel().getCount());
    }

    /**
     * Test close Incognito tab by swiping in Overview Portrait mode.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @RetryOnFailure
    public void testCloseIncognitoTabPortrait() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        newIncognitoTabsFromMenu(2);

        showOverviewAndWaitForAnimation();
        UiUtils.settleDownUI(getInstrumentation());
        swipeToCloseNTabs(2, false, true, SWIPE_TO_LEFT_DIRECTION);
    }

    /**
     * Test close 5 Incognito tabs by swiping in Overview Portrait mode.
     */
    @Feature({"Android-TabSwitcher"})
    @MediumTest
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @RetryOnFailure
    public void testCloseFiveIncognitoTabPortrait() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        newIncognitoTabsFromMenu(5);

        showOverviewAndWaitForAnimation();
        UiUtils.settleDownUI(getInstrumentation());
        swipeToCloseNTabs(5, false, true, SWIPE_TO_LEFT_DIRECTION);
    }

    /**
     * Simple swipe gesture should not close tabs when two Tabstacks are open in Overview mode.
     * Test in Portrait Mode.
     */
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    public void testSwitchTabStackWithoutClosingTabsInPortrait() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        newIncognitoTabFromMenu();
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());

        showOverviewAndWaitForAnimation();
        UiUtils.settleDownUI(getInstrumentation());
        final int normalTabCount = getLayoutTabInStackCount(false);
        final int incognitoTabCount = getLayoutTabInStackCount(true);

        LayoutManagerChrome layoutManager = updateTabsViewSize();

        // Swipe to Incognito Tabs.
        getInstrumentation().runOnMainSync(new SimulateTabSwipeOnMainThread(layoutManager,
                mTabsViewWidthDp - 20 , mTabsViewHeightDp / 2 ,
                SWIPE_TO_LEFT_DIRECTION * mTabsViewWidthDp, 0));
        UiUtils.settleDownUI(getInstrumentation());
        assertTrue("Tabs Stack should have been changed to incognito.",
                getActivity().getCurrentTabModel().isIncognito());
        assertEquals("Normal tabs count should be unchanged while switching to incognito tabs.",
                normalTabCount, getLayoutTabInStackCount(false));

        // Swipe to regular Tabs.
        getInstrumentation().runOnMainSync(new SimulateTabSwipeOnMainThread(layoutManager,
                20, mTabsViewHeightDp / 2,
                SWIPE_TO_RIGHT_DIRECTION * mTabsViewWidthDp, 0));
        UiUtils.settleDownUI(getInstrumentation());
        assertEquals("Incognito tabs count should be unchanged while switching back to normal "
                + "tab stack.", incognitoTabCount, getLayoutTabInStackCount(true));
        assertFalse("Tabs Stack should have been changed to regular tabs.",
                getActivity().getCurrentTabModel().isIncognito());
        assertEquals("Normal tabs count should be unchanged while switching back to normal tabs.",
                normalTabCount, getLayoutTabInStackCount(false));
    }

    /**
     * Simple swipe gesture should not close tabs when two Tabstacks are open in Overview mode.
     * Test in Landscape Mode.
     */
    /*
        @MediumTest
        @Feature({"Android-TabSwitcher"})
     */
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @DisabledTest(message = "crbug.com/157259")
    public void testSwitchTabStackWithoutClosingTabsInLandscape() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        newIncognitoTabFromMenu();
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());

        showOverviewAndWaitForAnimation();
        UiUtils.settleDownUI(getInstrumentation());
        final int normalTabCount = getLayoutTabInStackCount(false);
        final int incognitoTabCount = getLayoutTabInStackCount(true);

        LayoutManagerChrome layoutManager = updateTabsViewSize();

        // Swipe to Incognito Tabs.
        getInstrumentation().runOnMainSync(new SimulateTabSwipeOnMainThread(layoutManager,
                mTabsViewWidthDp / 2 , mTabsViewHeightDp - 20 ,
                0, SWIPE_TO_LEFT_DIRECTION * mTabsViewWidthDp));
        UiUtils.settleDownUI(getInstrumentation());
        assertTrue("Tabs Stack should have been changed to incognito.",
                getActivity().getCurrentTabModel().isIncognito());
        assertEquals("Normal tabs count should be unchanged while switching to incognito tabs.",
                normalTabCount, getLayoutTabInStackCount(false));

        // Swipe to regular Tabs.
        getInstrumentation().runOnMainSync(new SimulateTabSwipeOnMainThread(layoutManager,
                mTabsViewWidthDp / 2, 20,
                0, SWIPE_TO_RIGHT_DIRECTION * mTabsViewWidthDp));
        UiUtils.settleDownUI(getInstrumentation());
        assertEquals("Incognito tabs count should be unchanged while switching back to normal "
                + "tab stack.", incognitoTabCount, getLayoutTabInStackCount(true));
        assertFalse("Tabs Stack should have been changed to regular tabs.",
                getActivity().getCurrentTabModel().isIncognito());
        assertEquals("Normal tabs count should be unchanged while switching back to normal tabs.",
                normalTabCount, getLayoutTabInStackCount(false));
    }

    /**
     * Test close Incognito tab by swiping in Overview Landscape mode.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @RetryOnFailure
    public void testCloseIncognitoTabLandscape() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        newIncognitoTabFromMenu();

        showOverviewAndWaitForAnimation();
        UiUtils.settleDownUI(getInstrumentation());
        swipeToCloseTab(0, true, true, SWIPE_TO_LEFT_DIRECTION);
    }

    /**
     * Test close 5 Incognito tabs by swiping in Overview Landscape mode.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @RetryOnFailure
    public void testCloseFiveIncognitoTabLandscape() throws InterruptedException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        newIncognitoTabsFromMenu(5);

        showOverviewAndWaitForAnimation();
        UiUtils.settleDownUI(getInstrumentation());
        swipeToCloseNTabs(5, true, true, SWIPE_TO_LEFT_DIRECTION);
    }

    /**
     * Test that we can safely close a tab during a fling (http://b/issue?id=5364043)
     */
    @SmallTest
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testCloseTabDuringFling() throws InterruptedException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        loadUrlInNewTab(mTestServer.getURL(
                "/chrome/test/data/android/tabstest/text_page.html"));
        getInstrumentation().runOnMainSync(new Runnable() {
            @Override
            public void run() {
                ContentViewCore view = getActivity().getActivityTab().getContentViewCore();
                view.flingViewport(SystemClock.uptimeMillis(), 0, -2000);
            }
        });
        ChromeTabUtils.closeCurrentTab(getInstrumentation(), getActivity());
    }

    /**
     * Flaky on instrumentation-yakju-clankium-ics. See https://crbug.com/431296.
     * @Restriction(RESTRICTION_TYPE_PHONE)
     * @MediumTest
     * @Feature({"Android-TabSwitcher"})
     */
    @FlakyTest
    public void testQuickSwitchBetweenTabAndSwitcherMode() throws InterruptedException {
        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
        final String[] urls = {
                mTestServer.getURL("/chrome/test/data/android/navigate/one.html"),
                mTestServer.getURL("/chrome/test/data/android/navigate/two.html"),
                mTestServer.getURL("/chrome/test/data/android/navigate/three.html")};

        for (String url : urls) {
            loadUrlInNewTab(url);
        }

        int lastUrlIndex = urls.length - 1;

        View button = getActivity().findViewById(R.id.tab_switcher_button);
        assertNotNull("Could not find 'tab_switcher_button'", button);

        for (int i = 0; i < 15; i++) {
            singleClickView(button);
            // Switch back to the tab view from the tab-switcher mode.
            singleClickView(button);

            assertEquals("URL mismatch after switching back to the tab from tab-switch mode",
                    urls[lastUrlIndex], getActivity().getActivityTab().getUrl());
        }
    }

    /**
     * Open an incognito tab from menu and verify its property.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testOpenIncognitoTab() throws InterruptedException {
        newIncognitoTabFromMenu();

        assertTrue("Current Tab should be an incognito tab.",
                getActivity().getActivityTab().isIncognito());
    }

    /**
     * Test NewTab button on the browser toolbar.
     * Restricted to phones due crbug.com/429671.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(ChromeRestriction.RESTRICTION_TYPE_PHONE)
    @RetryOnFailure
    public void testNewTabButton() throws InterruptedException {
        MenuUtils.invokeCustomMenuActionSync(getInstrumentation(), getActivity(),
                R.id.close_all_tabs_menu_id);
        UiUtils.settleDownUI(getInstrumentation());

        CriteriaHelper.pollInstrumentationThread(new Criteria("Should be in overview mode") {
            @Override
            public boolean isSatisfied() {
                return getActivity().isInOverviewMode();
            }
        });

        int initialTabCount = getActivity().getCurrentTabModel().getCount();
        assertEquals("Tab count is expected to be 0 after closing all the tabs",
                0, initialTabCount);

        ChromeTabUtils.clickNewTabButton(this, this);

        int newTabCount = getActivity().getCurrentTabModel().getCount();
        assertEquals("Tab count is expected to be 1 after clicking Newtab button",
                1, newTabCount);
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @RetryOnFailure
    public void testToolbarSwipeOnlyTab() throws InterruptedException {
        final TabModel tabModel = getActivity().getTabModelSelector().getModel(false);

        assertEquals("Incorrect starting index", 0, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.RIGHT, 0, false);
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.LEFT, 0, false);
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @RetryOnFailure
    public void testToolbarSwipePrevTab() throws InterruptedException {
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        UiUtils.settleDownUI(getInstrumentation());

        final TabModel tabModel = getActivity().getTabModelSelector().getModel(false);

        assertEquals("Incorrect starting index", 1, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.RIGHT, 0, true);
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @RetryOnFailure
    public void testToolbarSwipeNextTab() throws InterruptedException {
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        ChromeTabUtils.switchTabInCurrentTabModel(getActivity(), 0);
        UiUtils.settleDownUI(getInstrumentation());

        final TabModel tabModel = getActivity().getTabModelSelector().getModel(false);

        assertEquals("Incorrect starting index", 0, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.LEFT, 1, true);
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @RetryOnFailure
    public void testToolbarSwipePrevTabNone() throws InterruptedException {
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        ChromeTabUtils.switchTabInCurrentTabModel(getActivity(), 0);
        UiUtils.settleDownUI(getInstrumentation());

        final TabModel tabModel = getActivity().getTabModelSelector().getModel(false);

        assertEquals("Incorrect starting index", 0, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.RIGHT, 0, false);
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @RetryOnFailure
    public void testToolbarSwipeNextTabNone() throws InterruptedException {
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        UiUtils.settleDownUI(getInstrumentation());

        final TabModel tabModel = getActivity().getTabModelSelector().getModel(false);

        assertEquals("Incorrect starting index", 1, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.LEFT, 1, false);
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @RetryOnFailure
    public void testToolbarSwipeNextThenPrevTab() throws InterruptedException {
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        ChromeTabUtils.switchTabInCurrentTabModel(getActivity(), 0);
        UiUtils.settleDownUI(getInstrumentation());

        final TabModel tabModel = getActivity().getTabModelSelector().getModel(false);

        assertEquals("Incorrect starting index", 0, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.LEFT, 1, true);

        assertEquals("Incorrect starting index", 1, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.RIGHT, 0, true);
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @RetryOnFailure
    public void testToolbarSwipeNextThenPrevTabIncognito() throws InterruptedException {
        newIncognitoTabFromMenu();
        newIncognitoTabFromMenu();
        ChromeTabUtils.switchTabInCurrentTabModel(getActivity(), 0);
        UiUtils.settleDownUI(getInstrumentation());

        final TabModel tabModel = getActivity().getTabModelSelector().getModel(true);

        assertEquals("Incorrect starting index", 0, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.LEFT, 1, true);

        assertEquals("Incorrect starting index", 1, tabModel.index());
        runToolbarSideSwipeTestOnCurrentModel(ScrollDirection.RIGHT, 0, true);
    }

    private void runToolbarSideSwipeTestOnCurrentModel(ScrollDirection direction, int finalIndex,
            boolean expectsSelection) throws InterruptedException {
        final CallbackHelper selectCallback = new CallbackHelper();
        final int id = getActivity().getCurrentTabModel().getTabAt(finalIndex).getId();
        final TabModelObserver observer = new EmptyTabModelObserver() {
            @Override
            public void didSelectTab(Tab tab, TabSelectionType type, int lastId) {
                if (tab.getId() == id) selectCallback.notifyCalled();
            }
        };

        if (expectsSelection) {
            ThreadUtils.runOnUiThreadBlocking(new Runnable() {
                @Override
                public void run() {
                    TabModelSelector selector = getActivity().getTabModelSelector();
                    for (TabModel tabModel : selector.getModels()) {
                        tabModel.addObserver(observer);
                    }
                }
            });
        }

        performToolbarSideSwipe(direction);
        waitForStaticLayout();
        assertEquals("Index after toolbar side swipe is incorrect", finalIndex,
                getActivity().getCurrentTabModel().index());

        if (expectsSelection) {
            try {
                selectCallback.waitForCallback(0);
            } catch (TimeoutException e) {
                fail("Tab selected event was never received");
            }
            ThreadUtils.runOnUiThreadBlocking(new Runnable() {
                @Override
                public void run() {
                    TabModelSelector selector = getActivity().getTabModelSelector();
                    for (TabModel tabModel : selector.getModels()) {
                        tabModel.removeObserver(observer);
                    }
                }
            });
        }
    }


    private void performToolbarSideSwipe(ScrollDirection direction) {
        assertTrue("Unexpected direction for side swipe " + direction,
                direction == ScrollDirection.LEFT || direction == ScrollDirection.RIGHT);
        final View toolbar = getActivity().findViewById(R.id.toolbar);
        int[] toolbarPos = new int[2];
        toolbar.getLocationOnScreen(toolbarPos);
        final int width = toolbar.getWidth();
        final int height = toolbar.getHeight();

        final int fromX = toolbarPos[0] + width / 2;
        final int toX = toolbarPos[0] + (direction == ScrollDirection.LEFT ? 0 : width);
        final int y = toolbarPos[1] + height / 2;
        final int stepCount = 10;

        long downTime = SystemClock.uptimeMillis();
        dragStart(fromX, y, downTime);
        dragTo(fromX, toX, y, y, stepCount, downTime);
        dragEnd(toX, y, downTime);
    }

    private void waitForStaticLayout() throws InterruptedException {
        CriteriaHelper.pollUiThread(
                new Criteria("Static Layout never selected after side swipe") {
                    @Override
                    public boolean isSatisfied() {
                        CompositorViewHolder compositorViewHolder = (CompositorViewHolder)
                                getActivity().findViewById(R.id.compositor_view_holder);
                        LayoutManager layoutManager = compositorViewHolder.getLayoutManager();

                        return layoutManager.getActiveLayout() instanceof StaticLayout;
                    }
                });
    }

    /**
     * Test that swipes and tab transitions are not causing URL bar to be focused.
     */
    @MediumTest
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testOSKIsNotShownDuringSwipe() throws InterruptedException {
        final View urlBar = getActivity().findViewById(R.id.url_bar);
        final LayoutManagerChrome layoutManager = updateTabsViewSize();
        final EdgeSwipeHandler edgeSwipeHandler = layoutManager.getTopSwipeHandler();

        UiUtils.settleDownUI(getInstrumentation());
        getInstrumentation().runOnMainSync(
                new Runnable() {
                    @Override
                    public void run() {
                        urlBar.requestFocus();
                    }
                });
        UiUtils.settleDownUI(getInstrumentation());

        getInstrumentation().runOnMainSync(
                new Runnable() {
                    @Override
                    public void run() {
                        urlBar.clearFocus();
                    }
                });
        UiUtils.settleDownUI(getInstrumentation());
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        UiUtils.settleDownUI(getInstrumentation());

        assertFalse("Keyboard somehow got shown",
                org.chromium.ui.UiUtils.isKeyboardShowing(getActivity(), urlBar));

        ThreadUtils.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                edgeSwipeHandler.swipeStarted(ScrollDirection.RIGHT, 0, 0);
                float swipeXChange = mTabsViewWidthDp / 2.f;
                edgeSwipeHandler.swipeUpdated(
                        swipeXChange, 0.f, swipeXChange, 0.f, swipeXChange, 0.f);
            }
        });

        CriteriaHelper.pollUiThread(
                new Criteria("Layout still requesting Tab Android view be attached") {
                    @Override
                    public boolean isSatisfied() {
                        LayoutManager driver = getActivity().getLayoutManager();
                        return !driver.getActiveLayout().shouldDisplayContentOverlay();
                    }
                });

        ThreadUtils.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                assertFalse("Keyboard should be hidden while swiping",
                        org.chromium.ui.UiUtils.isKeyboardShowing(getActivity(), urlBar));
                edgeSwipeHandler.swipeFinished();
            }
        });

        CriteriaHelper.pollUiThread(
                new Criteria("Layout not requesting Tab Android view be attached") {
                    @Override
                    public boolean isSatisfied() {
                        LayoutManager driver = getActivity().getLayoutManager();
                        return driver.getActiveLayout().shouldDisplayContentOverlay();
                    }
                });

        assertFalse("Keyboard should not be shown",
                org.chromium.ui.UiUtils.isKeyboardShowing(getActivity(), urlBar));
    }

    /**
     * Test that orientation changes cause the live tab reflow.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction(RESTRICTION_TYPE_NON_LOW_END_DEVICE)
    @RetryOnFailure
    public void testOrientationChangeCausesLiveTabReflowInNormalView()
            throws InterruptedException, TimeoutException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        loadUrl(RESIZE_TEST_URL);
        final WebContents webContents =
                getActivity().getActivityTab().getWebContents();

        JavaScriptUtils.executeJavaScriptAndWaitForResult(webContents,
                                                          "resizeHappened = false;");
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        UiUtils.settleDownUI(getInstrumentation());
        assertEquals("onresize event wasn't received by the tab (normal view)",
                "true",
                JavaScriptUtils.executeJavaScriptAndWaitForResult(
                        webContents, "resizeHappened",
                        WAIT_RESIZE_TIMEOUT_MS, TimeUnit.MILLISECONDS));
    }

    /**
     * Test that orientation changes cause the live tab reflow.
     */
    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @Restriction({ChromeRestriction.RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
    public void testOrientationChangeCausesLiveTabReflowInTabSwitcher()
            throws InterruptedException, TimeoutException {
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        ChromeTabUtils.newTabFromMenu(getInstrumentation(), getActivity());
        loadUrl(RESIZE_TEST_URL);
        final WebContents webContents =
                        getActivity().getActivityTab().getWebContents();

        showOverviewAndWaitForAnimation();
        JavaScriptUtils.executeJavaScriptAndWaitForResult(webContents,
                                                          "resizeHappened = false;");
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        UiUtils.settleDownUI(getInstrumentation());
        assertEquals("onresize event wasn't received by the live tab (tabswitcher, to Landscape)",
                "true",
                JavaScriptUtils.executeJavaScriptAndWaitForResult(
                        webContents, "resizeHappened",
                        WAIT_RESIZE_TIMEOUT_MS, TimeUnit.MILLISECONDS));

        JavaScriptUtils.executeJavaScriptAndWaitForResult(webContents,
                                                          "resizeHappened = false;");
        getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        UiUtils.settleDownUI(getInstrumentation());
        assertEquals("onresize event wasn't received by the live tab (tabswitcher, to Portrait)",
                "true",
                JavaScriptUtils.executeJavaScriptAndWaitForResult(webContents,
                        "resizeHappened", WAIT_RESIZE_TIMEOUT_MS, TimeUnit.MILLISECONDS));
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testLastClosedUndoableTabGetsHidden() {
        final TabModel model = getActivity().getTabModelSelector().getCurrentModel();
        final Tab tab = TabModelUtils.getCurrentTab(model);

        assertEquals("Too many tabs at startup", 1, model.getCount());

        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                model.closeTab(tab, false, false, true);
            }
        });

        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                assertTrue("Tab close is not undoable", model.isClosurePending(tab.getId()));
                assertTrue("Tab was not hidden", tab.isHidden());
            }
        });
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testLastClosedTabTriggersNotifyChangedCall() {
        final TabModel model = getActivity().getTabModelSelector().getCurrentModel();
        final Tab tab = TabModelUtils.getCurrentTab(model);
        final TabModelSelector selector = getActivity().getTabModelSelector();
        mNotifyChangedCalled = false;

        selector.addObserver(new EmptyTabModelSelectorObserver() {
            @Override
            public void onChange() {
                mNotifyChangedCalled = true;
            }
        });

        assertEquals("Too many tabs at startup", 1, model.getCount());

        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            public void run() {
                model.closeTab(tab, false, false, true);
            }
        });

        assertTrue("notifyChanged() was not called", mNotifyChangedCalled);
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testTabsAreDestroyedOnModelDestruction() throws InterruptedException {
        startMainActivityOnBlankPage();
        final TabModelSelectorImpl selector =
                (TabModelSelectorImpl) getActivity().getTabModelSelector();
        final Tab tab = getActivity().getActivityTab();

        final AtomicBoolean webContentsDestroyCalled = new AtomicBoolean();

        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            @SuppressFBWarnings("DLS_DEAD_LOCAL_STORE")
            public void run() {
                @SuppressWarnings("unused") // Avoid GC of observer
                WebContentsObserver observer = new WebContentsObserver(tab.getWebContents()) {
                            @Override
                            public void destroy() {
                                super.destroy();
                                webContentsDestroyCalled.set(true);
                            }
                        };

                assertNotNull("No initial tab at startup", tab);
                assertNotNull("Tab does not have a web contents", tab.getWebContents());
                assertTrue("Tab is destroyed", tab.isInitialized());

                selector.destroy();

                assertNull("Tab still has a web contents", tab.getWebContents());
                assertFalse("Tab was not destroyed", tab.isInitialized());
            }
        });

        assertTrue("WebContentsObserver was never destroyed", webContentsDestroyCalled.get());
    }

    @MediumTest
    @Feature({"Android-TabSwitcher"})
    @RetryOnFailure
    public void testIncognitoTabsNotRestoredAfterSwipe() throws Exception {
        newIncognitoTabFromMenu();

        File tabStateDir = TabbedModeTabPersistencePolicy.getOrCreateTabbedModeStateDirectory();
        TabModel normalModel = getActivity().getTabModelSelector().getModel(false);
        TabModel incognitoModel = getActivity().getTabModelSelector().getModel(true);
        File normalTabFile = new File(tabStateDir,
                TabState.getTabStateFilename(
                        normalModel.getTabAt(normalModel.getCount() - 1).getId(), false));
        File incognitoTabFile = new File(tabStateDir,
                TabState.getTabStateFilename(incognitoModel.getTabAt(0).getId(), true));

        assertFileExists(normalTabFile, true);
        assertFileExists(incognitoTabFile, true);

        // Although we're destroying the activity, the Application will still live on since its in
        // the same process as this test.
        ApplicationTestUtils.finishActivity(getActivity());

        // Activity will be started without a savedInstanceState.
        startMainActivityOnBlankPage();
        assertFileExists(normalTabFile, true);
        assertFileExists(incognitoTabFile, false);
    }

    @Override
    public void startMainActivity() throws InterruptedException {
        float dpToPx = getInstrumentation().getContext().getResources().getDisplayMetrics().density;
        mPxToDp = 1.0f / dpToPx;

        // Exclude the tests that can launch directly to a page other than the NTP.
        if (getName().equals("testOpenAndCloseNewTabButton")
                || getName().equals("testSwitchToTabThatDoesNotHaveThumbnail")
                || getName().equals("testCloseTabPortrait")
                || getName().equals("testCloseTabLandscape")
                || getName().equals("testTabsAreDestroyedOnModelDestruction")) {
            return;
        }
        startMainActivityFromLauncher();
    }

    private void assertFileExists(final File fileToCheck, final boolean expected)
            throws InterruptedException {
        CriteriaHelper.pollInstrumentationThread(
                    Criteria.equals(expected, new Callable<Boolean>() {
                        @Override
                        public Boolean call() {
                            return fileToCheck.exists();
                        }
                    }));
    }
}