[sessions] Properly namespace recently-componentized TabRestore code

chrome/browser/sessions/persistent_tab_restore_service_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 "components/sessions/core/persistent_tab_restore_service.h"
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 18 matching lines @@
 #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_utils.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-typedef TabRestoreService::Tab Tab;
-typedef TabRestoreService::Window Window;
+typedef sessions::TabRestoreService::Tab Tab;
+typedef sessions::TabRestoreService::Window Window;
 
 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 {
+class PersistentTabRestoreTimeFactory
+    : public sessions::TabRestoreService::TimeFactory {
  public:
   PersistentTabRestoreTimeFactory() : time_(base::Time::Now()) {}
 
   ~PersistentTabRestoreTimeFactory() override {}
 
   base::Time TimeNow() override { return time_; }
 
  private:
   base::Time time_;
 };
 
 class PersistentTabRestoreServiceTest : public ChromeRenderViewHostTestHarness {
  public:
   PersistentTabRestoreServiceTest()
     : url1_("http://1"),
       url2_("http://2"),
       url3_("http://3"),
       user_agent_override_(
           "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.19"
           " (KHTML, like Gecko) Chrome/18.0.1025.45 Safari/535.19"),
       time_factory_(NULL) {
   }
 
   ~PersistentTabRestoreServiceTest() override {}
 
  protected:
   enum {
-    kMaxEntries = TabRestoreServiceHelper::kMaxEntries,
+    kMaxEntries = sessions::TabRestoreServiceHelper::kMaxEntries,
   };
 
   // testing::Test:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     live_tab_ = make_scoped_ptr(new sessions::ContentLiveTab(web_contents()));
     time_factory_ = new PersistentTabRestoreTimeFactory();
-    service_.reset(new PersistentTabRestoreService(
+    service_.reset(new sessions::PersistentTabRestoreService(
         make_scoped_ptr(new ChromeTabRestoreServiceClient(profile())),
         time_factory_));
   }
 
   void TearDown() override {
     service_->Shutdown();
     service_.reset();
     delete time_factory_;
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
-  TabRestoreService::Entries* mutable_entries() {
+  sessions::TabRestoreService::Entries* mutable_entries() {
     return service_->mutable_entries();
   }
 
   void PruneEntries() {
     service_->PruneEntries();
   }
 
   void AddThreeNavigations() {
     // Navigate to three URLs.
     NavigateAndCommit(url1_);
     NavigateAndCommit(url2_);
     NavigateAndCommit(url3_);
   }
 
   void NavigateToIndex(int index) {
     // Navigate back. We have to do this song and dance as NavigationController
     // isn't happy if you navigate immediately while going back.
     controller().GoToIndex(index);
     WebContentsTester::For(web_contents())->CommitPendingNavigation();
   }
 
   void RecreateService() {
     // Must set service to null first so that it is destroyed before the new
     // one is created.
     service_->Shutdown();
     content::RunAllBlockingPoolTasksUntilIdle();
     service_.reset();
-    service_.reset(new PersistentTabRestoreService(
+    service_.reset(new sessions::PersistentTabRestoreService(
         make_scoped_ptr(new ChromeTabRestoreServiceClient(profile())),
         time_factory_));
     SynchronousLoadTabsFromLastSession();
   }
 
   // Adds a window with one tab and url to the profile's session service.
   // If |pinned| is true, the tab is marked as pinned in the session service.
   void AddWindowWithOneTabToSessionService(bool pinned) {
     SessionService* session_service =
         SessionServiceFactory::GetForProfile(profile());
@@ skipping 33 matching lines @@
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   sessions::LiveTab* live_tab() { return live_tab_.get(); }
 
   GURL url1_;
   GURL url2_;
   GURL url3_;
   std::string user_agent_override_;
   scoped_ptr<sessions::LiveTab> live_tab_;
-  scoped_ptr<PersistentTabRestoreService> service_;
+  scoped_ptr<sessions::PersistentTabRestoreService> service_;
   PersistentTabRestoreTimeFactory* time_factory_;
 };
 
 namespace {
 
-class TestTabRestoreServiceObserver : public TabRestoreServiceObserver {
+class TestTabRestoreServiceObserver
+    : public sessions::TabRestoreServiceObserver {
  public:
   TestTabRestoreServiceObserver() : got_loaded_(false) {}
 
   void clear_got_loaded() { got_loaded_ = false; }
   bool got_loaded() const { return got_loaded_; }
 
   // TabRestoreServiceObserver:
-  void TabRestoreServiceChanged(TabRestoreService* service) override {}
-  void TabRestoreServiceDestroyed(TabRestoreService* service) override {}
-  void TabRestoreServiceLoaded(TabRestoreService* service) override {
+  void TabRestoreServiceChanged(sessions::TabRestoreService* service) override {
+  }
+  void TabRestoreServiceDestroyed(
+      sessions::TabRestoreService* service) override {}
+  void TabRestoreServiceLoaded(sessions::TabRestoreService* service) override {
     got_loaded_ = true;
   }
 
  private:
   // Was TabRestoreServiceLoaded() invoked?
   bool got_loaded_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTabRestoreServiceObserver);
 };
 
 }  // namespace
 
 TEST_F(PersistentTabRestoreServiceTest, Basic) {
   AddThreeNavigations();
 
   // Have the service record the tab.
   service_->CreateHistoricalTab(live_tab(), -1);
 
   // Make sure an entry was created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // Make sure the entry matches.
-  TabRestoreService::Entry* entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::TAB, entry->type);
+  sessions::TabRestoreService::Entry* entry = service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   EXPECT_FALSE(tab->pinned);
   EXPECT_TRUE(tab->extension_app_id.empty());
   ASSERT_EQ(3U, tab->navigations.size());
   EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url());
   EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url());
   EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url());
   EXPECT_EQ("", tab->user_agent_override);
   EXPECT_EQ(2, tab->current_navigation_index);
   EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(),
             tab->timestamp.ToInternalValue());
 
   NavigateToIndex(1);
 
   // And check again, but set the user agent override this time.
   web_contents()->SetUserAgentOverride(user_agent_override_);
   service_->CreateHistoricalTab(live_tab(), -1);
 
   // There should be two entries now.
   ASSERT_EQ(2U, service_->entries().size());
 
   // Make sure the entry matches.
   entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
   tab = static_cast<Tab*>(entry);
   EXPECT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
   EXPECT_EQ(url1_, tab->navigations[0].virtual_url());
   EXPECT_EQ(url2_, tab->navigations[1].virtual_url());
   EXPECT_EQ(url3_, tab->navigations[2].virtual_url());
   EXPECT_EQ(user_agent_override_, tab->user_agent_override);
   EXPECT_EQ(1, tab->current_navigation_index);
   EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(),
             tab->timestamp.ToInternalValue());
@@ skipping 13 matching lines @@
   // Have the service record the tab.
   service_->CreateHistoricalTab(live_tab(), -1);
 
   // Recreate the service and have it load the tabs.
   RecreateService();
 
   // One entry should be created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // And verify the entry.
-  PersistentTabRestoreService::Entry* entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::TAB, entry->type);
+  sessions::PersistentTabRestoreService::Entry* entry =
+      service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   EXPECT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
   EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url());
   EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url());
   EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url());
   EXPECT_EQ(2, tab->current_navigation_index);
   EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(),
             tab->timestamp.ToInternalValue());
 }
 
 // Tests restoring a single pinned tab.
 TEST_F(PersistentTabRestoreServiceTest, RestorePinnedAndApp) {
   AddThreeNavigations();
 
   // Have the service record the tab.
   service_->CreateHistoricalTab(live_tab(), -1);
 
   // One entry should be created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // We have to explicitly mark the tab as pinned as there is no browser for
   // these tests.
-  TabRestoreService::Entry* entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::TAB, entry->type);
+  sessions::TabRestoreService::Entry* entry = service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   tab->pinned = true;
   const std::string extension_app_id("test");
   tab->extension_app_id = extension_app_id;
 
   // Recreate the service and have it load the tabs.
   RecreateService();
 
   // One entry should be created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // And verify the entry.
   entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
   tab = static_cast<Tab*>(entry);
   EXPECT_TRUE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
   EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url());
   EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url());
   EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url());
   EXPECT_EQ(2, tab->current_navigation_index);
   EXPECT_TRUE(extension_app_id == tab->extension_app_id);
 }
 
 // Make sure we persist entries to disk that have post data.
 TEST_F(PersistentTabRestoreServiceTest, DontPersistPostData) {
   AddThreeNavigations();
   controller().GetEntryAtIndex(0)->SetHasPostData(true);
   controller().GetEntryAtIndex(1)->SetHasPostData(true);
   controller().GetEntryAtIndex(2)->SetHasPostData(true);
 
   // Have the service record the tab.
   service_->CreateHistoricalTab(live_tab(), -1);
   ASSERT_EQ(1U, service_->entries().size());
 
   // Recreate the service and have it load the tabs.
   RecreateService();
 
   // One entry should be created.
   ASSERT_EQ(1U, service_->entries().size());
 
-  const TabRestoreService::Entry* restored_entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::TAB, restored_entry->type);
+  const sessions::TabRestoreService::Entry* restored_entry =
+      service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::TAB, restored_entry->type);
 
   const Tab* restored_tab =
       static_cast<const Tab*>(restored_entry);
   // There should be 3 navs.
   ASSERT_EQ(3U, restored_tab->navigations.size());
   EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(),
             restored_tab->timestamp.ToInternalValue());
 }
 
 // Make sure we don't persist entries to disk that have post data. This
@@ skipping 25 matching lines @@
   EXPECT_FALSE(service_->IsLoaded());
 
   TestTabRestoreServiceObserver observer;
   service_->AddObserver(&observer);
   SynchronousLoadTabsFromLastSession();
   EXPECT_TRUE(observer.got_loaded());
   service_->RemoveObserver(&observer);
 
   // Make sure we get back one entry with one tab whose url is url1.
   ASSERT_EQ(1U, service_->entries().size());
-  TabRestoreService::Entry* entry2 = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::WINDOW, entry2->type);
-  TabRestoreService::Window* window =
-      static_cast<TabRestoreService::Window*>(entry2);
+  sessions::TabRestoreService::Entry* entry2 = service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry2->type);
+  sessions::TabRestoreService::Window* window =
+      static_cast<sessions::TabRestoreService::Window*>(entry2);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->timestamp.ToInternalValue());
   EXPECT_EQ(0, window->selected_tab_index);
   ASSERT_EQ(1U, window->tabs[0].navigations.size());
   EXPECT_EQ(0, window->tabs[0].current_navigation_index);
   EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue());
   EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url());
 }
 
 // Makes sure we don't attempt to load previous sessions after a restore.
@@ skipping 35 matching lines @@
   AddThreeNavigations();
 
   service_->CreateHistoricalTab(live_tab(), -1);
 
   RecreateService();
 
   // We should get back two entries, one from the previous session and one from
   // the tab restore service. The previous session entry should be first.
   ASSERT_EQ(2U, service_->entries().size());
   // The first entry should come from the session service.
