Update touch selection notification names, add ESTABLISHED.

chrome/android/javatests/src/org/chromium/chrome/browser/contextualsearch/ContextualSearchManagerTest.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.contextualsearch;
 
 import static org.chromium.base.test.util.Restriction.RESTRICTION_TYPE_NON_LOW_END_DEVICE;
 import static org.chromium.base.test.util.Restriction.RESTRICTION_TYPE_PHONE;
 import static org.chromium.content.browser.test.util.CriteriaHelper.DEFAULT_POLLING_INTERVAL;
 
@@ skipping 289 matching lines @@
      */
     private void waitForPanelToPeekAndAssert() throws InterruptedException {
         assertTrue("Search Bar did not peek.", waitForPanelToEnterState(PanelState.PEEKED));
     }
 
     /**
      * Waits for the Search Panel to expand, and asserts that it did expand.
      * @throws InterruptedException
      */
     private void waitForPanelToExpandAndAssert() throws InterruptedException {
-        assertTrue("Search Bar did not expand.", waitForPanelToEnterState(PanelState.EXPANDED));
+        assertTrue("Search Panel did not expand.", waitForPanelToEnterState(PanelState.EXPANDED));
     }
 
     /**
      * Waits for the Search Panel to maximize, and asserts that it did maximize.
      * @throws InterruptedException
      */
     private void waitForPanelToMaximizeAndAssert() throws InterruptedException {
-        assertTrue("Search Bar did not maximize.", waitForPanelToEnterState(PanelState.MAXIMIZED));
+        assertTrue(
+                "Search Panel did not maximize.", waitForPanelToEnterState(PanelState.MAXIMIZED));
     }
 
     /**
      * Waits for the Search Panel to close, and asserts that it did close.
      * @throws InterruptedException
      */
     private void waitForPanelToCloseAndAssert() throws InterruptedException {
-        // TODO(donnd): figure out why using waitForPanelToEnterState here doesn't work.
-        assertTrue("Search Bar did not close.",
-                CriteriaHelper.pollForCriteria(new Criteria() {
-                    @Override
-                    public boolean isSatisfied() {
-                        return !mManager.isSearchPanelShowing();
-                    }
-                }, TEST_TIMEOUT, DEFAULT_POLLING_INTERVAL));
+        assertTrue("Search Panel did not close.", waitForPanelToEnterState(PanelState.CLOSED));
     }
 
     /**
+     * Asserts that the panel was never opened.
+     * @throws InterruptedException
+     */
+    private void assertPanelNeverOpened() throws InterruptedException {
+        assertTrue(
+                "Search Panel actually did open.", waitForPanelToEnterState(PanelState.UNDEFINED));
+    }
+
+    /**
      * Waits for the Search Panel to enter the given {@code PanelState}.
      * @throws InterruptedException
      */
     private boolean waitForPanelToEnterState(final PanelState state) throws InterruptedException {
         return CriteriaHelper.pollForCriteria(new Criteria() {
             @Override
             public boolean isSatisfied() {
                 return mPanelDelegate != null
                         && mPanelDelegate.getPanelState() == state;
             }
@@ skipping 38 matching lines @@
                 CriteriaHelper.pollForCriteria(new Criteria() {
                     @Override
                     public boolean isSatisfied() {
                         return TextUtils.equals(text, getSelectedText());
                     }
                 }, TEST_TIMEOUT, DEFAULT_POLLING_INTERVAL));
     }
 
     /**
      * Waits for the selection to be dissolved.
+     * Use this method any time a test repeatedly establishes and dissolves a selection to ensure
+     * that the selection has been completely dissolved before simulating the next selection event.
      * This is needed because the renderer's notification of a selection going away is async,
      * and a subsequent tap may think there's a current selection until it has been dissolved.
      */
     private void waitForSelectionDissolved() throws InterruptedException {
         assertTrue("Selection never dissolved.", CriteriaHelper.pollForCriteria(new Criteria() {
             @Override
             public boolean isSatisfied() {
                 return !mSelectionController.isSelectionEstablished();
             }
         }, TEST_TIMEOUT, DEFAULT_POLLING_INTERVAL));
     }
 
     /**
+     * Waits for the panel to close and then waits for the selection to dissolve.
+     */
+    private void waitForPanelToCloseAndSelectionDissolved() throws InterruptedException {
+        waitForPanelToCloseAndAssert();
+        waitForSelectionDissolved();
+    }
+
+    /**
      * A ContentViewCore that has some methods stubbed out for testing.
      */
     private static final class StubbedContentViewCore extends ContentViewCore {
         private boolean mIsFocusedNodeEditable;
 
         public StubbedContentViewCore(Context context) {
             super(context);
         }
 
         public void setIsFocusedNodeEditableForTest(boolean isFocusedNodeEditable) {
@@ skipping 40 matching lines @@
     /**
      * Scrolls the base page.
      */
     private void scrollBasePage() {
         swipe(0.f, 0.75f, 0.f, 0.7f, 100);
     }
 
     /**
      * Taps the base page near the top.
      */
-    private void tapBasePage() throws InterruptedException {
+    private void tapBasePageToClosePanel() throws InterruptedException {
         tapBasePage(0.1f, 0.1f);
+        waitForPanelToCloseAndAssert();
     }
 
     /**
      * Taps the base page at the given x, y position.
      */
-    private void tapBasePage(float x, float y) throws InterruptedException {
+    private void tapBasePage(float x, float y) {
         Point size = new Point();
         getActivity().getWindowManager().getDefaultDisplay().getSize(size);
         x *= size.x;
         y *= size.y;
         singleClick(x, y);
-        waitForPanelToCloseAndAssert();
     }
 
     /**
      * Click various places to cause the panel to show, expand, then close.
      */
     private void clickToExpandAndClosePanel() throws InterruptedException, TimeoutException {
         clickWordNode("states");
-        tapPeekingBarToExpandAndAssert();
-        tapBasePage();
-        waitForPanelToCloseAndAssert();
+        tapBarToExpandAndClosePanel();
+        waitForSelectionDissolved();
     }
 
     /**
+     * Tap on the peeking Bar to expand the panel, then taps on the base page to close it.
+     */
+    private void tapBarToExpandAndClosePanel() throws InterruptedException {
+        tapPeekingBarToExpandAndAssert();
+        tapBasePageToClosePanel();
+    }
+
+    /**
      * Generate a click in the panel's bar.
      * @barHeight The vertical position where the click should take place as a percentage
      *            of the screen size.
      */
     private void clickPanelBar(float barPositionVertical) {
         Point size = new Point();
         getActivity().getWindowManager().getDefaultDisplay().getSize(size);
         float w = size.x;
         float h = size.y;
         boolean landscape = w > h;
@@ skipping 14 matching lines @@
     /**
      * Simple sequence useful for checking if a Search Term Resolution request is sent.
      * Resets the fake server and clicks near to cause a search, then clicks far to let the panel
      * drop down (taking us back to the same state).
      */
     private void clickToTriggerSearchTermResolution()
             throws InterruptedException, TimeoutException {
         mFakeServer.reset();
         clickWordNode("states");
         clickNode("states-far");
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
     }
 
     /**
      * Simple sequence useful for checking if a Search Request is prefetched.
      * Resets the fake server and clicks near to cause a search, fakes a server response to
      * trigger a prefetch, then clicks far to let the panel drop down
      * which takes us back to the starting state except the the fake server knows
      * if a prefetch occurred.
      */
     private void clickToTriggerPrefetch() throws InterruptedException, TimeoutException {
         mFakeServer.reset();
         clickWordNode("states");
         assertSearchTermRequested();
         fakeResponse(false, 200, "States", "display-text", "alternate-term", false);
         waitForPanelToPeekAndAssert();
         clickNode("states-far");
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
     }
 
     /**
      * Simple sequence to click, resolve, and prefetch.  Verifies a prefetch occurred.
      */
     private void clickToResolveAndAssertPrefetch() throws InterruptedException, TimeoutException {
         clickWordNode("states");
         assertLoadedNoUrl();
         assertSearchTermRequested();
 
@@ skipping 164 matching lines @@
         waitForPanelToPeekAndAssert();
         assertLoadedNoUrl();
         assertNoContentViewCore();
         swipePanelUp();
         waitForPanelToExpandAndAssert();
         assertContentViewCoreCreated();
         assertLoadedNormalPriorityUrl();
         assertEquals(1, mFakeServer.loadedUrlCount());
 
         // tap the base page to close.
-        tapBasePage();
-        waitForPanelToCloseAndAssert();
+        tapBasePageToClosePanel();
         assertEquals(1, mFakeServer.loadedUrlCount());
         assertNoContentViewCore();
     }
 
     /**
      * Tests a sequence in landscape orientation: swiping the overlay open, after an
      * initial tap that activates the peeking card.
      */
     @SmallTest
     @Feature({"ContextualSearch"})
@@ skipping 22 matching lines @@
         fakeResponse(false, 200, "states", "United States Intelligence", "alternate-term", false);
         assertContainsParameters("states", "alternate-term");
         assertEquals(1, mFakeServer.loadedUrlCount());
         assertLoadedLowPriorityUrl();
         assertContentViewCoreCreated();
         tapPeekingBarToExpandAndAssert();
         assertLoadedLowPriorityUrl();
         assertEquals(1, mFakeServer.loadedUrlCount());
 
         // tap the base page to close.
-        tapBasePage();
-        waitForPanelToCloseAndAssert();
+        tapBasePageToClosePanel();
         assertEquals(1, mFakeServer.loadedUrlCount());
         assertNoContentViewCore();
     }
 
     /**
      * Tests that only a single low-priority request is issued for a Tap/Open sequence.
      */
     @SmallTest
     @Feature({"ContextualSearch"})
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
@@ skipping 384 matching lines @@
     }
 
     /**
      * Tests that a Tap gesture on an element with an ARIA role does not trigger.
      */
     @SmallTest
     @Feature({"ContextualSearch"})
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     public void testTapOnRoleIgnored() throws InterruptedException, TimeoutException {
         clickNode("role");
-        waitForGestureToClosePanelAndAssertNoSelection();
+        assertPanelNeverOpened();
     }
 
     /**
      * Tests that a Tap gesture on an element with an ARIA attribute does not trigger.
      */
     @SmallTest
     @Feature({"ContextualSearch"})
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     public void testTapOnARIAIgnored() throws InterruptedException, TimeoutException {
         clickNode("aria");
-        waitForGestureToClosePanelAndAssertNoSelection();
+        assertPanelNeverOpened();
     }
 
     /**
      * Tests that a Tap gesture on an element that is focusable does not trigger.
      */
     @SmallTest
     @Feature({"ContextualSearch"})
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     public void testTapOnFocusableIgnored() throws InterruptedException, TimeoutException {
         clickNode("focusable");
-        waitForGestureToClosePanelAndAssertNoSelection();
+        assertPanelNeverOpened();
     }
 
     /**
      * Tests that taps can be resolve-limited for decided users.
      *
      * @SmallTest
      * @Feature({"ContextualSearch"})
      * crbug.com/487759
      */
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
@@ skipping 116 matching lines @@
     @CommandLineFlags.Add({
             ContextualSearchFieldTrial.PROMO_ON_LIMITED_TAPS + "=true",
             ContextualSearchFieldTrial.TAP_TRIGGERED_PROMO_LIMIT + "=2"})
     @FlakyTest
     public void testTapTriggeredPromoLimitForOptOut()
             throws InterruptedException, TimeoutException {
         mPolicy.overrideDecidedStateForTesting(false);
 
         clickWordNode("states");
         clickNode("states-far");
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
         clickWordNode("states");
         clickNode("states-far");
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
 
         // 3rd click won't peek the panel.
         clickNode("states");
         assertPanelClosedOrUndefined();
         // The Tap should not select any text either!
         assertNull(getSelectedText());
 
         // A long-press should still show the promo bar.
         longPressNode("states");
         waitForPanelToPeekAndAssert();
 
         // Expanding the panel should deactivate the limit.
-        clickToExpandAndClosePanel();
+        tapBarToExpandAndClosePanel();
+        // Clear the long-press selection.
+        clickNode("states-far");
 
         // Three taps should work now.
         clickWordNode("states");
         clickNode("states-far");
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
         clickWordNode("states");
         clickNode("states-far");
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
         clickWordNode("states");
         clickNode("states-far");
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
     }
 
     /**
      * This is a test that happens to create a separate bar without any content area!
      *
      * @SmallTest
      * @Feature({"ContextualSearch"})
      */
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     @CommandLineFlags.Add(
             ContextualSearchFieldTrial.TAP_PREFETCH_LIMIT_FOR_DECIDED + "=2")
     @FlakyTest
     public void testDisembodiedBar() throws InterruptedException, TimeoutException {
         clickToTriggerPrefetch();
         assertLoadedLowPriorityUrl();
         clickToTriggerPrefetch();
         assertLoadedLowPriorityUrl();
         // 3rd click should not preload.
         clickToTriggerPrefetch();
         assertLoadedNoUrl();
 
         // Expanding the panel should reset the limit.
         swipePanelUp();
         singleClick(0.5f, 0.5f);
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
 
         // Click should preload again.
         clickToTriggerPrefetch();
         assertLoadedLowPriorityUrl();
     }
 
     /**
      * Tests expanding the panel before the search term has resolved, verifies that nothing
      * loads until the resolve completes and that it's now a normal priority URL.
      */
@@ skipping 119 matching lines @@
     @SmallTest
     @Feature({"ContextualSearch"})
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     public void testAppMenuSuppressedWhenExpanded() throws InterruptedException, TimeoutException {
         clickWordNode("states");
         tapPeekingBarToExpandAndAssert();
 
         pressAppMenuKey();
         assertAppMenuVisibility(false);
 
-        tapBasePage();
-        waitForPanelToCloseAndAssert();
+        tapBasePageToClosePanel();
 
         pressAppMenuKey();
         assertAppMenuVisibility(true);
     }
 
     /**
      * Tests that the App Menu gets suppressed when Search Panel is maximized.
      */
     @SmallTest
     @Feature({"ContextualSearch"})
@@ skipping 43 matching lines @@
         // A simple Tap should change the counter.
         clickToTriggerPrefetch();
         assertTapPromoCounterEnabledAt(1);
 
         // Another Tap should increase the counter.
         clickToTriggerPrefetch();
         assertTapPromoCounterEnabledAt(2);
 
         // Now we're at the limit, a tap should be ignored.
         clickNode("states");
-        waitForPanelToCloseAndAssert();
+        waitForPanelToCloseAndSelectionDissolved();
         assertTapPromoCounterEnabledAt(2);
 
         // An open should disable the counter, but we need to use long-press (tap is now disabled).
         longPressNode("states-far");
         tapPeekingBarToExpandAndAssert();
-        tapBasePage();
-        waitForPanelToCloseAndAssert();
+        tapBasePageToClosePanel();
         assertTapPromoCounterDisabledAt(2);
 
         // Even though we closed the panel, the long-press selection is still there.
         // Tap on the question mark to dismiss the long-press selection.
         clickNode("question-mark");
         waitForSelectionToBe(null);
 
         // Now taps should work and not change the counter.
         clickToTriggerPrefetch();
         assertTapPromoCounterDisabledAt(2);
@@ skipping 93 matching lines @@
     @SmallTest
     @Feature({"ContextualSearch"})
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     public void testNotifyObserverHideAfterLongPress()
             throws InterruptedException, TimeoutException {
         TestContextualSearchObserver observer = new TestContextualSearchObserver();
         mManager.addObserver(observer);
         longPressNode("states");
         assertEquals(0, observer.hideCount);
 
-        tapBasePage();
-        waitForPanelToCloseAndAssert();
+        tapBasePageToClosePanel();
         assertEquals(1, observer.hideCount);
     }
 
     /**
      * Tests that ContextualSearchObserver gets notified when user brings up contextual search
      * panel via tap and then dismisses the panel by tapping on the base page.
      */
     @SmallTest
     @Feature({"ContextualSearch"})
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     public void testNotifyObserverHideAfterTap() throws InterruptedException, TimeoutException {
         TestContextualSearchObserver observer = new TestContextualSearchObserver();
         mManager.addObserver(observer);
         clickWordNode("states");
         assertEquals(0, observer.hideCount);
 
-        tapBasePage();
-        waitForPanelToCloseAndAssert();
+        tapBasePageToClosePanel();
         assertEquals(1, observer.hideCount);
     }
 
     private void assertWaitForSelectActionBarVisible(final boolean visible)
             throws InterruptedException {
         assertTrue(CriteriaHelper.pollForUIThreadCriteria(new Criteria() {
             @Override
             public boolean isSatisfied() {
                 return visible == getActivity().getActivityTab().getContentViewCore()
                         .isSelectActionBarShowing();
@@ skipping 53 matching lines @@
         mManager.onSelectionEvent(SelectionEventType.SELECTION_HANDLE_DRAG_STOPPED, 303, 450);
         assertPanelClosedOrUndefined();
 
         // Select a different word and assert that the panel has appeared.
         longPressNode("states-far");
         waitForPanelToPeekAndAssert();
     }
 
     /**
      * Tests a bunch of taps in a row.
-     * We've had reliability problems with simple taps due to async clearing
+     * We've had reliability problems with a sequence of simple taps, due to async dissolving
      * of selection bounds, so this helps prevent a regression with that.
      */
     @Restriction({RESTRICTION_TYPE_PHONE, RESTRICTION_TYPE_NON_LOW_END_DEVICE})
     @CommandLineFlags.Add({ContextualSearchFieldTrial.TAP_RESOLVE_LIMIT_FOR_DECIDED + "=200",
             ContextualSearchFieldTrial.TAP_RESOLVE_LIMIT_FOR_UNDECIDED + "=200",
             ContextualSearchFieldTrial.TAP_PREFETCH_LIMIT_FOR_DECIDED + "=200",
             ContextualSearchFieldTrial.TAP_PREFETCH_LIMIT_FOR_UNDECIDED + "=200"})
     public void testTapALot() throws InterruptedException, TimeoutException {
         for (int i = 0; i < 50; i++) {
             clickToTriggerSearchTermResolution();
             waitForSelectionDissolved();
             assertSearchTermRequested();
         }
     }
 }