[TTS] Move Ranker logging to inference time.

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.annotation.SuppressLint;
 import android.os.Handler;
 import android.text.TextUtils;
 import android.view.View;
@@ skipping 76 matching lines @@
 
     // How long to wait for a tap near a previous tap before hiding the UI or showing a re-Tap.
     // This setting is not critical: in practice it determines how long to wait after an invalid
     // tap for the page to respond before hiding the UI. Specifically this setting just needs to be
     // long enough for Blink's decisions before calling handleShowUnhandledTapUIIfNeeded (which
     // probably are page-dependent), and short enough that the Bar goes away fairly quickly after a
     // tap on non-text or whitespace: We currently do not get notification in these cases (hence the
     // timer).
     private static final int TAP_NEAR_PREVIOUS_DETECTION_DELAY_MS = 100;
 
+    private static final int NANOSECONDS_IN_A_MILLISECOND = 1000000;
+
     private final ObserverList<ContextualSearchObserver> mObservers =
             new ObserverList<ContextualSearchObserver>();
 
     private final ChromeActivity mActivity;
     private final ContextualSearchTabPromotionDelegate mTabPromotionDelegate;
     private final ViewTreeObserver.OnGlobalFocusChangeListener mOnFocusChangeListener;
     private final TabModelObserver mTabModelObserver;
 
+    // The Ranker logger to use to write Tap Suppression Ranker logs to UMA.
+    private final ContextualSearchRankerLogger mTapSuppressionRankerLogger;
+
     private ContextualSearchSelectionController mSelectionController;
     private ContextualSearchNetworkCommunicator mNetworkCommunicator;
     private ContextualSearchPolicy mPolicy;
     private ContextualSearchInternalStateController mInternalStateController;
 
     @VisibleForTesting
     protected ContextualSearchTranslateController mTranslateController;
 
     // The Overlay panel.
     private ContextualSearchPanel mSearchPanel;
@@ skipping 102 matching lines @@
             @Override
             public void didAddTab(Tab tab, TabLaunchType type) {
                 // If we're in the process of promoting this tab, just return and don't mess with
                 // this state.
                 if (tab.getContentViewCore() == mSearchPanel.getContentViewCore()) return;
                 hideContextualSearch(StateChangeReason.UNKNOWN);
             }
         };
 
         mSelectionController = new ContextualSearchSelectionController(activity, this);
-
         mNetworkCommunicator = this;
-
         mPolicy = new ContextualSearchPolicy(mSelectionController, mNetworkCommunicator);
-
         mTranslateController = new ContextualSearchTranslateController(activity, mPolicy, this);
-
         mInternalStateController = new ContextualSearchInternalStateController(
                 mPolicy, getContextualSearchInternalStateHandler());
+        mTapSuppressionRankerLogger = new ContextualSearchRankerLoggerImpl();
     }
 
     /**
      * Initializes this manager.
      * @param parentView The parent view to attach Contextual Search UX to.
      */
     public void initialize(ViewGroup parentView) {
         mNativeContextualSearchManagerPtr = nativeInit();
 
         mParentView = parentView;
@@ skipping 530 matching lines @@
      * @param doesAnswer Whether the caption should be regarded as an answer such
      *        that the user may not need to open the panel, or whether the caption
      *        is simply informative or descriptive of the answer in the full results.
      */
     @CalledByNative
     private void onSetCaption(String caption, boolean doesAnswer) {
         if (TextUtils.isEmpty(caption)) return;
 
         // Notify the UI of the caption.
         mSearchPanel.setCaption(caption);
+        System.out.println("ctxs checking mQuickAnswersHeuristic " + mQuickAnswersHeuristic);
         if (mQuickAnswersHeuristic != null) {
             mQuickAnswersHeuristic.setConditionSatisfied(true);
             mQuickAnswersHeuristic.setDoesAnswer(doesAnswer);
         }
 
         // Update Tap counters to account for a possible answer.
         mPolicy.updateCountersForQuickAnswer(mWasActivatedByTap, doesAnswer);
     }
 
     /**
@@ skipping 488 matching lines @@
     }
 
     @Override
     public void handleSuppressedTap() {
         if (mIsAccessibilityModeEnabled) return;
 
         hideContextualSearch(StateChangeReason.BASE_PAGE_TAP);
     }
 
     @Override
-    public void handleNonSuppressedTap() {
+    public void handleNonSuppressedTap(long tapTimeNanoseconds) {
         if (mIsAccessibilityModeEnabled) return;
 
-        mInternalStateController.notifyFinishedWorkOn(InternalState.DECIDING_SUPPRESSION);
+        // If there's a wait-after-tap experiment then we may want to delay a bit longer for
+        // the user to take an action like scrolling that will reset our internal state.
+        long delayBeforeFinishingWorkMs = 0;
+        if (ContextualSearchFieldTrial.getWaitAfterTapDelayMs() > 0 && tapTimeNanoseconds > 0) {
+            delayBeforeFinishingWorkMs = ContextualSearchFieldTrial.getWaitAfterTapDelayMs()
+                    - (System.nanoTime() - tapTimeNanoseconds) / NANOSECONDS_IN_A_MILLISECOND;
+        }
+
+        // Finish work on the current state, either immediately or with a delay.
+        if (delayBeforeFinishingWorkMs <= 0) {
+            finishSuppressionDecision();
+        } else {
+            new Handler().postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    finishSuppressionDecision();
+                }
+            }, delayBeforeFinishingWorkMs);
+        }
+    }
+
+    /**
+     * Finishes work on the suppression decision if that work is still in progress.
+     * If no longer working on the suppression decision then resets the Ranker-logger.
+     */
+    private void finishSuppressionDecision() {
+        if (mInternalStateController.isStillWorkingOn(InternalState.DECIDING_SUPPRESSION)) {
+            mInternalStateController.notifyFinishedWorkOn(InternalState.DECIDING_SUPPRESSION);
+        } else {
+            mTapSuppressionRankerLogger.reset();
+        }
     }
 
     @Override
     public void handleMetricsForWouldSuppressTap(ContextualSearchHeuristics tapHeuristics) {
         mHeuristics = tapHeuristics;
 
         // TODO(donnd): QuickAnswersHeuristic is getting added to TapSuppressionHeuristics and
         // and getting considered in TapSuppressionHeuristics#shouldSuppressTap(). It should
         // be a part of ContextualSearchHeuristics for logging purposes but not for suppression.
         mQuickAnswersHeuristic = new QuickAnswersHeuristic();
         mHeuristics.add(mQuickAnswersHeuristic);
 
         mSearchPanel.getPanelMetrics().setResultsSeenExperiments(mHeuristics);
-        mSearchPanel.getPanelMetrics().setRankerLogExperiments(mHeuristics, getBasePageUrl());
+        mSearchPanel.getPanelMetrics().setRankerLogger(mTapSuppressionRankerLogger);
     }
 
     @Override
     public void handleValidTap() {
         if (mIsAccessibilityModeEnabled) return;
 
         mInternalStateController.enter(InternalState.TAP_RECOGNIZED);
     }
 
     /**
@@ skipping 113 matching lines @@
                             mNativeContextualSearchManagerPtr, mContext, webContents);
                 } else {
                     mInternalStateController.reset(StateChangeReason.UNKNOWN);
                 }
             }
 
             /** Starts the process of deciding if we'll suppress the current Tap gesture or not. */
             @Override
             public void decideSuppression() {
                 mInternalStateController.notifyStartingWorkOn(InternalState.DECIDING_SUPPRESSION);
-                mSelectionController.handleShouldSuppressTap();
+                // Ranker will handle the suppression, but our legacy implementation uses
+                // TapSuppressionHeuristics (run from the ContextualSearchSelectionConroller).
+                // Usage includes tap-far-from-previous suppression.
+                mTapSuppressionRankerLogger.setupLoggingForPage(getBasePageUrl());
+
+                // TODO(donnd): Move handleShouldSuppressTap out of the Selection Controller.
+                mSelectionController.handleShouldSuppressTap(mTapSuppressionRankerLogger);
             }
 
             /** Starts showing the Tap UI by selecting a word around the current caret. */
             @Override
             public void startShowingTapUi() {
                 WebContents baseWebContents = getBaseWebContents();
                 // TODO(donnd): Call isTapSupported earlier so we don't waste time gathering
                 // surrounding text and deciding suppression when unsupported, or remove the whole
                 // idea of unsupported taps in favor of deciding suppression better.
                 // Details in crbug.com/715297.
@@ skipping 140 matching lines @@
     private native void nativeStartSearchTermResolutionRequest(long nativeContextualSearchManager,
             ContextualSearchContext contextualSearchContext, WebContents baseWebContents);
     protected native void nativeGatherSurroundingText(long nativeContextualSearchManager,
             ContextualSearchContext contextualSearchContext, WebContents baseWebContents);
     private native void nativeEnableContextualSearchJsApiForOverlay(
             long nativeContextualSearchManager, WebContents overlayWebContents);
     // Don't call these directly, instead call the private methods that cache the results.
     private native String nativeGetTargetLanguage(long nativeContextualSearchManager);
     private native String nativeGetAcceptLanguages(long nativeContextualSearchManager);
 }