[Sync] Erase sync DB when corrupted

sync/syncable/directory_unittest.cc

 // Copyright 2014 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_unittest.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/test/values_test_util.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/test_syncable_utils.h"
 #include "sync/test/test_directory_backing_store.h"
+#include "sync/util/mock_unrecoverable_error_handler.h"
 
 using base::ExpectDictBooleanValue;
 using base::ExpectDictStringValue;
 
 namespace syncer {
 
 namespace syncable {
 
 namespace {
 
@@ skipping 1998 matching lines @@
   snapshot.delete_journals.insert(&kernel);
   EXPECT_TRUE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.delete_journals.clear();
 
   EXPECT_FALSE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.delete_journals_to_purge.insert(1);
   EXPECT_TRUE(snapshot.HasUnsavedMetahandleChanges());
   snapshot.delete_journals_to_purge.clear();
 }
 
+// Verify that Directory triggers an unrecoverable error when a catastrophic
+// DirectoryBackingStore error is detected.
+TEST_F(SyncableDirectoryTest, CatastrophicError) {
+  MockUnrecoverableErrorHandler unrecoverable_error_handler;
+  Directory dir(new InMemoryDirectoryBackingStore("catastrophic_error"),
+                &unrecoverable_error_handler, nullptr, nullptr, nullptr);
+  ASSERT_EQ(OPENED, dir.Open(kDirectoryName, directory_change_delegate(),
+                             NullTransactionObserver()));
+  ASSERT_EQ(0, unrecoverable_error_handler.invocation_count());
+
+  // Fire off two catastrophic errors.
+  dir.OnCatastrophicError();

[Nicolas Zea, 2015/04/27 19:17:32]

out of curiosity, why twice?

[maniscalco, 2015/04/27 19:51:17]

Just to make sure Directory can tolerate since that can happen outside of tests.
 I've added a comment to clarify.

+  dir.OnCatastrophicError();
+
+  // See that the unrecoverable error handler has been invoked twice.
+  ASSERT_EQ(2, unrecoverable_error_handler.invocation_count());
+}
+
 }  // namespace syncable
 
 }  // namespace syncer