Appcache::OnCorruptionDetected handling

webkit/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 "webkit/browser/appcache/appcache_database.h"
 
 #include "base/auto_reset.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "sql/connection.h"
+#include "sql/error_delegate_util.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "webkit/browser/appcache/appcache_entry.h"
 #include "webkit/browser/appcache/appcache_histograms.h"
 
 namespace appcache {
 
 // Schema -------------------------------------------------------------------
 namespace {
@@ skipping 170 matching lines @@
 
 AppCacheDatabase::NamespaceRecord::NamespaceRecord()
     : cache_id(0) {
 }
 
 AppCacheDatabase::NamespaceRecord::~NamespaceRecord() {
 }
 
 
 AppCacheDatabase::AppCacheDatabase(const base::FilePath& path)
-    : db_file_path_(path), is_disabled_(false), is_recreating_(false) {
+    : db_file_path_(path),
+      is_disabled_(false),
+      is_recreating_(false),
+      was_corruption_detected_(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.
   if (!db_file_path_.empty())
     ResetConnectionAndTables();
@@ skipping 815 matching lines @@
     // the existing appcache data and starting with a clean slate in
     // this browser session.
     if (!use_in_memory_db && DeleteExistingAndCreateNewDatabase())
       return true;
 
     Disable();
     return false;
   }
 
   AppCacheHistograms::CountInitResult(AppCacheHistograms::INIT_OK);
+  was_corruption_detected_ = false;
+  db_->set_error_callback(
+      base::Bind(&AppCacheDatabase::OnDatabaseError, base::Unretained(this)));
   return true;
 }
 
 bool AppCacheDatabase::EnsureDatabaseVersion() {
   if (!sql::MetaTable::DoesTableExist(db_.get()))
     return CreateSchema();
 
   if (!meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion))
     return false;
 
@@ skipping 139 matching lines @@
 
 bool AppCacheDatabase::DeleteExistingAndCreateNewDatabase() {
   DCHECK(!db_file_path_.empty());
   DCHECK(base::PathExists(db_file_path_));
   VLOG(1) << "Deleting existing appcache data and starting over.";
 
   ResetConnectionAndTables();
 
   // This also deletes the disk cache data.
   base::FilePath directory = db_file_path_.DirName();
-  if (!base::DeleteFile(directory, true) ||
-      !base::CreateDirectory(directory)) {
+  if (!base::DeleteFile(directory, true))
     return false;
-  }
 
   // Make sure the steps above actually deleted things.
-  if (base::PathExists(db_file_path_))
+  if (base::PathExists(directory))
+    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);
 }
 
+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 appcache