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

ios/chrome/browser/sync/ios_chrome_sync_client.mm

 // Copyright 2015 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 "ios/chrome/browser/sync/ios_chrome_sync_client.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 51 matching lines @@
 #include "ios/chrome/browser/undo/bookmark_undo_service_factory.h"
 #include "ios/chrome/browser/web_data_service_factory.h"
 #include "ios/chrome/common/channel_info.h"
 #include "ios/web/public/web_thread.h"
 #include "ui/base/device_form_factor.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
-using autofill::AutocompleteSyncableService;
-using autofill::AutofillProfileSyncableService;
-using autofill::AutofillWalletMetadataSyncableService;
-using autofill::AutofillWalletSyncableService;
-using base::Callback;
-using base::WeakPtr;
-using syncer::SyncableService;
-
-using ServiceProvider = syncer::SyncClient::ServiceProvider;
-
 namespace {
 
-template <typename T>
-T Trampoline(T arg) {
-  return arg;
-}
-
-template <typename T>
-Callback<T()> WrapInCallback(T arg) {
-  return base::Bind(&Trampoline<T>, arg);
-}
-
-WeakPtr<SyncableService> ServiceAsWeakPtr(SyncableService* ptr) {
-  return ptr ? ptr->AsWeakPtr() : WeakPtr<SyncableService>();
-}
-
-ServiceProvider WrapInProvider(SyncableService* service) {
-  return WrapInCallback(ServiceAsWeakPtr(service));
-}
-
-template <typename T>
-WeakPtr<SyncableService> CallbackResultAsWeakPtr(Callback<T()> callback) {
-  return ServiceAsWeakPtr(callback.Run());
-}
-
-template <typename T>
-ServiceProvider WrapInWeakPtrCallback(Callback<T()> callback) {
-  return base::Bind(&CallbackResultAsWeakPtr<T>, callback);
-}
-
 // iOS implementation of SyncSessionsClient. Needs to be in a separate class
 // due to possible multiple inheritance issues, wherein IOSChromeSyncClient
 // might inherit from other interfaces with same methods.
 class SyncSessionsClientImpl : public sync_sessions::SyncSessionsClient {
  public:
   explicit SyncSessionsClientImpl(ios::ChromeBrowserState* browser_state)
       : browser_state_(browser_state),
         window_delegates_getter_(
             base::MakeUnique<TabModelSyncedWindowDelegatesGetter>()),
         local_session_event_router_(
@@ skipping 171 matching lines @@
 scoped_refptr<syncer::ExtensionsActivity>
 IOSChromeSyncClient::GetExtensionsActivity() {
   return nullptr;
 }
 
 sync_sessions::SyncSessionsClient*
 IOSChromeSyncClient::GetSyncSessionsClient() {
   return sync_sessions_client_.get();
 }
 
-ServiceProvider IOSChromeSyncClient::GetSyncableServiceForType(
-    syncer::ModelType type) {
+base::WeakPtr<syncer::SyncableService>
+IOSChromeSyncClient::GetSyncableServiceForType(syncer::ModelType type) {
   switch (type) {
     case syncer::DEVICE_INFO:
-      return WrapInProvider(
-          IOSChromeProfileSyncServiceFactory::GetForBrowserState(browser_state_)
-              ->GetDeviceInfoSyncableService());
+      return IOSChromeProfileSyncServiceFactory::GetForBrowserState(
+                 browser_state_)
+          ->GetDeviceInfoSyncableService()
+          ->AsWeakPtr();
     case syncer::PREFERENCES:
+      return browser_state_->GetSyncablePrefs()
+          ->GetSyncableService(syncer::PREFERENCES)
+          ->AsWeakPtr();
     case syncer::PRIORITY_PREFERENCES:
-      return WrapInProvider(
-          browser_state_->GetSyncablePrefs()->GetSyncableService(type));
+      return browser_state_->GetSyncablePrefs()
+          ->GetSyncableService(syncer::PRIORITY_PREFERENCES)
+          ->AsWeakPtr();
     case syncer::AUTOFILL:
     case syncer::AUTOFILL_PROFILE:
     case syncer::AUTOFILL_WALLET_DATA:
     case syncer::AUTOFILL_WALLET_METADATA: {
       if (!web_data_service_)
-        return WrapInProvider(nullptr);
+        return base::WeakPtr<syncer::SyncableService>();
       if (type == syncer::AUTOFILL) {
-        return WrapInWeakPtrCallback(
-            base::Bind(&AutocompleteSyncableService::FromWebDataService,
-                       base::RetainedRef(web_data_service_)));
+        return autofill::AutocompleteSyncableService::FromWebDataService(
+                   web_data_service_.get())
+            ->AsWeakPtr();
       } else if (type == syncer::AUTOFILL_PROFILE) {
-        return WrapInWeakPtrCallback(
-            base::Bind(&AutofillProfileSyncableService::FromWebDataService,
-                       base::RetainedRef(web_data_service_)));
+        return autofill::AutofillProfileSyncableService::FromWebDataService(
+                   web_data_service_.get())
+            ->AsWeakPtr();
       } else if (type == syncer::AUTOFILL_WALLET_METADATA) {
-        return WrapInWeakPtrCallback(base::Bind(
-            &AutofillWalletMetadataSyncableService::FromWebDataService,
-            base::RetainedRef(web_data_service_)));
+        return autofill::AutofillWalletMetadataSyncableService::
+            FromWebDataService(web_data_service_.get())
+                ->AsWeakPtr();
       }
-      return WrapInWeakPtrCallback(
-          base::Bind(&AutofillWalletSyncableService::FromWebDataService,
-                     base::RetainedRef(web_data_service_)));
+      return autofill::AutofillWalletSyncableService::FromWebDataService(
+                 web_data_service_.get())
+          ->AsWeakPtr();
     }
     case syncer::HISTORY_DELETE_DIRECTIVES: {
-      return WrapInProvider(ios::HistoryServiceFactory::GetForBrowserState(
-          browser_state_, ServiceAccessType::EXPLICIT_ACCESS));
+      history::HistoryService* history =
+          ios::HistoryServiceFactory::GetForBrowserState(
+              browser_state_, ServiceAccessType::EXPLICIT_ACCESS);
+      return history ? history->AsWeakPtr()
+                     : base::WeakPtr<history::HistoryService>();
     }
     case syncer::TYPED_URLS: {
       history::HistoryService* history =
           ios::HistoryServiceFactory::GetForBrowserState(
               browser_state_, ServiceAccessType::EXPLICIT_ACCESS);
-      return WrapInProvider(history ? history->GetTypedUrlSyncableService()
-                                    : nullptr);
+      return history ? history->GetTypedUrlSyncableService()->AsWeakPtr()
+                     : base::WeakPtr<syncer::SyncableService>();
     }
     case syncer::FAVICON_IMAGES:
     case syncer::FAVICON_TRACKING: {
-      return WrapInProvider(
+      sync_sessions::FaviconCache* favicons =
           IOSChromeProfileSyncServiceFactory::GetForBrowserState(browser_state_)
-              ->GetFaviconCache());
+              ->GetFaviconCache();
+      return favicons ? favicons->AsWeakPtr()
+                      : base::WeakPtr<syncer::SyncableService>();
     }
     case syncer::ARTICLES: {
       // DomDistillerService is used in iOS ReadingList. The distilled articles
       // are saved separately and must not be synced.
       // Add a not reached to avoid having ARTICLES sync be enabled silently.
       NOTREACHED();
-      return WrapInProvider(nullptr);
+      return base::WeakPtr<syncer::SyncableService>();
     }
     case syncer::SESSIONS: {
-      return WrapInProvider(
-          IOSChromeProfileSyncServiceFactory::GetForBrowserState(browser_state_)
-              ->GetSessionsSyncableService());
+      return IOSChromeProfileSyncServiceFactory::GetForBrowserState(
+                 browser_state_)
+          ->GetSessionsSyncableService()
+          ->AsWeakPtr();
     }
     case syncer::PASSWORDS: {
-      return password_store_ ? base::Bind(&password_manager::PasswordStore::
-                                              GetPasswordSyncableService,
-                                          base::RetainedRef(password_store_))
-                             : WrapInProvider(nullptr);
+      return password_store_ ? password_store_->GetPasswordSyncableService()
+                             : base::WeakPtr<syncer::SyncableService>();
     }
     default:
       NOTREACHED();
-      return WrapInProvider(nullptr);
+      return base::WeakPtr<syncer::SyncableService>();
   }
 }
 
 base::WeakPtr<syncer::ModelTypeSyncBridge>
 IOSChromeSyncClient::GetSyncBridgeForModelType(syncer::ModelType type) {
   switch (type) {
     case syncer::DEVICE_INFO:
       return IOSChromeProfileSyncServiceFactory::GetForBrowserState(
                  browser_state_)
           ->GetDeviceInfoSyncBridge()
@@ skipping 71 matching lines @@
         IOSChromeProfileSyncServiceFactory::GetForBrowserState(browser_state);
     if (profile_sync_service != nullptr) {
       const syncer::DeviceInfoTracker* tracker =
           profile_sync_service->GetDeviceInfoTracker();
       if (tracker != nullptr) {
         trackers->push_back(tracker);
       }
     }
   }
 }