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 399 matching lines @@
 void ResourcePrefetchPredictor::SetAllowPortInUrlsForTesting(bool state) {
   g_allow_port_in_urls = state;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ResourcePrefetchPredictor nested types.
 
 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) {}
 
 ResourcePrefetchPredictor::URLRequestSummary::URLRequestSummary(
     const URLRequestSummary& other)
     : navigation_id(other.navigation_id),
       resource_url(other.resource_url),
       resource_type(other.resource_type),
       priority(other.priority),
+      response_time(other.response_time),
+      before_first_contentful_paint(other.before_first_contentful_paint),
       mime_type(other.mime_type),
       was_cached(other.was_cached),
       redirect_url(other.redirect_url),
       has_validators(other.has_validators),
       always_revalidate(other.always_revalidate) {}
 
 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();
   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", "*");
   }
   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 101 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) {
+  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 159 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.
+  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 396 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(

[alexilin, 2017/04/21 13:49:05]

It has been lost :(

[trevordixon, 2017/04/25 12:46:09]

Oh no, I did a bad merge. Restored.

+          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(

[alexilin, 2017/04/21 13:49:05]

Ditto.

[trevordixon, 2017/04/25 12:46:09]

Fixed.

+            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 218 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors