[Page Load Metrics] Add mojom file to page load metrics.

chrome/browser/page_load_metrics/observers/data_reduction_proxy_metrics_observer_unittest.cc

 // Copyright 2016 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/observers/data_reduction_proxy_metrics_observer.h"
 
 #include <stdint.h>
 
 #include <functional>
 #include <memory>
@@ skipping 122 matching lines @@
 
 class DataReductionProxyMetricsObserverTest
     : public page_load_metrics::PageLoadMetricsObserverTestHarness {
  public:
   DataReductionProxyMetricsObserverTest()
       : pingback_client_(new TestPingbackClient()),
         data_reduction_proxy_used_(false),
         is_using_lofi_(false) {}
 
   void ResetTest() {
+    page_load_metrics::InitPageLoadTimingForTest(&timing_);
     // Reset to the default testing state. Does not reset histogram state.
     timing_.navigation_start = base::Time::FromDoubleT(1);
     timing_.response_start = base::TimeDelta::FromSeconds(2);
-    timing_.parse_timing.parse_start = base::TimeDelta::FromSeconds(3);
-    timing_.paint_timing.first_contentful_paint =
+    timing_.parse_timing->parse_start = base::TimeDelta::FromSeconds(3);
+    timing_.paint_timing->first_contentful_paint =
         base::TimeDelta::FromSeconds(4);
-    timing_.paint_timing.first_paint = base::TimeDelta::FromSeconds(4);
-    timing_.paint_timing.first_meaningful_paint =
+    timing_.paint_timing->first_paint = base::TimeDelta::FromSeconds(4);
+    timing_.paint_timing->first_meaningful_paint =
         base::TimeDelta::FromSeconds(8);
-    timing_.paint_timing.first_image_paint = base::TimeDelta::FromSeconds(5);
-    timing_.paint_timing.first_text_paint = base::TimeDelta::FromSeconds(6);
-    timing_.document_timing.load_event_start = base::TimeDelta::FromSeconds(7);
-    timing_.parse_timing.parse_stop = base::TimeDelta::FromSeconds(4);
-    timing_.parse_timing.parse_blocked_on_script_load_duration =
+    timing_.paint_timing->first_image_paint = base::TimeDelta::FromSeconds(5);
+    timing_.paint_timing->first_text_paint = base::TimeDelta::FromSeconds(6);
+    timing_.document_timing->load_event_start = base::TimeDelta::FromSeconds(7);
+    timing_.parse_timing->parse_stop = base::TimeDelta::FromSeconds(4);
+    timing_.parse_timing->parse_blocked_on_script_load_duration =
         base::TimeDelta::FromSeconds(1);
     PopulateRequiredTimingFields(&timing_);
   }
 
   void RunTest(bool data_reduction_proxy_used, bool is_using_lofi) {
     data_reduction_proxy_used_ = data_reduction_proxy_used;
     is_using_lofi_ = is_using_lofi;
     NavigateAndCommit(GURL(kDefaultTestUrl));
     SimulateTimingUpdate(timing_);
     pingback_client_->Reset();
@@ skipping 14 matching lines @@
     } else {
       EXPECT_TRUE(!expected);
       EXPECT_TRUE(!actual);
     }
   }
 
   void ValidateTimes() {
     EXPECT_TRUE(pingback_client_->send_pingback_called());
     EXPECT_EQ(timing_.navigation_start,
               pingback_client_->timing()->navigation_start);
-    ExpectEqualOrUnset(timing_.paint_timing.first_contentful_paint,
+    ExpectEqualOrUnset(timing_.paint_timing->first_contentful_paint,
                        pingback_client_->timing()->first_contentful_paint);
     ExpectEqualOrUnset(
-        timing_.paint_timing.first_meaningful_paint,
+        timing_.paint_timing->first_meaningful_paint,
         pingback_client_->timing()->experimental_first_meaningful_paint);
     ExpectEqualOrUnset(timing_.response_start,
               pingback_client_->timing()->response_start);
-    ExpectEqualOrUnset(timing_.document_timing.load_event_start,
+    ExpectEqualOrUnset(timing_.document_timing->load_event_start,
                        pingback_client_->timing()->load_event_start);
-    ExpectEqualOrUnset(timing_.paint_timing.first_image_paint,
+    ExpectEqualOrUnset(timing_.paint_timing->first_image_paint,
                        pingback_client_->timing()->first_image_paint);
   }
 
   void ValidateLoFiInPingback(bool lofi_expected) {
     EXPECT_TRUE(pingback_client_->send_pingback_called());
     EXPECT_EQ(lofi_expected, pingback_client_->data().lofi_received());
   }
 
   void ValidateHistograms() {
     ValidateHistogramsForSuffix(
         internal::kHistogramDOMContentLoadedEventFiredSuffix,
-        timing_.document_timing.dom_content_loaded_event_start);
+        timing_.document_timing->dom_content_loaded_event_start);
     ValidateHistogramsForSuffix(internal::kHistogramFirstLayoutSuffix,
-                                timing_.document_timing.first_layout);
+                                timing_.document_timing->first_layout);
     ValidateHistogramsForSuffix(internal::kHistogramLoadEventFiredSuffix,
-                                timing_.document_timing.load_event_start);
+                                timing_.document_timing->load_event_start);
     ValidateHistogramsForSuffix(internal::kHistogramFirstContentfulPaintSuffix,
-                                timing_.paint_timing.first_contentful_paint);
+                                timing_.paint_timing->first_contentful_paint);
     ValidateHistogramsForSuffix(internal::kHistogramFirstMeaningfulPaintSuffix,
-                                timing_.paint_timing.first_meaningful_paint);
+                                timing_.paint_timing->first_meaningful_paint);
     ValidateHistogramsForSuffix(internal::kHistogramFirstImagePaintSuffix,
-                                timing_.paint_timing.first_image_paint);
+                                timing_.paint_timing->first_image_paint);
     ValidateHistogramsForSuffix(internal::kHistogramFirstPaintSuffix,
-                                timing_.paint_timing.first_paint);
+                                timing_.paint_timing->first_paint);
     ValidateHistogramsForSuffix(internal::kHistogramFirstTextPaintSuffix,
-                                timing_.paint_timing.first_text_paint);
+                                timing_.paint_timing->first_text_paint);
     ValidateHistogramsForSuffix(internal::kHistogramParseStartSuffix,
-                                timing_.parse_timing.parse_start);
+                                timing_.parse_timing->parse_start);
     ValidateHistogramsForSuffix(
         internal::kHistogramParseBlockedOnScriptLoadSuffix,
-        timing_.parse_timing.parse_blocked_on_script_load_duration);
+        timing_.parse_timing->parse_blocked_on_script_load_duration);
     ValidateHistogramsForSuffix(internal::kHistogramParseDurationSuffix,
-                                timing_.parse_timing.parse_stop.value() -
-                                    timing_.parse_timing.parse_start.value());
+                                timing_.parse_timing->parse_stop.value() -
+                                    timing_.parse_timing->parse_start.value());
   }
 
   void ValidateHistogramsForSuffix(
       const std::string& histogram_suffix,
       const base::Optional<base::TimeDelta>& event) {
     histogram_tester().ExpectTotalCount(
         std::string(internal::kHistogramDataReductionProxyPrefix)
             .append(histogram_suffix),
         data_reduction_proxy_used_ ? 1 : 0);
     histogram_tester().ExpectTotalCount(
@@ skipping 90 matching lines @@
 
  protected:
   void RegisterObservers(page_load_metrics::PageLoadTracker* tracker) override {
     tracker->AddObserver(
         base::MakeUnique<TestDataReductionProxyMetricsObserver>(
             web_contents(), pingback_client_.get(), data_reduction_proxy_used_,
             is_using_lofi_));
   }
 
   std::unique_ptr<TestPingbackClient> pingback_client_;
-  page_load_metrics::PageLoadTiming timing_;
+  page_load_metrics::mojom::PageLoadTiming timing_;
 
  private:
   bool data_reduction_proxy_used_;
   bool is_using_lofi_;
 
   DISALLOW_COPY_AND_ASSIGN(DataReductionProxyMetricsObserverTest);
 };
 
 TEST_F(DataReductionProxyMetricsObserverTest, DataReductionProxyOff) {
   ResetTest();
@@ skipping 21 matching lines @@
 TEST_F(DataReductionProxyMetricsObserverTest, OnCompletePingback) {
   ResetTest();
   // Verify that when data reduction proxy was used the correct timing
   // information is sent to SendPingback.
   RunTestAndNavigateToUntrackedUrl(true, false);
   ValidateTimes();
 
   ResetTest();
   // Verify that when data reduction proxy was used but first image paint is
   // unset, the correct timing information is sent to SendPingback.
-  timing_.paint_timing.first_image_paint = base::nullopt;
+  timing_.paint_timing->first_image_paint = base::nullopt;
   RunTestAndNavigateToUntrackedUrl(true, false);
   ValidateTimes();
 
   ResetTest();
   // Verify that when data reduction proxy was used but first contentful paint
   // is unset, SendPingback is not called.
-  timing_.paint_timing.first_contentful_paint = base::nullopt;
+  timing_.paint_timing->first_contentful_paint = base::nullopt;
   RunTestAndNavigateToUntrackedUrl(true, false);
   ValidateTimes();
 
   ResetTest();
   // Verify that when data reduction proxy was used but first meaningful paint
   // is unset, SendPingback is not called.
-  timing_.paint_timing.first_meaningful_paint = base::nullopt;
+  timing_.paint_timing->first_meaningful_paint = base::nullopt;
   RunTestAndNavigateToUntrackedUrl(true, false);
   ValidateTimes();
 
   ResetTest();
   // Verify that when data reduction proxy was used but load event start is
   // unset, SendPingback is not called.
-  timing_.document_timing.load_event_start = base::nullopt;
+  timing_.document_timing->load_event_start = base::nullopt;
   RunTestAndNavigateToUntrackedUrl(true, false);
   ValidateTimes();
   ValidateLoFiInPingback(false);
 
   ResetTest();
 
   std::unique_ptr<DataReductionProxyData> data =
       base::MakeUnique<DataReductionProxyData>();
   data->set_used_data_reduction_proxy(true);
   data->set_lofi_received(true);
@@ skipping 142 matching lines @@
     }
   }
 
   NavigateToUntrackedUrl();
 
   ValidateDataHistograms(network_resources, drp_resources, network_bytes,
                          drp_bytes, ocl_bytes);
 }
 
 }  //  namespace data_reduction_proxy