Reland "Remove data use updates from page load metrics"

This is a reland of 66ce35f844

Reverted in :
https://chromium-review.googlesource.com/c/chromium/src/+/1184062

See : https://crbug.com/876463

Build #2592 succeeded without reversion and test seems flaky in
more recent builds (#2608). Not believed to be the cause of the failing
test.

TBR=kinuko@chromium.org

Original change's description:
> Remove data use updates from page load metrics
>
> Now that per-resource updates are sent to page load metrics, we no
> longer need to send totals from the renderer process. Remove all
> piping/callbacks and convert existing consumers to
> OnResourceDataUseObserved.
>
> Per-resource updates:
> https://chromium-review.googlesource.com/c/chromium/src/+/1164222
>
> Change-Id: I1cb03df5e6579fc0ff767900336308a6bbad244a
> Reviewed-on: https://chromium-review.googlesource.com/1178324
> Reviewed-by: Charlie Harrison <csharrison@chromium.org>
> Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
> Commit-Queue: John Delaney <johnidel@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#584744}

Change-Id: Ifdc90e57677eb214e404616a41242d5fc1fa64a0
Bug: 876463
Reviewed-on: https://chromium-review.googlesource.com/1185101
Commit-Queue: John Delaney <johnidel@chromium.org>
Reviewed-by: Charlie Harrison <csharrison@chromium.org>
Cr-Commit-Position: refs/heads/master@{#585576}

chrome/browser/page_load_metrics/metrics_web_contents_observer.cc

@@ -640,7 +640,6 @@ void MetricsWebContentsObserver::OnTimingUpdated(
     const mojom::PageLoadTiming& timing,
     const mojom::PageLoadMetadata& metadata,
     const mojom::PageLoadFeatures& new_features,
-    const mojom::PageLoadDataUse& new_data_use,
     const std::vector<mojom::ResourceDataUpdatePtr>& resources) {
   // We may receive notifications from frames that have been navigated away
   // from. We simply ignore them.
@@ -674,8 +673,7 @@ void MetricsWebContentsObserver::OnTimingUpdated(
 
   if (committed_load_) {
     committed_load_->metrics_update_dispatcher()->UpdateMetrics(
-        render_frame_host, timing, metadata, new_features, new_data_use,
-        resources);
+        render_frame_host, timing, metadata, new_features, resources);
   }
 }
 
@@ -683,12 +681,11 @@ void MetricsWebContentsObserver::UpdateTiming(
     const mojom::PageLoadTimingPtr timing,
     const mojom::PageLoadMetadataPtr metadata,
     const mojom::PageLoadFeaturesPtr new_features,
-    const mojom::PageLoadDataUsePtr new_data_use,
     const std::vector<mojom::ResourceDataUpdatePtr> resources) {
   content::RenderFrameHost* render_frame_host =
       page_load_metrics_binding_.GetCurrentTargetFrame();
   OnTimingUpdated(render_frame_host, *timing, *metadata, *new_features,
-                  *new_data_use, resources);
+                  resources);
 }
 
 bool MetricsWebContentsObserver::ShouldTrackNavigation(

chrome/browser/page_load_metrics/metrics_web_contents_observer.h

@@ -151,7 +151,6 @@ class MetricsWebContentsObserver
       const mojom::PageLoadTiming& timing,
       const mojom::PageLoadMetadata& metadata,
       const mojom::PageLoadFeatures& new_features,
-      const mojom::PageLoadDataUse& new_data_use,
       const std::vector<mojom::ResourceDataUpdatePtr>& resources);
 
   // Informs the observers of the currently committed load that the event
@@ -168,7 +167,6 @@ class MetricsWebContentsObserver
       const mojom::PageLoadTimingPtr timing,
       const mojom::PageLoadMetadataPtr metadata,
       const mojom::PageLoadFeaturesPtr new_features,
-      const mojom::PageLoadDataUsePtr new_data_use,
       const std::vector<mojom::ResourceDataUpdatePtr> resources) override;
 
   void HandleFailedNavigationForTrackedLoad(

chrome/browser/page_load_metrics/metrics_web_contents_observer_unittest.cc

@@ -258,8 +258,7 @@ class MetricsWebContentsObserverTest : public ChromeRenderViewHostTestHarness {
       content::RenderFrameHost* render_frame_host) {
     observer()->OnTimingUpdated(
         render_frame_host, timing, mojom::PageLoadMetadata(),
-        mojom::PageLoadFeatures(), mojom::PageLoadDataUse(),
-        std::vector<mojom::ResourceDataUpdatePtr>());
+        mojom::PageLoadFeatures(), std::vector<mojom::ResourceDataUpdatePtr>());
   }
 
   void AttachObserver() {

chrome/browser/page_load_metrics/observers/data_saver_site_breakdown_metrics_observer.cc

@@ -40,9 +40,9 @@ DataSaverSiteBreakdownMetricsObserver::OnCommit(
   return CONTINUE_OBSERVING;
 }
 
-void DataSaverSiteBreakdownMetricsObserver::OnDataUseObserved(
-    int64_t received_data_length,
-    int64_t data_reduction_proxy_bytes_saved) {
+void DataSaverSiteBreakdownMetricsObserver::OnResourceDataUseObserved(
+    const std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr>&
+        resources) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   data_reduction_proxy::DataReductionProxySettings*
       data_reduction_proxy_settings =
@@ -51,6 +51,14 @@ void DataSaverSiteBreakdownMetricsObserver::OnDataUseObserved(
   if (data_reduction_proxy_settings &&
       data_reduction_proxy_settings->data_reduction_proxy_service()) {
     DCHECK(!committed_host_.empty());
+    int64_t received_data_length = 0;
+    int64_t data_reduction_proxy_bytes_saved = 0;
+    for (auto const& resource : resources) {
+      received_data_length += resource->delta_bytes;
+      data_reduction_proxy_bytes_saved +=
+          resource->delta_bytes *
+          (resource->data_reduction_proxy_compression_ratio_estimate - 1.0);
+    }
     data_reduction_proxy_settings->data_reduction_proxy_service()
         ->UpdateDataUseForHost(
             received_data_length,

chrome/browser/page_load_metrics/observers/data_saver_site_breakdown_metrics_observer.h

@@ -30,8 +30,9 @@ class DataSaverSiteBreakdownMetricsObserver
   ObservePolicy OnCommit(content::NavigationHandle* navigation_handle,
                          ukm::SourceId source_id) override;
 
-  void OnDataUseObserved(int64_t received_data_length,
-                         int64_t data_reduction_proxy_bytes_saved) override;
+  void OnResourceDataUseObserved(
+      const std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr>&
+          resources) override;
 
   std::string committed_host_;
 

chrome/browser/page_load_metrics/observers/noscript_preview_page_load_metrics_observer.cc

@@ -178,10 +178,12 @@ void NoScriptPreviewPageLoadMetricsObserver::RecordTimingMetrics(
   }
 }
 
-void NoScriptPreviewPageLoadMetricsObserver::OnDataUseObserved(
-    int64_t received_data_length,
-    int64_t data_reduction_proxy_bytes_saved) {
-  total_network_bytes_ += received_data_length;
+void NoScriptPreviewPageLoadMetricsObserver::OnResourceDataUseObserved(
+    const std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr>&
+        resources) {
+  for (auto const& resource : resources) {
+    total_network_bytes_ += resource->delta_bytes;
+  }
 }
 
 void NoScriptPreviewPageLoadMetricsObserver::WriteToSavings(

chrome/browser/page_load_metrics/observers/noscript_preview_page_load_metrics_observer.h

@@ -53,8 +53,9 @@ class NoScriptPreviewPageLoadMetricsObserver
   void OnLoadEventStart(
       const page_load_metrics::mojom::PageLoadTiming& timing,
       const page_load_metrics::PageLoadExtraInfo& info) override;
-  void OnDataUseObserved(int64_t received_data_length,
-                         int64_t data_reduction_proxy_bytes_saved) override;
+  void OnResourceDataUseObserved(
+      const std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr>&
+          resources) override;
 
  protected:
   // Virtual for testing. Writes the savings to the data saver feature.

chrome/browser/page_load_metrics/observers/noscript_preview_page_load_metrics_observer_unittest.cc

@@ -31,6 +31,9 @@ namespace previews {
 
 namespace {
 
+using page_load_metrics::mojom::ResourceDataUpdate;
+using page_load_metrics::mojom::ResourceDataUpdatePtr;
+
 const char kDefaultTestUrl[] = "https://www.google.com";
 
 class TestNoScriptPreviewPageLoadMetricsObserver
@@ -263,10 +266,19 @@ TEST_F(NoScriptPreviewPageLoadMetricsObserverTest, DataSavings) {
 
   int64_t data_use = 0;
   NavigateAndCommitWithPreviewsState(content::NOSCRIPT_ON);
-  SimulatePageLoadDataUseUpdate({5 * 1024, 0});
+  std::vector<ResourceDataUpdatePtr> resources;
+  auto resource_data_update = ResourceDataUpdate::New();
+  resource_data_update->delta_bytes = 5 * 1024;
+  resources.push_back(std::move(resource_data_update));
+  SimulateResourceDataUseUpdate(resources);
   data_use += (5 * 1024);
 
-  SimulatePageLoadDataUseUpdate({20 * 1024, 13});
+  resources.clear();
+
+  resource_data_update = ResourceDataUpdate::New();
+  resource_data_update->delta_bytes = 20 * 1024;
+  resources.push_back(std::move(resource_data_update));
+  SimulateResourceDataUseUpdate(resources);
   data_use += (20 * 1024);
 
   SimulateTimingUpdate(timing_);

chrome/browser/page_load_metrics/observers/page_load_metrics_observer_test_harness.cc

@@ -59,9 +59,9 @@ void PageLoadMetricsObserverTestHarness::SimulateTimingAndMetadataUpdate(
   tester_->SimulateTimingAndMetadataUpdate(timing, metadata);
 }
 
-void PageLoadMetricsObserverTestHarness::SimulatePageLoadDataUseUpdate(
-    const mojom::PageLoadDataUse& data_use) {
-  tester_->SimulatePageLoadDataUseUpdate(data_use);
+void PageLoadMetricsObserverTestHarness::SimulateResourceDataUseUpdate(
+    const std::vector<mojom::ResourceDataUpdatePtr>& resources) {
+  tester_->SimulateResourceDataUseUpdate(resources);
 }
 
 void PageLoadMetricsObserverTestHarness::SimulateFeaturesUpdate(

chrome/browser/page_load_metrics/observers/page_load_metrics_observer_test_harness.h

@@ -83,7 +83,8 @@ class PageLoadMetricsObserverTestHarness
       const mojom::PageLoadTiming& timing,
       const mojom::PageLoadMetadata& metadata,
       const mojom::PageLoadFeatures& new_features);
-  void SimulatePageLoadDataUseUpdate(const mojom::PageLoadDataUse& data_use);
+  void SimulateResourceDataUseUpdate(
+      const std::vector<mojom::ResourceDataUpdatePtr>& resources);
 
   // Simulates a loaded resource. Main frame resources must specify a
   // GlobalRequestID, using the SimulateLoadedResource() method that takes a

chrome/browser/page_load_metrics/observers/page_load_metrics_observer_tester.cc

@@ -88,7 +88,7 @@ void PageLoadMetricsObserverTester::SimulatePageLoadTimingUpdate(
     const mojom::PageLoadMetadata& metadata,
     const mojom::PageLoadFeatures& new_features) {
   observer_->OnTimingUpdated(web_contents()->GetMainFrame(), timing, metadata,
-                             new_features, mojom::PageLoadDataUse(),
+                             new_features,
                              std::vector<mojom::ResourceDataUpdatePtr>());
   // If sending the timing update caused the PageLoadMetricsUpdateDispatcher to
   // schedule a buffering timer, then fire it now so metrics are dispatched to
@@ -98,12 +98,11 @@ void PageLoadMetricsObserverTester::SimulatePageLoadTimingUpdate(
     mock_timer->Fire();
 }
 
-void PageLoadMetricsObserverTester::SimulatePageLoadDataUseUpdate(
-    const mojom::PageLoadDataUse& data_use) {
+void PageLoadMetricsObserverTester::SimulateResourceDataUseUpdate(
+    const std::vector<mojom::ResourceDataUpdatePtr>& resources) {
   observer_->OnTimingUpdated(web_contents()->GetMainFrame(),
                              mojom::PageLoadTiming(), mojom::PageLoadMetadata(),
-                             mojom::PageLoadFeatures(), data_use,
-                             std::vector<mojom::ResourceDataUpdatePtr>());
+                             mojom::PageLoadFeatures(), resources);
 }
 
 void PageLoadMetricsObserverTester::SimulateLoadedResource(

chrome/browser/page_load_metrics/observers/page_load_metrics_observer_tester.h

@@ -54,7 +54,8 @@ class PageLoadMetricsObserverTester : public test::WeakMockTimerProvider {
       const mojom::PageLoadTiming& timing,
       const mojom::PageLoadMetadata& metadata,
       const mojom::PageLoadFeatures& new_features);
-  void SimulatePageLoadDataUseUpdate(const mojom::PageLoadDataUse& data_use);
+  void SimulateResourceDataUseUpdate(
+      const std::vector<mojom::ResourceDataUpdatePtr>& resources);
 
   // Simulates a loaded resource. Main frame resources must specify a
   // GlobalRequestID, using the SimulateLoadedResource() method that takes a

chrome/browser/page_load_metrics/page_load_metrics_browsertest.cc

@@ -1766,93 +1766,6 @@ IN_PROC_BROWSER_TEST_F(SessionRestorePageLoadMetricsBrowserTest,
   ExpectFirstPaintMetricsTotalCount(1);
 }
 
-// TODO(rajendrant): Add tests for data reduction proxy savings, and tests for
-// page loads in brand new renderers that the navigation response is recorded
-// (e.g. do window.open('/some-cross-site-page')).
-IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest, ReceivedDataLength) {
-  ASSERT_TRUE(embedded_test_server()->Start());
-
-  auto waiter = CreatePageLoadMetricsTestWaiter();
-  waiter->AddPageExpectation(TimingField::kLoadEvent);
-  ui_test_utils::NavigateToURL(browser(), embedded_test_server()->GetURL(
-                                              "/page_load_metrics/large.html"));
-  waiter->AddMinimumPageLoadDataUseExpectation(10000);
-  waiter->Wait();
-}
-
-IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
-                       ReceivedDataLengthControlledLoad) {
-  const char kHttpResponseHeader[] =
-      "HTTP/1.1 200 OK\r\n"
-      "Content-Type: text/html; charset=utf-8\r\n"
-      "\r\n";
-
-  auto main_html_response =
-      std::make_unique<net::test_server::ControllableHttpResponse>(
-          embedded_test_server(), "/mock_page.html",
-          true /*relative_url_is_prefix*/);
-  auto css_response =
-      std::make_unique<net::test_server::ControllableHttpResponse>(
-          embedded_test_server(), "/mock_css.css",
-          true /*relative_url_is_prefix*/);
-  ASSERT_TRUE(embedded_test_server()->Start());
-
-  auto waiter = CreatePageLoadMetricsTestWaiter();
-
-  browser()->OpenURL(content::OpenURLParams(
-      embedded_test_server()->GetURL("/mock_page.html"), content::Referrer(),
-      WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
-
-  main_html_response->WaitForRequest();
-  main_html_response->Send(kHttpResponseHeader);
-  main_html_response->Send(
-      "<html><link rel=\"stylesheet\" href=\"mock_css.css\">");
-  main_html_response->Send(std::string(1000, ' '));
-  // TODO(rajendrant): Verify that 1000 bytes are received at this point before
-  // the request completes. This is hard to verify now since
-  // MojoAsyncResourceHandler throttles the transfer size updates, and calls
-  // only when a read is called after 1 second from previous update.
-
-  main_html_response->Send("</html>");
-  main_html_response->Send(std::string(1000, ' '));
-  main_html_response->Done();
-  waiter->AddMinimumPageLoadDataUseExpectation(2000);
-  waiter->Wait();
-
-  css_response->WaitForRequest();
-  css_response->Send(kHttpResponseHeader);
-  css_response->Send(std::string(1000, ' '));
-  css_response->Done();
-  waiter->AddMinimumPageLoadDataUseExpectation(3000);
-  waiter->Wait();
-}
-
-IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
-                       ReceivedDataLengthCrossSiteIframe) {
-  embedded_test_server()->ServeFilesFromSourceDirectory("content/test/data");
-  content::SetupCrossSiteRedirector(embedded_test_server());
-  ASSERT_TRUE(embedded_test_server()->Start());
-
-  auto waiter = CreatePageLoadMetricsTestWaiter();
-  waiter->AddPageExpectation(TimingField::kLoadEvent);
-  ui_test_utils::NavigateToURL(
-      browser(), embedded_test_server()->GetURL(
-                     "foo.com", "/cross_site_iframe_factory.html?foo"));
-  waiter->Wait();
-  int64_t one_frame_page_size = waiter->current_page_load_data_use();
-
-  waiter = CreatePageLoadMetricsTestWaiter();
-  waiter->AddPageExpectation(TimingField::kLoadEvent);
-  ui_test_utils::NavigateToURL(
-      browser(),
-      embedded_test_server()->GetURL(
-          "a.com", "/cross_site_iframe_factory.html?a(b,c,d(e,f,g))"));
-  // Verify that 7 iframes are fetched, with some amount of tolerance since
-  // favicon is fetched only once.
-  waiter->AddMinimumPageLoadDataUseExpectation(7 * (one_frame_page_size - 100));
-  waiter->Wait();
-}
-
 IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
                        ReceivedAggregateResourceDataLength) {
   embedded_test_server()->ServeFilesFromSourceDirectory("content/test/data");

chrome/browser/page_load_metrics/page_load_metrics_observer.h

@@ -420,14 +420,6 @@ class PageLoadMetricsObserver {
   virtual void OnFeaturesUsageObserved(const mojom::PageLoadFeatures& features,
                                        const PageLoadExtraInfo& extra_info) {}
 
-  // Invoked when data use is observed for the page load across all frames.
-  // These bytes are the additional bytes reported since the last call to
-  // OnDataUseObserved. |received_data_length| is the received network bytes.
-  // |data_reduction_proxy_bytes_saved| is the bytes saved by the data reduction
-  // proxy, which could be negative if the proxy had inflated the resource.
-  virtual void OnDataUseObserved(int64_t received_data_length,
-                                 int64_t data_reduction_proxy_bytes_saved) {}
-
   // Invoked when there is data use for loading a resource on the page
   // acrosss all frames. This only contains resources that have had new
   // data use since the last callback.

chrome/browser/page_load_metrics/page_load_metrics_test_waiter.cc

@@ -48,11 +48,6 @@ void PageLoadMetricsTestWaiter::AddMinimumResourceBytesExpectation(
   expected_minimum_resource_bytes_ = expected_minimum_resource_bytes;
 }
 
-void PageLoadMetricsTestWaiter::AddMinimumPageLoadDataUseExpectation(
-    int expected_minimum_page_load_data_use) {
-  expected_minimum_page_load_data_use_ = expected_minimum_page_load_data_use;
-}
-
 bool PageLoadMetricsTestWaiter::DidObserveInPage(TimingField field) const {
   return observed_page_fields_.IsSet(field);
 }
@@ -111,14 +106,6 @@ void PageLoadMetricsTestWaiter::OnLoadedResource(
     run_loop_->Quit();
 }
 
-void PageLoadMetricsTestWaiter::OnDataUseObserved(
-    int64_t received_data_length,
-    int64_t data_reduction_proxy_bytes_saved) {
-  current_page_load_data_use_ += received_data_length;
-  if (ExpectationsSatisfied() && run_loop_)
-    run_loop_->Quit();
-}
-
 void PageLoadMetricsTestWaiter::OnResourceDataUseObserved(
     const std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr>&
         resources) {
@@ -203,14 +190,9 @@ bool PageLoadMetricsTestWaiter::ResourceUseExpectationsSatisfied() const {
           current_resource_bytes_ >= expected_minimum_resource_bytes_);
 }
 
-bool PageLoadMetricsTestWaiter::DataUseExpectationsSatisfied() const {
-  return (expected_minimum_page_load_data_use_ == 0 ||
-          current_page_load_data_use_ >= expected_minimum_page_load_data_use_);
-}
-
 bool PageLoadMetricsTestWaiter::ExpectationsSatisfied() const {
   return subframe_expected_fields_.Empty() && page_expected_fields_.Empty() &&
-         DataUseExpectationsSatisfied() && ResourceUseExpectationsSatisfied();
+         ResourceUseExpectationsSatisfied();
 }
 
 PageLoadMetricsTestWaiter::WaiterMetricsObserver::~WaiterMetricsObserver() {}
@@ -234,15 +216,6 @@ void PageLoadMetricsTestWaiter::WaiterMetricsObserver::OnLoadedResource(
     waiter_->OnLoadedResource(extra_request_complete_info);
 }
 
-void PageLoadMetricsTestWaiter::WaiterMetricsObserver::OnDataUseObserved(
-    int64_t received_data_length,
-    int64_t data_reduction_proxy_bytes_saved) {
-  if (waiter_) {
-    waiter_->OnDataUseObserved(received_data_length,
-                               data_reduction_proxy_bytes_saved);
-  }
-}
-
 void PageLoadMetricsTestWaiter::WaiterMetricsObserver::
     OnResourceDataUseObserved(
         const std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr>&

chrome/browser/page_load_metrics/page_load_metrics_test_waiter.h

@@ -46,22 +46,13 @@ class PageLoadMetricsTestWaiter
   // Add aggregate received resource bytes expectation
   void AddMinimumResourceBytesExpectation(int expected_minimum_resource_bytes);
 
-  // Add a data use expectation
-  void AddMinimumPageLoadDataUseExpectation(
-      int expected_minimum_page_load_data_use);
-
   // Whether the given TimingField was observed in the page.
   bool DidObserveInPage(TimingField field) const;
 
-  // Waits for PageLoadMetrics events that match the fields set by
-  // |AddPageExpectation| and |AddSubFrameExpectation|. All matching fields
-  // must be set to end this wait.
+  // Waits for PageLoadMetrics events that match the fields set by the add
+  // expectation methods. All matching fields must be set to end this wait.
   void Wait();
 
-  int64_t current_page_load_data_use() const {
-    return current_page_load_data_use_;
-  }
-
   int64_t current_resource_bytes() const { return current_resource_bytes_; }
 
  private:
@@ -84,9 +75,6 @@ class PageLoadMetricsTestWaiter
     void OnLoadedResource(const page_load_metrics::ExtraRequestCompleteInfo&
                               extra_request_complete_info) override;
 
-    void OnDataUseObserved(int64_t received_data_length,
-                           int64_t data_reduction_proxy_bytes_saved) override;
-
     void OnResourceDataUseObserved(
         const std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr>&
             resources) override;
@@ -145,12 +133,6 @@ class PageLoadMetricsTestWaiter
   void OnLoadedResource(const page_load_metrics::ExtraRequestCompleteInfo&
                             extra_request_complete_info);
 
-  // Updates data counters when data use is seen by the
-  // MetricsWebContentsObserver. Stops waiting if expectations are satsfied
-  // after update.
-  void OnDataUseObserved(int64_t received_data_length,
-                         int64_t data_reduction_proxy_bytes_saved);
-
   // Updates resource map and associated data counters as updates are received
   // from a resource load. Stops waiting if expectations are satisfied after
   // update.
@@ -164,8 +146,6 @@ class PageLoadMetricsTestWaiter
 
   bool ResourceUseExpectationsSatisfied() const;
 
-  bool DataUseExpectationsSatisfied() const;
-
   virtual bool ExpectationsSatisfied() const;
 
   std::unique_ptr<base::RunLoop> run_loop_;
@@ -175,8 +155,6 @@ class PageLoadMetricsTestWaiter
 
   TimingFieldBitSet observed_page_fields_;
 
-  int64_t expected_minimum_page_load_data_use_ = 0;
-  int64_t current_page_load_data_use_ = 0;
   int current_complete_resources_ = 0;
   int64_t current_resource_bytes_ = 0;
   int expected_num_complete_resources_ = 0;

chrome/browser/page_load_metrics/page_load_metrics_update_dispatcher.cc

@@ -431,7 +431,6 @@ void PageLoadMetricsUpdateDispatcher::UpdateMetrics(
     const mojom::PageLoadTiming& new_timing,
     const mojom::PageLoadMetadata& new_metadata,
     const mojom::PageLoadFeatures& new_features,
-    const mojom::PageLoadDataUse& new_data_use,
     const std::vector<mojom::ResourceDataUpdatePtr>& resources) {
   if (render_frame_host->GetLastCommittedURL().SchemeIs(
           extensions::kExtensionScheme)) {
@@ -442,7 +441,6 @@ void PageLoadMetricsUpdateDispatcher::UpdateMetrics(
 
   // Report data usage before new timing and metadata for messages that have
   // both updates.
-  client_->UpdateDataUse(new_data_use);
   client_->UpdateResourceDataUse(resources);
   if (render_frame_host->GetParent() == nullptr) {
     UpdateMainFrameMetadata(new_metadata);

chrome/browser/page_load_metrics/page_load_metrics_update_dispatcher.h

@@ -109,7 +109,6 @@ class PageLoadMetricsUpdateDispatcher {
     virtual void OnSubframeMetadataChanged() = 0;
     virtual void UpdateFeaturesUsage(
         const mojom::PageLoadFeatures& new_features) = 0;
-    virtual void UpdateDataUse(const mojom::PageLoadDataUse& new_data_use) = 0;
     virtual void UpdateResourceDataUse(
         const std::vector<mojom::ResourceDataUpdatePtr>& resources) = 0;
   };
@@ -126,7 +125,6 @@ class PageLoadMetricsUpdateDispatcher {
       const mojom::PageLoadTiming& new_timing,
       const mojom::PageLoadMetadata& new_metadata,
       const mojom::PageLoadFeatures& new_features,
-      const mojom::PageLoadDataUse& new_data_use,
       const std::vector<mojom::ResourceDataUpdatePtr>& resources);
 
   // This method is only intended to be called for PageLoadFeatures being
@@ -164,8 +162,6 @@ class PageLoadMetricsUpdateDispatcher {
   void MaybeDispatchTimingUpdates(bool did_merge_new_timing_value);
   void DispatchTimingUpdates();
 
-  void UpdateDataUse(const mojom::PageLoadDataUse& new_data_use);
-
   // The client is guaranteed to outlive this object.
   Client* const client_;
 

chrome/browser/page_load_metrics/page_load_tracker.cc

@@ -643,14 +643,6 @@ void PageLoadTracker::UpdateFeaturesUsage(
   }
 }
 
-void PageLoadTracker::UpdateDataUse(
-    const mojom::PageLoadDataUse& new_data_use) {
-  for (const auto& observer : observers_) {
-    observer->OnDataUseObserved(new_data_use.received_data_length,
-                                new_data_use.data_reduction_proxy_bytes_saved);
-  }
-}
-
 void PageLoadTracker::UpdateResourceDataUse(
     const std::vector<mojom::ResourceDataUpdatePtr>& resources) {
   for (const auto& observer : observers_) {

chrome/browser/page_load_metrics/page_load_tracker.h

@@ -180,7 +180,6 @@ class PageLoadTracker : public PageLoadMetricsUpdateDispatcher::Client {
   void OnSubframeMetadataChanged() override;
   void UpdateFeaturesUsage(
       const mojom::PageLoadFeatures& new_features) override;
-  void UpdateDataUse(const mojom::PageLoadDataUse& new_datause) override;
   void UpdateResourceDataUse(
       const std::vector<mojom::ResourceDataUpdatePtr>& resources) override;
 

chrome/common/page_load_metrics/page_load_metrics.mojom

@@ -155,19 +155,6 @@ struct PageLoadFeatures {
   array<int32> animated_css_properties;
 };
 
-// Data used for the page load.
-// TODO(johnidel): Remove/deprecate this struct once per resource updates are
-// being sent to the browser
-struct PageLoadDataUse {
-  // Network bytes received for the page load.
-  int64 received_data_length = 0;
-
-  // The number of bytes saved by the data reduction proxy. Will be zero when
-  // data reduction proxy is not used. Can be negative if the proxy inflated the
-  // resource.
-  int64 data_reduction_proxy_bytes_saved = 0;
-};
-
 struct ResourceDataUpdate {
   // The id for the resource request.
   int32 request_id = 0;
@@ -182,6 +169,10 @@ struct ResourceDataUpdate {
 
   // Whether this resource load has completed.
   bool is_complete;
+
+  // Compression ratio estimated from the response headers if data saver was
+  // used.
+  double data_reduction_proxy_compression_ratio_estimate;
 };
 
 // Sent from renderer to browser process when the PageLoadTiming for the
@@ -190,6 +181,5 @@ interface PageLoadMetrics {
   UpdateTiming(PageLoadTiming page_load_timing,
                PageLoadMetadata page_load_metadata,
                PageLoadFeatures new_features,
-               PageLoadDataUse data_use,
                array<ResourceDataUpdate> resources);
 };

chrome/renderer/page_load_metrics/fake_page_timing_sender.cc

@@ -18,10 +18,8 @@ void FakePageTimingSender::SendTiming(
     const mojom::PageLoadTimingPtr& timing,
     const mojom::PageLoadMetadataPtr& metadata,
     mojom::PageLoadFeaturesPtr new_features,
-    mojom::PageLoadDataUsePtr new_data_use,
     std::vector<mojom::ResourceDataUpdatePtr> resources) {
-  validator_->UpdateTiming(timing, metadata, new_features, new_data_use,
-                           resources);
+  validator_->UpdateTiming(timing, metadata, new_features, resources);
 }
 
 FakePageTimingSender::PageTimingValidator::PageTimingValidator() {}
@@ -97,7 +95,6 @@ void FakePageTimingSender::PageTimingValidator::UpdateTiming(
     const mojom::PageLoadTimingPtr& timing,
     const mojom::PageLoadMetadataPtr& metadata,
     const mojom::PageLoadFeaturesPtr& new_features,
-    const mojom::PageLoadDataUsePtr& new_data_use,
     const std::vector<mojom::ResourceDataUpdatePtr>& resources) {
   actual_timings_.push_back(timing.Clone());
   for (const auto feature : new_features->features) {

chrome/renderer/page_load_metrics/fake_page_timing_sender.h

@@ -72,7 +72,6 @@ class FakePageTimingSender : public PageTimingSender {
         const mojom::PageLoadTimingPtr& timing,
         const mojom::PageLoadMetadataPtr& metadata,
         const mojom::PageLoadFeaturesPtr& new_features,
-        const mojom::PageLoadDataUsePtr& new_data_use,
         const std::vector<mojom::ResourceDataUpdatePtr>& resources);
 
    private:
@@ -90,7 +89,6 @@ class FakePageTimingSender : public PageTimingSender {
   void SendTiming(const mojom::PageLoadTimingPtr& timing,
                   const mojom::PageLoadMetadataPtr& metadata,
                   mojom::PageLoadFeaturesPtr new_features,
-                  mojom::PageLoadDataUsePtr new_data_use,
                   std::vector<mojom::ResourceDataUpdatePtr> resources) override;
 
  private:

chrome/renderer/page_load_metrics/metrics_render_frame_observer.cc

@@ -42,12 +42,11 @@ class MojoPageTimingSender : public PageTimingSender {
       const mojom::PageLoadTimingPtr& timing,
       const mojom::PageLoadMetadataPtr& metadata,
       mojom::PageLoadFeaturesPtr new_features,
-      mojom::PageLoadDataUsePtr new_data_use,
       std::vector<mojom::ResourceDataUpdatePtr> resources) override {
     DCHECK(page_load_metrics_);
-    page_load_metrics_->UpdateTiming(
-        timing->Clone(), metadata->Clone(), std::move(new_features),
-        std::move(new_data_use), std::move(resources));
+    page_load_metrics_->UpdateTiming(timing->Clone(), metadata->Clone(),
+                                     std::move(new_features),
+                                     std::move(resources));
   }
 
  private:
@@ -111,8 +110,7 @@ void MetricsRenderFrameObserver::DidCompleteResponse(
     const network::URLLoaderCompletionStatus& status) {
   if (provisional_frame_resource_data_use_ &&
       provisional_frame_resource_data_use_->resource_id() == request_id) {
-    provisional_frame_resource_data_use_->DidCompleteResponse(
-        status, provisional_delta_data_use_.get());
+    provisional_frame_resource_data_use_->DidCompleteResponse(status);
   } else if (page_timing_metrics_sender_) {
     page_timing_metrics_sender_->DidCompleteResponse(request_id, status);
   }
@@ -133,7 +131,7 @@ void MetricsRenderFrameObserver::DidReceiveTransferSizeUpdate(
   if (provisional_frame_resource_data_use_ &&
       provisional_frame_resource_data_use_->resource_id() == request_id) {
     provisional_frame_resource_data_use_->DidReceiveTransferSizeUpdate(
-        received_data_length, provisional_delta_data_use_.get());
+        received_data_length);
   } else if (page_timing_metrics_sender_) {
     page_timing_metrics_sender_->DidReceiveTransferSizeUpdate(
         request_id, received_data_length);
@@ -149,14 +147,12 @@ void MetricsRenderFrameObserver::DidStartProvisionalLoad(
   // Create a new data use tracker for the new provisional load.
   provisional_frame_resource_data_use_ =
       std::make_unique<PageResourceDataUse>();
-  provisional_delta_data_use_ = mojom::PageLoadDataUse::New();
 }
 
 void MetricsRenderFrameObserver::DidFailProvisionalLoad(
     const blink::WebURLError& error) {
   // Clear the data use tracker for the provisional navigation that started.
   provisional_frame_resource_data_use_.reset();
-  provisional_delta_data_use_.reset();
 }
 
 void MetricsRenderFrameObserver::DidCommitProvisionalLoad(
@@ -178,8 +174,7 @@ void MetricsRenderFrameObserver::DidCommitProvisionalLoad(
 
   page_timing_metrics_sender_ = std::make_unique<PageTimingMetricsSender>(
       CreatePageTimingSender(), CreateTimer(), GetTiming(),
-      std::move(provisional_frame_resource_data_use_),
-      std::move(provisional_delta_data_use_));
+      std::move(provisional_frame_resource_data_use_));
 }
 
 void MetricsRenderFrameObserver::SendMetrics() {

chrome/renderer/page_load_metrics/metrics_render_frame_observer.h

@@ -73,7 +73,6 @@ class MetricsRenderFrameObserver : public content::RenderFrameObserver {
   // information from ongoing resource requests on the previous page (or right
   // before this page loads in a new renderer).
   std::unique_ptr<PageResourceDataUse> provisional_frame_resource_data_use_;
-  mojom::PageLoadDataUsePtr provisional_delta_data_use_;
 
   // Will be null when we're not actively sending metrics.
   std::unique_ptr<PageTimingMetricsSender> page_timing_metrics_sender_;

chrome/renderer/page_load_metrics/page_resource_data_use.cc

@@ -32,26 +32,17 @@ void PageResourceDataUse::DidStartResponse(
 }
 
 void PageResourceDataUse::DidReceiveTransferSizeUpdate(
-    int received_data_length,
-    mojom::PageLoadDataUse* delta_data_use) {
-  delta_data_use->received_data_length += received_data_length;
-  delta_data_use->data_reduction_proxy_bytes_saved +=
-      received_data_length *
-      (data_reduction_proxy_compression_ratio_estimate_ - 1.0);
+    int received_data_length) {
   total_received_bytes_ += received_data_length;
 }
 
 bool PageResourceDataUse::DidCompleteResponse(
-    const network::URLLoaderCompletionStatus& status,
-    mojom::PageLoadDataUse* delta_data_use) {
+    const network::URLLoaderCompletionStatus& status) {
   // Report the difference in received bytes.
   is_complete_ = true;
   int64_t delta_bytes = status.encoded_data_length - total_received_bytes_;
   if (delta_bytes > 0) {
     total_received_bytes_ += delta_bytes;
-    delta_data_use->received_data_length += delta_bytes;
-    delta_data_use->data_reduction_proxy_bytes_saved +=
-        delta_bytes * (data_reduction_proxy_compression_ratio_estimate_ - 1.0);
     return true;
   }
   return false;
@@ -79,6 +70,8 @@ mojom::ResourceDataUpdatePtr PageResourceDataUse::GetResourceDataUpdate() {
   resource_data_update->received_data_length = total_received_bytes_;
   resource_data_update->delta_bytes = CalculateNewlyReceivedBytes();
   resource_data_update->is_complete = is_complete_;
+  resource_data_update->data_reduction_proxy_compression_ratio_estimate =
+      data_reduction_proxy_compression_ratio_estimate_;
   return resource_data_update;
 }
 }  // namespace page_load_metrics

chrome/renderer/page_load_metrics/page_resource_data_use.h

@@ -25,14 +25,11 @@ class PageResourceDataUse {
   void DidStartResponse(int resource_id,
                         const network::ResourceResponseHead& response_head);
 
-  // Updates any additional bytes of data use to |delta_data_use|.
-  void DidReceiveTransferSizeUpdate(int received_data_length,
-                                    mojom::PageLoadDataUse* delta_data_use);
+  // Updates received bytes.
+  void DidReceiveTransferSizeUpdate(int received_data_length);
 
-  // Updates additional bytes to |delta_data_use| and returns whether it was
-  // updated.
-  bool DidCompleteResponse(const network::URLLoaderCompletionStatus& status,
-                           mojom::PageLoadDataUse* delta_data_use);
+  // Updates received bytes from encoded length, returns whether it was updated.
+  bool DidCompleteResponse(const network::URLLoaderCompletionStatus& status);
 
   // Flags the resource as canceled.
   void DidCancelResponse();

chrome/renderer/page_load_metrics/page_timing_metrics_sender.cc

@@ -29,14 +29,12 @@ PageTimingMetricsSender::PageTimingMetricsSender(
     std::unique_ptr<PageTimingSender> sender,
     std::unique_ptr<base::OneShotTimer> timer,
     mojom::PageLoadTimingPtr initial_timing,
-    std::unique_ptr<PageResourceDataUse> initial_request,
-    mojom::PageLoadDataUsePtr initial_data_use)
+    std::unique_ptr<PageResourceDataUse> initial_request)
     : sender_(std::move(sender)),
       timer_(std::move(timer)),
       last_timing_(std::move(initial_timing)),
       metadata_(mojom::PageLoadMetadata::New()),
       new_features_(mojom::PageLoadFeatures::New()),
-      new_data_use_(std::move(initial_data_use)),
       buffer_timer_delay_ms_(kBufferTimerDelayMillis) {
   page_resource_data_use_.emplace(
       std::piecewise_construct,
@@ -115,8 +113,7 @@ void PageTimingMetricsSender::DidReceiveTransferSizeUpdate(
     return;
   }
 
-  resource_it->second.DidReceiveTransferSizeUpdate(received_data_length,
-                                                   new_data_use_.get());
+  resource_it->second.DidReceiveTransferSizeUpdate(received_data_length);
   modified_resources_.insert(&resource_it->second);
   EnsureSendTimer();
 }
@@ -136,7 +133,7 @@ void PageTimingMetricsSender::DidCompleteResponse(
     resource_it = new_resource_it.first;
   }
 
-  if (resource_it->second.DidCompleteResponse(status, new_data_use_.get())) {
+  if (resource_it->second.DidCompleteResponse(status)) {
     EnsureSendTimer();
   }
   modified_resources_.insert(&resource_it->second);
@@ -189,9 +186,8 @@ void PageTimingMetricsSender::SendNow() {
     }
   }
   sender_->SendTiming(last_timing_, metadata_, std::move(new_features_),
-                      std::move(new_data_use_), std::move(resources));
+                      std::move(resources));
   new_features_ = mojom::PageLoadFeatures::New();
-  new_data_use_ = mojom::PageLoadDataUse::New();
   modified_resources_.clear();
 }
 

chrome/renderer/page_load_metrics/page_timing_metrics_sender.h

@@ -38,8 +38,7 @@ class PageTimingMetricsSender {
   PageTimingMetricsSender(std::unique_ptr<PageTimingSender> sender,
                           std::unique_ptr<base::OneShotTimer> timer,
                           mojom::PageLoadTimingPtr initial_timing,
-                          std::unique_ptr<PageResourceDataUse> initial_request,
-                          mojom::PageLoadDataUsePtr initial_data_use);
+                          std::unique_ptr<PageResourceDataUse> initial_request);
   ~PageTimingMetricsSender();
 
   void DidObserveLoadingBehavior(blink::WebLoadingBehaviorFlag behavior);
@@ -72,8 +71,6 @@ class PageTimingMetricsSender {
   // A list of newly observed features during page load, to be sent to the
   // browser.
   mojom::PageLoadFeaturesPtr new_features_;
-  // Additional data use observed during the page load.
-  mojom::PageLoadDataUsePtr new_data_use_;
 
   std::bitset<static_cast<size_t>(blink::mojom::WebFeature::kNumberOfFeatures)>
       features_sent_;

chrome/renderer/page_load_metrics/page_timing_metrics_sender_unittest.cc

@@ -22,8 +22,7 @@ class TestPageTimingMetricsSender : public PageTimingMetricsSender {
       : PageTimingMetricsSender(std::move(page_timing_sender),
                                 std::make_unique<base::MockOneShotTimer>(),
                                 std::move(initial_timing),
-                                std::make_unique<PageResourceDataUse>(),
-                                mojom::PageLoadDataUse::New()) {}
+                                std::make_unique<PageResourceDataUse>()) {}
 
   base::MockOneShotTimer* mock_timer() const {
     return static_cast<base::MockOneShotTimer*>(timer());

chrome/renderer/page_load_metrics/page_timing_sender.h

@@ -18,7 +18,6 @@ class PageTimingSender {
       const mojom::PageLoadTimingPtr& timing,
       const mojom::PageLoadMetadataPtr& metadata,
       mojom::PageLoadFeaturesPtr new_features,
-      mojom::PageLoadDataUsePtr new_data_use,
       std::vector<mojom::ResourceDataUpdatePtr> resources) = 0;
 };