predictors: Mark before_first_contentful_paint for resources fetched before fcp.

chrome/browser/predictors/resource_prefetch_predictor.cc

 // Copyright 2014 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/predictors/resource_prefetch_predictor.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 451 matching lines @@
       first_occurrence(0) {}
 
 ResourcePrefetchPredictor::OriginRequestSummary::OriginRequestSummary(
     const OriginRequestSummary& other) = default;
 
 ResourcePrefetchPredictor::OriginRequestSummary::~OriginRequestSummary() {}
 
 ResourcePrefetchPredictor::URLRequestSummary::URLRequestSummary()
     : resource_type(content::RESOURCE_TYPE_LAST_TYPE),
       priority(net::IDLE),
+      response_time(base::TimeTicks()),
+      before_first_contentful_paint(false),
       was_cached(false),
       has_validators(false),
       always_revalidate(false),
       is_no_store(false),
       network_accessed(false) {}
 
 ResourcePrefetchPredictor::URLRequestSummary::URLRequestSummary(
     const URLRequestSummary& other) = default;
 
 ResourcePrefetchPredictor::URLRequestSummary::~URLRequestSummary() {
 }
 
 // static
 bool ResourcePrefetchPredictor::URLRequestSummary::SummarizeResponse(
     const net::URLRequest& request,
     URLRequestSummary* summary) {
   const content::ResourceRequestInfo* request_info =
       content::ResourceRequestInfo::ForRequest(&request);
   if (!request_info)
     return false;
 
+  summary->response_time = base::TimeTicks::Now();
   summary->resource_url = request.original_url();
   summary->request_url = request.url();
   content::ResourceType resource_type_from_request =
       request_info->GetResourceType();
   summary->priority = request.priority();
   request.GetMimeType(&summary->mime_type);
   summary->was_cached = request.was_cached();
   summary->resource_type =
       GetResourceType(resource_type_from_request, summary->mime_type);
 
   scoped_refptr<net::HttpResponseHeaders> headers =
       request.response_info().headers;
   if (headers.get()) {
     summary->has_validators = headers->HasValidators();
     // RFC 2616, section 14.9.
     summary->always_revalidate =
         headers->HasHeaderValue("cache-control", "no-cache") ||
         headers->HasHeaderValue("pragma", "no-cache") ||
         headers->HasHeaderValue("vary", "*");
     summary->is_no_store = IsNoStore(request);
   }
   summary->network_accessed = request.response_info().network_accessed;
   return true;
 }
 
 ResourcePrefetchPredictor::PageRequestSummary::PageRequestSummary(
     const GURL& i_main_frame_url)
-    : main_frame_url(i_main_frame_url), initial_url(i_main_frame_url) {}
+    : main_frame_url(i_main_frame_url),
+      initial_url(i_main_frame_url),
+      first_contentful_paint(base::TimeTicks::Max()) {}
 
 ResourcePrefetchPredictor::PageRequestSummary::PageRequestSummary(
     const PageRequestSummary& other) = default;
 
 ResourcePrefetchPredictor::PageRequestSummary::~PageRequestSummary() {}
 
 ResourcePrefetchPredictor::Prediction::Prediction() = default;
 
 ResourcePrefetchPredictor::Prediction::Prediction(
     const ResourcePrefetchPredictor::Prediction& other) = default;
@@ skipping 107 matching lines @@
       // corresponding to the navigation has not been created yet.
       if (!navigation_id.main_frame_url.is_empty())
         OnNavigationComplete(navigation_id);
       break;
     default:
       NOTREACHED() << "Unexpected initialization_state_: "
                    << initialization_state_;
   }
 }
 
