predictors: Collect page load metrics for ResourcePrefetchPredictor.

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 521 matching lines @@
       base::Bind(&ResourcePrefetcherManager::MaybeRemovePrefetch,
                  prefetch_manager_, url));
 }
 
 void ResourcePrefetchPredictor::OnPrefetchingFinished(
     const GURL& main_frame_url) {
   if (observer_)
     observer_->OnPrefetchingFinished(main_frame_url);
 }
 
+bool ResourcePrefetchPredictor::IsUrlPrefetchable(const GURL& main_frame_url) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (initialization_state_ != INITIALIZED)
+    return false;
+
+  return GetPrefetchData(main_frame_url, nullptr);
+}
+
 void ResourcePrefetchPredictor::SetObserverForTesting(TestObserver* observer) {
   observer_ = observer;
 }
 
 void ResourcePrefetchPredictor::Shutdown() {
   if (prefetch_manager_.get()) {
     prefetch_manager_->ShutdownOnUIThread();
     prefetch_manager_ = NULL;
   }
   history_service_observer_.RemoveAll();
@@ skipping 103 matching lines @@
   // Report readiness metric with 20% probability.
   if (base::RandInt(1, 5) == 5) {
     history_service->TopHosts(
         kNumSampleHosts,
         base::Bind(&ResourcePrefetchPredictor::ReportDatabaseReadiness,
                    AsWeakPtr()));
   }
 }
 
 bool ResourcePrefetchPredictor::GetPrefetchData(const GURL& main_frame_url,
-                                                std::vector<GURL>* urls) {
-  DCHECK(urls);
-  DCHECK(urls->empty());
+                                                std::vector<GURL>* urls) const {
+  DCHECK(!urls || urls->empty());
 
   // Fetch URLs based on a redirect endpoint for URL/host first.
   std::string redirect_endpoint;
   if (GetRedirectEndpoint(main_frame_url.spec(), *url_redirect_table_cache_,
                           &redirect_endpoint) &&
       PopulatePrefetcherRequest(redirect_endpoint, *url_table_cache_, urls)) {
     return true;
   }
 
   if (GetRedirectEndpoint(main_frame_url.host(), *host_redirect_table_cache_,
                           &redirect_endpoint) &&
       PopulatePrefetcherRequest(redirect_endpoint, *host_table_cache_, urls)) {
     return true;
   }
 
   // Fallback to fetching URLs based on the incoming URL/host.
   if (PopulatePrefetcherRequest(main_frame_url.spec(), *url_table_cache_,
                                 urls)) {
     return true;
   }
 
   return PopulatePrefetcherRequest(main_frame_url.host(), *host_table_cache_,
                                    urls);
 }
 
 bool ResourcePrefetchPredictor::PopulatePrefetcherRequest(
     const std::string& main_frame_key,
     const PrefetchDataMap& data_map,
-    std::vector<GURL>* urls) {
-  DCHECK(urls);
+    std::vector<GURL>* urls) const {
   PrefetchDataMap::const_iterator it = data_map.find(main_frame_key);
   if (it == data_map.end())
     return false;
 
-  size_t initial_size = urls->size();
+  bool has_prefetchable_resource = false;
   for (const ResourceData& resource : it->second.resources()) {
-    if (IsResourcePrefetchable(resource))
-      urls->push_back(GURL(resource.resource_url()));
+    if (IsResourcePrefetchable(resource)) {
+      has_prefetchable_resource = true;
+      if (urls)
+        urls->push_back(GURL(resource.resource_url()));
+    }
   }
 
-  return urls->size() > initial_size;
+  return has_prefetchable_resource;
 }
 
 void ResourcePrefetchPredictor::CreateCaches(
     std::unique_ptr<PrefetchDataMap> url_data_map,
     std::unique_ptr<PrefetchDataMap> host_data_map,
     std::unique_ptr<RedirectDataMap> url_redirect_data_map,
     std::unique_ptr<RedirectDataMap> host_redirect_data_map) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK_EQ(INITIALIZING, initialization_state_);
@@ skipping 422 matching lines @@
     const RedirectData& url_redirect_data =
         is_host ? empty_redirect_data : data;
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&ResourcePrefetchPredictorTables::UpdateData, tables_,
                    empty_data, empty_data, url_redirect_data,
                    host_redirect_data));
   }
 }
 
-bool ResourcePrefetchPredictor::IsDataPrefetchable(
-    const std::string& main_frame_key,
-    const PrefetchDataMap& data_map) const {
-  PrefetchDataMap::const_iterator it = data_map.find(main_frame_key);
-  if (it == data_map.end())
-    return false;
-
-  return std::any_of(it->second.resources().begin(),
-                     it->second.resources().end(),
-                     [this](const ResourceData& resource) {
-                       return IsResourcePrefetchable(resource);
-                     });
-}
-
 bool ResourcePrefetchPredictor::IsResourcePrefetchable(
     const ResourceData& resource) const {
   float confidence = static_cast<float>(resource.number_of_hits()) /
                      (resource.number_of_hits() + resource.number_of_misses());
   return confidence >= config_.min_resource_confidence_to_trigger_prefetch &&
          resource.number_of_hits() >=
              config_.min_resource_hits_to_trigger_prefetch;
 }
 
 void ResourcePrefetchPredictor::ReportDatabaseReadiness(
     const history::TopHostsList& top_hosts) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (top_hosts.size() == 0)
     return;
 
   size_t count_in_cache = 0;
   size_t total_visits = 0;
   for (const std::pair<std::string, int>& top_host : top_hosts) {
     const std::string& host = top_host.first;
     total_visits += top_host.second;
 
     // Hostnames in TopHostsLists are stripped of their 'www.' prefix. We
     // assume that www.foo.com entry from |host_table_cache_| is also suitable
     // for foo.com.
-    if (IsDataPrefetchable(host, *host_table_cache_) ||
+    if (PopulatePrefetcherRequest(host, *host_table_cache_, nullptr) ||
         (!base::StartsWith(host, "www.", base::CompareCase::SENSITIVE) &&
-         IsDataPrefetchable("www." + host, *host_table_cache_))) {
+         PopulatePrefetcherRequest("www." + host, *host_table_cache_,
+                                   nullptr))) {
       ++count_in_cache;
     }
   }
 
   // Filter users that don't have the rich browsing history.
   if (total_visits > kReportReadinessThreshold) {
     UMA_HISTOGRAM_PERCENTAGE("ResourcePrefetchPredictor.DatabaseReadiness",
                              100 * count_in_cache / top_hosts.size());
   }
 }
@@ skipping 48 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors