[PageLoadMetrics] Record bytes usage per page

chrome/browser/loader/chrome_resource_dispatcher_host_delegate.cc

 // Copyright (c) 2012 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/loader/chrome_resource_dispatcher_host_delegate.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 341 matching lines @@
   }
 }
 
 void NotifyUIThreadOfRequestComplete(
     const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const GURL& url,
     content::ResourceType resource_type,
     bool was_cached,
     int net_error,
     int64_t total_received_bytes,
+    int64_t raw_body_bytes,
     base::TimeDelta request_loading_time) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::WebContents* web_contents = web_contents_getter.Run();
   if (!web_contents)
     return;
   if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
     LogMainFrameMetricsOnUIThread(url, net_error, request_loading_time,
                                   web_contents);
   }
   if (!was_cached)
     UpdatePrerenderNetworkBytesCallback(web_contents, total_received_bytes);
   page_load_metrics::MetricsWebContentsObserver* metrics_observer =
       page_load_metrics::MetricsWebContentsObserver::FromWebContents(
           web_contents);
   if (metrics_observer) {
-    metrics_observer->OnRequestComplete(resource_type, was_cached, net_error);
+    metrics_observer->OnRequestComplete(resource_type, was_cached, net_error,
+                                        raw_body_bytes);
   }
 }
 
 }  // namespace
 
 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate()
     : download_request_limiter_(g_browser_process->download_request_limiter()),
       safe_browsing_(g_browser_process->safe_browsing_service())
 #if BUILDFLAG(ENABLE_EXTENSIONS)
       , user_script_listener_(new extensions::UserScriptListener())
@@ skipping 431 matching lines @@
   // once ResourceDispatcherHostDelegate is modified.
   int net_error = url_request->status().error();
   const ResourceRequestInfo* info =
       ResourceRequestInfo::ForRequest(url_request);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&NotifyUIThreadOfRequestComplete,
                  info->GetWebContentsGetterForRequest(), url_request->url(),
                  info->GetResourceType(), url_request->was_cached(), net_error,
                  url_request->GetTotalReceivedBytes(),
+                 url_request->GetRawBodyBytes(),

[RyanSturm, 2016/12/12 22:29:38]

I'm curious why you are using GetRawBodyBytes instead of GetTotalReceivedBytes.
Does it seem worth tracking GetTotalSentBytes as well? I'm not really sure what
exactly you are comparing and if bytes sent matters or if only bytes received
matter.

[jkarlin, 2016/12/19 19:26:01]

Right now only tracking received bytes. I'm using RawBodyBytes because I'm not
worried about how large the decoded resource is, I want to know how many network
and cache bytes the page load required.

We can always add decoded bytes and sent bytes later.

[RyanSturm, 2016/12/19 19:40:05]

I thought both of these tracked bytes after decoding SSL, but RawBodyBytes
doesn't include headers, I might be wrong on this though.
 

[jkarlin, 2016/12/20 14:03:58]

You're right that they both track bytes before decoding. The difference is that
the GetTotalReceivedBytes only counts bytes over the network while RawBodyBytes
counts body size regardless of if it came from the network or from cache. 

If we want the network and cached UMA values to be comparable, then they should
probably both use the same (body size). I could be persuaded otherwise though,
WDYT?

                  base::TimeTicks::Now() - url_request->creation_time()));
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldEnableLoFiMode(
     const net::URLRequest& url_request,
     content::ResourceContext* resource_context) {
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
   data_reduction_proxy::DataReductionProxyIOData* data_reduction_proxy_io_data =
       io_data->data_reduction_proxy_io_data();
 
@@ skipping 46 matching lines @@
           base::Bind(&ChromeResourceDispatcherHostDelegate::OnAbortedFrameLoad,
                     base::Unretained(this), url, request_loading_time));
       return;
   }
 
   std::string metric_name = (request_loading_time.InMilliseconds() < 100 ?
       "Net.ErrAborted.Fast" : "Net.ErrAborted.Slow");
   rappor::SampleDomainAndRegistryFromGURL(
       g_browser_process->rappor_service(), metric_name, url);
 }