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;
+const bool kCreateIfNeeded = true;
+const bool kDontCreate = false;
 
 // 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 162 matching lines @@
     return false;
   for (std::set<GURL>::const_iterator origin = origins.begin();
        origin != origins.end(); ++origin) {
     (*usage_map)[*origin] = GetOriginUsage(*origin);
   }
   return true;
 }
 
 bool AppCacheDatabase::FindOriginsWithGroups(std::set<GURL>* origins) {
   DCHECK(origins && origins->empty());
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT DISTINCT(origin) FROM Groups";
 
   sql::Statement statement(db_->GetUniqueStatement(kSql));
 
   while (statement.Step())
     origins->insert(GURL(statement.ColumnString(0)));
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindLastStorageIds(
     int64* last_group_id, int64* last_cache_id, int64* last_response_id,
     int64* last_deletable_response_rowid) {
   DCHECK(last_group_id && last_cache_id && last_response_id &&
          last_deletable_response_rowid);
 
   *last_group_id = 0;
   *last_cache_id = 0;
   *last_response_id = 0;
   *last_deletable_response_rowid = 0;
 
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
   const char* kMaxGroupIdSql = "SELECT MAX(group_id) FROM Groups";
   const char* kMaxCacheIdSql = "SELECT MAX(cache_id) FROM Caches";
   const char* kMaxResponseIdFromEntriesSql =
       "SELECT MAX(response_id) FROM Entries";
   const char* kMaxResponseIdFromDeletablesSql =
       "SELECT MAX(response_id) FROM DeletableResponseIds";
   const char* kMaxDeletableResponseRowIdSql =
       "SELECT MAX(rowid) FROM DeletableResponseIds";
@@ skipping 16 matching lines @@
   *last_group_id = max_group_id;
   *last_cache_id = max_cache_id;
   *last_response_id = std::max(max_response_id_from_entries,
                                max_response_id_from_deletables);
   *last_deletable_response_rowid = max_deletable_response_rowid;
   return true;
 }
 
 bool AppCacheDatabase::FindGroup(int64 group_id, GroupRecord* record) {
   DCHECK(record);
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  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))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  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))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  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))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  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) {
+  if (!LazyOpen(kCreateIfNeeded))
+    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(kDontCreate))
+    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))
+  if (!LazyOpen(kCreateIfNeeded))
     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))
