[USS] Store supports hosting multiple datatypes per database

sync/internal_api/model_type_store_impl.cc

Index: sync/internal_api/model_type_store_impl.cc
diff --git a/sync/internal_api/model_type_store_impl.cc b/sync/internal_api/model_type_store_impl.cc
index 18f96f057bfb876a6964e7317d2882128b0131e3..4134f785436edaf958bc307cfea25bd31e5001d5 100644
--- a/sync/internal_api/model_type_store_impl.cc
+++ b/sync/internal_api/model_type_store_impl.cc
@@ -28,20 +28,20 @@ const char kMetadataPrefix[] = "-md-";
 // Key for global metadata record.
 const char kGlobalMetadataKey[] = "GlobalMetadata";
 
-void NoOpForBackendDtor(std::unique_ptr<ModelTypeStoreBackend> backend) {
-  // This function was intentionally left blank.
+void OpsForBackendDtor(scoped_refptr<ModelTypeStoreBackend> backend) {
+  ModelTypeStoreBackend::Disconnect(backend);
 }
 
 }  // namespace
 
 // static
 std::string ModelTypeStoreImpl::FormatDataPrefix(const syncer::ModelType type) {
-  return std::string(syncer::ModelTypeToTag(type)) + kDataPrefix;
+  return std::string(syncer::GetModelTypeRootTag(type)) + kDataPrefix;
 }
 
 // static
 std::string ModelTypeStoreImpl::FormatMetaPrefix(const syncer::ModelType type) {
-  return std::string(syncer::ModelTypeToTag(type)) + kMetadataPrefix;
+  return std::string(syncer::GetModelTypeRootTag(type)) + kMetadataPrefix;
 }
 
 // static
@@ -51,21 +51,21 @@ leveldb::WriteBatch* ModelTypeStoreImpl::GetLeveldbWriteBatch(
 }
 
 std::string ModelTypeStoreImpl::FormatDataKey(const std::string& id) {
-  return dataPrefix_ + id;
+  return data_prefix_ + id;
 }
 
 std::string ModelTypeStoreImpl::FormatMetadataKey(const std::string& id) {
-  return metadataPrefix_ + id;
+  return metadata_prefix_ + id;
 }
 
 ModelTypeStoreImpl::ModelTypeStoreImpl(
     const syncer::ModelType type,
-    std::unique_ptr<ModelTypeStoreBackend> backend,
+    scoped_refptr<ModelTypeStoreBackend> backend,
     scoped_refptr<base::SequencedTaskRunner> backend_task_runner)
-    : backend_(std::move(backend)),
+    : backend_(backend),
       backend_task_runner_(backend_task_runner),
-      dataPrefix_(FormatDataPrefix(type)),
-      metadataPrefix_(FormatMetaPrefix(type)),
+      data_prefix_(FormatDataPrefix(type)),
+      metadata_prefix_(FormatMetaPrefix(type)),
       weak_ptr_factory_(this) {
   DCHECK(backend_);
   DCHECK(backend_task_runner_);
@@ -74,7 +74,7 @@ ModelTypeStoreImpl::ModelTypeStoreImpl(
 ModelTypeStoreImpl::~ModelTypeStoreImpl() {
   DCHECK(CalledOnValidThread());
   backend_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&NoOpForBackendDtor, base::Passed(&backend_)));
+      FROM_HERE, base::Bind(&OpsForBackendDtor, base::Passed(&backend_)));
 }
 
 // static
@@ -85,14 +85,15 @@ void ModelTypeStoreImpl::CreateStore(
     const InitCallback& callback) {
   DCHECK(!callback.is_null());
 
-  std::unique_ptr<ModelTypeStoreBackend> backend(new ModelTypeStoreBackend());
+  scoped_refptr<ModelTypeStoreBackend> backend =
+      ModelTypeStoreBackend::GetOrCreateBackend(path, nullptr,
+                                                blocking_task_runner);
 
   std::unique_ptr<ModelTypeStoreImpl> store(
-      new ModelTypeStoreImpl(type, std::move(backend), blocking_task_runner));
+      new ModelTypeStoreImpl(type, backend, blocking_task_runner));
 
