AppCache INTERCEPT namespace.

webkit/appcache/appcache_database.cc

 // Copyright (c) 2011 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 "webkit/appcache/appcache_database.h"
 
 #include "base/auto_reset.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "sql/connection.h"
 #include "sql/diagnostic_error_delegate.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_histograms.h"
 
 // Schema -------------------------------------------------------------------
 namespace {
 
-const int kCurrentVersion = 3;
-const int kCompatibleVersion = 3;
+const int kCurrentVersion = 4;
+const int kCompatibleVersion = 4;
 
 const char kGroupsTable[] = "Groups";
 const char kCachesTable[] = "Caches";
 const char kEntriesTable[] = "Entries";
-const char kFallbackNameSpacesTable[] = "FallbackNameSpaces";
+const char kNamespacesTable[] = "Namespaces";
 const char kOnlineWhiteListsTable[] = "OnlineWhiteLists";
 const char kDeletableResponseIdsTable[] = "DeletableResponseIds";
 
-const struct {
+struct TableInfo {
   const char* table_name;
   const char* columns;
-} kTables[] = {
+};
+
+struct IndexInfo {
+  const char* index_name;
+  const char* table_name;
+  const char* columns;
+  bool unique;
+};
+
+const TableInfo kTables[] = {
   { kGroupsTable,
     "(group_id INTEGER PRIMARY KEY,"
     " origin TEXT,"
     " manifest_url TEXT,"
     " creation_time INTEGER,"
     " last_access_time INTEGER)" },
 
   { kCachesTable,
     "(cache_id INTEGER PRIMARY KEY,"
     " group_id INTEGER,"
     " online_wildcard INTEGER CHECK(online_wildcard IN (0, 1)),"
     " update_time INTEGER,"
     " cache_size INTEGER)" },  // intentionally not normalized
 
   { kEntriesTable,
     "(cache_id INTEGER,"
     " url TEXT,"
     " flags INTEGER,"
     " response_id INTEGER,"
     " response_size INTEGER)" },
 
-  { kFallbackNameSpacesTable,
+  { kNamespacesTable,
     "(cache_id INTEGER,"
     " origin TEXT,"  // intentionally not normalized
+    " type INTEGER,"
     " namespace_url TEXT,"
-    " fallback_entry_url TEXT)" },
+    " target_url TEXT)" },
 
   { kOnlineWhiteListsTable,
     "(cache_id INTEGER,"
     " namespace_url TEXT)" },
 
   { kDeletableResponseIdsTable,
     "(response_id INTEGER NOT NULL)" },
 };
 
-const struct {
-  const char* index_name;
-  const char* table_name;
-  const char* columns;
-  bool unique;
-} kIndexes[] = {
+const IndexInfo kIndexes[] = {
   { "GroupsOriginIndex",
     kGroupsTable,
     "(origin)",
     false },
 
   { "GroupsManifestIndex",
     kGroupsTable,
     "(manifest_url)",
     true },
 
@@ skipping 10 matching lines @@
   { "EntriesCacheAndUrlIndex",
     kEntriesTable,
     "(cache_id, url)",
     true },
 
   { "EntriesResponseIdIndex",
     kEntriesTable,
     "(response_id)",
     true },
 
-  { "FallbackNameSpacesCacheIndex",
-    kFallbackNameSpacesTable,
+  { "NamespacesCacheIndex",
+    kNamespacesTable,
     "(cache_id)",
     false },
 
-  { "FallbackNameSpacesOriginIndex",
-    kFallbackNameSpacesTable,
+  { "NamespacesOriginIndex",
+    kNamespacesTable,
     "(origin)",
     false },
 
-  { "FallbackNameSpacesCacheAndUrlIndex",
-    kFallbackNameSpacesTable,
+  { "NamespacesCacheAndUrlIndex",
+    kNamespacesTable,
     "(cache_id, namespace_url)",
     true },
 
   { "OnlineWhiteListCacheIndex",
     kOnlineWhiteListsTable,
     "(cache_id)",
     false },
 
   { "DeletableResponsesIdIndex",
     kDeletableResponseIdsTable,
     "(response_id)",
     true },
 };
 
 const int kTableCount = ARRAYSIZE_UNSAFE(kTables);
 const int kIndexCount = ARRAYSIZE_UNSAFE(kIndexes);
 
 class HistogramUniquifier {
  public:
   static const char* name() { return "Sqlite.AppCache.Error"; }
 };
 
 sql::ErrorDelegate* GetErrorHandlerForAppCacheDb() {
   return new sql::DiagnosticErrorDelegate<HistogramUniquifier>();
 }
 
+bool CreateTable(sql::Connection* db, const TableInfo& info) {
+  std::string sql("CREATE TABLE ");
+  sql += info.table_name;
+  sql += info.columns;
+  return db->Execute(sql.c_str());
+}
+
+bool CreateIndex(sql::Connection* db, const IndexInfo& info) {
+  std::string sql;
+  if (info.unique)
+    sql += "CREATE UNIQUE INDEX ";
+  else
+    sql += "CREATE INDEX ";
+  sql += info.index_name;
+  sql += " ON ";
+  sql += info.table_name;
+  sql += info.columns;
+  return db->Execute(sql.c_str());
+}
+
 }  // anon namespace
 
 // AppCacheDatabase ----------------------------------------------------------
 namespace appcache {
 
 AppCacheDatabase::GroupRecord::GroupRecord()
     : group_id(0) {
 }
 
 AppCacheDatabase::GroupRecord::~GroupRecord() {
 }
 
-AppCacheDatabase::FallbackNameSpaceRecord::FallbackNameSpaceRecord()
-    : cache_id(0) {
+AppCacheDatabase::NamespaceRecord::NamespaceRecord()
+    : cache_id(0), type(FALLBACK_NAMESPACE) {
 }
 
-AppCacheDatabase::FallbackNameSpaceRecord::~FallbackNameSpaceRecord() {
+AppCacheDatabase::NamespaceRecord::~NamespaceRecord() {
 }
 
+
 AppCacheDatabase::AppCacheDatabase(const FilePath& path)
     : db_file_path_(path), is_disabled_(false), is_recreating_(false) {
 }
 
 AppCacheDatabase::~AppCacheDatabase() {
 }
 
 void AppCacheDatabase::CloseConnection() {
   // We can't close the connection for an in-memory database w/o
   // losing all of the data, so we don't do that.
@@ skipping 474 matching lines @@
   sql::Statement statement;
   if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
     return false;
 
   statement.BindInt(0, additional_flags);
   statement.BindInt64(1, cache_id);
   statement.BindString(2, entry_url.spec());
   return statement.Run() && db_->GetLastChangeCount();
 }
 
-bool AppCacheDatabase::FindFallbackNameSpacesForOrigin(
-    const GURL& origin, std::vector<FallbackNameSpaceRecord>* records) {
-  DCHECK(records && records->empty());
+bool AppCacheDatabase::FindNamespacesForOrigin(
+    const GURL& origin,
+    std::vector<NamespaceRecord>* intercepts,
+    std::vector<NamespaceRecord>* fallbacks) {
+  DCHECK(intercepts && intercepts->empty());
+  DCHECK(fallbacks && fallbacks->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
-      "SELECT cache_id, origin, namespace_url, fallback_entry_url"
-      "  FROM FallbackNameSpaces WHERE origin = ?";
+      "SELECT cache_id, origin, type, namespace_url, target_url"
+      "  FROM Namespaces WHERE origin = ?";
 
   sql::Statement statement;
   if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
     return false;
 
   statement.BindString(0, origin.spec());
-  while (statement.Step()) {
-    records->push_back(FallbackNameSpaceRecord());
-    ReadFallbackNameSpaceRecord(statement, &records->back());
-    DCHECK(records->back().origin == origin);
-  }
+  ReadNamespaceRecords(&statement, intercepts, fallbacks);
   return statement.Succeeded();
 }
 
-bool AppCacheDatabase::FindFallbackNameSpacesForCache(
-    int64 cache_id, std::vector<FallbackNameSpaceRecord>* records) {
-  DCHECK(records && records->empty());
+bool AppCacheDatabase::FindNamespacesForCache(
+    int64 cache_id,
+    std::vector<NamespaceRecord>* intercepts,
+    std::vector<NamespaceRecord>* fallbacks) {
+  DCHECK(intercepts && intercepts->empty());
+  DCHECK(fallbacks && fallbacks->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
-      "SELECT cache_id, origin, namespace_url, fallback_entry_url"
-      "  FROM FallbackNameSpaces WHERE cache_id = ?";
+      "SELECT cache_id, origin, type, namespace_url, target_url"
+      "  FROM Namespaces WHERE cache_id = ?";
 
   sql::Statement statement;
   if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
     return false;
 
   statement.BindInt64(0, cache_id);
-  while (statement.Step()) {
-    records->push_back(FallbackNameSpaceRecord());
-    ReadFallbackNameSpaceRecord(statement, &records->back());
-    DCHECK(records->back().cache_id == cache_id);
-  }
+  ReadNamespaceRecords(&statement, intercepts, fallbacks);
   return statement.Succeeded();
 }
 
-bool AppCacheDatabase::InsertFallbackNameSpace(
-    const FallbackNameSpaceRecord* record) {
+bool AppCacheDatabase::InsertNamespace(
+    const NamespaceRecord* record) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
-      "INSERT INTO FallbackNameSpaces"
-      "  (cache_id, origin, namespace_url, fallback_entry_url)"
-      "  VALUES (?, ?, ?, ?)";
+      "INSERT INTO Namespaces"
+      "  (cache_id, origin, type, namespace_url, target_url)"
+      "  VALUES (?, ?, ?, ?, ?)";
 
   sql::Statement statement;
   if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
     return false;
 
   statement.BindInt64(0, record->cache_id);
   statement.BindString(1, record->origin.spec());
-  statement.BindString(2, record->namespace_url.spec());
-  statement.BindString(3, record->fallback_entry_url.spec());
+  statement.BindInt(2, record->type);
+  statement.BindString(3, record->namespace_url.spec());
+  statement.BindString(4, record->target_url.spec());
   return statement.Run();
 }
 
-bool AppCacheDatabase::InsertFallbackNameSpaceRecords(
-    const std::vector<FallbackNameSpaceRecord>& records) {
+bool AppCacheDatabase::InsertNamespaceRecords(
+    const std::vector<NamespaceRecord>& records) {
   if (records.empty())
     return true;
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
-  std::vector<FallbackNameSpaceRecord>::const_iterator iter = records.begin();
+  std::vector<NamespaceRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
-    if (!InsertFallbackNameSpace(&(*iter)))
+    if (!InsertNamespace(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
-bool AppCacheDatabase::DeleteFallbackNameSpacesForCache(int64 cache_id) {
+bool AppCacheDatabase::DeleteNamespacesForCache(int64 cache_id) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
-      "DELETE FROM FallbackNameSpaces WHERE cache_id = ?";
+      "DELETE FROM Namespaces WHERE cache_id = ?";
 
   sql::Statement statement;
   if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
     return false;
 
   statement.BindInt64(0, cache_id);
   return statement.Run();
 }
 
 bool AppCacheDatabase::FindOnlineWhiteListForCache(
@@ skipping 210 matching lines @@
 
 void AppCacheDatabase::ReadEntryRecord(
     const sql::Statement& statement, EntryRecord* record) {
   record->cache_id = statement.ColumnInt64(0);
   record->url = GURL(statement.ColumnString(1));
   record->flags = statement.ColumnInt(2);
   record->response_id = statement.ColumnInt64(3);
   record->response_size = statement.ColumnInt64(4);
 }
 
-void AppCacheDatabase::ReadFallbackNameSpaceRecord(
-    const sql::Statement& statement, FallbackNameSpaceRecord* record) {
-  record->cache_id = statement.ColumnInt64(0);
-  record->origin = GURL(statement.ColumnString(1));
-  record->namespace_url = GURL(statement.ColumnString(2));
-  record->fallback_entry_url = GURL(statement.ColumnString(3));
+void AppCacheDatabase::ReadNamespaceRecords(
+      sql::Statement* statement,
+      NamespaceRecordVector* intercepts,
+      NamespaceRecordVector* fallbacks) {
+  while (statement->Step()) {
+    NamespaceType type = static_cast<NamespaceType>(statement->ColumnInt(2));
+    NamespaceRecordVector* records =
+        (type == FALLBACK_NAMESPACE) ? fallbacks : intercepts;
+    records->push_back(NamespaceRecord());
+    ReadNamespaceRecord(statement, &records->back());
+  }
+}
+
+void AppCacheDatabase::ReadNamespaceRecord(
+    const sql::Statement* statement, NamespaceRecord* record) {
+  record->cache_id = statement->ColumnInt64(0);
+  record->origin = GURL(statement->ColumnString(1));
+  record->type = static_cast<NamespaceType>(statement->ColumnInt(2));
+  record->namespace_url = GURL(statement->ColumnString(3));
+  record->target_url = GURL(statement->ColumnString(4));
 }
 
 void AppCacheDatabase::ReadOnlineWhiteListRecord(
     const sql::Statement& statement, OnlineWhiteListRecord* record) {
   record->cache_id = statement.ColumnInt64(0);
   record->namespace_url = GURL(statement.ColumnString(1));
 }
 
 bool AppCacheDatabase::LazyOpen(bool create_if_needed) {
   if (db_.get())
@@ skipping 60 matching lines @@
   }
 
   if (meta_table_->GetVersionNumber() < kCurrentVersion)
     return UpgradeSchema();
 
 #ifndef NDEBUG
   DCHECK(sql::MetaTable::DoesTableExist(db_.get()));
   for (int i = 0; i < kTableCount; ++i) {
     DCHECK(db_->DoesTableExist(kTables[i].table_name));
   }
+  for (int i = 0; i < kIndexCount; ++i) {
+    DCHECK(db_->DoesIndexExist(kIndexes[i].index_name));
+  }
 #endif
 
   return true;
 }
 
 bool AppCacheDatabase::CreateSchema() {
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
 
   if (!meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion))
     return false;
 
   for (int i = 0; i < kTableCount; ++i) {
-    std::string sql("CREATE TABLE ");
-    sql += kTables[i].table_name;
-    sql += kTables[i].columns;
-    if (!db_->Execute(sql.c_str()))
+    if (!CreateTable(db_.get(), kTables[i]))
       return false;
   }
 
   for (int i = 0; i < kIndexCount; ++i) {
-    std::string sql;
-    if (kIndexes[i].unique)
-      sql += "CREATE UNIQUE INDEX ";
-    else
-      sql += "CREATE INDEX ";
-    sql += kIndexes[i].index_name;
-    sql += " ON ";
-    sql += kIndexes[i].table_name;
-    sql += kIndexes[i].columns;
-    if (!db_->Execute(sql.c_str()))
+    if (!CreateIndex(db_.get(), kIndexes[i]))
       return false;
   }
 
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::UpgradeSchema() {
-  // Upgrade logic goes here
+  if (meta_table_->GetVersionNumber() == 3) {
+    DCHECK_EQ(strcmp(kNamespacesTable, kTables[3].table_name), 0);
+    DCHECK_EQ(strcmp(kNamespacesTable, kIndexes[6].table_name), 0);
+    DCHECK_EQ(strcmp(kNamespacesTable, kIndexes[7].table_name), 0);
+    DCHECK_EQ(strcmp(kNamespacesTable, kIndexes[8].table_name), 0);
+
+    // Migrate from the old "FallbackNameSpaces" to the new "Namespaces" table.
+    sql::Transaction transaction(db_.get());
+    if (!transaction.Begin() ||
+        !CreateTable(db_.get(), kTables[3])) {
+      return false;
+    }
+
+    // Move data from the old table to the new table, setting the
+    // 'type' for all current records to the value for FALLBACK_NAMESPACE.
+    DCHECK_EQ(0, static_cast<int>(FALLBACK_NAMESPACE));
+    if (!db_->Execute(
+            "INSERT INTO Namespaces"
+            "  SELECT cache_id, origin, 0, namespace_url, fallback_entry_url"
+            "  FROM FallbackNameSpaces")) {
+      return false;
+    }
+
+    // Drop the old table, indexes on that table are also removed by this.
+    if (!db_->Execute("DROP TABLE FallbackNameSpaces"))
+      return false;
+
+    // Create new indexes.
+    if (!CreateIndex(db_.get(), kIndexes[6]) ||
+        !CreateIndex(db_.get(), kIndexes[7]) ||
+        !CreateIndex(db_.get(), kIndexes[8])) {
+      return false;
+    }
+
+    // Finally bump the version numbers and commit it.
+    meta_table_->SetVersionNumber(4);
+    meta_table_->SetCompatibleVersionNumber(4);
+    return transaction.Commit();
+  }
 
   // If there is no upgrade path for the version on disk to the current
   // version, nuke everything and start over.
   return DeleteExistingAndCreateNewDatabase();
 }
 
 void AppCacheDatabase::ResetConnectionAndTables() {
   meta_table_.reset();
   db_.reset();
 }
@@ skipping 18 matching lines @@
 
   // So we can't go recursive.
   if (is_recreating_)
     return false;
 
   AutoReset<bool> auto_reset(&is_recreating_, true);
   return LazyOpen(true);
 }
 
 }  // namespace appcache