-  TabRestoreService::Entry* entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::WINDOW, entry->type);
-  TabRestoreService::Window* window =
-      static_cast<TabRestoreService::Window*>(entry);
+  sessions::TabRestoreService::Entry* entry = service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
+  sessions::TabRestoreService::Window* window =
+      static_cast<sessions::TabRestoreService::Window*>(entry);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->selected_tab_index);
   EXPECT_EQ(0, window->timestamp.ToInternalValue());
   ASSERT_EQ(1U, window->tabs[0].navigations.size());
   EXPECT_EQ(0, window->tabs[0].current_navigation_index);
   EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue());
   EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url());
 
   // Then the closed tab.
   entry = *(++service_->entries().begin());
-  ASSERT_EQ(TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   ASSERT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
   EXPECT_EQ(2, tab->current_navigation_index);
   EXPECT_EQ(time_factory_->TimeNow().ToInternalValue(),
             tab->timestamp.ToInternalValue());
   EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url());
   EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url());
   EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url());
 }
 
 // Make sure pinned state is correctly loaded from session service.
 TEST_F(PersistentTabRestoreServiceTest, LoadPreviousSessionAndTabsPinned) {
   CreateSessionServiceWithOneWindow(true);
 
   SessionServiceFactory::GetForProfile(profile())->
       MoveCurrentSessionToLastSession();
 
   AddThreeNavigations();
 
   service_->CreateHistoricalTab(live_tab(), -1);
 
   RecreateService();
 
   // We should get back two entries, one from the previous session and one from
   // the tab restore service. The previous session entry should be first.
   ASSERT_EQ(2U, service_->entries().size());
   // The first entry should come from the session service.
-  TabRestoreService::Entry* entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::WINDOW, entry->type);
-  TabRestoreService::Window* window =
-      static_cast<TabRestoreService::Window*>(entry);
+  sessions::TabRestoreService::Entry* entry = service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
+  sessions::TabRestoreService::Window* window =
+      static_cast<sessions::TabRestoreService::Window*>(entry);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->selected_tab_index);
   EXPECT_TRUE(window->tabs[0].pinned);
   ASSERT_EQ(1U, window->tabs[0].navigations.size());
   EXPECT_EQ(0, window->tabs[0].current_navigation_index);
   EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url());
 
   // Then the closed tab.
   entry = *(++service_->entries().begin());
-  ASSERT_EQ(TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   ASSERT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
   EXPECT_EQ(2, tab->current_navigation_index);
   EXPECT_TRUE(url1_ == tab->navigations[0].virtual_url());
   EXPECT_TRUE(url2_ == tab->navigations[1].virtual_url());
   EXPECT_TRUE(url3_ == tab->navigations[2].virtual_url());
 }
 
 // Creates kMaxEntries + 1 windows in the session service and makes sure we only
