Finish removing query_helpers.*

chrome/browser/sync/syncable/directory_backing_store.cc

 // Copyright (c) 2009 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 "chrome/browser/sync/syncable/directory_backing_store.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
+#include <limits>
+
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable_columns.h"
 #include "chrome/browser/sync/util/crypto_helpers.h"
-#include "chrome/browser/sync/util/query_helpers.h"
 #include "chrome/common/sqlite_utils.h"
 #include "third_party/sqlite/preprocessed/sqlite3.h"
 
 // Sometimes threads contend on the DB lock itself, especially when one thread
 // is calling SaveChanges.  In the worst case scenario, the user can put his
 // laptop to sleep during db contention, and wake up the laptop days later, so
 // infinity seems like the best choice here.
 const int kDirectoryBackingStoreBusyTimeoutMs = std::numeric_limits<int>::max();
 
 using std::string;
@@ skipping 127 matching lines @@
     load_dbhandle_ = NULL;
   }
   if (NULL != save_dbhandle_) {
     sqlite3_close(save_dbhandle_);
     save_dbhandle_ = NULL;
   }
 }
 
 bool DirectoryBackingStore::OpenAndConfigureHandleHelper(
     sqlite3** handle) const {
-  if (SQLITE_OK == SqliteOpen(backing_filepath_, handle)) {
+  if (SQLITE_OK == OpenSqliteDb(backing_filepath_, handle)) {
+    sqlite3_busy_timeout(*handle, std::numeric_limits<int>::max());
+    {
+      SQLStatement statement;
+      statement.prepare(*handle, "PRAGMA fullfsync = 1");
+      if (SQLITE_DONE != statement.step()) {
+        LOG(FATAL) << sqlite3_errmsg(*handle);
+      }
+    }
+    {
+      SQLStatement statement;
+      statement.prepare(*handle, "PRAGMA synchronous = 2");
+      if (SQLITE_DONE != statement.step()) {
+        LOG(FATAL) << sqlite3_errmsg(*handle);
+      }
+    }
     sqlite3_busy_timeout(*handle, kDirectoryBackingStoreBusyTimeoutMs);
     RegisterPathNameCollate(*handle);
+#if defined(OS_WIN)
+    // Do not index this file. Scanning can occur every time we close the file,
+    // which causes long delays in SQLite's file locking.
+    const DWORD attrs = GetFileAttributes(backing_filepath_.value().c_str());
+    const BOOL attrs_set =
+      SetFileAttributes(backing_filepath_.value().c_str(),
+                        attrs | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED);
+#endif
 
     return true;
   }
   return false;
 }
 
 DirOpenResult DirectoryBackingStore::Load(MetahandlesIndex* entry_bucket,
     ExtendedAttributes* xattrs_bucket,
     Directory::KernelLoadInfo* kernel_load_info) {
   DCHECK(load_dbhandle_ == NULL);
@@ skipping 400 matching lines @@
 
 sqlite3* DirectoryBackingStore::LazyGetSaveHandle() {
   if (!save_dbhandle_ && !OpenAndConfigureHandleHelper(&save_dbhandle_)) {
     DCHECK(FALSE) << "Unable to open handle for saving";
     return NULL;
   }
   return save_dbhandle_;
 }
 
 }  // namespace syncable