Refactor PageLoadMetricsObserver completion callback policy

components/page_load_metrics/browser/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 "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 #include <utility>
@@ skipping 31 matching lines @@
 const char kAbortChainSizeForwardBack[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.ForwardBack";
 const char kAbortChainSizeNewNavigation[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.NewNavigation";
 const char kAbortChainSizeSameURL[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.SameURL";
 const char kAbortChainSizeNoCommit[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.NoCommit";
 const char kClientRedirectDelayAfterPaint[] =
     "PageLoad.Internal.ClientRedirectDelayAfterPaint";
+const char kCommitToCompleteNoTimingIPCs[] =
+    "PageLoad.Internal.CommitToComplete.NoTimingIPCs";
 
 }  // 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 194 matching lines @@
     observer->OnStart(navigation_handle, currently_committed_url,
                       started_in_foreground_);
   }
 }
 
 PageLoadTracker::~PageLoadTracker() {
   if (did_stop_tracking_)
     return;
 
   const PageLoadExtraInfo info = ComputePageLoadExtraInfo();
-
+  DCHECK_NE(static_cast<bool>(info.time_to_commit),
+            static_cast<bool>(failed_provisional_load_info_));
   if (info.time_to_commit && timing_.IsEmpty()) {
     RecordInternalError(ERR_NO_IPCS_RECEIVED);
+    const base::TimeTicks commit_time =
+        navigation_start_ + info.time_to_commit.value();
+    PAGE_LOAD_HISTOGRAM(internal::kCommitToCompleteNoTimingIPCs,
+                        base::TimeTicks::Now() - commit_time);
   }
   // 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.
   if (commit_time_.is_null() && abort_type_ != ABORT_UNKNOWN_NAVIGATION)
     LogAbortChainHistograms(nullptr);
 
   for (const auto& observer : observers_) {
-    observer->OnComplete(timing_, info);
+    if (failed_provisional_load_info_) {
+      observer->OnFailedProvisionalLoad(failed_provisional_load_info_.value(),
+                                        info);
+    } else {
+      observer->OnComplete(timing_, info);
+    }
   }
 }
 
 void PageLoadTracker::LogAbortChainHistograms(
     content::NavigationHandle* final_navigation) {
   if (aborted_chain_size_ == 0)
     return;
   // Note that this could be broken out by this navigation's abort type, if more
   // granularity is needed. Add one to the chain size to count the current
   // navigation. In the other cases, the current navigation is the final
@@ skipping 72 matching lines @@
   ClampBrowserTimestampIfInterProcessTimeTickSkew(&commit_time_);
   url_ = navigation_handle->GetURL();
   for (const auto& observer : observers_) {
     observer->OnCommit(navigation_handle);
   }
   LogAbortChainHistograms(navigation_handle);
 }
 
 void PageLoadTracker::FailedProvisionalLoad(
     content::NavigationHandle* navigation_handle) {
-  for (const auto& observer : observers_) {
-    observer->OnFailedProvisionalLoad(navigation_handle);
-  }
+  failed_provisional_load_info_ = FailedProvisionalLoadInfo(
+      base::TimeTicks::Now() - navigation_handle->NavigationStart(),
+      navigation_handle->GetNetErrorCode());
 }
 
 void PageLoadTracker::Redirect(content::NavigationHandle* navigation_handle) {
   for (const auto& observer : observers_) {
     observer->OnRedirect(navigation_handle);
   }
 }
 
 void PageLoadTracker::OnInputEvent(const blink::WebInputEvent& event) {
   for (const auto& observer : observers_) {
@@ skipping 552 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