[page_load_metrics] Log cache warmth ratios at parse stop

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 241 matching lines @@
     content::NavigationHandle* navigation_handle,
     int aborted_chain_size,
     int aborted_chain_size_same_url)
     : did_stop_tracking_(false),
       app_entered_background_(false),
       navigation_start_(navigation_handle->NavigationStart()),
       url_(navigation_handle->GetURL()),
       abort_type_(ABORT_NONE),
       started_in_foreground_(in_foreground),
       page_transition_(navigation_handle->GetPageTransition()),
+      cache_subresource_bytes_(0),
+      network_subresource_bytes_(0),
+      cache_requests_(0),
+      network_requests_(0),
       aborted_chain_size_(aborted_chain_size),
       aborted_chain_size_same_url_(aborted_chain_size_same_url),
       embedder_interface_(embedder_interface) {
   DCHECK(!navigation_handle->HasCommitted());
   embedder_interface_->RegisterObservers(this);
   for (const auto& observer : observers_) {
     observer->OnStart(navigation_handle, currently_committed_url,
                       started_in_foreground_);
   }
 }
@@ skipping 199 matching lines @@
     const PageLoadExtraInfo info = ComputePageLoadExtraInfo();
     for (const auto& observer : observers_) {
       DispatchObserverTimingCallbacks(observer.get(), last_timing, new_timing,
                                       last_metadata, info);
     }
     return true;
   }
   return false;
 }
 
+void PageLoadTracker::OnLoadedSubresource(int64_t bytes, bool was_cached) {
+  if (was_cached) {
+    ++cache_requests_;
+    cache_subresource_bytes_ += bytes;
+  } else {
+    ++network_requests_;
+    network_subresource_bytes_ += bytes;
+  }
+}
+
 void PageLoadTracker::StopTracking() {
   did_stop_tracking_ = true;
 }
 
 void PageLoadTracker::AddObserver(
     std::unique_ptr<PageLoadMetricsObserver> observer) {
   observers_.push_back(std::move(observer));
 }
 
 void PageLoadTracker::ClampBrowserTimestampIfInterProcessTimeTickSkew(
@@ skipping 47 matching lines @@
   }
 
   if (!commit_time_.is_null()) {
     DCHECK_GE(commit_time_, navigation_start_);
     time_to_commit = commit_time_ - navigation_start_;
   }
 
   return PageLoadExtraInfo(
       first_background_time, first_foreground_time, started_in_foreground_,
       commit_time_.is_null() ? GURL() : url_, time_to_commit, abort_type_,
-      time_to_abort, metadata_);
+      time_to_abort, cache_subresource_bytes_, network_subresource_bytes_,
+      cache_requests_, network_requests_, metadata_);
 }
 
 void PageLoadTracker::NotifyAbort(UserAbortType abort_type,
                                   base::TimeTicks timestamp,
                                   bool is_certainly_browser_timestamp) {
   DCHECK_NE(abort_type, ABORT_NONE);
   // Use UpdateAbort to update an already notified PageLoadTracker.
   if (abort_type_ != ABORT_NONE)
     return;
 
@@ skipping 166 matching lines @@
   // the MetricsWebContentsObserver owns them both list and they are torn down
   // after the PageLoadTracker. The PageLoadTracker does not hold on to
   // committed_load_ or navigation_handle beyond the scope of the constructor.
   provisional_loads_.insert(std::make_pair(
       navigation_handle,
       base::WrapUnique(new PageLoadTracker(
           in_foreground_, embedder_interface_.get(), currently_committed_url,
           navigation_handle, chain_size, chain_size_same_url))));
 }
 
+void MetricsWebContentsObserver::OnRequestComplete(
+    content::ResourceType resource_type,
+    bool was_cached,
+    int net_error,
+    int64_t total_received_bytes,
+    int64_t raw_body_bytes) {
+  // For simplicity, only count subresources.
+  if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME &&
+      net_error != net::OK) {
+    return;
+  }
+  if (!committed_load_)
+    return;
+  int64_t bytes = was_cached ? raw_body_bytes : total_received_bytes;

[Bryan McQuade, 2016/08/08 18:53:28]

is raw_body_bytes uncompressed but total_received_bytes compressed? that'd skew
byte counts towards cached responses.

[Charlie Harrison, 2016/08/08 20:55:02]

Great point. I chatted with mmenke@ about this and it seems like if we want
decompressed bytes we have to instrument read calls manually here. Because
that's a decent amount of code for little gain, I'll just punt on the "bytes"
metric for now and go based on # of requests.

+  committed_load_->OnLoadedSubresource(bytes, was_cached);

[Bryan McQuade, 2016/08/08 18:53:28]

are we sure that all resources loaded are for the currently committed load? can
we verify that somehow?

[Charlie Harrison, 2016/08/08 20:55:02]

I think this is reasonably accurate. If there are subresource requests going on
I think it makes sense to attribute them with the current page (i.e. current
committed load). Barring threading race conditions, I think we're okay here.

What kind of verification were you thinking of? 

The alternative approach here would be to do this logic in blink. But I wanted
to fully account for OOPIF, and subframe loads contribute lots to page loads.

+}
+
 const PageLoadExtraInfo
 MetricsWebContentsObserver::GetPageLoadExtraInfoForCommittedLoad() {
   DCHECK(committed_load_);
   return committed_load_->ComputePageLoadExtraInfo();
 }
 
 void MetricsWebContentsObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
@@ skipping 251 matching lines @@
     if (navigation_handle->IsSamePage() || navigation_handle->IsErrorPage())
       return false;
     const std::string& mime_type = web_contents()->GetContentsMimeType();
     if (mime_type != "text/html" && mime_type != "application/xhtml+xml")
       return false;
   }
   return true;
 }
 
 }  // namespace page_load_metrics