[Sync] ModelTypeStore factory shouldn't require valid PSS to function correctly

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 130 matching lines @@
     1000 * 3600 * 4,  // 4 hours.
 
     // Time to keep an entry from being discarded even when it
     // has no significant state, -1 to never discard.
     -1,
 
     // Don't use initial delay unless the last request was an error.
     false,
 };
 
-const base::FilePath::CharType kLevelDBFolderName[] =
-    FILE_PATH_LITERAL("LevelDB");
-
 }  // namespace
 
 ProfileSyncService::InitParams::InitParams() = default;
 ProfileSyncService::InitParams::InitParams(InitParams&& other) = default;
 ProfileSyncService::InitParams::~InitParams() = default;
 
 ProfileSyncService::ProfileSyncService(InitParams init_params)
     : SyncServiceBase(std::move(init_params.sync_client),
                       std::move(init_params.signin_wrapper),
                       init_params.channel,
                       init_params.base_directory,
                       init_params.debug_identifier),
       OAuth2TokenService::Consumer("sync"),
       last_auth_error_(AuthError::AuthErrorNone()),
       sync_service_url_(
           syncer::GetSyncServiceURL(*base::CommandLine::ForCurrentProcess(),
                                     init_params.channel)),
       network_time_update_callback_(
           std::move(init_params.network_time_update_callback)),
       url_request_context_(init_params.url_request_context),
-      blocking_task_runner_(std::move(init_params.blocking_task_runner)),
       is_first_time_sync_configure_(false),
       engine_initialized_(false),
       sync_disabled_by_admin_(false),
       is_auth_in_progress_(false),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       expect_sync_configuration_aborted_(false),
       configure_status_(DataTypeManager::UNKNOWN),
       oauth2_token_service_(init_params.oauth2_token_service),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       connection_status_(syncer::CONNECTION_NOT_ATTEMPTED),
@@ skipping 57 matching lines @@
       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());
     device_info_sync_bridge_ = base::MakeUnique<DeviceInfoSyncBridge>(
-        local_device_.get(), GetModelTypeStoreFactory(syncer::DEVICE_INFO),
+        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());
   }
 
   syncer::SyncApiComponentFactory::RegisterDataTypesMethod
       register_platform_types_callback =
@@ skipping 287 matching lines @@
 
   startup_controller_->OnDataTypeRequestsSyncStartup(type);
 }
 
 void ProfileSyncService::StartUpSlowEngineComponents() {
   invalidation::InvalidationService* invalidator =
       sync_client_->GetInvalidationService();
 
   engine_.reset(sync_client_->GetSyncApiComponentFactory()->CreateSyncEngine(
       debug_identifier_, invalidator, sync_prefs_.AsWeakPtr(),
-      sync_data_folder_));
+      FormatSyncDataPath(base_directory_)));
 
   // Clear any old errors the first time sync starts.
   if (!IsFirstSetupComplete())
     ClearStaleErrors();
 
   InitializeEngine();
 
   UpdateFirstSyncTimePref();
 
   ReportPreviousSessionMemoryWarningCount();
@@ skipping 115 matching lines @@
 }
 
 void ProfileSyncService::ShutdownImpl(syncer::ShutdownReason reason) {
   if (!engine_) {
     if (reason == syncer::ShutdownReason::DISABLE_SYNC && sync_thread_) {
       // If the engine is already shut down when a DISABLE_SYNC happens,
       // the data directory needs to be cleaned up here.
       sync_thread_->task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&syncer::syncable::Directory::DeleteDirectoryFiles,
-                     sync_data_folder_));
+                     FormatSyncDataPath(base_directory_)));
     }
     return;
   }
 
   if (reason == syncer::ShutdownReason::STOP_SYNC ||
       reason == syncer::ShutdownReason::DISABLE_SYNC) {
     RemoveClientFromServer();
   }
 
   // First, we spin down the engine to stop change processing as soon as
@@ skipping 215 matching lines @@
     signin_scoped_device_id = "local_device";
   } else {
     SigninClient* signin_client = signin_->GetOriginal()->signin_client();
     DCHECK(signin_client);
     std::string signin_scoped_device_id =
         signin_client->GetSigninScopedDeviceId();
   }
 
   // Initialize local device info.
   local_device_->Initialize(cache_guid, signin_scoped_device_id,
-                            blocking_task_runner_);
+                            sync_client_->GetBlockingPool());
 
   if (protocol_event_observers_.might_have_observers()) {
     engine_->RequestBufferedProtocolEventsAndEnableForwarding();
   }
 
   if (type_debug_info_observers_.might_have_observers()) {
     engine_->EnableDirectoryTypeDebugInfoForwarding();
   }
 
   // The very first time the backend initializes is effectively the first time
@@ skipping 719 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return engine_ && engine_->IsCryptographerReady(trans);
 }
 
 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) {
-  return base::Bind(&ModelTypeStore::CreateStore, type,
-                    sync_data_folder_.Append(base::FilePath(kLevelDBFolderName))
-                        .AsUTF8Unsafe(),
-                    blocking_task_runner_);
+    ModelType type,
+    const base::FilePath& base_path,
+    base::SequencedWorkerPool* blocking_pool) {
+  // 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);

[skym, 2017/03/08 19:28:15]

Cool!

+  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);
 }
 
 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 634 matching lines @@
 void ProfileSyncService::FlushDirectory() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   // engine_initialized_ implies engine_ isn't null and the manager exists.
   // If sync is not initialized yet, we fail silently.
   if (engine_initialized_)
     engine_->FlushDirectory();
 }
 
 base::FilePath ProfileSyncService::GetDirectoryPathForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return sync_data_folder_;
+  return FormatSyncDataPath(base_directory_);
 }
 
 base::MessageLoop* ProfileSyncService::GetSyncLoopForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (sync_thread_) {
     return sync_thread_->message_loop();
   } else {
     return nullptr;
   }
 }
@@ skipping 77 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsEngineInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync