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),
+      creation_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),
+      creation_time(other.creation_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->creation_time = request.creation_time();
   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 =
@@ skipping 126 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::TimeDelta& first_contentful_paint) {
+  NavigationMap::iterator nav_it =
+      inflight_navigations_.find(navigation_id);
+  if (nav_it == inflight_navigations_.end())
+    return;
+
+  base::TimeTicks fcp = nav_it->first.creation_time + first_contentful_paint;
+  for (auto& request_summary : nav_it->second->subresource_requests) {
+    request_summary.before_first_contentful_paint =
+        request_summary.creation_time < fcp;
+  }
+}
+
+
 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 568 matching lines @@
     data.set_primary_key(key);
     data.set_last_visit_time(base::Time::Now().ToInternalValue());
     size_t new_resources_size = new_resources.size();
     std::set<GURL> resources_seen;
     for (size_t i = 0; i < new_resources_size; ++i) {
       const URLRequestSummary& summary = new_resources[i];
       if (resources_seen.find(summary.resource_url) != resources_seen.end())
         continue;
 
       ResourceData* resource_to_add = data.add_resources();
+      resource_to_add->set_before_first_contentful_paint(
+          summary.before_first_contentful_paint);
       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_has_validators(summary.has_validators);
       resource_to_add->set_always_revalidate(summary.always_revalidate);
 
@@ skipping 36 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));
 

[alexilin, 2017/03/27 15:31:59]

Need to update before_first_contentful_paint property here as well.
This code corresponds the case when we had an entry in the database for the
current host with this resource.

For priority field we save the latest value seen so it makes sense to do so for
before_first_contentful_paint as well.

[trevordixon, 2017/03/28 11:10:41]

Done.

         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();

[alexilin, 2017/03/27 15:31:59]

Need to set_before_first_contentful_paint() here too.
This code corresponds the case when we had an entry in the database for the
current host but the resource is new. 

[trevordixon, 2017/03/28 11:10:41]

Done.

       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_has_validators(new_resources[i].has_validators);
       resource_to_add->set_always_revalidate(
           new_resources[i].always_revalidate);
@@ skipping 225 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors