[appcache] Don't write during startup.

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"
@@ skipping 192 matching lines @@
 
 
 AppCacheDatabase::AppCacheDatabase(const base::FilePath& path)
     : db_file_path_(path),
       is_disabled_(false),
       is_recreating_(false),
       was_corruption_detected_(false) {
 }
 
 AppCacheDatabase::~AppCacheDatabase() {
+  CommitLazyLastAccessTimes();
 }
 
 void AppCacheDatabase::Disable() {
   VLOG(1) << "Disabling appcache database.";
   is_disabled_ = true;
   ResetConnectionAndTables();
 }
 
 int64 AppCacheDatabase::GetOriginUsage(const GURL& origin) {
   std::vector<CacheRecord> records;
@@ skipping 162 matching lines @@
   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::UpdateGroupLastAccessTime(
+bool AppCacheDatabase::UpdateLastAccessTime(
     int64 group_id, base::Time time) {
   if (!LazyOpen(true))
     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() && db_->GetLastChangeCount();
+  return statement.Run();
+}
+
+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_) {
+    if (!UpdateLastAccessTime(pair.first, pair.second))
+      return false;
+  }
+  if (!transaction.Commit())

[cmumford, 2015/02/13 23:06:15]

If we fail to update or commit the last access times then does it make sense to
still keep this map around? won't it likely just fail again?

[michaeln, 2015/02/14 01:35:03]

Done, the method easier to read now too.

+    return false;
+
+  lazy_last_access_times_.clear();
+  return true;
 }
 
 bool AppCacheDatabase::InsertGroup(const GroupRecord* record) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
       "INSERT INTO Groups"
       "  (group_id, origin, manifest_url, creation_time, last_access_time)"
       "  VALUES(?, ?, ?, ?, ?)";
@@ skipping 499 matching lines @@
   return statement.Succeeded();
 }
 
 void AppCacheDatabase::ReadGroupRecord(
     const sql::Statement& statement, GroupRecord* record) {
   record->group_id = statement.ColumnInt64(0);
   record->origin = GURL(statement.ColumnString(1));
   record->manifest_url = GURL(statement.ColumnString(2));
   record->creation_time =
       base::Time::FromInternalValue(statement.ColumnInt64(3));
-  record->last_access_time =
-      base::Time::FromInternalValue(statement.ColumnInt64(4));
+
+  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));
+  }
 }
 
 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 280 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