Remove CRWSessionEntry from CRWSessionController's unittests.

ios/web/navigation/crw_session_controller_unittest.mm

 // Copyright 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.
 
 #import "ios/web/navigation/crw_session_controller.h"
 
 #import <Foundation/Foundation.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
 #import "ios/web/navigation/crw_session_controller+private_constructors.h"
-#import "ios/web/navigation/crw_session_entry.h"
 #import "ios/web/navigation/navigation_item_impl.h"
 #import "ios/web/navigation/navigation_manager_impl.h"
 #include "ios/web/public/referrer.h"
 #include "ios/web/public/test/fakes/test_browser_state.h"
 #include "ios/web/public/test/test_web_thread_bundle.h"
 #import "net/base/mac/url_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #import "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 
 @interface CRWSessionController (Testing)
-- (const GURL&)URLForSessionAtIndex:(NSUInteger)index;
+- (const GURL&)URLForItemAtIndex:(size_t)index;
 - (const GURL&)currentURL;
 @end
 
 @implementation CRWSessionController (Testing)
-- (const GURL&)URLForSessionAtIndex:(NSUInteger)index {
-  CRWSessionEntry* entry =
-      static_cast<CRWSessionEntry*>([self.entries objectAtIndex:index]);
-  return entry.navigationItem->GetURL();
+- (const GURL&)URLForItemAtIndex:(size_t)index {
+  web::NavigationItemList items = self.items;
+  if (index < items.size())
+    return items[index]->GetURL();
+  return GURL::EmptyGURL();
 }
 
 - (const GURL&)currentURL {
-  DCHECK([self currentEntry]);
-  return [self currentEntry].navigationItem->GetURL();
+  return self.currentItem ? self.currentItem->GetURL() : GURL::EmptyGURL();
 }
 @end
 
 namespace {
 
 class CRWSessionControllerTest : public PlatformTest {
  protected:
   void SetUp() override {
     session_controller_.reset([[CRWSessionController alloc]
         initWithBrowserState:&browser_state_
                  openedByDOM:NO]);
   }
 
   web::Referrer MakeReferrer(const std::string& url) {
     return web::Referrer(GURL(url), web::ReferrerPolicyDefault);
   }
 
   web::TestWebThreadBundle thread_bundle_;
   web::TestBrowserState browser_state_;
   base::scoped_nsobject<CRWSessionController> session_controller_;
 };
 
 TEST_F(CRWSessionControllerTest, Init) {
   EXPECT_FALSE([session_controller_ isOpenedByDOM]);
-  EXPECT_EQ(0U, [[session_controller_ entries] count]);
-  EXPECT_EQ(nil, [session_controller_ currentEntry]);
+  EXPECT_TRUE([session_controller_ items].empty());
+  EXPECT_FALSE([session_controller_ currentItem]);
 }
 
 // Tests session controller state after setting a pending index.
 TEST_F(CRWSessionControllerTest, SetPendingIndex) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
   [session_controller_ setPendingItemIndex:0];
   EXPECT_EQ(0, [session_controller_ pendingItemIndex]);
-  EXPECT_EQ([[session_controller_ entries] lastObject],
-            [session_controller_ pendingEntry]);
+  EXPECT_EQ([session_controller_ items].back(),
+            [session_controller_ pendingItem]);
 }
 
 TEST_F(CRWSessionControllerTest, addPendingItem) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
-  EXPECT_EQ(0U, [[session_controller_ entries] count]);
+  EXPECT_TRUE([session_controller_ items].empty());
   EXPECT_EQ(
       GURL("http://www.url.com/"),
       [session_controller_ currentURL]);
 }
 
