[PageLoadMetrics] Record bytes usage per page

chrome/browser/page_load_metrics/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 "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 #include <utility>
@@ skipping 160 matching lines @@
       navigation_handle,
       base::MakeUnique<PageLoadTracker>(
           in_foreground_, embedder_interface_.get(), currently_committed_url,
           navigation_handle, user_initiated_info, chain_size,
           chain_size_same_url)));
 }
 
 void MetricsWebContentsObserver::OnRequestComplete(
     content::ResourceType resource_type,
     bool was_cached,
-    int net_error) {
+    int net_error,
+    int64_t raw_body_bytes) {
   // For simplicity, only count subresources. Navigations are hard to attribute
   // here because we won't have a committed load by the time data streams in
   // from the IO thread.
   if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME &&

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

Does this conditional match the comment?

It looks like according to the comment, it should maybe be an "or" instead of an
"and" because you don't want to track Main frame requests or net errors.

This implementation might be correct right now as the load will commit on the UI
thread before this method runs on the UI thread for the same request. In that
case, main frame requests are being tracked correctly.

You can also check if GlobalRequestID matches on NavigationHandle and
ResourceRequestInfo if you plumb it here (this won't work in a PlzNavigate world
however). However, GlobalRequestID is only available in ReadyToCommitNavigation.

[RyanSturm, 2016/12/12 23:17:14]

As of  https://crrev.com/4434137b674aa5703a2f1e3cf10d6ad0bdac9ac2,
GlobalRequestID is available in PlzNavigate.

If you can store a copy of GlobalRequestID in PageLoadTracker and plumb the
Request's GlobalRequestID, you should be able to attribute the main request to
the committed_load_ when they match. I suspect they will match except in the
case of a cancelled navigation.

[jkarlin, 2016/12/14 18:26:29]

You're right, that should be an or. So right now we are in fact tracking main
frame resources.
There is some concern that there is a race. Do we know for sure that
DidFinishNavigation is called on the UI thread before the URLRequest's
NotifyUIThreadOfRequestComplete is run?

Assuming that there is no race, do you believe this will work in a PlzNavigate
world as well?

[RyanSturm, 2016/12/14 19:56:07]

AFAIK, ChromeResourceDispatcherHostDelegate::RequestComplete() happens on the IO
thread after ResourceLoader::CompleteResponseStarted() happens on the IO thread
(I could be mistaken as there is a lot hpapening between net/ and content/).
This assumes a non-error, non-throttled NavigationHandle. I don't know enough
about NavigationThrottles using DEFER to really answer this question fully. In
the typical case, this should work.

However, I suspect that you are right that this is not a bullet-proof technique,
but there may be a way to match requests and NavigationHandles once both are
complete.
This should work in PlzNavigate now that GlobalRequestID got added, but I
haven't verified it myself.

       net_error != net::OK) {
     return;
   }
   if (!committed_load_)
     return;
-  committed_load_->OnLoadedSubresource(was_cached);
+  committed_load_->OnLoadedSubresource(was_cached, raw_body_bytes);
 }
 
 const PageLoadExtraInfo
 MetricsWebContentsObserver::GetPageLoadExtraInfoForCommittedLoad() {
   DCHECK(committed_load_);
   return committed_load_->ComputePageLoadExtraInfo();
 }
 
 void MetricsWebContentsObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
@@ skipping 271 matching lines @@
     content::NavigationHandle* navigation_handle) const {
   DCHECK(navigation_handle->IsInMainFrame());
   DCHECK(!navigation_handle->HasCommitted() ||
          !navigation_handle->IsSamePage());
 
   return BrowserPageTrackDecider(embedder_interface_.get(), web_contents(),
                                  navigation_handle).ShouldTrack();
 }
 
 }  // namespace page_load_metrics