Separate SyncData methods into three groups, local, remote, and common.

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"
@@ skipping 260 matching lines @@
 
   void SetSyncData(const syncer::SyncDataList& data) {
      test_processor_->SetSyncDataToReturn(data);
   }
 
   syncer::SyncChangeList* FilterOutLocalHeaderChanges(
       syncer::SyncChangeList* list) {
     syncer::SyncChangeList::iterator it = list->begin();
     bool found = false;
     while (it != list->end()) {
-      if (it->sync_data().GetTag() == manager_->current_machine_tag()) {
+      if (syncer::SyncDataLocal(it->sync_data()).GetTag() ==
+          manager_->current_machine_tag()) {
         EXPECT_TRUE(SyncChange::ACTION_ADD == it->change_type() ||
                     SyncChange::ACTION_UPDATE == it->change_type());
         it = list->erase(it);
         found = true;
       } else {
         ++it;
       }
     }
     EXPECT_TRUE(found);
     return list;
@@ skipping 338 matching lines @@
 // presence of no other session activity, once and only once.
 TEST_F(SessionsSyncManagerTest, MergeLocalSessionNoTabs) {
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   EXPECT_FALSE(manager()->current_machine_tag().empty());
 
   EXPECT_EQ(2U, out.size());
   EXPECT_TRUE(out[0].IsValid());
   EXPECT_EQ(SyncChange::ACTION_ADD, out[0].change_type());
   const SyncData data(out[0].sync_data());
-  EXPECT_EQ(manager()->current_machine_tag(), data.GetTag());
+  EXPECT_EQ(manager()->current_machine_tag(),
+            syncer::SyncDataLocal(data).GetTag());
   const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
   EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
   EXPECT_TRUE(specifics.has_header());
   const sync_pb::SessionHeader& header_s = specifics.header();
   EXPECT_TRUE(header_s.has_device_type());
   EXPECT_EQ(GetLocalDeviceInfo()->client_name(), header_s.client_name());
   EXPECT_EQ(0, header_s.window_size());
 
   EXPECT_TRUE(out[1].IsValid());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[1].change_type());
   const SyncData data_2(out[1].sync_data());
-  EXPECT_EQ(manager()->current_machine_tag(), data_2.GetTag());
+  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()));
   syncer::SyncDataList in(&d, &d + 1);
   out.clear();
@@ skipping 155 matching lines @@
   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());
-  EXPECT_EQ(manager()->current_machine_tag(), data.GetTag());
+  EXPECT_EQ(manager()->current_machine_tag(),
+            syncer::SyncDataLocal(data).GetTag());
   const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
   EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
   EXPECT_TRUE(specifics.has_header());
   const sync_pb::SessionHeader& header_s = specifics.header();
   EXPECT_TRUE(header_s.has_device_type());
   EXPECT_EQ(GetLocalDeviceInfo()->client_name(), header_s.client_name());
   EXPECT_EQ(0, header_s.window_size());
 
   // Verify the tab node creations and updates with content.
   for (int i = 1; i < 3; i++) {
     EXPECT_TRUE(output[i].IsValid());
     const SyncData data(output[i].sync_data());
-    EXPECT_TRUE(StartsWithASCII(data.GetTag(),
+    EXPECT_TRUE(StartsWithASCII(syncer::SyncDataLocal(data).GetTag(),
                                 manager()->current_machine_tag(), true));
     const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
     EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
   }
   EXPECT_EQ(SyncChange::ACTION_ADD, output[1].change_type());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, output[2].change_type());
   EXPECT_TRUE(output[2].sync_data().GetSpecifics().session().has_tab());
 
   // Verify the header was updated to reflect window state.
   EXPECT_TRUE(output[3].IsValid());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, output[3].change_type());
   const SyncData data_2(output[3].sync_data());
-  EXPECT_EQ(manager()->current_machine_tag(), data_2.GetTag());
+  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(1, header_s2.window_size());
 
   // Verify foreign data.
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   std::vector<std::vector<SessionID::id_type> > session_reference;
@@ skipping 136 matching lines @@
   EXPECT_EQ(5U, changes.size());
   std::set<std::string> expected_tags(&tag, &tag + 1);
   for (int i = 0; i < 5; i++)
     expected_tags.insert(TabNodePool2::TabIdToTag(tag, i));
 
   for (int i = 0; i < 5; i++) {
     SCOPED_TRACE(changes[i].ToString());
     EXPECT_TRUE(changes[i].IsValid());
     EXPECT_EQ(SyncChange::ACTION_DELETE, changes[i].change_type());
     EXPECT_TRUE(changes[i].sync_data().IsValid());
-    EXPECT_EQ(1U, expected_tags.erase(changes[i].sync_data().GetTag()));
+    EXPECT_EQ(1U,
+              expected_tags.erase(
+                  syncer::SyncDataLocal(changes[i].sync_data()).GetTag()));
   }
 }
 
 // Write a foreign session to a node, with the tabs arriving first, and then
 // retrieve it.
 TEST_F(SessionsSyncManagerTest, WriteForeignSessionToNodeTabsFirst) {
   InitWithNoSyncData();
 
   // Fill an instance of session specifics with a foreign session's data.
   std::string tag = "tag1";
@@ skipping 102 matching lines @@
   // notification triggers association of the tab, and the subsequent window
   // update.  So we should see 4 changes at the SyncChangeProcessor.
   ASSERT_EQ(4U, out.size());
 
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[0].change_type());
   ASSERT_TRUE(out[0].sync_data().GetSpecifics().session().has_header());
   EXPECT_EQ(SyncChange::ACTION_ADD, out[1].change_type());
   int tab_node_id = out[1].sync_data().GetSpecifics().session().tab_node_id();
   EXPECT_EQ(TabNodePool2::TabIdToTag(
                 manager()->current_machine_tag(), tab_node_id),
-            out[1].sync_data().GetTag());
+            syncer::SyncDataLocal(out[1].sync_data()).GetTag());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[2].change_type());
   ASSERT_TRUE(out[2].sync_data().GetSpecifics().session().has_tab());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[3].change_type());
   ASSERT_TRUE(out[3].sync_data().GetSpecifics().session().has_header());
 
   // Verify the actual content.
   const sync_pb::SessionHeader& session_header =
       out[3].sync_data().GetSpecifics().session().header();
   ASSERT_EQ(1, session_header.window_size());
   EXPECT_EQ(1, session_header.window(0).tab_size());
@@ skipping 78 matching lines @@
   SyncData d(SyncData::CreateRemoteData(
       1, changes[0].sync_data().GetSpecifics(), base::Time()));
   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),
-            changes[0].sync_data().GetTag());
+            syncer::SyncDataLocal(changes[0].sync_data()).GetTag());
 }
 
 // Test that things work if a tab is initially ignored.
 TEST_F(SessionsSyncManagerTest, AssociateWindowsDontReloadTabs) {
   syncer::SyncChangeList out;
   // Go to a URL that is ignored by session syncing.
   AddTab(browser(), GURL("chrome://preferences/"));
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   ASSERT_EQ(2U, out.size());  // Header add and update.
   EXPECT_EQ(
       0,
       out[1].sync_data().GetSpecifics().session().header().window_size());
   out.clear();
 
   // Go to a sync-interesting URL.
   NavigateAndCommitActiveTab(GURL("http://foo2"));
 
   EXPECT_EQ(3U, out.size());  // Tab add, update, and header update.
 
-  EXPECT_TRUE(StartsWithASCII(out[0].sync_data().GetTag(),
-                              manager()->current_machine_tag(), true));
+  EXPECT_TRUE(
+      StartsWithASCII(syncer::SyncDataLocal(out[0].sync_data()).GetTag(),
+                      manager()->current_machine_tag(),
+                      true));
   EXPECT_EQ(manager()->current_machine_tag(),
             out[0].sync_data().GetSpecifics().session().session_tag());
   EXPECT_EQ(SyncChange::ACTION_ADD, out[0].change_type());
 
-  EXPECT_TRUE(StartsWithASCII(out[1].sync_data().GetTag(),
-                              manager()->current_machine_tag(), true));
+  EXPECT_TRUE(
+      StartsWithASCII(syncer::SyncDataLocal(out[1].sync_data()).GetTag(),
+                      manager()->current_machine_tag(),
+                      true));
   EXPECT_EQ(manager()->current_machine_tag(),
             out[1].sync_data().GetSpecifics().session().session_tag());
   EXPECT_TRUE(out[1].sync_data().GetSpecifics().session().has_tab());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[1].change_type());
 
   EXPECT_TRUE(out[2].IsValid());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[2].change_type());
   const SyncData data(out[2].sync_data());