-TEST_F(CRWSessionControllerTest, addPendingItemWithCommittedEntries) {
+TEST_F(CRWSessionControllerTest, addPendingItemWithCommittedItems) {
   [session_controller_
       addPendingItem:GURL("http://www.committed.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
-  EXPECT_EQ(1U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      GURL("http://www.committed.url.com/"),
-      [session_controller_ URLForSessionAtIndex:0U]);
+  EXPECT_EQ(1U, [session_controller_ items].size());
+  EXPECT_EQ(GURL("http://www.committed.url.com/"),
+            [session_controller_ URLForItemAtIndex:0U]);
   EXPECT_EQ(
       GURL("http://www.url.com/"),
       [session_controller_ currentURL]);
 }
 
-// Tests that adding a pending entry resets pending entry index.
-TEST_F(CRWSessionControllerTest, addPendingItemWithExisingPendingEntryIndex) {
+// Tests that adding a pending item resets pending item index.
+TEST_F(CRWSessionControllerTest, addPendingItemWithExistingPendingItemIndex) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
-  // Set 0 as pending entry index.
+  // Set 0 as pending item index.
   [session_controller_ setPendingItemIndex:0];
   EXPECT_EQ(GURL("http://www.example.com/"),
-            [[session_controller_ pendingEntry] navigationItem]->GetURL());
+            [session_controller_ pendingItem]->GetURL());
   EXPECT_EQ(0, [session_controller_ pendingItemIndex]);
 
-  // Add a pending entry, which should drop pending navigation index.
+  // Add a pending item, which should drop pending navigation index.
   [session_controller_
       addPendingItem:GURL("http://www.example.com/1")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   EXPECT_EQ(GURL("http://www.example.com/1"),
-            [[session_controller_ pendingEntry] navigationItem]->GetURL());
+            [session_controller_ pendingItem]->GetURL());
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
 }
 
 TEST_F(CRWSessionControllerTest, addPendingItemOverriding) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_
       addPendingItem:GURL("http://www.another.url.com")
             referrer:MakeReferrer("http://www.another.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
-  EXPECT_EQ(0U, [[session_controller_ entries] count]);
+  EXPECT_TRUE([session_controller_ items].empty());
   EXPECT_EQ(
       GURL("http://www.another.url.com/"),
       [session_controller_ currentURL]);
 }
 
 TEST_F(CRWSessionControllerTest, addPendingItemAndCommit) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
-  EXPECT_EQ(1U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      GURL("http://www.url.com/"),
-      [session_controller_ URLForSessionAtIndex:0U]);
-  EXPECT_EQ(
-      [[session_controller_ entries] objectAtIndex:0U],
-      [session_controller_ currentEntry]);
+  EXPECT_EQ(1U, [session_controller_ items].size());
+  EXPECT_EQ(GURL("http://www.url.com/"),
+            [session_controller_ URLForItemAtIndex:0U]);
+  EXPECT_EQ([session_controller_ items].front(),
+            [session_controller_ currentItem]);
 }
 
 TEST_F(CRWSessionControllerTest, addPendingItemOverridingAndCommit) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_
       addPendingItem:GURL("http://www.another.url.com")
             referrer:MakeReferrer("http://www.another.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
-  EXPECT_EQ(1U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      GURL("http://www.another.url.com/"),
-      [session_controller_ URLForSessionAtIndex:0U]);
-  EXPECT_EQ(
-      [[session_controller_ entries] objectAtIndex:0U],
-      [session_controller_ currentEntry]);
+  EXPECT_EQ(1U, [session_controller_ items].size());
+  EXPECT_EQ(GURL("http://www.another.url.com/"),
+            [session_controller_ URLForItemAtIndex:0U]);
+  EXPECT_EQ([session_controller_ items].front(),
+            [session_controller_ currentItem]);
 }
 
 TEST_F(CRWSessionControllerTest, addPendingItemAndCommitMultiple) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   [session_controller_
       addPendingItem:GURL("http://www.another.url.com")
             referrer:MakeReferrer("http://www.another.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
-  EXPECT_EQ(2U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      GURL("http://www.url.com/"),
-      [session_controller_ URLForSessionAtIndex:0U]);
-  EXPECT_EQ(
-      GURL("http://www.another.url.com/"),
-      [session_controller_ URLForSessionAtIndex:1U]);
-  EXPECT_EQ(
-      [[session_controller_ entries] objectAtIndex:1U],
-      [session_controller_ currentEntry]);
+  EXPECT_EQ(2U, [session_controller_ items].size());
+  EXPECT_EQ(GURL("http://www.url.com/"),
+            [session_controller_ URLForItemAtIndex:0U]);
+  EXPECT_EQ(GURL("http://www.another.url.com/"),
+            [session_controller_ URLForItemAtIndex:1U]);
+  EXPECT_EQ([session_controller_ items][1U], [session_controller_ currentItem]);
 }
 
 TEST_F(CRWSessionControllerTest, addPendingItemAndDiscard) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ discardNonCommittedItems];
 
-  EXPECT_EQ(0U, [[session_controller_ entries] count]);
-  EXPECT_EQ(nil, [session_controller_ currentEntry]);
+  EXPECT_TRUE([session_controller_ items].empty());
+  EXPECT_FALSE([session_controller_ currentItem]);
 }
 
-// Tests discarding pending entry added via |setPendingItemIndex:| call.
+// Tests discarding pending item added via |setPendingItemIndex:| call.
 TEST_F(CRWSessionControllerTest, setPendingItemIndexAndDiscard) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   [session_controller_ setPendingItemIndex:0];
-  EXPECT_TRUE([session_controller_ pendingEntry]);
+  EXPECT_TRUE([session_controller_ pendingItem]);
   EXPECT_EQ(0, [session_controller_ pendingItemIndex]);
 
   [session_controller_ discardNonCommittedItems];
