| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef COMPONENTS_SYNC_API_MODEL_TYPE_STORE_H_ | |
| 6 #define COMPONENTS_SYNC_API_MODEL_TYPE_STORE_H_ | |
| 7 | |
| 8 #include <memory> | |
| 9 #include <string> | |
| 10 #include <vector> | |
| 11 | |
| 12 #include "base/callback.h" | |
| 13 #include "base/macros.h" | |
| 14 #include "components/sync/base/model_type.h" | |
| 15 | |
| 16 namespace base { | |
| 17 class SequencedTaskRunner; | |
| 18 } // namespace base | |
| 19 | |
| 20 namespace syncer { | |
| 21 | |
| 22 // ModelTypeStore is leveldb backed store for model type's data, metadata and | |
| 23 // global metadata. | |
| 24 // | |
| 25 // Store keeps records for entries identified by ids. For each entry store keeps | |
| 26 // data and metadata. Also store keeps one record for global metadata. | |
| 27 // | |
| 28 // To create store call one of Create*Store static factory functions. Model type | |
| 29 // controls store's lifetime with returned unique_ptr. Call to Create*Store | |
| 30 // function triggers asynchronous store backend initialization, callback will be | |
| 31 // called with results when initialization is done. | |
| 32 // | |
| 33 // Read operations are asynchronous, initiated with one of Read* functions, | |
| 34 // provided callback will be called with result code and output of read | |
| 35 // operation. | |
| 36 // | |
| 37 // Write operations are done in context of write batch. To get one call | |
| 38 // CreateWriteBatch(). After that pass write batch object to Write/Delete | |
| 39 // functions. WriteBatch only accumulates pending changes, doesn't actually do | |
| 40 // data modification. Calling CommitWriteBatch writes all accumulated changes to | |
| 41 // disk atomically. Callback passed to CommitWriteBatch will be called with | |
| 42 // result of write operation. If write batch object is destroyed without | |
| 43 // comitting accumulated write operations will not be persisted. | |
| 44 // | |
| 45 // Destroying store object doesn't necessarily cancel asynchronous operations | |
| 46 // issued previously. You should be prepared to handle callbacks from those | |
| 47 // operations. | |
| 48 class ModelTypeStore { | |
| 49 public: | |
| 50 // Result of store operations. | |
| 51 enum class Result { | |
| 52 SUCCESS, | |
| 53 UNSPECIFIED_ERROR, | |
| 54 }; | |
| 55 | |
| 56 // Output of read operations is passed back as list of Record structures. | |
| 57 struct Record { | |
| 58 Record(const std::string& id, const std::string& value) | |
| 59 : id(id), value(value) {} | |
| 60 | |
| 61 std::string id; | |
| 62 std::string value; | |
| 63 }; | |
| 64 | |
| 65 // WriteBatch object is used in all modification operations. | |
| 66 class WriteBatch { | |
| 67 public: | |
| 68 virtual ~WriteBatch(); | |
| 69 | |
| 70 protected: | |
| 71 friend class MockModelTypeStore; | |
| 72 WriteBatch(); | |
| 73 }; | |
| 74 | |
| 75 typedef std::vector<Record> RecordList; | |
| 76 typedef std::vector<std::string> IdList; | |
| 77 | |
| 78 typedef base::Callback<void(Result result, | |
| 79 std::unique_ptr<ModelTypeStore> store)> | |
| 80 InitCallback; | |
| 81 typedef base::Callback<void(Result result)> CallbackWithResult; | |
| 82 typedef base::Callback<void(Result result, | |
| 83 std::unique_ptr<RecordList> data_records, | |
| 84 std::unique_ptr<IdList> missing_id_list)> | |
| 85 ReadDataCallback; | |
| 86 typedef base::Callback<void(Result result, | |
| 87 std::unique_ptr<RecordList> data_records)> | |
| 88 ReadAllDataCallback; | |
| 89 typedef base::Callback<void(Result result, | |
| 90 std::unique_ptr<RecordList> metadata_records, | |
| 91 const std::string& global_metadata)> | |
| 92 ReadMetadataCallback; | |
| 93 | |
| 94 // CreateStore takes |path| and |blocking_task_runner|. Here is how to get | |
| 95 // task runner in production code: | |
| 96 // | |
| 97 // base::SequencedWorkerPool* worker_pool = | |
| 98 // content::BrowserThread::GetBlockingPool(); | |
| 99 // scoped_refptr<base::SequencedTaskRunner> blocking_task_runner( | |
| 100 // worker_pool->GetSequencedTaskRunnerWithShutdownBehavior( | |
| 101 // worker_pool->GetSequenceToken(), | |
| 102 // base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)); | |
| 103 // | |
| 104 // In test get task runner from MessageLoop::task_runner(). | |
| 105 static void CreateStore( | |
| 106 const ModelType type, | |
| 107 const std::string& path, | |
| 108 scoped_refptr<base::SequencedTaskRunner> blocking_task_runner, | |
| 109 const InitCallback& callback); | |
| 110 // Creates store object backed by in-memory leveldb database. It is used in | |
| 111 // tests. | |
| 112 static void CreateInMemoryStoreForTest(const InitCallback& callback); | |
| 113 | |
| 114 virtual ~ModelTypeStore(); | |
| 115 | |
| 116 // Read operations return records either for all entries or only for ones | |
| 117 // identified in |id_list|. Result is SUCCESS if all records were read | |
| 118 // successfully. If reading any of records fails result is UNSPECIFIED_ERROR | |
| 119 // and RecordList contains some records that were read successfully. There is | |
| 120 // no guarantee that RecordList will contain all successfully read records in | |
| 121 // this case. | |
| 122 // Callback for ReadData (ReadDataCallback) in addition receives list of ids | |
| 123 // that were not found in store (missing_id_list). | |
| 124 virtual void ReadData(const IdList& id_list, | |
| 125 const ReadDataCallback& callback) = 0; | |
| 126 virtual void ReadAllData(const ReadAllDataCallback& callback) = 0; | |
| 127 // ReadMetadataCallback will be invoked with three parameters: result of | |
| 128 // operation, list of metadata records and global metadata. | |
| 129 virtual void ReadAllMetadata(const ReadMetadataCallback& callback) = 0; | |
| 130 | |
| 131 // Creates write batch for write operations. | |
| 132 virtual std::unique_ptr<WriteBatch> CreateWriteBatch() = 0; | |
| 133 | |
| 134 // Commits write operations accumulated in write batch. If write operation | |
| 135 // fails result is UNSPECIFIED_ERROR and write operations will not be | |
| 136 // reflected in the store. | |
| 137 virtual void CommitWriteBatch(std::unique_ptr<WriteBatch> write_batch, | |
| 138 const CallbackWithResult& callback) = 0; | |
| 139 | |
| 140 // Write operations. | |
| 141 virtual void WriteData(WriteBatch* write_batch, | |
| 142 const std::string& id, | |
| 143 const std::string& value) = 0; | |
| 144 virtual void WriteMetadata(WriteBatch* write_batch, | |
| 145 const std::string& id, | |
| 146 const std::string& value) = 0; | |
| 147 virtual void WriteGlobalMetadata(WriteBatch* write_batch, | |
| 148 const std::string& value) = 0; | |
| 149 virtual void DeleteData(WriteBatch* write_batch, const std::string& id) = 0; | |
| 150 virtual void DeleteMetadata(WriteBatch* write_batch, | |
| 151 const std::string& id) = 0; | |
| 152 virtual void DeleteGlobalMetadata(WriteBatch* write_batch) = 0; | |
| 153 // TODO(pavely): Consider implementing DeleteAllMetadata with following | |
| 154 // signature: | |
| 155 // virtual void DeleteAllMetadata(const CallbackWithResult& callback) = 0. | |
| 156 // It will delete all metadata records and global metadata record. | |
| 157 }; | |
| 158 | |
| 159 } // namespace syncer | |
| 160 | |
| 161 #endif // COMPONENTS_SYNC_API_MODEL_TYPE_STORE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2401223002:
[Sync] Renaming sync/api* to sync/model*. (Closed)
