[Sync] Rename NonUIDataTypeController to AsyncDirectoryTypeController

components/sync/driver/async_directory_type_controller.cc

 // 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_ui_data_type_controller.h"
+#include "components/sync/driver/async_directory_type_controller.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/base/bind_to_task_runner.h"
 #include "components/sync/base/data_type_histogram.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/driver/generic_change_processor_factory.h"
 #include "components/sync/driver/sync_api_component_factory.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/sync/model/data_type_error_handler_impl.h"
 #include "components/sync/model/sync_error.h"
 #include "components/sync/model/sync_merge_result.h"
 #include "components/sync/model/syncable_service.h"
 
 namespace syncer {
 
-SharedChangeProcessor* NonUIDataTypeController::CreateSharedChangeProcessor() {
+SharedChangeProcessor*
+AsyncDirectoryTypeController::CreateSharedChangeProcessor() {
   return new SharedChangeProcessor(type());
 }
 
-NonUIDataTypeController::NonUIDataTypeController(
+AsyncDirectoryTypeController::AsyncDirectoryTypeController(
     ModelType type,
     const base::Closure& dump_stack,
     SyncClient* sync_client,
     ModelSafeGroup model_safe_group,
     scoped_refptr<base::SequencedTaskRunner> model_thread)
     : DirectoryDataTypeController(type,
                                   dump_stack,
                                   sync_client,
                                   model_safe_group),
       user_share_(nullptr),
       processor_factory_(new GenericChangeProcessorFactory()),
       state_(NOT_RUNNING),
       model_thread_(std::move(model_thread)) {}
 
-void NonUIDataTypeController::LoadModels(
+void AsyncDirectoryTypeController::LoadModels(
     const ModelLoadCallback& model_load_callback) {
   DCHECK(CalledOnValidThread());
   model_load_callback_ = model_load_callback;
   if (state() != NOT_RUNNING) {
     model_load_callback.Run(type(),
                             SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
                                       "Model already running", type()));
     return;
   }
 
   state_ = MODEL_STARTING;
   // Since we can't be called multiple times before Stop() is called,
   // |shared_change_processor_| must be null here.
   DCHECK(!shared_change_processor_.get());
   shared_change_processor_ = CreateSharedChangeProcessor();
   DCHECK(shared_change_processor_.get());
   if (!StartModels()) {
     // If we are waiting for some external service to load before associating
     // or we failed to start the models, we exit early.
     DCHECK(state() == MODEL_STARTING || state() == NOT_RUNNING);
     return;
   }
 
   OnModelLoaded();
 }
 
-void NonUIDataTypeController::OnModelLoaded() {
+void AsyncDirectoryTypeController::OnModelLoaded() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, MODEL_STARTING);
   state_ = MODEL_LOADED;
   model_load_callback_.Run(type(), SyncError());
 }
 
-bool NonUIDataTypeController::StartModels() {
+bool AsyncDirectoryTypeController::StartModels() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, MODEL_STARTING);
   // By default, no additional services need to be started before we can proceed
   // with model association.
   return true;
 }
 
-void NonUIDataTypeController::StopModels() {
+void AsyncDirectoryTypeController::StopModels() {
   DCHECK(CalledOnValidThread());
 }
 
-bool NonUIDataTypeController::PostTaskOnModelThread(
+bool AsyncDirectoryTypeController::PostTaskOnModelThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   DCHECK(CalledOnValidThread());
   return model_thread_->PostTask(from_here, task);
 }
 
-void NonUIDataTypeController::StartAssociating(
+void AsyncDirectoryTypeController::StartAssociating(
     const StartCallback& start_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!start_callback.is_null());
   DCHECK_EQ(state_, MODEL_LOADED);
   state_ = ASSOCIATING;
 
   // Store UserShare now while on UI thread to avoid potential race
   // condition in StartAssociationWithSharedChangeProcessor.
   DCHECK(sync_client_->GetSyncService());
   user_share_ = sync_client_->GetSyncService()->GetUserShare();
 
   start_callback_ = start_callback;
   if (!StartAssociationAsync()) {
     SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR,
                     "Failed to post StartAssociation", type());
     SyncMergeResult local_merge_result(type());
     local_merge_result.set_error(error);
     StartDone(ASSOCIATION_FAILED, local_merge_result, SyncMergeResult(type()));
     // StartDone should have cleared the SharedChangeProcessor.
     DCHECK(!shared_change_processor_.get());
     return;
   }
 }
 
-void NonUIDataTypeController::Stop() {
+void AsyncDirectoryTypeController::Stop() {
   DCHECK(CalledOnValidThread());
 
   if (state() == NOT_RUNNING)
     return;
 
   // Disconnect the change processor. At this point, the
   // SyncableService can no longer interact with the Syncer, even if
   // it hasn't finished MergeDataAndStartSyncing.
   DisconnectSharedChangeProcessor();
 
   // If we haven't finished starting, we need to abort the start.
   bool service_started = state() == ASSOCIATING || state() == RUNNING;
   state_ = service_started ? STOPPING : NOT_RUNNING;
   StopModels();
 
   if (service_started)
     StopSyncableService();
 
   shared_change_processor_ = nullptr;
   state_ = NOT_RUNNING;
 }
 
-std::string NonUIDataTypeController::name() const {
+std::string AsyncDirectoryTypeController::name() const {
   // For logging only.
   return ModelTypeToString(type());
 }
 
-DataTypeController::State NonUIDataTypeController::state() const {
+DataTypeController::State AsyncDirectoryTypeController::state() const {
   return state_;
 }
 
-void NonUIDataTypeController::SetGenericChangeProcessorFactoryForTest(
+void AsyncDirectoryTypeController::SetGenericChangeProcessorFactoryForTest(
     std::unique_ptr<GenericChangeProcessorFactory> factory) {
   DCHECK_EQ(state_, NOT_RUNNING);
   processor_factory_ = std::move(factory);
 }
 
-NonUIDataTypeController::NonUIDataTypeController()
+AsyncDirectoryTypeController::AsyncDirectoryTypeController()
     : DirectoryDataTypeController(UNSPECIFIED,
                                   base::Closure(),
                                   nullptr,
                                   GROUP_PASSIVE) {}
 
-NonUIDataTypeController::~NonUIDataTypeController() {}
+AsyncDirectoryTypeController::~AsyncDirectoryTypeController() {}
 
-void NonUIDataTypeController::StartDone(
+void AsyncDirectoryTypeController::StartDone(
     DataTypeController::ConfigureResult start_result,
     const SyncMergeResult& local_merge_result,
     const SyncMergeResult& syncer_merge_result) {
   DCHECK(CalledOnValidThread());
 
   DataTypeController::State new_state;
   if (IsSuccessfulResult(start_result)) {
     new_state = RUNNING;
   } else {
     new_state = (start_result == ASSOCIATION_FAILED ? DISABLED : NOT_RUNNING);
@@ skipping 17 matching lines @@
   state_ = new_state;
   if (state_ != RUNNING) {
     // Start failed.
     StopModels();
     RecordStartFailure(start_result);
   }
 
   start_callback_.Run(start_result, local_merge_result, syncer_merge_result);
 }
 
-void NonUIDataTypeController::RecordStartFailure(ConfigureResult result) {
+void AsyncDirectoryTypeController::RecordStartFailure(ConfigureResult result) {
   DCHECK(CalledOnValidThread());
   UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeStartFailures",
                             ModelTypeToHistogramInt(type()), 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 NonUIDataTypeController::DisableImpl(const SyncError& error) {
+void AsyncDirectoryTypeController::DisableImpl(const SyncError& error) {
   DCHECK(CalledOnValidThread());
   if (!model_load_callback_.is_null()) {
     model_load_callback_.Run(type(), error);
   }
 }
 
-bool NonUIDataTypeController::StartAssociationAsync() {
+bool AsyncDirectoryTypeController::StartAssociationAsync() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state(), ASSOCIATING);
   return PostTaskOnModelThread(
       FROM_HERE,
       base::Bind(
           &SharedChangeProcessor::StartAssociation, shared_change_processor_,
-          BindToCurrentThread(base::Bind(&NonUIDataTypeController::StartDone,
-                                         base::AsWeakPtr(this))),
+          BindToCurrentThread(base::Bind(
+              &AsyncDirectoryTypeController::StartDone, base::AsWeakPtr(this))),
           sync_client_, processor_factory_.get(), user_share_,
           base::Passed(CreateErrorHandler())));
 }
 
-ChangeProcessor* NonUIDataTypeController::GetChangeProcessor() const {
+ChangeProcessor* AsyncDirectoryTypeController::GetChangeProcessor() const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, RUNNING);
   return shared_change_processor_->generic_change_processor();
 }
 
-void NonUIDataTypeController::DisconnectSharedChangeProcessor() {
+void AsyncDirectoryTypeController::DisconnectSharedChangeProcessor() {
   DCHECK(CalledOnValidThread());
   // |shared_change_processor_| can already be null if Stop() is
   // called after StartDone(_, DISABLED, _).
   if (shared_change_processor_.get()) {
     shared_change_processor_->Disconnect();
   }
 }
 
-void NonUIDataTypeController::StopSyncableService() {
+void AsyncDirectoryTypeController::StopSyncableService() {
   DCHECK(CalledOnValidThread());
   if (shared_change_processor_.get()) {
     PostTaskOnModelThread(FROM_HERE,
                           base::Bind(&SharedChangeProcessor::StopLocalService,
                                      shared_change_processor_));
   }
 }
 
 std::unique_ptr<DataTypeErrorHandler>
-NonUIDataTypeController::CreateErrorHandler() {
+AsyncDirectoryTypeController::CreateErrorHandler() {
   DCHECK(CalledOnValidThread());
   return base::MakeUnique<DataTypeErrorHandlerImpl>(
       base::ThreadTaskRunnerHandle::Get(), dump_stack_,
-      base::Bind(&NonUIDataTypeController::DisableImpl, base::AsWeakPtr(this)));
+      base::Bind(&AsyncDirectoryTypeController::DisableImpl,
+                 base::AsWeakPtr(this)));
 }
 
 }  // namespace syncer