-  EXPECT_FALSE([session_controller_ pendingEntry]);
+  EXPECT_FALSE([session_controller_ pendingItem]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
 }
 
 TEST_F(CRWSessionControllerTest, addPendingItemAndDiscardAndAddAndCommit) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ discardNonCommittedItems];
 
   [session_controller_
       addPendingItem:GURL("http://www.another.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
-  EXPECT_EQ(1U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      GURL("http://www.another.url.com/"),
-      [session_controller_ URLForSessionAtIndex:0U]);
-  EXPECT_EQ(
-      [[session_controller_ entries] objectAtIndex:0U],
-      [session_controller_ currentEntry]);
+  EXPECT_EQ(1U, [session_controller_ items].size());
+  EXPECT_EQ(GURL("http://www.another.url.com/"),
+            [session_controller_ URLForItemAtIndex:0U]);
+  EXPECT_EQ([session_controller_ items].front(),
+            [session_controller_ currentItem]);
 }
 
 TEST_F(CRWSessionControllerTest, addPendingItemAndCommitAndAddAndDiscard) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   [session_controller_
       addPendingItem:GURL("http://www.another.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ discardNonCommittedItems];
 
-  EXPECT_EQ(1U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      GURL("http://www.url.com/"),
-      [session_controller_ URLForSessionAtIndex:0U]);
-  EXPECT_EQ(
-      [[session_controller_ entries] objectAtIndex:0U],
-      [session_controller_ currentEntry]);
+  EXPECT_EQ(1U, [session_controller_ items].size());
+  EXPECT_EQ(GURL("http://www.url.com/"),
+            [session_controller_ URLForItemAtIndex:0U]);
+  EXPECT_EQ([session_controller_ items].front(),
+            [session_controller_ currentItem]);
 }
 
 TEST_F(CRWSessionControllerTest,
-       commitPendingItemWithoutPendingOrCommittedEntry) {
+       commitPendingItemWithoutPendingOrCommittedItem) {
   [session_controller_ commitPendingItem];
 
-  EXPECT_EQ(0U, [[session_controller_ entries] count]);
-  EXPECT_EQ(nil, [session_controller_ currentEntry]);
+  EXPECT_TRUE([session_controller_ items].empty());
+  EXPECT_FALSE([session_controller_ currentItem]);
 }
 
 TEST_F(CRWSessionControllerTest,
-       commitPendingItemWithoutPendingEntryWithCommittedEntry) {
-  // Setup committed entry
+       commitPendingItemWithoutPendingItemWithCommittedItem) {
+  // Setup committed item.
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
-  // Commit pending entry when there is no such one
+  // Commit pending item when there is no such one
   [session_controller_ commitPendingItem];
 
-  EXPECT_EQ(1U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      [[session_controller_ entries] objectAtIndex:0U],
-      [session_controller_ currentEntry]);
+  EXPECT_EQ(1U, [session_controller_ items].size());
+  EXPECT_EQ([session_controller_ items].front(),
+            [session_controller_ currentItem]);
 }
 
-// Tests that forward entries are discarded after navigation entry is committed.
-TEST_F(CRWSessionControllerTest, commitPendingItemWithExistingForwardEntries) {
+// Tests that forward entries are discarded after navigation item is committed.
+TEST_F(CRWSessionControllerTest, commitPendingItemWithExistingForwardItems) {
   // Make 3 entries.
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/1")
             referrer:MakeReferrer("http://www.example.com/b")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/2")
             referrer:MakeReferrer("http://www.example.com/c")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
   [session_controller_ commitPendingItem];
 
-  // Go back to the first entry.
+  // Go back to the first item.
   [session_controller_ goToItemAtIndex:0];
 
-  // Create and commit a new pending entry.
+  // Create and commit a new pending item.
   [session_controller_
       addPendingItem:GURL("http://www.example.com/2")
             referrer:MakeReferrer("http://www.example.com/c")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
   [session_controller_ commitPendingItem];
 
   // All forward entries should go away.
-  EXPECT_EQ(2U, [[session_controller_ entries] count]);
-  EXPECT_EQ(0U, [[session_controller_ forwardEntries] count]);
+  EXPECT_EQ(2U, [session_controller_ items].size());
+  EXPECT_EQ(0U, [session_controller_ forwardItems].size());
   ASSERT_EQ(1, [session_controller_ currentNavigationIndex]);
   ASSERT_EQ(0, [session_controller_ previousNavigationIndex]);
 }
 
-// Tests committing pending entry index from the middle.
+// Tests committing pending item index from the middle.
 TEST_F(CRWSessionControllerTest, commitPendingItemIndex) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/1")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/2")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
-  ASSERT_EQ(3U, [[session_controller_ entries] count]);
+  ASSERT_EQ(3U, [session_controller_ items].size());
 
-  // Go to the middle, and commit first pending entry index.
+  // Go to the middle, and commit first pending item index.
   [session_controller_ goToItemAtIndex:1];
   [session_controller_ setPendingItemIndex:0];
   ASSERT_EQ(0, [session_controller_ pendingItemIndex]);
-  base::scoped_nsobject<CRWSessionEntry> pendingEntry(
-      [[session_controller_ pendingEntry] retain]);
-  ASSERT_TRUE(pendingEntry);
+  web::NavigationItem* pendingItem = [session_controller_ pendingItem];
+  ASSERT_TRUE(pendingItem);
   ASSERT_EQ(1, [session_controller_ currentNavigationIndex]);
   EXPECT_EQ(2, [session_controller_ previousNavigationIndex]);
   [session_controller_ commitPendingItem];
 
-  // Verify that pending entry has been committed and current and previous entry
+  // Verify that pending item has been committed and current and previous item
   // indices updated.
-  EXPECT_EQ(pendingEntry, [session_controller_ lastCommittedEntry]);
+  EXPECT_EQ([session_controller_ lastCommittedItem], pendingItem);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
-  EXPECT_FALSE([session_controller_ pendingEntry]);
+  EXPECT_FALSE([session_controller_ pendingItem]);
   EXPECT_EQ(0, [session_controller_ currentNavigationIndex]);
   EXPECT_EQ(1, [session_controller_ previousNavigationIndex]);
-  EXPECT_EQ(3U, [[session_controller_ entries] count]);
+  EXPECT_EQ(3U, [session_controller_ items].size());
 }
 
 TEST_F(CRWSessionControllerTest,
-       DiscardPendingEntryWithoutPendingOrCommittedEntry) {
+       DiscardPendingItemWithoutPendingOrCommittedItem) {
   [session_controller_ discardNonCommittedItems];
 
-  EXPECT_EQ(0U, [[session_controller_ entries] count]);
-  EXPECT_EQ(nil, [session_controller_ currentEntry]);
+  EXPECT_TRUE([session_controller_ items].empty());
+  EXPECT_FALSE([session_controller_ currentItem]);
 }
 
 TEST_F(CRWSessionControllerTest,
-       DiscardPendingEntryWithoutPendingEntryWithCommittedEntry) {
-  // Setup committed entry
+       DiscardPendingItemWithoutPendingItemWithCommittedItem) {
+  // Setup committed item
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   // Discard noncommitted entries when there is no such one
   [session_controller_ discardNonCommittedItems];
 
-  EXPECT_EQ(1U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      [[session_controller_ entries] objectAtIndex:0U],
-      [session_controller_ currentEntry]);
+  EXPECT_EQ(1U, [session_controller_ items].size());
+  EXPECT_EQ([session_controller_ items].front(),
+            [session_controller_ currentItem]);
 }
 
-TEST_F(CRWSessionControllerTest, updatePendingItemWithoutPendingEntry) {
+TEST_F(CRWSessionControllerTest, updatePendingItemWithoutPendingItem) {
   [session_controller_ updatePendingItem:GURL("http://www.another.url.com")];
   [session_controller_ commitPendingItem];
 
-  EXPECT_EQ(0U, [[session_controller_ entries] count]);
-  EXPECT_EQ(nil, [session_controller_ currentEntry]);
+  EXPECT_TRUE([session_controller_ items].empty());
+  EXPECT_FALSE([session_controller_ currentItem]);
 }
 
-TEST_F(CRWSessionControllerTest, updatePendingItemWithPendingEntry) {
+TEST_F(CRWSessionControllerTest, updatePendingItemWithPendingItem) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ updatePendingItem:GURL("http://www.another.url.com")];
 
   EXPECT_EQ(
       GURL("http://www.another.url.com/"),
       [session_controller_ currentURL]);
 }
 
 TEST_F(CRWSessionControllerTest,
-       updatePendingItemWithPendingEntryAlreadyCommited) {
+       updatePendingItemWithPendingItemAlreadyCommited) {
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_ updatePendingItem:GURL("http://www.another.url.com")];
   [session_controller_ commitPendingItem];
 
-  EXPECT_EQ(1U, [[session_controller_ entries] count]);
-  EXPECT_EQ(
-      GURL("http://www.url.com/"),
-      [session_controller_ URLForSessionAtIndex:0U]);
-  EXPECT_EQ(
-      [[session_controller_ entries] objectAtIndex:0U],
-      [session_controller_ currentEntry]);
+  EXPECT_EQ(1U, [session_controller_ items].size());
+  EXPECT_EQ(GURL("http://www.url.com/"),
+            [session_controller_ URLForItemAtIndex:0U]);
+  EXPECT_EQ([session_controller_ items].front(),
+            [session_controller_ currentItem]);
 }
 
 // Tests inserting session controller state.
 TEST_F(CRWSessionControllerTest, InsertState) {
-  // Add 1 committed and 1 pending entry to target controller.
+  // Add 1 committed and 1 pending item to target controller.
   [session_controller_
       addPendingItem:GURL("http://www.url.com/2")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.url.com/3")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
-  // Create source session controller with 1 committed entry.
+  // Create source session controller with 1 committed item.
   base::scoped_nsobject<CRWSessionController> other_session_controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                              openedByDOM:NO]);
   [other_session_controller
       addPendingItem:GURL("http://www.url.com/0")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [other_session_controller commitPendingItem];
   [other_session_controller
       addPendingItem:GURL("http://www.url.com/1")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
   // Insert and verify the state of target session controller.
   [session_controller_
       insertStateFromSessionController:other_session_controller.get()];
 
-  EXPECT_EQ(2U, [[session_controller_ entries] count]);
+  EXPECT_EQ(2U, [session_controller_ items].size());
   EXPECT_EQ(1, [session_controller_ currentNavigationIndex]);
   EXPECT_EQ(-1, [session_controller_ previousNavigationIndex]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
 
   EXPECT_EQ(GURL("http://www.url.com/0"),
-            [session_controller_ URLForSessionAtIndex:0]);
+            [session_controller_ URLForItemAtIndex:0]);
   EXPECT_EQ(GURL("http://www.url.com/2"),
-            [session_controller_ URLForSessionAtIndex:1]);
+            [session_controller_ URLForItemAtIndex:1]);
   EXPECT_EQ(GURL("http://www.url.com/3"),
-            [[session_controller_ pendingEntry] navigationItem]->GetURL());
+            [session_controller_ pendingItem]->GetURL());
 }
 
 // Tests inserting session controller state from empty session controller.
 TEST_F(CRWSessionControllerTest, InsertStateFromEmptySessionController) {
   // Add 2 committed entries to target controller.
   [session_controller_
       addPendingItem:GURL("http://www.url.com/0")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.url.com/1")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   // Create empty source session controller.
   base::scoped_nsobject<CRWSessionController> other_session_controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                              openedByDOM:NO]);
 
   // Insert and verify the state of target session controller.
   [session_controller_
       insertStateFromSessionController:other_session_controller.get()];
