1 // Copyright 2014 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 SYNC_INTERNAL_API_PUBLIC_NON_BLOCKING_SYNC_COMMON_H_ 6 #define SYNC_INTERNAL_API_PUBLIC_NON_BLOCKING_SYNC_COMMON_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/time/time.h" 12 #include "sync/base/sync_export.h" 13 #include "sync/protocol/sync.pb.h" 14 15 namespace syncer { 16 17 static const int64 kUncommittedVersion = -1; 18 19 // Data-type global state that must be accessed and updated on the sync thread, 20 // but persisted on or through the model thread. 21 struct SYNC_EXPORT_PRIVATE DataTypeState { 22 DataTypeState(); 23 ~DataTypeState(); 24 25 // The latest progress markers received from the server. 26 sync_pb::DataTypeProgressMarker progress_marker; 27 28 // A data type context. Sent to the server in every commit or update 29 // request. May be updated by either by responses from the server or 30 // requests made on the model thread. The interpretation of this value may 31 // be data-type specific. Many data types ignore it. 32 sync_pb::DataTypeContext type_context; 33 34 // The ID of the folder node that sits at the top of this type's folder 35 // hierarchy. We keep this around for legacy reasons. The protocol expects 36 // that all nodes of a certain type are children of the same type root 37 // entity. This entity is delivered by the server, and may not be available 38 // until the first download cycle has completed. 39 std::string type_root_id; 40 41 // This value is set if this type's data should be encrypted on the server. 42 // If this key changes, the client will need to re-commit all of its local 43 // data to the server using the new encryption key. 44 std::string encryption_key_name; 45 46 // A strictly increasing counter used to generate unique values for the 47 // client-assigned IDs. The incrementing and ID assignment happens on the 48 // sync thread, but we store the value here so we can pass it back to the 49 // model thread for persistence. This is probably unnecessary for the 50 // client-tagged data types supported by non-blocking sync, but we will 51 // continue to emulate the directory sync's behavior for now. 52 int64 next_client_id; 53 54 // This flag is set to true when the first download cycle is complete. The 55 // ModelTypeSyncProxy should not attempt to commit any items until this 56 // flag is set. 57 bool initial_sync_done; 58 }; 59 struct SYNC_EXPORT_PRIVATE CommitRequestData { 60 CommitRequestData(); 61 ~CommitRequestData(); 62 63 std::string id; 64 std::string client_tag_hash; 65 66 // Strictly incrementing number for in-progress commits. More information 67 // about its meaning can be found in comments in the files that make use of 68 // this struct. 69 int64 sequence_number; 70 71 int64 base_version; 72 base::Time ctime; 73 base::Time mtime; 74 std::string non_unique_name; 75 bool deleted; 76 sync_pb::EntitySpecifics specifics; 77 }; 78 79 struct SYNC_EXPORT_PRIVATE CommitResponseData { 80 CommitResponseData(); 81 ~CommitResponseData(); 82 83 std::string id; 84 std::string client_tag_hash; 85 int64 sequence_number; 86 int64 response_version; 87 }; 88 89 struct SYNC_EXPORT_PRIVATE UpdateResponseData { 90 UpdateResponseData(); 91 ~UpdateResponseData(); 92 93 std::string id; 94 std::string client_tag_hash; 95 int64 response_version; 96 base::Time ctime; 97 base::Time mtime; 98 std::string non_unique_name; 99 bool deleted; 100 sync_pb::EntitySpecifics specifics; 101 std::string encryption_key_name; 102 }; 103 104 typedef std::vector<CommitRequestData> CommitRequestDataList; 105 typedef std::vector<CommitResponseData> CommitResponseDataList; 106 typedef std::vector<UpdateResponseData> UpdateResponseDataList; 107 108 } // namespace syncer 109 110 #endif // SYNC_INTERNAL_API_PUBLIC_NON_BLOCKING_SYNC_COMMON_H_ 111