Update sync API to support attachments.

sync/api/sync_change_processor.h

 // Copyright 2012 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_API_SYNC_CHANGE_PROCESSOR_H_
 #define SYNC_API_SYNC_CHANGE_PROCESSOR_H_
 
 #include <vector>
 
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
 #include "sync/base/sync_export.h"
 #include "sync/internal_api/public/base/model_type.h"
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
 namespace syncer {
 
 class SyncChange;
 
 typedef std::vector<SyncChange> SyncChangeList;
 
 // An interface for services that handle receiving SyncChanges.
 class SYNC_EXPORT SyncChangeProcessor {
  public:
+  typedef base::Callback<void(const SyncData&)> GetSyncDataCallback;
+
   SyncChangeProcessor();
   virtual ~SyncChangeProcessor();
 
   // Process a list of SyncChanges.
   // Returns: A default SyncError (IsSet() == false) if no errors were
   //          encountered, and a filled SyncError (IsSet() == true)
   //          otherwise.
   // Inputs:
   //   |from_here|: allows tracking of where sync changes originate.
   //   |change_list|: is the list of sync changes in need of processing.
   virtual SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const SyncChangeList& change_list) = 0;
 
   // Fills a list of SyncData. This should create an up to date representation
   // of all the data known to the ChangeProcessor for |datatype|, and
   // should match/be a subset of the server's view of that datatype.
   //
   // WARNING: This can be a potentially slow & memory intensive operation and
   // should only be used when absolutely necessary / sparingly.
   virtual SyncDataList GetAllSyncData(ModelType type) const = 0;
+
+  // Retrieves the SyncData identified by |type| and |sync_tag| and invokes
+  // |callback|. If no such SyncData exists, IsValid on the SyncData passed to

[tim (not reviewing), 2014/03/10 22:55:58]

"... invokes |callback| asynchronously."

Also, what does "does not exist" mean here?  Locally?

[maniscalco, 2014/03/18 20:49:18]

Done.
That should have read "does not exist locally".  Comment updated.

+  // |callback| will return false.
+  //
+  // This can be a potentially slow operation and may result in disk IO.
+  //
+  // TODO:(maniscalco): N.B. this method should really be pure virtual. An
+  // implentation is provide here just to verify that everything compiles.

[tim (not reviewing), 2014/03/10 22:55:58]

'implementation is provided'

[maniscalco, 2014/03/18 20:49:18]

Done.

+  // Update this method to be pure virtual before committing.
+  virtual void GetSyncData(const ModelType& type,

[tim (not reviewing), 2014/03/10 22:55:58]

I want to call this GetSyncDataAsync, but Sync/Async, sigh.

Maybe (Request | Lookup)SyncData(...) is better. Comment on whether this is a
local only operation?

[maniscalco, 2014/03/18 20:49:18]

Yes, it's local only.  I've updated the comment in an effort to make that more
clear.

Re Get vs Request vs Lookup... I'm ambivalent.  On one hand would like to use an
name that has clear local/remote semantics.  On the other hand, I want
GetSyncData's name to be similar to GetAllSyncData, because they are similar
(both are local operations) and only differ in that one is synchronous and it
returns all the SyncDatas, not just one SyncData.

I don't feel strongly on the naming here.

+                           const std::string& sync_tag,

[tim (not reviewing), 2014/03/10 22:55:58]

Comment for sync_tag, refer to sync_data.h for details.

[maniscalco, 2014/03/18 20:49:18]

Done.

+                           const GetSyncDataCallback& callback) const {}
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_API_SYNC_CHANGE_PROCESSOR_H_