[Sync] Switch ModelTypeStore* from blocking pool to post_task.h

components/browser_sync/profile_sync_service.cc

 // Copyright (c) 2012 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/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 224 matching lines @@
   sessions_sync_manager_ = base::MakeUnique<SessionsSyncManager>(
       sync_client_->GetSyncSessionsClient(), &sync_prefs_, local_device_.get(),
       std::move(router),
       base::Bind(&ProfileSyncService::NotifyForeignSessionUpdated,
                  sync_enabled_weak_factory_.GetWeakPtr()),
       base::Bind(&ProfileSyncService::TriggerRefresh,
                  sync_enabled_weak_factory_.GetWeakPtr(),
                  syncer::ModelTypeSet(syncer::SESSIONS)));
 
   if (base::FeatureList::IsEnabled(switches::kSyncUSSDeviceInfo)) {
-    // TODO(skym): Stop creating leveldb files when signed out.
-    // TODO(skym): Verify using AsUTF8Unsafe is okay here. Should work as long
-    // as the Local State file is guaranteed to be UTF-8.
     const syncer::ModelTypeStoreFactory& store_factory =
-        GetModelTypeStoreFactory(syncer::DEVICE_INFO, base_directory_,
-                                 sync_client_->GetBlockingPool());
+        GetModelTypeStoreFactory(syncer::DEVICE_INFO, base_directory_);
     device_info_sync_bridge_ = base::MakeUnique<DeviceInfoSyncBridge>(
         local_device_.get(), store_factory,
         base::BindRepeating(
             &ModelTypeChangeProcessor::Create,
             base::BindRepeating(&syncer::ReportUnrecoverableError, channel_)));
   } else {
     device_info_sync_service_ =
         base::MakeUnique<DeviceInfoSyncService>(local_device_.get());
   }
 
@@ skipping 1413 matching lines @@
 
 void ProfileSyncService::SetPlatformSyncAllowedProvider(
     const PlatformSyncAllowedProvider& platform_sync_allowed_provider) {
   DCHECK(thread_checker_.CalledOnValidThread());
   platform_sync_allowed_provider_ = platform_sync_allowed_provider;
 }
 
 // static
 syncer::ModelTypeStoreFactory ProfileSyncService::GetModelTypeStoreFactory(
     ModelType type,
-    const base::FilePath& base_path,
-    base::SequencedWorkerPool* blocking_pool) {
+    const base::FilePath& base_path) {
   // TODO(skym): Verify using AsUTF8Unsafe is okay here. Should work as long
   // as the Local State file is guaranteed to be UTF-8.
-  std::string path = FormatSharedModelTypeStorePath(base_path).AsUTF8Unsafe();
-  base::SequencedWorkerPool::SequenceToken sequence_token =
-      blocking_pool->GetNamedSequenceToken(path);
-  scoped_refptr<base::SequencedTaskRunner> task_runner =
-      blocking_pool->GetSequencedTaskRunnerWithShutdownBehavior(
-          blocking_pool->GetNamedSequenceToken(path),
-          base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
-  return base::Bind(&ModelTypeStore::CreateStore, type, path, task_runner);
+  const std::string path =
+      FormatSharedModelTypeStorePath(base_path).AsUTF8Unsafe();
+  return base::Bind(&ModelTypeStore::CreateStore, type, path);
 }
 
 void ProfileSyncService::ConfigureDataTypeManager() {
   // Don't configure datatypes if the setup UI is still on the screen - this
   // is to help multi-screen setting UIs (like iOS) where they don't want to
   // start syncing data until the user is done configuring encryption options,
   // etc. ReconfigureDatatypeManager() will get called again once the UI calls
   // SetSetupInProgress(false).
   if (!CanConfigureDataTypes()) {
     // If we can't configure the data type manager yet, we should still notify
@@ skipping 722 matching lines @@
     return;
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsEngineInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 }  // namespace browser_sync