-  EXPECT_EQ(manager()->current_machine_tag(), data.GetTag());
+  EXPECT_EQ(manager()->current_machine_tag(),
+            syncer::SyncDataLocal(data).GetTag());
   const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
   EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
   EXPECT_TRUE(specifics.has_header());
   const sync_pb::SessionHeader& header_s = specifics.header();
   EXPECT_EQ(1, header_s.window_size());
   EXPECT_EQ(1, header_s.window(0).tab_size());
 }
 
 // Tests that the SyncSessionManager responds to local tab events properly.
 TEST_F(SessionsSyncManagerTest, OnLocalTabModified) {
@@ skipping 23 matching lines @@
   // = 6 total header updates.
   // 12 total updates.
   ASSERT_EQ(12U, out.size());
 
   // Verify the tab node creations and updates to ensure the SyncProcessor
   // sees the right operations.
   for (int i = 0; i < 12; i++) {
     SCOPED_TRACE(i);
     EXPECT_TRUE(out[i].IsValid());
     const SyncData data(out[i].sync_data());
-    EXPECT_TRUE(StartsWithASCII(data.GetTag(),
+    EXPECT_TRUE(StartsWithASCII(syncer::SyncDataLocal(data).GetTag(),
                                 manager()->current_machine_tag(), true));
     const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
     EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
     if (i % 6 == 0) {
       // First thing on an AddTab is a no-op header update for parented tab.
       EXPECT_EQ(header.SerializeAsString(),
                 data.GetSpecifics().SerializeAsString());
-      EXPECT_EQ(manager()->current_machine_tag(), data.GetTag());
+      EXPECT_EQ(manager()->current_machine_tag(),
+                syncer::SyncDataLocal(data).GetTag());
     } else if (i % 6 == 1) {
       // Next, the TabNodePool should create the tab node.
       EXPECT_EQ(SyncChange::ACTION_ADD, out[i].change_type());
       EXPECT_EQ(TabNodePool2::TabIdToTag(
                     manager()->current_machine_tag(),
                     data.GetSpecifics().session().tab_node_id()),
-                data.GetTag());
+                syncer::SyncDataLocal(data).GetTag());
     } else if (i % 6 == 2) {
       // Then we see the tab update to the URL.
       EXPECT_EQ(SyncChange::ACTION_UPDATE, out[i].change_type());
       EXPECT_EQ(TabNodePool2::TabIdToTag(
                     manager()->current_machine_tag(),
                     data.GetSpecifics().session().tab_node_id()),
-                data.GetTag());
+                syncer::SyncDataLocal(data).GetTag());
       ASSERT_TRUE(specifics.has_tab());
     } else if (i % 6 == 3) {
       // The header needs to be updated to reflect the new window state.
       EXPECT_EQ(SyncChange::ACTION_UPDATE, out[i].change_type());
       EXPECT_TRUE(specifics.has_header());
     } else if (i % 6 == 4) {
       // Now we move on to NavigateAndCommit.  Update the tab.
       EXPECT_EQ(SyncChange::ACTION_UPDATE, out[i].change_type());
       EXPECT_EQ(TabNodePool2::TabIdToTag(
                     manager()->current_machine_tag(),
                     data.GetSpecifics().session().tab_node_id()),
-                data.GetTag());
+                syncer::SyncDataLocal(data).GetTag());
       ASSERT_TRUE(specifics.has_tab());
     } else if (i % 6 == 5) {
       // The header needs to be updated to reflect the new window state.
       EXPECT_EQ(SyncChange::ACTION_UPDATE, out[i].change_type());
       ASSERT_TRUE(specifics.has_header());
       header = data.GetSpecifics();
     }
   }
 
   // Verify the actual content to ensure sync sees the right data.
