Remove the concept of currentItemIndex

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>
 
@@ skipping 341 matching lines @@
   [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 items should go away.
   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]);
+  ASSERT_EQ(1, [session_controller_ lastCommittedItemIndex]);
+  ASSERT_EQ(0, [session_controller_ previousItemIndex]);
 }
 
 // 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];
@@ skipping 10 matching lines @@
       initiationType:web::NavigationInitiationType::USER_INITIATED];
   [session_controller_ commitPendingItem];
   ASSERT_EQ(3U, [session_controller_ items].size());
 
   // Go to the middle, and commit first pending item index.
   [session_controller_ goToItemAtIndex:1];
   [session_controller_ setPendingItemIndex:0];
   ASSERT_EQ(0, [session_controller_ pendingItemIndex]);
   web::NavigationItem* pending_item = [session_controller_ pendingItem];
   ASSERT_TRUE(pending_item);
-  ASSERT_EQ(1, [session_controller_ currentNavigationIndex]);
-  EXPECT_EQ(2, [session_controller_ previousNavigationIndex]);
+  ASSERT_EQ(1, [session_controller_ lastCommittedItemIndex]);
+  EXPECT_EQ(2, [session_controller_ previousItemIndex]);
   [session_controller_ commitPendingItem];
 
   // Verify that pending item has been committed and current and previous item
   // indices updated.
   EXPECT_EQ(pending_item, [session_controller_ lastCommittedItem]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
   EXPECT_FALSE([session_controller_ pendingItem]);
-  EXPECT_EQ(0, [session_controller_ currentNavigationIndex]);
-  EXPECT_EQ(1, [session_controller_ previousNavigationIndex]);
+  EXPECT_EQ(0, [session_controller_ lastCommittedItemIndex]);
+  EXPECT_EQ(1, [session_controller_ previousItemIndex]);
   EXPECT_EQ(3U, [session_controller_ items].size());
 }
 
 TEST_F(CRWSessionControllerTest,
        DiscardPendingItemWithoutPendingOrCommittedItem) {
   [session_controller_ discardNonCommittedItems];
 
   EXPECT_TRUE([session_controller_ items].empty());
   EXPECT_FALSE([session_controller_ currentItem]);
 }
@@ skipping 84 matching lines @@
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
   // Insert and verify the state of target session controller.
   EXPECT_TRUE([session_controller_ canPruneAllButLastCommittedItem]);
   [session_controller_
       copyStateFromSessionControllerAndPrune:other_session_controller.get()];
 
   EXPECT_EQ(2U, [session_controller_ items].size());
-  EXPECT_EQ(1, [session_controller_ currentNavigationIndex]);
-  EXPECT_EQ(-1, [session_controller_ previousNavigationIndex]);
+  EXPECT_EQ(1, [session_controller_ lastCommittedItemIndex]);
+  EXPECT_EQ(-1, [session_controller_ previousItemIndex]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
 
   EXPECT_EQ(GURL("http://www.url.com/0"),
             [session_controller_ URLForItemAtIndex:0]);
   EXPECT_EQ(GURL("http://www.url.com/2"),
             [session_controller_ URLForItemAtIndex:1]);
   EXPECT_EQ(GURL("http://www.url.com/3"),
             [session_controller_ pendingItem]->GetURL());
 }
 
@@ skipping 15 matching lines @@
 
   // Create empty source session controller.
   base::scoped_nsobject<CRWSessionController> other_session_controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_]);
 
   // Insert and verify the state of target session controller.
   EXPECT_TRUE([session_controller_ canPruneAllButLastCommittedItem]);
   [session_controller_
       copyStateFromSessionControllerAndPrune:other_session_controller.get()];
   EXPECT_EQ(2U, [session_controller_ items].size());
-  EXPECT_EQ(1, [session_controller_ currentNavigationIndex]);
-  EXPECT_EQ(0, [session_controller_ previousNavigationIndex]);
+  EXPECT_EQ(1, [session_controller_ lastCommittedItemIndex]);
+  EXPECT_EQ(0, [session_controller_ previousItemIndex]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
   EXPECT_FALSE([session_controller_ pendingItem]);
   EXPECT_EQ(GURL("http://www.url.com/0"),
             [session_controller_ URLForItemAtIndex:0]);
   EXPECT_EQ(GURL("http://www.url.com/1"),
             [session_controller_ URLForItemAtIndex:1]);
 }
 
 // Tests that |-copyStateFromSessionControllerAndPrune:| is a no-op when the
 // receiver has no last committed item.
@@ skipping 13 matching lines @@
       addPendingItem:GURL("http://www.url.com/1")
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
   // Attempt to copy |other_session_controller|'s state and verify that
   // |session_controller_| is unchanged.
   [session_controller_
       copyStateFromSessionControllerAndPrune:other_session_controller];
   EXPECT_TRUE([session_controller_ items].empty());
-  EXPECT_EQ(-1, [session_controller_ currentNavigationIndex]);
-  EXPECT_EQ(-1, [session_controller_ previousNavigationIndex]);
+  EXPECT_EQ(-1, [session_controller_ lastCommittedItemIndex]);
+  EXPECT_EQ(-1, [session_controller_ previousItemIndex]);
   EXPECT_FALSE([session_controller_ currentItem]);
   EXPECT_FALSE([session_controller_ pendingItem]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
 }
 
 // Tests that |-copyStateFromSessionControllerAndPrune:| is a no-op during a
 // pending history navigation.
 TEST_F(CRWSessionControllerTest, CopyStateDuringPendingHistoryNavigation) {
   // Add 1 committed and 1 pending item to target controller.
   [session_controller_
@@ skipping 26 matching lines @@
 
   // Set the pending item index to the first item.
   [session_controller_ setPendingItemIndex:0];
   EXPECT_FALSE([session_controller_ canPruneAllButLastCommittedItem]);
 
   // Attempt to copy |other_session_controller|'s state and verify that
   // |session_controller_| is unchanged.
   [session_controller_
       copyStateFromSessionControllerAndPrune:other_session_controller];
   EXPECT_EQ(2U, [session_controller_ items].size());
-  EXPECT_EQ(1, [session_controller_ currentNavigationIndex]);
-  EXPECT_EQ(0, [session_controller_ previousNavigationIndex]);
+  EXPECT_EQ(1, [session_controller_ lastCommittedItemIndex]);
+  EXPECT_EQ(0, [session_controller_ previousItemIndex]);
   EXPECT_EQ(0, [session_controller_ pendingItemIndex]);
   EXPECT_TRUE([session_controller_ pendingItem]);
   EXPECT_EQ([session_controller_ previousItem],
             [session_controller_ pendingItem]);
 }
 
 // Tests that |-copyStateFromSessionControllerAndPrune:| is a when a transient
 // NavigationItem exists.
 TEST_F(CRWSessionControllerTest, CopyStateWithTransientItem) {
   // Add 1 committed and 1 pending item to target controller.
@@ skipping 25 matching lines @@
             referrer:web::Referrer()
           transition:ui::PAGE_TRANSITION_TYPED
       initiationType:web::NavigationInitiationType::USER_INITIATED];
 
   // Attempt to copy |other_session_controller|'s state and verify that
   // |session_controller_| is unchanged.
   EXPECT_FALSE([session_controller_ canPruneAllButLastCommittedItem]);
   [session_controller_
       copyStateFromSessionControllerAndPrune:other_session_controller];
   EXPECT_EQ(1U, [session_controller_ items].size());
-  EXPECT_EQ(0, [session_controller_ currentNavigationIndex]);
-  EXPECT_EQ(-1, [session_controller_ previousNavigationIndex]);
+  EXPECT_EQ(0, [session_controller_ lastCommittedItemIndex]);
+  EXPECT_EQ(-1, [session_controller_ previousItemIndex]);
   EXPECT_EQ(-1, [session_controller_ pendingItemIndex]);
   EXPECT_TRUE([session_controller_ pendingItem]);
   EXPECT_TRUE([session_controller_ transientItem]);
   EXPECT_EQ([session_controller_ transientItem],
             [session_controller_ currentItem]);
 }
 
 // Tests state of an empty session controller.
 TEST_F(CRWSessionControllerTest, EmptyController) {
   EXPECT_TRUE([session_controller_ items].empty());
-  EXPECT_EQ(-1, [session_controller_ currentNavigationIndex]);
-  EXPECT_EQ(-1, [session_controller_ previousNavigationIndex]);
+  EXPECT_EQ(-1, [session_controller_ lastCommittedItemIndex]);
+  EXPECT_EQ(-1, [session_controller_ previousItemIndex]);
   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::NavigationItem> CreateNavigationItem(
     const std::string& url,
     const std::string& referrer,
     NSString* title) {
@@ skipping 11 matching lines @@
   std::unique_ptr<web::NavigationItem> item(
       static_cast<web::NavigationItem*>(navigation_item.release()));
   return 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]);
+                                  lastCommittedItemIndex:0]);
   EXPECT_TRUE(controller.get().items.empty());
-  EXPECT_EQ(controller.get().currentNavigationIndex, -1);
-  EXPECT_EQ(controller.get().previousNavigationIndex, -1);
+  EXPECT_EQ(controller.get().lastCommittedItemIndex, -1);
+  EXPECT_EQ(controller.get().previousItemIndex, -1);
   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]);
+                                  lastCommittedItemIndex:1]);
 
   EXPECT_EQ(controller.get().items.size(), 3U);
-  EXPECT_EQ(controller.get().currentNavigationIndex, 1);
-  EXPECT_EQ(controller.get().previousNavigationIndex, -1);
+  EXPECT_EQ(controller.get().lastCommittedItemIndex, 1);
+  EXPECT_EQ(controller.get().previousItemIndex, -1);
   // Sanity check the current item, the NavigationItem unit test will ensure
   // the entire object is created properly.
   EXPECT_EQ([controller currentItem]->GetURL(), GURL("http://www.yahoo.com"));
 }
 
 // Tests index of previous navigation item.
 TEST_F(CRWSessionControllerTest, PreviousNavigationItem) {
-  EXPECT_EQ(session_controller_.get().previousNavigationIndex, -1);
+  EXPECT_EQ(session_controller_.get().previousItemIndex, -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);
+  EXPECT_EQ(session_controller_.get().previousItemIndex, -1);
   [session_controller_
       addPendingItem:GURL("http://www.url1.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, 0);
+  EXPECT_EQ(session_controller_.get().previousItemIndex, 0);
   [session_controller_
       addPendingItem:GURL("http://www.url2.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);
+  EXPECT_EQ(session_controller_.get().previousItemIndex, 1);
 
   [session_controller_ goToItemAtIndex:1];
-  EXPECT_EQ(session_controller_.get().previousNavigationIndex, 2);
+  EXPECT_EQ(session_controller_.get().previousItemIndex, 2);
 
   [session_controller_ goToItemAtIndex:0];
-  EXPECT_EQ(session_controller_.get().previousNavigationIndex, 1);
+  EXPECT_EQ(session_controller_.get().previousItemIndex, 1);
 
   [session_controller_ goToItemAtIndex:1];
-  EXPECT_EQ(session_controller_.get().previousNavigationIndex, 0);
+  EXPECT_EQ(session_controller_.get().previousItemIndex, 0);
 
   [session_controller_ goToItemAtIndex:2];
-  EXPECT_EQ(session_controller_.get().previousNavigationIndex, 1);
+  EXPECT_EQ(session_controller_.get().previousItemIndex, 1);
 }
 
 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]);
+                                  lastCommittedItemIndex:0]);
 
   GURL pushPageGurl1("http://www.firstpage.com/#push1");
   NSString* stateObject1 = @"{'foo': 1}";
   [controller pushNewItemWithURL:pushPageGurl1
                      stateObject:stateObject1
                       transition:ui::PAGE_TRANSITION_LINK];
   web::NavigationItemImpl* pushedItem = [controller currentItem];
   NSUInteger expectedCount = 2;
   EXPECT_EQ(expectedCount, controller.get().items.size());
   EXPECT_EQ(pushPageGurl1, pushedItem->GetURL());
@@ skipping 28 matching lines @@
       CreateNavigationItem("http://foo.com", "http://google.com", @"Fourth"));
   // Push state navigation.
   items.push_back(
       CreateNavigationItem("http://foo.com/bar", "http://foo.com", @"Fifth"));
   // Push state navigation.
   items.push_back(CreateNavigationItem("http://foo.com/bar#bar",
                                        "http://foo.com/bar", @"Sixth"));
   base::scoped_nsobject<CRWSessionController> controller(
       [[CRWSessionController alloc] initWithBrowserState:&browser_state_
                                          navigationItems:std::move(items)
-                                            currentIndex:0]);
+                                  lastCommittedItemIndex:0]);
   web::NavigationItemImpl* item0 = [controller items][0].get();
   web::NavigationItemImpl* item1 = [controller items][1].get();
   web::NavigationItemImpl* item2 = [controller items][2].get();
   web::NavigationItemImpl* item3 = [controller items][3].get();
   web::NavigationItemImpl* item4 = [controller items][4].get();
   web::NavigationItemImpl* item5 = [controller items][5].get();
   item1->SetIsCreatedFromPushState(true);
   item4->SetIsCreatedFromHashChange(true);
   item5->SetIsCreatedFromPushState(true);
 
