Create NavigationContext right after the navigation was started.

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 583 matching lines @@
 // navigation is committed.
 - (void)commitPendingNavigationInfo;
 // Returns a NSMutableURLRequest that represents the current NavigationItem.
 - (NSMutableURLRequest*)requestForCurrentNavigationItem;
 // Returns the WKBackForwardListItemHolder for the current navigation item.
 - (web::WKBackForwardListItemHolder*)currentBackForwardListItemHolder;
 // Updates the WKBackForwardListItemHolder navigation item.
 - (void)updateCurrentBackForwardListItemHolder;
 
 // Loads the current nativeController in a native view. If a web view is
-// present, removes it and swaps in the native view in its place.
-- (void)loadNativeViewWithSuccess:(BOOL)loadSuccess;
+// present, removes it and swaps in the native view in its place. |context| can
+// not be null.
+- (void)loadNativeViewWithSuccess:(BOOL)loadSuccess
+                navigationContext:(web::NavigationContextImpl*)context;
+// Loads the correct HTML page for |error| in a native controller, retrieved
+// from the native provider.
+- (void)loadErrorInNativeView:(NSError*)error
+            navigationContext:(web::NavigationContextImpl*)context;
 // YES if the navigation to |url| should be treated as a reload.
 - (BOOL)shouldReload:(const GURL&)destinationURL
           transition:(ui::PageTransition)transition;
 // Internal implementation of reload. Reloads without notifying the delegate.
 // Most callers should use -reload instead.
 - (void)reloadInternal;
 // Aborts any load for both the web view and web controller.
 - (void)abortLoad;
 // Updates the internal state and informs the delegate that any outstanding load
 // operations are cancelled.
@@ skipping 725 matching lines @@
   return web::Referrer(GURL(base::SysNSStringToUTF8(referrerString)),
                        web::ReferrerPolicyAlways);
 }
 
 - (void)pushStateWithPageURL:(const GURL&)pageURL
                  stateObject:(NSString*)stateObject
                   transition:(ui::PageTransition)transition {
   [[self sessionController] pushNewItemWithURL:pageURL
                                    stateObject:stateObject
                                     transition:transition];
-  _webStateImpl->OnSameDocumentNavigation(pageURL);
+  std::unique_ptr<web::NavigationContext> context =
+      web::NavigationContextImpl::CreateSameDocumentNavigationContext(
+          _webStateImpl, pageURL);
+  _webStateImpl->OnNavigationFinished(context.get());
   self.userInteractionRegistered = NO;
 }
 
 - (void)replaceStateWithPageURL:(const GURL&)pageURL
                     stateObject:(NSString*)stateObject {
   [[self sessionController] updateCurrentItemWithURL:pageURL
                                          stateObject:stateObject];
-  _webStateImpl->OnSameDocumentNavigation(pageURL);
+  std::unique_ptr<web::NavigationContext> context =
+      web::NavigationContextImpl::CreateSameDocumentNavigationContext(
+          _webStateImpl, pageURL);
+  _webStateImpl->OnNavigationFinished(context.get());
 }
 
 - (void)setDocumentURL:(const GURL&)newURL {
   if (newURL != _documentURL && newURL.is_valid()) {
     _documentURL = newURL;
     _interactionRegisteredSinceLastURLChange = NO;
   }
 }
 
 - (void)setNavigationItemTitle:(NSString*)title {
@@ skipping 149 matching lines @@
     // Typically on PAGE_TRANSITION_CLIENT_REDIRECT.
     [[self sessionController] updatePendingItem:requestURL];
   } else {
     // A new session history entry needs to be created.
     self.navigationManagerImpl->AddPendingItem(
         requestURL, referrer, transition,
         web::NavigationInitiationType::RENDERER_INITIATED,
         web::NavigationManager::UserAgentOverrideOption::INHERIT);
   }
   std::unique_ptr<web::NavigationContextImpl> context =
