[Sync] Put session tracker in charge of maintaining local state.

chrome/browser/sync/sessions/sessions_sync_manager_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_sessions/sessions_sync_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 531 matching lines @@
     if (static_cast<size_t>(i) >= entries_.size())
       return;
     *serialized_entry =
         sessions::ContentSerializedNavigationBuilder::FromNavigationEntry(
             i, *entries_[i]);
   }
 
   int GetEntryCount() const override { return entries_.size(); }
 
   SessionID::id_type GetWindowId() const override {
-    return SessionID::id_type();
+    return window_id_;
+  }
+  void SetWindowId(SessionID::id_type window_id) {
+    window_id_ = window_id;
   }
 
   SessionID::id_type GetSessionId() const override {
-    return SessionID::id_type();
+    return tab_id_;
+  }
+  void SetSessionId(SessionID::id_type id) {
+    tab_id_ = id;
   }
 
   bool IsBeingDestroyed() const override { return false; }
   std::string GetExtensionAppId() const override { return std::string(); }
   bool ProfileIsSupervised() const override { return is_supervised_; }
   void set_is_supervised(bool is_supervised) { is_supervised_ = is_supervised; }
   const std::vector<std::unique_ptr<const sessions::SerializedNavigationEntry>>*
   GetBlockedNavigations() const override {
     return &blocked_navigations_;
   }
@@ skipping 20 matching lines @@
   void reset() {
     current_entry_index_ = 0;
     sync_id_ = -1;
     entries_.clear();
   }
 
  private:
   int current_entry_index_;
   bool is_supervised_;
   int sync_id_;
+  SessionID::id_type tab_id_ = 0;
+  SessionID::id_type window_id_ = 0;
   std::vector<std::unique_ptr<const sessions::SerializedNavigationEntry>>
       blocked_navigations_;
   std::vector<std::unique_ptr<content::NavigationEntry>> entries_;
 };
 
 }  // namespace
 
 static const base::Time kTime0 = base::Time::FromInternalValue(100);
 static const base::Time kTime1 = base::Time::FromInternalValue(110);
 static const base::Time kTime2 = base::Time::FromInternalValue(120);
@@ skipping 374 matching lines @@
   in.push_back(CreateRemoteData(t1_entity));
   in.push_back(CreateRemoteData(t2_entity));
   out.clear();
   manager()->StopSyncing(syncer::SESSIONS);
 
   const std::set<const SyncedWindowDelegate*>& windows =
       manager()->synced_window_delegates_getter()->GetSyncedWindowDelegates();
   ASSERT_EQ(1U, windows.size());
   SyncedTabDelegateFake t1_override, t2_override;
   t1_override.SetSyncId(1);  // No WebContents by default.
+  t1_override.SetSessionId(kNewTabId);
   t2_override.SetSyncId(2);  // No WebContents by default.
+  t2_override.SetSessionId(t2_entity.session().tab().tab_id());
   SyncedWindowDelegateOverride window_override(*windows.begin());
   window_override.OverrideTabAt(1, &t1_override, kNewTabId);
   window_override.OverrideTabAt(2, &t2_override,
                                 t2_entity.session().tab().tab_id());
   std::set<const SyncedWindowDelegate*> delegates;
   delegates.insert(&window_override);
   std::unique_ptr<TestSyncedWindowDelegatesGetter> getter(
       new TestSyncedWindowDelegatesGetter(delegates));
   set_synced_window_getter(getter.get());
 
   syncer::SyncMergeResult result = manager()->MergeDataAndStartSyncing(
       syncer::SESSIONS, in, std::unique_ptr<syncer::SyncChangeProcessor>(
                                 new TestSyncProcessorStub(&out)),
       std::unique_ptr<syncer::SyncErrorFactory>(
           new syncer::SyncErrorFactoryMock()));
 
   // There should be two changes, one for the fully associated tab, and
-  // one for the tab_id update to t1.  t2 shouldn't need to be updated.
-  ASSERT_EQ(2U, FilterOutLocalHeaderChanges(&out)->size());
+  // one each for the tab_id updates to t1 and t2.
+  ASSERT_EQ(3U, FilterOutLocalHeaderChanges(&out)->size());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[0].change_type());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[1].change_type());
+  EXPECT_EQ(SyncChange::ACTION_UPDATE, out[2].change_type());
   EXPECT_EQ(kNewTabId,
             out[1].sync_data().GetSpecifics().session().tab().tab_id());
+  EXPECT_EQ(t2_entity.session().tab().tab_id(),
+            out[2].sync_data().GetSpecifics().session().tab().tab_id());
 
   // Verify TabLinks.
   SessionsSyncManager::TabLinksMap tab_map = manager()->local_tab_map_;
   ASSERT_EQ(3U, tab_map.size());
   int t2_tab_id = t2_entity.session().tab().tab_id();
   EXPECT_EQ(2, tab_map.find(t2_tab_id)->second->tab_node_id());
   EXPECT_EQ(1, tab_map.find(kNewTabId)->second->tab_node_id());
   int t0_tab_id = out[0].sync_data().GetSpecifics().session().tab().tab_id();
   EXPECT_EQ(0, tab_map.find(t0_tab_id)->second->tab_node_id());
-  // TODO(tim): Once bug 337057 is fixed, we can issue an OnLocalTabModified
-  // from here (using an override similar to above) to return a new tab id
-  // and verify that we don't see any node creations in the SyncChangeProcessor
-  // (similar to how SessionsSyncManagerTest.OnLocalTabModified works.)
 }
 
 // Ensure model association updates the window ID for tabs whose window's ID has
 // changed.
 TEST_F(SessionsSyncManagerTest, WindowIdUpdatedOnRestore) {
   const int kNewWindowId = 1337;
   syncer::SyncDataList in;
   syncer::SyncChangeList out;
 
   // Set up one tab and start sync with it.
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   InitWithSyncDataTakeOutput(in, &out);
 
   // Should be one header add, 1 tab add/update pair, and one header update.
   ASSERT_EQ(4U, out.size());
   const sync_pb::EntitySpecifics t0_entity = out[2].sync_data().GetSpecifics();
 
   in.push_back(CreateRemoteData(t0_entity));
   out.clear();
   manager()->StopSyncing(syncer::SESSIONS);
 
   // SyncedTabDelegateFake is a placeholder (no WebContents) by default.
   SyncedTabDelegateFake t0_override;
   t0_override.SetSyncId(t0_entity.session().tab_node_id());
+  t0_override.SetWindowId(kNewWindowId);
 
   // Set up the window override with the new window ID and placeholder tab.
   const std::set<const SyncedWindowDelegate*>& windows =
       get_synced_window_getter()->GetSyncedWindowDelegates();
   ASSERT_EQ(1U, windows.size());
   SyncedWindowDelegateOverride window_override(*windows.begin());
   window_override.OverrideSessionId(kNewWindowId);
   window_override.OverrideTabAt(0, &t0_override,
                                 t0_entity.session().tab().tab_id());
 
@@ skipping 237 matching lines @@
   EXPECT_TRUE(changes.empty());
 
   // Fill an instance of session specifics with a foreign session's data.
   std::vector<sync_pb::SessionSpecifics> tabs;
   SessionID::id_type n1[] = {5, 10, 13, 17};
   std::vector<SessionID::id_type> tab_nums1(n1, n1 + arraysize(n1));
   sync_pb::SessionSpecifics meta(helper()->BuildForeignSession(
       tag, tab_nums1, &tabs));
 
   // Update associator with the session's meta node, window, and tabs.
-  manager()->UpdateTrackerWithForeignSession(meta, base::Time());
+  manager()->UpdateTrackerWithSpecifics(meta, base::Time());
   for (std::vector<sync_pb::SessionSpecifics>::iterator iter = tabs.begin();
        iter != tabs.end(); ++iter) {
-    manager()->UpdateTrackerWithForeignSession(*iter, base::Time());
+    manager()->UpdateTrackerWithSpecifics(*iter, base::Time());
   }
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(1U, foreign_sessions.size());
 
   // Now delete the foreign session.
   manager()->DeleteForeignSessionInternal(tag, &changes);
   EXPECT_FALSE(manager()->GetAllForeignSessions(&foreign_sessions));
 
   EXPECT_EQ(5U, changes.size());
   std::set<std::string> expected_tags(&tag, &tag + 1);
@@ skipping 739 matching lines @@
   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
   // the tree based on order of tabs created
   SessionsSyncManager::TabLinksMap::iterator iter = tab_map.begin();
-  ASSERT_EQ(2, iter->second->tab()->GetEntryCount());
-  EXPECT_EQ(GURL("http://foo1"), iter->second->tab()->GetVirtualURLAtIndex(0));
-  EXPECT_EQ(GURL("http://foo2"), iter->second->tab()->GetVirtualURLAtIndex(1));
+  EXPECT_EQ(GURL("http://foo2"), iter->second->url());
   iter++;
-  ASSERT_EQ(2, iter->second->tab()->GetEntryCount());
-  EXPECT_EQ(GURL("http://bar1"), iter->second->tab()->GetVirtualURLAtIndex(0));
-  EXPECT_EQ(GURL("http://bar2"), iter->second->tab()->GetVirtualURLAtIndex(1));
+  EXPECT_EQ(GURL("http://bar2"), iter->second->url());
 }
 
 TEST_F(SessionsSyncManagerTest, ForeignSessionModifiedTime) {
   syncer::SyncDataList foreign_data;
   base::Time newest_time = base::Time::Now() - base::TimeDelta::FromDays(1);
   base::Time middle_time = base::Time::Now() - base::TimeDelta::FromDays(2);
   base::Time oldest_time = base::Time::Now() - base::TimeDelta::FromDays(3);
 
   {
     std::string session_tag = "tag1";
@@ skipping 513 matching lines @@
   base::Time last_time;
   for (size_t i = 0; i < tabs.size(); ++i) {
     base::Time this_time = tabs[i]->timestamp;
     if (i > 0)
       ASSERT_GE(last_time, this_time);
     last_time = tabs[i]->timestamp;
   }
 }
 
 }  // namespace sync_sessions