[Sync] Stop accessing BrowserContextKeyedServiceFactory on non-UI thread.

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/async_directory_type_controller.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 210 matching lines @@
   if (!model_load_callback_.is_null()) {
     model_load_callback_.Run(type(), error);
   }
 }
 
 bool AsyncDirectoryTypeController::StartAssociationAsync() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state(), ASSOCIATING);
   return PostTaskOnModelThread(
       FROM_HERE,
+      // TODO(skym): Sending a non-owning SyncApiComponentFactory pointer across
+      // threads is less than ideal. Likely safe because of the locking and
+      // disconnect flag in SharedChangeProcessor. This object is only ever used
+      // for dead attachments code anyways.
       base::Bind(
           &SharedChangeProcessor::StartAssociation, shared_change_processor_,
           BindToCurrentThread(base::Bind(
               &AsyncDirectoryTypeController::StartDone, base::AsWeakPtr(this))),
-          sync_client_, processor_factory_.get(), user_share_,
-          base::Passed(CreateErrorHandler())));
+          sync_client_->GetSyncableServiceForType(type()),
+          sync_client_->GetSyncApiComponentFactory(), processor_factory_.get(),
+          user_share_, base::Passed(CreateErrorHandler())));
 }
 
 ChangeProcessor* AsyncDirectoryTypeController::GetChangeProcessor() const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, RUNNING);
   return shared_change_processor_->generic_change_processor();
 }
 
 void AsyncDirectoryTypeController::DisconnectSharedChangeProcessor() {
   DCHECK(CalledOnValidThread());
@@ skipping 16 matching lines @@
 std::unique_ptr<DataTypeErrorHandler>
 AsyncDirectoryTypeController::CreateErrorHandler() {
   DCHECK(CalledOnValidThread());
   return base::MakeUnique<DataTypeErrorHandlerImpl>(
       base::ThreadTaskRunnerHandle::Get(), dump_stack_,
       base::Bind(&AsyncDirectoryTypeController::DisableImpl,
                  base::AsWeakPtr(this)));
 }
 
 }  // namespace syncer