Standardize which page loads are tracked

components/page_load_metrics/browser/metrics_web_contents_observer_unittest.cc

 // Copyright (c) 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 <memory>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 127 matching lines @@
   }
 
   void CheckTotalErrorEvents() {
     histogram_tester_.ExpectTotalCount(internal::kErrorEvents, num_errors_);
   }
 
   void CheckNoErrorEvents() {
     histogram_tester_.ExpectTotalCount(internal::kErrorEvents, 0);
   }
 
-  void AssertNoNonEmptyTimingReported() {
-    ASSERT_FALSE(embedder_interface_->complete_timings().empty());
+  int CountEmptyCompleteTimingReported() {
+    int empty = 0;
     for (const auto& timing : embedder_interface_->complete_timings()) {
-      ASSERT_TRUE(timing.IsEmpty());
+      if (timing.IsEmpty())
+        ++empty;
     }
-  }
-
-  void AssertNonEmptyTimingsReported(size_t expected_non_empty_timings) {
-    ASSERT_GE(embedder_interface_->complete_timings().size(),
-              expected_non_empty_timings);
-    size_t actual_non_empty_timings = 0;
-    for (const auto& timing : embedder_interface_->complete_timings()) {
-      if (!timing.IsEmpty()) {
-        ++actual_non_empty_timings;
-      }
-    }
-    ASSERT_EQ(expected_non_empty_timings, actual_non_empty_timings);
-    ASSERT_GE(embedder_interface_->updated_timings().size(),
-              actual_non_empty_timings);
+    return empty;
   }
 
   int CountCompleteTimingReported() {
     return embedder_interface_->complete_timings().size();
   }
   int CountUpdatedTimingReported() {
     return embedder_interface_->updated_timings().size();
   }
 
   const std::vector<GURL>& observed_committed_urls_from_on_start() const {
@@ skipping 23 matching lines @@
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   ASSERT_EQ(1u, observed_committed_urls_from_on_start().size());
   ASSERT_TRUE(observed_committed_urls_from_on_start().at(0).is_empty());
 
   ASSERT_EQ(0, CountUpdatedTimingReported());
   SimulateTimingUpdate(timing);
   ASSERT_EQ(1, CountUpdatedTimingReported());
   ASSERT_EQ(0, CountCompleteTimingReported());
 
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
-  AssertNonEmptyTimingsReported(1);
+  ASSERT_EQ(1, CountCompleteTimingReported());
+  ASSERT_EQ(0, CountEmptyCompleteTimingReported());
   ASSERT_EQ(2u, observed_committed_urls_from_on_start().size());
   ASSERT_EQ(kDefaultTestUrl,
             observed_committed_urls_from_on_start().at(1).spec());
   ASSERT_EQ(1, CountUpdatedTimingReported());
 
   CheckNoErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, NotInMainFrame) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
 
   content::RenderFrameHostTester* rfh_tester =
       content::RenderFrameHostTester::For(main_rfh());
   content::RenderFrameHost* subframe = rfh_tester->AppendChild("subframe");
 
   content::RenderFrameHostTester* subframe_tester =
       content::RenderFrameHostTester::For(subframe);
   subframe_tester->SimulateNavigationStart(GURL(kDefaultTestUrl2));
   subframe_tester->SimulateNavigationCommit(GURL(kDefaultTestUrl2));
   SimulateTimingUpdate(timing, subframe);
   subframe_tester->SimulateNavigationStop();
 
   // Navigate again to see if the timing updated for a subframe message.
-  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
+  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
 
   ASSERT_EQ(0, CountUpdatedTimingReported());
-  AssertNoNonEmptyTimingReported();
+  ASSERT_EQ(1, CountCompleteTimingReported());
+  ASSERT_EQ(1, CountEmptyCompleteTimingReported());
   CheckErrorEvent(ERR_IPC_FROM_WRONG_FRAME, 1);
+  CheckErrorEvent(ERR_NO_IPCS_RECEIVED, 1);
   CheckTotalErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, SamePageNoTrigger) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
   ASSERT_EQ(0, CountUpdatedTimingReported());
   SimulateTimingUpdate(timing);
   ASSERT_EQ(1, CountUpdatedTimingReported());
   web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrlAnchor));
+  // Send the same timing update. The original tracker for kDefaultTestUrl
+  // should dedup the update, and the tracker for kDefaultTestUrlAnchor should
+  // have been destroyed as a result of its being a same page navigation, so
+  // CountUpdatedTimingReported() should continue to return 1.
+  SimulateTimingUpdate(timing);
+
+  ASSERT_EQ(1, CountUpdatedTimingReported());
+  ASSERT_EQ(0, CountCompleteTimingReported());
+
+  // Navigate again to force histogram logging.
+  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
+
   // A same page navigation shouldn't trigger logging UMA for the original.
   ASSERT_EQ(1, CountUpdatedTimingReported());
-  AssertNoNonEmptyTimingReported();
+  ASSERT_EQ(1, CountCompleteTimingReported());
+  ASSERT_EQ(0, CountEmptyCompleteTimingReported());
   CheckNoErrorEvents();
 }
 
 TEST_F(MetricsWebContentsObserverTest, DontLogPrerender) {
   PageLoadTiming timing;
   timing.navigation_start = base::Time::FromDoubleT(1);
 
   content::WebContentsTester* web_contents_tester =
       content::WebContentsTester::For(web_contents());
   embedder_interface_->set_is_prerendering(true);
@@ skipping 192 matching lines @@
   rfh_tester->SimulateNavigationStop();
 
   web_contents()->Stop();
 
   histogram_tester_.ExpectTotalCount(internal::kAbortChainSizeNoCommit, 1);
   histogram_tester_.ExpectBucketCount(internal::kAbortChainSizeNoCommit, 3,
                                       1);
 }
 
 }  // namespace page_load_metrics