Expire appcaches that fail to update for "too long".

content/browser/appcache/appcache_database.cc

 // Copyright (c) 2012 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 "content/browser/appcache/appcache_database.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "sql/connection.h"
 #include "sql/error_delegate_util.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 namespace content {
 
 // Schema -------------------------------------------------------------------
 namespace {
 
-#if defined(APPCACHE_USE_SIMPLE_CACHE)
-const int kCurrentVersion = 6;
-const int kCompatibleVersion = 6;
-#else
-const int kCurrentVersion = 5;
-const int kCompatibleVersion = 5;
-#endif
+const int kCurrentVersion = 7;
+const int kCompatibleVersion = 7;
 
 // A mechanism to run experiments that may affect in data being persisted
 // in different ways such that when the experiment is toggled on/off via
 // cmd line flags, the database gets reset. The active flags are stored at
 // the time of database creation and compared when reopening. If different
 // the database is reset.
 const char kExperimentFlagsKey[] = "ExperimentFlags";
 
 const char kGroupsTable[] = "Groups";
 const char kCachesTable[] = "Caches";
@@ skipping 13 matching lines @@
   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)" },
+    " last_access_time INTEGER,"
+    " last_full_update_check_time INTEGER,"
+    " first_evictable_error_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,"
@@ skipping 229 matching lines @@
   return true;
 }
 
 bool AppCacheDatabase::FindGroup(int64 group_id, GroupRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT group_id, origin, manifest_url,"
-      "       creation_time, last_access_time"
+      "       creation_time, last_access_time,"
+      "       last_full_update_check_time,"
+      "       first_evictable_error_time"
       "  FROM Groups WHERE group_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   statement.BindInt64(0, group_id);
   if (!statement.Step())
     return false;
 
   ReadGroupRecord(statement, record);
   DCHECK(record->group_id == group_id);
   return true;
 }
 
 bool AppCacheDatabase::FindGroupForManifestUrl(
     const GURL& manifest_url, GroupRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT group_id, origin, manifest_url,"
-      "       creation_time, last_access_time"
+      "       creation_time, last_access_time,"
+      "       last_full_update_check_time,"
+      "       first_evictable_error_time"
       "  FROM Groups WHERE manifest_url = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, manifest_url.spec());
 
   if (!statement.Step())
     return false;
 
   ReadGroupRecord(statement, record);
   DCHECK(record->manifest_url == manifest_url);
   return true;
 }
 
 bool AppCacheDatabase::FindGroupsForOrigin(
     const GURL& origin, std::vector<GroupRecord>* records) {
   DCHECK(records && records->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT group_id, origin, manifest_url,"
-      "       creation_time, last_access_time"
+      "       creation_time, last_access_time,"
+      "       last_full_update_check_time,"
+      "       first_evictable_error_time"
       "   FROM Groups WHERE origin = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, origin.spec());
 
   while (statement.Step()) {
     records->push_back(GroupRecord());
     ReadGroupRecord(statement, &records->back());
     DCHECK(records->back().origin == origin);
   }
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindGroupForCache(int64 cache_id, GroupRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT g.group_id, g.origin, g.manifest_url,"
-      "       g.creation_time, g.last_access_time"
+      "       g.creation_time, g.last_access_time,"
+      "       g.last_full_update_check_time,"
+      "       g.first_evictable_error_time"
       "  FROM Groups g, Caches c"
       "  WHERE c.cache_id = ? AND c.group_id = g.group_id";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   if (!statement.Step())
     return false;
 
   ReadGroupRecord(statement, record);
   return true;
 }
 
+bool AppCacheDatabase::InsertGroup(const GroupRecord* record) {

[palmer, 2015/06/01 21:09:02]

Nit: I normally think to use a const reference, rather than pointer, for uses
like this.

[michaeln, 2015/06/19 21:38:19]

You're right!?

This is an existing method (it only shows up here as fully green because I
rearranged the order of the method bodies to match the order in the .h file) and
I'd rather not change the method signature in this CL.

+  if (!LazyOpen(true))
+    return false;
+
+  const char* kSql =
+      "INSERT INTO Groups"
+      "  (group_id, origin, manifest_url, creation_time, last_access_time,"
+      "   last_full_update_check_time, first_evictable_error_time)"
+      "  VALUES(?, ?, ?, ?, ?, ?, ?)";
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, record->group_id);
+  statement.BindString(1, record->origin.spec());
+  statement.BindString(2, record->manifest_url.spec());
+  statement.BindInt64(3, record->creation_time.ToInternalValue());
+  statement.BindInt64(4, record->last_access_time.ToInternalValue());
+  statement.BindInt64(5, record->last_full_update_check_time.ToInternalValue());
+  statement.BindInt64(6, record->first_evictable_error_time.ToInternalValue());
+  return statement.Run();
+}
+
+bool AppCacheDatabase::DeleteGroup(int64 group_id) {
+  if (!LazyOpen(false))
+    return false;
+
+  const char* kSql =
+      "DELETE FROM Groups WHERE group_id = ?";
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, group_id);
+  return statement.Run();
+}
+
 bool AppCacheDatabase::UpdateLastAccessTime(
     int64 group_id, base::Time time) {
-  if (!LazyOpen(true))
+  if (!LazyUpdateLastAccessTime(group_id, time))
     return false;
-
-  const char* kSql =
-      "UPDATE Groups SET last_access_time = ? WHERE group_id = ?";
-
-  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
-  statement.BindInt64(0, time.ToInternalValue());
-  statement.BindInt64(1, group_id);
-
-  return statement.Run();
+  return CommitLazyLastAccessTimes();
 }
 
 bool AppCacheDatabase::LazyUpdateLastAccessTime(
     int64 group_id, base::Time time) {
   if (!LazyOpen(true))
     return false;
   lazy_last_access_times_[group_id] = time;
   return true;
 }
 
 bool AppCacheDatabase::CommitLazyLastAccessTimes() {
   if (lazy_last_access_times_.empty())
     return true;
   if (!LazyOpen(false))
     return false;
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
-  for (const auto& pair : lazy_last_access_times_)
-    UpdateLastAccessTime(pair.first, pair.second);
+  for (const auto& pair : lazy_last_access_times_) {
+    const char* kSql =
+        "UPDATE Groups SET last_access_time = ? WHERE group_id = ?";
+    sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+    statement.BindInt64(0, pair.second.ToInternalValue());  // time
+    statement.BindInt64(1, pair.first);  // group_id
+    statement.Run();
+  }
   lazy_last_access_times_.clear();
   return transaction.Commit();
 }
 