-  EXPECT_EQ(2U, [[session_controller_ entries] count]);
+  EXPECT_EQ(2U, [session_controller_ items].size());
   EXPECT_EQ(1, [session_controller_ currentNavigationIndex]);
   EXPECT_EQ(0, [session_controller_ previousNavigationIndex]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
-  EXPECT_FALSE([session_controller_ pendingEntry]);
+  EXPECT_FALSE([session_controller_ pendingItem]);
   EXPECT_EQ(GURL("http://www.url.com/0"),
-            [session_controller_ URLForSessionAtIndex:0]);
+            [session_controller_ URLForItemAtIndex:0]);
   EXPECT_EQ(GURL("http://www.url.com/1"),
-            [session_controller_ URLForSessionAtIndex:1]);
+            [session_controller_ URLForItemAtIndex:1]);
 }
 
 // Tests inserting session controller state to empty session controller.
 TEST_F(CRWSessionControllerTest, InsertStateToEmptySessionController) {
   // Create source session controller with 2 committed entries and one
-  // pending entry.
+  // pending item.
   base::scoped_nsobject<CRWSessionController> other_session_controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                              openedByDOM:NO]);
   [other_session_controller
       addPendingItem:GURL("http://www.url.com/0")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [other_session_controller commitPendingItem];
   [other_session_controller
       addPendingItem:GURL("http://www.url.com/1")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [other_session_controller commitPendingItem];
   [other_session_controller
       addPendingItem:GURL("http://www.url.com/2")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
   // Insert and verify the state of target session controller.
   [session_controller_
       insertStateFromSessionController:other_session_controller.get()];
 
-  EXPECT_EQ(2U, [[session_controller_ entries] count]);
+  EXPECT_EQ(2U, [session_controller_ items].size());
   EXPECT_EQ(1, [session_controller_ currentNavigationIndex]);
   EXPECT_EQ(-1, [session_controller_ previousNavigationIndex]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
-  EXPECT_FALSE([session_controller_ pendingEntry]);
+  EXPECT_FALSE([session_controller_ pendingItem]);
   EXPECT_EQ(GURL("http://www.url.com/0"),
-            [session_controller_ URLForSessionAtIndex:0]);
+            [session_controller_ URLForItemAtIndex:0]);
   EXPECT_EQ(GURL("http://www.url.com/1"),
-            [session_controller_ URLForSessionAtIndex:1]);
+            [session_controller_ URLForItemAtIndex:1]);
 }
 
-// Tests inserting session controller state. Verifies that pending entry index
+// Tests inserting session controller state. Verifies that pending item index
 // remains valid.
 TEST_F(CRWSessionControllerTest,
-       InsertStateWithPendingEntryIndexInTargetController) {
-  // Add 2 committed entries and make the first entry pending.
+       InsertStateWithPendingItemIndexInTargetController) {
+  // Add 2 committed entries and make the first item pending.
   [session_controller_
       addPendingItem:GURL("http://www.url.com/2")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.url.com/3")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_ setPendingItemIndex:0];
 
-  // Create source session controller with 1 committed entry.
+  // Create source session controller with 1 committed item.
   base::scoped_nsobject<CRWSessionController> other_session_controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                              openedByDOM:NO]);
   [other_session_controller
       addPendingItem:GURL("http://www.url.com/0")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [other_session_controller commitPendingItem];
 
   // Insert and verify the state of target session controller.
   [session_controller_
       insertStateFromSessionController:other_session_controller.get()];
 
-  EXPECT_EQ(3U, [[session_controller_ entries] count]);
+  EXPECT_EQ(3U, [session_controller_ items].size());
   EXPECT_EQ(2, [session_controller_ currentNavigationIndex]);
   EXPECT_EQ(-1, [session_controller_ previousNavigationIndex]);
   EXPECT_EQ(1, [session_controller_ pendingItemIndex]);
   EXPECT_EQ(GURL("http://www.url.com/0"),
-            [session_controller_ URLForSessionAtIndex:0]);
+            [session_controller_ URLForItemAtIndex:0]);
   EXPECT_EQ(GURL("http://www.url.com/2"),
-            [session_controller_ URLForSessionAtIndex:1]);
+            [session_controller_ URLForItemAtIndex:1]);
   EXPECT_EQ(GURL("http://www.url.com/2"),
-            [[session_controller_ pendingEntry] navigationItem]->GetURL());
+            [session_controller_ pendingItem]->GetURL());
 }
 
 // Tests state of an empty session controller.
 TEST_F(CRWSessionControllerTest, EmptyController) {
-  EXPECT_EQ(0U, [[session_controller_ entries] count]);
+  EXPECT_TRUE([session_controller_ items].empty());
   EXPECT_EQ(-1, [session_controller_ currentNavigationIndex]);
   EXPECT_EQ(-1, [session_controller_ previousNavigationIndex]);
-  EXPECT_FALSE([session_controller_ currentEntry]);
-  EXPECT_FALSE([session_controller_ pendingEntry]);
+  EXPECT_FALSE([session_controller_ currentItem]);
+  EXPECT_FALSE([session_controller_ pendingItem]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
 }
 
 // Helper to create a NavigationItem.
 std::unique_ptr<web::NavigationItemImpl> CreateNavigationItem(
     const std::string& url,
     const std::string& referrer,
     NSString* title) {
   web::Referrer referrer_object(GURL(referrer),
                                 web::ReferrerPolicyDefault);
   std::unique_ptr<web::NavigationItemImpl> navigation_item =
       base::MakeUnique<web::NavigationItemImpl>();
   navigation_item->SetURL(GURL(url));
   navigation_item->SetReferrer(referrer_object);
   navigation_item->SetTitle(base::SysNSStringToUTF16(title));
   navigation_item->SetTransitionType(ui::PAGE_TRANSITION_TYPED);
 
   return navigation_item;
 }
 
 TEST_F(CRWSessionControllerTest, CreateWithEmptyNavigations) {
   std::vector<std::unique_ptr<web::NavigationItem>> items;
   base::scoped_nsobject<CRWSessionController> controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                          navigationItems:std::move(items)
                                             currentIndex:0]);
