[Sync] Update DirectoryBackingStore to detect Sync DB corruption

sync/syncable/directory_backing_store.cc

 // Copyright 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 "sync/syncable/directory_backing_store.h"
 
 #include "build/build_config.h"
 
 #include <limits>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "sql/connection.h"
+#include "sql/error_delegate_util.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/syncable-inl.h"
 #include "sync/syncable/syncable_columns.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/util/time.h"
 
 using std::string;
 
 namespace {
 
 bool IsSyncBackingDatabase32KEnabled() {
   const std::string group_name =
       base::FieldTrialList::FindFullName("SyncBackingDatabase32K");
   return group_name == "Enabled";
 }
 
+void OnSqliteError(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const base::Closure& catastrophic_error_handler,
+    int err,
+    sql::Statement* statement) {
+  // An error has been detected. Ignore unless it is catastrophic.
+  if (sql::IsErrorCatastrophic(err)) {
+    // At this point sql::* and DirectoryBackingStore may be on the callstack so
+    // don't invoke the error handler directly. Instead, PostTask to this thread
+    // to avoid potential reentrancy issues.
+    task_runner->PostTask(FROM_HERE, catastrophic_error_handler);

[Nicolas Zea, 2015/04/13 20:16:33]

nit: do you need the task runner? Can you just post to
base::MessageLoop::current()?

[maniscalco, 2015/04/14 17:44:14]

Good idea.  Done.

+  }
+}
+
 }  // namespace
 
 namespace syncer {
 namespace syncable {
 
 // This just has to be big enough to hold an UPDATE or INSERT statement that
 // modifies all the columns in the entry table.
 static const string::size_type kUpdateStatementBufferSize = 2048;
 
 // Increment this version whenever updating DB tables.
@@ skipping 129 matching lines @@
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // DirectoryBackingStore implementation.
 
 DirectoryBackingStore::DirectoryBackingStore(const string& dir_name)
     : dir_name_(dir_name),
       database_page_size_(IsSyncBackingDatabase32KEnabled() ? 32768 : 4096),
       needs_column_refresh_(false) {
+  DCHECK(base::ThreadTaskRunnerHandle::IsSet());
   ResetAndCreateConnection();
 }
 
 DirectoryBackingStore::DirectoryBackingStore(const string& dir_name,
                                              sql::Connection* db)
     : db_(db),
       dir_name_(dir_name),
       database_page_size_(IsSyncBackingDatabase32KEnabled() ? 32768 : 4096),
       needs_column_refresh_(false) {
+  DCHECK(base::ThreadTaskRunnerHandle::IsSet());
 }
 
 DirectoryBackingStore::~DirectoryBackingStore() {
 }
 
 bool DirectoryBackingStore::DeleteEntries(EntryTable from,
                                           const MetahandleSet& handles) {
   if (handles.empty())
     return true;
 
@@ skipping 1427 matching lines @@
 bool DirectoryBackingStore::needs_column_refresh() const {
   return needs_column_refresh_;
 }
 
 void DirectoryBackingStore::ResetAndCreateConnection() {
   db_.reset(new sql::Connection());
   db_->set_histogram_tag("SyncDirectory");
   db_->set_exclusive_locking();
   db_->set_cache_size(32);
   db_->set_page_size(database_page_size_);
+  if (!catastrophic_error_handler_.is_null())
+    SetCatastrophicErrorHandler(catastrophic_error_handler_);
+}
+
+void DirectoryBackingStore::SetCatastrophicErrorHandler(
+    const base::Closure& catastrophic_error_handler) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!catastrophic_error_handler.is_null());
+  catastrophic_error_handler_ = catastrophic_error_handler;
+  sql::Connection::ErrorCallback error_callback =
+      base::Bind(&OnSqliteError, base::ThreadTaskRunnerHandle::Get(),
+                 catastrophic_error_handler_);
+  db_->set_error_callback(error_callback);
 }
 
 }  // namespace syncable
 }  // namespace syncer