Remove the concept of currentItemIndex

ios/web/navigation/crw_session_controller.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"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 19 matching lines @@
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 @interface CRWSessionController () {
   // Weak pointer back to the owning NavigationManager. This is to facilitate
   // the incremental merging of the two classes.
   web::NavigationManagerImpl* _navigationManager;
 
-  // Identifies the index of the current navigation in the NavigationItem
-  // array.
-  NSInteger _currentNavigationIndex;
-  // Identifies the index of the previous navigation in the NavigationItem
-  // array.
-  NSInteger _previousNavigationIndex;
+  // Identifies the index of the last committed item in the items array.
+  NSInteger _lastCommittedItemIndex;
+  // Identifies the index of the previous item in the items array.
+  NSInteger _previousItemIndex;
 
-   // Stores the certificate policies decided by the user.
+  // Stores the certificate policies decided by the user.
   CRWSessionCertificatePolicyManager* _sessionCertificatePolicyManager;
 
   // The browser state associated with this CRWSessionController;
   web::BrowserState* _browserState;  // weak
 
   // Time smoother for navigation item timestamps; see comment in
   // navigation_controller_impl.h
   web::TimeSmoother _timeSmoother;
 
   // Backing objects for properties of the same name.
   web::ScopedNavigationItemImplList _items;
   // |_pendingItem| only contains a NavigationItem for non-history navigations.
   // For back/forward navigations within session history, _pendingItemIndex will
   // be an index within |_items|, and self.pendingItem will return the item at
   // that index.
   std::unique_ptr<web::NavigationItemImpl> _pendingItem;
   std::unique_ptr<web::NavigationItemImpl> _transientItem;
 }
 
 // Redefine as readwrite.
-@property(nonatomic, readwrite, assign) NSInteger currentNavigationIndex;
+@property(nonatomic, readwrite, assign) NSInteger lastCommittedItemIndex;
 
 // TODO(rohitrao): These properties must be redefined readwrite to work around a
 // clang bug. crbug.com/228650
 @property(nonatomic, readwrite, strong)
     CRWSessionCertificatePolicyManager* sessionCertificatePolicyManager;
 
 // Expose setters for serialization properties.  These are exposed in a category
 // in SessionStorageBuilder, and will be removed as ownership of
 // their backing ivars moves to NavigationManagerImpl.
-@property(nonatomic, readwrite, assign) NSInteger previousNavigationIndex;
+@property(nonatomic, readwrite, assign) NSInteger previousItemIndex;
 
-// Removes all items after currentNavigationIndex_.
+// Removes all items after lastCommittedItemIndex.
 - (void)clearForwardItems;
 // Discards the transient item, if any.
 - (void)discardTransientItem;
 // Creates a NavigationItemImpl with the specified properties.
 - (std::unique_ptr<web::NavigationItemImpl>)
    itemWithURL:(const GURL&)url
       referrer:(const web::Referrer&)referrer
     transition:(ui::PageTransition)transition
 initiationType:(web::NavigationInitiationType)initiationType;
 // Returns YES if the PageTransition for the underlying navigationItem at
 // |index| in |items| has ui::PAGE_TRANSITION_IS_REDIRECT_MASK.
 - (BOOL)isRedirectTransitionForItemAtIndex:(size_t)index;
 
 @end
 
 @implementation CRWSessionController
 
-@synthesize currentNavigationIndex = _currentNavigationIndex;
-@synthesize previousNavigationIndex = _previousNavigationIndex;
+@synthesize lastCommittedItemIndex = _lastCommittedItemIndex;
+@synthesize previousItemIndex = _previousItemIndex;
 @synthesize pendingItemIndex = _pendingItemIndex;
 @synthesize sessionCertificatePolicyManager = _sessionCertificatePolicyManager;
 
 - (instancetype)initWithBrowserState:(web::BrowserState*)browserState {
   self = [super init];
   if (self) {
     _browserState = browserState;
-    _currentNavigationIndex = -1;
-    _previousNavigationIndex = -1;
+    _lastCommittedItemIndex = -1;
+    _previousItemIndex = -1;
     _pendingItemIndex = -1;
     _sessionCertificatePolicyManager =
         [[CRWSessionCertificatePolicyManager alloc] init];
   }
   return self;
 }
 
 - (instancetype)initWithBrowserState:(web::BrowserState*)browserState
                      navigationItems:(web::ScopedNavigationItemList)items
