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

components/sync/model/model_type_store.h

 // 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.
 
 #ifndef COMPONENTS_SYNC_MODEL_MODEL_TYPE_STORE_H_
 #define COMPONENTS_SYNC_MODEL_MODEL_TYPE_STORE_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/optional.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/model/metadata_batch.h"
 #include "components/sync/model/metadata_change_list.h"
 #include "components/sync/model/model_error.h"
 
-namespace base {
-class SequencedTaskRunner;
-}  // namespace base
-
 namespace syncer {
 
 // ModelTypeStore is leveldb backed store for model type's data, metadata and
 // global metadata.
 //
 // Store keeps records for entries identified by ids. For each entry store keeps
 // data and metadata. Also store keeps one record for global metadata.
 //
 // To create store call one of Create*Store static factory functions. Model type
 // controls store's lifetime with returned unique_ptr. Call to Create*Store
@@ skipping 83 matching lines @@
       base::Callback<void(Result result,
                           std::unique_ptr<RecordList> data_records,
                           std::unique_ptr<IdList> missing_id_list)>;
   using ReadAllDataCallback =
       base::Callback<void(Result result,
                           std::unique_ptr<RecordList> data_records)>;
   using ReadMetadataCallback =
       base::Callback<void(base::Optional<ModelError> error,
                           std::unique_ptr<MetadataBatch> metadata_batch)>;
 
-  // CreateStore takes |path| and |blocking_task_runner|. Here is how to get
-  // task runner in production code:
-  //
-  // base::SequencedWorkerPool* worker_pool =
-  //     content::BrowserThread::GetBlockingPool();
-  // scoped_refptr<base::SequencedTaskRunner> blocking_task_runner(
-  //     worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
-  //         worker_pool->GetNamedSequenceToken(path),
-  //         base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
-  //
-  // In test get task runner from MessageLoop::task_runner().
+  // CreateStore takes |path|, and will run blocking calls on a task runner
+  // scoped to the given path. Tests likely don't want to use this method.
   static void CreateStore(
       ModelType type,
       const std::string& path,
-      scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
       const InitCallback& callback);
-  // Creates store object backed by in-memory leveldb database. It is used in
-  // tests.
+  // Creates store object backed by in-memory leveldb database, gets its task
+  // runner from MessageLoop::task_runner(), and should only be used in tests.
   static void CreateInMemoryStoreForTest(ModelType type,
                                          const InitCallback& callback);
 
   virtual ~ModelTypeStore();
 
   // Read operations return records either for all entries or only for ones
   // identified in |id_list|. Result is SUCCESS if all records were read
   // successfully. If reading any of records fails result is UNSPECIFIED_ERROR
   // and RecordList contains some records that were read successfully. There is
   // no guarantee that RecordList will contain all successfully read records in
@@ skipping 40 matching lines @@
   // It will delete all metadata records and global metadata record.
 };
 
 // Typedef for a store factory that has all params bound except InitCallback.
 using ModelTypeStoreFactory =
     base::Callback<void(const ModelTypeStore::InitCallback&)>;
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_MODEL_MODEL_TYPE_STORE_H_