Remove CRWWebController currentNavigationURL

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 542 matching lines @@
 
 // Returns the current entry from the underlying session controller.
 // TODO(stuartmorgan): Audit all calls to these methods; these are just wrappers
 // around the same logic as GetActiveEntry, so should probably not be used for
 // the same reason that GetActiveEntry is deprecated. (E.g., page operations
 // should generally be dealing with the last commited entry, not a pending
 // entry).
 - (CRWSessionEntry*)currentSessionEntry;
 // Returns the navigation item for the current page.
 - (web::NavigationItem*)currentNavItem;
-// Returns the URL that the navigation system believes should be currently
-// active.
-// TODO(stuartmorgan):Remove this in favor of more specific getters.
-- (const GURL&)currentNavigationURL;
 // Returns the current transition type.
 - (ui::PageTransition)currentTransition;
 // Returns the referrer for current navigation item. May be empty.
 - (web::Referrer)currentSessionEntryReferrer;
 // The HTTP headers associated with the current navigation item. These are nil
 // unless the request was a POST.
 - (NSDictionary*)currentHTTPHeaders;
 
 // Creates a web view if it's not yet created.
 - (void)ensureWebViewCreated;
@@ skipping 847 matching lines @@
   }
   // Any non-web URL source is trusted.
   *trustLevel = web::URLVerificationTrustLevel::kAbsolute;
   if (self.nativeController) {
     if ([self.nativeController respondsToSelector:@selector(virtualURL)]) {
       return [self.nativeController virtualURL];
     } else {
       return [self.nativeController url];
     }
   }
