[USS] Break NonBlockingDataTypeController into UI specific one and non-UI specific one

components/sync_driver/non_blocking_data_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_blocking_data_type_controller.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 11 matching lines @@
 
 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),
       state_(NOT_RUNNING) {
-  // TODO(gangwu): should initial processor somewhere else in
-  // NonBlockingDataTypeController
-  InitializeProcessor();
+  DCHECK(BelongsToUIThread());
 }
 
 NonBlockingDataTypeController::~NonBlockingDataTypeController() {}
 
 void NonBlockingDataTypeController::LoadModels(
     const ModelLoadCallback& model_load_callback) {
   DCHECK(ui_thread()->BelongsToCurrentThread());
   DCHECK(!model_load_callback.is_null());
   model_load_callback_ = model_load_callback;
 
@@ skipping 42 matching lines @@
   }
 
   if (!model_load_callback_.is_null()) {
     model_load_callback_.Run(type(), error);
   }
 }
 
 void NonBlockingDataTypeController::OnProcessorStarted(
     syncer::SyncError error,
     scoped_ptr<syncer_v2::ActivationContext> activation_context) {
-  if (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);
-  } else {
-    RunOnUIThread(
-        FROM_HERE,
-        base::Bind(&NonBlockingDataTypeController::OnProcessorStarted, this,
-                   error, base::Passed(std::move(activation_context))));
+  RunOnUIThread(
+      FROM_HERE,
+      base::Bind(&NonBlockingDataTypeController::OnProcessorStartedOnUIThread,
+                 this, error, base::Passed(std::move(activation_context))));
+}
+
+void NonBlockingDataTypeController::OnProcessorStartedOnUIThread(
+    syncer::SyncError error,
+    scoped_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::StartAssociating(
     const StartCallback& start_callback) {
   DCHECK(BelongsToUIThread());
   DCHECK(!start_callback.is_null());
 
   state_ = RUNNING;
 
   // There is no association, just call back promptly.
@@ skipping 39 matching lines @@
 
 sync_driver::DataTypeController::State NonBlockingDataTypeController::state()
     const {
   return state_;
 }
 
 bool NonBlockingDataTypeController::BelongsToUIThread() const {
   return ui_thread()->BelongsToCurrentThread();
 }
 
-void NonBlockingDataTypeController::RunOnUIThread(
-    const tracked_objects::Location& from_here,
-    const base::Closure& task) {
-  DCHECK(!BelongsToUIThread());
-  ui_thread()->PostTask(from_here, task);
-}
-
 void NonBlockingDataTypeController::OnSingleDataTypeUnrecoverableError(
     const syncer::SyncError& error) {
   RecordUnrecoverableError();
   if (!error_callback_.is_null())
     error_callback_.Run();
 
   ReportLoadModelError(UNRECOVERABLE_ERROR, error);
 }
 
 void NonBlockingDataTypeController::ReportLoadModelError(
@@ skipping 34 matching lines @@
 
 base::WeakPtr<syncer_v2::SharedModelTypeProcessor>
 NonBlockingDataTypeController::type_processor() const {
   return type_processor_;
 }
 
 syncer::ModelType NonBlockingDataTypeController::type() const {
   return model_type_;
 }
 
-void NonBlockingDataTypeController::InitializeProcessor() {
+void NonBlockingDataTypeController::InitializeProcessorOnModelThread() {
   base::WeakPtr<syncer_v2::ModelTypeService> model_type_service =
       sync_client_->GetModelTypeServiceForType(type());
   if (!model_type_service.get()) {
     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_|.
   }
 
   scoped_ptr<syncer_v2::SharedModelTypeProcessor> shared_model_type_processor(
       make_scoped_ptr(new syncer_v2::SharedModelTypeProcessor(
           type(), model_type_service.get())));
   type_processor_ = shared_model_type_processor->AsWeakPtrForUI();
   model_type_service->set_change_processor(
       std::move(shared_model_type_processor));
 }
 
+void NonBlockingDataTypeController::InitializeProcessor() {
+  DCHECK(BelongsToUIThread());
+  RunOnModelThread(
+      FROM_HERE,
+      base::Bind(
+          &NonBlockingDataTypeController::InitializeProcessorOnModelThread,
+          this));
+}
+
 }  // namespace sync_driver_v2