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

components/sync/driver/shared_change_processor.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/shared_change_processor.h"
 
 #include <utility>
 
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/base/data_type_histogram.h"
 #include "components/sync/driver/generic_change_processor.h"
 #include "components/sync/driver/generic_change_processor_factory.h"
 #include "components/sync/driver/shared_change_processor_ref.h"
-#include "components/sync/driver/sync_client.h"
 #include "components/sync/model/sync_change.h"
 #include "components/sync/model/syncable_service.h"
 
 using base::AutoLock;
 
 namespace syncer {
 
+using ServiceProvider = SyncClient::ServiceProvider;
+
 class AttachmentService;
 
 SharedChangeProcessor::SharedChangeProcessor(ModelType type)
     : disconnected_(false),
       type_(type),
       frontend_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       generic_change_processor_(nullptr) {
   DCHECK_NE(type_, UNSPECIFIED);
 }
 
@@ skipping 11 matching lines @@
                                             generic_change_processor_)) {
         NOTREACHED();
       }
     }
   } else {
     DCHECK(!generic_change_processor_);
   }
 }
 
 void SharedChangeProcessor::StartAssociation(
-    StartDoneCallback start_done,
-    SyncClient* const sync_client,
+    const StartDoneCallback& start_done,
+    const ServiceProvider& service_provider,

[pavely, 2017/03/27 19:38:25]

ServiceProvider looks weird outside of context of sync_client.h. How about
SyncableServiceProvider?

[skym, 2017/03/27 21:45:26]

Removed using instead, hopefully that's okay.

+    SyncApiComponentFactory* driver_factory,
     GenericChangeProcessorFactory* processor_factory,
     UserShare* user_share,
     std::unique_ptr<DataTypeErrorHandler> error_handler) {
   DCHECK(user_share);
   SyncMergeResult local_merge_result(type_);
   SyncMergeResult syncer_merge_result(type_);
   base::WeakPtrFactory<SyncMergeResult> weak_ptr_factory(&syncer_merge_result);
 
   // Connect |shared_change_processor| to the syncer and get the
   // SyncableService associated with type_.
   // Note that it's possible the shared_change_processor has already been
   // disconnected at this point, so all our accesses to the syncer from this
   // point on are through it.
   local_service_ =
-      Connect(sync_client, processor_factory, user_share,
+      Connect(service_provider, driver_factory, processor_factory, user_share,
               std::move(error_handler), weak_ptr_factory.GetWeakPtr());
   if (!local_service_.get()) {
     SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR,
                     "Failed to connect to syncer.", type_);
     local_merge_result.set_error(error);
     start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result,
                    syncer_merge_result);
     return;
   }
 
@@ skipping 51 matching lines @@
   }
 
   syncer_merge_result.set_num_items_after_association(GetSyncCount());
 
   start_done.Run(!sync_has_nodes ? DataTypeController::OK_FIRST_RUN
                                  : DataTypeController::OK,
                  local_merge_result, syncer_merge_result);
 }
 
 base::WeakPtr<SyncableService> SharedChangeProcessor::Connect(
-    SyncClient* sync_client,
+    const ServiceProvider& service_provider,
+    SyncApiComponentFactory* driver_factory,
     GenericChangeProcessorFactory* processor_factory,
     UserShare* user_share,
     std::unique_ptr<DataTypeErrorHandler> error_handler,
     const base::WeakPtr<SyncMergeResult>& merge_result) {
-  DCHECK(sync_client);
   DCHECK(error_handler);
   backend_task_runner_ = base::SequencedTaskRunnerHandle::Get();
   AutoLock lock(monitor_lock_);
   if (disconnected_)
     return base::WeakPtr<SyncableService>();
   error_handler_ = std::move(error_handler);
-  base::WeakPtr<SyncableService> local_service =
-      sync_client->GetSyncableServiceForType(type_);
+  base::WeakPtr<SyncableService> local_service = service_provider.Run();
   if (!local_service.get()) {
     LOG(WARNING) << "SyncableService destroyed before DTC was stopped.";
     disconnected_ = true;
     return base::WeakPtr<SyncableService>();
   }
 
-  generic_change_processor_ = processor_factory
-                                  ->CreateGenericChangeProcessor(
-                                      type_, user_share, error_handler_->Copy(),
-                                      local_service, merge_result, sync_client)
-                                  .release();
+  generic_change_processor_ =
+      processor_factory
+          ->CreateGenericChangeProcessor(type_, user_share,
+                                         error_handler_->Copy(), local_service,
+                                         merge_result, driver_factory)
+          .release();
   // If available, propagate attachment service to the syncable service.
   std::unique_ptr<AttachmentService> attachment_service =
       generic_change_processor_->GetAttachmentService();
   if (attachment_service) {
     local_service->SetAttachmentService(std::move(attachment_service));
   }
   return local_service;
 }
 
 bool SharedChangeProcessor::Disconnect() {
@@ skipping 141 matching lines @@
 #undef PER_DATA_TYPE_MACRO
 }
 
 void SharedChangeProcessor::StopLocalService() {
   if (local_service_.get())
     local_service_->StopSyncing(type_);
   local_service_.reset();
 }
 
 }  // namespace syncer