-  auto task =
-      base::Bind(&ModelTypeStoreBackend::Init,
-                 base::Unretained(store->backend_.get()), path, nullptr);
+  auto task = base::Bind(&ModelTypeStoreBackend::InitResult,
+                         base::Unretained(store->backend_.get()));
   auto reply = base::Bind(&ModelTypeStoreImpl::BackendInitDone, callback,
                           base::Passed(&store));
 
@@ -112,22 +113,23 @@ void ModelTypeStoreImpl::CreateInMemoryStoreForTest(
   // for Init call.
   leveldb::Env* env_ptr = env.get();
 
-  std::unique_ptr<ModelTypeStoreBackend> backend(new ModelTypeStoreBackend());
-  backend->TakeEnvOwnership(std::move(env));
+  std::string path;
+  env_ptr->GetTestDirectory(&path);
+  path += "/in-memory";
 
   // In-memory store backend works on the same thread as test.
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       base::ThreadTaskRunnerHandle::Get();
+
+  scoped_refptr<ModelTypeStoreBackend> backend =
+      ModelTypeStoreBackend::GetOrCreateBackend(path, env_ptr, task_runner);
+  backend->TakeEnvOwnership(std::move(env));
+
   std::unique_ptr<ModelTypeStoreImpl> store(new ModelTypeStoreImpl(
       syncer::UNSPECIFIED, std::move(backend), task_runner));
 
-  std::string path;
-  env_ptr->GetTestDirectory(&path);
-  path += "/in-memory";
-
-  auto task =
-      base::Bind(&ModelTypeStoreBackend::Init,
-                 base::Unretained(store->backend_.get()), path, env_ptr);
+  auto task = base::Bind(&ModelTypeStoreBackend::InitResult,
+                         base::Unretained(store->backend_.get()));
   auto reply = base::Bind(&ModelTypeStoreImpl::BackendInitDone, callback,
                           base::Passed(&store));
 
@@ -165,8 +167,8 @@ void ModelTypeStoreImpl::ReadData(const IdList& id_list,
   std::unique_ptr<IdList> missing_id_list(new IdList());
 
   auto task = base::Bind(&ModelTypeStoreBackend::ReadRecordsWithPrefix,
-                         base::Unretained(backend_.get()), dataPrefix_, id_list,
-                         base::Unretained(record_list.get()),
+                         base::Unretained(backend_.get()), data_prefix_,
+                         id_list, base::Unretained(record_list.get()),
                          base::Unretained(missing_id_list.get()));
   auto reply = base::Bind(
       &ModelTypeStoreImpl::ReadDataDone, weak_ptr_factory_.GetWeakPtr(),
@@ -188,7 +190,7 @@ void ModelTypeStoreImpl::ReadAllData(const ReadAllDataCallback& callback) {
   DCHECK(!callback.is_null());
   std::unique_ptr<RecordList> record_list(new RecordList());
   auto task = base::Bind(&ModelTypeStoreBackend::ReadAllRecordsWithPrefix,
-                         base::Unretained(backend_.get()), dataPrefix_,
+                         base::Unretained(backend_.get()), data_prefix_,
                          base::Unretained(record_list.get()));
   auto reply = base::Bind(&ModelTypeStoreImpl::ReadAllDataDone,
                           weak_ptr_factory_.GetWeakPtr(), callback,
@@ -215,7 +217,7 @@ void ModelTypeStoreImpl::ReadAllMetadata(const ReadMetadataCallback& callback) {
   // issue read operation for global metadata record.
   std::unique_ptr<RecordList> metadata_records(new RecordList());
   auto task = base::Bind(&ModelTypeStoreBackend::ReadAllRecordsWithPrefix,
-                         base::Unretained(backend_.get()), metadataPrefix_,
+                         base::Unretained(backend_.get()), metadata_prefix_,
                          base::Unretained(metadata_records.get()));
   auto reply = base::Bind(&ModelTypeStoreImpl::ReadMetadataRecordsDone,
                           weak_ptr_factory_.GetWeakPtr(), callback,