@@ skipping 11 matching lines @@
 
   service_->CreateHistoricalTab(live_tab(), -1);
 
   RecreateService();
 
   // We should get back kMaxEntries entries. We added more, but
   // TabRestoreService only allows up to kMaxEntries.
   ASSERT_EQ(kMaxEntries, service_->entries().size());
 
   // The first entry should come from the session service.
-  TabRestoreService::Entry* entry = service_->entries().front();
-  ASSERT_EQ(TabRestoreService::WINDOW, entry->type);
-  TabRestoreService::Window* window =
-      static_cast<TabRestoreService::Window*>(entry);
+  sessions::TabRestoreService::Entry* entry = service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
+  sessions::TabRestoreService::Window* window =
+      static_cast<sessions::TabRestoreService::Window*>(entry);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->selected_tab_index);
   EXPECT_EQ(0, window->timestamp.ToInternalValue());
   ASSERT_EQ(1U, window->tabs[0].navigations.size());
   EXPECT_EQ(0, window->tabs[0].current_navigation_index);
   EXPECT_EQ(0, window->tabs[0].timestamp.ToInternalValue());
   EXPECT_TRUE(url1_ == window->tabs[0].navigations[0].virtual_url());
 }
 
 // Makes sure we restore timestamps correctly.
 TEST_F(PersistentTabRestoreServiceTest, TimestampSurvivesRestore) {
   base::Time tab_timestamp(base::Time::FromInternalValue(123456789));
 
   AddThreeNavigations();
 
   // Have the service record the tab.
   service_->CreateHistoricalTab(live_tab(), -1);
 
   // Make sure an entry was created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // Make sure the entry matches.
   std::vector<SerializedNavigationEntry> old_navigations;
   {
     // |entry|/|tab| doesn't survive after RecreateService().
-    TabRestoreService::Entry* entry = service_->entries().front();
-    ASSERT_EQ(TabRestoreService::TAB, entry->type);
+    sessions::TabRestoreService::Entry* entry = service_->entries().front();
+    ASSERT_EQ(sessions::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(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);
+  sessions::TabRestoreService::Entry* restored_entry =
+      service_->entries().front();
+  ASSERT_EQ(sessions::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(old_navigations[i].timestamp(),
               restored_tab->navigations[i].timestamp());
   }
 }
 
 // Makes sure we restore status codes correctly.
 TEST_F(PersistentTabRestoreServiceTest, StatusCodesSurviveRestore) {
   AddThreeNavigations();
 
   // Have the service record the tab.
   service_->CreateHistoricalTab(live_tab(), -1);
 
   // Make sure an entry was created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // Make sure the entry matches.
   std::vector<sessions::SerializedNavigationEntry> old_navigations;
   {
     // |entry|/|tab| doesn't survive after RecreateService().
-    TabRestoreService::Entry* entry = service_->entries().front();
-    ASSERT_EQ(TabRestoreService::TAB, entry->type);
+    sessions::TabRestoreService::Entry* entry = service_->entries().front();
+    ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
     Tab* tab = static_cast<Tab*>(entry);
     old_navigations = tab->navigations;
   }
 
   EXPECT_EQ(3U, old_navigations.size());
   for (size_t i = 0; i < old_navigations.size(); ++i) {
     EXPECT_EQ(200, old_navigations[i].http_status_code());
   }
 
   // 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);
+  sessions::TabRestoreService::Entry* restored_entry =
+      service_->entries().front();
+  ASSERT_EQ(sessions::TabRestoreService::TAB, restored_entry->type);
   Tab* restored_tab =
       static_cast<Tab*>(restored_entry);
   ASSERT_EQ(old_navigations.size(), restored_tab->navigations.size());
   for (size_t i = 0; i < restored_tab->navigations.size(); ++i) {
     EXPECT_EQ(200, restored_tab->navigations[i].http_status_code());
   }
 }
 
 TEST_F(PersistentTabRestoreServiceTest, PruneEntries) {
   service_->ClearEntries();
@@ skipping 117 matching lines @@
 
   EXPECT_FALSE(service_->IsLoaded());
   TestTabRestoreServiceObserver observer;
   service_->AddObserver(&observer);
   EXPECT_EQ(max_entries, service_->entries().size());
   SynchronousLoadTabsFromLastSession();
   EXPECT_TRUE(observer.got_loaded());
   EXPECT_TRUE(service_->IsLoaded());
   service_->RemoveObserver(&observer);
 }