+  if (!LazyOpen(kDontCreate))
     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) {
-  if (!LazyOpen(true))
+bool AppCacheDatabase::UpdateEvictionTimes(
+    int64 group_id,
+    base::Time last_full_update_check_time,
+    base::Time first_evictable_error_time) {
+  if (!LazyOpen(kCreateIfNeeded))
     return false;
 
-  const char* kSql =
-      "INSERT INTO Groups"
-      "  (group_id, origin, manifest_url, creation_time, last_access_time)"
-      "  VALUES(?, ?, ?, ?, ?)";
-
+  const char kSql[] =
+      "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))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
       " FROM Caches WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   if (!statement.Step())
     return false;
 
   ReadCacheRecord(statement, record);
   return true;
 }
 
 bool AppCacheDatabase::FindCacheForGroup(int64 group_id, CacheRecord* record) {
   DCHECK(record);
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
       "  FROM Caches WHERE group_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, group_id);
 
   if (!statement.Step())
     return false;
 
   ReadCacheRecord(statement, record);
@@ skipping 11 matching lines @@
   std::vector<GroupRecord>::const_iterator iter = group_records.begin();
   while (iter != group_records.end()) {
     if (FindCacheForGroup(iter->group_id, &cache_record))
       records->push_back(cache_record);
     ++iter;
   }
   return true;
 }
 
 bool AppCacheDatabase::InsertCache(const CacheRecord* record) {
-  if (!LazyOpen(true))
+  if (!LazyOpen(kCreateIfNeeded))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "INSERT INTO Caches (cache_id, group_id, online_wildcard,"
       "                    update_time, cache_size)"
       "  VALUES(?, ?, ?, ?, ?)";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindInt64(1, record->group_id);
   statement.BindBool(2, record->online_wildcard);
   statement.BindInt64(3, record->update_time.ToInternalValue());
   statement.BindInt64(4, record->cache_size);
 
   return statement.Run();
 }
 
 bool AppCacheDatabase::DeleteCache(int64 cache_id) {
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "DELETE FROM Caches WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   return statement.Run();
 }
 
 bool AppCacheDatabase::FindEntriesForCache(
     int64 cache_id, std::vector<EntryRecord>* records) {
   DCHECK(records && records->empty());
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
       "  WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   while (statement.Step()) {
     records->push_back(EntryRecord());
     ReadEntryRecord(statement, &records->back());
     DCHECK(records->back().cache_id == cache_id);
   }
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindEntriesForUrl(
     const GURL& url, std::vector<EntryRecord>* records) {
   DCHECK(records && records->empty());
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
       "  WHERE url = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, url.spec());
 
   while (statement.Step()) {
     records->push_back(EntryRecord());
     ReadEntryRecord(statement, &records->back());
     DCHECK(records->back().url == url);
   }
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindEntry(
     int64 cache_id, const GURL& url, EntryRecord* record) {
   DCHECK(record);
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
       "  WHERE cache_id = ? AND url = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
   statement.BindString(1, url.spec());
 
   if (!statement.Step())
     return false;
 
   ReadEntryRecord(statement, record);
   DCHECK(record->cache_id == cache_id);
   DCHECK(record->url == url);
   return true;
 }
 
 bool AppCacheDatabase::InsertEntry(const EntryRecord* record) {
-  if (!LazyOpen(true))
+  if (!LazyOpen(kCreateIfNeeded))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "INSERT INTO Entries (cache_id, url, flags, response_id, response_size)"
       "  VALUES(?, ?, ?, ?, ?)";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindString(1, record->url.spec());
   statement.BindInt(2, record->flags);
   statement.BindInt64(3, record->response_id);
   statement.BindInt64(4, record->response_size);
 
@@ skipping 10 matching lines @@
   std::vector<EntryRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertEntry(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::DeleteEntriesForCache(int64 cache_id) {
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "DELETE FROM Entries WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   return statement.Run();
 }
 
 bool AppCacheDatabase::AddEntryFlags(
     const GURL& entry_url, int64 cache_id, int additional_flags) {
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "UPDATE Entries SET flags = flags | ? WHERE cache_id = ? AND url = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt(0, additional_flags);
   statement.BindInt64(1, cache_id);
   statement.BindString(2, entry_url.spec());
 
   return statement.Run() && db_->GetLastChangeCount();
 }
 
 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))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT cache_id, origin, type, namespace_url, target_url, is_pattern"
       "  FROM Namespaces WHERE origin = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, origin.spec());
 
   ReadNamespaceRecords(&statement, intercepts, fallbacks);
 
   return statement.Succeeded();
 }
 
 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))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT cache_id, origin, type, namespace_url, target_url, is_pattern"
       "  FROM Namespaces WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   ReadNamespaceRecords(&statement, intercepts, fallbacks);
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::InsertNamespace(
     const NamespaceRecord* record) {
-  if (!LazyOpen(true))
+  if (!LazyOpen(kCreateIfNeeded))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "INSERT INTO Namespaces"
       "  (cache_id, origin, type, namespace_url, target_url, is_pattern)"
       "  VALUES (?, ?, ?, ?, ?, ?)";
 
   // Note: quick and dirty storage for the 'executable' bit w/o changing
   // schemas, we use the high bit of 'type' field.
   int type_with_executable_bit = record->namespace_.type;
   if (record->namespace_.is_executable) {
     type_with_executable_bit |= 0x8000000;
     DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 20 matching lines @@
   std::vector<NamespaceRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertNamespace(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::DeleteNamespacesForCache(int64 cache_id) {
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "DELETE FROM Namespaces WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   return statement.Run();
 }
 
 bool AppCacheDatabase::FindOnlineWhiteListForCache(
     int64 cache_id, std::vector<OnlineWhiteListRecord>* records) {
   DCHECK(records && records->empty());
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT cache_id, namespace_url, is_pattern FROM OnlineWhiteLists"
       "  WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   while (statement.Step()) {
     records->push_back(OnlineWhiteListRecord());
     this->ReadOnlineWhiteListRecord(statement, &records->back());
     DCHECK(records->back().cache_id == cache_id);
   }
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::InsertOnlineWhiteList(
     const OnlineWhiteListRecord* record) {
-  if (!LazyOpen(true))
+  if (!LazyOpen(kCreateIfNeeded))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "INSERT INTO OnlineWhiteLists (cache_id, namespace_url, is_pattern)"
       "  VALUES (?, ?, ?)";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindString(1, record->namespace_url.spec());
   statement.BindBool(2, record->is_pattern);
 
   return statement.Run();
 }
 
 bool AppCacheDatabase::InsertOnlineWhiteListRecords(
     const std::vector<OnlineWhiteListRecord>& records) {
   if (records.empty())
     return true;
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
   std::vector<OnlineWhiteListRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertOnlineWhiteList(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::DeleteOnlineWhiteListForCache(int64 cache_id) {
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "DELETE FROM OnlineWhiteLists WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   return statement.Run();
 }
 
 bool AppCacheDatabase::GetDeletableResponseIds(
     std::vector<int64>* response_ids, int64 max_rowid, int limit) {
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT response_id FROM DeletableResponseIds "
       "  WHERE rowid <= ?"
       "  LIMIT ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, max_rowid);
   statement.BindInt64(1, limit);
 
   while (statement.Step())
     response_ids->push_back(statement.ColumnInt64(0));
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::InsertDeletableResponseIds(
     const std::vector<int64>& response_ids) {
-  const char* kSql =
+  const char kSql[] =
       "INSERT INTO DeletableResponseIds (response_id) VALUES (?)";
   return RunCachedStatementWithIds(SQL_FROM_HERE, kSql, response_ids);
 }
 
 bool AppCacheDatabase::DeleteDeletableResponseIds(
     const std::vector<int64>& response_ids) {
-  const char* kSql =
+  const char kSql[] =
       "DELETE FROM DeletableResponseIds WHERE response_id = ?";
   return RunCachedStatementWithIds(SQL_FROM_HERE, kSql, response_ids);
 }
 
 bool AppCacheDatabase::RunCachedStatementWithIds(
     const sql::StatementID& statement_id, const char* sql,
     const std::vector<int64>& ids) {
   DCHECK(sql);
-  if (!LazyOpen(true))
+  if (!LazyOpen(kCreateIfNeeded))
     return false;
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
 
   sql::Statement statement(db_->GetCachedStatement(statement_id, sql));
 
   std::vector<int64>::const_iterator iter = ids.begin();
   while (iter != ids.end()) {
@@ skipping 16 matching lines @@
   }
   *result = statement.ColumnInt64(0);
   return true;
 }
 
 bool AppCacheDatabase::FindResponseIdsForCacheHelper(
     int64 cache_id, std::vector<int64>* ids_vector,
     std::set<int64>* ids_set) {
   DCHECK(ids_vector || ids_set);
   DCHECK(!(ids_vector && ids_set));
-  if (!LazyOpen(false))
+  if (!LazyOpen(kDontCreate))
     return false;
 
-  const char* kSql =
+  const char kSql[] =
       "SELECT response_id FROM Entries WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   statement.BindInt64(0, cache_id);
   while (statement.Step()) {
     int64 id = statement.ColumnInt64(0);
     if (ids_set)
       ids_set->insert(id);
     else
@@ skipping 11 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
+    // Versions 5 and 6 were pre-July 2015.
+    // Version 7 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 11 matching lines @@
     return false;
 
   if (!base::CreateDirectory(directory))
     return false;
 
   // So we can't go recursive.
   if (is_recreating_)
     return false;
 
   base::AutoReset<bool> auto_reset(&is_recreating_, true);
-  return LazyOpen(true);
+  return LazyOpen(kCreateIfNeeded);
 }
 
 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