[Sync] Componentize synced_tab_delegate

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 "chrome/browser/sync/sessions/sessions_sync_manager.h"
 
 #include "base/strings/string_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
+#include "chrome/browser/sync/chrome_sync_client.h"
 #include "chrome/browser/sync/glue/session_sync_test_helper.h"
-#include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/sessions/notification_service_sessions_router.h"
 #include "chrome/browser/ui/sync/browser_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/content/content_serialized_navigation_builder.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "components/sessions/core/session_id.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sync_driver/device_info.h"
 #include "components/sync_driver/glue/synced_window_delegate.h"
 #include "components/sync_driver/local_device_info_provider_mock.h"
 #include "components/sync_driver/sessions/synced_window_delegates_getter.h"
+#include "components/sync_driver/sync_api_component_factory.h"
+#include "components/sync_sessions/synced_tab_delegate.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/sync_error_factory_mock.h"
 #include "sync/internal_api/public/attachments/attachment_service_proxy_for_test.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 75 matching lines @@
  public:
   TestSyncedWindowDelegatesGetter(
       const std::set<const SyncedWindowDelegate*>& delegates)
       : delegates_(delegates) {}
 
   std::set<const SyncedWindowDelegate*> GetSyncedWindowDelegates() override {
     return delegates_;
   }
 
   const SyncedWindowDelegate* FindById(SessionID::id_type id) override {
+    for (auto* window : delegates_) {
+      if (window->GetSessionId() == id)
+        return window;
+    }
     return nullptr;
   }
 
  private:
   const std::set<const SyncedWindowDelegate*> delegates_;
 };
 
 class TestSyncProcessorStub : public syncer::SyncChangeProcessor {
  public:
   explicit TestSyncProcessorStub(syncer::SyncChangeList* output)
@@ skipping 100 matching lines @@
  public:
   ~DummyRouter() override {}
   void StartRoutingTo(LocalSessionEventHandler* handler) override {}
   void Stop() override {}
 };
 
 scoped_ptr<LocalSessionEventRouter> NewDummyRouter() {
   return scoped_ptr<LocalSessionEventRouter>(new DummyRouter());
 }
 
-scoped_ptr<SyncedWindowDelegatesGetter> NewBrowserWindowGetter() {
-  return make_scoped_ptr(new BrowserSyncedWindowDelegatesGetter());
-}
-
 }  // namespace
 
 class SessionsSyncManagerTest
     : public BrowserWithTestWindowTest {
  public:
   SessionsSyncManagerTest()
       : test_processor_(NULL) {
     local_device_.reset(new LocalDeviceInfoProviderMock(
         "cache_guid",
         "Wayne Gretzky's Hacking Box",
         "Chromium 10k",
         "Chrome 10k",
         sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
         "device_id"));
   }
 
   void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
+    sync_client_.reset(new browser_sync::ChromeSyncClient(profile(), nullptr));
     browser_sync::NotificationServiceSessionsRouter* router(
         new browser_sync::NotificationServiceSessionsRouter(
-            profile(), syncer::SyncableService::StartSyncFlare()));
+            profile(), GetSyncSessionsClient(),
+            syncer::SyncableService::StartSyncFlare()));
     manager_.reset(new SessionsSyncManager(
-        profile(), local_device_.get(),
-        scoped_ptr<LocalSessionEventRouter>(router),
-        NewBrowserWindowGetter()));
+        GetSyncSessionsClient(), profile(), local_device_.get(),
+        scoped_ptr<LocalSessionEventRouter>(router)));
   }
 
   void TearDown() override {
     test_processor_ = NULL;
     helper()->Reset();
     manager_.reset();
     BrowserWithTestWindowTest::TearDown();
   }
 
   const DeviceInfo* GetLocalDeviceInfo() {
@@ skipping 41 matching lines @@
         it = list->erase(it);
         found = true;
       } else {
         ++it;
       }
     }
     EXPECT_TRUE(found);
     return list;
   }
 
+  sync_sessions::SyncSessionsClient* GetSyncSessionsClient() {
+    return sync_client_->GetSyncSessionsClient();
+  }
+
  private:
+  scoped_ptr<browser_sync::ChromeSyncClient> sync_client_;
   scoped_ptr<SessionsSyncManager> manager_;
   SessionSyncTestHelper helper_;
   TestSyncProcessorStub* test_processor_;
   scoped_ptr<LocalDeviceInfoProviderMock> local_device_;
 };
 
 // Test that the SyncSessionManager can properly fill in a SessionHeader.
 TEST_F(SessionsSyncManagerTest, PopulateSessionHeader) {
   sync_pb::SessionHeader header_s;
   header_s.set_client_name("Client 1");
@@ skipping 25 matching lines @@
   ASSERT_EQ(sessions::SessionWindow::TYPE_TABBED, session->windows[0]->type);
   ASSERT_EQ(1U, manager()->session_tracker_.num_synced_sessions());
   ASSERT_EQ(1U,
             manager()->session_tracker_.num_synced_tabs(std::string("tag")));
 }
 
 namespace {
 
 class SyncedTabDelegateFake : public SyncedTabDelegate {
  public:
-  SyncedTabDelegateFake() : current_entry_index_(0),
-                            pending_entry_index_(-1),
-                            is_supervised_(false),
-                            sync_id_(-1),
-                            blocked_navigations_(NULL) {}
+  SyncedTabDelegateFake()
+      : current_entry_index_(0), is_supervised_(false), sync_id_(-1) {}
   ~SyncedTabDelegateFake() override {}
 
   bool IsInitialBlankNavigation() const override {
     // This differs from NavigationControllerImpl, which has an initial blank
     // NavigationEntry.
     return GetEntryCount() == 0;
   }
   int GetCurrentEntryIndex() const override { return current_entry_index_; }
   void set_current_entry_index(int i) {
     current_entry_index_ = i;
   }
 
-  content::NavigationEntry* GetEntryAtIndex(int i) const override {
-    const int size = entries_.size();
-    return (size < i + 1) ? NULL : entries_[i];
-  }
-
   void AppendEntry(scoped_ptr<content::NavigationEntry> entry) {
     entries_.push_back(entry.Pass());
   }
 
+  GURL GetVirtualURLAtIndex(int i) const override {
+    if (static_cast<size_t>(i) >= entries_.size())
+      return GURL();
+    return entries_[i]->GetVirtualURL();
+  }
+
+  GURL GetFaviconURLAtIndex(int i) const override { return GURL(); }
+
+  ui::PageTransition GetTransitionAtIndex(int i) const override {
+    if (static_cast<size_t>(i) >= entries_.size())
+      return ui::PAGE_TRANSITION_LINK;
+    return entries_[i]->GetTransitionType();
+  }
+
+  void GetSerializedNavigationAtIndex(
+      int i,
+      sessions::SerializedNavigationEntry* serialized_entry) const override {
+    if (static_cast<size_t>(i) >= entries_.size())
+      return;
+    *serialized_entry =
+        sessions::ContentSerializedNavigationBuilder::FromNavigationEntry(
+            i, *entries_[i]);
+  }
+
   int GetEntryCount() const override { return entries_.size(); }
 
-  int GetPendingEntryIndex() const override { return pending_entry_index_; }
-  void set_pending_entry_index(int i) {
-    pending_entry_index_ = i;
-  }
-
   SessionID::id_type GetWindowId() const override {
     return SessionID::id_type();
   }
 
   SessionID::id_type GetSessionId() const override {
     return SessionID::id_type();
   }
 
   bool IsBeingDestroyed() const override { return false; }
-  Profile* profile() const override { return NULL; }
   std::string GetExtensionAppId() const override { return std::string(); }
-  content::NavigationEntry* GetPendingEntry() const override { return NULL; }
-  content::NavigationEntry* GetActiveEntry() const override { return NULL; }
   bool ProfileIsSupervised() const override { return is_supervised_; }
   void set_is_supervised(bool is_supervised) { is_supervised_ = is_supervised; }
-  const std::vector<const content::NavigationEntry*>* GetBlockedNavigations()
-      const override {
-    return blocked_navigations_;
+  const std::vector<const sessions::SerializedNavigationEntry*>*
+  GetBlockedNavigations() const override {
+    return &blocked_navigations_.get();
   }
   void set_blocked_navigations(
       std::vector<const content::NavigationEntry*>* navs) {
-    blocked_navigations_ = navs;
+    for (auto* entry : *navs) {
+      scoped_ptr<sessions::SerializedNavigationEntry> serialized_entry(
+          new sessions::SerializedNavigationEntry());
+      *serialized_entry =
+          sessions::ContentSerializedNavigationBuilder::FromNavigationEntry(
+              blocked_navigations_.size(), *entry);
+      blocked_navigations_.push_back(serialized_entry.release());
+    }
   }
-  bool IsPinned() const override { return false; }
-  bool HasWebContents() const override { return false; }
-  content::WebContents* GetWebContents() const override { return NULL; }
+  bool IsPlaceholderTab() const override { return true; }
 
   // Session sync related methods.
   int GetSyncId() const override { return sync_id_; }
   void SetSyncId(int sync_id) override { sync_id_ = sync_id; }
 
+  bool ShouldSync(sync_sessions::SyncSessionsClient* sessions_client) override {
+    return false;
+  }
+
   void reset() {
     current_entry_index_ = 0;
-    pending_entry_index_ = -1;
     sync_id_ = -1;
     entries_.clear();
   }
 
  private:
    int current_entry_index_;
-   int pending_entry_index_;
    bool is_supervised_;
    int sync_id_;
-   std::vector<const content::NavigationEntry*>* blocked_navigations_;
+   ScopedVector<const sessions::SerializedNavigationEntry> blocked_navigations_;
    ScopedVector<content::NavigationEntry> entries_;
 };
 
 }  // namespace
 
-// Make sure GetCurrentVirtualURL() returns the virtual URL of the pending
-// entry if the current entry is pending.
-TEST_F(SessionsSyncManagerTest, GetCurrentVirtualURLPending) {
-  SyncedTabDelegateFake tab;
-  scoped_ptr<content::NavigationEntry> entry(
-      content::NavigationEntry::Create());
-  GURL url("http://www.google.com/");
-  entry->SetVirtualURL(url);
-  tab.AppendEntry(entry.Pass());
-  EXPECT_EQ(url, manager()->GetCurrentVirtualURL(tab));
-}
-
-// Make sure GetCurrentVirtualURL() returns the virtual URL of the current
-// entry if the current entry is non-pending.
-TEST_F(SessionsSyncManagerTest, GetCurrentVirtualURLNonPending) {
-  SyncedTabDelegateFake tab;
-  scoped_ptr<content::NavigationEntry> entry(
-      content::NavigationEntry::Create());
-  GURL url("http://www.google.com/");
-  entry->SetVirtualURL(url);
-  tab.AppendEntry(entry.Pass());
-  EXPECT_EQ(url, manager()->GetCurrentVirtualURL(tab));
-}
-
 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);
 static const base::Time kTime3 = base::Time::FromInternalValue(130);
 static const base::Time kTime4 = base::Time::FromInternalValue(140);
 static const base::Time kTime5 = base::Time::FromInternalValue(150);
 static const base::Time kTime6 = base::Time::FromInternalValue(160);
 static const base::Time kTime7 = base::Time::FromInternalValue(170);
 static const base::Time kTime8 = base::Time::FromInternalValue(180);
 static const base::Time kTime9 = base::Time::FromInternalValue(190);
@@ skipping 34 matching lines @@
   session_tab.tab_visual_index = 1;
   session_tab.current_navigation_index = 1;
   session_tab.pinned = true;
   session_tab.extension_app_id = "app id";
   session_tab.user_agent_override = "override";
   session_tab.timestamp = kTime5;
   session_tab.navigations.push_back(
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://www.example.com", "Example"));
   session_tab.session_storage_persistent_id = "persistent id";
-  manager()->SetSessionTabFromDelegate(tab, kTime4, &session_tab);
+  manager()->SetSessionTabFromDelegate(
+      manager()->GetSyncedWindowDelegatesGetter(), tab, kTime4, &session_tab);
 
   EXPECT_EQ(0, session_tab.window_id.id());
   EXPECT_EQ(0, session_tab.tab_id.id());
   EXPECT_EQ(0, session_tab.tab_visual_index);
   EXPECT_EQ(2, session_tab.current_navigation_index);
   EXPECT_FALSE(session_tab.pinned);
   EXPECT_TRUE(session_tab.extension_app_id.empty());
   EXPECT_TRUE(session_tab.user_agent_override.empty());
   EXPECT_EQ(kTime4, session_tab.timestamp);
   ASSERT_EQ(3u, session_tab.navigations.size());
@@ skipping 86 matching lines @@
   tab.AppendEntry(entry3.Pass());
   tab.AppendEntry(entry4.Pass());
   tab.AppendEntry(entry5.Pass());
   tab.AppendEntry(entry6.Pass());
   tab.AppendEntry(entry7.Pass());
   tab.AppendEntry(entry8.Pass());
   tab.AppendEntry(entry9.Pass());
   tab.set_current_entry_index(8);
 
   sessions::SessionTab session_tab;
-  manager()->SetSessionTabFromDelegate(tab, kTime9, &session_tab);
+  manager()->SetSessionTabFromDelegate(
+      manager()->GetSyncedWindowDelegatesGetter(), tab, kTime9, &session_tab);
 
   EXPECT_EQ(6, session_tab.current_navigation_index);
   ASSERT_EQ(8u, session_tab.navigations.size());
   EXPECT_EQ(url2, session_tab.navigations[0].virtual_url());
   EXPECT_EQ(url3, session_tab.navigations[1].virtual_url());
   EXPECT_EQ(url4, session_tab.navigations[2].virtual_url());
 }
 
 // Ensure the current_navigation_index gets set to the end of the navigation
 // stack if the current navigation is invalid.
@@ skipping 20 matching lines @@
   entry3->SetTimestamp(kTime3);
   entry3->SetHttpStatusCode(200);
 
   tab.AppendEntry(entry0.Pass());
   tab.AppendEntry(entry1.Pass());
   tab.AppendEntry(entry2.Pass());
   tab.AppendEntry(entry3.Pass());
   tab.set_current_entry_index(1);
 
   sessions::SessionTab session_tab;
-  manager()->SetSessionTabFromDelegate(tab, kTime9, &session_tab);
+  manager()->SetSessionTabFromDelegate(
+      manager()->GetSyncedWindowDelegatesGetter(), tab, kTime9, &session_tab);
 
   EXPECT_EQ(2, session_tab.current_navigation_index);
   ASSERT_EQ(3u, session_tab.navigations.size());
 }
 
 // Tests that variation ids are set correctly.
 TEST_F(SessionsSyncManagerTest, SetVariationIds) {
   // Create two trials with a group which has a variation id for Chrome Sync
   // and one with a variation id for another service.
   const variations::VariationID kVariationId1 = 3300200;
@@ skipping 50 matching lines @@
   session_tab.tab_visual_index = 1;
   session_tab.current_navigation_index = 1;
   session_tab.pinned = true;
   session_tab.extension_app_id = "app id";
   session_tab.user_agent_override = "override";
   session_tab.timestamp = kTime5;
   session_tab.navigations.push_back(
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://www.example.com", "Example"));
   session_tab.session_storage_persistent_id = "persistent id";
-  manager()->SetSessionTabFromDelegate(tab, kTime4, &session_tab);
+  manager()->SetSessionTabFromDelegate(
+      manager()->GetSyncedWindowDelegatesGetter(), tab, kTime4, &session_tab);
 
   EXPECT_EQ(0, session_tab.window_id.id());
   EXPECT_EQ(0, session_tab.tab_id.id());
   EXPECT_EQ(0, session_tab.tab_visual_index);
   EXPECT_EQ(0, session_tab.current_navigation_index);
   EXPECT_FALSE(session_tab.pinned);
   EXPECT_TRUE(session_tab.extension_app_id.empty());
   EXPECT_TRUE(session_tab.user_agent_override.empty());
   EXPECT_EQ(kTime4, session_tab.timestamp);
   ASSERT_EQ(3u, session_tab.navigations.size());
@@ skipping 46 matching lines @@
 
   // Now take that header node and feed it in as input.
   SyncData d(SyncData::CreateRemoteData(
       1,
       data.GetSpecifics(),
       base::Time(),
       syncer::AttachmentIdList(),
       syncer::AttachmentServiceProxyForTest::Create()));
   syncer::SyncDataList in(&d, &d + 1);
   out.clear();
-  SessionsSyncManager manager2(profile(), local_device(), NewDummyRouter(),
-                               NewBrowserWindowGetter());
+  SessionsSyncManager manager2(GetSyncSessionsClient(), profile(),
+                               local_device(), 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());
 
   EXPECT_EQ(1U, out.size());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[0].change_type());
@@ skipping 55 matching lines @@
   t1_override.SetSyncId(1);  // No WebContents by default.
   t2_override.SetSyncId(2);  // No WebContents by default.
   SyncedWindowDelegateOverride window_override(*windows.begin());
   window_override.OverrideTabAt(1, &t1_override, kNewTabId);
   window_override.OverrideTabAt(2, &t2_override,
                                 t2.GetSpecifics().session().tab().tab_id());
   std::set<const SyncedWindowDelegate*> delegates;
   delegates.insert(&window_override);
   scoped_ptr<TestSyncedWindowDelegatesGetter> getter(
       new TestSyncedWindowDelegatesGetter(delegates));
-  manager()->synced_window_getter_.reset(getter.release());
+  manager()->synced_window_getter_ = getter.get();
 
   syncer::SyncMergeResult result = manager()->MergeDataAndStartSyncing(
       syncer::SESSIONS, in,
       scoped_ptr<syncer::SyncChangeProcessor>(
           new TestSyncProcessorStub(&out)),
       scoped_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.
@@ skipping 492 matching lines @@
   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(),
       syncer::AttachmentIdList(),
       syncer::AttachmentServiceProxyForTest::Create()));
   syncer::SyncDataList in(&d, &d + 1);
   changes.clear();
-  SessionsSyncManager manager2(profile(), local_device(), NewDummyRouter(),
-                               NewBrowserWindowGetter());
+  SessionsSyncManager manager2(GetSyncSessionsClient(), profile(),
+                               local_device(), 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());
 }
 
@@ skipping 171 matching lines @@
       out[8].sync_data().GetSpecifics().session().tab();
   ASSERT_EQ(1, tab2_1.navigation_size());
   EXPECT_EQ(bar1.spec(), tab2_1.navigation(0).virtual_url());
   const sync_pb::SessionTab& tab2_2 =
       out[10].sync_data().GetSpecifics().session().tab();
   ASSERT_EQ(2, tab2_2.navigation_size());
   EXPECT_EQ(bar1.spec(), tab2_2.navigation(0).virtual_url());
   EXPECT_EQ(bar2.spec(), tab2_2.navigation(1).virtual_url());
 }
 
+// Check that if a tab becomes uninteresting (for example no syncable URLs),
+// we correctly remove it from the header node.
+TEST_F(SessionsSyncManagerTest, TabBecomesUninteresting) {
+  syncer::SyncChangeList out;
+  // Init with no local data, relies on MergeLocalSessionNoTabs.
+  InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
+  ASSERT_FALSE(manager()->current_machine_tag().empty());
+  ASSERT_EQ(2U, out.size());
+  out.clear();
+
+  const GURL kValidUrl("http://foo/1");
+  const GURL kInternalUrl("chrome://internal");
+
+  // Add an interesting tab.
+  AddTab(browser(), kValidUrl);
+  // No-op header update, tab creation, tab update, header update.
+  ASSERT_EQ(4U, out.size());
+  // The last two are the interesting updates.
+  ASSERT_TRUE(out[2].sync_data().GetSpecifics().session().has_tab());
+  EXPECT_EQ(kValidUrl.spec(), out[2]
+                                  .sync_data()
+                                  .GetSpecifics()
+                                  .session()
+                                  .tab()
+                                  .navigation(0)
+                                  .virtual_url());
+  ASSERT_TRUE(out[3].sync_data().GetSpecifics().session().has_header());
+  ASSERT_EQ(1,
+            out[3].sync_data().GetSpecifics().session().header().window_size());
+  ASSERT_EQ(1, out[3]
+                   .sync_data()
+                   .GetSpecifics()
+                   .session()
+                   .header()
+                   .window(0)
+                   .tab_size());
+
+  // Navigate five times to uninteresting urls to push the interesting one off
+  // the back of the stack.
+  NavigateAndCommitActiveTab(kInternalUrl);
+  NavigateAndCommitActiveTab(kInternalUrl);
+  NavigateAndCommitActiveTab(kInternalUrl);
+  NavigateAndCommitActiveTab(kInternalUrl);
+
+  // Reset |out| so we only see the effects of the final navigation.
+  out.clear();
+  NavigateAndCommitActiveTab(kInternalUrl);
+
+  // Only the header node should be updated, and it should no longer have any
+  // valid windows/tabs.
+  ASSERT_EQ(2U, out.size());  // Two header updates (first is a no-op).
+  ASSERT_TRUE(out[1].sync_data().GetSpecifics().session().has_header());
+  EXPECT_EQ(1,
+            out[1].sync_data().GetSpecifics().session().header().window_size());
+}
+
 // Ensure model association associates the pre-existing tabs.
 TEST_F(SessionsSyncManagerTest, MergeLocalSessionExistingTabs) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));  // Adds back entry.
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));  // Adds back entry.
 
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   ASSERT_EQ(6U, out.size());
@@ skipping 45 matching lines @@
   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()->
-          GetEntryAtIndex(0)->GetVirtualURL());
-  EXPECT_EQ(GURL("http://foo2"), iter->second->tab()->
-          GetEntryAtIndex(1)->GetVirtualURL());
+  EXPECT_EQ(GURL("http://foo1"), iter->second->tab()->GetVirtualURLAtIndex(0));
+  EXPECT_EQ(GURL("http://foo2"), iter->second->tab()->GetVirtualURLAtIndex(1));
   iter++;
   ASSERT_EQ(2, iter->second->tab()->GetEntryCount());
-  EXPECT_EQ(GURL("http://bar1"), iter->second->tab()->
-      GetEntryAtIndex(0)->GetVirtualURL());
-  EXPECT_EQ(GURL("http://bar2"), iter->second->tab()->
-      GetEntryAtIndex(1)->GetVirtualURL());
+  EXPECT_EQ(GURL("http://bar1"), iter->second->tab()->GetVirtualURLAtIndex(0));
+  EXPECT_EQ(GURL("http://bar2"), iter->second->tab()->GetVirtualURLAtIndex(1));
 }
 
 // Test garbage collection of stale foreign sessions.
 TEST_F(SessionsSyncManagerTest, DoGarbageCollection) {
   // Fill two instances of session specifics with a foreign session's data.
   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(
@@ skipping 520 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 browser_sync