@@ skipping 17 matching lines @@
   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]);
+                                  lastCommittedItemIndex:0]);
 
   GURL replacePageGurl1("http://www.firstpage.com/#replace1");
   NSString* stateObject1 = @"{'foo': 1}";
 
   // Replace current item and check the size of history and fields of the
   // modified item.
   [controller updateCurrentItemWithURL:replacePageGurl1
                            stateObject:stateObject1];
   web::NavigationItemImpl* replacedItem = [controller currentItem];
   NSUInteger expectedCount = 3;
@@ skipping 33 matching lines @@
           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);
+  EXPECT_EQ(3, session_controller_.get().lastCommittedItemIndex);
   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_ backwardItems].size());
   EXPECT_EQ(1U, [session_controller_ forwardItems].size());
 
   [session_controller_ goToItemAtIndex:0];
@@ skipping 28 matching lines @@
             referrer:MakeReferrer("http://www.example.com/c")
           transition:ui::PAGE_TRANSITION_LINK
       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_EQ(3, session_controller_.get().lastCommittedItemIndex);
+  EXPECT_EQ(2, session_controller_.get().previousItemIndex);
   EXPECT_TRUE([session_controller_ pendingItem]);
   EXPECT_TRUE([session_controller_ transientItem]);
 
   // Going back should discard transient and pending items.
   [session_controller_ goToItemAtIndex:1];
-  EXPECT_EQ(1, session_controller_.get().currentNavigationIndex);
-  EXPECT_EQ(3, session_controller_.get().previousNavigationIndex);
+  EXPECT_EQ(1, session_controller_.get().lastCommittedItemIndex);
+  EXPECT_EQ(3, session_controller_.get().previousItemIndex);
   EXPECT_FALSE(session_controller_.get().pendingItem);
   EXPECT_FALSE(session_controller_.get().transientItem);
 
   // Going forward should discard transient item.
   [session_controller_ addTransientItemWithURL:GURL("http://www.example.com")];
   EXPECT_TRUE(session_controller_.get().transientItem);
   [session_controller_ goToItemAtIndex:2];
-  EXPECT_EQ(2, session_controller_.get().currentNavigationIndex);
-  EXPECT_EQ(1, session_controller_.get().previousNavigationIndex);
+  EXPECT_EQ(2, session_controller_.get().lastCommittedItemIndex);
+  EXPECT_EQ(1, session_controller_.get().previousItemIndex);
   EXPECT_FALSE(session_controller_.get().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);
+  EXPECT_EQ(2, session_controller_.get().lastCommittedItemIndex);
+  EXPECT_EQ(1, session_controller_.get().previousItemIndex);
   [session_controller_ goToItemAtIndex:NSIntegerMax];
-  EXPECT_EQ(2, session_controller_.get().currentNavigationIndex);
-  EXPECT_EQ(1, session_controller_.get().previousNavigationIndex);
+  EXPECT_EQ(2, session_controller_.get().lastCommittedItemIndex);
+  EXPECT_EQ(1, session_controller_.get().previousItemIndex);
 
   // 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);
+  EXPECT_EQ(2, session_controller_.get().lastCommittedItemIndex);
+  EXPECT_EQ(1, session_controller_.get().previousItemIndex);
 }
 
 // Tests that visible URL is the same as transient URL if there are no committed
 // items.
 TEST_F(CRWSessionControllerTest, VisibleItemWithSingleTransientItem) {
   [session_controller_ addTransientItemWithURL:GURL("http://www.example.com")];
   web::NavigationItem* visible_item = [session_controller_ visibleItem];
   ASSERT_TRUE(visible_item);
   EXPECT_EQ("http://www.example.com/", visible_item->GetURL().spec());
 }
@@ skipping 114 matching lines @@
   [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_ backwardItems].size());
 }
 
 }  // anonymous namespace