[Sync] Use OnSingleDataTypeUnrecoverableError for all errors

components/sync_driver/non_ui_data_type_controller_unittest.cc

Index: components/sync_driver/non_ui_data_type_controller_unittest.cc
diff --git a/components/sync_driver/non_ui_data_type_controller_unittest.cc b/components/sync_driver/non_ui_data_type_controller_unittest.cc
index 021db4134e3e7a69934148441bc552dbb5763bff..875523db3921868bef9030e21934052d1128d7f3 100644
--- a/components/sync_driver/non_ui_data_type_controller_unittest.cc
+++ b/components/sync_driver/non_ui_data_type_controller_unittest.cc
@@ -96,12 +96,10 @@ class NonUIDataTypeControllerFake
       SyncApiComponentFactory* sync_factory,
       NonUIDataTypeControllerMock* mock,
       SharedChangeProcessor* change_processor,
-      const DisableTypeCallback& disable_callback,
       scoped_refptr<base::MessageLoopProxy> backend_loop)
       : NonUIDataTypeController(
           base::MessageLoopProxy::current(),
           base::Closure(),
-          disable_callback,
           sync_factory),
         blocked_(false),
         mock_(mock),
@@ -188,22 +186,17 @@ class NonUIDataTypeControllerFake
 class SyncNonUIDataTypeControllerTest : public testing::Test {
  public:
   SyncNonUIDataTypeControllerTest()
-      : backend_thread_("dbthread"),
-        disable_callback_invoked_(false) {}
+      : backend_thread_("dbthread") {}
 
   virtual void SetUp() OVERRIDE {
     backend_thread_.Start();
     change_processor_ = new SharedChangeProcessorMock();
     // All of these are refcounted, so don't need to be released.
     dtc_mock_ = new StrictMock<NonUIDataTypeControllerMock>();
-    DataTypeController::DisableTypeCallback disable_callback =
-        base::Bind(&SyncNonUIDataTypeControllerTest::DisableTypeCallback,
-                   base::Unretained(this));
     non_ui_dtc_ =
         new NonUIDataTypeControllerFake(NULL,
                                         dtc_mock_.get(),
                                         change_processor_,
-                                        disable_callback,
                                         backend_thread_.message_loop_proxy());
   }
 
@@ -271,12 +264,6 @@ class SyncNonUIDataTypeControllerTest : public testing::Test {
     done->Signal();
   }
 
-  void DisableTypeCallback(const tracked_objects::Location& location,
-                           const std::string& message) {
-    disable_callback_invoked_ = true;
-    non_ui_dtc_->Stop();
-  }
-
   base::MessageLoopForUI message_loop_;
   base::Thread backend_thread_;
 
@@ -288,8 +275,6 @@ class SyncNonUIDataTypeControllerTest : public testing::Test {
   scoped_refptr<NonUIDataTypeControllerMock> dtc_mock_;
   scoped_refptr<SharedChangeProcessorMock> change_processor_;
   scoped_ptr<syncer::SyncChangeProcessor> saved_change_processor_;
-
-  bool disable_callback_invoked_;
 };
 
 TEST_F(SyncNonUIDataTypeControllerTest, StartOk) {
@@ -496,7 +481,7 @@ TEST_F(SyncNonUIDataTypeControllerTest, StopStart) {
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
 }
 
-TEST_F(SyncNonUIDataTypeControllerTest, OnSingleDatatypeUnrecoverableError) {
+TEST_F(SyncNonUIDataTypeControllerTest, OnSingleDataTypeUnrecoverableError) {
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
@@ -507,12 +492,15 @@ TEST_F(SyncNonUIDataTypeControllerTest, OnSingleDatatypeUnrecoverableError) {
 
   testing::Mock::VerifyAndClearExpectations(&start_callback_);
   EXPECT_CALL(start_callback_, Run(DataTypeController::RUNTIME_ERROR, _, _));
+  syncer::SyncError error(FROM_HERE,
+                          syncer::SyncError::DATATYPE_ERROR,
+                          "error",
+                          non_ui_dtc_->type());
   backend_thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
       &NonUIDataTypeControllerFake::
-          OnSingleDatatypeUnrecoverableError,
+          OnSingleDataTypeUnrecoverableError,
       non_ui_dtc_.get(),
-      FROM_HERE,
-      std::string("Test")));
+      error));
   WaitForDTC();
 }