[ios] Correctly determine last seen WKNavigation object.

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 70 matching lines @@
 #import "ios/web/web_state/crw_pass_kit_downloader.h"
 #import "ios/web/web_state/crw_web_view_proxy_impl.h"
 #import "ios/web/web_state/error_translation_util.h"
 #import "ios/web/web_state/js/crw_js_plugin_placeholder_manager.h"
 #import "ios/web/web_state/js/crw_js_post_request_loader.h"
 #import "ios/web/web_state/js/crw_js_window_id_manager.h"
 #import "ios/web/web_state/page_viewport_state.h"
 #import "ios/web/web_state/ui/crw_swipe_recognizer_provider.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #import "ios/web/web_state/ui/crw_web_controller_container_view.h"
+#import "ios/web/web_state/ui/crw_wk_navigation_states.h"
 #import "ios/web/web_state/ui/crw_wk_script_message_router.h"
 #import "ios/web/web_state/ui/wk_back_forward_list_item_holder.h"
 #import "ios/web/web_state/ui/wk_web_view_configuration_provider.h"
 #import "ios/web/web_state/web_controller_observer_bridge.h"
 #include "ios/web/web_state/web_state_facade_delegate.h"
 #import "ios/web/web_state/web_state_impl.h"
 #import "ios/web/web_state/web_view_internal_creation_util.h"
 #import "ios/web/web_state/wk_web_view_security_util.h"
 #import "ios/web/webui/crw_web_ui_manager.h"
 #import "ios/web/webui/mojo_facade.h"
@@ skipping 340 matching lines @@
   // Referrer for the current page; does not include the fragment.
   base::scoped_nsobject<NSString> _currentReferrerString;
 
   // Pending information for an in-progress page navigation. The lifetime of
   // this object starts at |decidePolicyForNavigationAction| where the info is
   // extracted from the request, and ends at either |didCommitNavigation| or
   // |didFailProvisionalNavigation|.
   base::scoped_nsobject<CRWWebControllerPendingNavigationInfo>
       _pendingNavigationInfo;
 
-  // The WKNavigation for the most recent load request.
-  base::scoped_nsobject<WKNavigation> _latestWKNavigation;
+  // Holds all WKNavigation objects and their states which are currently in
+  // flight.
+  base::scoped_nsobject<CRWWKNavigationStates> _navigationStates;
 
   // The WKNavigation captured when |stopLoading| was called. Used for reporting
   // WebController.EmptyNavigationManagerCausedByStopLoading UMA metric which
   // helps with diagnosing a navigation related crash (crbug.com/565457).
   base::WeakNSObject<WKNavigation> _stoppedWKNavigation;
 
   // CRWWebUIManager object for loading WebUI pages.
   base::scoped_nsobject<CRWWebUIManager> _webUIManager;
 
   // Updates SSLStatus for current navigation item.
@@ skipping 579 matching lines @@
         [[CRWWebViewProxyImpl alloc] initWithWebController:self]);
     [[_webViewProxy scrollViewProxy] addObserver:self];
     _gestureRecognizers.reset([[NSMutableArray alloc] init]);
     _webViewToolbars.reset([[NSMutableArray alloc] init]);
     _pendingLoadCompleteActions.reset([[NSMutableArray alloc] init]);
     web::BrowserState* browserState = _webStateImpl->GetBrowserState();
     _certVerificationController.reset([[CRWCertVerificationController alloc]
         initWithBrowserState:browserState]);
     _certVerificationErrors.reset(
         new CertVerificationErrorsCacheType(kMaxCertErrorsCount));
+    _navigationStates.reset([[CRWWKNavigationStates alloc] init]);
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(orientationDidChange)
                name:UIApplicationDidChangeStatusBarOrientationNotification
              object:nil];
   }
   return self;
 }
 
 - (id<CRWNativeContentProvider>)nativeProvider {
@@ skipping 2517 matching lines @@
 
 - (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))
     return NO;
 
-  if (self.sessionController.pendingEntryIndex != -1 &&

[Eugene But (OOO till 7-30), 2016/12/29 02:18:50]

This is not needed with better tracking of last WKNavigation object

-      ![self isLoadRequestPendingForURL:errorURL]) {
-    // Do not cancel the load if there is a pending back forward navigation for
-    // another URL (Back forward happened in the middle of WKWebView
-    // navigation).
-    return NO;
-  }
-
   // Don't cancel NSURLErrorCancelled errors originating from navigation
   // as the WKWebView will automatically retry these loads.
   WKWebViewErrorSource source = WKWebViewErrorSourceFromError(error);
   return source != NAVIGATION;
 }
 
 #pragma mark -
 #pragma mark WebUI
 
 - (void)createWebUIForURL:(const GURL&)URL {
@@ skipping 1217 matching lines @@
   // This happens during tests.
   if (!_webView) {
     return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
   }
 
   std::string MIMEType = self.webState->GetContentsMimeType();
   return [self documentTypeFromMIMEType:base::SysUTF8ToNSString(MIMEType)];
 }
 
 - (void)loadRequest:(NSMutableURLRequest*)request {
-  _latestWKNavigation.reset([[_webView loadRequest:request] retain]);
+  [_navigationStates addNavigation:[_webView loadRequest:request]
+                          forState:web::WK_NAVIGATION_STATE_REQUESTED];
 }
 
 - (void)loadPOSTRequest:(NSMutableURLRequest*)request {
   if (!_POSTRequestLoader) {
     _POSTRequestLoader.reset([[CRWJSPOSTRequestLoader alloc] init]);
   }
 
   CRWWKScriptMessageRouter* messageRouter =
       [self webViewConfigurationProvider].GetScriptMessageRouter();
 
@@ skipping 12 matching lines @@
   // Remove the transient content view.
   [self clearTransientContentView];
 
   _loadPhase = web::LOAD_REQUESTED;
 
   // Web View should not be created for App Specific URLs.
   if (!web::GetWebClient()->IsAppSpecificURL(URL)) {
     [self ensureWebViewCreated];
     DCHECK(_webView) << "_webView null while trying to load HTML";
   }
-  [_webView loadHTMLString:HTML baseURL:net::NSURLWithGURL(URL)];
+  WKNavigation* navigation =
+      [_webView loadHTMLString:HTML baseURL:net::NSURLWithGURL(URL)];
+  [_navigationStates addNavigation:navigation
+                          forState:web::WK_NAVIGATION_STATE_REQUESTED];
 }
 
 - (void)loadHTML:(NSString*)HTML forAppSpecificURL:(const GURL&)URL {
   CHECK(web::GetWebClient()->IsAppSpecificURL(URL));
   [self loadHTML:HTML forURL:URL];
 }
 
 - (void)loadHTMLForCurrentURL:(NSString*)HTML {
   [self loadHTML:HTML forURL:self.currentURL];
 }
 
 - (void)stopLoading {
-  _stoppedWKNavigation.reset(_latestWKNavigation);
+  _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 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.
@@ skipping 242 matching lines @@
   }
 
   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 {
+  [_navigationStates addNavigation:navigation
+                          forState:web::WK_NAVIGATION_STATE_STARTED];
+
   GURL webViewURL = net::GURLWithNSURL(webView.URL);
   if (webViewURL.is_empty()) {
     // May happen on iOS9, however in didCommitNavigation: callback the URL
     // will be "about:blank".
     webViewURL = GURL(url::kAboutBlankURL);
   }
 
   // Intercept renderer-initiated navigations. If this navigation has not yet
   // been registered, do so. loadPhase check is necessary because
   // lastRegisteredRequestURL may be the same as the webViewURL on a new tab
@@ skipping 16 matching lines @@
         [self loadWithParams:params];
       }
       return;
     } else {
       [self registerLoadRequest:webViewURL];
     }
   }
   // Ensure the URL is registered and loadPhase is as expected.
   DCHECK(_lastRegisteredRequestURL == webViewURL);
   DCHECK(self.loadPhase == web::LOAD_REQUESTED);
-  _latestWKNavigation.reset([navigation retain]);
 }
 
 - (void)webView:(WKWebView*)webView
     didReceiveServerRedirectForProvisionalNavigation:(WKNavigation*)navigation {
+  [_navigationStates addNavigation:navigation
+                          forState:web::WK_NAVIGATION_STATE_REDIRECTED];
+
   [self registerLoadRequest:net::GURLWithNSURL(webView.URL)
                    referrer:[self currentReferrer]
                  transition:ui::PAGE_TRANSITION_SERVER_REDIRECT];
 }
 
 - (void)webView:(WKWebView*)webView
     didFailProvisionalNavigation:(WKNavigation*)navigation
                        withError:(NSError*)error {
+  [_navigationStates
+      addNavigation:navigation
+           forState:web::WK_NAVIGATION_STATE_PROVISIONALY_FAILED];
+
   // Ignore provisional navigation failure if a new navigation has been started,
   // for example, if a page is reloaded after the start of the provisional
   // load but before the load has been committed.
-  if (![_latestWKNavigation isEqual:navigation]) {
+  if (![[_navigationStates lastAddedNavigation] isEqual:navigation]) {
     return;
   }
 
   // TODO(crbug.com/570699): Remove this workaround once |stopLoading| does not
   // discard pending navigation items.
   if ((!self.webStateImpl ||
        !self.webStateImpl->GetNavigationManagerImpl().GetVisibleItem()) &&
       [error.domain isEqual:base::SysUTF8ToNSString(web::kWebKitErrorDomain)] &&
       error.code == web::kWebKitErrorFrameLoadInterruptedByPolicyChange) {
     // App is going to crash in this state (crbug.com/565457). Crash will occur
@@ skipping 21 matching lines @@
   }
 
   // This must be reset at the end, since code above may need information about
   // the pending load.
   _pendingNavigationInfo.reset();
   _certVerificationErrors->Clear();
 }
 
 - (void)webView:(WKWebView*)webView
     didCommitNavigation:(WKNavigation*)navigation {
+  [_navigationStates addNavigation:navigation
+                          forState:web::WK_NAVIGATION_STATE_COMMITTED];
+
   // This method will crash if |currentSessionEntry| is null. If this check is
   // hit it means that |didStartProvisionalNavigation| was called as expected
   // but it did not call |registerLoadRequest|. TODO(crbug.com/676721): remove
   // this CHECK once there is at least one crash on this line (which means that
   // |didStartProvisionalNavigation| did not call |registerLoadRequest| and it
   // should be fixed.
   CHECK([self currentSessionEntry] ||
-        ![_latestWKNavigation isEqual:navigation]);
+        [_navigationStates stateForNavigation:navigation] ==
+            web::WK_NAVIGATION_STATE_STARTED);
 
   DCHECK_EQ(_webView, webView);
   _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) {
@@ skipping 40 matching lines @@
   if (_documentURL.SchemeIsCryptographic()) {
     scoped_refptr<net::X509Certificate> cert =
         web::CreateCertFromChain([_webView certificateChain]);
     UMA_HISTOGRAM_BOOLEAN("WebController.WKWebViewHasCertForSecureConnection",
                           static_cast<bool>(cert));
   }
 }
 
 - (void)webView:(WKWebView*)webView
     didFinishNavigation:(WKNavigation*)navigation {
+  [_navigationStates addNavigation:navigation
+                          forState:web::WK_NAVIGATION_STATE_FINISHED];
+
   DCHECK(!_isHalted);
   // Trigger JavaScript driven post-document-load-completion tasks.
   // TODO(crbug.com/546350): Investigate using
   // WKUserScriptInjectionTimeAtDocumentEnd to inject this material at the
   // appropriate time rather than invoking here.
   web::ExecuteJavaScript(webView, @"__gCrWeb.didFinishNavigation()", nil);
   [self didFinishNavigation];
 }
 
 - (void)webView:(WKWebView*)webView
     didFailNavigation:(WKNavigation*)navigation
             withError:(NSError*)error {
+  [_navigationStates addNavigation:navigation
+                          forState:web::WK_NAVIGATION_STATE_FAILED];
+
   [self handleLoadError:WKWebViewErrorWithSource(error, NAVIGATION)
             inMainFrame:YES];
   _certVerificationErrors->Clear();
 }
 
 - (void)webView:(WKWebView*)webView
     didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge*)challenge
                     completionHandler:
                         (void (^)(NSURLSessionAuthChallengeDisposition,
                                   NSURLCredential*))completionHandler {
@@ skipping 347 matching lines @@
     // If the current navigation URL is the same as the URL of the visible
     // page, that means the user requested a reload. |goToBackForwardListItem|
     // will be a no-op when it is passed the current back forward list item,
     // so |reload| must be explicitly called.
     web::NavigationItem* item = [self currentNavItem];
     GURL navigationURL = item ? item->GetURL() : GURL::EmptyGURL();
     [self registerLoadRequest:navigationURL
                      referrer:[self currentSessionEntryReferrer]
                    transition:[self currentTransition]];
     if (navigationURL == net::GURLWithNSURL([_webView URL])) {
-      [_webView reload];
+      [_navigationStates addNavigation:[_webView reload]
+                              forState:web::WK_NAVIGATION_STATE_REQUESTED];
     } else {
       // |didCommitNavigation:| may not be called for fast navigation, so update
       // the navigation type now as it is already known.
       holder->set_navigation_type(WKNavigationTypeBackForward);
-      [_webView goToBackForwardListItem:holder->back_forward_list_item()];
+      WKNavigation* navigation =
+          [_webView goToBackForwardListItem:holder->back_forward_list_item()];
+      [_navigationStates addNavigation:navigation
+                              forState:web::WK_NAVIGATION_STATE_REQUESTED];
     }
   };
 
   // If the request is not a form submission or resubmission, or the user
   // doesn't need to confirm the load, then continue right away.
 
   if (!isFormPOSTResubmission ||
       currentItem->ShouldSkipResubmitDataConfirmation()) {
     webViewNavigationBlock();
     return;
@@ skipping 84 matching lines @@
   }
 
   return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
 }
 
 - (NSString*)refererFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:@"Referer"];
 }
 
 @end