Revert of [sqlite] sql::Recovery working under USE_SYSTEM_SQLITE.

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"
@@ skipping 80 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()) {
@@ skipping 80 matching lines @@
 
   // TODO(shess): If this is a common failure case, it might be
   // possible to fall back to a memory database.  But it probably
   // implies that the SQLite tmpdir logic is busted, which could cause
   // a variety of other random issues in our code.
   if (!recover_db_.OpenTemporary()) {
     RecordRecoveryEvent(RECOVERY_FAILED_OPEN_TEMPORARY);
     return false;
   }
 
-  // Enable the recover virtual table for this connection.
+  // 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