Invoke AttachmentUploader and update AttachmentIds.

components/sync_driver/generic_change_processor.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 COMPONENTS_SYNC_DRIVER_GENERIC_CHANGE_PROCESSOR_H_
 #define COMPONENTS_SYNC_DRIVER_GENERIC_CHANGE_PROCESSOR_H_
 
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 10 matching lines @@
 namespace syncer {
 class SyncData;
 class SyncableService;
 class WriteNode;
 class WriteTransaction;
 
 typedef std::vector<syncer::SyncData> SyncDataList;
 }  // namespace syncer
 
 namespace browser_sync {
+class SyncApiComponentFactory;
 
 // Datatype agnostic change processor. One instance of GenericChangeProcessor
 // is created for each datatype and lives on the datatype's thread. It then
 // handles all interaction with the sync api, both translating pushes from the
 // local service into transactions and receiving changes from the sync model,
 // which then get converted into SyncChange's and sent to the local service.
 //
 // As a rule, the GenericChangeProcessor is not thread safe, and should only
 // be used on the same thread in which it was created.
 class GenericChangeProcessor : public ChangeProcessor,
                                public syncer::SyncChangeProcessor,
+                               public syncer::AttachmentService::Delegate,
                                public base::NonThreadSafe {
  public:
   // Create a change processor and connect it to the syncer.
   GenericChangeProcessor(
       DataTypeErrorHandler* error_handler,
       const base::WeakPtr<syncer::SyncableService>& local_service,
       const base::WeakPtr<syncer::SyncMergeResult>& merge_result,
       syncer::UserShare* user_share,
-      scoped_ptr<syncer::AttachmentService> attachment_service);
+      SyncApiComponentFactory* sync_factory);

[pavely, 2014/05/15 19:26:52]

The problem with this approach is that now FakeGenericChangeProcessor depends on
some SyncApiComponentFactory and cannot be initialized without it.

[maniscalco, 2014/05/15 20:09:28]

I think I see what you mean.  Creating a mock SyncApiComponentsFactory for use
in tests doesn't seem too bad to me.  Overall, I like this approach a lot better
that the setter approach.

On 2014/05/15 19:26:52, pavely wrote:

   virtual ~GenericChangeProcessor();
 
   // ChangeProcessor interface.
   // Build and store a list of all changes into |syncer_changes_|.
   virtual void ApplyChangesFromSyncModel(
       const syncer::BaseTransaction* trans,
       int64 version,
       const syncer::ImmutableChangeRecordList& changes) OVERRIDE;
   // Passes |syncer_changes_|, built in ApplyChangesFromSyncModel, onto
   // |local_service_| by way of its ProcessSyncChanges method.
   virtual void CommitChangesFromSyncModel() OVERRIDE;
 
   // syncer::SyncChangeProcessor implementation.
   virtual syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const syncer::SyncChangeList& change_list) OVERRIDE;
   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type)
       const OVERRIDE;
   virtual syncer::SyncError UpdateDataTypeContext(
       syncer::ModelType type,
       syncer::SyncChangeProcessor::ContextRefreshStatus refresh_status,
       const std::string& context) OVERRIDE;
 
+  // syncer::AttachmentService::Delegate implementation.
+  virtual void OnAttachmentUploaded(
+      const syncer::AttachmentId& attachment_id) OVERRIDE;
+
   // Similar to above, but returns a SyncError for use by direct clients
   // of GenericChangeProcessor that may need more error visibility.
   virtual syncer::SyncError GetAllSyncDataReturnError(
       syncer::ModelType type,
       syncer::SyncDataList* data) const;
 
   // If a datatype context associated with |type| exists, fills |context| and
   // returns true. Otheriwse, if there has not been a context set, returns
   // false.
   virtual bool GetDataTypeContext(syncer::ModelType type,
@@ skipping 64 matching lines @@
   base::WeakPtrFactory<syncer::AttachmentService>
       attachment_service_weak_ptr_factory_;
   syncer::AttachmentServiceProxy attachment_service_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(GenericChangeProcessor);
 };
 
 }  // namespace browser_sync
 
 #endif  // COMPONENTS_SYNC_DRIVER_GENERIC_CHANGE_PROCESSOR_H_