[Sync] Remove backend unrecoverable error handler

sync/syncable/directory.cc

 // Copyright 2013 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.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/base64.h"
@@ skipping 85 matching lines @@
       transaction_observer(transaction_observer) {
   DCHECK(delegate);
   DCHECK(transaction_observer.IsInitialized());
 }
 
 Directory::Kernel::~Kernel() {
   STLDeleteContainerPairSecondPointers(metahandles_map.begin(),
                                        metahandles_map.end());
 }
 
-Directory::Directory(DirectoryBackingStore* store,
-                     UnrecoverableErrorHandler* unrecoverable_error_handler,
-                     const base::Closure& report_unrecoverable_error_function,
-                     NigoriHandler* nigori_handler,
-                     Cryptographer* cryptographer)
+Directory::Directory(
+    DirectoryBackingStore* store,
+    const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
+    const base::Closure& report_unrecoverable_error_function,
+    NigoriHandler* nigori_handler,
+    Cryptographer* cryptographer)
     : kernel_(NULL),
       store_(store),
       unrecoverable_error_handler_(unrecoverable_error_handler),
       report_unrecoverable_error_function_(report_unrecoverable_error_function),
       unrecoverable_error_set_(false),
       nigori_handler_(nigori_handler),
       cryptographer_(cryptographer),
       invariant_check_level_(VERIFY_CHANGES),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 Directory::~Directory() {
   Close();
 }
 
 DirOpenResult Directory::Open(
     const string& name,
     DirectoryChangeDelegate* delegate,
     const WeakHandle<TransactionObserver>& transaction_observer) {
   TRACE_EVENT0("sync", "SyncDatabaseOpen");
@@ skipping 93 matching lines @@
     delete kernel_;
     kernel_ = NULL;
   }
 }
 
 void Directory::OnUnrecoverableError(const BaseTransaction* trans,
                                      const tracked_objects::Location& location,
                                      const std::string & message) {
   DCHECK(trans != NULL);
   unrecoverable_error_set_ = true;
-  unrecoverable_error_handler_->OnUnrecoverableError(location,
-                                                     message);
+  unrecoverable_error_handler_.Call(
+      FROM_HERE, &UnrecoverableErrorHandler::OnUnrecoverableError, location,
+      message);
 }
 
 EntryKernel* Directory::GetEntryById(const Id& id) {
   ScopedKernelLock lock(this);
   return GetEntryById(lock, id);
 }
 
 EntryKernel* Directory::GetEntryById(const ScopedKernelLock& lock,
                                      const Id& id) {
   DCHECK(kernel_);
@@ skipping 1316 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer