[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_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(bool was_cached) {
+  if (was_cached) {
+    ++cache_requests_;
+  } else {
+    ++network_requests_;
+  }
+}
+
 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_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) {
+  // For simplicity, only count subresources.

[kinuko, 2016/08/09 12:40:37]

nit: this comment doesn't really say anything, would be nice to explain why we
only care about subresources

[Charlie Harrison, 2016/08/09 13:15:44]

I added a comment. Essentially we do care about main resource loads but they
will have to be treated differently / more complicated within this pipeline
because data comes in from main resource loads before we have a committed load
here.

+  if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME &&
+      net_error != net::OK) {
+    return;
+  }
+  if (!committed_load_)
+    return;
+  committed_load_->OnLoadedSubresource(was_cached);
+}
+
 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