-  EXPECT_EQ(controller.get().entries.count, 0U);
+  EXPECT_TRUE(controller.get().items.empty());
   EXPECT_EQ(controller.get().currentNavigationIndex, -1);
   EXPECT_EQ(controller.get().previousNavigationIndex, -1);
-  EXPECT_FALSE(controller.get().currentEntry);
+  EXPECT_FALSE(controller.get().currentItem);
 }
 
 TEST_F(CRWSessionControllerTest, CreateWithNavList) {
   std::vector<std::unique_ptr<web::NavigationItem>> items;
   items.push_back(CreateNavigationItem("http://www.google.com",
                                        "http://www.referrer.com", @"Google"));
   items.push_back(CreateNavigationItem("http://www.yahoo.com",
                                        "http://www.google.com", @"Yahoo"));
   items.push_back(CreateNavigationItem("http://www.espn.com",
                                        "http://www.nothing.com", @"ESPN"));
   base::scoped_nsobject<CRWSessionController> controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                          navigationItems:std::move(items)
                                             currentIndex:1]);
 
-  EXPECT_EQ(controller.get().entries.count, 3U);
+  EXPECT_EQ(controller.get().items.size(), 3U);
   EXPECT_EQ(controller.get().currentNavigationIndex, 1);
   EXPECT_EQ(controller.get().previousNavigationIndex, -1);
-  // Sanity check the current entry, the CRWSessionEntry unit test will ensure
+  // Sanity check the current item, the CRWSessionItem unit test will ensure
   // the entire object is created properly.
-  CRWSessionEntry* current_entry = controller.get().currentEntry;
-  EXPECT_EQ(current_entry.navigationItem->GetURL(),
+  EXPECT_EQ(controller.get().currentItem->GetURL(),
             GURL("http://www.yahoo.com"));
 }
 
-// Tests index of previous navigation entry.
-TEST_F(CRWSessionControllerTest, PreviousNavigationEntry) {
+// Tests index of previous navigation item.
+TEST_F(CRWSessionControllerTest, PreviousNavigationItem) {
   EXPECT_EQ(session_controller_.get().previousNavigationIndex, -1);
   [session_controller_
       addPendingItem:GURL("http://www.url.com")
             referrer:MakeReferrer("http://www.referer.com")
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   EXPECT_EQ(session_controller_.get().previousNavigationIndex, -1);
   [session_controller_
       addPendingItem:GURL("http://www.url1.com")
@@ skipping 17 matching lines @@
   [session_controller_ goToItemAtIndex:0];
   EXPECT_EQ(session_controller_.get().previousNavigationIndex, 1);
 
   [session_controller_ goToItemAtIndex:1];
   EXPECT_EQ(session_controller_.get().previousNavigationIndex, 0);
 
   [session_controller_ goToItemAtIndex:2];
   EXPECT_EQ(session_controller_.get().previousNavigationIndex, 1);
 }
 
-TEST_F(CRWSessionControllerTest, PushNewEntry) {
+TEST_F(CRWSessionControllerTest, PushNewItem) {
   std::vector<std::unique_ptr<web::NavigationItem>> items;
   items.push_back(CreateNavigationItem("http://www.firstpage.com",
                                        "http://www.starturl.com", @"First"));
   items.push_back(CreateNavigationItem("http://www.secondpage.com",
                                        "http://www.firstpage.com", @"Second"));
   items.push_back(CreateNavigationItem("http://www.thirdpage.com",
                                        "http://www.secondpage.com", @"Third"));
   base::scoped_nsobject<CRWSessionController> controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                          navigationItems:std::move(items)
                                             currentIndex:0]);
 
   GURL pushPageGurl1("http://www.firstpage.com/#push1");
   NSString* stateObject1 = @"{'foo': 1}";
   [controller pushNewItemWithURL:pushPageGurl1
                      stateObject:stateObject1
                       transition:ui::PAGE_TRANSITION_LINK];
-  CRWSessionEntry* pushedEntry = [controller currentEntry];
-  web::NavigationItemImpl* pushedItem = pushedEntry.navigationItemImpl;
+  web::NavigationItemImpl* pushedItem = [controller currentItem];
   NSUInteger expectedCount = 2;
-  EXPECT_EQ(expectedCount, controller.get().entries.count);
-  EXPECT_EQ(pushPageGurl1, pushedEntry.navigationItem->GetURL());
+  EXPECT_EQ(expectedCount, controller.get().items.size());
+  EXPECT_EQ(pushPageGurl1, pushedItem->GetURL());
   EXPECT_TRUE(pushedItem->IsCreatedFromPushState());
   EXPECT_NSEQ(stateObject1, pushedItem->GetSerializedStateObject());
-  EXPECT_EQ(GURL("http://www.firstpage.com/"),
-            pushedEntry.navigationItem->GetReferrer().url);
+  EXPECT_EQ(GURL("http://www.firstpage.com/"), pushedItem->GetReferrer().url);
 
-  // Add another new entry and check size and fields again.
+  // Add another new item and check size and fields again.
   GURL pushPageGurl2("http://www.firstpage.com/push2");
   [controller pushNewItemWithURL:pushPageGurl2
                      stateObject:nil
                       transition:ui::PAGE_TRANSITION_LINK];
-  pushedEntry = [controller currentEntry];
-  pushedItem = pushedEntry.navigationItemImpl;
+  pushedItem = [controller currentItem];
   expectedCount = 3;
-  EXPECT_EQ(expectedCount, controller.get().entries.count);
-  EXPECT_EQ(pushPageGurl2, pushedEntry.navigationItem->GetURL());
+  EXPECT_EQ(expectedCount, controller.get().items.size());
+  EXPECT_EQ(pushPageGurl2, pushedItem->GetURL());
   EXPECT_TRUE(pushedItem->IsCreatedFromPushState());
   EXPECT_EQ(nil, pushedItem->GetSerializedStateObject());
-  EXPECT_EQ(pushPageGurl1, pushedEntry.navigationItem->GetReferrer().url);
+  EXPECT_EQ(pushPageGurl1, pushedItem->GetReferrer().url);
 }
 
 TEST_F(CRWSessionControllerTest, IsSameDocumentNavigation) {
   std::vector<std::unique_ptr<web::NavigationItem>> items;
   items.push_back(
       CreateNavigationItem("http://foo.com", "http://google.com", @"First"));
   // Push state navigation.
   items.push_back(
       CreateNavigationItem("http://foo.com#bar", "http://foo.com", @"Second"));
   items.push_back(CreateNavigationItem("http://google.com",
@@ skipping 35 matching lines @@
   EXPECT_TRUE(
       [controller isSameDocumentNavigationBetweenItem:item4 andItem:item3]);
   EXPECT_FALSE(
       [controller isSameDocumentNavigationBetweenItem:item1 andItem:item2]);
   EXPECT_FALSE(
       [controller isSameDocumentNavigationBetweenItem:item0 andItem:item5]);
   EXPECT_FALSE(
       [controller isSameDocumentNavigationBetweenItem:item2 andItem:item4]);
 }
 
-TEST_F(CRWSessionControllerTest, UpdateCurrentEntry) {
+TEST_F(CRWSessionControllerTest, UpdateCurrentItem) {
   std::vector<std::unique_ptr<web::NavigationItem>> items;
   items.push_back(CreateNavigationItem("http://www.firstpage.com",
                                        "http://www.starturl.com", @"First"));
   items.push_back(CreateNavigationItem("http://www.secondpage.com",
                                        "http://www.firstpage.com", @"Second"));
   items.push_back(CreateNavigationItem("http://www.thirdpage.com",
                                        "http://www.secondpage.com", @"Third"));
   base::scoped_nsobject<CRWSessionController> controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                          navigationItems:std::move(items)
                                             currentIndex:0]);
 
   GURL replacePageGurl1("http://www.firstpage.com/#replace1");
   NSString* stateObject1 = @"{'foo': 1}";
 
-  // Replace current entry and check the size of history and fields of the
-  // modified entry.
+  // Replace current item and check the size of history and fields of the
+  // modified item.
   [controller updateCurrentItemWithURL:replacePageGurl1
                            stateObject:stateObject1];
-  CRWSessionEntry* replacedEntry = [controller currentEntry];
-  web::NavigationItemImpl* replacedItem = replacedEntry.navigationItemImpl;
+  web::NavigationItemImpl* replacedItem = [controller currentItem];
   NSUInteger expectedCount = 3;
-  EXPECT_EQ(expectedCount, controller.get().entries.count);
-  EXPECT_EQ(replacePageGurl1, replacedEntry.navigationItem->GetURL());
+  EXPECT_EQ(expectedCount, controller.get().items.size());
+  EXPECT_EQ(replacePageGurl1, replacedItem->GetURL());
   EXPECT_FALSE(replacedItem->IsCreatedFromPushState());
   EXPECT_NSEQ(stateObject1, replacedItem->GetSerializedStateObject());
-  EXPECT_EQ(GURL("http://www.starturl.com/"),
-            replacedEntry.navigationItem->GetReferrer().url);
+  EXPECT_EQ(GURL("http://www.starturl.com/"), replacedItem->GetReferrer().url);
 
-  // Replace current entry and check size and fields again.
+  // Replace current item and check size and fields again.
   GURL replacePageGurl2("http://www.firstpage.com/#replace2");
   [controller.get() updateCurrentItemWithURL:replacePageGurl2 stateObject:nil];
-  replacedEntry = [controller currentEntry];
-  replacedItem = replacedEntry.navigationItemImpl;
-  EXPECT_EQ(expectedCount, controller.get().entries.count);
-  EXPECT_EQ(replacePageGurl2, replacedEntry.navigationItem->GetURL());
+  replacedItem = [controller currentItem];
+  EXPECT_EQ(expectedCount, controller.get().items.size());
+  EXPECT_EQ(replacePageGurl2, replacedItem->GetURL());
   EXPECT_FALSE(replacedItem->IsCreatedFromPushState());
   EXPECT_NSEQ(nil, replacedItem->GetSerializedStateObject());
-  EXPECT_EQ(GURL("http://www.starturl.com/"),
-            replacedEntry.navigationItem->GetReferrer().url);
+  EXPECT_EQ(GURL("http://www.starturl.com/"), replacedItem->GetReferrer().url);
 }
 
-TEST_F(CRWSessionControllerTest, TestBackwardForwardEntries) {
+TEST_F(CRWSessionControllerTest, TestBackwardForwardItems) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/1")
             referrer:MakeReferrer("http://www.example.com/b")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/redirect")
             referrer:MakeReferrer("http://www.example.com/r")
           transition:ui::PAGE_TRANSITION_IS_REDIRECT_MASK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/2")
             referrer:MakeReferrer("http://www.example.com/c")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   EXPECT_EQ(3, session_controller_.get().currentNavigationIndex);
-  NSArray* backEntries = [session_controller_ backwardEntries];
-  EXPECT_EQ(2U, [backEntries count]);
-  EXPECT_EQ(0U, [[session_controller_ forwardEntries] count]);
-  EXPECT_EQ("http://www.example.com/redirect",
-            [[backEntries objectAtIndex:0] navigationItem]->GetURL().spec());
+  web::NavigationItemList backItems = [session_controller_ backwardItems];
+  EXPECT_EQ(2U, backItems.size());
+  EXPECT_TRUE([session_controller_ forwardItems].empty());
+  EXPECT_EQ("http://www.example.com/redirect", backItems[0]->GetURL().spec());
 
   [session_controller_ goToItemAtIndex:1];
-  EXPECT_EQ(1U, [[session_controller_ backwardEntries] count]);
-  EXPECT_EQ(1U, [[session_controller_ forwardEntries] count]);
+  EXPECT_EQ(1U, [session_controller_ backwardItems].size());
+  EXPECT_EQ(1U, [session_controller_ forwardItems].size());
 
   [session_controller_ goToItemAtIndex:0];
-  NSArray* forwardEntries = [session_controller_ forwardEntries];
-  EXPECT_EQ(0U, [[session_controller_ backwardEntries] count]);
-  EXPECT_EQ(2U, [forwardEntries count]);
-  EXPECT_EQ("http://www.example.com/2",
-            [[forwardEntries objectAtIndex:1] navigationItem]->GetURL().spec());
+  web::NavigationItemList forwardItems = [session_controller_ forwardItems];
+  EXPECT_EQ(0U, [session_controller_ backwardItems].size());
+  EXPECT_EQ(2U, forwardItems.size());
+  EXPECT_EQ("http://www.example.com/2", forwardItems[1]->GetURL().spec());
 }
 
 // Tests going to entries with existing and non-existing indices.
-TEST_F(CRWSessionControllerTest, GoToEntryAtIndex) {
+TEST_F(CRWSessionControllerTest, GoToItemAtIndex) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/1")
             referrer:MakeReferrer("http://www.example.com/b")
           transition:ui::PAGE_TRANSITION_LINK
@@ skipping 12 matching lines @@
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/3")
             referrer:MakeReferrer("http://www.example.com/d")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ addTransientItemWithURL:GURL("http://www.example.com")];
   EXPECT_EQ(3, session_controller_.get().currentNavigationIndex);
   EXPECT_EQ(2, session_controller_.get().previousNavigationIndex);
-  EXPECT_TRUE(session_controller_.get().pendingEntry);
-  EXPECT_TRUE(session_controller_.get().transientEntry);
+  EXPECT_TRUE([session_controller_ pendingItem]);
+  EXPECT_TRUE([session_controller_ transientItem]);
 
   // Going back should discard transient and pending entries.
   [session_controller_ goToItemAtIndex:1];
   EXPECT_EQ(1, session_controller_.get().currentNavigationIndex);
   EXPECT_EQ(3, session_controller_.get().previousNavigationIndex);
-  EXPECT_FALSE(session_controller_.get().pendingEntry);
-  EXPECT_FALSE(session_controller_.get().transientEntry);
+  EXPECT_FALSE([session_controller_ pendingItem]);
+  EXPECT_FALSE([session_controller_ transientItem]);
 
-  // Going forward should discard transient entry.
+  // Going forward should discard transient item.
   [session_controller_ addTransientItemWithURL:GURL("http://www.example.com")];
-  EXPECT_TRUE(session_controller_.get().transientEntry);
+  EXPECT_TRUE([session_controller_ transientItem]);
   [session_controller_ goToItemAtIndex:2];
   EXPECT_EQ(2, session_controller_.get().currentNavigationIndex);
   EXPECT_EQ(1, session_controller_.get().previousNavigationIndex);
-  EXPECT_FALSE(session_controller_.get().transientEntry);
+  EXPECT_FALSE([session_controller_ transientItem]);
 
   // Out of bounds navigations should be no-op.
   [session_controller_ goToItemAtIndex:-1];
   EXPECT_EQ(2, session_controller_.get().currentNavigationIndex);
   EXPECT_EQ(1, session_controller_.get().previousNavigationIndex);
   [session_controller_ goToItemAtIndex:NSIntegerMax];
   EXPECT_EQ(2, session_controller_.get().currentNavigationIndex);
   EXPECT_EQ(1, session_controller_.get().previousNavigationIndex);
 
   // Going to current index should not change the previous index.
   [session_controller_ goToItemAtIndex:2];
   EXPECT_EQ(2, session_controller_.get().currentNavigationIndex);
   EXPECT_EQ(1, session_controller_.get().previousNavigationIndex);
 }
 
 // Tests that visible URL is the same as transient URL if there are no committed
 // entries.
-TEST_F(CRWSessionControllerTest, VisibleEntryWithSingleTransientEntry) {
+TEST_F(CRWSessionControllerTest, VisibleItemWithSingleTransientItem) {
   [session_controller_ addTransientItemWithURL:GURL("http://www.example.com")];
-  web::NavigationItem* visible_item =
-      [[session_controller_ visibleEntry] navigationItem];
+  web::NavigationItem* visible_item = [session_controller_ visibleItem];
   ASSERT_TRUE(visible_item);
   EXPECT_EQ("http://www.example.com/", visible_item->GetURL().spec());
 }
 
 // Tests that visible URL is the same as transient URL if there is a committed
-// entry.
-TEST_F(CRWSessionControllerTest, VisibleEntryWithCommittedAndTransientEntries) {
+// item.
+TEST_F(CRWSessionControllerTest, VisibleItemWithCommittedAndTransientItems) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_ addTransientItemWithURL:GURL("http://www.example.com")];
-  web::NavigationItem* visible_item =
-      [[session_controller_ visibleEntry] navigationItem];
+  web::NavigationItem* visible_item = [session_controller_ visibleItem];
   ASSERT_TRUE(visible_item);
   EXPECT_EQ("http://www.example.com/", visible_item->GetURL().spec());
 }
 
 // Tests that visible URL is the same as pending URL if it was user-initiated.
 TEST_F(CRWSessionControllerTest,
-       VisibleEntryWithSingleUserInitiatedPendingEntry) {
+       VisibleItemWithSingleUserInitiatedPendingItem) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
-  web::NavigationItem* visible_item =
-      [[session_controller_ visibleEntry] navigationItem];
+  web::NavigationItem* visible_item = [session_controller_ visibleItem];
   ASSERT_TRUE(visible_item);
   EXPECT_EQ("http://www.example.com/0", visible_item->GetURL().spec());
 }
 
 // Tests that visible URL is the same as pending URL if it was user-initiated
-// and there is a committed entry.
+// and there is a committed item.
 TEST_F(CRWSessionControllerTest,
-       VisibleEntryWithCommittedAndUserInitiatedPendingEntry) {
+       VisibleItemWithCommittedAndUserInitiatedPendingItem) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/b")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
-  web::NavigationItem* visible_item =
-      [[session_controller_ visibleEntry] navigationItem];
+  web::NavigationItem* visible_item = [session_controller_ visibleItem];
   ASSERT_TRUE(visible_item);
   EXPECT_EQ("http://www.example.com/0", visible_item->GetURL().spec());
 }
 
 // Tests that visible URL is not the same as pending URL if it was
 // renderer-initiated.
 TEST_F(CRWSessionControllerTest,
-       VisibleEntryWithSingleRendererInitiatedPendingEntry) {
+       VisibleItemWithSingleRendererInitiatedPendingItem) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
-  web::NavigationItem* visible_item =
-      [[session_controller_ visibleEntry] navigationItem];
+  web::NavigationItem* visible_item = [session_controller_ visibleItem];
   ASSERT_FALSE(visible_item);
 }
 
 // Tests that visible URL is not the same as pending URL if it was