-      web::NavigationContextImpl::CreateNavigationContext(
-          _webStateImpl, requestURL, nullptr /* response_headers */);
+      web::NavigationContextImpl::CreateNavigationContext(_webStateImpl,
+                                                          requestURL);
   _webStateImpl->SetIsLoading(true);
   // TODO(crbug.com/713836): pass context to |OnProvisionalNavigationStarted|.
   _webStateImpl->OnProvisionalNavigationStarted(requestURL);
   return context;
 }
 
 - (void)updateHTML5HistoryState {
   web::NavigationItemImpl* currentItem = self.currentNavItem;
   if (!currentItem)
     return;
@@ skipping 213 matching lines @@
   holder->set_http_method([_pendingNavigationInfo HTTPMethod]);
 
   // Only update the MIME type in the holder if there was MIME type information
   // as part of this pending load. It will be nil when doing a fast
   // back/forward navigation, for instance, because the callback that would
   // populate it is not called in that flow.
   if ([_pendingNavigationInfo MIMEType])
     holder->set_mime_type([_pendingNavigationInfo MIMEType]);
 }
 
-- (void)loadNativeViewWithSuccess:(BOOL)loadSuccess {
+- (void)loadNativeViewWithSuccess:(BOOL)loadSuccess
+                navigationContext:(web::NavigationContextImpl*)context {
   const GURL currentURL([self currentURL]);
   [self didStartLoadingURL:currentURL];
   _loadPhase = web::PAGE_LOADED;
-  if (loadSuccess) {
-    _webStateImpl->OnNavigationCommitted(currentURL);
-  } else {
-    _webStateImpl->OnErrorPageNavigation(currentURL);
-  }
+  _webStateImpl->OnNavigationFinished(context);
 
   // Perform post-load-finished updates.
   [self didFinishWithURL:currentURL loadSuccess:loadSuccess];
 
   NSString* title = [self.nativeController title];
   if (title) {
     [self setNavigationItemTitle:title];
   }
 
   if ([self.nativeController respondsToSelector:@selector(setDelegate:)]) {
     [self.nativeController setDelegate:self];
   }
 }
 
-- (void)loadErrorInNativeView:(NSError*)error {
+- (void)loadErrorInNativeView:(NSError*)error
+            navigationContext:(web::NavigationContextImpl*)context {
   [self removeWebViewAllowingCachedReconstruction:NO];
   web::NavigationItem* item = self.currentNavItem;
   const GURL currentURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
 
   if (web::IsWKWebViewSSLCertError(error)) {
     // This could happen only if certificate is absent or could not be parsed.
     error = web::NetErrorFromError(error, net::ERR_SSL_SERVER_CERT_BAD_FORMAT);
 #if defined(DEBUG)
     net::SSLInfo info;
     web::GetSSLInfoFromWKWebViewSSLCertError(error, &info);
     CHECK(!error.cert);
 #endif
   } else {
     error = web::NetErrorFromError(error);
   }
 
   BOOL isPost = [self isCurrentNavigationItemPOST];
   [self setNativeController:[_nativeProvider controllerForURL:currentURL
                                                     withError:error
                                                        isPost:isPost]];
-  [self loadNativeViewWithSuccess:NO];
+  [self loadNativeViewWithSuccess:NO navigationContext:context];
 }
 
-// Load the current URL in a native controller, retrieved from the native
-// provider. Call |loadNativeViewWithSuccess:YES| to load the native controller.
+// Loads the current URL in a native controller, retrieved from the native
+// provider.
 - (void)loadCurrentURLInNativeView {
   // Free the web view.
   [self removeWebViewAllowingCachedReconstruction:NO];
 
   web::NavigationItem* item = self.currentNavItem;
   const GURL targetURL = item ? item->GetURL() : GURL::EmptyGURL();
   const web::Referrer referrer;
   id<CRWNativeContent> nativeContent =
       [_nativeProvider controllerForURL:targetURL webState:self.webState];
   // Unlike the WebView case, always create a new controller and view.
   // TODO(pinkerton): What to do if this does return nil?
   [self setNativeController:nativeContent];
   if ([nativeContent respondsToSelector:@selector(virtualURL)]) {
     item->SetVirtualURL([nativeContent virtualURL]);
   }
 
   std::unique_ptr<web::NavigationContextImpl> navigationContext =
       [self registerLoadRequestForURL:targetURL
                              referrer:referrer
                            transition:self.currentTransition];
-  [self loadNativeViewWithSuccess:YES];
+  [self loadNativeViewWithSuccess:YES
+                navigationContext:navigationContext.get()];
 }
 
 - (void)loadWithParams:(const NavigationManager::WebLoadParams&)params {
   DCHECK(!(params.transition_type & ui::PAGE_TRANSITION_FORWARD_BACK));
 
   // 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];
 
@@ skipping 1323 matching lines @@
   // Reset SSL status to default, unless the load was cancelled (manually or by
   // back-forward navigation).
   web::NavigationManager* navManager = self.webState->GetNavigationManager();
   if (navManager->GetLastCommittedItem() && [error code] != NSURLErrorCancelled)
     navManager->GetLastCommittedItem()->GetSSL() = web::SSLStatus();
 
   NSURL* errorURL = [NSURL
       URLWithString:[userInfo objectForKey:NSURLErrorFailingURLStringErrorKey]];
   const GURL errorGURL = net::GURLWithNSURL(errorURL);
 
+  web::NavigationContextImpl* navigationContext =
+      [_navigationStates contextForNavigation:navigation];
+  navigationContext->SetIsErrorPage(true);
+
   // Handles Frame Load Interrupted errors from WebView.
   if ([error.domain isEqual:base::SysUTF8ToNSString(web::kWebKitErrorDomain)] &&
       error.code == web::kWebKitErrorFrameLoadInterruptedByPolicyChange) {
     // See if the delegate wants to handle this case.
     if (errorGURL.is_valid() &&
         [_delegate
             respondsToSelector:@selector(
                                    controllerForUnhandledContentAtURL:)]) {
       id<CRWNativeContent> controller =
           [_delegate controllerForUnhandledContentAtURL:errorGURL];
       if (controller) {
         [self loadCompleteWithSuccess:NO forNavigation:navigation];
         [self removeWebViewAllowingCachedReconstruction:NO];
         [self setNativeController:controller];
-        [self loadNativeViewWithSuccess:YES];
+        [self loadNativeViewWithSuccess:YES
+                      navigationContext:navigationContext];
         return;
       }
     }
 
     // Ignore errors that originate from URLs that are opened in external apps.
     if ([_openedApplicationURL containsObject:errorURL])
       return;
     // Certain frame errors don't have URL information for some reason; for
     // those cases (so far the only known case is plugin content loaded directly
     // in a frame) just ignore the error. See crbug.com/414295
     if (!errorURL) {
       DCHECK(!inMainFrame);
       return;
     }
     // The wrapper error uses the URL of the error and not the requested URL
     // (which can be different in case of a redirect) to match desktop Chrome
     // behavior.
     NSError* wrapperError = [NSError
         errorWithDomain:[error domain]
                    code:[error code]
                userInfo:@{
                  NSURLErrorFailingURLStringErrorKey : [errorURL absoluteString],
                  NSUnderlyingErrorKey : error
                }];
     [self loadCompleteWithSuccess:NO forNavigation:navigation];
-    [self loadErrorInNativeView:wrapperError];
+    [self loadErrorInNativeView:wrapperError
+              navigationContext:navigationContext];
     return;
   }
 
   if ([error code] == NSURLErrorCancelled) {
     [self handleCancelledError:error];
     // NSURLErrorCancelled errors that aren't handled by aborting the load will
     // automatically be retried by the web view, so early return in this case.
     return;
   }
 
   [self loadCompleteWithSuccess:NO forNavigation:navigation];
-  [self loadErrorInNativeView:error];
+  [self loadErrorInNativeView:error navigationContext:navigationContext];
 }
 
 - (void)handleCancelledError:(NSError*)error {
   if ([self shouldCancelLoadForCancelledError:error]) {
     [self loadCancelled];
     [[self sessionController] discardNonCommittedItems];
   }
 }
 
 - (BOOL)shouldCancelLoadForCancelledError:(NSError*)error {
@@ skipping 965 matching lines @@
 
   // 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";
   }
   WKNavigation* navigation =
       [_webView loadHTMLString:HTML baseURL:net::NSURLWithGURL(URL)];
   [_navigationStates setState:web::WKNavigationState::REQUESTED
                 forNavigation:navigation];
+  std::unique_ptr<web::NavigationContextImpl> context =
+      web::NavigationContextImpl::CreateNavigationContext(_webStateImpl, URL);
+  [_navigationStates setContext:std::move(context) forNavigation:navigation];
 }
 
 - (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];
 }
@@ skipping 262 matching lines @@
       // dangerous.
       if (web::GetWebClient()->IsAppSpecificURL(_documentURL)) {
         [self abortLoad];
         NavigationManager::WebLoadParams params(webViewURL);
         [self loadWithParams:params];
       }
       return;
     } else {
       std::unique_ptr<web::NavigationContextImpl> navigationContext =
           [self registerLoadRequestForURL:webViewURL];
+      [_navigationStates setContext:std::move(navigationContext)
+                      forNavigation:navigation];
     }
   }
 
   // Ensure the URL is registered and loadPhase is as expected.
   DCHECK(_lastRegisteredRequestURL == webViewURL);
   DCHECK(self.loadPhase == web::LOAD_REQUESTED);
 }
 
 - (void)webView:(WKWebView*)webView
     didReceiveServerRedirectForProvisionalNavigation:(WKNavigation*)navigation {
@@ skipping 123 matching lines @@
     // TODO(crbug.com/712269):
     for (int i = 0; i < self.navigationManagerImpl->GetItemCount(); i++) {
       web::NavigationItem* item = self.navigationManagerImpl->GetItemAtIndex(i);
       if (item->GetURL() == _documentURL) {
         // Do not discard pending entry, because another pending navigation is
         // still in progress and will commit or fail soon.
         [self.sessionController goToItemAtIndex:i discardNonCommittedItems:NO];
       }
     }
   }
