#include "base/callback.h"
#include "base/logging.h"
#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/sync/glue/change_processor.h"
#include "chrome/browser/sync/glue/chrome_report_unrecoverable_error.h"
-#include "chrome/browser/sync/glue/model_associator.h"
#include "chrome/browser/sync/profile_sync_components_factory.h"
#include "chrome/browser/sync/profile_sync_service.h"
+#include "components/sync_driver/change_processor.h"
+#include "components/sync_driver/model_associator.h"
#include "content/public/browser/browser_thread.h"
#include "sync/api/sync_error.h"
#include "sync/internal_api/public/base/model_type.h"
// For returning association results to controller on UI.
syncer::WeakHandle<NonFrontendDataTypeController> controller_handle_;
- scoped_ptr<AssociatorInterface> model_associator_;
- scoped_ptr<ChangeProcessor> change_processor_;
+ scoped_ptr<sync_driver::AssociatorInterface> model_associator_;
+ scoped_ptr<sync_driver::ChangeProcessor> change_processor_;
};
NonFrontendDataTypeController::
BackendComponentsContainer::BackendComponentsContainer(
NonFrontendDataTypeController* controller)
- : controller_(controller),
- type_(controller->type()) {
+ : controller_(controller),
+ type_(controller->type()) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
controller_handle_ =
syncer::MakeWeakHandle(controller_->weak_ptr_factory_.GetWeakPtr());
}
void NonFrontendDataTypeController::BackendComponentsContainer::Run() {
- DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK(controller_->IsOnBackendThread());
if (CreateComponents())
Associate();
}
NonFrontendDataTypeController::AssociationResult::~AssociationResult() {}
+// TODO(tim): Legacy controllers are being left behind in componentization
+// effort for now, hence still having a dependency on ProfileSyncService.
+// That dep can probably be removed without too much work.
NonFrontendDataTypeController::NonFrontendDataTypeController(
+ scoped_refptr<base::MessageLoopProxy> ui_thread,
+ const base::Closure& error_callback,
ProfileSyncComponentsFactory* profile_sync_factory,
Profile* profile,
ProfileSyncService* sync_service)
- : state_(NOT_RUNNING),
+ : DataTypeController(ui_thread, error_callback),
+ state_(NOT_RUNNING),
profile_sync_factory_(profile_sync_factory),
profile_(profile),
profile_sync_service_(sync_service),
}
void DestroyComponentsInBackend(
- NonFrontendDataTypeController::BackendComponentsContainer *containter) {
- delete containter;
+ NonFrontendDataTypeController::BackendComponentsContainer *container) {
+ delete container;
}
void NonFrontendDataTypeController::Stop() {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- DCHECK_NE(state_, NOT_RUNNING);
+
+ if (state_ == NOT_RUNNING)
+ return;
// Deactivate the date type on the UI thread first to stop processing
// sync server changes. This needs to happen before posting task to destroy
change_processor_ = NULL;
}
- // Call start callback if waiting for association.
- if (state_ == ASSOCIATING) {
- StartDone(ABORTED,
- syncer::SyncMergeResult(type()),
- syncer::SyncMergeResult(type()));
-
- }
-
state_ = NOT_RUNNING;
}
return syncer::ModelTypeToString(type());
}
-DataTypeController::State NonFrontendDataTypeController::state() const {
+sync_driver::DataTypeController::State NonFrontendDataTypeController::state()
+ const {
return state_;
}
-void NonFrontendDataTypeController::OnSingleDatatypeUnrecoverableError(
- const tracked_objects::Location& from_here,
- const std::string& message) {
- DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
- RecordUnrecoverableError(from_here, message);
- BrowserThread::PostTask(BrowserThread::UI, from_here,
+void NonFrontendDataTypeController::OnSingleDataTypeUnrecoverableError(
+ const syncer::SyncError& error) {
+ DCHECK(IsOnBackendThread());
+ DCHECK_EQ(type(), error.model_type());
+ RecordUnrecoverableError(error.location(), error.message());
+ BrowserThread::PostTask(BrowserThread::UI, error.location(),
base::Bind(&NonFrontendDataTypeController::DisableImpl,
this,
- from_here,
- message));
+ error));
}
NonFrontendDataTypeController::NonFrontendDataTypeController()
- : state_(NOT_RUNNING),
+ : DataTypeController(base::MessageLoopProxy::current(), base::Closure()),
+ state_(NOT_RUNNING),
profile_sync_factory_(NULL),
profile_(NULL),
profile_sync_service_(NULL),
return true;
}
+bool NonFrontendDataTypeController::IsOnBackendThread() {
+ return !BrowserThread::CurrentlyOn(BrowserThread::UI);
+}
+
void NonFrontendDataTypeController::StartDone(
- DataTypeController::StartResult start_result,
+ DataTypeController::ConfigureResult start_result,
const syncer::SyncMergeResult& local_merge_result,
const syncer::SyncMergeResult& syncer_merge_result) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
}
void NonFrontendDataTypeController::StartDoneImpl(
- DataTypeController::StartResult start_result,
+ DataTypeController::ConfigureResult start_result,
DataTypeController::State new_state,
const syncer::SyncMergeResult& local_merge_result,
const syncer::SyncMergeResult& syncer_merge_result) {
RecordStartFailure(start_result);
}
- DCHECK(!start_callback_.is_null());
- // We have to release the callback before we call it, since it's possible
- // invoking the callback will trigger a call to STOP(), which will get
- // confused by the non-NULL start_callback_.
- StartCallback callback = start_callback_;
- start_callback_.Reset();
- callback.Run(start_result, local_merge_result, syncer_merge_result);
+ start_callback_.Run(start_result, local_merge_result, syncer_merge_result);
}
void NonFrontendDataTypeController::DisableImpl(
- const tracked_objects::Location& from_here,
- const std::string& message) {
+ const syncer::SyncError& error) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- profile_sync_service_->DisableBrokenDatatype(type(), from_here, message);
+ if (!start_callback_.is_null()) {
+ syncer::SyncMergeResult local_merge_result(type());
+ local_merge_result.set_error(error);
+ start_callback_.Run(RUNTIME_ERROR,
+ local_merge_result,
+ syncer::SyncMergeResult(type()));
+ }
}
void NonFrontendDataTypeController::RecordAssociationTime(
#undef PER_DATA_TYPE_MACRO
}
-void NonFrontendDataTypeController::RecordStartFailure(StartResult result) {
+void NonFrontendDataTypeController::RecordStartFailure(ConfigureResult result) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeStartFailures",
ModelTypeToHistogramInt(type()),
#undef PER_DATA_TYPE_MACRO
}
+void NonFrontendDataTypeController::RecordUnrecoverableError(
+ const tracked_objects::Location& from_here,
+ const std::string& message) {
+ DVLOG(1) << "Datatype Controller failed for type "
+ << ModelTypeToString(type()) << " "
+ << message << " at location "
+ << from_here.ToString();
+ UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeRunFailures",
+ ModelTypeToHistogramInt(type()),
+ syncer::MODEL_TYPE_COUNT);
+
+ if (!error_callback_.is_null())
+ error_callback_.Run();
+}
+
+
ProfileSyncComponentsFactory*
NonFrontendDataTypeController::profile_sync_factory() const {
return profile_sync_factory_;
state_ = state;
}
-AssociatorInterface* NonFrontendDataTypeController::associator() const {
+sync_driver::AssociatorInterface* NonFrontendDataTypeController::associator()
+ const {
return model_associator_;
}
-ChangeProcessor* NonFrontendDataTypeController::change_processor() const {
+sync_driver::ChangeProcessor*
+NonFrontendDataTypeController::GetChangeProcessor() const {
return change_processor_;
}
change_processor_ = result.change_processor;
model_associator_ = result.model_associator;
- profile_sync_service_->ActivateDataType(type(), model_safe_group(),
- change_processor());
StartDone(!result.sync_has_nodes ? OK_FIRST_RUN : OK,
result.local_merge_result,
result.syncer_merge_result);
projects / platform / framework / web / crosswalk.git / blobdiff