[Sync] Update DirectoryBackingStore to detect Sync DB corruption

sync/syncable/directory_backing_store.h

 // 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.
 
 #ifndef SYNC_SYNCABLE_DIRECTORY_BACKING_STORE_H_
 #define SYNC_SYNCABLE_DIRECTORY_BACKING_STORE_H_
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 29 matching lines @@
 // not even two separate browser instances would be able to acquire it
 // simultaneously.
 //
 // This class is abstract so that we can extend it in interesting ways for use
 // in tests.  The concrete class used in non-test scenarios is
 // OnDiskDirectoryBackingStore.
 class SYNC_EXPORT_PRIVATE DirectoryBackingStore : public base::NonThreadSafe {
   friend class DirectoryBackingStoreTest;
   FRIEND_TEST_ALL_PREFIXES(DirectoryBackingStoreTest,
                            IncreaseDatabasePageSizeFrom4KTo32K);
+  FRIEND_TEST_ALL_PREFIXES(DirectoryBackingStoreTest,
+                           CatastrophicErrorHandler_KeptAcrossReset);
+  FRIEND_TEST_ALL_PREFIXES(DirectoryBackingStoreTest,
+                           CatastrophicErrorHandler_Invocation);
 
  public:
   explicit DirectoryBackingStore(const std::string& dir_name);
   virtual ~DirectoryBackingStore();
 
   // Loads and drops all currently persisted meta entries into |handles_map|
   // and loads appropriate persisted kernel info into |kernel_load_info|.
   // The function determines which entries can be safely dropped and inserts
   // their keys into |metahandles_to_purge|. It is up to the caller to
   // perform the actual cleanup.
   //
   // This function will migrate to the latest database version.
   //
   // NOTE: On success (return value of OPENED), the buckets are populated with
   // newly allocated items, meaning ownership is bestowed upon the caller.
   virtual DirOpenResult Load(Directory::MetahandlesMap* handles_map,
                              JournalIndex* delete_journals,
                              MetahandleSet* metahandles_to_purge,
                              Directory::KernelLoadInfo* kernel_load_info) = 0;
 
   // Updates the on-disk store with the input |snapshot| as a database
   // transaction.  Does NOT open any syncable transactions as this would cause
   // opening transactions elsewhere to block on synchronous I/O.
   // DO NOT CALL THIS FROM MORE THAN ONE THREAD EVER.  Also, whichever thread
   // calls SaveChanges *must* be the thread that owns/destroys |this|.
+  //
+  // Returns true if the changes were saved successfully. Returns false if an
+  // error (of any kind) occurred. See also |SetCatastrophicErrorHandler| for a
+  // systematic way of handling underlying DB errors.
   virtual bool SaveChanges(const Directory::SaveChangesSnapshot& snapshot);
 
+  // Set the catastrophic error handler.
+  //
+  // When a catastrophic error is encountered while accessing the underlying DB,
+  // |catastrophic_error_handler| will be invoked (via PostTask) on the thread
+  // on which this DirectoryBackingStore object lives.
+  //
+  // For a definition of what's catastrophic, see sql::IsErrorCatastrophic.
+  //
+  // |catastrophic_error_handler| must be initialized (i.e. !is_null()).
+  //
+  // A single operation (like Load or SaveChanges) may result in the
+  // |catastrophic_error_handler| being invoked several times.
+  //
+  // There can be at most one handler. If this method is invoked when there is
+  // already a handler, the existing handler is overwritten with
+  // |catastrophic_error_handler|.
+  virtual void SetCatastrophicErrorHandler(
+      const base::Closure& catastrophic_error_handler);
+
  protected:
   // For test classes.
   DirectoryBackingStore(const std::string& dir_name,
                         sql::Connection* connection);
 
   // General Directory initialization and load helpers.
   bool InitializeTables();
   bool CreateTables();
 
   // Create 'share_info' or 'temp_share_info' depending on value of
@@ skipping 112 matching lines @@
 
   const std::string dir_name_;
   const int database_page_size_;
   sql::Statement save_meta_statement_;
   sql::Statement save_delete_journal_statement_;
 
   // Set to true if migration left some old columns around that need to be
   // discarded.
   bool needs_column_refresh_;
 
+  // We keep a copy of the Closure so we reinstall it when the underlying
+  // sql::Connection is destroyed/recreated.
+  base::Closure catastrophic_error_handler_;
+
   DISALLOW_COPY_AND_ASSIGN(DirectoryBackingStore);
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif  // SYNC_SYNCABLE_DIRECTORY_BACKING_STORE_H_