-  self.webStateImpl->OnNavigationCommitted(_documentURL);
+
+  web::NavigationContextImpl* context =
+      [_navigationStates contextForNavigation:navigation];
+  context->SetResponseHeaders(_webStateImpl->GetHttpResponseHeaders());
+  self.webStateImpl->OnNavigationFinished(context);
 
   [self updateSSLStatusForCurrentNavigationItem];
 
   // Attempt to update the HTML5 history state.
   [self updateHTML5HistoryState];
 
   // This is the point where pending entry has been committed, and navigation
   // item title should be updated.
   [self setNavigationItemTitle:[_webView title]];
 
@@ skipping 171 matching lines @@
   }
 
   if (!navigationWasCommitted && ![_pendingNavigationInfo cancelled]) {
     // A fast back/forward within the same origin does not call
     // |didCommitNavigation:|, so signal page change explicitly.
     DCHECK_EQ(_documentURL.GetOrigin(), webViewURL.GetOrigin());
     BOOL isSameDocumentNavigation =
         [self isKVOChangePotentialSameDocumentNavigationToURL:webViewURL];
     [self setDocumentURL:webViewURL];
     [self webPageChanged];
-    if (isSameDocumentNavigation) {
-      _webStateImpl->OnSameDocumentNavigation(webViewURL);
-    } else {
-      _webStateImpl->OnNavigationCommitted(webViewURL);
-    }
+
+    // Same document navigation does not contain response headers.
+    std::unique_ptr<web::NavigationContextImpl> context =
+        web::NavigationContextImpl::CreateNavigationContext(_webStateImpl,
+                                                            webViewURL);
+    net::HttpResponseHeaders* headers =
+        isSameDocumentNavigation ? nullptr
+                                 : _webStateImpl->GetHttpResponseHeaders();
+    context->SetResponseHeaders(headers);
+    context->SetIsSameDocument(isSameDocumentNavigation);
+    _webStateImpl->OnNavigationFinished(context.get());
   }
 
   [self updateSSLStatusForCurrentNavigationItem];
 
   // Fast back forward navigation may not call |didFinishNavigation:|, so
   // signal did finish navigation explicitly.
   if (_lastRegisteredRequestURL == _documentURL) {
     [self didFinishNavigation:nil];
   }
 }