-  return [self currentNavigationURL];
+  web::NavigationItem* item = [self currentNavItem];
+  return item ? item->GetVirtualURL() : GURL::EmptyGURL();
 }
 
 - (WKWebView*)webView {
   return _webView.get();
 }
 
 - (UIScrollView*)webScrollView {
   return [_webView scrollView];
 }
 
 - (GURL)currentURL {
   web::URLVerificationTrustLevel trustLevel =
       web::URLVerificationTrustLevel::kNone;
   return [self currentURLWithTrustLevel:&trustLevel];
 }
 
 - (web::Referrer)currentReferrer {
   // Referrer string doesn't include the fragment, so in cases where the
   // previous URL is equal to the current referrer plus the fragment the
   // previous URL is returned as current referrer.
   NSString* referrerString = _currentReferrerString;
 
   // In case of an error evaluating the JavaScript simply return empty string.
   if ([referrerString length] == 0)
     return web::Referrer();
 
-  NSString* previousURLString =
-      base::SysUTF8ToNSString([self currentNavigationURL].spec());
+  web::NavigationItem* item = [self currentNavItem];
+  GURL navigationURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
+  NSString* previousURLString = base::SysUTF8ToNSString(navigationURL.spec());
   // Check if the referrer is equal to the previous URL minus the hash symbol.
   // L'#' is used to convert the char '#' to a unichar.
   if ([previousURLString length] > [referrerString length] &&
       [previousURLString hasPrefix:referrerString] &&
       [previousURLString characterAtIndex:[referrerString length]] == L'#') {
     referrerString = previousURLString;
   }
   // Since referrer is being extracted from the destination page, the correct
   // policy from the origin has *already* been applied. Since the extracted URL
   // is the post-policy value, and the source policy is no longer available,
@@ skipping 353 matching lines @@
           strongSelf.get()->_URLOnStartLoading = URL;
           strongSelf.get()->_lastRegisteredRequestURL = URL;
         }];
 }
 
 // Load the current URL in a web view, first ensuring the web view is visible.
 - (void)loadCurrentURLInWebView {
   // Clear the set of URLs opened in external applications.
   _openedApplicationURL.reset([[NSMutableSet alloc] init]);
 
+  web::NavigationItem* item = [self currentNavItem];
+  GURL targetURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
   // Load the url. The UIWebView delegate callbacks take care of updating the
   // session history and UI.
-  const GURL targetURL([self currentNavigationURL]);
   if (!targetURL.is_valid()) {
     [self didFinishWithURL:targetURL loadSuccess:NO];
     return;
   }
 
   // JavaScript should never be evaluated here. User-entered JS should be
   // evaluated via stringByEvaluatingUserJavaScriptFromString.
   DCHECK(!targetURL.SchemeIs(url::kJavaScriptScheme));
 
   [self ensureWebViewCreated];
@@ skipping 31 matching lines @@
   if ([_pendingNavigationInfo MIMEType]) {
     self.webStateImpl->SetContentsMimeType(
         base::SysNSStringToUTF8([_pendingNavigationInfo MIMEType]));
   }
   [self updateCurrentBackForwardListItemHolder];
 
   _pendingNavigationInfo.reset();
 }
 
 - (NSMutableURLRequest*)requestForCurrentNavigationItem {
-  const GURL currentNavigationURL([self currentNavigationURL]);
+  web::NavigationItem* item = [self currentNavItem];
+  const GURL currentNavigationURL =
+      item ? item->GetVirtualURL() : GURL::EmptyGURL();
   NSMutableURLRequest* request = [NSMutableURLRequest
       requestWithURL:net::NSURLWithGURL(currentNavigationURL)];
   const web::Referrer referrer([self currentSessionEntryReferrer]);
   if (referrer.url.is_valid()) {
     std::string referrerValue =
         web::ReferrerHeaderValueForNavigation(currentNavigationURL, referrer);
     if (!referrerValue.empty()) {
       [request setValue:base::SysUTF8ToNSString(referrerValue)
           forHTTPHeaderField:kReferrerHeaderName];
     }
@@ skipping 64 matching lines @@
     // If the controller handles title change notification, route those to the
     // delegate.
     if ([self.nativeController respondsToSelector:@selector(setDelegate:)]) {
       [self.nativeController setDelegate:self];
     }
   }
 }
 
 - (void)loadErrorInNativeView:(NSError*)error {
   [self removeWebViewAllowingCachedReconstruction:NO];
-
-  const GURL currentUrl = [self currentNavigationURL];
+  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
+  [self setNativeController:[_nativeProvider controllerForURL:currentURL
                                                     withError:error
                                                        isPost:isPost]];
   [self loadNativeViewWithSuccess:NO];
 }
 
 // Load the current URL in a native controller, retrieved from the native
 // provider. Call |loadNativeViewWithSuccess:YES| to load the native controller.
 - (void)loadCurrentURLInNativeView {
   // Free the web view.
   [self removeWebViewAllowingCachedReconstruction:NO];
 
-  const GURL targetURL = [self currentNavigationURL];
+  web::NavigationItem* item = [self currentNavItem];
+  const GURL targetURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
   const web::Referrer referrer;
   id<CRWNativeContent> nativeContent =
       [_nativeProvider controllerForURL:targetURL];
   // 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)]) {
-    [self currentNavItem]->SetVirtualURL([nativeContent virtualURL]);
+    item->SetVirtualURL([nativeContent virtualURL]);
   }
   [self registerLoadRequest:targetURL
                    referrer:referrer
                  transition:[self currentTransition]];
   [self loadNativeViewWithSuccess:YES];
 }
 
 - (void)loadWithParams:(const NavigationManager::WebLoadParams&)originalParams {
   // Make a copy of |params|, as some of the delegate methods may modify it.
   NavigationManager::WebLoadParams params(originalParams);
@@ skipping 67 matching lines @@
 
   // Abort any outstanding page load. This ensures the delegate gets informed
   // about the outgoing page, and further messages from the page are suppressed.
   if (_loadPhase != web::PAGE_LOADED)
     [self abortLoad];
 
   DCHECK(!_isHalted);
   // Remove the transient content view.
   [self clearTransientContentView];
 
-  const GURL currentURL = [self currentNavigationURL];
+  web::NavigationItem* item = [self currentNavItem];
+  const GURL currentURL = item ? item->GetVirtualURL() : 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]) {
-    web::NavigationItem* item = [self currentNavItem];
     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];
       return;
     } else {
       [self createWebUIForURL:currentURL];
@@ skipping 42 matching lines @@
     CGRect containerViewFrame =
         [UIApplication sharedApplication].keyWindow.bounds;
     containerViewFrame.origin.y += statusBarHeight;
     containerViewFrame.size.height -= statusBarHeight;
     _containerView.get().frame = containerViewFrame;
     DCHECK(!CGRectIsEmpty(_containerView.get().frame));
 
     [_containerView addGestureRecognizer:[self touchTrackingRecognizer]];
     [_containerView setAccessibilityIdentifier:web::kContainerViewID];
     // Is |currentUrl| a web scheme or native chrome scheme.
+    web::NavigationItem* item = [self currentNavItem];
+    const GURL currentNavigationURL =
+        item ? item->GetVirtualURL() : GURL::EmptyGURL();
     BOOL isChromeScheme =
-        web::GetWebClient()->IsAppSpecificURL([self currentNavigationURL]);
+        web::GetWebClient()->IsAppSpecificURL(currentNavigationURL);
 
     // Don't immediately load the web page if in overlay mode. Always load if
     // native.
     if (isChromeScheme || !_overlayPreviewMode) {
       // TODO(jimblackler): end the practice of calling |loadCurrentURL| when it
       // is possible there is no current URL. If the call performs necessary
       // initialization, break that out.
       [self loadCurrentURL];
     }
 
@@ skipping 1217 matching lines @@
 
   // Check if the link navigation leads to a launch of an external app.
   // TODO(crbug.com/607780): Revise the logic of allowing external app launch
   // and move it to externalAppLauncher.
   BOOL isOpenInNewTabNavigation =
       !_webStateImpl->GetNavigationManager()->GetItemCount();
   BOOL isPossibleLinkClick = [self isLinkNavigation:action.navigationType];
   if (isPossibleLinkClick || isOpenInNewTabNavigation ||
       PageTransitionCoreTypeIs([self currentTransition],
                                ui::PAGE_TRANSITION_AUTO_BOOKMARK)) {
+    web::NavigationItem* item = [self currentNavItem];
+    const GURL currentNavigationURL =
+        item ? item->GetVirtualURL() : GURL::EmptyGURL();
     // Check If the URL is handled by a native app.
     if ([self urlTriggersNativeAppLaunch:requestURL
-                               sourceURL:[self currentNavigationURL]
+                               sourceURL:currentNavigationURL
                  linkActivatedNavigation:isNavigationTypeLinkActivated]) {
       // External app has been launched successfully. Stop the current page
       // load operation (e.g. notifying all observers) and record the URL so
       // that errors reported following the 'NO' reply can be safely ignored.
       if ([self shouldClosePageOnNativeApplicationLoad])
         [_delegate webPageOrderedClose];
       [self stopLoading];
       [_openedApplicationURL addObject:request.URL];
       return NO;
     }
@@ skipping 337 matching lines @@
                                                        sourceURL:)]) {
     return NO;
   }
   return [_delegate webController:self
           shouldBlockPopupWithURL:popupURL
                         sourceURL:sourceURL];
 }
 
 - (void)openPopupWithInfo:(const web::NewWindowInfo&)windowInfo {
   const GURL url(windowInfo.url);
-  const GURL currentURL([self currentNavigationURL]);
+  web::NavigationItem* item = [self currentNavItem];
+  const GURL currentURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
   NSString* windowName = windowInfo.window_name.get();
   web::Referrer referrer(currentURL, windowInfo.referrer_policy);
   base::WeakNSObject<CRWWebController> weakSelf(self);
   void (^showPopupHandler)() = ^{
     CRWWebController* child = [[weakSelf delegate] webPageOrderedOpen:url
                                                              referrer:referrer
                                                            windowName:windowName
                                                          inBackground:NO];
     DCHECK(!child || child.sessionController.openedByDOM);
   };
@@ skipping 265 matching lines @@
 - (web::NavigationItem*)currentNavItem {
   // This goes through the legacy Session* interface rather than Navigation*
   // because it is itself a legacy method that should not exist, and this
   // avoids needing to add a GetActiveItem to NavigationManager. If/when this
   // method chain becomes a blocker to eliminating SessionController, the logic
   // can be moved here, using public NavigationManager getters. That's not
   // done now in order to avoid code duplication.
   return [[self currentSessionEntry] navigationItem];
 }
 
-- (const GURL&)currentNavigationURL {
-  // TODO(stuartmorgan): Fix the fact that this method doesn't have clear usage
-  // delination that would allow changing to one of the non-deprecated URL
-  // calls.
-  web::NavigationItem* item = [self currentNavItem];
-  return item ? item->GetVirtualURL() : GURL::EmptyGURL();
-}
-
 - (ui::PageTransition)currentTransition {
   if ([self currentNavItem])
     return [self currentNavItem]->GetTransitionType();
   else
     return ui::PageTransitionFromInt(0);
 }
 
 - (web::Referrer)currentSessionEntryReferrer {
   web::NavigationItem* currentItem = [self currentNavItem];
   return currentItem ? currentItem->GetReferrer() : web::Referrer();
@@ skipping 743 matching lines @@
 
 - (void)removeWebViewAllowingCachedReconstruction:(BOOL)allowCache {
   if (!_webView)
     return;
 
   SEL cancelDialogsSelector = @selector(cancelDialogsForWebController:);
   if ([self.UIDelegate respondsToSelector:cancelDialogsSelector])
     [self.UIDelegate cancelDialogsForWebController:self];
   _webStateImpl->CancelDialogs();
 
-  if (allowCache)
-    _expectedReconstructionURL = [self currentNavigationURL];
-  else
-    _expectedReconstructionURL = GURL();
+  web::NavigationItem* item = [self currentNavItem];
+  if (allowCache && item) {
+    _expectedReconstructionURL = item->GetVirtualURL();
+  } else {
+    _expectedReconstructionURL = GURL::EmptyGURL();
+  }
 
   [self abortLoad];
   [_webView removeFromSuperview];
   [_containerView resetContent];
   [self setWebView:nil];
 }
 
 - (void)webViewWebProcessDidCrash {
   _webProcessIsDead = YES;
 
@@ skipping 69 matching lines @@
 }
 
 - (void)stopLoading {
   _stoppedWKNavigation.reset(_latestWKNavigation);
 
   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.
   if (!self.nativeController &&
-      [self shouldLoadURLInNativeView:[self currentNavigationURL]]) {
+      [self shouldLoadURLInNativeView:navigationURL]) {
     [self loadCurrentURLInNativeView];
   }
 }
 
 #pragma mark -
 #pragma mark WKUIDelegate Methods
 
 - (WKWebView*)webView:(WKWebView*)webView
     createWebViewWithConfiguration:(WKWebViewConfiguration*)configuration
                forNavigationAction:(WKNavigationAction*)action
@@ skipping 717 matching lines @@
       [self currentSessionEntry].navigationItemImpl;
   NSData* POSTData = currentItem->GetPostData();
   NSMutableURLRequest* request = [self requestForCurrentNavigationItem];
 
   // If the request has POST data and is not a form resubmission, configure and
   // run the POST request.
   if (POSTData.length && !isFormPOSTResubmission) {
     [request setHTTPMethod:@"POST"];
     [request setHTTPBody:POSTData];
     [request setAllHTTPHeaderFields:[self currentHTTPHeaders]];
-    [self registerLoadRequest:[self currentNavigationURL]
+    GURL navigationURL =
+        currentItem ? currentItem->GetVirtualURL() : GURL::EmptyGURL();
+    [self registerLoadRequest:navigationURL
                      referrer:[self currentSessionEntryReferrer]
                    transition:[self currentTransition]];
     [self loadPOSTRequest:request];
     return;
   }
 
   ProceduralBlock defaultNavigationBlock = ^{
-    [self registerLoadRequest:[self currentNavigationURL]
+    web::NavigationItem* item = [self currentNavItem];
+    GURL navigationURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
+    [self registerLoadRequest:navigationURL
                      referrer:[self currentSessionEntryReferrer]
                    transition:[self currentTransition]];
     [self loadRequest:request];
   };
 
   // When navigating via WKBackForwardListItem to pages created or updated by
   // calls to pushState() and replaceState(), sometimes core.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.
@@ skipping 12 matching lines @@
       ![self isBackForwardListItemValid:holder->back_forward_list_item()]) {
     defaultNavigationBlock();
     return;
   }
 
   ProceduralBlock webViewNavigationBlock = ^{
     // 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.
-    [self registerLoadRequest:[self currentNavigationURL]
+    web::NavigationItem* item = [self currentNavItem];
+    GURL navigationURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
+    [self registerLoadRequest:navigationURL
                      referrer:[self currentSessionEntryReferrer]
                    transition:[self currentTransition]];
-    if ([self currentNavigationURL] == net::GURLWithNSURL([_webView URL])) {
+    if (navigationURL == net::GURLWithNSURL([_webView URL])) {
       [_webView reload];
     } 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()];
     }
   };
 
   // If the request is not a form submission or resubmission, or the user
@@ skipping 91 matching lines @@
   }
 
   return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
 }
 
 - (NSString*)refererFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:@"Referer"];
 }
 
 @end