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

chrome/browser/sync/sessions2/sessions_sync_manager_unittest.cc

 // Copyright 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/sessions2/sessions_sync_manager.h"
 
 #include "base/strings/string_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/sync/glue/device_info.h"
 #include "chrome/browser/sync/glue/session_sync_test_helper.h"
 #include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.h"
 #include "chrome/browser/sync/sessions2/notification_service_sessions_router.h"
 #include "chrome/browser/sync/sessions2/sessions_util.h"
 #include "chrome/browser/sync/sessions2/synced_window_delegates_getter.h"
 #include "chrome/browser/ui/sync/tab_contents_synced_tab_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "components/sessions/serialized_navigation_entry_test_helper.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
+#include "sync/api/attachments/attachment_id.h"
+#include "sync/api/attachments/attachment_service_proxy_for_test.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::WebContents;
 using sessions::SerializedNavigationEntry;
 using sessions::SerializedNavigationEntryTestHelper;
 using syncer::SyncChange;
 using syncer::SyncData;
 
@@ skipping 121 matching lines @@
   syncer::SyncChangeList* output_;
   syncer::SyncDataList sync_data_to_return_;
 };
 
 syncer::SyncChange MakeRemoteChange(
     int64 id,
     const sync_pb::SessionSpecifics& specifics,
     SyncChange::SyncChangeType type) {
   sync_pb::EntitySpecifics entity;
   entity.mutable_session()->CopyFrom(specifics);
-  return syncer::SyncChange(
-      FROM_HERE, type,
-      syncer::SyncData::CreateRemoteData(id, entity, base::Time()));
+  return syncer::SyncChange(FROM_HERE,
+                            type,
+                            syncer::SyncData::CreateRemoteData(
+                                id,
+                                entity,
+                                base::Time(),
+                                syncer::AttachmentIdList(),
+                                syncer::AttachmentServiceProxyForTest()));
 }
 
 void AddTabsToChangeList(
       const std::vector<sync_pb::SessionSpecifics>& batch,
       SyncChange::SyncChangeType type,
       syncer::SyncChangeList* change_list) {
   std::vector<sync_pb::SessionSpecifics>::const_iterator iter;
   for (iter = batch.begin();
        iter != batch.end(); ++iter) {
     sync_pb::EntitySpecifics entity;
     entity.mutable_session()->CopyFrom(*iter);
-    change_list->push_back(syncer::SyncChange(
-        FROM_HERE, type,
-        syncer::SyncData::CreateRemoteData(iter->tab_node_id(),
-                                           entity, base::Time())));
+    change_list->push_back(
+        syncer::SyncChange(FROM_HERE,
+                           type,
+                           syncer::SyncData::CreateRemoteData(
+                               iter->tab_node_id(),
+                               entity,
+                               base::Time(),
+                               syncer::AttachmentIdList(),
+                               syncer::AttachmentServiceProxyForTest())));
   }
 }
 
 void AddTabsToSyncDataList(const std::vector<sync_pb::SessionSpecifics> tabs,
                            syncer::SyncDataList* list) {
   for (size_t i = 0; i < tabs.size(); i++) {
     sync_pb::EntitySpecifics entity;
     entity.mutable_session()->CopyFrom(tabs[i]);
-    list->push_back(SyncData::CreateRemoteData(
-        i + 2, entity, base::Time()));
+    list->push_back(
+        SyncData::CreateRemoteData(i + 2,
+                                   entity,
+                                   base::Time(),
+                                   syncer::AttachmentIdList(),
+                                   syncer::AttachmentServiceProxyForTest()));
   }
 }
 
 class DummyRouter : public LocalSessionEventRouter {
  public:
   virtual ~DummyRouter() {}
   virtual void StartRoutingTo(LocalSessionEventHandler* handler) OVERRIDE {}
   virtual void Stop() OVERRIDE {}
 };
 
@@ skipping 446 matching lines @@
   const SyncData data_2(out[1].sync_data());
   EXPECT_EQ(manager()->current_machine_tag(),
             syncer::SyncDataLocal(data_2).GetTag());
   const sync_pb::SessionSpecifics& specifics2(data_2.GetSpecifics().session());
   EXPECT_EQ(manager()->current_machine_tag(), specifics2.session_tag());
   EXPECT_TRUE(specifics2.has_header());
   const sync_pb::SessionHeader& header_s2 = specifics2.header();
   EXPECT_EQ(0, header_s2.window_size());
 
   // Now take that header node and feed it in as input.
