#include "base/synchronization/waitable_event.h"
#include "base/test/test_timeouts.h"
#include "base/tracked_objects.h"
-#include "chrome/browser/sync/glue/change_processor_mock.h"
-#include "chrome/browser/sync/glue/data_type_controller_mock.h"
-#include "chrome/browser/sync/glue/model_associator_mock.h"
#include "chrome/browser/sync/glue/non_frontend_data_type_controller.h"
#include "chrome/browser/sync/glue/non_frontend_data_type_controller_mock.h"
#include "chrome/browser/sync/profile_sync_components_factory_mock.h"
#include "chrome/browser/sync/profile_sync_service_mock.h"
#include "chrome/test/base/profile_mock.h"
+#include "components/sync_driver/change_processor_mock.h"
+#include "components/sync_driver/data_type_controller_mock.h"
+#include "components/sync_driver/model_associator_mock.h"
#include "content/public/test/test_browser_thread.h"
#include "sync/internal_api/public/engine/model_safe_worker.h"
using base::WaitableEvent;
-using browser_sync::ChangeProcessorMock;
-using browser_sync::DataTypeController;
using syncer::GROUP_DB;
using browser_sync::NonFrontendDataTypeController;
using browser_sync::NonFrontendDataTypeControllerMock;
-using browser_sync::ModelAssociatorMock;
-using browser_sync::ModelLoadCallbackMock;
-using browser_sync::StartCallbackMock;
+using sync_driver::ChangeProcessorMock;
+using sync_driver::DataTypeController;
+using sync_driver::ModelAssociatorMock;
+using sync_driver::ModelLoadCallbackMock;
+using sync_driver::StartCallbackMock;
using content::BrowserThread;
using testing::_;
using testing::DoAll;
Profile* profile,
ProfileSyncService* sync_service,
NonFrontendDataTypeControllerMock* mock)
- : NonFrontendDataTypeController(profile_sync_factory,
+ : NonFrontendDataTypeController(base::MessageLoopProxy::current(),
+ base::Closure(),
+ profile_sync_factory,
profile,
sync_service),
mock_(mock) {}
- virtual syncer::ModelType type() const OVERRIDE { return syncer::BOOKMARKS; }
- virtual syncer::ModelSafeGroup model_safe_group() const OVERRIDE {
+ syncer::ModelType type() const override { return syncer::BOOKMARKS; }
+ syncer::ModelSafeGroup model_safe_group() const override {
return syncer::GROUP_DB;
}
private:
- virtual ~NonFrontendDataTypeControllerFake() {}
+ ~NonFrontendDataTypeControllerFake() override {}
- virtual ProfileSyncComponentsFactory::SyncComponents
- CreateSyncComponents() OVERRIDE {
+ ProfileSyncComponentsFactory::SyncComponents CreateSyncComponents() override {
return profile_sync_factory()->
CreateBookmarkSyncComponents(profile_sync_service(), this);
}
- virtual bool PostTaskOnBackendThread(
- const tracked_objects::Location& from_here,
- const base::Closure& task) OVERRIDE {
+ bool PostTaskOnBackendThread(const tracked_objects::Location& from_here,
+ const base::Closure& task) override {
return BrowserThread::PostTask(BrowserThread::DB, from_here, task);
}
// 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() OVERRIDE {
- return mock_->StartModels();
- }
- virtual void RecordUnrecoverableError(
- const tracked_objects::Location& from_here,
- const std::string& message) OVERRIDE {
+ bool StartModels() override { return mock_->StartModels(); }
+ void RecordUnrecoverableError(const tracked_objects::Location& from_here,
+ const std::string& message) override {
mock_->RecordUnrecoverableError(from_here, message);
}
- virtual void RecordAssociationTime(base::TimeDelta time) OVERRIDE {
+ void RecordAssociationTime(base::TimeDelta time) override {
mock_->RecordAssociationTime(time);
}
- virtual void RecordStartFailure(
- DataTypeController::StartResult result) OVERRIDE {
+ void RecordStartFailure(DataTypeController::ConfigureResult result) override {
mock_->RecordStartFailure(result);
}
- virtual void DisconnectProcessor(
- browser_sync::ChangeProcessor* processor) OVERRIDE{
+ void DisconnectProcessor(sync_driver::ChangeProcessor* processor) override {
mock_->DisconnectProcessor(processor);
}
SyncNonFrontendDataTypeControllerTest()
: ui_thread_(BrowserThread::UI, &message_loop_),
db_thread_(BrowserThread::DB),
+ service_(&profile_),
model_associator_(NULL),
change_processor_(NULL) {}
- virtual void SetUp() {
+ void SetUp() override {
db_thread_.Start();
- profile_sync_factory_.reset(
- new StrictMock<ProfileSyncComponentsFactoryMock>());
+ profile_sync_factory_.reset(new ProfileSyncComponentsFactoryMock());
// All of these are refcounted, so don't need to be released.
dtc_mock_ = new StrictMock<NonFrontendDataTypeControllerMock>();
dtc_mock_.get());
}
- virtual void TearDown() {
+ void TearDown() override {
if (non_frontend_dtc_->state() !=
NonFrontendDataTypeController::NOT_RUNNING) {
non_frontend_dtc_->Stop();
EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_));
}
- void SetActivateExpectations(DataTypeController::StartResult result) {
- EXPECT_CALL(service_, ActivateDataType(_, _, _));
+ void SetActivateExpectations(DataTypeController::ConfigureResult result) {
EXPECT_CALL(start_callback_, Run(result, _, _));
}
WillOnce(Return(syncer::SyncError()));
}
- void SetStartFailExpectations(DataTypeController::StartResult result) {
+ void SetStartFailExpectations(DataTypeController::ConfigureResult result) {
if (DataTypeController::IsUnrecoverableResult(result))
EXPECT_CALL(*dtc_mock_.get(), RecordUnrecoverableError(_, _));
if (model_associator_) {
SignalEvent(&pause_db_thread));
EXPECT_CALL(*model_associator_, AssociateModels(_, _)).
WillOnce(Return(syncer::SyncError()));
- EXPECT_CALL(start_callback_, Run(DataTypeController::ABORTED,_,_));
- EXPECT_CALL(*dtc_mock_.get(),
- RecordStartFailure(DataTypeController::ABORTED));
SetStopExpectations();
EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state());
Start();
SignalEvent(&wait_for_association_starts),
WaitOnEvent(&wait_for_dtc_stop),
Return(syncer::SyncError())));
- EXPECT_CALL(start_callback_, Run(DataTypeController::ABORTED,_,_));
- EXPECT_CALL(*dtc_mock_.get(),
- RecordStartFailure(DataTypeController::ABORTED));
SetStopExpectations();
EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state());
Start();
EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state());
}
+// Disabled due to http://crbug.com/388367
TEST_F(SyncNonFrontendDataTypeControllerTest,
- OnSingleDatatypeUnrecoverableError) {
+ DISABLED_OnSingleDataTypeUnrecoverableError) {
SetStartExpectations();
SetAssociateExpectations();
SetActivateExpectations(DataTypeController::OK);
EXPECT_CALL(*dtc_mock_.get(), RecordUnrecoverableError(_, "Test"));
- EXPECT_CALL(service_, DisableBrokenDatatype(_, _, _))
+ EXPECT_CALL(service_, DisableDatatype(_))
.WillOnce(InvokeWithoutArgs(non_frontend_dtc_.get(),
&NonFrontendDataTypeController::Stop));
SetStopExpectations();
WaitForDTC();
EXPECT_EQ(DataTypeController::RUNNING, non_frontend_dtc_->state());
// This should cause non_frontend_dtc_->Stop() to be called.
+ syncer::SyncError error(FROM_HERE,
+ syncer::SyncError::DATATYPE_ERROR,
+ "error",
+ non_frontend_dtc_->type());
BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, base::Bind(
- &NonFrontendDataTypeControllerFake::OnSingleDatatypeUnrecoverableError,
+ &NonFrontendDataTypeControllerFake::OnSingleDataTypeUnrecoverableError,
non_frontend_dtc_.get(),
- FROM_HERE,
- std::string("Test")));
+ error));
WaitForDTC();
EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state());
}
projects / platform / framework / web / crosswalk.git / blobdiff