Overlay content is its own class

chrome/android/java/src/org/chromium/chrome/browser/contextualsearch/ContextualSearchManager.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 android.app.Activity;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
 import android.view.ViewTreeObserver.OnGlobalFocusChangeListener;
 
 import org.chromium.base.ActivityState;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.ApplicationStatus.ActivityStateListener;
 import org.chromium.base.SysUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.ChromeActivity;
+import org.chromium.chrome.browser.compositor.bottombar.OverlayContentDelegate;
 import org.chromium.chrome.browser.compositor.bottombar.contextualsearch.ContextualSearchPanel.PanelState;
 import org.chromium.chrome.browser.compositor.bottombar.contextualsearch.ContextualSearchPanel.StateChangeReason;
 import org.chromium.chrome.browser.compositor.bottombar.contextualsearch.ContextualSearchPanelDelegate;
 import org.chromium.chrome.browser.contextualsearch.ContextualSearchSelectionController.SelectionType;
 import org.chromium.chrome.browser.device.DeviceClassManager;
 import org.chromium.chrome.browser.externalnav.ExternalNavigationHandler;
 import org.chromium.chrome.browser.externalnav.ExternalNavigationHandler.OverrideUrlLoadingResult;
 import org.chromium.chrome.browser.externalnav.ExternalNavigationParams;
 import org.chromium.chrome.browser.gsa.GSAContextDisplaySelection;
 import org.chromium.chrome.browser.infobar.InfoBarContainer;
@@ skipping 68 matching lines @@
     private long mLoadedSearchUrlTimeMs;
     // TODO(donnd): consider changing this member's name to indicate "opened" instead of "seen".
     private boolean mWereSearchResultsSeen;
     private boolean mWereInfoBarsHidden;
     private boolean mDidLoadAnyUrl;
     private boolean mDidPromoteSearchNavigation;
     private boolean mDidBasePageLoadJustStart;
     private boolean mWasActivatedByTap;
     private boolean mIsInitialized;
 
+    /**
+     * This boolean is used for loading content after a long-press when content is not immediately
+     * loaded.
+     */
+    private boolean mShouldLoadDelayedSearch;
+
     private boolean mIsShowingPromo;
     private boolean mDidLogPromoOutcome;
 
     /**
      * Whether contextual search manager is currently promoting a tab. We should be ignoring hide
      * requests when mIsPromotingTab is set to true.
      */
     private boolean mIsPromotingToTab;
 
     private ContextualSearchNetworkCommunicator mNetworkCommunicator;
@@ skipping 340 matching lines @@
         }
 
         // If the user is jumping from one unseen search to another search, remove the last search
         // from history.
         PanelState state = mSearchPanelDelegate.getPanelState();
         if (!mWereSearchResultsSeen && mLoadedSearchUrlTimeMs != 0L
                 && state != PanelState.UNDEFINED && state != PanelState.CLOSED) {
             removeLastSearchVisit();
         }
 
+        mSearchPanelDelegate.setSearchContentViewVisibility(false);
+
         boolean isTap = mSelectionController.getSelectionType() == SelectionType.TAP;
         boolean didRequestSurroundings = false;
+
+        if (isTap) {
+            // If the user action was not a long-press, immediately start loading content.
+            mShouldLoadDelayedSearch = false;

[pedro (no code reviews), 2015/09/23 00:00:12]

I'm not very happy with adding a new boolean, because the logic in the Manager
is already pretty complicated, but I cannot think of a better solution at the
moment.

Things to keep in mind:

1) If we decide to keep the boolean, it should actually be placed inside the
block below, because not all taps will load content before the user pulls the
Panel up.

2) Also note that even when it does, a tap will not load it *immediately*, as
stated in comment. Instead if will be loaded after a round trip to the server to
find out the resolved search term. For this reason, please update the phrasing
of the comment.

