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) {

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

Please add following lines to the beginning of the method:
  DCHECK_CURRENTLY_ON(BrowserThread::UI);
  if (initialization_state_ != INITIALIZED)
    return;

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

Done.

+  NavigationMap::iterator nav_it = inflight_navigations_.find(navigation_id);
+  if (nav_it != inflight_navigations_.end()) {

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

very tiny nit:
You could omit curly braces.

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

OK.

+    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.
+  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 555 matching lines @@
 
       // 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