Invoke AttachmentUploader and update AttachmentIds.

components/sync_driver/generic_change_processor_unittest.cc

 // 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.
 
 #include "components/sync_driver/generic_change_processor.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/sync_driver/data_type_error_handler_mock.h"
+#include "components/sync_driver/sync_api_component_factory.h"
 #include "sync/api/attachments/attachment_service_impl.h"
 #include "sync/api/fake_syncable_service.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/internal_api/public/attachments/fake_attachment_store.h"
 #include "sync/internal_api/public/attachments/fake_attachment_uploader.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/sync_encryption_handler.h"
@@ skipping 20 matching lines @@
 
  private:
   std::vector<syncer::AttachmentList> attachment_lists_;
 };
 
 MockAttachmentService::MockAttachmentService()
     : AttachmentServiceImpl(
           scoped_ptr<syncer::AttachmentStore>(new syncer::FakeAttachmentStore(
               base::MessageLoopProxy::current())),
           scoped_ptr<syncer::AttachmentUploader>(
-              new syncer::FakeAttachmentUploader)) {
+              new syncer::FakeAttachmentUploader),
+          NULL) {
 }
 
 MockAttachmentService::~MockAttachmentService() {
 }
 
 void MockAttachmentService::StoreAttachments(
     const syncer::AttachmentList& attachments,
     const StoreCallback& callback) {
   attachment_lists_.push_back(attachments);
   AttachmentServiceImpl::StoreAttachments(attachments, callback);
 }
 
 std::vector<syncer::AttachmentList>* MockAttachmentService::attachment_lists() {
   return &attachment_lists_;
 }
 
