[page_load_metrics] User Initiated Abort Tracking (Observer version)

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_PAGE_LOAD_METRICS_WEB_CONTENTS_OBSERVER_H_
 #define COMPONENTS_PAGE_LOAD_METRICS_BROWSER_PAGE_LOAD_METRICS_WEB_CONTENTS_OBSERVER_H_
 
 #include <map>
 
 #include "base/macros.h"
+#include "base/memory/scoped_vector.h"

[Bryan McQuade, 2015/12/10 17:04:23]

now that we're using std::vector directly, can we remove this include?

[Charlie Harrison, 2015/12/10 17:59:31]

Done. Also removing observer_list.

 #include "base/observer_list.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"
 
 class PageLoadMetricsObserverTest;
@@ skipping 44 matching lines @@
 
 const char kHistogramFirstContentfulPaintHigh[] =
     "PageLoad.Timing2.NavigationToFirstContentfulPaint.HighResolutionClock";
 const char kHistogramFirstContentfulPaintLow[] =
     "PageLoad.Timing2.NavigationToFirstContentfulPaint.LowResolutionClock";
 
 const char kHistogramFirstBackground[] =
     "PageLoad.Timing2.NavigationToFirstBackground";
 const char kHistogramFirstForeground[] =
     "PageLoad.Timing2.NavigationToFirstForeground";
+const char kHistogramBackgroundBeforePaint[] =
+    "PageLoad.Timing2.NavigationToFirstBackgroundBeforePaint";
+const char kHistogramProvisionalBackground[] =
+    "PageLoad.Timing2.Provisional.NavigationToFirstBackground";

[Bryan McQuade, 2015/12/10 17:04:23]

I prefer the name 'BeforeCommit' rather than 'Provisional' here (and treating
BeforeCommit as a suffix like we do elsewhere, so
'PageLoad.Timing2.NavigationToFirstBackground.BeforeCommit' since I think
more people will understand what that means than 'Provisional' - you have to
understand chrome's navigation flow pretty well to understand what a provisional
load is, whereas I think we can explain once what a commit is and when it
happens, and then
people logically can understand what 'BeforeCommit' means.

I know we have the PageLoad.Events UMAs which use Provisional and Committed -
those are more internal UMA for our team so I'm less concerned about using
familiar naming, but feel free to rename them to use 'BeforeCommit' and
'AfterCommit' if you want for consistency.

[Charlie Harrison, 2015/12/10 17:59:31]

Done. Switched it to using BeforeCommit / AfterCommit.BeforePaint.

 
 const char kProvisionalEvents[] = "PageLoad.Events.Provisional";
 const char kCommittedEvents[] = "PageLoad.Events.Committed";
 const char kBackgroundProvisionalEvents[] =
     "PageLoad.Events.Provisional.Background";
 const char kBackgroundCommittedEvents[] =
     "PageLoad.Events.Committed.Background";
 
 const char kErrorEvents[] = "PageLoad.Events.InternalError";
 
@@ skipping 132 matching lines @@
   void RecordProvisionalEvent(ProvisionalLoadEvent event);
   void RecordCommittedEvent(CommittedRelevantLoadEvent event,
                             bool backgrounded);
   bool HasBackgrounded();
 
   void set_renderer_tracked(bool renderer_tracked);
   bool renderer_tracked() { return renderer_tracked_; }
 
   void AddObserver(scoped_ptr<PageLoadMetricsObserver> observer);
 
+  // If the user performs some abort-like action while we are tracking this page
+  // load, notify the tracker. Note that we may not classify this as an abort if
+  // we've already performed a first paint.
+  void NotifyAbort(UserAbortType abort_type, const base::TimeTicks& timestamp);
+
  private:
   PageLoadExtraInfo GetPageLoadMetricsInfo();
   // Only valid to call post-commit.
   const GURL& committed_url();
 
-  base::TimeDelta GetBackgroundDelta();
-  void RecordTimingHistograms();
-  void RecordRappor();
+  void RecordTimingHistograms(const PageLoadExtraInfo& info);
+  void RecordRappor(const PageLoadExtraInfo& info);
 
   // Whether the renderer should be sending timing IPCs to this page load.
   bool renderer_tracked_;
 
   bool has_commit_;
 
   // The navigation start in TimeTicks, not the wall time reported by Blink.
   const base::TimeTicks navigation_start_;
 
+  // Will be ABORT_NONE if we have not aborted this load yet. Otherwise will
+  // be the first abort action the user performed.
+  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_;
 
   PageLoadTiming timing_;
   GURL url_;
 
@@ skipping 24 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;
   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,
+                                        const base::TimeTicks& timestamp);
+
   void OnTimingUpdated(content::RenderFrameHost*, const PageLoadTiming& timing);
 
   // 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_|.
   scoped_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*, scoped_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
+  // vanish before we get signal about what caused the abort (new navigation,
+  // stop button, etc.).
+  std::vector<scoped_ptr<PageLoadTracker>> aborted_provisional_loads_;
   scoped_ptr<PageLoadTracker> committed_load_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserver);
 };
 
 }  // namespace page_load_metrics
 
 #endif  // COMPONENTS_PAGE_LOAD_METRICS_BROWSER_PAGE_LOAD_METRICS_WEB_CONTENTS_OBSERVER_H_