Replace calls to 3-arg SyncData::CreateLocalData with 5-arg version.

chrome/browser/sync/glue/favicon_cache_unittest.cc

 // Copyright (c) 2013 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 "chrome/browser/sync/glue/favicon_cache.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "content/public/browser/notification_service.h"
+#include "sync/api/attachments/attachment_id.h"
+#include "sync/api/attachments/attachment_service_proxy_for_test.h"
 #include "sync/api/sync_change_processor_wrapper_for_test.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/api/time.h"
 #include "sync/protocol/favicon_image_specifics.pb.h"
 #include "sync/protocol/favicon_tracking_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
@@ skipping 583 matching lines @@
 // Setting up sync with existing sync data should load that data into the local
 // cache.
 TEST_F(SyncFaviconCacheTest, SyncExistingRemote) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   std::vector<int> expected_icons;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   syncer::SyncMergeResult merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                         initial_image_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
   EXPECT_EQ((unsigned long)kFaviconBatchSize,
             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
@@ skipping 45 matching lines @@
       test_data.image_16 = std::string();
       expected_icons.push_back(i);
       expected_change_types.push_back(syncer::SyncChange::ACTION_UPDATE);
     } else {
       test_data.image_16 += "custom";
       expected_data.push_back(test_data);
     }
     FillImageSpecifics(test_data,
                        image_specifics.mutable_favicon_image());
 
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(test_data,
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   syncer::SyncMergeResult merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                         initial_image_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
   EXPECT_EQ((unsigned long)kFaviconBatchSize,
             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
@@ skipping 51 matching lines @@
       test_data.last_visit_time = i-1;
       expected_icons.push_back(i);
       expected_change_types.push_back(syncer::SyncChange::ACTION_UPDATE);
     } else {
       test_data.last_visit_time = i+1;
       expected_data.push_back(test_data);
     }
     FillImageSpecifics(test_data,
                        image_specifics.mutable_favicon_image());
 
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(test_data,
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   syncer::SyncMergeResult merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                         initial_image_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
   EXPECT_EQ((unsigned long)kFaviconBatchSize,
             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
@@ skipping 31 matching lines @@
 TEST_F(SyncFaviconCacheTest, ReceiveStaleImages) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   syncer::SyncChangeList stale_changes;
   std::vector<int> expected_icons;
   std::vector<syncer::SyncChange::SyncChangeType> expected_change_types;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     expected_change_types.push_back(syncer::SyncChange::ACTION_UPDATE);
     image_specifics.mutable_favicon_image()->clear_favicon_web();
-    stale_changes.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_UPDATE,
-             syncer::SyncData::CreateRemoteData(1,
-                                                image_specifics,
-                                                base::Time())));
+    stale_changes.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_UPDATE,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            image_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the same icons as an update, but with missing image data.
   cache()->ProcessSyncChanges(FROM_HERE, stale_changes);
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
   ASSERT_EQ((unsigned long)kFaviconBatchSize, changes.size());
   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_IMAGES,
                             expected_change_types,
                             expected_icons,
                             changes));
 }
 
 // New icons should be added locally without pushing anything back to the
 // remote syncer.
 TEST_F(SyncFaviconCacheTest, ReceiveNewImages) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   syncer::SyncChangeList new_changes;
   std::vector<int> expected_icons;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     TestFaviconData test_data = BuildFaviconData(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(test_data,
                        image_specifics.mutable_favicon_image());
-    new_changes.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_UPDATE,
-             syncer::SyncData::CreateRemoteData(1,
-                                                image_specifics,
-                                                base::Time())));
-    image_specifics.mutable_favicon_image()->mutable_favicon_web()->
-        mutable_favicon()->append("old");
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    new_changes.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_UPDATE,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            image_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
+    image_specifics.mutable_favicon_image()
+        ->mutable_favicon_web()
+        ->mutable_favicon()
+        ->append("old");
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the new icons as an update.
   cache()->ProcessSyncChanges(FROM_HERE, new_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 }
 
 // Recieving the same icons as the local data should have no effect.
 TEST_F(SyncFaviconCacheTest, ReceiveSameImages) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   syncer::SyncChangeList same_changes;
   std::vector<int> expected_icons;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     TestFaviconData test_data = BuildFaviconData(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(test_data,
                        image_specifics.mutable_favicon_image());
-    same_changes.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_UPDATE,
-             syncer::SyncData::CreateRemoteData(1,
-                                                image_specifics,
-                                                base::Time())));
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    same_changes.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_UPDATE,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            image_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the new icons as an update.
   cache()->ProcessSyncChanges(FROM_HERE, same_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 }
 
 // Receiving stale tracking (old visit times) should result in pushing back
 // the newer visit times to the remote syncer.
 TEST_F(SyncFaviconCacheTest, ReceiveStaleTracking) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   syncer::SyncChangeList stale_changes;
   std::vector<int> expected_icons;
   std::vector<syncer::SyncChange::SyncChangeType> expected_change_types;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     expected_change_types.push_back(syncer::SyncChange::ACTION_UPDATE);
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     tracking_specifics.mutable_favicon_tracking()->set_last_visit_time_ms(-1);
-    stale_changes.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_UPDATE,
-             syncer::SyncData::CreateRemoteData(1,
-                                                tracking_specifics,
-                                                base::Time())));
+    stale_changes.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_UPDATE,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            tracking_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the same icons as an update, but with missing image data.
   cache()->ProcessSyncChanges(FROM_HERE, stale_changes);
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
   ASSERT_EQ((unsigned long)kFaviconBatchSize, changes.size());
   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_TRACKING,
                             expected_change_types,
                             expected_icons,
                             changes));
 }
 
 // New tracking information should be added locally without pushing anything
 // back to the remote syncer.
 TEST_F(SyncFaviconCacheTest, ReceiveNewTracking) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   syncer::SyncChangeList new_changes;
   std::vector<int> expected_icons;
   // We start from one here so that we don't have to deal with a -1 visit time.
   for (int i = 1; i <= kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    new_changes.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_UPDATE,
-             syncer::SyncData::CreateRemoteData(1,
-                                                tracking_specifics,
-                                                base::Time())));
+    new_changes.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_UPDATE,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            tracking_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
     tracking_specifics.mutable_favicon_tracking()->set_last_visit_time_ms(i-1);
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the new icons as an update.
   cache()->ProcessSyncChanges(FROM_HERE, new_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 }
 
 // Receiving the same tracking information as the local data should have no
 // effect.
 TEST_F(SyncFaviconCacheTest, ReceiveSameTracking) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   syncer::SyncChangeList same_changes;
   std::vector<int> expected_icons;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
