Converted CRWSessionController to use NavigationItems.

ios/web/web_state/ui/crw_web_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/web_state/ui/crw_web_controller.h"
 
 #import <WebKit/WebKit.h>
 
 #import <objc/runtime.h>
 #include <stddef.h>
@@ skipping 1375 matching lines @@
   [self executeJavaScript:@"__gCrWeb.getPageReferrerPolicy()"
         completionHandler:^(id referrer, NSError* error) {
           DCHECK_NE(error.code, WKErrorJavaScriptExceptionOccurred);
           responseHandler(base::mac::ObjCCast<NSString>(referrer));
         }];
 }
 
 - (void)pushStateWithPageURL:(const GURL&)pageURL
                  stateObject:(NSString*)stateObject
                   transition:(ui::PageTransition)transition {
-  [[self sessionController] pushNewEntryWithURL:pageURL
-                                    stateObject:stateObject
-                                     transition:transition];
+  [[self sessionController] pushNewItemWithURL:pageURL
+                                   stateObject:stateObject
+                                    transition:transition];
   [self didUpdateHistoryStateWithPageURL:pageURL];
   self.userInteractionRegistered = NO;
 }
 
 - (void)replaceStateWithPageURL:(const GURL&)pageUrl
                     stateObject:(NSString*)stateObject {
-  [[self sessionController] updateCurrentEntryWithURL:pageUrl
-                                          stateObject:stateObject];
+  [[self sessionController] updateCurrentItemWithURL:pageUrl
+                                         stateObject:stateObject];
   [self didUpdateHistoryStateWithPageURL:pageUrl];
 }
 
 - (void)setDocumentURL:(const GURL&)newURL {
   if (newURL != _documentURL && newURL.is_valid()) {
     _documentURL = newURL;
     _interactionRegisteredSinceLastURLChange = NO;
   }
 }
 
@@ skipping 170 matching lines @@
   if (!(transition & ui::PAGE_TRANSITION_IS_REDIRECT_MASK)) {
     // Record state of outgoing page.
     [self recordStateInHistory];
   }
 
   [_delegate webWillAddPendingURL:requestURL transition:transition];
   // Add or update pending url.
   if (_webStateImpl->GetNavigationManagerImpl().GetPendingItem()) {
     // Update the existing pending entry.
     // Typically on PAGE_TRANSITION_CLIENT_REDIRECT.
-    [[self sessionController] updatePendingEntry:requestURL];
+    [[self sessionController] updatePendingItem:requestURL];
   } else {
     // A new session history entry needs to be created.
-    [[self sessionController] addPendingEntry:requestURL
-                                     referrer:referrer
-                                   transition:transition
-                            rendererInitiated:YES];
+    [[self sessionController] addPendingItem:requestURL
+                                    referrer:referrer
+                                  transition:transition
+                           rendererInitiated:YES];
   }
   _webStateImpl->SetIsLoading(true);
   _webStateImpl->OnProvisionalNavigationStarted(requestURL);
 }
 
 - (void)updateHTML5HistoryState {
   web::NavigationItemImpl* currentItem =
       static_cast<web::NavigationItemImpl*>([self currentNavItem]);
   if (!currentItem)
     return;
 
   // Same-document navigations must trigger a popState event.
   CRWSessionController* sessionController = self.sessionController;
   BOOL sameDocumentNavigation = [sessionController
-      isSameDocumentNavigationBetweenEntry:sessionController.currentEntry
-                                  andEntry:sessionController.previousEntry];
+      isSameDocumentNavigationBetweenItem:sessionController.currentItem
+                                  andItem:sessionController.previousItem];
   // WKWebView doesn't send hashchange events for same-document non-BFLI
   // navigations, so one must be dispatched manually for hash change same-
   // document navigations.
   web::NavigationItem* previousItem =
       self.sessionController.previousEntry.navigationItem;
   const GURL URL = currentItem->GetURL();
   const GURL oldURL = previousItem ? previousItem->GetURL() : GURL();
   BOOL shouldDispatchHashchange = sameDocumentNavigation && previousItem &&
                                   (web::GURLByRemovingRefFromGURL(URL) ==
                                    web::GURLByRemovingRefFromGURL(oldURL));
