predictors: Mark before_first_contentful_paint for resources fetched before fcp.

chrome/browser/predictors/resource_prefetch_predictor_test_util.cc

 // Copyright 2016 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_test_util.h"
 
 #include <cmath>
 
 namespace {
 
@@ skipping 19 matching lines @@
                             bool has_validators,
                             bool always_revalidate) {
   resource->set_resource_url(resource_url);
   resource->set_resource_type(
       static_cast<ResourceData::ResourceType>(resource_type));
   resource->set_number_of_hits(number_of_hits);
   resource->set_number_of_misses(number_of_misses);
   resource->set_consecutive_misses(consecutive_misses);
   resource->set_average_position(average_position);
   resource->set_priority(static_cast<ResourceData::Priority>(priority));
+  resource->set_before_first_contentful_paint(true);
   resource->set_has_validators(has_validators);
   resource->set_always_revalidate(always_revalidate);
 }
 
 void InitializeRedirectStat(RedirectStat* redirect,
                             const std::string& url,
                             int number_of_hits,
                             int number_of_misses,
                             int consecutive_misses) {
   redirect->set_url(url);
@@ skipping 104 matching lines @@
                                           const std::string& redirect_url,
                                           bool has_validators,
                                           bool always_revalidate) {
   URLRequestSummary summary;
   summary.navigation_id = CreateNavigationID(tab_id, main_frame_url);
   summary.resource_url =
       resource_url.empty() ? GURL(main_frame_url) : GURL(resource_url);
   summary.request_url = summary.resource_url;
   summary.resource_type = resource_type;
   summary.priority = priority;
+  summary.before_first_contentful_paint = true;
   summary.mime_type = mime_type;
   summary.was_cached = was_cached;
   if (!redirect_url.empty())
     summary.redirect_url = GURL(redirect_url);
   summary.has_validators = has_validators;
   summary.always_revalidate = always_revalidate;
   summary.is_no_store = false;
   summary.network_accessed = true;
   return summary;
 }
 
 std::ostream& operator<<(std::ostream& os, const PrefetchData& data) {
   os << "[" << data.primary_key() << "," << data.last_visit_time() << "]"
      << std::endl;
   for (const ResourceData& resource : data.resources())
     os << "\t\t" << resource << std::endl;
   return os;
 }
 
 std::ostream& operator<<(std::ostream& os, const ResourceData& resource) {
   return os << "[" << resource.resource_url() << "," << resource.resource_type()
             << "," << resource.number_of_hits() << ","
             << resource.number_of_misses() << ","
             << resource.consecutive_misses() << ","
             << resource.average_position() << "," << resource.priority() << ","
+            << resource.before_first_contentful_paint() << ","
             << resource.has_validators() << "," << resource.always_revalidate()
             << "]";
 }
 
 std::ostream& operator<<(std::ostream& os, const RedirectData& data) {
   os << "[" << data.primary_key() << "," << data.last_visit_time() << "]"
      << std::endl;
   for (const RedirectStat& redirect : data.redirect_endpoints())
     os << "\t\t" << redirect << std::endl;
   return os;
@@ skipping 24 matching lines @@
   os << "[" << summary.main_frame_url << "," << summary.initial_url << "]"
      << std::endl;
   for (const auto& request : summary.subresource_requests)
     os << "\t\t" << request << std::endl;
   return os;
 }
 
 std::ostream& operator<<(std::ostream& os, const URLRequestSummary& summary) {
   return os << "[" << summary.navigation_id << "," << summary.resource_url
             << "," << summary.resource_type << "," << summary.priority << ","
-            << summary.mime_type << "," << summary.was_cached << ","
-            << summary.redirect_url << "," << summary.has_validators << ","
-            << summary.always_revalidate << "]";
+            << summary.before_first_contentful_paint << "," << summary.mime_type
+            << "," << summary.was_cached << "," << summary.redirect_url << ","
+            << summary.has_validators << "," << summary.always_revalidate
+            << "]";
 }
 
 std::ostream& operator<<(std::ostream& os, const NavigationID& navigation_id) {
   return os << navigation_id.tab_id << "," << navigation_id.main_frame_url;
 }
 
 bool operator==(const PrefetchData& lhs, const PrefetchData& rhs) {
   bool equal = lhs.primary_key() == rhs.primary_key() &&
                lhs.resources_size() == rhs.resources_size();
 
   if (!equal)
     return false;
 
   for (int i = 0; i < lhs.resources_size(); ++i)
     equal = equal && lhs.resources(i) == rhs.resources(i);
 
   return equal;
 }
 
 bool operator==(const ResourceData& lhs, const ResourceData& rhs) {
   return lhs.resource_url() == rhs.resource_url() &&
          lhs.resource_type() == rhs.resource_type() &&
          lhs.number_of_hits() == rhs.number_of_hits() &&
          lhs.number_of_misses() == rhs.number_of_misses() &&
          lhs.consecutive_misses() == rhs.consecutive_misses() &&
          AlmostEqual(lhs.average_position(), rhs.average_position()) &&
          lhs.priority() == rhs.priority() &&
+         lhs.before_first_contentful_paint() ==
+             rhs.before_first_contentful_paint() &&
          lhs.has_validators() == rhs.has_validators() &&
          lhs.always_revalidate() == rhs.always_revalidate();
 }
 
 bool operator==(const RedirectData& lhs, const RedirectData& rhs) {
   bool equal = lhs.primary_key() == rhs.primary_key() &&
                lhs.redirect_endpoints_size() == rhs.redirect_endpoints_size();
 
   if (!equal)
     return false;
@@ skipping 15 matching lines @@
   return lhs.main_frame_url == rhs.main_frame_url &&
          lhs.initial_url == rhs.initial_url &&
          lhs.subresource_requests == rhs.subresource_requests;
 }
 
 bool operator==(const URLRequestSummary& lhs, const URLRequestSummary& rhs) {
   return lhs.navigation_id == rhs.navigation_id &&
          lhs.resource_url == rhs.resource_url &&
          lhs.resource_type == rhs.resource_type &&
          lhs.priority == rhs.priority && lhs.mime_type == rhs.mime_type &&
+         lhs.before_first_contentful_paint ==
+             rhs.before_first_contentful_paint &&
          lhs.was_cached == rhs.was_cached &&
          lhs.redirect_url == rhs.redirect_url &&
          lhs.has_validators == rhs.has_validators &&
          lhs.always_revalidate == rhs.always_revalidate;
 }
 
 bool operator==(const OriginData& lhs, const OriginData& rhs) {
   bool equal =
       lhs.host() == rhs.host() && lhs.origins_size() == rhs.origins_size();
   if (!equal)
@@ skipping 43 matching lines @@
 
   return equal;
 }
 
 bool operator==(const PrecacheResource& lhs, const PrecacheResource& rhs) {
   return lhs.url() == rhs.url() &&
          AlmostEqual(lhs.weight_ratio(), rhs.weight_ratio());
 }
 
 }  // namespace precache