Notify page load metrics when the app enters the background.

chrome/browser/page_load_metrics/metrics_web_contents_observer.cc

 // 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.
 
 #include "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 #include <utility>
@@ skipping 35 matching lines @@
 const char kAbortChainSizeSameURL[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.SameURL";
 const char kAbortChainSizeNoCommit[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.NoCommit";
 const char kClientRedirectFirstPaintToNavigation[] =
     "PageLoad.Internal.ClientRedirect.FirstPaintToNavigation";
 const char kClientRedirectWithoutPaint[] =
     "PageLoad.Internal.ClientRedirect.NavigationWithoutPaint";
 const char kCommitToCompleteNoTimingIPCs[] =
     "PageLoad.Internal.CommitToComplete.NoTimingIPCs";
+const char kPageLoadCompletedAfterAppBackground[] =
+    "PageLoad.Internal.PageLoadCompleted.AfterAppBackground";
 
 }  // namespace internal
 
 namespace {
 
 // Helper to allow use of Optional<> values in LOG() messages.
 std::ostream& operator<<(std::ostream& os,
                          const base::Optional<base::TimeDelta>& opt) {
   if (opt)
     os << opt.value();
@@ skipping 114 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void RecordInternalError(InternalErrorLoadEvent event) {
   UMA_HISTOGRAM_ENUMERATION(internal::kErrorEvents, event, ERR_LAST_ENTRY);
 }
 
+void RecordAppBackgroundPageLoadCompleted(bool completed_after_background) {
+  UMA_HISTOGRAM_BOOLEAN(internal::kPageLoadCompletedAfterAppBackground,
+                        completed_after_background);
+}
+
 UserAbortType AbortTypeForPageTransition(ui::PageTransition transition) {
   if (ui::PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_RELOAD))
     return ABORT_RELOAD;
   if (transition & ui::PAGE_TRANSITION_FORWARD_BACK)
     return ABORT_FORWARD_BACK;
   if (ui::PageTransitionIsNewNavigation(transition))
     return ABORT_NEW_NAVIGATION;
   NOTREACHED()
       << "AbortTypeForPageTransition received unexpected ui::PageTransition: "
       << transition;
@@ skipping 40 matching lines @@
 }  // namespace
 
 PageLoadTracker::PageLoadTracker(
     bool in_foreground,
     PageLoadMetricsEmbedderInterface* embedder_interface,
     const GURL& currently_committed_url,
     content::NavigationHandle* navigation_handle,
     int aborted_chain_size,
     int aborted_chain_size_same_url)
     : did_stop_tracking_(false),
+      app_entered_background_(false),
       navigation_start_(navigation_handle->NavigationStart()),
       url_(navigation_handle->GetURL()),
       abort_type_(ABORT_NONE),
       started_in_foreground_(in_foreground),
       aborted_chain_size_(aborted_chain_size),
       aborted_chain_size_same_url_(aborted_chain_size_same_url),
       embedder_interface_(embedder_interface) {
   DCHECK(!navigation_handle->HasCommitted());
   embedder_interface_->RegisterObservers(this);
   for (const auto& observer : observers_) {
     observer->OnStart(navigation_handle, currently_committed_url,
                       started_in_foreground_);
   }
 }
 
 PageLoadTracker::~PageLoadTracker() {
+  if (app_entered_background_) {
+    RecordAppBackgroundPageLoadCompleted(true);
+  }
+
   if (did_stop_tracking_)
     return;
 
   if (commit_time_.is_null()) {
     if (!failed_provisional_load_info_)
       RecordInternalError(ERR_NO_COMMIT_OR_FAILED_PROVISIONAL_LOAD);
 
     // Recall that trackers that are given ABORT_UNKNOWN_NAVIGATION have their
     // chain length added to the next navigation. Take care not to double count
     // them. Also do not double count committed loads, which call this already.
@@ skipping 115 matching lines @@
     observer->OnRedirect(navigation_handle);
   }
 }
 
 void PageLoadTracker::OnInputEvent(const blink::WebInputEvent& event) {
   for (const auto& observer : observers_) {
     observer->OnUserInput(event);
   }
 }
 
+void PageLoadTracker::FlushMetricsOnAppEnterBackground() {
+  if (!app_entered_background_) {
+    RecordAppBackgroundPageLoadCompleted(false);
+    app_entered_background_ = true;
+  }
+}
+
 void PageLoadTracker::NotifyClientRedirectTo(
     const PageLoadTracker& destination) {
   if (timing_.first_paint) {
     base::TimeTicks first_paint_time =
         navigation_start() + timing_.first_paint.value();
     base::TimeDelta first_paint_to_navigation;
     if (destination.navigation_start() > first_paint_time)
       first_paint_to_navigation =
           destination.navigation_start() - first_paint_time;
     PAGE_LOAD_HISTOGRAM(internal::kClientRedirectFirstPaintToNavigation,
@@ skipping 387 matching lines @@
 void MetricsWebContentsObserver::OnInputEvent(
     const blink::WebInputEvent& event) {
   // Ignore browser navigation or reload which comes with type Undefined.
   if (event.type == blink::WebInputEvent::Type::Undefined)
     return;
 
   if (committed_load_)
     committed_load_->OnInputEvent(event);
 }
 
+void MetricsWebContentsObserver::FlushMetricsOnAppEnterBackground() {
+  if (committed_load_)
+    committed_load_->FlushMetricsOnAppEnterBackground();
+  for (const auto& kv : provisional_loads_) {
+    kv.second->FlushMetricsOnAppEnterBackground();
+  }
+  for (const auto& tracker : aborted_provisional_loads_) {
+    tracker->FlushMetricsOnAppEnterBackground();
+  }
+}
+
 void MetricsWebContentsObserver::DidRedirectNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
   auto it = provisional_loads_.find(navigation_handle);
   if (it == provisional_loads_.end())
     return;
   it->second->Redirect(navigation_handle);
 }
 
@@ skipping 134 matching lines @@
     if (navigation_handle->IsSamePage() || navigation_handle->IsErrorPage())
       return false;
     const std::string& mime_type = web_contents()->GetContentsMimeType();
     if (mime_type != "text/html" && mime_type != "application/xhtml+xml")
       return false;
   }
   return true;
 }
 
 }  // namespace page_load_metrics