[sql] Serialize calls to sqlite3_initialize().

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 <string.h>
 
 #include "base/files/file_path.h"
 #include "base/file_util.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #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 "sql/statement.h"
 #include "third_party/sqlite/sqlite3.h"
 
 #if defined(OS_IOS) && defined(USE_SYSTEM_SQLITE)
 #include "third_party/sqlite/src/ext/icu/sqliteicu.h"
 #endif
 
 namespace {
 
 // Spin for up to a second waiting for the lock to clear when setting
@@ skipping 59 matching lines @@
 
   // If successful, exactly one page should have been backed up.  If
   // this breaks, check this function to make sure assumptions aren't
   // being broken.
   if (rc == SQLITE_DONE)
     DCHECK_EQ(pages, 1);
 
   return rc;
 }
 
+// SQLite automatically calls sqlite3_initialize() lazily, but
+// sqlite3_initialize() uses double-checked locking and thus can have
+// data races.
+//
+// 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());
+  sqlite3_initialize();
+}
+
 }  // namespace
 
 namespace sql {
 
 // static
 Connection::ErrorIgnorerCallback* Connection::current_ignorer_cb_ = NULL;
 
 // static
 bool Connection::ShouldIgnore(int error) {
   if (!current_ignorer_cb_)
@@ skipping 593 matching lines @@
 }
 
 bool Connection::OpenInternal(const std::string& file_name) {
   AssertIOAllowed();
 
   if (db_) {
     DLOG(FATAL) << "sql::Connection is already open.";
     return false;
   }
 
+  // Make sure sqlite3_initialize() is called before anything else.
+  InitializeSqlite();
+
   // 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_);
@@ skipping 179 matching lines @@
   }
 
   // Best effort to put things back as they were before.
   const char kNoWritableSchema[] = "PRAGMA writable_schema = OFF";
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 }  // namespace sql