Index: components/sync_driver/non_blocking_data_type_controller.cc |
diff --git a/components/sync_driver/non_blocking_data_type_controller.cc b/components/sync_driver/non_blocking_data_type_controller.cc |
deleted file mode 100644 |
index d669d08de9535278b42c99734dc1a9c9e5b8922a..0000000000000000000000000000000000000000 |
--- a/components/sync_driver/non_blocking_data_type_controller.cc |
+++ /dev/null |
@@ -1,265 +0,0 @@ |
-// Copyright 2014 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 "components/sync_driver/non_blocking_data_type_controller.h" |
- |
-#include <utility> |
- |
-#include "base/bind.h" |
-#include "base/bind_helpers.h" |
-#include "base/location.h" |
-#include "base/single_thread_task_runner.h" |
-#include "components/sync/api/model_type_change_processor.h" |
-#include "components/sync/api/model_type_service.h" |
-#include "components/sync/api/sync_error.h" |
-#include "components/sync/api/sync_merge_result.h" |
-#include "components/sync/base/data_type_histogram.h" |
-#include "components/sync/core/activation_context.h" |
-#include "components/sync_driver/backend_data_type_configurer.h" |
-#include "components/sync_driver/sync_client.h" |
- |
-namespace sync_driver_v2 { |
- |
-NonBlockingDataTypeController::NonBlockingDataTypeController( |
- const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread, |
- const base::Closure& error_callback, |
- syncer::ModelType model_type, |
- sync_driver::SyncClient* sync_client) |
- : sync_driver::DataTypeController(ui_thread, error_callback), |
- model_type_(model_type), |
- sync_client_(sync_client), |
- sync_prefs_(sync_client->GetPrefService()), |
- state_(NOT_RUNNING) { |
- DCHECK(BelongsToUIThread()); |
-} |
- |
-NonBlockingDataTypeController::~NonBlockingDataTypeController() {} |
- |
-bool NonBlockingDataTypeController::ShouldLoadModelBeforeConfigure() const { |
- // USS datatypes require loading models because model controls storage where |
- // data type context and progress marker are persisted. |
- return true; |
-} |
- |
-void NonBlockingDataTypeController::LoadModels( |
- const ModelLoadCallback& model_load_callback) { |
- DCHECK(ui_thread()->BelongsToCurrentThread()); |
- DCHECK(!model_load_callback.is_null()); |
- model_load_callback_ = model_load_callback; |
- |
- if (state() != NOT_RUNNING) { |
- LoadModelsDone( |
- RUNTIME_ERROR, |
- syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, |
- "Model already running", type())); |
- return; |
- } |
- |
- state_ = MODEL_STARTING; |
- |
- // Start the type processor on the model thread. |
- if (!RunOnModelThread( |
- FROM_HERE, |
- base::Bind(&NonBlockingDataTypeController::LoadModelsOnModelThread, |
- this))) { |
- LoadModelsDone( |
- UNRECOVERABLE_ERROR, |
- syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, |
- "Failed to post model Start", type())); |
- } |
-} |
- |
-void NonBlockingDataTypeController::LoadModelsOnModelThread() { |
- syncer_v2::ModelTypeService* model_type_service = |
- sync_client_->GetModelTypeServiceForType(type()); |
- if (!model_type_service) { |
- LOG(WARNING) << "ModelTypeService destroyed before " |
- "ModelTypeController was started."; |
- // TODO(gangwu): Add SyncError and then call start_callback with it. Also |
- // set an error state to |state_|. |
- return; |
- } |
- |
- model_type_service->OnSyncStarting( |
- this, |
- base::Bind(&NonBlockingDataTypeController::OnProcessorStarted, this)); |
-} |
- |
-void NonBlockingDataTypeController::LoadModelsDone( |
- ConfigureResult result, |
- const syncer::SyncError& error) { |
- DCHECK(BelongsToUIThread()); |
- |
- if (state_ == NOT_RUNNING) { |
- // The callback arrived on the UI thread after the type has been already |
- // stopped. |
- RecordStartFailure(ABORTED); |
- return; |
- } |
- |
- if (IsSuccessfulResult(result)) { |
- DCHECK_EQ(MODEL_STARTING, state_); |
- state_ = MODEL_LOADED; |
- } else { |
- RecordStartFailure(result); |
- } |
- |
- if (!model_load_callback_.is_null()) { |
- model_load_callback_.Run(type(), error); |
- } |
-} |
- |
-void NonBlockingDataTypeController::OnProcessorStarted( |
- syncer::SyncError error, |
- std::unique_ptr<syncer_v2::ActivationContext> activation_context) { |
- RunOnUIThread( |
- FROM_HERE, |
- base::Bind(&NonBlockingDataTypeController::OnProcessorStartedOnUIThread, |
- this, error, base::Passed(std::move(activation_context)))); |
-} |
- |
-void NonBlockingDataTypeController::OnProcessorStartedOnUIThread( |
- syncer::SyncError error, |
- std::unique_ptr<syncer_v2::ActivationContext> activation_context) { |
- DCHECK(BelongsToUIThread()); |
- // Hold on to the activation context until ActivateDataType is called. |
- if (state_ == MODEL_STARTING) { |
- activation_context_ = std::move(activation_context); |
- } |
- // TODO(stanisc): Figure out if UNRECOVERABLE_ERROR is OK in this case. |
- ConfigureResult result = error.IsSet() ? UNRECOVERABLE_ERROR : OK; |
- LoadModelsDone(result, error); |
-} |
- |
-void NonBlockingDataTypeController::RegisterWithBackend( |
- sync_driver::BackendDataTypeConfigurer* configurer) { |
- DCHECK(BelongsToUIThread()); |
- DCHECK(configurer); |
- DCHECK(activation_context_); |
- DCHECK_EQ(MODEL_LOADED, state_); |
- configurer->ActivateNonBlockingDataType(type(), |
- std::move(activation_context_)); |
-} |
- |
-void NonBlockingDataTypeController::StartAssociating( |
- const StartCallback& start_callback) { |
- DCHECK(BelongsToUIThread()); |
- DCHECK(!start_callback.is_null()); |
- |
- state_ = RUNNING; |
- |
- // There is no association, just call back promptly. |
- syncer::SyncMergeResult merge_result(type()); |
- start_callback.Run(OK, merge_result, merge_result); |
-} |
- |
-void NonBlockingDataTypeController::ActivateDataType( |
- sync_driver::BackendDataTypeConfigurer* configurer) { |
- DCHECK(BelongsToUIThread()); |
- DCHECK(configurer); |
- DCHECK_EQ(RUNNING, state_); |
- // In contrast with directory datatypes, non-blocking data types should be |
- // activated in RegisterWithBackend. activation_context_ should be passed |
- // to backend before call to ActivateDataType. |
- DCHECK(!activation_context_); |
-} |
- |
-void NonBlockingDataTypeController::DeactivateDataType( |
- sync_driver::BackendDataTypeConfigurer* configurer) { |
- DCHECK(BelongsToUIThread()); |
- DCHECK(configurer); |
- configurer->DeactivateNonBlockingDataType(type()); |
-} |
- |
-void NonBlockingDataTypeController::Stop() { |
- DCHECK(ui_thread()->BelongsToCurrentThread()); |
- |
- if (state() == NOT_RUNNING) |
- return; |
- |
- // Check preferences if datatype is not in preferred datatypes. Only call |
- // DisableSync if service is ready to handle it (controller is in loaded |
- // state). |
- syncer::ModelTypeSet preferred_types = |
- sync_prefs_.GetPreferredDataTypes(syncer::ModelTypeSet(type())); |
- if ((state() == MODEL_LOADED || state() == RUNNING) && |
- (!sync_prefs_.IsFirstSetupComplete() || !preferred_types.Has(type()))) { |
- RunOnModelThread(FROM_HERE, base::Bind( |
- &NonBlockingDataTypeController::DisableSyncOnModelThread, this)); |
- } |
- |
- state_ = NOT_RUNNING; |
-} |
- |
-void NonBlockingDataTypeController::DisableSyncOnModelThread() { |
- syncer_v2::ModelTypeService* model_type_service = |
- sync_client_->GetModelTypeServiceForType(type()); |
- DCHECK(model_type_service); |
- model_type_service->DisableSync(); |
-} |
- |
-std::string NonBlockingDataTypeController::name() const { |
- // For logging only. |
- return syncer::ModelTypeToString(type()); |
-} |
- |
-sync_driver::DataTypeController::State NonBlockingDataTypeController::state() |
- const { |
- return state_; |
-} |
- |
-bool NonBlockingDataTypeController::BelongsToUIThread() const { |
- return ui_thread()->BelongsToCurrentThread(); |
-} |
- |
-void NonBlockingDataTypeController::OnSingleDataTypeUnrecoverableError( |
- const syncer::SyncError& error) { |
- RecordUnrecoverableError(); |
- if (!error_callback_.is_null()) |
- error_callback_.Run(); |
- |
- ReportLoadModelError(UNRECOVERABLE_ERROR, error); |
-} |
- |
-void NonBlockingDataTypeController::ReportLoadModelError( |
- ConfigureResult result, |
- const syncer::SyncError& error) { |
- DCHECK(!IsSuccessfulResult(result)); |
- if (BelongsToUIThread()) { |
- // Report the error only if the model is starting. |
- if (state_ == MODEL_STARTING) { |
- LoadModelsDone(result, error); |
- } |
- } else { |
- RunOnUIThread( |
- error.location(), |
- base::Bind(&NonBlockingDataTypeController::ReportLoadModelError, this, |
- result, error)); |
- } |
-} |
- |
-void NonBlockingDataTypeController::RecordStartFailure( |
- ConfigureResult result) const { |
- DCHECK(BelongsToUIThread()); |
- UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeStartFailures", |
- ModelTypeToHistogramInt(type()), |
- syncer::MODEL_TYPE_COUNT); |
-#define PER_DATA_TYPE_MACRO(type_str) \ |
- UMA_HISTOGRAM_ENUMERATION("Sync." type_str "ConfigureFailure", result, \ |
- MAX_CONFIGURE_RESULT); |
- SYNC_DATA_TYPE_HISTOGRAM(type()); |
-#undef PER_DATA_TYPE_MACRO |
-} |
- |
-void NonBlockingDataTypeController::RecordUnrecoverableError() { |
- UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeRunFailures", |
- ModelTypeToHistogramInt(type()), |
- syncer::MODEL_TYPE_COUNT); |
-} |
- |
-syncer::ModelType NonBlockingDataTypeController::type() const { |
- return model_type_; |
-} |
- |
-} // namespace sync_driver_v2 |