[sqlite] iOS running recover virtual table.

sql/recovery.cc

 // Copyright 2013 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 "sql/recovery.h"
 
 #include <stddef.h>
 
 #include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
+#include "third_party/sqlite/ext/recover.h"
 #include "third_party/sqlite/sqlite3.h"
 
 namespace sql {
 
 namespace {
 
 enum RecoveryEventType {
   // Init() completed successfully.
   RECOVERY_SUCCESS_INIT = 0,
 
@@ skipping 62 matching lines @@
 void RecordRecoveryEvent(RecoveryEventType recovery_event) {
   UMA_HISTOGRAM_ENUMERATION("Sqlite.RecoveryEvents",
                             recovery_event, RECOVERY_EVENT_MAX);
 }
 
 }  // namespace
 
 // static
 bool Recovery::FullRecoverySupported() {
   // TODO(shess): See comment in Init().
-#if defined(USE_SYSTEM_SQLITE)
-  return false;
-#else
   return true;
-#endif
 }
 
 // static
 scoped_ptr<Recovery> Recovery::Begin(
     Connection* connection,
     const base::FilePath& db_path) {
-  // Recovery is likely to be used in error handling.  Since recovery changes
-  // the state of the handle, protect against multiple layers attempting the
-  // same recovery.
-  if (!connection->is_open()) {
-    // Warn about API mis-use.
-    DLOG_IF(FATAL, !connection->poisoned_)
-        << "Illegal to recover with closed database";
+  if (!connection->is_open())
     return scoped_ptr<Recovery>();
-  }
 
   scoped_ptr<Recovery> r(new Recovery(connection));
   if (!r->Init(db_path)) {
     // TODO(shess): Should Init() failure result in Raze()?
     r->Shutdown(POISON);
     return scoped_ptr<Recovery>();
   }
 
   return r;
 }
@@ skipping 74 matching lines @@
 
   // TODO(shess): Figure out a story for USE_SYSTEM_SQLITE.  The
   // virtual table implementation relies on SQLite internals for some
   // types and functions, which could be copied inline to make it
   // standalone.  Or an alternate implementation could try to read
   // through errors entirely at the SQLite level.
   //
   // For now, defer to the caller.  The setup will succeed, but the
   // later CREATE VIRTUAL TABLE call will fail, at which point the
   // caller can fire Unrecoverable().
-#if !defined(USE_SYSTEM_SQLITE)
   int rc = recoverVtableInit(recover_db_.db_);
   if (rc != SQLITE_OK) {
     RecordRecoveryEvent(RECOVERY_FAILED_VIRTUAL_TABLE_INIT);
     LOG(ERROR) << "Failed to initialize recover module: "
                << recover_db_.GetErrorMessage();
     return false;
   }
-#else
-  // If this is infrequent enough, just wire it to Raze().
-  RecordRecoveryEvent(RECOVERY_FAILED_VIRTUAL_TABLE_SYSTEM_SQLITE);
-#endif
 
   // Turn on |SQLITE_RecoveryMode| for the handle, which allows
   // reading certain broken databases.
   if (!recover_db_.Execute("PRAGMA writable_schema=1")) {
     RecordRecoveryEvent(RECOVERY_FAILED_WRITABLE_SCHEMA);
     return false;
   }
 
   if (!recover_db_.AttachDatabase(db_path, "corrupt")) {
     RecordRecoveryEvent(RECOVERY_FAILED_ATTACH);
@@ skipping 283 matching lines @@
     }
     return false;
   }
 
   RecordRecoveryEvent(RECOVERY_SUCCESS_META_VERSION);
   *version = recovery_version.ColumnInt(0);
   return true;
 }
 
 }  // namespace sql