[sql] Experiment to enable smart-vacuum on Android.

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>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
+#include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 194 matching lines @@
 }
 
 std::string AsUTF8ForSQL(const base::FilePath& path) {
 #if defined(OS_WIN)
   return base::WideToUTF8(path.value());
 #elif defined(OS_POSIX)
   return path.value();
 #endif
 }
 
+// http://crbug.com/698010
+//
+// The feature enables a SQLite patch which causes SQLite to leverage
+// SQLITE_FCNTL_CHUNK_SIZE when making auto-vacuum decisions.  This should lower
+// write load (histogram Sqlite.Vfs_Write in vfs_wrapper.cc).  Only Android
+// enables auto-vacuum under Chromium.
+const base::Feature kSqliteSmartAutoVacuumEnabled{
+    "SqliteSmartAutoVacuum", base::FEATURE_DISABLED_BY_DEFAULT};
+
 }  // namespace
 
 namespace sql {
 
 // static
 Connection::ErrorExpecterCallback* Connection::current_expecter_cb_ = NULL;
 
 // static
 bool Connection::IsExpectedSqliteError(int error) {
   if (!current_expecter_cb_)
@@ skipping 1603 matching lines @@
   // databases (<20k) while other clients have a broad distribution of sizes
   // (hundreds of kilobytes to many megabytes).
   sqlite3_file* file = NULL;
   sqlite3_int64 db_size = 0;
   int rc = GetSqlite3FileAndSize(db_, &file, &db_size);
   if (rc == SQLITE_OK && db_size > 16 * 1024) {
     int chunk_size = 4 * 1024;
     if (db_size > 128 * 1024)
       chunk_size = 32 * 1024;
     sqlite3_file_control(db_, NULL, SQLITE_FCNTL_CHUNK_SIZE, &chunk_size);
+    if (base::FeatureList::IsEnabled(kSqliteSmartAutoVacuumEnabled)) {
+      int page_size = 0;
+      {
+        sql::Statement stmt(GetUniqueStatement("PRAGMA page_size"));
+        if (stmt.Step())
+          page_size = stmt.ColumnInt(0);
+        if (!page_size)
+          page_size = 1024;
+      }
+      std::string slack_sql = base::StringPrintf(
+          "PRAGMA auto_vacuum_slack_pages = %d", chunk_size / page_size);
+      ignore_result(Execute(slack_sql.c_str()));
+    }
   }
 
   // Enable memory-mapped access.  The explicit-disable case is because SQLite
   // can be built to default-enable mmap.  GetAppropriateMmapSize() calculates a
   // safe range to memory-map based on past regular I/O.  This value will be
   // capped by SQLITE_MAX_MMAP_SIZE, which could be different between 32-bit and
   // 64-bit platforms.
   size_t mmap_size = mmap_disabled_ ? 0 : GetAppropriateMmapSize();
   std::string mmap_sql =
       base::StringPrintf("PRAGMA mmap_size = %" PRIuS, mmap_size);
@@ skipping 191 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