@@ skipping 273 matching lines @@
 - (void)loadWithParams:(const NavigationManager::WebLoadParams&)originalParams {
   // Make a copy of |params|, as some of the delegate methods may modify it.
   NavigationManager::WebLoadParams params(originalParams);
 
   // Initiating a navigation from the UI, record the current page state before
   // the new page loads. Don't record for back/forward, as the current entry
   // has already been moved to the next entry in the history. Do, however,
   // record it for general reload.
   // TODO(jimblackler): consider a single unified call to record state whenever
   // the page is about to be changed. This cannot currently be done after
-  // addPendingEntry is called.
+  // addPendingItem is called.
 
   [_delegate webWillInitiateLoadWithParams:params];
 
   GURL navUrl = params.url;
   ui::PageTransition transition = params.transition_type;
 
   BOOL initialNavigation = NO;
   BOOL forwardBack =
       PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_RELOAD) &&
       (transition & ui::PAGE_TRANSITION_FORWARD_BACK);
   if (forwardBack) {
     // Setting these for back/forward is not supported.
     DCHECK(!params.extra_headers);
     DCHECK(!params.post_data);
   } else {
     // Clear transient view before making any changes to history and navigation
     // manager. TODO(stuartmorgan): Drive Transient Item clearing from
     // navigation system, rather than from WebController.
     [self clearTransientContentView];
 
     // TODO(stuartmorgan): Why doesn't recordStateInHistory get called for
     // forward/back transitions?
     [self recordStateInHistory];
 
     CRWSessionController* history =
         _webStateImpl->GetNavigationManagerImpl().GetSessionController();
     if (!self.currentSessionEntry)
       initialNavigation = YES;
-    [history addPendingEntry:navUrl
-                    referrer:params.referrer
-                  transition:transition
-           rendererInitiated:params.is_renderer_initiated];
+    [history addPendingItem:navUrl
+                   referrer:params.referrer
+                 transition:transition
+          rendererInitiated:params.is_renderer_initiated];
     web::NavigationItemImpl* addedItem =
         [self currentSessionEntry].navigationItemImpl;
     DCHECK(addedItem);
     if (params.extra_headers)
       addedItem->AddHttpRequestHeaders(params.extra_headers);
     if (params.post_data) {
       DCHECK([addedItem->GetHttpRequestHeaders() objectForKey:@"Content-Type"])
           << "Post data should have an associated content type";
       addedItem->SetPostData(params.post_data);
       addedItem->SetShouldSkipRepostFormConfirmation(true);
@@ skipping 28 matching lines @@
   const GURL currentURL = item ? item->GetURL() : GURL::EmptyGURL();
   // If it's a chrome URL, but not a native one, create the WebUI instance.
   if (web::GetWebClient()->IsAppSpecificURL(currentURL) &&
       ![_nativeProvider hasControllerForURL:currentURL]) {
     if (!(item->GetTransitionType() & ui::PAGE_TRANSITION_TYPED ||
           item->GetTransitionType() & ui::PAGE_TRANSITION_AUTO_BOOKMARK) &&
         self.sessionController.openedByDOM) {
       // WebUI URLs can not be opened by DOM to prevent cross-site scripting as
       // they have increased power. WebUI URLs may only be opened when the user
       // types in the URL or use bookmarks.
-      [[self sessionController] discardNonCommittedEntries];
+      [[self sessionController] discardNonCommittedItems];
       return;
     } else {
       [self createWebUIForURL:currentURL];
     }
   }
 
   // Loading a new url, must check here if it's a native chrome URL and
   // replace the appropriate view if so, or transition back to a web view from
   // a native view.
   if ([self shouldLoadURLInNativeView:currentURL]) {
@@ skipping 158 matching lines @@
 - (void)goToItemAtIndex:(int)index {
   CRWSessionController* sessionController = self.sessionController;
   NSArray* entries = sessionController.entries;
   if (index < 0 || index >= static_cast<int>(entries.count)) {
     NOTREACHED();
     return;
   }
 
   if (!_webStateImpl->IsShowingWebInterstitial())
     [self recordStateInHistory];
-  CRWSessionEntry* fromEntry = self.sessionController.currentEntry;
+  CRWSessionEntry* fromEntry = sessionController.currentEntry;
+  CRWSessionEntry* toEntry = entries[index];
 
   NSUserDefaults* userDefaults = [NSUserDefaults standardUserDefaults];
   if (![userDefaults boolForKey:@"PendingIndexNavigationDisabled"]) {
-    BOOL sameDocumentNavigation =
-        [sessionController isSameDocumentNavigationBetweenEntry:fromEntry
-                                                       andEntry:entries[index]];
+    BOOL sameDocumentNavigation = [sessionController
+        isSameDocumentNavigationBetweenItem:fromEntry.navigationItem
+                                    andItem:toEntry.navigationItem];
     if (sameDocumentNavigation) {
-      [self.sessionController goToEntryAtIndex:index];
+      [self.sessionController goToItemAtIndex:index];
       // TODO(crbug.com/684098): move this call out this block to avoid code
       // duplication.
       [self webWillFinishHistoryNavigationFromEntry:fromEntry];
       [self updateHTML5HistoryState];
     } else {
-      [sessionController discardNonCommittedEntries];
-      [sessionController setPendingEntryIndex:index];
+      [sessionController discardNonCommittedItems];
+      [sessionController setPendingItemIndex:index];
 
       // TODO(crbug.com/684098): move this call out this block to avoid code
       // duplication.
       [self webWillFinishHistoryNavigationFromEntry:fromEntry];
 
       web::NavigationItemImpl* pendingItem =
           sessionController.pendingEntry.navigationItemImpl;
       pendingItem->SetTransitionType(ui::PageTransitionFromInt(
           pendingItem->GetTransitionType() | ui::PAGE_TRANSITION_FORWARD_BACK));
 
       [self loadCurrentURL];
     }
   } else {
-    [self.sessionController goToEntryAtIndex:index];
+    [self.sessionController goToItemAtIndex:index];
     if (fromEntry)
       [self finishHistoryNavigationFromEntry:fromEntry];
   }
 }
 
 - (BOOL)isLoaded {
   return _loadPhase == web::PAGE_LOADED;
 }
 
 - (void)didFinishNavigation {
@@ skipping 84 matching lines @@
 }
 
 - (void)finishHistoryNavigationFromEntry:(CRWSessionEntry*)fromEntry {
   [self webWillFinishHistoryNavigationFromEntry:fromEntry];
 
   // Only load the new URL if it has a different document than |fromEntry| to
   // prevent extra page loads from NavigationItems created by hash changes or
   // calls to window.history.pushState().
   BOOL shouldLoadURL =
       ![_webStateImpl->GetNavigationManagerImpl().GetSessionController()
-          isSameDocumentNavigationBetweenEntry:fromEntry
-                                      andEntry:self.currentSessionEntry];
+          isSameDocumentNavigationBetweenItem:fromEntry.navigationItem
+                                      andItem:self.currentNavItem];
   web::NavigationItemImpl* currentItem =
       self.currentSessionEntry.navigationItemImpl;
   GURL endURL = [self URLForHistoryNavigationFromItem:fromEntry.navigationItem
                                                toItem:currentItem];
   if (shouldLoadURL) {
     ui::PageTransition transition = ui::PageTransitionFromInt(
         ui::PAGE_TRANSITION_RELOAD | ui::PAGE_TRANSITION_FORWARD_BACK);
 
     NavigationManager::WebLoadParams params(endURL);
     if (currentItem) {
@@ skipping 829 matching lines @@
 }
 
 - (void)didStartLoadingURL:(const GURL&)url updateHistory:(BOOL)updateHistory {
   _loadPhase = web::PAGE_LOADING;
   _URLOnStartLoading = url;
   _displayStateOnStartLoading = self.pageDisplayState;
 
   self.userInteractionRegistered = NO;
   _pageHasZoomed = NO;
 
-  [[self sessionController] commitPendingEntry];
+  [[self sessionController] commitPendingItem];
   [_delegate webDidStartLoadingURL:url shouldUpdateHistory:updateHistory];
 }
 
 - (void)wasShown {
   if ([self.nativeController respondsToSelector:@selector(wasShown)]) {
     [self.nativeController wasShown];
   }
 }
 
 - (void)wasHidden {
@@ skipping 285 matching lines @@
     return;
   }
 
   [self loadCompleteWithSuccess:NO];
   [self loadErrorInNativeView:error];
 }
 
 - (void)handleCancelledError:(NSError*)error {
   if ([self shouldCancelLoadForCancelledError:error]) {
     [self loadCancelled];
-    [[self sessionController] discardNonCommittedEntries];
+    [[self sessionController] discardNonCommittedItems];
   }
 }
 
 - (BOOL)shouldCancelLoadForCancelledError:(NSError*)error {
   DCHECK_EQ(error.code, NSURLErrorCancelled);
   // Do not cancel the load if it is for an app specific URL, as such errors
   // are produced during the app specific URL load process.
   const GURL errorURL =
       net::GURLWithNSURL(error.userInfo[NSURLErrorFailingURLErrorKey]);
   if (web::GetWebClient()->IsAppSpecificURL(errorURL))
@@ skipping 1046 matching lines @@
 - (void)loadHTMLForCurrentURL:(NSString*)HTML {
   [self loadHTML:HTML forURL:self.currentURL];
 }
 
 - (void)stopLoading {
   _stoppedWKNavigation.reset([_navigationStates lastAddedNavigation]);
 
   base::RecordAction(UserMetricsAction("Stop"));
   // Discard the pending and transient entried before notifying the tab model
   // observers of the change via |-abortLoad|.
-  [[self sessionController] discardNonCommittedEntries];
+  [[self sessionController] discardNonCommittedItems];
   [self abortLoad];
   web::NavigationItem* item = [self currentNavItem];
   GURL navigationURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
   // If discarding the non-committed entries results in an app-specific URL,
   // reload it in its native view.
   if (!self.nativeController &&
       [self shouldLoadURLInNativeView:navigationURL]) {
     [self loadCurrentURLInNativeView];
   }
 }
@@ skipping 186 matching lines @@
     // committed URL, which can happen when a link is opened in a new tab via a
     // context menu or window.open, the pending entry should not be
     // discarded so that the NavigationManager is never empty. Also, URLs loaded
     // in a native view should be excluded to avoid an ugly animation where the
     // web view is inserted and quickly removed.
     GURL lastCommittedURL = self.webState->GetLastCommittedURL();
     BOOL isFirstLoad = lastCommittedURL.is_empty();
     BOOL previousItemWasLoadedInNativeView =
         [self shouldLoadURLInNativeView:lastCommittedURL];
     if (!isFirstLoad && !previousItemWasLoadedInNativeView)
-      [self.sessionController discardNonCommittedEntries];
+      [self.sessionController discardNonCommittedItems];
   }
 
   handler(allowNavigation ? WKNavigationResponsePolicyAllow
                           : WKNavigationResponsePolicyCancel);
 }
 
 // TODO(stuartmorgan): Move all the guesswork around these states out of the
 // superclass, and wire these up to the remaining methods.
 - (void)webView:(WKWebView*)webView
     didStartProvisionalNavigation:(WKNavigation*)navigation {
@@ skipping 129 matching lines @@
   _certVerificationErrors->Clear();
 
   // This is the point where the document's URL has actually changed, and
   // pending navigation information should be applied to state information.
   [self setDocumentURL:net::GURLWithNSURL([_webView URL])];
 
   if (!_lastRegisteredRequestURL.is_valid() &&
       _documentURL != _lastRegisteredRequestURL) {
     // if |_lastRegisteredRequestURL| is an invalid URL, then |_documentURL|
     // will be "about:blank".
-    [[self sessionController] updatePendingEntry:_documentURL];
+    [[self sessionController] updatePendingItem:_documentURL];
   }
   DCHECK(_documentURL == _lastRegisteredRequestURL ||
          (!_lastRegisteredRequestURL.is_valid() &&
           _documentURL.spec() == url::kAboutBlankURL));
 
   self.webStateImpl->OnNavigationCommitted(_documentURL);
   [self commitPendingNavigationInfo];
   if ([self currentBackForwardListItemHolder]->navigation_type() ==
       WKNavigationTypeBackForward) {
     // A fast back/forward won't call decidePolicyForNavigationResponse, so
@@ skipping 553 matching lines @@
   }
 
   return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
 }
 
 - (NSString*)refererFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:@"Referer"];
 }
 
 @end