Report Precache.TimeSinceLastPrecache

components/precache/core/precache_database.cc

 // Copyright 2013 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 "components/precache/core/precache_database.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/history/core/browser/history_constants.h"
 #include "components/precache/core/proto/unfinished_work.pb.h"
 #include "sql/connection.h"
 #include "sql/transaction.h"
 #include "url/gurl.h"
 
 namespace {
 
 // The number of days old that an entry in the precache URL table can be before
 // it is considered "old" and is removed from the table.
 const int kPrecacheHistoryExpiryPeriodDays = 60;
 
+const int kSecondsInMinute = 60;
+const int kSecondsInHour = kSecondsInMinute * 60;
+
 }  // namespace
 
 namespace precache {
 
 PrecacheDatabase::PrecacheDatabase()
     : is_flush_posted_(false), weak_factory_(this) {
   // A PrecacheDatabase can be constructed on any thread.
   thread_checker_.DetachFromThread();
 }
 
@@ skipping 47 matching lines @@
   if (!IsDatabaseAccessible()) {
     // Do nothing if unable to access the database.
     return;
   }
 
   buffered_writes_.push_back(base::Bind(
       &PrecacheURLTable::DeleteAll, base::Unretained(&precache_url_table_)));
   Flush();
 }
 
+void PrecacheDatabase::SetLastPrecacheTimestamp(const base::Time& time) {
+  last_precache_timestamp_ = time;
+
+  if (!IsDatabaseAccessible()) {
+    // Do nothing if unable to access the database.
+    return;
+  }
+
+  buffered_writes_.push_back(
+      base::Bind(&PrecacheSessionTable::SetLastPrecacheTimestamp,
+                 base::Unretained(&precache_session_table_), time));
+  MaybePostFlush();
+}
+
+base::Time PrecacheDatabase::GetLastPrecacheTimestamp() {
+  if (last_precache_timestamp_.is_null() && IsDatabaseAccessible()) {
+    last_precache_timestamp_ =
+        precache_session_table_.GetLastPrecacheTimestamp();
+  }
+  return last_precache_timestamp_;
+}
+
 void PrecacheDatabase::RecordURLPrefetch(const GURL& url,
                                          const base::TimeDelta& latency,
                                          const base::Time& fetch_time,
                                          int64_t size,
                                          bool was_cached) {
   UMA_HISTOGRAM_TIMES("Precache.Latency.Prefetch", latency);
 
   if (!IsDatabaseAccessible()) {
     // Don't track anything if unable to access the database.
     return;
@@ skipping 47 matching lines @@
     // The resource was loaded on a page that could NOT have been affected by
     // precaching.
     UMA_HISTOGRAM_TIMES("Precache.Latency.NonPrefetch.NonTopHosts", latency);
   }
 
   if (!IsDatabaseAccessible()) {
     // Don't track anything if unable to access the database.
     return;
   }
 
+  RecordTimeSinceLastPrecache(fetch_time);
+
   if (buffered_urls_.find(url.spec()) != buffered_urls_.end()) {
     // If the URL for this fetch is in the write buffer, then flush the write
     // buffer.
     Flush();
   }
 
   if (was_cached && !precache_url_table_.HasURL(url)) {
     // Ignore cache hits that precache can't take credit for.
     return;
   }
@@ skipping 24 matching lines @@
   // The current fetch would have put this resource in the cache regardless of
   // whether or not it was previously precached, so delete any record of that
   // URL having been precached from the URL table.
   buffered_writes_.push_back(
       base::Bind(&PrecacheURLTable::DeleteURL,
                  base::Unretained(&precache_url_table_), url));
   buffered_urls_.insert(url.spec());
   MaybePostFlush();
 }
 
+void PrecacheDatabase::RecordTimeSinceLastPrecache(
+    const base::Time& fetch_time) {
+  const base::Time& last_precache_timestamp = GetLastPrecacheTimestamp();
+  // It could still be null if the DB was not accessible.
+  if (!last_precache_timestamp.is_null()) {
+    // This is the timespan (in seconds) between the last call to
+    // PrecacheManager::StartPrecaching and the fetch time of a non-precache
+    // URL. Please note that the session started by that call to
+    // PrecacheManager::StartPrecaching may not have precached this particular
+    // URL or even any URL for that matter.
+    // The range was estimated to have the 95 percentile within the last bounded
+    // bucket.
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "Precache.TimeSinceLastPrecache",
+        (fetch_time - last_precache_timestamp).InSeconds(), kSecondsInMinute,
+        kSecondsInHour * 36, 100);
+  }
+}
+
 bool PrecacheDatabase::IsDatabaseAccessible() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(db_);
 
   return db_->is_open();
 }
 
 void PrecacheDatabase::Flush() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (buffered_writes_.empty()) {
@@ skipping 63 matching lines @@
 
 void PrecacheDatabase::DeleteUnfinishedWork() {
   precache_session_table_.DeleteUnfinishedWork();
 }
 
 base::WeakPtr<PrecacheDatabase> PrecacheDatabase::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 }  // namespace precache