[Sync] Rename NonUIDataTypeController to AsyncDirectoryTypeController

components/sync/driver/async_directory_type_controller.h

 // 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.
 
-#ifndef COMPONENTS_SYNC_DRIVER_NON_UI_DATA_TYPE_CONTROLLER_H_
-#define COMPONENTS_SYNC_DRIVER_NON_UI_DATA_TYPE_CONTROLLER_H_
+#ifndef COMPONENTS_SYNC_DRIVER_ASYNC_DIRECTORY_TYPE_CONTROLLER_H_
+#define COMPONENTS_SYNC_DRIVER_ASYNC_DIRECTORY_TYPE_CONTROLLER_H_
 
 #include <memory>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "components/sync/driver/directory_data_type_controller.h"
 #include "components/sync/driver/shared_change_processor.h"
 
 namespace syncer {
 
 class SyncClient;
 struct UserShare;
 
-// Implementation for datatypes that reside on non-UI thread. All interaction
-// with datatype controller happens on UI thread. Calls to SyncableService are
-// posted to model thread through PostTaskOnModelThread().
-// Note: RefCountedThreadSafe by way of DataTypeController.
-class NonUIDataTypeController : public DirectoryDataTypeController {
+// Implementation for directory based datatypes that interact with their
+// syncable services by posting to model thread. All interaction with datatype
+// controller happens on UI thread.
+class AsyncDirectoryTypeController : public DirectoryDataTypeController {
  public:
   // |dump_stack| is called when an unrecoverable error occurs.
-  NonUIDataTypeController(
+  AsyncDirectoryTypeController(
       ModelType type,
       const base::Closure& dump_stack,
       SyncClient* sync_client,
       ModelSafeGroup model_safe_group,
       scoped_refptr<base::SequencedTaskRunner> model_thread);
-  ~NonUIDataTypeController() override;
+  ~AsyncDirectoryTypeController() override;
 
   // DataTypeController interface.
   void LoadModels(const ModelLoadCallback& model_load_callback) override;
   void StartAssociating(const StartCallback& start_callback) override;
   void Stop() override;
   ChangeProcessor* GetChangeProcessor() const override;
   std::string name() const override;
   State state() const override;
 
   // Used by tests to override the factory used to create
   // GenericChangeProcessors.
   void SetGenericChangeProcessorFactoryForTest(
       std::unique_ptr<GenericChangeProcessorFactory> factory);
 
  protected:
   // For testing only.
-  NonUIDataTypeController();
+  AsyncDirectoryTypeController();
 
   // Start any dependent services that need to be running before we can
   // associate models. The default implementation is a no-op.
   // Return value:
   //   True - if models are ready and association can proceed.
   //   False - if models are not ready. StartAssociationAsync should be called
   //           when the models are ready.
   // Note: this is performed on the UI thread.
   virtual bool StartModels();
 
@@ skipping 80 matching lines @@
   // thread and passed on to the backend thread.  This reference is
   // released on the UI thread in Stop()/StartDoneImpl(), but the
   // backend thread may still have references to it (which is okay,
   // since we call Disconnect() before releasing the UI thread
   // reference).
   scoped_refptr<SharedChangeProcessor> shared_change_processor_;
 };
 
 }  // namespace syncer
 
-#endif  // COMPONENTS_SYNC_DRIVER_NON_UI_DATA_TYPE_CONTROLLER_H_
+#endif  // COMPONENTS_SYNC_DRIVER_ASYNC_DIRECTORY_TYPE_CONTROLLER_H_