+void ResourcePrefetchPredictor::RecordFirstContentfulPaint(
+    const NavigationID& navigation_id,
+    const base::TimeTicks& first_contentful_paint) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (initialization_state_ != INITIALIZED)
+    return;
+
+  NavigationMap::iterator nav_it = inflight_navigations_.find(navigation_id);
+  if (nav_it != inflight_navigations_.end())
+    nav_it->second->first_contentful_paint = first_contentful_paint;
+}
+
 void ResourcePrefetchPredictor::StartPrefetching(const GURL& url,
                                                  PrefetchOrigin origin) {
   TRACE_EVENT1("browser", "ResourcePrefetchPredictor::StartPrefetching", "url",
                url.spec());
   // Save prefetch start time to report prefetching duration.
   if (inflight_prefetches_.find(url) == inflight_prefetches_.end() &&
       IsUrlPrefetchable(url)) {
     inflight_prefetches_.insert(std::make_pair(url, base::TimeTicks::Now()));
   }
 
@@ skipping 179 matching lines @@
 
   NavigationMap::iterator nav_it =
       inflight_navigations_.find(nav_id_without_timing_info);
   if (nav_it == inflight_navigations_.end())
     return;
 
   // Remove the navigation from the inflight navigations.
   std::unique_ptr<PageRequestSummary> summary = std::move(nav_it->second);
   inflight_navigations_.erase(nav_it);
 
+  // Set before_first_contentful paint for each resource.

[Benoit L, 2017/04/25 15:30:36]

If I understand the code correctly, this will slightly overestimate the
resources we get before first contentful paint, because we take the time at
which we start reading the response as the reference, not the time at which we
are done with a resource.

This is fine, and doing otherwise would complicate the code.

If my understanding is correct, can you add a comment making that explicit?

[trevordixon, 2017/04/25 20:23:55]

OK, documented above where response_time is recorded.

+  for (auto& request_summary : summary->subresource_requests) {
+    request_summary.before_first_contentful_paint =
+        request_summary.response_time < summary->first_contentful_paint;
+  }
+
   const GURL& initial_url = summary->initial_url;
   ResourcePrefetchPredictor::Prediction prediction;
   bool has_data = GetPrefetchData(initial_url, &prediction);
   if (has_data)
     ReportPredictionAccuracy(prediction, *summary);
 
   auto it = prefetcher_stats_.find(initial_url);
   if (it != prefetcher_stats_.end()) {
     const std::vector<URLRequestSummary>& summaries =
         summary->subresource_requests;
@@ skipping 479 matching lines @@
         continue;
 
       ResourceData* resource_to_add = data.add_resources();
       resource_to_add->set_resource_url(summary.resource_url.spec());
       resource_to_add->set_resource_type(
           static_cast<ResourceData::ResourceType>(summary.resource_type));
       resource_to_add->set_number_of_hits(1);
       resource_to_add->set_average_position(i + 1);
       resource_to_add->set_priority(
           static_cast<ResourceData::Priority>(summary.priority));
+      resource_to_add->set_before_first_contentful_paint(
+          summary.before_first_contentful_paint);
       resource_to_add->set_has_validators(summary.has_validators);
       resource_to_add->set_always_revalidate(summary.always_revalidate);
 
       resources_seen.insert(summary.resource_url);
     }
   } else {
     PrefetchData& data = cache_entry->second;
     data.set_last_visit_time(base::Time::Now().ToInternalValue());
 
     // Build indices over the data.
@@ skipping 29 matching lines @@
 
         // Update the resource type since it could have changed.
         if (new_summary.resource_type != content::RESOURCE_TYPE_LAST_TYPE) {
           old_resource->set_resource_type(
               static_cast<ResourceData::ResourceType>(
                   new_summary.resource_type));
         }
 
         old_resource->set_priority(
             static_cast<ResourceData::Priority>(new_summary.priority));
+        old_resource->set_before_first_contentful_paint(
+            new_summary.before_first_contentful_paint);
 
         int position = new_index[resource_url] + 1;
         int total =
             old_resource->number_of_hits() + old_resource->number_of_misses();
         old_resource->set_average_position(
             ((old_resource->average_position() * total) + position) /
             (total + 1));
         old_resource->set_number_of_hits(old_resource->number_of_hits() + 1);
         old_resource->set_consecutive_misses(0);
       }
     }
 
     // Add the new ones that we have not seen before.
     for (int i = 0; i < new_resources_size; ++i) {
       const URLRequestSummary& summary = new_resources[i];
       if (old_index.find(summary.resource_url) != old_index.end())
         continue;
 
       // Only need to add new stuff.
       ResourceData* resource_to_add = data.add_resources();
       resource_to_add->set_resource_url(summary.resource_url.spec());
       resource_to_add->set_resource_type(
           static_cast<ResourceData::ResourceType>(summary.resource_type));
       resource_to_add->set_number_of_hits(1);
       resource_to_add->set_average_position(i + 1);
       resource_to_add->set_priority(
           static_cast<ResourceData::Priority>(summary.priority));
+      resource_to_add->set_before_first_contentful_paint(
+          summary.before_first_contentful_paint);
       resource_to_add->set_has_validators(new_resources[i].has_validators);
       resource_to_add->set_always_revalidate(
           new_resources[i].always_revalidate);
 
       // To ensure we dont add the same url twice.
       old_index[summary.resource_url] = 0;
     }
   }
 
   PrefetchData& data = cache_entry->second;
@@ skipping 368 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors