Log First User Interaction in Page Load Metrics

components/page_load_metrics/browser/metrics_web_contents_observer.h

 // 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.
 
 #ifndef COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_
 #define COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_
 
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "components/page_load_metrics/browser/page_load_metrics_observer.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "net/base/net_errors.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
 
 namespace content {
 class NavigationHandle;
 class RenderFrameHost;
 }  // namespace content
 
 namespace IPC {
 class Message;
 }  // namespace IPC
 
@@ skipping 50 matching lines @@
   // cc file for details). We use this error counter to understand how often it
   // happens.
   ERR_ABORT_BEFORE_NAVIGATION_START,
 
   // A new navigation triggers abort updates in multiple trackers in
   // |aborted_provisional_loads_|, when usually there should only be one (the
   // navigation that just aborted because of this one). If this happens, the
   // latest aborted load is used to track the chain size.
   ERR_NAVIGATION_SIGNALS_MULIPLE_ABORTED_LOADS,
 
+  // Receives user interaction before navigation start
+  ERR_USER_INTERACTION_WITH_NO_RELEVANT_LOAD,
+
   // Add values before this final count.
-  ERR_LAST_ENTRY
+  ERR_LAST_ENTRY,
 };
 
 // This class serves as a functional interface to various chrome// features.
 // Impl version is defined in chrome/browser/page_load_metrics.
 class PageLoadMetricsEmbedderInterface {
  public:
   virtual ~PageLoadMetricsEmbedderInterface() {}
   virtual bool IsPrerendering(content::WebContents* web_contents) = 0;
   virtual void RegisterObservers(PageLoadTracker* metrics) = 0;
 };
@@ skipping 14 matching lines @@
                   content::NavigationHandle* navigation_handle,
                   int aborted_chain_size,
                   int aborted_chain_size_same_url);
   ~PageLoadTracker();
   void Redirect(content::NavigationHandle* navigation_handle);
   void Commit(content::NavigationHandle* navigation_handle);
   void FailedProvisionalLoad(content::NavigationHandle* navigation_handle);
   void WebContentsHidden();
   void WebContentsShown();
 
+  void OnInputEvent(const blink::WebInputEvent& event);
+
   // Returns true if the timing was successfully updated.
   bool UpdateTiming(const PageLoadTiming& timing,
                     const PageLoadMetadata& metadata);
 
   void set_renderer_tracked(bool renderer_tracked);
   bool renderer_tracked() const { return renderer_tracked_; }
 
   int aborted_chain_size() const { return aborted_chain_size_; }
   int aborted_chain_size_same_url() const {
     return aborted_chain_size_same_url_;
@@ skipping 21 matching lines @@
 
   // Only valid to call post-commit.
   const GURL& committed_url() const {
     DCHECK(!commit_time_.is_null());
     return url_;
   }
 
  private:
   PageLoadExtraInfo GetPageLoadMetricsInfo();
 
-  void UpdateAbortInternal(UserAbortType abort_type,
-                           base::TimeTicks timestamp);
+  void UpdateAbortInternal(UserAbortType abort_type, base::TimeTicks timestamp);
 
   // If |final_navigation| is null, then this is an "unparented" abort chain,
   // and represents a sequence of provisional aborts that never ends with a
   // committed load.
   void LogAbortChainHistograms(content::NavigationHandle* final_navigation);
 
   // Whether the renderer should be sending timing IPCs to this page load.
   bool renderer_tracked_;
 
   // The navigation start in TimeTicks, not the wall time reported by Blink.
@@ skipping 12 matching lines @@
   UserAbortType abort_type_;
   base::TimeTicks abort_time_;
 
   // We record separate metrics for events that occur after a background,
   // because metrics like layout/paint are delayed artificially
   // when they occur in the background.
   base::TimeTicks background_time_;
   base::TimeTicks foreground_time_;
   bool started_in_foreground_;
 
+  base::TimeTicks user_interaction_time_;

[Bryan McQuade, 2016/05/25 21:32:30]

let's remove this (see related comment with more detail)

+
   PageLoadTiming timing_;
   PageLoadMetadata metadata_;
 
   // This is a subtle member. If a provisional load A gets aborted by
   // provisional load B, which gets aborted by C that eventually commits, then
   // there exists an abort chain of length 2, starting at A's navigation_start.
   // This is useful because it allows histograming abort chain lengths based on
   // what the last load's transition type is. i.e. holding down F-5 to spam
   // reload will produce a long chain with the RELOAD transition.
   const int aborted_chain_size_;
@@ skipping 29 matching lines @@
   // content::WebContentsObserver implementation:
   bool OnMessageReceived(const IPC::Message& message,
                          content::RenderFrameHost* render_frame_host) override;
   void DidStartNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidFinishNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidRedirectNavigation(
       content::NavigationHandle* navigation_handle) override;
   void NavigationStopped() override;
+  bool OnInputEvent(const blink::WebInputEvent& event);
   void WasShown() override;
   void WasHidden() override;
   void RenderProcessGone(base::TerminationStatus status) override;
 
  private:
   friend class content::WebContentsUserData<MetricsWebContentsObserver>;
 
   // Notify all loads, provisional and committed, that we performed an action
   // that might abort them.
   void NotifyAbortAllLoads(UserAbortType abort_type);
   void NotifyAbortAllLoadsWithTimestamp(UserAbortType abort_type,
                                         base::TimeTicks timestamp);
   // Notify aborted provisional loads that a new navigation occurred. This is
   // used for more consistent attribution tracking for aborted provisional
-  // loads. This method returns the provisional load that was likely aborted by
+  // loads. This method returns the provisional load that was likely aborted
+  // by
   // this navigation, to help instantiate the new PageLoadTracker.

[tdresser, 2016/05/24 14:28:38]

Awkward whitespace.

   std::unique_ptr<PageLoadTracker> NotifyAbortedProvisionalLoadsNewNavigation(
       content::NavigationHandle* new_navigation);
 
   void OnTimingUpdated(content::RenderFrameHost*,
                        const PageLoadTiming& timing,
                        const PageLoadMetadata& metadata);
 
   // True if the web contents is currently in the foreground.
   bool in_foreground_;
 
   // The PageLoadTrackers must be deleted before the |embedded_interface_|,
   // because they hold a pointer to the |embedder_interface_|.
   std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface_;
 
   // This map tracks all of the navigations ongoing that are not committed
   // yet. Once a navigation is committed, it moves from the map to
   // committed_load_. Note that a PageLoadTrackers NavigationHandle is only
   // valid until commit time, when we remove it from the map.
   std::map<content::NavigationHandle*, std::unique_ptr<PageLoadTracker>>
       provisional_loads_;
 
   // Tracks aborted provisional loads for a little bit longer than usual (one
   // more navigation commit at the max), in order to better understand how the
-  // navigation failed. This is because most provisional loads are destroyed and
+  // navigation failed. This is because most provisional loads are destroyed
+  // and
   // vanish before we get signal about what caused the abort (new navigation,

[tdresser, 2016/05/24 14:28:38]

Awkward whitespace.

   // stop button, etc.).
   std::vector<std::unique_ptr<PageLoadTracker>> aborted_provisional_loads_;
 
   std::unique_ptr<PageLoadTracker> committed_load_;
 
   // Has the MWCO observed at least one navigation?
   bool has_navigated_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserver);
 };
 
 }  // namespace page_load_metrics
 
 #endif  // COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_