Precache tracking database

components/precache/core/precache_database.cc

Index: components/precache/core/precache_database.cc
diff --git a/components/precache/core/precache_database.cc b/components/precache/core/precache_database.cc
new file mode 100644
index 0000000000000000000000000000000000000000..86e4e27f118a2035236ac03ce03fa952e742f194
--- /dev/null
+++ b/components/precache/core/precache_database.cc
@@ -0,0 +1,233 @@
+// 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/metrics/histogram.h"
+#include "base/time/time.h"
+#include "components/precache/core/precache_statistics_table.h"
+#include "components/precache/core/precache_url_table.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 int64 kPrecacheHistoryExpiryPeriodDays = 60;

[Scott Hess - ex-Googler, 2013/11/27 01:32:33]

Just |int| unless being 64-bit is somehow relevant.

[sclittle, 2013/12/02 21:12:52]

Done.

+
+void RecordSingleDayPrecacheUMA(
+    const precache::PrecacheStatisticsTable::PrecacheStatistics& stats) {
+  UMA_HISTOGRAM_COUNTS("Precache.DailyDownloadedPrecacheMotivatedKB",
+                       stats.downloaded_precache_motivated_bytes / 1024);
+  UMA_HISTOGRAM_COUNTS("Precache.DailyDownloadedNonPrecacheKB",
+                       stats.downloaded_non_precache_bytes / 1024);
+  UMA_HISTOGRAM_COUNTS("Precache.DailyDownloadedNonPrecacheKB.Cellular",
+                       stats.downloaded_non_precache_bytes_cellular / 1024);
+  UMA_HISTOGRAM_COUNTS("Precache.DailySavedKB", stats.saved_bytes / 1024);
+  UMA_HISTOGRAM_COUNTS("Precache.DailySavedKB.Cellular",
+                       stats.saved_bytes_cellular / 1024);
+
+  if (stats.saved_bytes + stats.downloaded_non_precache_bytes > 0) {
+    UMA_HISTOGRAM_PERCENTAGE(
+        "Precache.DailySavingsPercentage",
+        stats.saved_bytes * 100.0 /
+            (stats.saved_bytes + stats.downloaded_non_precache_bytes));
+  }
+
+  if (stats.saved_bytes_cellular +
+          stats.downloaded_non_precache_bytes_cellular > 0) {
+    UMA_HISTOGRAM_PERCENTAGE(
+        "Precache.DailySavingsPercentage.Cellular",
+        stats.saved_bytes_cellular * 100.0 /
+            (stats.saved_bytes_cellular +
+             stats.downloaded_non_precache_bytes_cellular));
+  }
+}
+
+}  // namespace
+
+namespace precache {
+
+PrecacheDatabase::PrecacheDatabase()
+    : precache_url_table_(new PrecacheURLTable()),
+      precache_statistics_table_(new PrecacheStatisticsTable()) {
+  // A PrecacheDatabase can be constructed on any thread.
+  thread_checker_.DetachFromThread();
+}
+
+PrecacheDatabase::~PrecacheDatabase() {
+  // Since the PrecacheDatabase is refcounted, it will only be deleted if there
+  // are no references remaining to it, meaning that it is not in use. Thus, it
+  // is safe to delete it, regardless of what thread we are on.
+  thread_checker_.DetachFromThread();

[Scott Hess - ex-Googler, 2013/11/27 01:32:33]

Note that sql::Connection doesn't make thread-safety guarantees.  That does not
mean that everything will bust if you destruct db_ on a different thread than it
was created on, just that nobody has your back if you do so.  I don't think it
will cause problems in here, though.

[sclittle, 2013/12/02 21:12:52]

Ok.

+}
+
+void PrecacheDatabase::Init(scoped_ptr<sql::Connection> db) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!db_);  // Init must only be called once.
+  DCHECK(db);    // |db| must not be NULL.
+
+  db_ = db.Pass();
+  db_->set_histogram_tag("Precache");
+
+  if (!IsDatabaseAccessible()) {
+    // Don't initialize the URL table or statistics table if unable to access
+    // the database.
+    return;
+  }
+
+  bool initialization_was_successful = false;
+
+  sql::Transaction transaction(db_.get());
+  if (transaction.Begin()) {
+    precache_url_table_->Init(db_.get());
+    precache_statistics_table_->Init(db_.get());
+    initialization_was_successful = transaction.Commit();
+  }
+
+  if (!initialization_was_successful) {
+    // Raze and close the database connection to indicate that it's not usable,
+    // and so that the database will be created anew next time, in case it's
+    // corrupted.
+    db_->RazeAndClose();

[Scott Hess - ex-Googler, 2013/11/27 01:32:33]

Note that RazeAndClose() is a bit of a misnomer - it was originally intended to
be used from a nested context where sql::Connection code was on the stack,
possibly transactions open, so neither Raze() nor Close() were appropriate. 
After calling this, db_ is still a sql::Connection*, but all calls to it will
fail.

I don't think it's necessarily inappropriate, is_open() should return false
after this, so I think it works.  Just wanted to make sure the subtleties are
understood.

[sclittle, 2013/12/02 21:12:52]

Ok

+  }
+}
+
+void PrecacheDatabase::ReportAndDeleteOldStats(const base::Time& current_time) {
+  if (!IsDatabaseAccessible()) {
+    // Do nothing if unable to access the database.
+    return;
+  }
+
+  sql::Transaction transaction(db_.get());
+  if (!transaction.Begin()) {
+    // Do nothing if unable to begin a transaction.
+    return;
+  }
+
+  // Delete old precache history that has expired.
+  precache_url_table_->DeleteAllPrecachedBefore(
+      current_time -
+      base::TimeDelta::FromDays(kPrecacheHistoryExpiryPeriodDays));
+
+  PrecacheStatisticsTable::PrecacheStatisticsMap stats_map;
+  precache_statistics_table_->GetOldStats(current_time, &stats_map);
+
+  precache_statistics_table_->DeleteOldStats(current_time);
+
+  if (!transaction.Commit()) {
+    // If the database transaction was rolled back, then don't report any
+    // precache UMA, to avoid double-counting any stats.
+    return;
+  }
+
+  // Report UMA for every row of old statistics in the statistics table. There
+  // won't be any rows in the statistics table for days when nothing was fetched
+  // or precached.
+  for (PrecacheStatisticsTable::PrecacheStatisticsMap::const_iterator it =
+           stats_map.begin();
+       it != stats_map.end(); ++it) {
+    RecordSingleDayPrecacheUMA(it->second);
+  }
+}
+
+void PrecacheDatabase::RecordURLPrecached(const GURL& url,
+                                          const base::Time& fetch_time,
+                                          int64 size, bool was_cached) {
+  if (!IsDatabaseAccessible()) {
+    // Don't track anything if unable to access the database.
+    return;
+  }
+
+  sql::Transaction transaction(db_.get());
+  if (!transaction.Begin()) {
+    // Do nothing if unable to begin a transaction.
+    return;
+  }
+
+  if (was_cached && !precache_url_table_->HasURL(url)) {
+    // Since the precache came from the cache, and there's no entry in the URL
+    // table for the URL, this means that the resource was already in the cache
+    // because of user browsing. Thus, this precache had no effect, so ignore
+    // it.
+    return;
+  }
+
+  if (!was_cached) {
+    // The precache only counts as overhead if it was downloaded over the
+    // network.
+    PrecacheStatisticsTable::PrecacheStatistics stats;
+    stats.downloaded_precache_motivated_bytes = size;
+    precache_statistics_table_->IncreaseDailyStats(fetch_time, stats);
+  }
+
+  // Use the URL table to keep track of URLs that are in the cache thanks to
+  // precaching. If a row for the URL already exists, than update the timestamp
+  // to |fetch_time|.
+  precache_url_table_->AddURL(url, fetch_time);
+
+  transaction.Commit();
+}
+
+void PrecacheDatabase::RecordURLFetched(const GURL& url,
+                                        const base::Time& fetch_time,
+                                        int64 size, bool was_cached,
+                                        bool is_connection_cellular) {
+  if (!IsDatabaseAccessible()) {
+    // Don't track anything if unable to access the database.
+    return;
+  }
+
+  sql::Transaction transaction(db_.get());
+  if (!transaction.Begin()) {
+    // Do nothing if unable to begin a transaction.
+    return;
+  }
+
+  if (was_cached && !precache_url_table_->HasURL(url)) {
+    // Ignore cache hits that precache can't take credit for.
+    return;
+  }
+
+  PrecacheStatisticsTable::PrecacheStatistics stats;
+
+  if (!was_cached) {
+    // The fetch was served over the network during user browsing, so count it
+    // as downloaded non-precache bytes.
+    stats.downloaded_non_precache_bytes = size;
+    if (is_connection_cellular) {
+      stats.downloaded_non_precache_bytes_cellular = size;
+    }
+  } else {
+    // The fetch was served from the cache, and since there's an entry for this
+    // URL in the URL table, this means that the resource was served from the
+    // cache only because precaching put it there. Thus, precaching was helpful,
+    // so count the fetch as saved bytes.
+    stats.saved_bytes = size;
+    if (is_connection_cellular) {
+      stats.saved_bytes_cellular = size;
+    }
+  }
+  precache_statistics_table_->IncreaseDailyStats(fetch_time, stats);
+
+  // Since the resource has been fetched during user browsing, remove any record
+  // of that URL having been precached from the URL table, if any exists.
+  // 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.
+  precache_url_table_->DeleteURL(url);
+
+  transaction.Commit();
+}
+
+bool PrecacheDatabase::IsDatabaseAccessible() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(db_);
+
+  return db_->is_open();
+}
+
+}  // namespace precache