-    same_changes.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_UPDATE,
-             syncer::SyncData::CreateRemoteData(1,
-                                                tracking_specifics,
-                                                base::Time())));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
+    same_changes.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_UPDATE,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            tracking_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the new icons as an update.
   cache()->ProcessSyncChanges(FROM_HERE, same_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 }
 
 // Verify we can delete favicons after setting up sync.
 TEST_F(SyncFaviconCacheTest, DeleteFavicons) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   syncer::SyncChangeList tracking_deletions, image_deletions;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
-    tracking_deletions.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_DELETE,
-             syncer::SyncData::CreateRemoteData(1,
-                                                tracking_specifics,
-                                                base::Time())));
-    image_deletions.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_DELETE,
-             syncer::SyncData::CreateRemoteData(1,
-                                                image_specifics,
-                                                base::Time())));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
+    tracking_deletions.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_DELETE,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            tracking_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
+    image_deletions.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_DELETE,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            image_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the tracking deletions. Since we'll still have orphan data,
   // the favicon count should remain the same.
   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
   cache()->ProcessSyncChanges(FROM_HERE, tracking_deletions);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
 
   // Once the image deletions arrive, the favicon count should be 0 again.
   cache()->ProcessSyncChanges(FROM_HERE, image_deletions);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ(0U, GetFaviconCount());
 }
 
 // Ensure that MergeDataAndStartSyncing enforces the sync favicon limit by
 // dropping local icons.
 TEST_F(SyncFaviconCacheTest, ExpireOnMergeData) {
   std::vector<int> expected_icons;
   syncer::SyncDataList initial_image_data, initial_tracking_data;
 
   // Set up sync so it has the maximum number of favicons, while the local has
   // the same amount of different favicons.
   for (int i = 0; i < kMaxSyncFavicons; ++i) {
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     expected_icons.push_back(i);
 
     TestFaviconData favicon = BuildFaviconData(i+kMaxSyncFavicons);
     TriggerSyncFaviconReceived(favicon.page_url,
                                favicon.icon_url,
                                favicon.image_16,
                                i+kMaxSyncFavicons);
   }
 
   EXPECT_FALSE(VerifyLocalIcons(expected_icons));
@@ skipping 37 matching lines @@
 // expirations.
 TEST_F(SyncFaviconCacheTest, NoExpireOnProcessSyncChanges) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   syncer::SyncChangeList image_changes, tracking_changes;
   std::vector<int> expected_icons;
   for (int i = 0; i < kMaxSyncFavicons; ++i) {
     expected_icons.push_back(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     // Set up new tracking specifics for the icons received at change time.
     expected_icons.push_back(i + kMaxSyncFavicons);
     FillImageSpecifics(BuildFaviconData(i + kMaxSyncFavicons),
                        image_specifics.mutable_favicon_image());
-    image_changes.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_ADD,
-             syncer::SyncData::CreateRemoteData(1,
-                                                image_specifics,
-                                                base::Time())));
+    image_changes.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_ADD,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            image_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
     FillTrackingSpecifics(BuildFaviconData(i + kMaxSyncFavicons),
                           tracking_specifics.mutable_favicon_tracking());
-    tracking_changes.push_back(
-        syncer::SyncChange(
-             FROM_HERE,
-             syncer::SyncChange::ACTION_ADD,
-             syncer::SyncData::CreateRemoteData(1,
-                                                tracking_specifics,
-                                                base::Time())));
+    tracking_changes.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_ADD,
+        syncer::SyncData::CreateRemoteData(
+            1,
+            tracking_specifics,
+            base::Time(),
+            syncer::AttachmentIdList(),
+            syncer::AttachmentServiceProxyForTest::Create())));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the new icons as an update.
   EXPECT_EQ((unsigned long)kMaxSyncFavicons, GetFaviconCount());
   cache()->ProcessSyncChanges(FROM_HERE, image_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   cache()->ProcessSyncChanges(FROM_HERE, tracking_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
@@ skipping 132 matching lines @@
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   std::vector<int> expected_icons;
   std::vector<syncer::SyncChange::SyncChangeType> expected_deletions;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     expected_deletions.push_back(syncer::SyncChange::ACTION_DELETE);
     TestFaviconData test_data = BuildFaviconData(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(test_data,
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   EXPECT_TRUE(changes.empty());
 
   history::URLsDeletedDetails deletions;
   deletions.all_history = true;
   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
   content::NotificationService::current()->Notify(
@@ skipping 28 matching lines @@
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     if (i < kFaviconBatchSize/2) {
       expected_icons.push_back(i);
       expected_deletions.push_back(syncer::SyncChange::ACTION_DELETE);
       deletions.favicon_urls.insert(test_data.icon_url);
     }
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(test_data,
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   EXPECT_TRUE(changes.empty());
 
   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
   content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_HISTORY_URLS_DELETED,
         content::Source<Profile>(NULL),
@@ skipping 91 matching lines @@
   syncer::SyncChangeList initial_image_changes;
   syncer::SyncChangeList initial_tracking_changes;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     // Even favicons have image data but no tracking data. Odd favicons have
     // tracking data but no image data.
     if (i % 2 == 0) {
       sync_pb::EntitySpecifics image_specifics;
       FillImageSpecifics(BuildFaviconData(i),
                          image_specifics.mutable_favicon_image());
-      initial_image_changes.push_back(
-          syncer::SyncChange(FROM_HERE,
-                             syncer::SyncChange::ACTION_ADD,
-                             syncer::SyncData::CreateRemoteData(
-                                 1, image_specifics, base::Time())));
+      initial_image_changes.push_back(syncer::SyncChange(
+          FROM_HERE,
+          syncer::SyncChange::ACTION_ADD,
+          syncer::SyncData::CreateRemoteData(
+              1,
+              image_specifics,
+              base::Time(),
+              syncer::AttachmentIdList(),
+              syncer::AttachmentServiceProxyForTest::Create())));
     } else {
       sync_pb::EntitySpecifics tracking_specifics;
       FillTrackingSpecifics(BuildFaviconData(i),
                             tracking_specifics.mutable_favicon_tracking());
-      initial_tracking_changes.push_back(
-          syncer::SyncChange(FROM_HERE,
-                             syncer::SyncChange::ACTION_ADD,
-                             syncer::SyncData::CreateRemoteData(
-                                 1, tracking_specifics, base::Time())));
+      initial_tracking_changes.push_back(syncer::SyncChange(
+          FROM_HERE,
+          syncer::SyncChange::ACTION_ADD,
+          syncer::SyncData::CreateRemoteData(
+              1,
+              tracking_specifics,
+              base::Time(),
+              syncer::AttachmentIdList(),
+              syncer::AttachmentServiceProxyForTest::Create())));
     }
   }
 
   cache()->ProcessSyncChanges(FROM_HERE, initial_image_changes);
   cache()->ProcessSyncChanges(FROM_HERE, initial_tracking_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
 
   for (int i = 0; i < kFaviconBatchSize/2; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
@@ skipping 38 matching lines @@
 }
 
 // Verify that orphaned favicon images don't result in creating invalid
 // favicon tracking data.
 TEST_F(SyncFaviconCacheTest, PartialAssociationInfo) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     sync_pb::EntitySpecifics image_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     image_specifics.mutable_favicon_image()->clear_favicon_web();
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
   syncer::SyncChangeList change_list = processor()->GetAndResetChangeList();
   EXPECT_TRUE(change_list.empty());
   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
 }
 
 // Tests that we don't choke if a favicon visit node with a null visit time is
 // present (see crbug.com/258196) and an update is made.
 TEST_F(SyncFaviconCacheTest, NullFaviconVisitTime) {
   EXPECT_EQ(0U, GetFaviconCount());
 
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   std::vector<int> expected_icons;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
     tracking_specifics.mutable_favicon_tracking()->set_last_visit_time_ms(
         syncer::TimeToProtoTime(base::Time()));
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                     initial_image_data,
                                     CreateAndPassProcessor(),
                                     CreateAndPassSyncErrorFactory());
   ASSERT_EQ(0U, processor()->GetAndResetChangeList().size());
   cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
                                     initial_tracking_data,
                                     CreateAndPassProcessor(),
@@ skipping 34 matching lines @@
   // future.
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   for (int i = 0; i < kMaxSyncFavicons; ++i) {
     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
     TestFaviconData test_data = BuildFaviconData(i);
     test_data.last_visit_time =
         syncer::TimeToProtoTime(
             base::Time::Now() + base::TimeDelta::FromMinutes(kClockSkew));
     FillImageSpecifics(test_data,
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
     FillTrackingSpecifics(test_data,
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Visit some new favicons with local time, which will be expired as they
   // are added.
   EXPECT_EQ(0U, GetTaskCount());
   for (int i = 0; i < kClockSkew; ++i) {
     TestFaviconData test_data = BuildFaviconData(i + kMaxSyncFavicons);
     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
     OnCustomFaviconDataAvailable(test_data);
@@ skipping 29 matching lines @@
   }
 
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   // Then sync with enough favicons such that the tracking info is over the max
   // after merge completes.
   for (int i = 0; i < kMaxSyncFavicons; ++i) {
     sync_pb::EntitySpecifics image_specifics;
     // Push the images forward by 5, to match the unsynced favicons.
     FillImageSpecifics(BuildFaviconData(i + 5),
                        image_specifics.mutable_favicon_image());
-    initial_image_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           image_specifics,
-                                           base::Time()));
+    initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        image_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
 
     sync_pb::EntitySpecifics tracking_specifics;
     FillTrackingSpecifics(BuildFaviconData(i),
                           tracking_specifics.mutable_favicon_tracking());
-    initial_tracking_data.push_back(
-        syncer::SyncData::CreateRemoteData(1,
-                                           tracking_specifics,
-                                           base::Time()));
+    initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
+        1,
+        tracking_specifics,
+        base::Time(),
+        syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
   }
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // The local unsynced tracking info should be dropped, but not deleted.
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 
   // Because the image and tracking data don't overlap, the total number of
   // favicons is still over the limit.
   EXPECT_EQ((unsigned long)kMaxSyncFavicons + 5, GetFaviconCount());
 
@@ skipping 26 matching lines @@
   EXPECT_EQ(changes[4].change_type(), syncer::SyncChange::ACTION_ADD);
   EXPECT_EQ(changes[4].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
   EXPECT_EQ(kMaxSyncFavicons, GetFaviconId(changes[4]));
   // Expire tracking for favicon[0].
   EXPECT_EQ(changes[5].change_type(), syncer::SyncChange::ACTION_DELETE);
   EXPECT_EQ(changes[5].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
   EXPECT_EQ(0, GetFaviconId(changes[5]));
 }
 
 }  // namespace browser_sync