-// renderer-initiated and there is a committed entry.
+// renderer-initiated and there is a committed item.
 TEST_F(CRWSessionControllerTest,
-       VisibleEntryWithCommittedAndRendererInitiatedPendingEntry) {
+       VisibleItemWithCommittedAndRendererInitiatedPendingItem) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/b")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
-  web::NavigationItem* visible_item =
-      [[session_controller_ visibleEntry] navigationItem];
+  web::NavigationItem* visible_item = [session_controller_ visibleItem];
   ASSERT_TRUE(visible_item);
   EXPECT_EQ("http://www.example.com/", visible_item->GetURL().spec());
 }
 
 // Tests that visible URL is not the same as pending URL created via pending
 // navigation index.
-TEST_F(CRWSessionControllerTest, VisibleEntryWithPendingNavigationIndex) {
+TEST_F(CRWSessionControllerTest, VisibleItemWithPendingNavigationIndex) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/b")
           transition:ui::PAGE_TRANSITION_LINK
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
 
   [session_controller_ setPendingItemIndex:0];
 
-  web::NavigationItem* visible_item =
-      [[session_controller_ visibleEntry] navigationItem];
+  web::NavigationItem* visible_item = [session_controller_ visibleItem];
   ASSERT_TRUE(visible_item);
   EXPECT_EQ("http://www.example.com/0", visible_item->GetURL().spec());
 }
 
-// Tests that |-backwardEntries| is empty if all preceding entries are
+// Tests that |-backwardItems| is empty if all preceding entries are
 // redirects.
-TEST_F(CRWSessionControllerTest, BackwardEntriesForAllRedirects) {
+TEST_F(CRWSessionControllerTest, BackwardItemsForAllRedirects) {
   [session_controller_
       addPendingItem:GURL("http://www.example.com")
             referrer:MakeReferrer("http://www.example.com/a")
           transition:ui::PAGE_TRANSITION_CLIENT_REDIRECT
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
   [session_controller_ commitPendingItem];
   [session_controller_
       addPendingItem:GURL("http://www.example.com/0")
             referrer:MakeReferrer("http://www.example.com/b")
           transition:ui::PAGE_TRANSITION_CLIENT_REDIRECT
       initiationType:web::NavigationInitiationType::RENDERER_INITIATED];
   [session_controller_ commitPendingItem];
-  EXPECT_EQ(0U, [session_controller_ backwardEntries].count);
+  EXPECT_EQ(0U, [session_controller_ backwardItems].size());
 }
 
 }  // anonymous namespace