[Sync] ModelTypeStoreImpl implementation

This is implementation of ModelTypeStore interface.
Calls are forwarded to ModelTypeStoreBackend with ids formatted into
record keys. Typical pattern for cross-thread communication is that
API function creates scoped_ptr variables that will hold future result.
These variables are passed as pointers to task that invokes backend. The
ownership of these variables is passed to reply object which will be
posted when backend function completes.

This change lacks tests involving persistence across store initialization
and tests with faulty env. These will be added in separate change.

R=stanisc@chromium.org,skym@chromium.org
BUG=517663

Review URL: https://codereview.chromium.org/1460333002

Cr-Commit-Position: refs/heads/master@{#361528}

3 files changed, 34 insertions, 25 deletions

diff --git a/sync/api/mock_model_type_store.cc b/sync/api/mock_model_type_store.cc
index 6759be6..2887728 100644
--- a/sync/api/mock_model_type_store.cc
+++ b/sync/api/mock_model_type_store.cc
@@ -17,17 +17,18 @@ MockModelTypeStore::MockModelTypeStore() {}
 MockModelTypeStore::~MockModelTypeStore() {}
 
 void MockModelTypeStore::ReadData(const IdList& id_list,
-                                  const ReadRecordsCallback& callback) {
+                                  const ReadDataCallback& callback) {
   if (!read_data_handler_.is_null()) {
     read_data_handler_.Run(id_list, callback);
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, Result::SUCCESS,
-                              base::Passed(scoped_ptr<RecordList>())));
+                              base::Passed(scoped_ptr<RecordList>()),
+                              base::Passed(scoped_ptr<IdList>())));
   }
 }
 
-void MockModelTypeStore::ReadAllData(const ReadRecordsCallback& callback) {
+void MockModelTypeStore::ReadAllData(const ReadAllDataCallback& callback) {
   if (!read_all_data_handler_.is_null()) {
     read_all_data_handler_.Run(callback);
   } else {
@@ -107,12 +108,12 @@ void MockModelTypeStore::DeleteGlobalMetadata(WriteBatch* write_batch) {
 }
 
 void MockModelTypeStore::RegisterReadDataHandler(
-    const ReadRecordsSignature& handler) {
+    const ReadDataSignature& handler) {
   read_data_handler_ = handler;
 }
 
 void MockModelTypeStore::RegisterReadAllDataHandler(
-    const ReadAllRecordsSignature& handler) {
+    const ReadAllDataSignature& handler) {
   read_all_data_handler_ = handler;
 }
 
diff --git a/sync/api/mock_model_type_store.h b/sync/api/mock_model_type_store.h
index 123d456..49913d0 100644
--- a/sync/api/mock_model_type_store.h
+++ b/sync/api/mock_model_type_store.h
@@ -21,7 +21,7 @@ namespace syncer_v2 {
 // Here is an example:
 // ===
 // void OnReadData(const ModelTypeStore::IdList& id_list,
-//                 const ModelTypeStore::ReadRecordsCallback& callback) {
+//                 const ModelTypeStore::ReadAllDataCallback& callback) {
 //   // Verify id_list here.
 //   // Prepare fake response.
 //   scoped_ptr<ModelTypeStore::RecordList> record_list(
@@ -43,10 +43,9 @@ namespace syncer_v2 {
 class MockModelTypeStore : public ModelTypeStore {
  public:
   // Signatures for all ModelTypeStore virtual functions.
-  typedef base::Callback<void(const ReadRecordsCallback&)>
-      ReadAllRecordsSignature;
-  typedef base::Callback<void(const IdList&, const ReadRecordsCallback&)>
-      ReadRecordsSignature;
+  typedef base::Callback<void(const ReadAllDataCallback&)> ReadAllDataSignature;
+  typedef base::Callback<void(const IdList&, const ReadDataCallback&)>
+      ReadDataSignature;
   typedef base::Callback<void(const ReadMetadataCallback& callback)>
       ReadAllMetadataSignature;
   typedef base::Callback<void(scoped_ptr<WriteBatch>, CallbackWithResult)>
@@ -65,8 +64,8 @@ class MockModelTypeStore : public ModelTypeStore {
 
   // ModelTypeStore implementation.
   void ReadData(const IdList& id_list,
-                const ReadRecordsCallback& callback) override;
-  void ReadAllData(const ReadRecordsCallback& callback) override;
+                const ReadDataCallback& callback) override;
+  void ReadAllData(const ReadAllDataCallback& callback) override;
   void ReadAllMetadata(const ReadMetadataCallback& callback) override;
 
   scoped_ptr<WriteBatch> CreateWriteBatch() override;
@@ -86,8 +85,8 @@ class MockModelTypeStore : public ModelTypeStore {
   void DeleteGlobalMetadata(WriteBatch* write_batch) override;
 
   // Register handler functions.
-  void RegisterReadDataHandler(const ReadRecordsSignature& handler);
-  void RegisterReadAllDataHandler(const ReadAllRecordsSignature& handler);
+  void RegisterReadDataHandler(const ReadDataSignature& handler);
+  void RegisterReadAllDataHandler(const ReadAllDataSignature& handler);
   void RegisterReadAllMetadataHandler(const ReadAllMetadataSignature& handler);
   void RegisterCommitWriteBatchHandler(
       const CommitWriteBatchSignature& handler);
@@ -101,8 +100,8 @@ class MockModelTypeStore : public ModelTypeStore {
       const DeleteGlobalMetadataSignature& handler);
 
  private:
-  ReadRecordsSignature read_data_handler_;
-  ReadAllRecordsSignature read_all_data_handler_;
+  ReadDataSignature read_data_handler_;
+  ReadAllDataSignature read_all_data_handler_;
   ReadAllMetadataSignature read_all_metadata_handler_;
   CommitWriteBatchSignature commit_write_batch_handler_;
   WriteRecordSignature write_data_handler_;
diff --git a/sync/api/model_type_store.h b/sync/api/model_type_store.h
index 2c0e4d3..c37eddd 100644
--- a/sync/api/model_type_store.h
+++ b/sync/api/model_type_store.h
@@ -70,13 +70,20 @@ class SYNC_EXPORT ModelTypeStore {
   typedef std::vector<Record> RecordList;
   typedef std::vector<std::string> IdList;
 
-  typedef base::Callback<void(Result, scoped_ptr<ModelTypeStore>)> InitCallback;
-  typedef base::Callback<void(Result)> CallbackWithResult;
-  typedef base::Callback<void(Result, scoped_ptr<RecordList>)>
-      ReadRecordsCallback;
-  typedef base::Callback<void(Result,
-                              scoped_ptr<RecordList>,
-                              const std::string&)> ReadMetadataCallback;
+  typedef base::Callback<void(Result result, scoped_ptr<ModelTypeStore> store)>
+      InitCallback;
+  typedef base::Callback<void(Result result)> CallbackWithResult;
+  typedef base::Callback<void(Result result,
+                              scoped_ptr<RecordList> data_records,
+                              scoped_ptr<IdList> missing_id_list)>
+      ReadDataCallback;
+  typedef base::Callback<void(Result result,
+                              scoped_ptr<RecordList> data_records)>
+      ReadAllDataCallback;
+  typedef base::Callback<void(Result result,
+                              scoped_ptr<RecordList> metadata_records,
+                              const std::string& global_metadata)>
+      ReadMetadataCallback;
 
   // Creates store object backed by in-memory leveldb database. It is used in
   // tests.
@@ -90,9 +97,11 @@ class SYNC_EXPORT ModelTypeStore {
   // and RecordList contains some records that were read successfully. There is
   // no guarantee that RecordList will contain all successfully read records in
   // this case.
+  // Callback for ReadData (ReadDataCallback) in addition receives list of ids
+  // that were not found in store (missing_id_list).
   virtual void ReadData(const IdList& id_list,
-                        const ReadRecordsCallback& callback) = 0;
-  virtual void ReadAllData(const ReadRecordsCallback& callback) = 0;
+                        const ReadDataCallback& callback) = 0;
+  virtual void ReadAllData(const ReadAllDataCallback& callback) = 0;
   // ReadMetadataCallback will be invoked with three parameters: result of
   // operation, list of metadata records and global metadata.
   virtual void ReadAllMetadata(const ReadMetadataCallback& callback) = 0;