Moves TabNavigation into components/sessions and renames

chrome/browser/sessions/persistent_tab_restore_service_browsertest.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 "chrome/browser/sessions/persistent_tab_restore_service.h"
 
 #include "base/compiler_specific.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_types.h"
-#include "chrome/browser/sessions/session_types_test_helper.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/sessions/serialized_navigation_entry_test_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/render_view_test.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 
 typedef TabRestoreService::Tab Tab;
 typedef TabRestoreService::Window Window;
-using content::WebContentsTester;
 
 using content::NavigationEntry;
+using content::WebContentsTester;
+using sessions::SerializedNavigationEntry;
+using sessions::SerializedNavigationEntryTestHelper;
 
 // Create subclass that overrides TimeNow so that we can control the time used
 // for closed tabs and windows.
 class PersistentTabRestoreTimeFactory : public TabRestoreService::TimeFactory {
  public:
   PersistentTabRestoreTimeFactory() : time_(base::Time::Now()) {}
 
   virtual ~PersistentTabRestoreTimeFactory() {}
 
   virtual base::Time TimeNow() OVERRIDE {
@@ skipping 79 matching lines @@
     SessionID window_id;
     session_service->SetWindowType(
         window_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
     session_service->SetTabWindow(window_id, tab_id);
     session_service->SetTabIndexInWindow(window_id, tab_id, 0);
     session_service->SetSelectedTabInWindow(window_id, 0);
     if (pinned)
       session_service->SetPinnedState(window_id, tab_id, true);
     session_service->UpdateTabNavigation(
         window_id, tab_id,
-        SessionTypesTestHelper::CreateNavigation(url1_.spec(), "title"));
+        SerializedNavigationEntryTestHelper::CreateNavigation(
+            url1_.spec(), "title"));
   }
 
   // Creates a SessionService and assigns it to the Profile. The SessionService
   // is configured with a single window with a single tab pointing at url1_ by
   // way of AddWindowWithOneTabToSessionService. If |pinned| is true, the
   // tab is marked as pinned in the session service.
   void CreateSessionServiceWithOneWindow(bool pinned) {
     // The profile takes ownership of this.
     SessionService* session_service = new SessionService(profile());
     SessionServiceFactory::SetForTestProfile(profile(), session_service);
@@ skipping 388 matching lines @@
 
   AddThreeNavigations();
 
   // Have the service record the tab.
   service_->CreateHistoricalTab(web_contents(), -1);
 
   // Make sure an entry was created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // Make sure the entry matches.
-  std::vector<TabNavigation> old_navigations;
+  std::vector<SerializedNavigationEntry> old_navigations;
   {
     // |entry|/|tab| doesn't survive after RecreateService().
     TabRestoreService::Entry* entry = service_->entries().front();
     ASSERT_EQ(TabRestoreService::TAB, entry->type);
     Tab* tab = static_cast<Tab*>(entry);
     tab->timestamp = tab_timestamp;
     old_navigations = tab->navigations;
   }
 
   EXPECT_EQ(3U, old_navigations.size());
   for (size_t i = 0; i < old_navigations.size(); ++i) {
-    EXPECT_FALSE(
-        SessionTypesTestHelper::GetTimestamp(old_navigations[i]).is_null());
+    EXPECT_FALSE(old_navigations[i].timestamp().is_null());
   }
 
   // Set this, otherwise previous session won't be loaded.
   profile()->set_last_session_exited_cleanly(false);
 
   RecreateService();
 
   // One entry should be created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // And verify the entry.
   TabRestoreService::Entry* restored_entry = service_->entries().front();
   ASSERT_EQ(TabRestoreService::TAB, restored_entry->type);
   Tab* restored_tab =
       static_cast<Tab*>(restored_entry);
   EXPECT_EQ(tab_timestamp.ToInternalValue(),
             restored_tab->timestamp.ToInternalValue());
   ASSERT_EQ(old_navigations.size(), restored_tab->navigations.size());
   for (size_t i = 0; i < restored_tab->navigations.size(); ++i) {
-    EXPECT_EQ(
-        SessionTypesTestHelper::GetTimestamp(old_navigations[i]),
-        SessionTypesTestHelper::GetTimestamp(restored_tab->navigations[i]));
+    EXPECT_EQ(old_navigations[i].timestamp(),
+              restored_tab->navigations[i].timestamp());
   }
 }
 
 TEST_F(PersistentTabRestoreServiceTest, PruneEntries) {
   service_->ClearEntries();
   ASSERT_TRUE(service_->entries().empty());
 
   const size_t max_entries = kMaxEntries;
   for (size_t i = 0; i < max_entries + 5; i++) {
-    TabNavigation navigation =
-        SessionTypesTestHelper::CreateNavigation(
+    SerializedNavigationEntry navigation =
+        SerializedNavigationEntryTestHelper::CreateNavigation(
             base::StringPrintf("http://%d", static_cast<int>(i)),
             base::StringPrintf("%d", static_cast<int>(i)));
 
     Tab* tab = new Tab();
     tab->navigations.push_back(navigation);
     tab->current_navigation_index = 0;
 
     mutable_entries()->push_back(tab);
   }
 
   // Only keep kMaxEntries around.
   EXPECT_EQ(max_entries + 5, service_->entries().size());
   PruneEntries();
   EXPECT_EQ(max_entries, service_->entries().size());
   // Pruning again does nothing.
   PruneEntries();
   EXPECT_EQ(max_entries, service_->entries().size());
 
   // Prune older first.
   const char kRecentUrl[] = "http://recent";
-  TabNavigation navigation =
-      SessionTypesTestHelper::CreateNavigation(kRecentUrl, "Most recent");
+  SerializedNavigationEntry navigation =
+      SerializedNavigationEntryTestHelper::CreateNavigation(kRecentUrl,
+                                                            "Most recent");
   Tab* tab = new Tab();
   tab->navigations.push_back(navigation);
   tab->current_navigation_index = 0;
   mutable_entries()->push_front(tab);
   EXPECT_EQ(max_entries + 1, service_->entries().size());
   PruneEntries();
   EXPECT_EQ(max_entries, service_->entries().size());
   EXPECT_EQ(GURL(kRecentUrl),
       static_cast<Tab*>(service_->entries().front())->
           navigations[0].virtual_url());
 
   // Ignore NTPs.
-  navigation =
-      SessionTypesTestHelper::CreateNavigation(
-          chrome::kChromeUINewTabURL, "New tab");
+  navigation = SerializedNavigationEntryTestHelper::CreateNavigation(
+      chrome::kChromeUINewTabURL, "New tab");
 
   tab = new Tab();
   tab->navigations.push_back(navigation);
   tab->current_navigation_index = 0;
   mutable_entries()->push_front(tab);
 
   EXPECT_EQ(max_entries + 1, service_->entries().size());
   PruneEntries();
   EXPECT_EQ(max_entries, service_->entries().size());
   EXPECT_EQ(GURL(kRecentUrl),
@@ skipping 44 matching lines @@
     NavigateAndCommit(
         GURL(base::StringPrintf("http://%d", static_cast<int>(i))));
     service_->CreateHistoricalTab(web_contents(), -1);
   }
 
   EXPECT_EQ(max_entries, service_->entries().size());
   // This should not crash.
   service_->LoadTabsFromLastSession();
   EXPECT_EQ(max_entries, service_->entries().size());
 }