-bool AppCacheDatabase::InsertGroup(const GroupRecord* record) {
+bool AppCacheDatabase::UpdateEvictionTimes(
+    int64 group_id,
+    base::Time last_full_update_check_time,
+    base::Time first_evictable_error_time) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
-      "INSERT INTO Groups"
-      "  (group_id, origin, manifest_url, creation_time, last_access_time)"
-      "  VALUES(?, ?, ?, ?, ?)";
-
+      "UPDATE Groups"
+      " SET last_full_update_check_time = ?, first_evictable_error_time = ?"
+      " WHERE group_id = ?";
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
-  statement.BindInt64(0, record->group_id);
-  statement.BindString(1, record->origin.spec());
-  statement.BindString(2, record->manifest_url.spec());
-  statement.BindInt64(3, record->creation_time.ToInternalValue());
-  statement.BindInt64(4, record->last_access_time.ToInternalValue());
-
-  return statement.Run();
-}
-
-bool AppCacheDatabase::DeleteGroup(int64 group_id) {
-  if (!LazyOpen(false))
-    return false;
-
-  const char* kSql =
-      "DELETE FROM Groups WHERE group_id = ?";
-
-  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
-  statement.BindInt64(0, group_id);
-
-  return statement.Run();
+  statement.BindInt64(0, last_full_update_check_time.ToInternalValue());
+  statement.BindInt64(1, first_evictable_error_time.ToInternalValue());
+  statement.BindInt64(2, group_id);
+  return statement.Run();  // Will succeed even if group_id is invalid.
 }
 
 bool AppCacheDatabase::FindCache(int64 cache_id, CacheRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
       " FROM Caches WHERE cache_id = ?";
@@ skipping 475 matching lines @@
   record->creation_time =
       base::Time::FromInternalValue(statement.ColumnInt64(3));
 
   const auto found = lazy_last_access_times_.find(record->group_id);
   if (found != lazy_last_access_times_.end()) {
     record->last_access_time = found->second;
   } else {
     record->last_access_time =
         base::Time::FromInternalValue(statement.ColumnInt64(4));
   }
+
+  record->last_full_update_check_time =
+      base::Time::FromInternalValue(statement.ColumnInt64(5));
+  record->first_evictable_error_time =
+      base::Time::FromInternalValue(statement.ColumnInt64(6));
 }
 
 void AppCacheDatabase::ReadCacheRecord(
     const sql::Statement& statement, CacheRecord* record) {
   record->cache_id = statement.ColumnInt64(0);
   record->group_id = statement.ColumnInt64(1);
   record->online_wildcard = statement.ColumnBool(2);
   record->update_time =
       base::Time::FromInternalValue(statement.ColumnInt64(3));
   record->cache_size = statement.ColumnInt64(4);
@@ skipping 158 matching lines @@
   for (int i = 0; i < kIndexCount; ++i) {
     if (!CreateIndex(db_.get(), kIndexes[i]))
       return false;
   }
 
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::UpgradeSchema() {
 #if defined(APPCACHE_USE_SIMPLE_CACHE)
-  return DeleteExistingAndCreateNewDatabase();
-#else
+  if (meta_table_->GetVersionNumber() < 6)
+    return DeleteExistingAndCreateNewDatabase();
+#endif
   if (meta_table_->GetVersionNumber() == 3) {
     // version 3 was pre 12/17/2011
     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);
 
     const TableInfo kNamespaceTable_v4 = {
         kNamespacesTable,
         "(cache_id INTEGER,"
@@ skipping 51 matching lines @@
             "  is_pattern INTEGER CHECK(is_pattern IN (0, 1))")) {
       return false;
     }
     if (!db_->Execute(
             "ALTER TABLE OnlineWhitelists ADD COLUMN"
             "  is_pattern INTEGER CHECK(is_pattern IN (0, 1))")) {
       return false;
     }
     meta_table_->SetVersionNumber(5);
     meta_table_->SetCompatibleVersionNumber(5);
+    if (!transaction.Commit())
+      return false;
+  }
+
+#if defined(APPCACHE_USE_SIMPLE_CACHE)
+  // The schema version number was increased to 6 when we switched to the
+  // SimpleCache for Android, but the SQL part of the schema is identical
+  // to v5 on desktop chrome.
+  if (meta_table_->GetVersionNumber() == 6) {
+#else
+  if (meta_table_->GetVersionNumber() == 5) {
+#endif
+    // version [5,6] was pre May 2015

[palmer, 2015/06/01 21:09:02]

Nit: Punctuation, et c.

// Versions 5 and 6 were pre-May 2015. Version 7 adds support for expiring
// caches that are failing to update.

[michaeln, 2015/06/19 21:38:19]

Done.

+    // v7 Adds support for expiring caches that are failing to update.
+    sql::Transaction transaction(db_.get());
+    if (!transaction.Begin() ||
+        !db_->Execute(
+            "ALTER TABLE Groups ADD COLUMN"
+            " last_full_update_check_time INTEGER") ||
+        !db_->Execute(
+            "ALTER TABLE Groups ADD COLUMN"
+            " first_evictable_error_time INTEGER") ||
+        !db_->Execute(
+            "UPDATE Groups"
+            " SET last_full_update_check_time ="
+            "   (SELECT update_time FROM Caches"
+            "    WHERE Caches.group_id = Groups.group_id)")) {
+      return false;
+    }
+    meta_table_->SetVersionNumber(7);
+    meta_table_->SetCompatibleVersionNumber(7);
     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();
-#endif
 }
 
 void AppCacheDatabase::ResetConnectionAndTables() {
   meta_table_.reset();
   db_.reset();
 }
 
 bool AppCacheDatabase::DeleteExistingAndCreateNewDatabase() {
   DCHECK(!db_file_path_.empty());
   DCHECK(base::PathExists(db_file_path_));
@@ skipping 22 matching lines @@
 }
 
 void AppCacheDatabase::OnDatabaseError(int err, sql::Statement* stmt) {
   was_corruption_detected_ |= sql::IsErrorCatastrophic(err);
   if (!db_->ShouldIgnoreSqliteError(err))
     DLOG(ERROR) << db_->GetErrorMessage();
   // TODO: Maybe use non-catostrophic errors to trigger a full integrity check?
 }
 
 }  // namespace content