-                        currentIndex:(NSUInteger)currentIndex {
+              lastCommittedItemIndex:(NSUInteger)lastCommittedItemIndex {
   self = [super init];
   if (self) {
     _browserState = browserState;
     _items = web::CreateScopedNavigationItemImplList(std::move(items));
-    _currentNavigationIndex =
-        std::min(static_cast<NSInteger>(currentIndex),
+    _lastCommittedItemIndex =
+        std::min(static_cast<NSInteger>(lastCommittedItemIndex),
                  static_cast<NSInteger>(_items.size()) - 1);
-    _previousNavigationIndex = -1;
+    _previousItemIndex = -1;
     _pendingItemIndex = -1;
     _sessionCertificatePolicyManager =
         [[CRWSessionCertificatePolicyManager alloc] init];
   }
   return self;
 }
 
 #pragma mark - Accessors
 
-- (void)setCurrentNavigationIndex:(NSInteger)currentNavigationIndex {
-  if (_currentNavigationIndex != currentNavigationIndex) {
-    _currentNavigationIndex = currentNavigationIndex;
+- (void)setLastCommittedItemIndex:(NSInteger)lastCommittedItemIndex {
+  if (_lastCommittedItemIndex != lastCommittedItemIndex) {
+    _lastCommittedItemIndex = lastCommittedItemIndex;
     if (_navigationManager)
       _navigationManager->RemoveTransientURLRewriters();
   }
 }
 
 - (void)setPendingItemIndex:(NSInteger)pendingItemIndex {
   DCHECK_GE(pendingItemIndex, -1);
   DCHECK_LT(pendingItemIndex, static_cast<NSInteger>(self.items.size()));
   _pendingItemIndex = pendingItemIndex;
   DCHECK(_pendingItemIndex == -1 || self.pendingItem);
 }
 
 - (BOOL)canPruneAllButLastCommittedItem {
-  return self.currentNavigationIndex != -1 && self.pendingItemIndex == -1 &&
+  return self.lastCommittedItemIndex != -1 && self.pendingItemIndex == -1 &&
          !self.transientItem;
 }
 
 - (const web::ScopedNavigationItemImplList&)items {
   return _items;
 }
 
 - (web::NavigationItemImpl*)currentItem {
   if (self.transientItem)
     return self.transientItem;
@@ skipping 23 matching lines @@
   if (self.pendingItemIndex == -1)
     return _pendingItem.get();
   return self.items[self.pendingItemIndex].get();
 }
 
 - (web::NavigationItemImpl*)transientItem {
   return _transientItem.get();
 }
 
 - (web::NavigationItemImpl*)lastCommittedItem {
-  NSInteger index = self.currentNavigationIndex;
+  NSInteger index = self.lastCommittedItemIndex;
   return index == -1 ? nullptr : self.items[index].get();
 }
 
 - (web::NavigationItemImpl*)previousItem {
-  NSInteger index = self.previousNavigationIndex;
+  NSInteger index = self.previousItemIndex;
   return index == -1 || self.items.empty() ? nullptr : self.items[index].get();
 }
 
 - (web::NavigationItemList)backwardItems {
   web::NavigationItemList items;
-  for (size_t index = _currentNavigationIndex; index > 0; --index) {
+  for (size_t index = _lastCommittedItemIndex; index > 0; --index) {
     if (![self isRedirectTransitionForItemAtIndex:index])
       items.push_back(self.items[index - 1].get());
   }
   return items;
 }
 
 - (web::NavigationItemList)forwardItems {
   web::NavigationItemList items;
-  NSUInteger lastNonRedirectedIndex = _currentNavigationIndex + 1;
+  NSUInteger lastNonRedirectedIndex = _lastCommittedItemIndex + 1;
   while (lastNonRedirectedIndex < self.items.size()) {
     web::NavigationItem* item = self.items[lastNonRedirectedIndex].get();
     if (!ui::PageTransitionIsRedirect(item->GetTransitionType()))
       items.push_back(item);
     ++lastNonRedirectedIndex;
   }
   return items;
 }
 
 #pragma mark - NSObject
@@ skipping 17 matching lines @@
 #else
   if (self.pendingItem) {
     pendingItemDescription =
         [NSString stringWithFormat:@"%p", self.pendingItem];
   }
   if (self.transientItem) {
     transientItemDescription =
         [NSString stringWithFormat:@"%p", self.transientItem];
   }
 #endif
-  return [NSString stringWithFormat:@"current index: %" PRIdNS
-                                    @"\nprevious index: %" PRIdNS
-                                    @"\npending"
-                                    @" index: %" PRIdNS
-                                    @"\n%@\npending: %@\ntransient: %@\n",
-                                    _currentNavigationIndex,
-                                    _previousNavigationIndex, _pendingItemIndex,
-                                    itemsDescription, pendingItemDescription,
+  return [NSString stringWithFormat:@"last committed item index: %" PRIdNS
+                                    @"\nprevious item index: %" PRIdNS
+                                    @"\npending item index: %" PRIdNS
+                                    @"\nall items: %@ \npending item: %@"
+                                    @"\ntransient item: %@\n",
+                                    _lastCommittedItemIndex, _previousItemIndex,
+                                    _pendingItemIndex, itemsDescription,
+                                    pendingItemDescription,
                                     transientItemDescription];
 }
 
 #pragma mark - Public
 
 - (void)setNavigationManager:(web::NavigationManagerImpl*)navigationManager {
   _navigationManager = navigationManager;
   if (_navigationManager) {
     // _browserState will be nullptr if CRWSessionController has been
     // initialized with -initWithCoder: method. Take _browserState from
@@ skipping 82 matching lines @@
   // This should probably not be sent if the URLs matched, but that's what was
   // done before, so preserve behavior in case something relies on it.
   if (_navigationManager && _navigationManager->GetFacadeDelegate())
     _navigationManager->GetFacadeDelegate()->OnNavigationItemPending();
 }
 
 - (void)clearForwardItems {
   DCHECK_EQ(self.pendingItemIndex, -1);
   [self discardTransientItem];
 
-  NSInteger forwardItemStartIndex = _currentNavigationIndex + 1;
+  NSInteger forwardItemStartIndex = _lastCommittedItemIndex + 1;
   DCHECK(forwardItemStartIndex >= 0);
 
   size_t itemCount = self.items.size();
   if (forwardItemStartIndex >= static_cast<NSInteger>(itemCount))
     return;
 
-  if (_previousNavigationIndex >= forwardItemStartIndex)
-    _previousNavigationIndex = -1;
+  if (_previousItemIndex >= forwardItemStartIndex)
+    _previousItemIndex = -1;
 
   // Remove the NavigationItems and notify the NavigationManater
   _items.erase(_items.begin() + forwardItemStartIndex, _items.end());
   if (_navigationManager) {
     _navigationManager->OnNavigationItemsPruned(itemCount -
                                                 forwardItemStartIndex);
   }
 }
 
 - (void)commitPendingItem {
   if (self.pendingItem) {
     // Once an item is committed it's not renderer-initiated any more. (Matches
     // the implementation in NavigationController.)
     self.pendingItem->ResetForCommit();
 
-    NSInteger newNavigationIndex = self.pendingItemIndex;
-    if (newNavigationIndex == -1) {
+    NSInteger newItemIndex = self.pendingItemIndex;
+    if (newItemIndex == -1) {
       [self clearForwardItems];
       // Add the new item at the end.
       _items.push_back(std::move(_pendingItem));
-      newNavigationIndex = self.items.size() - 1;
+      newItemIndex = self.items.size() - 1;
     }
-    _previousNavigationIndex = _currentNavigationIndex;
-    self.currentNavigationIndex = newNavigationIndex;
+    _previousItemIndex = _lastCommittedItemIndex;
+    self.lastCommittedItemIndex = newItemIndex;
     self.pendingItemIndex = -1;
     DCHECK(!_pendingItem);
   }
 
   web::NavigationItem* item = self.currentItem;
   // Update the navigation timestamp now that it's actually happened.
   if (item)
     item->SetTimestamp(_timeSmoother.GetSmoothedTime(base::Time::Now()));
 
   if (_navigationManager && item)
@@ skipping 30 matching lines @@
           initiationType:web::NavigationInitiationType::USER_INITIATED];
   pushedItem->SetUserAgentType(lastCommittedItem->GetUserAgentType());
   pushedItem->SetSerializedStateObject(stateObject);
   pushedItem->SetIsCreatedFromPushState(true);
   pushedItem->GetSSL() = lastCommittedItem->GetSSL();
   pushedItem->SetTimestamp(_timeSmoother.GetSmoothedTime(base::Time::Now()));
 
   [self clearForwardItems];
   // Add the new item at the end.
   _items.push_back(std::move(pushedItem));
-  _previousNavigationIndex = _currentNavigationIndex;
-  self.currentNavigationIndex = self.items.size() - 1;
+  _previousItemIndex = _lastCommittedItemIndex;
+  self.lastCommittedItemIndex = self.items.size() - 1;
 
   if (_navigationManager)
     _navigationManager->OnNavigationItemCommitted();
 }
 
 - (void)updateCurrentItemWithURL:(const GURL&)url
                      stateObject:(NSString*)stateObject {
   DCHECK(!self.transientItem);
   web::NavigationItemImpl* currentItem = self.currentItem;
   currentItem->SetURL(url);
@@ skipping 23 matching lines @@
   // The other session may not have any items, in which case there is nothing
   // to insert.
   const web::ScopedNavigationItemImplList& sourceItems = source->_items;
   if (sourceItems.empty())
     return;
 
   // Early return if there's no committed source item.
   if (!source.lastCommittedItem)
     return;
 
-  // Copy |sourceItems| into a new NavigationItemList.  |mergedItems| is needs
-  // to be large enough for all items in |source| preceding
-  // |sourceCurrentIndex|, the |source|'s current item, and |self|'s current
-  // item, which comes out to |sourceCurrentIndex| + 2.
-  DCHECK_GT(source.currentNavigationIndex, -1);
-  size_t sourceCurrentIndex =
-      static_cast<size_t>(source.currentNavigationIndex);
-  web::ScopedNavigationItemImplList mergedItems(sourceCurrentIndex + 2);
-  for (size_t index = 0; index <= sourceCurrentIndex; ++index) {
+  // Copy |sourceItems| into a new NavigationItemList.  |mergedItems| needs to
+  // be large enough for all items in |source| preceding
+  // |sourceLastCommittedItemIndex|, the |source|'s current item, and |self|'s
+  // current item, which comes out to |sourceCurrentIndex| + 2.
+  DCHECK_GT(source.lastCommittedItemIndex, -1);
+  size_t sourceLastCommittedItemIndex =
+      static_cast<size_t>(source.lastCommittedItemIndex);
+  web::ScopedNavigationItemImplList mergedItems(sourceLastCommittedItemIndex +
+                                                2);
+  for (size_t index = 0; index <= sourceLastCommittedItemIndex; ++index) {
     mergedItems[index] =
         base::MakeUnique<web::NavigationItemImpl>(*sourceItems[index]);
   }
-  mergedItems.back() = std::move(_items[self.currentNavigationIndex]);
+  mergedItems.back() = std::move(_items[self.lastCommittedItemIndex]);
 
   // Use |mergedItems| as the session history.
   std::swap(mergedItems, _items);
 
   // Update state to reflect inserted NavigationItems.
-  _previousNavigationIndex = -1;
-  _currentNavigationIndex = self.items.size() - 1;
+  _previousItemIndex = -1;
+  _lastCommittedItemIndex = self.items.size() - 1;
 
-  DCHECK_LT(static_cast<NSUInteger>(_currentNavigationIndex),
+  DCHECK_LT(static_cast<NSUInteger>(_lastCommittedItemIndex),
             self.items.size());
 }
 
 - (void)goToItemAtIndex:(NSInteger)index {
   if (index < 0 || static_cast<NSUInteger>(index) >= self.items.size())
     return;
 
-  if (index < _currentNavigationIndex) {
+  if (index < _lastCommittedItemIndex) {
     // Going back.
     [self discardNonCommittedItems];
-  } else if (_currentNavigationIndex < index) {
+  } else if (_lastCommittedItemIndex < index) {
     // Going forward.
     [self discardTransientItem];
   } else {
-    // |delta| is 0, no need to change current navigation index.
+    // |delta| is 0, no need to change the last committed item index.
     return;
   }
 
-  _previousNavigationIndex = _currentNavigationIndex;
-  _currentNavigationIndex = index;
+  _previousItemIndex = _lastCommittedItemIndex;
+  _lastCommittedItemIndex = index;
 }
 
 - (void)removeItemAtIndex:(NSInteger)index {
   DCHECK(index < static_cast<NSInteger>(self.items.size()));
-  DCHECK(index != _currentNavigationIndex);
+  DCHECK(index != _lastCommittedItemIndex);
   DCHECK(index >= 0);
 
   [self discardNonCommittedItems];
 
   _items.erase(_items.begin() + index);
-  if (_currentNavigationIndex > index)
-    _currentNavigationIndex--;
-  if (_previousNavigationIndex >= index)
-    _previousNavigationIndex--;
+  if (_lastCommittedItemIndex > index)
+    _lastCommittedItemIndex--;
+  if (_previousItemIndex >= index)
+    _previousItemIndex--;
 }
 
 - (BOOL)isSameDocumentNavigationBetweenItem:(web::NavigationItem*)firstItem
                                     andItem:(web::NavigationItem*)secondItem {
   if (!firstItem || !secondItem || firstItem == secondItem)
     return NO;
   NSUInteger firstIndex = [self indexOfItem:firstItem];
   NSUInteger secondIndex = [self indexOfItem:secondItem];
   if (firstIndex == NSNotFound || secondIndex == NSNotFound)
     return NO;
@@ skipping 64 matching lines @@
   return item;
 }
 
 - (BOOL)isRedirectTransitionForItemAtIndex:(size_t)index {
   DCHECK_LT(index, self.items.size());
   ui::PageTransition transition = self.items[index]->GetTransitionType();
   return (transition & ui::PAGE_TRANSITION_IS_REDIRECT_MASK) ? YES : NO;
 }
 
 @end