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"
@@ skipping 11 matching lines @@
 // 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;
 
 }  // namespace
 
 namespace precache {
 
 PrecacheDatabase::PrecacheDatabase()
     : is_flush_posted_(false), weak_factory_(this) {
   // A PrecacheDatabase can be constructed on any thread.

[Raj, 2016/07/06 17:16:46]

nit: initialize last_precache_timestamp_ to 0

[jamartin, 2016/07/07 12:12:36]

No need. The default constructor of base::Time already initializes it so that
is_null (sort of 0).

   thread_checker_.DetachFromThread();
 }
 
 PrecacheDatabase::~PrecacheDatabase() {
   // The destructor must not run on the UI thread, as it may trigger IO
   // operations via sql::Connection's destructor.
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool PrecacheDatabase::Init(const base::FilePath& db_path) {
@@ skipping 40 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() {

[Raj, 2016/07/06 17:16:46]

nit: Can we check if the cached last_precache_timestamp_ is valid (!=0), and
return it and avoid the sql call. 

[jamartin, 2016/07/07 12:12:36]

Done.

Anyway, I think I put this function here only for testing purposes.

+  if (!IsDatabaseAccessible()) {
+    // Use the cached value, possibly not initialized (and hence is_null()).
+    return last_precache_timestamp_;
+  }
+
+  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) {
+  if (last_precache_timestamp_.is_null()) {
+    last_precache_timestamp_ =
+        precache_session_table_.GetLastPrecacheTimestamp();
+  }
+  // It could still be null if the DB was not accessible.
+  if (!last_precache_timestamp_.is_null()) {
+    // This is the timespan 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.
+    UMA_HISTOGRAM_TIMES("Precache.TimeSinceLastPrecache",
+                        fetch_time - last_precache_timestamp_);
+  }
+}
+
 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