predictors: Add ResourcePrefetchPredictor database readiness histogram.

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>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
+#include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/predictor_database_factory.h"
 #include "chrome/browser/predictors/resource_prefetcher_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
@@ skipping 23 matching lines @@
                                 "application/font-woff2",
                                 "font/x-woff",
                                 "application/x-font-ttf",
                                 "font/woff",
                                 "font/ttf",
                                 "application/x-font-otf",
                                 "x-font/woff",
                                 "application/font-sfnt",
                                 "application/font-ttf"};
 
+const size_t kNumSampleHosts = 50;
+const size_t kReportReadinessThreshold = 50;
+
 // For reporting events of interest that are not tied to any navigation.
 enum ReportingEvent {
   REPORTING_EVENT_ALL_HISTORY_CLEARED = 0,
   REPORTING_EVENT_PARTIAL_HISTORY_CLEARED = 1,
   REPORTING_EVENT_COUNT = 2
 };
 
 float ComputeRedirectConfidence(const predictors::RedirectStat& redirect) {
   return (redirect.number_of_hits() + 0.0) /
          (redirect.number_of_hits() + redirect.number_of_misses());
@@ skipping 533 matching lines @@
   history::HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile_,
                                            ServiceAccessType::EXPLICIT_ACCESS);
   DCHECK(history_service);
   history_service->ScheduleDBTask(
       std::unique_ptr<history::HistoryDBTask>(new GetUrlVisitCountTask(
           std::move(summary),
           base::Bind(&ResourcePrefetchPredictor::OnVisitCountLookup,
                      AsWeakPtr()))),
       &history_lookup_consumer_);
+
+  // Report readiness metric with 20% probability.

[Ilya Sherman, 2017/01/12 21:10:39]

What's the reason for sampling?

[alexilin, 2017/01/12 22:53:13]

Because of relatively high computation cost. We need to make round trip from UI
thread to DB and back for the top hosts list + to search top hosts in predictor
db cache.
I don't think that the sampling will cause any analysis issues.

[Ilya Sherman, 2017/01/12 23:08:08]

Okay, fair enough!

+  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());
 
   // 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_,
@@ skipping 22 matching lines @@
     const std::string& main_frame_key,
     const PrefetchDataMap& data_map,
     std::vector<GURL>* urls) {
   DCHECK(urls);
   PrefetchDataMap::const_iterator it = data_map.find(main_frame_key);
   if (it == data_map.end())
     return false;
 
   size_t initial_size = urls->size();
   for (const ResourceData& resource : it->second.resources()) {
-    float confidence =
-        static_cast<float>(resource.number_of_hits()) /
-        (resource.number_of_hits() + resource.number_of_misses());
-    if (confidence < config_.min_resource_confidence_to_trigger_prefetch ||
-        resource.number_of_hits() <
-            config_.min_resource_hits_to_trigger_prefetch)
-      continue;
-
-    urls->push_back(GURL(resource.resource_url()));
+    if (IsResourcePrefetchable(resource))
+      urls->push_back(GURL(resource.resource_url()));
   }
 
   return urls->size() > initial_size;
 }
 
 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) {
@@ skipping 425 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_) ||
+        (!base::StartsWith(host, "www.", base::CompareCase::SENSITIVE) &&
+         IsDataPrefetchable("www." + host, *host_table_cache_))) {
+      ++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());
+  }
+}
+
 void ResourcePrefetchPredictor::OnURLsDeleted(
     history::HistoryService* history_service,
     bool all_history,
     bool expired,
     const history::URLRows& deleted_rows,
     const std::set<GURL>& favicon_urls) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(initialization_state_ == INITIALIZED);
 
   if (all_history) {
@@ skipping 37 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors