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;
+
 // 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.
+  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 476 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));
   }
 }
 
+void ResourcePrefetchPredictor::ReportDatabaseReadiness(
+    const history::TopHostsList& top_hosts) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (top_hosts.size() == 0)
+    return;
+
+  int count_in_cache = 0;
+  for (const std::pair<std::string, int>& top_host : top_hosts) {
+    const std::string& host = top_host.first;
+    if (host_table_cache_->find(host) != host_table_cache_->end()) {
+      ++count_in_cache;
+    } else {
+      // 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 (!base::StartsWith(host, "www.", base::CompareCase::SENSITIVE) &&
+          host_table_cache_->find("www." + host) != host_table_cache_->end()) {
+        ++count_in_cache;
+      }
+    }
+  }
+  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