[Contextual Search] Add metrics for Resolve and View timing

chrome/android/java/src/org/chromium/chrome/browser/compositor/bottombar/contextualsearch/ContextualSearchPanelMetrics.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.compositor.bottombar.contextualsearch;
 
 import org.chromium.chrome.browser.compositor.bottombar.OverlayPanel.PanelState;
 import org.chromium.chrome.browser.compositor.bottombar.OverlayPanel.StateChangeReason;
 import org.chromium.chrome.browser.contextualsearch.ContextualSearchUma;
 
 /**
  * This class is responsible for all the logging related to Contextual Search.
  */
 public class ContextualSearchPanelMetrics {
 
     // Flags for logging.
     private boolean mDidSearchInvolvePromo;
     private boolean mWasSearchContentViewSeen;
     private boolean mIsPromoActive;
     private boolean mHasExpanded;
     private boolean mHasMaximized;
     private boolean mHasExitedPeeking;
     private boolean mHasExitedExpanded;
     private boolean mHasExitedMaximized;
     private boolean mIsSerpNavigation;
     private boolean mWasActivatedByTap;
     private boolean mIsSearchPanelFullyPreloaded;
     private boolean mWasIconSpriteAnimated;
-    private long mSearchStartTimeNs;
-    private long mSearchViewStartTimeNs;
+    // Time when the panel peeks into view (not reset by a chained search).
+    // Used to log total time the panel is showing (not closed).
+    private long mFirstPeekTimeNs;
+    // Time when the panel contents come into view (when the panel is opened).
+    // Used to log preload effectiveness info -- additional time needed to fully render the
+    // content in the overlay.
+    private long mContentFirstViewTimeNs;
+    // Time when a search request was started.  Reset by chained searches.
+    // Used to log the time it takes for a Search Result to become available.
+    private long mSearchRequestStartTimeNs;
 
     /**
      * Log information when the panel's state has changed.
      * @param fromState The state the panel is transitioning from.
      * @param toState The state that the panel is transitioning to.
      * @param reason The reason for the state change.
      */
     public void onPanelStateChanged(PanelState fromState, PanelState toState,
             StateChangeReason reason) {
         // Note: the logging within this function includes the promo, unless specifically
         // excluded.
         boolean isStartingSearch = isStartingNewContextualSearch(toState, reason);
         boolean isEndingSearch = isEndingContextualSearch(fromState, toState, isStartingSearch);
         boolean isChained = isStartingSearch && isOngoingContextualSearch(fromState);
         boolean isSameState = fromState == toState;
         boolean isFirstExitFromPeeking = fromState == PanelState.PEEKED && !mHasExitedPeeking
                 && (!isSameState || isStartingSearch);
         boolean isFirstExitFromExpanded = fromState == PanelState.EXPANDED && !mHasExitedExpanded
                 && !isSameState;
         boolean isFirstExitFromMaximized = fromState == PanelState.MAXIMIZED && !mHasExitedMaximized
                 && !isSameState;
         boolean isFirstSearchView = isFirstExitFromPeeking && toState != PanelState.CLOSED;
         // This variable is needed for logging and gets reset in an isStartingSearch block below,
         // so a local copy is created before the reset.
         boolean isSearchPanelFullyPreloaded = mIsSearchPanelFullyPreloaded;
 
         if (isEndingSearch) {
             if (!mDidSearchInvolvePromo) {
                 // Measure duration only when the promo is not involved.
-                long durationMs = (System.nanoTime() - mSearchStartTimeNs) / 1000000;
+                long durationMs = (System.nanoTime() - mFirstPeekTimeNs) / 1000000;
                 ContextualSearchUma.logDuration(mWasSearchContentViewSeen, isChained, durationMs);
             }
             if (mIsPromoActive) {
                 // The user is exiting still in the promo, without choosing an option.
                 ContextualSearchUma.logPromoSeen(mWasSearchContentViewSeen, mWasActivatedByTap);
             } else {
                 ContextualSearchUma.logResultsSeen(mWasSearchContentViewSeen, mWasActivatedByTap);
             }
 
             ContextualSearchUma.logIconSpriteAnimated(mWasIconSpriteAnimated,
                     mWasSearchContentViewSeen, mWasActivatedByTap);
         }
         if (isStartingSearch) {
-            mSearchStartTimeNs = System.nanoTime();
-            mSearchViewStartTimeNs = 0;
+            mFirstPeekTimeNs = System.nanoTime();
+            mContentFirstViewTimeNs = 0;
             mIsSearchPanelFullyPreloaded = false;
             mWasActivatedByTap = reason == StateChangeReason.TEXT_SELECT_TAP;
         }
         if (isFirstSearchView) {
             onSearchPanelFirstView();
         }
 
         // Log state changes. We only log the first transition to a state within a contextual
         // search. Note that when a user clicks on a link on the search content view, this will
         // trigger a transition to MAXIMIZED (SERP_NAVIGATION) followed by a transition to
@@ skipping 72 matching lines @@
     }
 
     /**
      * @param wasIconSpriteAnimated Whether the search provider icon sprite was animated.
      */
     public void setWasIconSpriteAnimated(boolean wasIconSpriteAnimated) {
         mWasIconSpriteAnimated = wasIconSpriteAnimated;
     }
 
     /**
-     * Gets whether the promo is active.
+     * Called to record the time when a search request started, for resolve and prefetch timing.
      */
-    private boolean getIsPromoActive() {
-        return mIsPromoActive;
+    public void onSearchRequestStarted() {
+        mSearchRequestStartTimeNs = System.nanoTime();
     }
 
     /**
+     * Called when a Search Term has been resolved.
+     */
+    public void onSearchTermResolved() {
+        long durationMs = (System.nanoTime() - mSearchRequestStartTimeNs) / 1000000;
+        ContextualSearchUma.logSearchTermResolutionDuration(durationMs);
+    }
+
+    /**
      * Records timing information when the search results have fully loaded.
      * @param wasPrefetch Whether the request was prefetch-enabled.
      */
     public void onSearchResultsLoaded(boolean wasPrefetch) {
         if (mHasExpanded || mHasMaximized) {
             // Already opened, log how long it took.
-            assert mSearchViewStartTimeNs != 0;
-            long durationMs = (System.nanoTime() - mSearchViewStartTimeNs) / 1000000;
+            assert mContentFirstViewTimeNs != 0;
+            long durationMs = (System.nanoTime() - mContentFirstViewTimeNs) / 1000000;
             logSearchPanelLoadDuration(wasPrefetch, durationMs);
         }
 
         // Not yet opened, wait till an open to log.
         mIsSearchPanelFullyPreloaded = true;
     }
 
     /**
+     * Called after the panel has navigated to prefetched Search Results.
+     * This is the point where the search result starts to render in the panel.
+     */
+    public void onPanelNavigatedToPrefetchedSearch(boolean didResolve) {
+        long durationMs = (System.nanoTime() - mSearchRequestStartTimeNs) / 1000000;
+        ContextualSearchUma.logPrefetchedSearchNavigatedDuration(durationMs, didResolve);
+    }
+
+    /**
      * Records timing information when the search panel has been viewed for the first time.
      */
     private void onSearchPanelFirstView() {
         if (mIsSearchPanelFullyPreloaded) {
             // Already fully pre-loaded, record a wait of 0 milliseconds.
             logSearchPanelLoadDuration(true, 0);
         } else {
             // Start a loading timer.
-            mSearchViewStartTimeNs = System.nanoTime();
+            mContentFirstViewTimeNs = System.nanoTime();
         }
     }
 
     /**
      * Determine whether a new contextual search is starting.
      * @param toState The contextual search state that will be transitioned to.
      * @param reason The reason for the search state transition.
      * @return Whether a new contextual search is starting.
      */
     private boolean isStartingNewContextualSearch(PanelState toState, StateChangeReason reason) {
@@ skipping 26 matching lines @@
     /**
      * Logs the duration the user waited for the search panel to fully load, once it was opened.
      * @param wasPrefetch Whether the load included prefetch.
      * @param durationMs The duration to log.
      */
     private void logSearchPanelLoadDuration(boolean wasPrefetch, long durationMs) {
         ContextualSearchUma.logSearchPanelLoadDuration(wasPrefetch, durationMs);
     }
 }