sync: Add non-blocking type encryption (retry)

sync/engine/model_type_entity.h

 // Copyright 2014 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 SYNC_ENGINE_MODEL_TYPE_ENTITY_H_
 #define SYNC_ENGINE_MODEL_TYPE_ENTITY_H_
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 28 matching lines @@
 
   // Construct an instance representing an item newly received from the server.
   static scoped_ptr<ModelTypeEntity> FromServerUpdate(
       const std::string& id,
       const std::string& client_tag_hash,
       const std::string& non_unique_name,
       int64 version,
       const sync_pb::EntitySpecifics& specifics,
       bool deleted,
       base::Time ctime,
-      base::Time mtime);
+      base::Time mtime,
+      const std::string& encryption_key_name);
 
   // TODO(rlarocque): Implement FromDisk constructor when we implement storage.
 
   ~ModelTypeEntity();
 
   // Returns true if this data is out of sync with local storage.
   bool IsWriteRequired() const;
 
   // Returns true if this data is out of sync with the server.
   // A commit may or may not be in progress at this time.
@@ skipping 12 matching lines @@
   // Returns true if the specified update version conflicts with local changes.
   bool UpdateIsInConflict(int64 update_version) const;
 
   // Applies an update from the sync server.
   //
   // Overrides any local changes.  Check UpdateIsInConflict() before calling
   // this function if you want to handle conflicts differently.
   void ApplyUpdateFromServer(int64 update_version,
                              bool deleted,
                              const sync_pb::EntitySpecifics& specifics,
-                             base::Time mtime);
+                             base::Time mtime,
+                             const std::string& encryption_key_name);
 
   // Applies a local change to this item.
   void MakeLocalChange(const sync_pb::EntitySpecifics& specifics);
 
+  // Schedule a commit if the |name| does not match this item's last known
+  // encryption key.  The worker that performs the commit is expected to
+  // encrypt the item using the latest available key.
+  void UpdateDesiredEncryptionKey(const std::string& name);
+
   // Applies a local deletion to this item.
   void Delete();
 
   // Initializes a message representing this item's uncommitted state
   // to be forwarded to the sync server for committing.
   void InitializeCommitRequestData(CommitRequestData* request) const;
 
   // Notes that the current version of this item has been queued for commit.
   void SetCommitRequestInProgress();
 
   // Receives a successful commit response.
   //
   // Sucssful commit responses can overwrite an item's ID.
   //
   // Note that the receipt of a successful commit response does not necessarily
   // unset IsUnsynced().  If many local changes occur in quick succession, it's
   // possible that the committed item was already out of date by the time it
   // reached the server.
   void ReceiveCommitResponse(const std::string& id,
                              int64 sequence_number,
-                             int64 response_version);
+                             int64 response_version,
+                             const std::string& encryption_key_name);
 
   // Clears any in-memory sync state associated with outstanding commits.
   void ClearTransientSyncState();
 
   // Clears all sync state.  Invoked when a user signs out.
   void ClearSyncState();
 
  private:
   ModelTypeEntity(int64 sequence_number,
                   int64 commit_requested_sequence_number,
                   int64 acked_sequence_number,
                   int64 base_version,
                   bool is_dirty,
                   const std::string& id,
                   const std::string& client_tag_hash,
                   const std::string& non_unique_name,
                   const sync_pb::EntitySpecifics& specifics,
                   bool deleted,
                   base::Time ctime,
-                  base::Time mtime);
+                  base::Time mtime,
+                  const std::string& encryption_key_name);
 
   // A sequence number used to track in-progress commits.  Each local change
   // increments this number.
   int64 sequence_number_;
 
   // The sequence number of the last item sent to the sync thread.
   int64 commit_requested_sequence_number_;
 
   // The sequence number of the last item known to be successfully committed.
   int64 acked_sequence_number_;
@@ skipping 40 matching lines @@
 
   // Whether or not the item is deleted.  The |specifics_| field may be empty
   // if this flag is true.
   bool deleted_;
 
   // Entity creation and modification timestamps.
   // Assigned by the client and synced by the server, though the server usually
   // doesn't bother to inspect their values.
   base::Time ctime_;
   base::Time mtime_;
+
+  // The name of the encryption key used to encrypt this item on the server.
+  // Empty when no encryption is in use.
+  std::string encryption_key_name_;
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_ENGINE_MODEL_TYPE_ENTITY_H_