+// MockSyncApiComponentFactory needed to initialize GenericChangeProcessor and
+// pass MockAttachmentService to it.
+class MockSyncApiComponentFactory : public SyncApiComponentFactory {
+ public:
+  MockSyncApiComponentFactory(
+      scoped_ptr<syncer::AttachmentService> attachment_service)
+      : attachment_service_(attachment_service.Pass()) {}
+
+  virtual base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
+      syncer::ModelType type) OVERRIDE {
+    // Shouldn't be called for this test.
+    NOTREACHED();
+    return base::WeakPtr<syncer::SyncableService>();
+  }
+
+  virtual scoped_ptr<syncer::AttachmentService> CreateAttachmentService(
+      syncer::AttachmentService::Delegate* delegate) OVERRIDE {
+    EXPECT_TRUE(attachment_service_ != NULL);
+    return attachment_service_.Pass();
+  }
+
+ private:
+  scoped_ptr<syncer::AttachmentService> attachment_service_;
+};
+
 class SyncGenericChangeProcessorTest : public testing::Test {
  public:
   // It doesn't matter which type we use.  Just pick one.
   static const syncer::ModelType kType = syncer::PREFERENCES;
 
   SyncGenericChangeProcessorTest()
       : sync_merge_result_(kType),
         merge_result_ptr_factory_(&sync_merge_result_),
         syncable_service_ptr_factory_(&fake_syncable_service_),
         mock_attachment_service_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     test_user_share_.SetUp();
     syncer::ModelTypeSet types = syncer::ProtocolTypes();
     for (syncer::ModelTypeSet::Iterator iter = types.First(); iter.Good();
          iter.Inc()) {
       syncer::TestUserShare::CreateRoot(iter.Get(),
                                         test_user_share_.user_share());
     }
     test_user_share_.encryption_handler()->Init();
     scoped_ptr<MockAttachmentService> mock_attachment_service(
         new MockAttachmentService);
     // GenericChangeProcessor takes ownership of the AttachmentService, but we
     // need to have a pointer to it so we can see that it was used properly.
     // Take a pointer and trust that GenericChangeProcessor does not prematurely
     // destroy it.
     mock_attachment_service_ = mock_attachment_service.get();
-    change_processor_.reset(new GenericChangeProcessor(
-        &data_type_error_handler_,
-        syncable_service_ptr_factory_.GetWeakPtr(),
-        merge_result_ptr_factory_.GetWeakPtr(),
-        test_user_share_.user_share(),
+    sync_factory_.reset(new MockSyncApiComponentFactory(
         mock_attachment_service.PassAs<syncer::AttachmentService>()));
+    change_processor_.reset(
+        new GenericChangeProcessor(&data_type_error_handler_,
+                                   syncable_service_ptr_factory_.GetWeakPtr(),
+                                   merge_result_ptr_factory_.GetWeakPtr(),
+                                   test_user_share_.user_share(),
+                                   sync_factory_.get()));
   }
 
   virtual void TearDown() OVERRIDE {
     mock_attachment_service_ = NULL;
     test_user_share_.TearDown();
   }
 
   void BuildChildNodes(int n) {
     syncer::WriteTransaction trans(FROM_HERE, user_share());
     syncer::ReadNode root(&trans);
@@ skipping 23 matching lines @@
   syncer::SyncMergeResult sync_merge_result_;
   base::WeakPtrFactory<syncer::SyncMergeResult> merge_result_ptr_factory_;
 
   syncer::FakeSyncableService fake_syncable_service_;
   base::WeakPtrFactory<syncer::FakeSyncableService>
       syncable_service_ptr_factory_;
 
   DataTypeErrorHandlerMock data_type_error_handler_;
   syncer::TestUserShare test_user_share_;
   MockAttachmentService* mock_attachment_service_;
+  scoped_ptr<SyncApiComponentFactory> sync_factory_;
 
   scoped_ptr<GenericChangeProcessor> change_processor_;
 };
 
 // Similar to above, but focused on the method that implements sync/api
 // interfaces and is hence exposed to datatypes directly.
 TEST_F(SyncGenericChangeProcessorTest, StressGetAllSyncData) {
   const int kNumChildNodes = 1000;
   const int kRepeatCount = 1;
 
@@ skipping 184 matching lines @@
       change_processor()->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
 
   // Check that the AttachmentService received it.
   ASSERT_EQ(mock_attachment_service()->attachment_lists()->size(), 1U);
   const syncer::AttachmentList& new_attachments_added =
       mock_attachment_service()->attachment_lists()->front();
   ASSERT_EQ(new_attachments_added.size(), 1U);
   ASSERT_EQ(new_attachments_added[0].GetId(), new_attachments[0].GetId());
 }
 
+// Verify that after attachment is uploaded GenericChangeProcessor updates
+// corresponding entries
+TEST_F(SyncGenericChangeProcessorTest, AttachmentUploaded) {
+  std::string tag = "client_tag";
+  std::string title = "client_title";
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::PreferenceSpecifics* pref_specifics = specifics.mutable_preference();
+  pref_specifics->set_name("test");
+  syncer::AttachmentList attachments;
+  scoped_refptr<base::RefCountedString> attachment_data =
+      new base::RefCountedString;
+  attachment_data->data() = kTestData;
+  attachments.push_back(syncer::Attachment::Create(attachment_data));
+
+  // Add a SyncData with two attachments.
+  syncer::SyncChangeList change_list;
+  change_list.push_back(
+      syncer::SyncChange(FROM_HERE,
+                         syncer::SyncChange::ACTION_ADD,
+                         syncer::SyncData::CreateLocalDataWithAttachments(
+                             tag, title, specifics, attachments)));
+  ASSERT_FALSE(
+      change_processor()->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
+
+  sync_pb::AttachmentIdProto attachment_id_proto =
+      attachments[0].GetId().GetProto();
+  syncer::AttachmentId attachment_id =
+      syncer::AttachmentId::CreateFromProto(attachment_id_proto);
+
+  change_processor()->OnAttachmentUploaded(attachment_id);
+  syncer::ReadTransaction read_transaction(FROM_HERE, user_share());
+  syncer::ReadNode node(&read_transaction);
+  ASSERT_EQ(node.InitByClientTagLookup(syncer::PREFERENCES, tag),
+            syncer::BaseNode::INIT_OK);
+  syncer::AttachmentIdList attachment_ids = node.GetAttachmentIds();
+  EXPECT_EQ(1U, attachment_ids.size());
+}
+
 }  // namespace
 
 }  // namespace browser_sync