[Sync] Remove backend unrecoverable error handler

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/run_loop.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"
 
@@ skipping 49 matching lines @@
 void SyncableDirectoryTest::TearDown() {
   if (dir_)
     dir_->SaveChanges();
   dir_.reset();
 }
 
 DirOpenResult SyncableDirectoryTest::ReopenDirectory() {
   // Use a TestDirectoryBackingStore and sql::Connection so we can have test
   // data persist across Directory object lifetimes while getting the
   // performance benefits of not writing to disk.
-  dir_.reset(
-      new Directory(new TestDirectoryBackingStore(kDirectoryName, &connection_),
-                    &handler_, base::Closure(), NULL, NULL));
+  dir_.reset(new Directory(
+      new TestDirectoryBackingStore(kDirectoryName, &connection_),
+      MakeWeakHandle(handler_.GetWeakPtr()), base::Closure(), NULL, NULL));
 
   DirOpenResult open_result =
       dir_->Open(kDirectoryName, &delegate_, NullTransactionObserver());
 
   if (open_result != OPENED) {
     dir_.reset();
   }
 
   return open_result;
 }
@@ skipping 108 matching lines @@
 }
 
 DirectoryChangeDelegate* SyncableDirectoryTest::directory_change_delegate() {
   return &delegate_;
 }
 
 Encryptor* SyncableDirectoryTest::encryptor() {
   return &encryptor_;
 }
 
-UnrecoverableErrorHandler*
+
+TestUnrecoverableErrorHandler*
 SyncableDirectoryTest::unrecoverable_error_handler() {
   return &handler_;
 }
 
 void SyncableDirectoryTest::ValidateEntry(BaseTransaction* trans,
                                           int64 id,
                                           bool check_name,
                                           const std::string& name,
                                           int64 base_version,
                                           int64 server_version,
@@ skipping 1812 matching lines @@
   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, base::Closure(), nullptr,
-                nullptr);
+                MakeWeakHandle(unrecoverable_error_handler.GetWeakPtr()),
+                base::Closure(), 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. Call it twice to ensure Directory is
   // tolerant of multiple invocations since that may happen in the real world.
   dir.OnCatastrophicError();
   dir.OnCatastrophicError();
 
+  base::RunLoop().RunUntilIdle();
+
   // See that the unrecoverable error handler has been invoked twice.
   ASSERT_EQ(2, unrecoverable_error_handler.invocation_count());
 }
 
 bool EntitySpecificsValuesAreSame(const sync_pb::EntitySpecifics& v1,
                                   const sync_pb::EntitySpecifics& v2) {
   return &v1 == &v2;
 }
 
 // Verifies that server and client specifics are shared when their values
@@ skipping 41 matching lines @@
   EXPECT_FALSE(EntitySpecificsValuesAreSame(item.GetServerSpecifics(),
                                             item.GetBaseServerSpecifics()));
   item.PutBaseServerSpecifics(specifics3);
   EXPECT_TRUE(EntitySpecificsValuesAreSame(item.GetServerSpecifics(),
                                            item.GetBaseServerSpecifics()));
 }
 
 }  // namespace syncable
 
 }  // namespace syncer