@@ skipping 38 matching lines @@
   ASSERT_EQ(6U, out.size());
 
   // Check that this machine's data is not included in the foreign windows.
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_FALSE(manager()->GetAllForeignSessions(&foreign_sessions));
 
   // Verify the header.
   EXPECT_TRUE(out[0].IsValid());
   EXPECT_EQ(SyncChange::ACTION_ADD, out[0].change_type());
   const SyncData data(out[0].sync_data());
-  EXPECT_EQ(manager()->current_machine_tag(), data.GetTag());
+  EXPECT_EQ(manager()->current_machine_tag(),
+            syncer::SyncDataLocal(data).GetTag());
   const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
   EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
   EXPECT_TRUE(specifics.has_header());
   const sync_pb::SessionHeader& header_s = specifics.header();
   EXPECT_TRUE(header_s.has_device_type());
   EXPECT_EQ(GetLocalDeviceInfo()->client_name(), header_s.client_name());
   EXPECT_EQ(0, header_s.window_size());
 
   // Verify the tab node creations and updates with content.
   for (int i = 1; i < 5; i++) {
     EXPECT_TRUE(out[i].IsValid());
     const SyncData data(out[i].sync_data());
-    EXPECT_TRUE(StartsWithASCII(data.GetTag(),
+    EXPECT_TRUE(StartsWithASCII(syncer::SyncDataLocal(data).GetTag(),
                                 manager()->current_machine_tag(), true));
     const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
     EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
     if (i % 2 == 1) {
       EXPECT_EQ(SyncChange::ACTION_ADD, out[i].change_type());
     } else {
       EXPECT_EQ(SyncChange::ACTION_UPDATE, out[i].change_type());
       EXPECT_TRUE(specifics.has_tab());
     }
   }
 
   // Verify the header was updated to reflect new window state.
   EXPECT_TRUE(out[5].IsValid());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[5].change_type());
   const SyncData data_2(out[5].sync_data());
-  EXPECT_EQ(manager()->current_machine_tag(), data_2.GetTag());
+  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(1, header_s2.window_size());
 
   // Verify TabLinks.
   SessionsSyncManager::TabLinksMap tab_map = manager()->local_tab_map_;
   ASSERT_EQ(2U, tab_map.size());
   // Tabs are ordered by sessionid in tab_map, so should be able to traverse
@@ skipping 49 matching lines @@
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(2U, foreign_sessions.size());
   foreign_sessions.clear();
 
   // Now garbage collect and verify the non-stale session is still there.
   manager()->DoGarbageCollection();
   ASSERT_EQ(5U, output.size());
   EXPECT_EQ(SyncChange::ACTION_DELETE, output[0].change_type());
   const SyncData data(output[0].sync_data());
-  EXPECT_EQ(tag1, data.GetTag());
+  EXPECT_EQ(tag1, syncer::SyncDataLocal(data).GetTag());
   for (int i = 1; i < 5; i++) {
     EXPECT_EQ(SyncChange::ACTION_DELETE, output[i].change_type());
     const SyncData data(output[i].sync_data());
-    EXPECT_EQ(TabNodePool2::TabIdToTag(tag1, i), data.GetTag());
+    EXPECT_EQ(TabNodePool2::TabIdToTag(tag1, i),
+              syncer::SyncDataLocal(data).GetTag());
   }
 
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(1U, foreign_sessions.size());
   std::vector<std::vector<SessionID::id_type> > session_reference;
   session_reference.push_back(tab_list2);
   helper()->VerifySyncedSession(tag2, session_reference,
                                 *(foreign_sessions[0]));
 }
 
@@ skipping 191 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