@@ skipping 128 matching lines @@
   // the next runloop.
   //
   // Otherwise, simulate the whole delegate flow for a load (since the
   // superclass currently doesn't have a clean separation between URL changes
   // and document changes). Note that the order of these calls is important:
   // registering a load request logically comes before updating the document
   // URL, but also must come first since it uses state that is reset on URL
   // changes.
   std::unique_ptr<web::NavigationContextImpl> navigationContext;
   if (!_changingHistoryState) {
-    // If this wasn't a previously-expected load (e.g., certain back/forward
-    // navigations), register the load request.
-    if (![self isLoadRequestPendingForURL:newURL])
+    if ([self isLoadRequestPendingForURL:newURL]) {
+      // |loadWithParams:| was called with URL that has different fragment
+      // comparing to the orevious URL.
+      // TODO(crbug.com/713836): Instead of creating a new context, find
+      // existing navigation context stored in |_navigationStates| and use it.
+      navigationContext = web::NavigationContextImpl::CreateNavigationContext(
+          _webStateImpl, newURL);
+    } else {
+      // This could be:
+      //   1.) Renderer-initiated fragment change
+      //   2.) Assigning same-origin URL to window.location
+      //   3.) Incorrectly handled window.location.replace (crbug.com/307072)
+      //   4.) Back-forward same document navigation
       navigationContext = [self registerLoadRequestForURL:newURL];
+    }
+    navigationContext->SetIsSameDocument(true);
   }
 
   [self setDocumentURL:newURL];
 
   if (!_changingHistoryState) {
     [self didStartLoadingURL:_documentURL];
-    _webStateImpl->OnSameDocumentNavigation(newURL);
+    _webStateImpl->OnNavigationFinished(navigationContext.get());
     [self updateSSLStatusForCurrentNavigationItem];
     [self didFinishNavigation:nil];
   }
 }
 
 - (BOOL)isLoadRequestPendingForURL:(const GURL&)targetURL {
   if (self.loadPhase != web::LOAD_REQUESTED)
     return NO;
 
   web::NavigationItem* pendingItem =
@@ skipping 26 matching lines @@
   if (POSTData.length && !repostedForm) {
     [request setHTTPMethod:@"POST"];
     [request setHTTPBody:POSTData];
     [request setAllHTTPHeaderFields:self.currentHTTPHeaders];
     GURL navigationURL =
         currentItem ? currentItem->GetURL() : GURL::EmptyGURL();
     std::unique_ptr<web::NavigationContextImpl> navigationContext =
         [self registerLoadRequestForURL:navigationURL
                                referrer:self.currentNavItemReferrer
                              transition:self.currentTransition];
-    [self loadPOSTRequest:request];
+    WKNavigation* navigation = [self loadPOSTRequest:request];
+    [_navigationStates setContext:std::move(navigationContext)
+                    forNavigation:navigation];
     return;
   }
 
   ProceduralBlock defaultNavigationBlock = ^{
     web::NavigationItem* item = self.currentNavItem;
     GURL navigationURL = item ? item->GetURL() : GURL::EmptyGURL();
     std::unique_ptr<web::NavigationContextImpl> navigationContext =
         [self registerLoadRequestForURL:navigationURL
                                referrer:self.currentNavItemReferrer
                              transition:self.currentTransition];
-    [self loadRequest:request];
+    WKNavigation* navigation = [self loadRequest:request];
+    [_navigationStates setContext:std::move(navigationContext)
+                    forNavigation:navigation];
     [self reportBackForwardNavigationTypeForFastNavigation:NO];
   };
 
   // When navigating via WKBackForwardListItem to pages created or updated by
   // calls to pushState() and replaceState(), sometimes web_bundle.js is not
   // injected correctly.  This means that calling window.history navigation
   // functions will invoke WKWebView's non-overridden implementations, causing a
   // mismatch between the WKBackForwardList and NavigationManager.
   // TODO(crbug.com/659816): Figure out how to prevent web_bundle.js injection
   // flake.
@@ skipping 30 matching lines @@
     } 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);
       navigation =
           [_webView goToBackForwardListItem:holder->back_forward_list_item()];
       [self reportBackForwardNavigationTypeForFastNavigation:YES];
     }
     [_navigationStates setState:web::WKNavigationState::REQUESTED
                   forNavigation:navigation];
+    [_navigationStates setContext:std::move(navigationContext)
+                    forNavigation:navigation];
   };
 
   // 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 (!repostedForm || currentItem->ShouldSkipRepostFormConfirmation()) {
     webViewNavigationBlock();
     return;
   }
 
@@ skipping 86 matching lines @@
 - (NSUInteger)observerCount {
   DCHECK_EQ(_observerBridges.size(), [_observers count]);
   return [_observers count];
 }
 
 - (NSString*)referrerFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:kReferrerHeaderName];
 }
 
 @end