-  SyncData d(SyncData::CreateRemoteData(1, data.GetSpecifics(), base::Time()));
+  SyncData d(
+      SyncData::CreateRemoteData(1,
+                                 data.GetSpecifics(),
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   syncer::SyncDataList in(&d, &d + 1);
   out.clear();
   SessionsSyncManager manager2(profile(), this, NewDummyRouter());
   syncer::SyncMergeResult result = manager2.MergeDataAndStartSyncing(
       syncer::SESSIONS, in,
       scoped_ptr<syncer::SyncChangeProcessor>(
           new TestSyncProcessorStub(&out)),
       scoped_ptr<syncer::SyncErrorFactory>(
           new syncer::SyncErrorFactoryMock()));
   ASSERT_FALSE(result.error().IsSet());
@@ skipping 18 matching lines @@
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(in, &out);
 
   // Should be one header add, 3 tab add/update pairs, one header update.
   ASSERT_EQ(8U, out.size());
 
   // For input, we set up:
   // * one "normal" fully loaded tab
   // * one "frozen" tab with no WebContents and a tab_id change
   // * one "frozen" tab with no WebContents and no tab_id change
-  SyncData t0(SyncData::CreateRemoteData(1, out[2].sync_data().GetSpecifics(),
-                                         base::Time()));
+  SyncData t0(
+      SyncData::CreateRemoteData(1,
+                                 out[2].sync_data().GetSpecifics(),
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   sync_pb::EntitySpecifics entity(out[4].sync_data().GetSpecifics());
   entity.mutable_session()->mutable_tab()->set_tab_id(kRestoredTabId);
-  SyncData t1(SyncData::CreateRemoteData(2, entity, base::Time()));
-  SyncData t2(SyncData::CreateRemoteData(3, out[6].sync_data().GetSpecifics(),
-                                         base::Time()));
+  SyncData t1(
+      SyncData::CreateRemoteData(2,
+                                 entity,
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
+  SyncData t2(
+      SyncData::CreateRemoteData(3,
+                                 out[6].sync_data().GetSpecifics(),
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   in.push_back(t0);
   in.push_back(t1);
   in.push_back(t2);
   out.clear();
   manager()->StopSyncing(syncer::SESSIONS);
 
   const std::set<SyncedWindowDelegate*> windows(
       SyncedWindowDelegate::GetSyncedWindowDelegates());
   ASSERT_EQ(1U, windows.size());
   SyncedTabDelegateFake t1_override, t2_override;
@@ skipping 49 matching lines @@
       tag, tab_list1, &tabs1));
   // Add a second window.
   SessionID::id_type n2[] = {7, 15, 18, 20};
   std::vector<SessionID::id_type> tab_list2(n2, n2 + arraysize(n2));
   helper()->AddWindowSpecifics(1, tab_list2, &meta);
 
   // Set up initial data.
   syncer::SyncDataList initial_data;
   sync_pb::EntitySpecifics entity;
   entity.mutable_session()->CopyFrom(meta);
-  initial_data.push_back(SyncData::CreateRemoteData(1, entity, base::Time()));
+  initial_data.push_back(
+      SyncData::CreateRemoteData(1,
+                                 entity,
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   AddTabsToSyncDataList(tabs1, &initial_data);
 
   for (size_t i = 0; i < tab_list2.size(); ++i) {
     sync_pb::EntitySpecifics entity;
     helper()->BuildTabSpecifics(tag, 0, tab_list2[i],
                                 entity.mutable_session());
     initial_data.push_back(
-        SyncData::CreateRemoteData(i + 10, entity, base::Time()));
+        SyncData::CreateRemoteData(i + 10,
+                                   entity,
+                                   base::Time(),
+                                   syncer::AttachmentIdList(),
+                                   syncer::AttachmentServiceProxyForTest()));
   }
 
   syncer::SyncChangeList output;
   InitWithSyncDataTakeOutput(initial_data, &output);
   EXPECT_TRUE(FilterOutLocalHeaderChanges(&output)->empty());
 
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(1U, foreign_sessions.size());
   std::vector<std::vector<SessionID::id_type> > session_reference;
@@ skipping 13 matching lines @@
   // Foreign.
   std::string tag = "tag1";
   SessionID::id_type n1[] = {5, 10, 13, 17};
   std::vector<SessionID::id_type> tab_list1(n1, n1 + arraysize(n1));
   std::vector<sync_pb::SessionSpecifics> tabs1;
   sync_pb::SessionSpecifics meta(helper()->BuildForeignSession(
       tag, tab_list1, &tabs1));
   syncer::SyncDataList foreign_data;
   sync_pb::EntitySpecifics entity;
   entity.mutable_session()->CopyFrom(meta);
-  foreign_data.push_back(SyncData::CreateRemoteData(1, entity, base::Time()));
+  foreign_data.push_back(
+      SyncData::CreateRemoteData(1,
+                                 entity,
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   AddTabsToSyncDataList(tabs1, &foreign_data);
 
   syncer::SyncChangeList output;
   InitWithSyncDataTakeOutput(foreign_data, &output);
   ASSERT_EQ(4U, output.size());
 
   // Verify the local header.
   EXPECT_TRUE(output[0].IsValid());
   EXPECT_EQ(SyncChange::ACTION_ADD, output[0].change_type());
   const SyncData data(output[0].sync_data());
@@ skipping 56 matching lines @@
   std::vector<std::vector<SessionID::id_type> > meta1_reference;
   sync_pb::SessionSpecifics meta1;
 
   SessionID::id_type n1[] = {5, 10, 13, 17};
   std::vector<SessionID::id_type> tab_list1(n1, n1 + arraysize(n1));
   meta1_reference.push_back(tab_list1);
   std::vector<sync_pb::SessionSpecifics> tabs1;
   meta1 = helper()->BuildForeignSession(tag1, tab_list1, &tabs1);
   sync_pb::EntitySpecifics entity;
   entity.mutable_session()->CopyFrom(meta1);
-  foreign_data1.push_back(SyncData::CreateRemoteData(
-      1, entity, base::Time()));
+  foreign_data1.push_back(
+      SyncData::CreateRemoteData(1,
+                                 entity,
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   AddTabsToSyncDataList(tabs1, &foreign_data1);
 
   syncer::SyncChangeList output1;
   InitWithSyncDataTakeOutput(foreign_data1, &output1);
   ASSERT_EQ(4U, output1.size());
 
   // Add a second window to the foreign session.
   // TODO(tim): Bug 98892. Add local window too when observers are hooked up.
   SessionID::id_type tab_nums2[] = {7, 15, 18, 20};
   std::vector<SessionID::id_type> tab_list2(
@@ skipping 193 matching lines @@
   helper()->VerifySyncedSession(tag, session_reference, *(foreign_sessions[0]));
 }
 
 // Tests that the SessionsSyncManager can handle a remote client deleting
 // sync nodes that belong to this local session.
 TEST_F(SessionsSyncManagerTest, ProcessRemoteDeleteOfLocalSession) {
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   ASSERT_EQ(2U, out.size());
   sync_pb::EntitySpecifics entity(out[0].sync_data().GetSpecifics());
-  SyncData d(SyncData::CreateRemoteData(1, entity, base::Time()));
+  SyncData d(
+      SyncData::CreateRemoteData(1,
+                                 entity,
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   SetSyncData(syncer::SyncDataList(&d, &d + 1));
   out.clear();
 
   syncer::SyncChangeList changes;
   changes.push_back(
       MakeRemoteChange(1, entity.session(), SyncChange::ACTION_DELETE));
   manager()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(manager()->local_tab_pool_out_of_sync_);
   EXPECT_TRUE(out.empty());  // ChangeProcessor shouldn't see any activity.
 
@@ skipping 77 matching lines @@
   std::string local_tag = manager()->current_machine_tag();
   // Create a free node and then dissassociate sessions so that it ends up
   // unassociated.
   manager()->local_tab_pool_.GetFreeTabNode(&changes);
 
   // Update the tab_id of the node, so that it is considered a valid
   // unassociated node otherwise it will be mistaken for a corrupted node and
   // will be deleted before being added to the tab node pool.
   sync_pb::EntitySpecifics entity(changes[0].sync_data().GetSpecifics());
   entity.mutable_session()->mutable_tab()->set_tab_id(1);
-  SyncData d(SyncData::CreateRemoteData(1, entity, base::Time()));
+  SyncData d(
+      SyncData::CreateRemoteData(1,
+                                 entity,
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   syncer::SyncDataList in(&d, &d + 1);
   changes.clear();
   SessionsSyncManager manager2(profile(), this, NewDummyRouter());
   syncer::SyncMergeResult result = manager2.MergeDataAndStartSyncing(
       syncer::SESSIONS, in,
       scoped_ptr<syncer::SyncChangeProcessor>(
           new TestSyncProcessorStub(&changes)),
       scoped_ptr<syncer::SyncErrorFactory>(
           new syncer::SyncErrorFactoryMock()));
   ASSERT_FALSE(result.error().IsSet());
   EXPECT_TRUE(FilterOutLocalHeaderChanges(&changes)->empty());
 }
 
 TEST_F(SessionsSyncManagerTest, MergeDeletesCorruptNode) {
   syncer::SyncChangeList changes;
   InitWithNoSyncData();
 
   std::string local_tag = manager()->current_machine_tag();
   int tab_node_id = manager()->local_tab_pool_.GetFreeTabNode(&changes);
-  SyncData d(SyncData::CreateRemoteData(
-      1, changes[0].sync_data().GetSpecifics(), base::Time()));
+  SyncData d(
+      SyncData::CreateRemoteData(1,
+                                 changes[0].sync_data().GetSpecifics(),
+                                 base::Time(),
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   syncer::SyncDataList in(&d, &d + 1);
   changes.clear();
   TearDown();
   SetUp();
   InitWithSyncDataTakeOutput(in, &changes);
   EXPECT_EQ(1U, FilterOutLocalHeaderChanges(&changes)->size());
   EXPECT_EQ(SyncChange::ACTION_DELETE, changes[0].change_type());
   EXPECT_EQ(TabNodePool2::TabIdToTag(local_tag, tab_node_id),
             syncer::SyncDataLocal(changes[0].sync_data()).GetTag());
 }
@@ skipping 247 matching lines @@
   sync_pb::SessionSpecifics meta2(helper()->BuildForeignSession(
       tag2, tab_list2, &tabs2));
   // Set the modification time for tag1 to be 21 days ago, tag2 to 5 days ago.
   base::Time tag1_time = base::Time::Now() - base::TimeDelta::FromDays(21);
   base::Time tag2_time = base::Time::Now() - base::TimeDelta::FromDays(5);
 
   syncer::SyncDataList foreign_data;
   sync_pb::EntitySpecifics entity1, entity2;
   entity1.mutable_session()->CopyFrom(meta);
   entity2.mutable_session()->CopyFrom(meta2);
-  foreign_data.push_back(SyncData::CreateRemoteData(1, entity1, tag1_time));
-  foreign_data.push_back(SyncData::CreateRemoteData(1, entity2, tag2_time));
+  foreign_data.push_back(
+      SyncData::CreateRemoteData(1,
+                                 entity1,
+                                 tag1_time,
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
+  foreign_data.push_back(
+      SyncData::CreateRemoteData(1,
+                                 entity2,
+                                 tag2_time,
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   AddTabsToSyncDataList(tabs1, &foreign_data);
   AddTabsToSyncDataList(tabs2, &foreign_data);
 
   syncer::SyncChangeList output;
   InitWithSyncDataTakeOutput(foreign_data, &output);
   ASSERT_EQ(2U, output.size());
   output.clear();
 
   // Check that the foreign session was associated and retrieve the data.
   std::vector<const SyncedSession*> foreign_sessions;
@@ skipping 28 matching lines @@
   std::string tag1 = "tag1";
   SessionID::id_type n1[] = {5, 10, 13, 17};
   std::vector<SessionID::id_type> tab_list1(n1, n1 + arraysize(n1));
   std::vector<sync_pb::SessionSpecifics> tabs1;
   sync_pb::SessionSpecifics meta(helper()->BuildForeignSession(
       tag1, tab_list1, &tabs1));
   syncer::SyncDataList foreign_data;
   sync_pb::EntitySpecifics entity1;
   base::Time tag1_time = base::Time::Now() - base::TimeDelta::FromDays(21);
   entity1.mutable_session()->CopyFrom(meta);
-  foreign_data.push_back(SyncData::CreateRemoteData(1, entity1, tag1_time));
+  foreign_data.push_back(
+      SyncData::CreateRemoteData(1,
+                                 entity1,
+                                 tag1_time,
+                                 syncer::AttachmentIdList(),
+                                 syncer::AttachmentServiceProxyForTest()));
   AddTabsToSyncDataList(tabs1, &foreign_data);
   syncer::SyncChangeList output;
   InitWithSyncDataTakeOutput(foreign_data, &output);
   ASSERT_EQ(2U, output.size());
 
   // Update to a non-stale time.
   sync_pb::EntitySpecifics update_entity;
   update_entity.mutable_session()->CopyFrom(tabs1[0]);
   syncer::SyncChangeList changes;
-  changes.push_back(syncer::SyncChange(
-      FROM_HERE,
-      SyncChange::ACTION_UPDATE,
-      syncer::SyncData::CreateRemoteData(1, update_entity,
-                                         base::Time::Now())));
+  changes.push_back(
+      syncer::SyncChange(FROM_HERE,
+                         SyncChange::ACTION_UPDATE,
+                         syncer::SyncData::CreateRemoteData(
+                             1,
+                             update_entity,
+                             base::Time::Now(),
+                             syncer::AttachmentIdList(),
+                             syncer::AttachmentServiceProxyForTest())));
   manager()->ProcessSyncChanges(FROM_HERE, changes);
 
   // Check that the foreign session was associated and retrieve the data.
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(1U, foreign_sessions.size());
   foreign_sessions.clear();
 
   // Verify the now non-stale session does not get deleted.
   manager()->DoGarbageCollection();
@@ skipping 153 matching lines @@
   ASSERT_FALSE(observer.notified_of_refresh());
   InitWithNoSyncData();
   AddTab(browser(), GURL("http://foo1"));
   EXPECT_FALSE(observer.notified_of_refresh());
   NavigateAndCommitActiveTab(GURL("chrome://newtab/#open_tabs"));
   EXPECT_TRUE(observer.notified_of_refresh());
 }
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
 }  // namespace browser_sync