I will try to find a better solution, but I cannot apply your patch due to merge
conflicts :(

[mdjones, 2015/09/23 00:29:31]

Acknowledged.

+        }
+
         if (isTap && mPolicy.shouldPreviousTapResolve(
                 mNetworkCommunicator.getBasePageUrl())) {
             mNetworkCommunicator.startSearchTermResolutionRequest(
                     mSelectionController.getSelectedText());
             didRequestSurroundings = true;
         } else {
             boolean shouldPrefetch = mPolicy.shouldPrefetchSearchResult(isTap);
             mSearchRequest = new ContextualSearchRequest(mSelectionController.getSelectedText(),
                     null, shouldPrefetch);
             mDidLoadResolvedSearchRequest = false;
@@ skipping 269 matching lines @@
     /**
      * @return Whether a Tap gesture is currently supported.
      */
     private boolean isTapSupported() {
         // Base page just started navigating away, so taps should be ignored.
         if (mDidBasePageLoadJustStart) return false;
 
         return mPolicy.isTapSupported();
     }
 
+    // ============================================================================================
+    // OverlayContentDelegate
+    // ============================================================================================
+
+    @Override
+    public OverlayContentDelegate getOverlayContentDelegate() {
+        return new SearchOverlayContentDelegate();
+    }
+
+    /**
+     * Implementation of OverlayContentDelegate. Made public for testing purposes.
+     */
+    public class SearchOverlayContentDelegate extends OverlayContentDelegate {
+
+        public SearchOverlayContentDelegate() {}
+
+        @Override
+        public void onMainFrameLoadStarted(String url) {
+            onExternalNavigation(url);
+        }
+
+        @Override
+        public void onMainFrameNavigation(String url, boolean isFailure) {
+            handleDidNavigateMainFrame(url, isFailure);
+        }
+
+        @Override
+        public void onContentLoadStarted(String url) {
+            onStartedLoading();
+        }
+
+        @Override
+        public void onContentLoadFinished() {
+            onSearchResultsLoaded();
+        }
+
+        @Override
+        public void onVisibilityChanged(boolean isVisible) {
+            onContentViewVisibilityChanged(isVisible);
+        }
+
+        @Override
+        public void onContentViewCreated(ContentViewCore contentViewCore) {
+            // TODO: implemented in manager
+            ContextualSearchManager.this.onContentViewCreated(contentViewCore);
+        }
+
+        @Override
+        public void onContentViewDestroyed() {
+            // TODO: implemented in manager
+            ContextualSearchManager.this.onContentViewDestroyed();
+        }
+
+        @Override
+        public void onContentViewSeen() {
+            mSearchPanelDelegate.setWasSearchContentViewSeen();
+        }
+
+        @Override
+        public boolean shouldInterceptNavigation(ExternalNavigationHandler externalNavHandler,
+                NavigationParams navigationParams) {
+            return ContextualSearchManager.this.shouldInterceptNavigation(externalNavHandler,
+                    navigationParams);
+        }
+    }
+
+
     // --------------------------------------------------------------------------------------------
     // Search Content View
     // --------------------------------------------------------------------------------------------
 
     /**
      * Gets the {@code ContentViewCore} associated with Contextual Search Panel.
      * @return Contextual Search Panel's {@code ContentViewCore}.
      */
     @Override
     public ContentViewCore getSearchContentViewCore() {
@@ skipping 58 matching lines @@
     @Override
     public void logPromoOutcome() {
         ContextualSearchUma.logPromoOutcome(mWasActivatedByTap);
         mDidLogPromoOutcome = true;
     }
 
     /**
      * Called when the Search Content view has finished loading to record how long it takes the SERP
      * to load after opening the panel.
      */
-    @Override
     public void onSearchResultsLoaded() {
         if (mSearchRequest == null) return;
 
         mSearchPanelDelegate.onSearchResultsLoaded(mSearchRequest.wasPrefetch());
 
         // Any time we place a page in a ContentViewCore, clear history if needed.
         // This prevents error URLs from appearing in the Tab's history stack.
         // Also please note that clearHistory() will not
         // clear the current entry (search results page in this case),
         // and it will not work properly if there are pending navigations.
         // That's why we need to clear the history here, after the navigation
         // is completed.
         boolean shouldClearHistory = mSearchRequest.getHasFailed();
         if (shouldClearHistory && mSearchPanelDelegate.getContentViewCore() != null) {
             mSearchPanelDelegate.getContentViewCore().getWebContents().getNavigationController()
                     .clearHistory();
         }
     }
 
-    @Override
-    public void handleDidNavigateMainFrame(String url, int httpResultCode) {
+    /**
+     * Handles the WebContentsObserver#didNavigateMainFrame callback.
+     * @param url The URL of the navigation.
+     * @param isFailure True if the navigation resulted in a failure.
+     */
+    public void handleDidNavigateMainFrame(String url, boolean isFailure) {
         if (shouldPromoteSearchNavigation()) {
             onExternalNavigation(url);
         } else {
             // Could be just prefetching, check if that failed.
-            boolean isFailure = isHttpFailureCode(httpResultCode);
             onContextualSearchRequestNavigation(isFailure);
         }
     }
 
-    @Override
+    /**
+     * Called when the WebContents for the panel starts loading.
+     */
     public void onStartedLoading() {
         mDidPromoteSearchNavigation = false;
     }
 
-    @Override
+    /**
+     * Determine if the panel should intercept a particular navigation.
+     * @param externamNavHandler External navigation handler.
+     * @param navigationParams Params associated with the navigation.
+     * @return True if the navigation should be intecepted.
+     */
     public boolean shouldInterceptNavigation(
             ExternalNavigationHandler externalNavHandler, NavigationParams navigationParams) {
         mTabRedirectHandler.updateNewUrlLoading(navigationParams.pageTransitionType,
                 navigationParams.isRedirect,
                 navigationParams.hasUserGesture || navigationParams.hasUserGestureCarryover,
                 mActivity.getLastUserInteractionTime(), TabRedirectHandler.INVALID_ENTRY_INDEX);
         ExternalNavigationParams params = new ExternalNavigationParams.Builder(
                 navigationParams.url, false, navigationParams.referrer,
                 navigationParams.pageTransitionType, navigationParams.isRedirect)
                 .setApplicationMustBeInForeground(true)
                 .setRedirectHandler(mTabRedirectHandler)
                 .setIsMainFrame(navigationParams.isMainFrame)
                 .build();
         if (externalNavHandler.shouldOverrideUrlLoading(params)
                 != OverrideUrlLoadingResult.NO_OVERRIDE) {
             mSearchPanelDelegate.maximizePanelThenPromoteToTab(StateChangeReason.TAB_PROMOTION,
                     INTERCEPT_NAVIGATION_PROMOTION_ANIMATION_DURATION_MS);
-            return true;
+            return false;
         }
         if (navigationParams.isExternalProtocol) {
-            return true;
+            return false;
         }
-        return false;
+        return true;
     }
 
     /**
      * @return Whether the given HTTP result code represents a failure or not.
      */
     private boolean isHttpFailureCode(int httpResultCode) {
         return httpResultCode <= 0 || httpResultCode >= 400;
     }
 
     /**
      * @return whether a navigation in the search content view should promote to a separate tab.
      */
     private boolean shouldPromoteSearchNavigation() {
         // A navigation can be due to us loading a URL, or a touch in the search content view.
         // Require a touch, but no recent loading, in order to promote to a separate tab.
         // Note that tapping the opt-in button requires checking for recent loading.
         return mSearchPanelDelegate.didTouchSearchContentView()
                 && !mSearchPanelDelegate.didLoadAnyUrl();
     }
 
     /**
      * Called to check if an external navigation is being done and take the appropriate action:
      * Auto-promotes the panel into a separate tab if that's not already being done.
      * @param url The URL we are navigating to.
      */
-    @Override
     public void onExternalNavigation(String url) {
         mSearchPanelDelegate.updateTopControlState();
 
         if (!mDidPromoteSearchNavigation
                 && !BLACKLISTED_URL.equals(url)
                 && !url.startsWith(INTENT_URL_PREFIX)
                 && shouldPromoteSearchNavigation()) {
             // Do not promote to a regular tab if we're loading our Resolved Search
             // URL, otherwise we'll promote it when prefetching the Serp.
             // Don't promote URLs when they are navigating to an intent - this is
             // handled by the InterceptNavigationDelegate which uses a faster
             // maximizing animation.
             mDidPromoteSearchNavigation = true;
             mSearchPanelDelegate.maximizePanelThenPromoteToTab(StateChangeReason.SERP_NAVIGATION);
         }
     }
 
-    @Override
+    /**
+     * This method is called when the panel's ContentViewCore is created.
+     * @param contentView The created ContentViewCore.
+     */
     public void onContentViewCreated(ContentViewCore contentView) {
         // TODO(mdjones): Move SearchContentViewDelegate ownership to panel.
         mSearchContentViewDelegate.setContextualSearchContentViewCore(contentView);
     }
 
-    @Override
+    /**
+     * This method is called when the panel's ContentViewCore is destroyed.
+     */
     public void onContentViewDestroyed() {
         if (mSearchContentViewDelegate != null) {
             mSearchContentViewDelegate.releaseContextualSearchContentViewCore();
         }
     }
 
     @Override
     public void openResolvedSearchUrlInNewTab() {
         if (mSearchRequest != null && mSearchRequest.getSearchUrl() != null) {
             openUrlInNewTab(mSearchRequest.getSearchUrl());
@@ skipping 61 matching lines @@
                 ? entry.getUrl() : searchContentViewCore.getWebContents().getUrl();
         return url;
     }
 
     @Override
     public float getSearchContentViewVerticalScroll() {
         return mSearchPanelDelegate.getContentViewCore() != null
                 ? mSearchPanelDelegate.getContentViewCore().computeVerticalScrollOffset() : -1.f;
     }
 
-    @Override
+    /**
+     * This is called when the search panel is shown or is hidden.
+     * @param isVisible True if the panel is now visible.
+     */
     public void onContentViewVisibilityChanged(boolean isVisible) {
         if (isVisible) {
             mWereSearchResultsSeen = true;
             // If there's no current request, then either a search term resolution
             // is in progress or we should do a verbatim search now.
             if (mSearchRequest == null
                     && mPolicy.shouldCreateVerbatimRequest(mSelectionController,
                             mNetworkCommunicator.getBasePageUrl())) {
                 mSearchRequest = new ContextualSearchRequest(
                         mSelectionController.getSelectedText());
                 mDidLoadResolvedSearchRequest = false;
             }
-            if (mSearchRequest != null && !mDidLoadResolvedSearchRequest) {
+            if ((mSearchRequest != null && !mDidLoadResolvedSearchRequest)
+                    || mShouldLoadDelayedSearch) {

[pedro (no code reviews), 2015/09/23 00:00:12]

Could you please include a comment here detailing why exactly we need the new
boolean?

[mdjones, 2015/09/23 00:29:31]

Done.

                 mSearchRequest.setNormalPriority();
                 loadSearchUrl();
             }
+            mShouldLoadDelayedSearch = true;
             mPolicy.updateCountersForOpen();
         }
     }
 
     @Override
     public void preserveBasePageSelectionOnNextLossOfFocus() {
         ContentViewCore basePageContentView = getBaseContentView();
         if (basePageContentView != null) {
             basePageContentView.preserveSelectionOnNextLossOfFocus();
         }
@@ skipping 115 matching lines @@
 
     private native long nativeInit();
     private native void nativeDestroy(long nativeContextualSearchManager);
     private native void nativeStartSearchTermResolutionRequest(long nativeContextualSearchManager,
             String selection, boolean useResolvedSearchTerm, ContentViewCore baseContentViewCore,
             boolean maySendBasePageUrl);
     private native void nativeGatherSurroundingText(long nativeContextualSearchManager,
             String selection, boolean useResolvedSearchTerm, ContentViewCore baseContentViewCore,
             boolean maySendBasePageUrl);
 }