[sql] Move time-machine support from third_party/sqlite to sql/

sql/connection.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 "sql/connection.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ skipping 15 matching lines @@
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "sql/connection_memory_dump_provider.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
+#include "sql/vfs_wrapper.h"
 #include "third_party/sqlite/sqlite3.h"
 
 #if defined(OS_IOS) && defined(USE_SYSTEM_SQLITE)
 #include "base/ios/ios_util.h"
 #include "third_party/sqlite/src/ext/icu/sqliteicu.h"
 #endif
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+#include <CoreFoundation/CoreFoundation.h>
+#include <CoreServices/CoreServices.h>
+#endif
+
 namespace {
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+void gross() {
+  CFPreferencesSetAppValue(CFSTR("CSBackupDebugLogging"),
+                           kCFBooleanTrue,
+                           kCFPreferencesCurrentApplication);
+}
+#else
+void gross() {
+}
+#endif
+
 // Spin for up to a second waiting for the lock to clear when setting
 // up the database.
 // TODO(shess): Better story on this.  http://crbug.com/56559
 const int kBusyTimeoutSeconds = 1;
 
 class ScopedBusyTimeout {
  public:
   explicit ScopedBusyTimeout(sqlite3* db)
       : db_(db) {
   }
@@ skipping 97 matching lines @@
 //
 // TODO(shess): Another alternative would be to have
 // sqlite3_initialize() called as part of process bring-up.  If this
 // is changed, remove the dynamic_annotations dependency in sql.gyp.
 base::LazyInstance<base::Lock>::Leaky
     g_sqlite_init_lock = LAZY_INSTANCE_INITIALIZER;
 void InitializeSqlite() {
   base::AutoLock lock(g_sqlite_init_lock.Get());
   static bool first_call = true;
   if (first_call) {
+    gross();
     sqlite3_initialize();
 
     // Schedule callback to record memory footprint histograms at 10m, 1h, and
     // 1d. There may not be a registered thread task runner in tests.
     if (base::ThreadTaskRunnerHandle::IsSet()) {
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE, base::Bind(&RecordSqliteMemory10Min),
           base::TimeDelta::FromMinutes(10));
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE, base::Bind(&RecordSqliteMemoryHour),
@@ skipping 1511 matching lines @@
 
   // If |poisoned_| is set, it means an error handler called
   // RazeAndClose().  Until regular Close() is called, the caller
   // should be treating the database as open, but is_open() currently
   // only considers the sqlite3 handle's state.
   // TODO(shess): Revise is_open() to consider poisoned_, and review
   // to see if any non-testing code even depends on it.
   DLOG_IF(FATAL, poisoned_) << "sql::Connection is already open.";
   poisoned_ = false;
 
-  int err = sqlite3_open(file_name.c_str(), &db_);
+  // Custom memory-mapping VFS which reads pages using regular I/O on first hit.
+  sqlite3_vfs* vfs = VFSWrapper();
+  const char* vfs_name = (vfs ? vfs->zName : NULL);
+  int err = sqlite3_open_v2(file_name.c_str(), &db_,
+                            SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+                            vfs_name);
   if (err != SQLITE_OK) {
     // Extended error codes cannot be enabled until a handle is
     // available, fetch manually.
     err = sqlite3_extended_errcode(db_);
 
     // Histogram failures specific to initial open for debugging
     // purposes.
     UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.OpenFailure", err);
 
     OnSqliteError(err, NULL, "-- sqlite3_open()");
@@ skipping 344 matching lines @@
                                    const std::string& dump_name) {
   return memory_dump_provider_ &&
          memory_dump_provider_->ReportMemoryUsage(pmd, dump_name);
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql