Revamp TabNavigation class

chrome/browser/sync/glue/session_model_associator_unittest.cc

 // Copyright (c) 2012 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 <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
+#include "base/string_number_conversions.h"
 #include "chrome/browser/sessions/session_types.h"
+#include "chrome/browser/sessions/session_types_test_helper.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/profile_mock.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/common/page_transition_types.h"
@@ skipping 29 matching lines @@
   size_t NumFavicons() {
     return model_associator_.NumFaviconsForTesting();
   }
 
   void DecrementFavicon(std::string url) {
     model_associator_.DecrementAndCleanFaviconForURL(url);
   }
 
   void AssociateTabContents(const SyncedWindowDelegate& window,
                             const SyncedTabDelegate& new_tab,
-                            SyncedSessionTab* prev_tab,
+                            SessionTab* prev_tab,
                             sync_pb::SessionTab* sync_tab,
                             GURL* new_url) {
     model_associator_.AssociateTabContents(window,
                                            new_tab,
                                            prev_tab,
                                            sync_tab,
                                            new_url);
   }
 
  protected:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   NiceMock<ProfileMock> profile_;
   NiceMock<ProfileSyncServiceMock> sync_service_;
   SessionModelAssociator model_associator_;
 };
 
 TEST_F(SyncSessionModelAssociatorTest, SessionWindowHasNoTabsToSync) {
   SessionWindow win;
   ASSERT_TRUE(SessionWindowHasNoTabsToSync(win));
   scoped_ptr<SessionTab> tab(new SessionTab());
   win.tabs.push_back(tab.release());
   ASSERT_TRUE(SessionWindowHasNoTabsToSync(win));
-  TabNavigation nav(0, GURL("about:bubba"),
-                    content::Referrer(GURL("about:referrer"),
-                                      WebKit::WebReferrerPolicyDefault),
-                    string16(ASCIIToUTF16("title")),
-                    std::string("state"), content::PageTransitionFromInt(0));
+  TabNavigation nav =
+      SessionTypesTestHelper::CreateNavigation("about:bubba", "title");
   win.tabs[0]->navigations.push_back(nav);
   ASSERT_FALSE(SessionWindowHasNoTabsToSync(win));
 }
 
 TEST_F(SyncSessionModelAssociatorTest, ShouldSyncSessionTab) {
-  SyncedSessionTab tab;
+  SessionTab tab;
   ASSERT_FALSE(ShouldSyncSessionTab(tab));
-  TabNavigation nav(0, GURL(chrome::kChromeUINewTabURL),
-                    content::Referrer(GURL("about:referrer"),
-                                      WebKit::WebReferrerPolicyDefault),
-                    string16(ASCIIToUTF16("title")),
-                    std::string("state"), content::PageTransitionFromInt(0));
+  TabNavigation nav =
+      SessionTypesTestHelper::CreateNavigation(
+          chrome::kChromeUINewTabURL, "title");
   tab.navigations.push_back(nav);
   // NewTab does not count as valid if it's the only navigation.
   ASSERT_FALSE(ShouldSyncSessionTab(tab));
-  TabNavigation nav2(0, GURL("about:bubba"),
-                     content::Referrer(GURL("about:referrer"),
-                                       WebKit::WebReferrerPolicyDefault),
-                    string16(ASCIIToUTF16("title")),
-                    std::string("state"), content::PageTransitionFromInt(0));
+  TabNavigation nav2 =
+      SessionTypesTestHelper::CreateNavigation("about:bubba", "title");
   tab.navigations.push_back(nav2);
   // Once there's another navigation, the tab is valid.
   ASSERT_TRUE(ShouldSyncSessionTab(tab));
 }
 
 TEST_F(SyncSessionModelAssociatorTest,
        ShouldSyncSessionTabIgnoresFragmentForNtp) {
-  SyncedSessionTab tab;
+  SessionTab tab;
   ASSERT_FALSE(ShouldSyncSessionTab(tab));
-  TabNavigation nav(0, GURL(std::string(chrome::kChromeUINewTabURL) +
-                            "#bookmarks"),
-                    content::Referrer(GURL("about:referrer"),
-                                      WebKit::WebReferrerPolicyDefault),
-                    string16(ASCIIToUTF16("title")),
-                    std::string("state"), content::PageTransitionFromInt(0));
+  TabNavigation nav =
+      SessionTypesTestHelper::CreateNavigation(
+          std::string(chrome::kChromeUINewTabURL) + "#bookmarks", "title");
   tab.navigations.push_back(nav);
   // NewTab does not count as valid if it's the only navigation.
   ASSERT_FALSE(ShouldSyncSessionTab(tab));
 }
 
 TEST_F(SyncSessionModelAssociatorTest, PopulateSessionHeader) {
   sync_pb::SessionHeader header_s;
   header_s.set_client_name("Client 1");
   header_s.set_device_type(sync_pb::SessionHeader_DeviceType_TYPE_WIN);
 
@@ skipping 25 matching lines @@
   ASSERT_EQ(1U, tracker.num_synced_tabs(std::string("tag")));
 }
 
 TEST_F(SyncSessionModelAssociatorTest, PopulateSessionTab) {
   sync_pb::SessionTab tab_s;
   tab_s.set_tab_id(5);
   tab_s.set_tab_visual_index(13);
   tab_s.set_current_navigation_index(3);
   tab_s.set_pinned(true);
   tab_s.set_extension_app_id("app_id");
-  sync_pb::TabNavigation* navigation = tab_s.add_navigation();
-  navigation->set_virtual_url("http://foo/1");
-  navigation->set_referrer("referrer");
-  navigation->set_title("title");
-  navigation->set_page_transition(sync_pb::SyncEnums_PageTransition_TYPED);
+  for (int i = 0; i < 5; ++i) {
+    sync_pb::TabNavigation* navigation = tab_s.add_navigation();
+    navigation->set_virtual_url("http://foo/" + base::IntToString(i));
+    navigation->set_referrer("referrer");
+    navigation->set_title("title");
+    navigation->set_page_transition(sync_pb::SyncEnums_PageTransition_TYPED);
+  }
 
-  SyncedSessionTab tab;
+  SessionTab tab;
   tab.tab_id.set_id(5);  // Expected to be set by the SyncedSessionTracker.
   SessionModelAssociator::PopulateSessionTabFromSpecifics(
       tab_s, base::Time(), &tab);
   ASSERT_EQ(5, tab.tab_id.id());
   ASSERT_EQ(13, tab.tab_visual_index);
   ASSERT_EQ(3, tab.current_navigation_index);
   ASSERT_TRUE(tab.pinned);
   ASSERT_EQ("app_id", tab.extension_app_id);
-  ASSERT_EQ(GURL("referrer"), tab.navigations[0].referrer().url);
-  ASSERT_EQ(string16(ASCIIToUTF16("title")), tab.navigations[0].title());
-  ASSERT_EQ(content::PAGE_TRANSITION_TYPED, tab.navigations[0].transition());
-  ASSERT_EQ(GURL("http://foo/1"), tab.navigations[0].virtual_url());
+  ASSERT_EQ(5u, tab.navigations.size());
+  for (int i = 0; i < 5; ++i) {
+    ASSERT_EQ(i, tab.navigations[i].index());
+    ASSERT_EQ(GURL("referrer"),
+              SessionTypesTestHelper::GetReferrer(tab.navigations[i]).url);
+    ASSERT_EQ(string16(ASCIIToUTF16("title")), tab.navigations[i].title());
+    ASSERT_EQ(content::PAGE_TRANSITION_TYPED,
+              SessionTypesTestHelper::GetTransitionType(tab.navigations[i]));
+    ASSERT_EQ(GURL("http://foo/" + base::IntToString(i)),
+              tab.navigations[i].virtual_url());
+  }
 }
 
 TEST_F(SyncSessionModelAssociatorTest, TabNodePool) {
   SessionModelAssociator::TabNodePool pool(NULL);
   pool.set_machine_tag("tag");
   ASSERT_TRUE(pool.empty());
   ASSERT_TRUE(pool.full());
   ASSERT_EQ(0U, pool.capacity());
   pool.AddTabNode(5);
   pool.AddTabNode(10);
@@ skipping 386 matching lines @@
   EXPECT_CALL(tab_mock, GetEntryAtIndex(0)).WillRepeatedly(
       Return(entry1.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(1)).WillRepeatedly(
       Return(entry2.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(2)).WillRepeatedly(
       Return(entry3.get()));
   EXPECT_CALL(tab_mock, GetEntryCount()).WillRepeatedly(Return(3));
   EXPECT_CALL(tab_mock, GetPendingEntryIndex()).WillRepeatedly(Return(-1));
 
   // This tab is new, so prev_tab is the default SyncedSessionTab object.
-  SyncedSessionTab prev_tab;
+  SessionTab prev_tab;
   prev_tab.tab_id.set_id(0);
 
   sync_pb::SessionTab sync_tab;
   GURL new_url;
   int64 now = syncer::TimeToProtoTime(base::Time::Now());
   AssociateTabContents(window_mock, tab_mock, &prev_tab, &sync_tab, &new_url);
 
   EXPECT_EQ(new_url, entry3->GetVirtualURL());
   ASSERT_EQ(3, sync_tab.navigation_size());
   EXPECT_EQ(entry1->GetVirtualURL().spec(),
@@ skipping 29 matching lines @@
   EXPECT_CALL(tab_mock, GetEntryAtIndex(0)).WillRepeatedly(
       Return(entry1.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(1)).WillRepeatedly(
       Return(entry2.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(2)).WillRepeatedly(
       Return(entry3.get()));
   EXPECT_CALL(tab_mock, GetEntryCount()).WillRepeatedly(Return(3));
   EXPECT_CALL(tab_mock, GetPendingEntryIndex()).WillRepeatedly(Return(-1));
 
   // This tab is new, so prev_tab is the default SyncedSessionTab object.
-  SyncedSessionTab prev_tab;
+  SessionTab prev_tab;
   prev_tab.tab_id.set_id(0);
 
   // The initial AssociateTabContents call builds the prev_tab.
   sync_pb::SessionTab sync_tab;
   GURL new_url;
   AssociateTabContents(window_mock, tab_mock, &prev_tab, &sync_tab, &new_url);
 
-  // Override the timestamps to arbitrary old values we can compare against.
-  prev_tab.synced_tab_navigations[0].set_timestamp(syncer::ProtoTimeToTime(1));
-  prev_tab.synced_tab_navigations[1].set_timestamp(syncer::ProtoTimeToTime(2));
-  prev_tab.synced_tab_navigations[2].set_timestamp(syncer::ProtoTimeToTime(3));
+  ASSERT_EQ(3u, prev_tab.navigations.size());
 
   // Now re-associate with the same data.
   AssociateTabContents(window_mock, tab_mock, &prev_tab, &sync_tab, &new_url);
 
   EXPECT_EQ(new_url, entry3->GetVirtualURL());
   ASSERT_EQ(3, sync_tab.navigation_size());
   EXPECT_EQ(entry1->GetVirtualURL().spec(),
             sync_tab.navigation(0).virtual_url());
   EXPECT_EQ(entry2->GetVirtualURL().spec(),
             sync_tab.navigation(1).virtual_url());
   EXPECT_EQ(entry3->GetVirtualURL().spec(),
             sync_tab.navigation(2).virtual_url());
   EXPECT_EQ(2, sync_tab.current_navigation_index());
-  EXPECT_EQ(1, sync_tab.navigation(0).timestamp());
-  EXPECT_EQ(2, sync_tab.navigation(1).timestamp());
-  EXPECT_EQ(3, sync_tab.navigation(2).timestamp());
+  EXPECT_EQ(syncer::TimeToProtoTime(prev_tab.navigations[0].timestamp()),
+            sync_tab.navigation(0).timestamp());
+  EXPECT_EQ(syncer::TimeToProtoTime(prev_tab.navigations[1].timestamp()),
+            sync_tab.navigation(1).timestamp());
+  EXPECT_EQ(syncer::TimeToProtoTime(prev_tab.navigations[2].timestamp()),
+            sync_tab.navigation(2).timestamp());
   EXPECT_EQ(3U, prev_tab.navigations.size());
-  EXPECT_EQ(3U, prev_tab.synced_tab_navigations.size());
 }
 
 // Ensure we add a fresh timestamp for new entries appended to the end.
 TEST_F(SyncSessionModelAssociatorTest, AssociateAppendedTab) {
     NiceMock<SyncedWindowDelegateMock> window_mock;
   EXPECT_CALL(window_mock, IsTabPinned(_)).WillRepeatedly(Return(false));
 
   // Create a tab with three valid entries.
   NiceMock<SyncedTabDelegateMock> tab_mock;
   EXPECT_CALL(tab_mock, GetSessionId()).WillRepeatedly(Return(0));
@@ skipping 10 matching lines @@
   EXPECT_CALL(tab_mock, GetEntryAtIndex(0)).WillRepeatedly(
       Return(entry1.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(1)).WillRepeatedly(
       Return(entry2.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(2)).WillRepeatedly(
       Return(entry3.get()));
   EXPECT_CALL(tab_mock, GetEntryCount()).WillRepeatedly(Return(3));
   EXPECT_CALL(tab_mock, GetPendingEntryIndex()).WillRepeatedly(Return(-1));
 
   // This tab is new, so prev_tab is the default SyncedSessionTab object.
-  SyncedSessionTab prev_tab;
+  SessionTab prev_tab;
   prev_tab.tab_id.set_id(0);
 
   // The initial AssociateTabContents call builds the prev_tab.
   sync_pb::SessionTab sync_tab;
   GURL new_url;
   AssociateTabContents(window_mock, tab_mock, &prev_tab, &sync_tab, &new_url);
 
-  // Override the timestamps to arbitrary old values we can compare against.
-  prev_tab.synced_tab_navigations[0].set_timestamp(syncer::ProtoTimeToTime(1));
-  prev_tab.synced_tab_navigations[1].set_timestamp(syncer::ProtoTimeToTime(2));
-  prev_tab.synced_tab_navigations[2].set_timestamp(syncer::ProtoTimeToTime(3));
+  ASSERT_EQ(3u, prev_tab.navigations.size());
 
   // Add a new entry and change the current navigation index.
   scoped_ptr<content::NavigationEntry> entry4(
       content::NavigationEntry::Create());
   entry4->SetVirtualURL(GURL("http://www.poodle.com"));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(3)).WillRepeatedly(
       Return(entry4.get()));
   EXPECT_CALL(tab_mock, GetEntryCount()).WillRepeatedly(Return(4));
   EXPECT_CALL(tab_mock, GetCurrentEntryIndex()).WillRepeatedly(Return(3));
 
   // The new entry should have a timestamp later than this.
   int64 now = syncer::TimeToProtoTime(base::Time::Now());
 
   // Now re-associate with the new version.
   AssociateTabContents(window_mock, tab_mock, &prev_tab, &sync_tab, &new_url);
 
   EXPECT_EQ(new_url, entry4->GetVirtualURL());
   ASSERT_EQ(4, sync_tab.navigation_size());
   EXPECT_EQ(entry1->GetVirtualURL().spec(),
             sync_tab.navigation(0).virtual_url());
   EXPECT_EQ(entry2->GetVirtualURL().spec(),
             sync_tab.navigation(1).virtual_url());
   EXPECT_EQ(entry3->GetVirtualURL().spec(),
             sync_tab.navigation(2).virtual_url());
   EXPECT_EQ(entry4->GetVirtualURL().spec(),
             sync_tab.navigation(3).virtual_url());
   EXPECT_EQ(3, sync_tab.current_navigation_index());
-  EXPECT_EQ(1, sync_tab.navigation(0).timestamp());
-  EXPECT_EQ(2, sync_tab.navigation(1).timestamp());
-  EXPECT_EQ(3, sync_tab.navigation(2).timestamp());
+  EXPECT_EQ(syncer::TimeToProtoTime(prev_tab.navigations[0].timestamp()),
+            sync_tab.navigation(0).timestamp());
+  EXPECT_EQ(syncer::TimeToProtoTime(prev_tab.navigations[1].timestamp()),
+            sync_tab.navigation(1).timestamp());
+  EXPECT_EQ(syncer::TimeToProtoTime(prev_tab.navigations[2].timestamp()),
+            sync_tab.navigation(2).timestamp());
   EXPECT_LE(now, sync_tab.navigation(3).timestamp());
   EXPECT_EQ(4U, prev_tab.navigations.size());
-  EXPECT_EQ(4U, prev_tab.synced_tab_navigations.size());
 }
 
 // We shouldn't get confused when old/new entries from the previous tab have
 // been pruned in the new tab. Timestamps for old entries we move back to in the
 // navigation stack should be refreshed.
 TEST_F(SyncSessionModelAssociatorTest, AssociatePrunedTab) {
     NiceMock<SyncedWindowDelegateMock> window_mock;
   EXPECT_CALL(window_mock, IsTabPinned(_)).WillRepeatedly(Return(false));
 
   // Create a tab with four valid entries.
@@ skipping 17 matching lines @@
   EXPECT_CALL(tab_mock, GetEntryAtIndex(1)).WillRepeatedly(
       Return(entry2.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(2)).WillRepeatedly(
       Return(entry3.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(3)).WillRepeatedly(
       Return(entry4.get()));
   EXPECT_CALL(tab_mock, GetEntryCount()).WillRepeatedly(Return(4));
   EXPECT_CALL(tab_mock, GetPendingEntryIndex()).WillRepeatedly(Return(-1));
 
   // This tab is new, so prev_tab is the default SyncedSessionTab object.
-  SyncedSessionTab prev_tab;
+  SessionTab prev_tab;
   prev_tab.tab_id.set_id(0);
 
   // The initial AssociateTabContents call builds the prev_tab.
   sync_pb::SessionTab sync_tab;
   GURL new_url;
   AssociateTabContents(window_mock, tab_mock, &prev_tab, &sync_tab, &new_url);
 
-  // Override the timestamps to arbitrary old values we can compare against.
-  prev_tab.synced_tab_navigations[0].set_timestamp(syncer::ProtoTimeToTime(1));
-  prev_tab.synced_tab_navigations[1].set_timestamp(syncer::ProtoTimeToTime(2));
-  prev_tab.synced_tab_navigations[2].set_timestamp(syncer::ProtoTimeToTime(3));
-  prev_tab.synced_tab_navigations[2].set_timestamp(syncer::ProtoTimeToTime(4));
+  ASSERT_EQ(4u, prev_tab.navigations.size());
 
   // Reset new tab to have the oldest entry pruned, the current navigation
   // set to entry3, and a new entry added in place of entry4.
   testing::Mock::VerifyAndClearExpectations(&tab_mock);
   EXPECT_CALL(tab_mock, GetCurrentEntryIndex()).WillRepeatedly(Return(1));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(0)).WillRepeatedly(
       Return(entry2.get()));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(1)).WillRepeatedly(
       Return(entry3.get()));
   scoped_ptr<content::NavigationEntry> entry5(
@@ skipping 14 matching lines @@
   // new timestamp.
   EXPECT_EQ(new_url, entry3->GetVirtualURL());
   ASSERT_EQ(3, sync_tab.navigation_size());
   EXPECT_EQ(entry2->GetVirtualURL().spec(),
             sync_tab.navigation(0).virtual_url());
   EXPECT_EQ(entry3->GetVirtualURL().spec(),
             sync_tab.navigation(1).virtual_url());
   EXPECT_EQ(entry5->GetVirtualURL().spec(),
             sync_tab.navigation(2).virtual_url());
   EXPECT_EQ(1, sync_tab.current_navigation_index());
-  EXPECT_EQ(2, sync_tab.navigation(0).timestamp());
+  EXPECT_EQ(syncer::TimeToProtoTime(prev_tab.navigations[0].timestamp()),
+            sync_tab.navigation(0).timestamp());
   EXPECT_LE(now, sync_tab.navigation(1).timestamp());
   EXPECT_LE(now, sync_tab.navigation(2).timestamp());
   EXPECT_EQ(3U, prev_tab.navigations.size());
-  EXPECT_EQ(3U, prev_tab.synced_tab_navigations.size());
 }
 
 }  // namespace browser_sync