[Sync] Make generic non-frontend thread datatype controller.

chrome/browser/sync/glue/frontend_data_type_controller_unittest.cc

 // Copyright (c) 2011 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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/task.h"
@@ skipping 45 matching lines @@
             CreateBookmarkSyncComponents(sync_service_, this);
     model_associator_.reset(sync_components.model_associator);
     change_processor_.reset(sync_components.change_processor);
   }
 
   // We mock the following methods because their default implementations do
   // nothing, but we still want to make sure they're called appropriately.
   virtual bool StartModels() {
     return mock_->StartModels();
   }
-  virtual void CleanupState() {
-    mock_->CleanupState();
+  virtual void CleanUpState() {
+    mock_->CleanUpState();
   }
   virtual void RecordUnrecoverableError(
       const tracked_objects::Location& from_here,
       const std::string& message) {
     mock_->RecordUnrecoverableError(from_here, message);
   }
   virtual void RecordAssociationTime(base::TimeDelta time) {
     mock_->RecordAssociationTime(time);
   }
   virtual void RecordStartFailure(DataTypeController::StartResult result) {
@@ skipping 37 matching lines @@
         WillOnce(Return(true));
     EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
   }
 
   void SetActivateExpectations(DataTypeController::StartResult result) {
     EXPECT_CALL(service_, ActivateDataType(_, _));
     EXPECT_CALL(start_callback_, Run(result,_));
   }
 
   void SetStopExpectations() {
-    EXPECT_CALL(*dtc_mock_, CleanupState());
+    EXPECT_CALL(*dtc_mock_, CleanUpState());
     EXPECT_CALL(service_, DeactivateDataType(_, _));
     EXPECT_CALL(*model_associator_, DisassociateModels());
   }
 
   void SetStartFailExpectations(DataTypeController::StartResult result) {
-    EXPECT_CALL(*dtc_mock_, CleanupState());
+    EXPECT_CALL(*dtc_mock_, CleanUpState());
     EXPECT_CALL(*dtc_mock_, RecordStartFailure(result));
     EXPECT_CALL(start_callback_, Run(result,_));
   }
 
   MessageLoopForUI message_loop_;
   BrowserThread ui_thread_;
   scoped_refptr<FrontendDataTypeControllerFake> frontend_dtc_;
   scoped_ptr<ProfileSyncFactoryMock> profile_sync_factory_;
   scoped_refptr<FrontendDataTypeControllerMock> dtc_mock_;
   ProfileMock profile_;
@@ skipping 20 matching lines @@
       WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true)));
   EXPECT_CALL(*model_associator_, AssociateModels()).
       WillOnce(Return(true));
   EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
   SetActivateExpectations(DataTypeController::OK_FIRST_RUN);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
   frontend_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
   EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state());
 }
 
+TEST_F(FrontendDataTypeControllerTest, AbortDuringStartModels) {
+  EXPECT_CALL(*dtc_mock_, StartModels()).WillOnce(Return(false));
+  SetStartFailExpectations(DataTypeController::ABORTED);
+  EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
+  frontend_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
+  EXPECT_EQ(DataTypeController::MODEL_STARTING, frontend_dtc_->state());
+  frontend_dtc_->Stop();
+  EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
+}
+
 TEST_F(FrontendDataTypeControllerTest, StartAssociationFailed) {
   SetStartExpectations();
   EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()).
       WillOnce(Return(true));
   EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
   EXPECT_CALL(*model_associator_, AssociateModels()).
       WillOnce(Return(false));
   EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
   SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED);
@@ skipping 26 matching lines @@
   EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
   frontend_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
   EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
 }
 
 TEST_F(FrontendDataTypeControllerTest, Stop) {
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
   SetStopExpectations();
-
   EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
   frontend_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
   EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state());
   frontend_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
 }
 
 TEST_F(FrontendDataTypeControllerTest, OnUnrecoverableError) {
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
   EXPECT_CALL(*dtc_mock_, RecordUnrecoverableError(_, "Test"));
   EXPECT_CALL(service_, OnUnrecoverableError(_,_)).
       WillOnce(InvokeWithoutArgs(frontend_dtc_.get(),
                                  &FrontendDataTypeController::Stop));
   SetStopExpectations();
-
   EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
   frontend_dtc_->Start(NewCallback(&start_callback_, &StartCallback::Run));
   EXPECT_EQ(DataTypeController::RUNNING, frontend_dtc_->state());
   // This should cause frontend_dtc_->Stop() to be called.
   frontend_dtc_->OnUnrecoverableError(FROM_HERE, "Test");
   EXPECT_EQ(DataTypeController::NOT_RUNNING, frontend_dtc_->state());
 }