Precache tracking database

components/precache/core/precache_url_table.cc

Index: components/precache/core/precache_url_table.cc
diff --git a/components/precache/core/precache_url_table.cc b/components/precache/core/precache_url_table.cc
new file mode 100644
index 0000000000000000000000000000000000000000..99eb1d76ee31557cd866cff18e3ce7f1fe8b9dd6
--- /dev/null
+++ b/components/precache/core/precache_url_table.cc
@@ -0,0 +1,119 @@
+// 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_url_table.h"
+
+#include <string>
+
+#include "base/logging.h"
+#include "base/strings/stringprintf.h"
+#include "base/time/time.h"
+#include "sql/connection.h"
+#include "sql/statement.h"
+#include "url/gurl.h"
+
+using sql::Statement;
+
+namespace {
+
+const char kUrlTableName[] = "precache_urls";
+
+}  // namespace
+
+namespace precache {
+
+PrecacheURLTable::PrecacheURLTable() : db_(NULL) {}
+
+PrecacheURLTable::~PrecacheURLTable() {}
+
+void PrecacheURLTable::Init(sql::Connection* db) {
+  DCHECK(!db_);  // Init must only be called once.
+  DCHECK(db);    // The database connection must be non-NULL.
+  db_ = db;
+  CreateTableIfNonExistent();
+}
+
+void PrecacheURLTable::AddURL(const GURL& url,
+                              const base::Time& precache_time) {
+  DCHECK(db_);
+
+  Statement statement(db_->GetCachedStatement(
+      SQL_FROM_HERE,
+      base::StringPrintf("INSERT OR REPLACE INTO %s (url, time) VALUES(?,?)",
+                         kUrlTableName).c_str()));
+  statement.BindString(0, GetKey(url));
+  statement.BindInt64(1, precache_time.ToInternalValue());
+
+  statement.Run();
+}
+
+bool PrecacheURLTable::HasURL(const GURL& url) {
+  DCHECK(db_);
+
+  Statement statement(db_->GetCachedStatement(
+      SQL_FROM_HERE, base::StringPrintf("SELECT time FROM %s WHERE url=?",
+                                        kUrlTableName).c_str()));
+  statement.BindString(0, GetKey(url));
+
+  return statement.Step();
+}
+
+void PrecacheURLTable::DeleteURL(const GURL& url) {
+  DCHECK(db_);
+
+  Statement statement(db_->GetCachedStatement(
+      SQL_FROM_HERE,
+      base::StringPrintf("DELETE FROM %s WHERE url=?", kUrlTableName).c_str()));
+  statement.BindString(0, GetKey(url));
+
+  statement.Run();
+}
+
+void PrecacheURLTable::DeleteAllPrecachedBetween(const base::Time& delete_begin,
+                                                 const base::Time& delete_end) {
+  DCHECK(db_);
+
+  Statement statement(db_->GetCachedStatement(
+      SQL_FROM_HERE,
+      base::StringPrintf("DELETE FROM %s WHERE time >= ? AND time <= ?",
+                         kUrlTableName).c_str()));
+
+  statement.BindInt64(0, delete_begin.ToInternalValue());
+  statement.BindInt64(1, delete_end.ToInternalValue());

[mmenke, 2013/10/31 16:45:00]

Are internal values guaranteed to be consistent between chrome versions (On a
single platform, of course)?  I don't see it changing, just want to make sure we
shouldn't be using something else guaranteed to be consistent.

[sclittle, 2013/11/06 01:51:42]

There aren't any consistency guarantees on internal values. I don't see any
methods on Time that are more standard and guaranteed to be consistent, though,
and other code seems to use the internal value as well
(https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/pre...).

We could do something more complicated like (delete_begin -
base::Time()).InMicroseconds(), which is guaranteed to be consistent, but it's
probably not worth the additional complexity.

+
+  statement.Run();
+}
+
+void PrecacheURLTable::GetAllDataForTesting(std::map<GURL, base::Time>* map) {

[mmenke, 2013/10/31 16:45:00]

I suggest clearing the map first, so we have a well defined behavior.

[sclittle, 2013/11/06 01:51:42]

Done.

+  DCHECK(db_);
+
+  Statement statement(db_->GetCachedStatement(
+      SQL_FROM_HERE,
+      base::StringPrintf("SELECT url, time FROM %s", kUrlTableName).c_str()));
+
+  while (statement.Step()) {
+    GURL url = GURL(statement.ColumnString(0));
+    (*map)[url] = base::Time::FromInternalValue(statement.ColumnInt64(1));
+  }
+}
+
+// static
+std::string PrecacheURLTable::GetKey(const GURL& url) {
+  return url.spec();
+}

[mmenke, 2013/10/31 16:45:00]

This doesn't need to be a member function.  Suggest just moving it up to the
anonymous namespace.

[sclittle, 2013/11/06 01:51:42]

Done.

+
+void PrecacheURLTable::CreateTableIfNonExistent() {
+  DCHECK(db_);
+
+  if (db_->DoesTableExist(kUrlTableName))
+    return;
+
+  if (!db_->Execute(base::StringPrintf(
+           "CREATE TABLE %s (url TEXT, time INTEGER, PRIMARY KEY(url))",
+           kUrlTableName).c_str())) {
+    DLOG(WARNING) << "Could not create precache URL table in database.";
+  }
+}
+
+}  // namespace precache