Remove CRWWKWebViewWebController variables.

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 <objc/runtime.h>
 #include <stddef.h>
 
 #include <cmath>
@@ skipping 251 matching lines @@
   // Each observer in |_observers| is associated with a
   // WebControllerObserverBridge in order to listen from WebState callbacks.
   // TODO(droger): Remove |_observerBridges| when all CRWWebControllerObservers
   // are converted to WebStateObservers.
   ScopedVector<web::WebControllerObserverBridge> _observerBridges;
   // |windowId| that is saved when a page changes. Used to detect refreshes.
   base::scoped_nsobject<NSString> _lastSeenWindowID;
   // YES if a user interaction has been registered at any time once the page has
   // loaded.
   BOOL _userInteractionRegistered;
+  // YES if the user has interacted with the content area since the last URL
+  // change.
+  BOOL _interactionRegisteredSinceLastURLChange;
+  // The actual URL of the document object (i.e., the last committed URL).
+  // TODO(crbug.com/549616): Remove this in favor of just updating the
+  // navigation manager and treating that as authoritative.
+  GURL _documentURL;
   // Last URL change reported to webWill/DidStartLoadingURL. Used to detect page
   // location changes (client redirects) in practice.
   GURL _lastRegisteredRequestURL;
   // Last URL change reported to webDidStartLoadingURL. Used to detect page
   // location changes in practice.
   GURL _URLOnStartLoading;
   // Page loading phase.
   web::LoadPhase _loadPhase;
   // The web::PageDisplayState recorded when the page starts loading.
   web::PageDisplayState _displayStateOnStartLoading;
@@ skipping 178 matching lines @@
 // Returns a new autoreleased web view created with given configuration.
 - (WKWebView*)createWebViewWithConfiguration:(WKWebViewConfiguration*)config;
 // Sets the value of the webView property, and performs its basic setup.
 - (void)setWebView:(WKWebView*)webView;
 // Destroys the web view by setting webView property to nil.
 - (void)resetWebView;
 // Returns the WKWebViewConfigurationProvider associated with the web
 // controller's BrowserState.
 - (web::WKWebViewConfigurationProvider&)webViewConfigurationProvider;
 
+// Returns the current URL of the web view, and sets |trustLevel| accordingly
+// based on the confidence in the verification.
+- (GURL)webURLWithTrustLevel:(web::URLVerificationTrustLevel*)trustLevel;
 // Returns |YES| if |url| should be loaded in a native view.
 - (BOOL)shouldLoadURLInNativeView:(const GURL&)url;
 // Loads the HTML into the page at the given URL.
 - (void)loadHTML:(NSString*)html forURL:(const GURL&)url;
 // 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;
 // YES if the navigation to |url| should be treated as a reload.
 - (BOOL)shouldReload:(const GURL&)destinationURL
           transition:(ui::PageTransition)transition;
@@ skipping 90 matching lines @@
 // stack. A state object is a serialized generic JavaScript object that contains
 // details of the UI's state for a given CRWSessionEntry/URL.
 // TODO(stuartmorgan): Move the pushState/replaceState logic into
 // NavigationManager.
 - (void)pushStateWithPageURL:(const GURL&)pageURL
                  stateObject:(NSString*)stateObject
                   transition:(ui::PageTransition)transition;
 // Assigns the given URL and state object to the current CRWSessionEntry.
 - (void)replaceStateWithPageURL:(const GURL&)pageUrl
                     stateObject:(NSString*)stateObject;
+// Sets _documentURL to newURL, and updates any relevant state information.
+- (void)setDocumentURL:(const GURL&)newURL;
 // Returns YES if the current navigation item corresponds to a web page
 // loaded by a POST request.
 - (BOOL)isCurrentNavigationItemPOST;
 // Returns whether the given navigation is triggered by a user link click.
 - (BOOL)isLinkNavigation:(WKNavigationType)navigationType;
 
 // Finds all the scrollviews in the view hierarchy and makes sure they do not
 // interfere with scroll to top when tapping the statusbar.
 - (void)optOutScrollsToTopForSubviews;
 // Tears down the old native controller, and then replaces it with the new one.
@@ skipping 768 matching lines @@
   self.userInteractionRegistered = NO;
 }
 
 - (void)replaceStateWithPageURL:(const GURL&)pageUrl
                     stateObject:(NSString*)stateObject {
   [[self sessionController] updateCurrentEntryWithURL:pageUrl
                                           stateObject:stateObject];
   [self didUpdateHistoryStateWithPageURL:pageUrl];
 }
 
+- (void)setDocumentURL:(const GURL&)newURL {
+  if (newURL != _documentURL) {
+    _documentURL = newURL;
+    _interactionRegisteredSinceLastURLChange = NO;
+  }
+}
+
 - (BOOL)isCurrentNavigationItemPOST {
   // |_pendingNavigationInfo| will be nil if the decidePolicy* delegate methods
   // were not called.
   WKNavigationType type =
       _pendingNavigationInfo
           ? [_pendingNavigationInfo navigationType]
           : [self currentBackForwardListItemHolder]->navigation_type();
   return type == WKNavigationTypeFormSubmitted ||
          type == WKNavigationTypeFormResubmitted;
 }
@@ skipping 187 matching lines @@
       transition = ui::PAGE_TRANSITION_FORWARD_BACK;
       break;
     case WKNavigationTypeReload:
       transition = ui::PAGE_TRANSITION_RELOAD;
       break;
     case WKNavigationTypeOther:
       // The "Other" type covers a variety of very different cases, which may
       // or may not be the result of user actions. For now, guess based on
       // whether there's been an interaction since the last URL change.
       // TODO(crbug.com/549301): See if this heuristic can be improved.
-      transition = self.interactionRegisteredSinceLastURLChange
+      transition = _interactionRegisteredSinceLastURLChange
                        ? ui::PAGE_TRANSITION_LINK
                        : ui::PAGE_TRANSITION_CLIENT_REDIRECT;
       break;
   }
   // The referrer is not known yet, and will be updated later.
   const web::Referrer emptyReferrer;
   [self registerLoadRequest:URL referrer:emptyReferrer transition:transition];
 }
 
 - (void)registerLoadRequest:(const GURL&)requestURL
@@ skipping 354 matching lines @@
     [self loadCurrentURLInNativeView];
   } else {
     [self loadCurrentURLInWebView];
   }
 
   // Once a URL has been loaded, any cached-based reconstruction state has
   // either been handled or obsoleted.
   _expectedReconstructionURL = GURL();
 }
 
+- (GURL)webURLWithTrustLevel:(web::URLVerificationTrustLevel*)trustLevel {
+  DCHECK(trustLevel);
+  *trustLevel = web::URLVerificationTrustLevel::kAbsolute;
+  return _documentURL;
+}
+
 - (BOOL)shouldLoadURLInNativeView:(const GURL&)url {
   // App-specific URLs that don't require WebUI are loaded in native views.
   return web::GetWebClient()->IsAppSpecificURL(url) &&
          !_webStateImpl->HasWebUI();
 }
 
 - (void)triggerPendingLoad {
   if (!self.containerView) {
     DCHECK(!_isBeingDestroyed);
     // Create the top-level parent view, which will contain the content (whether
@@ skipping 1193 matching lines @@
 }
 
 + (BOOL)webControllerCanShow:(const GURL&)url {
   return web::UrlHasWebScheme(url) ||
          web::GetWebClient()->IsAppSpecificURL(url) ||
          url.SchemeIs(url::kFileScheme) || url.SchemeIs(url::kAboutScheme);
 }
 
 - (void)setUserInteractionRegistered:(BOOL)flag {
   _userInteractionRegistered = flag;
+  if (flag)
+    _interactionRegisteredSinceLastURLChange = YES;
 }
 
 - (BOOL)userInteractionRegistered {
   return _userInteractionRegistered;
 }
 
 - (BOOL)useDesktopUserAgent {
   web::NavigationItem* item = [self currentNavItem];
   return item && item->IsOverridingUserAgent();
 }
@@ skipping 1196 matching lines @@
     return;
   }
 
   if (!_SSLStatusUpdater) {
     _SSLStatusUpdater.reset([[CRWSSLStatusUpdater alloc]
         initWithDataSource:self
          navigationManager:navManager
                certGroupID:self.certGroupID]);
     [_SSLStatusUpdater setDelegate:self];
   }
-  NSString* host = base::SysUTF8ToNSString(self.documentURL.host());
+  NSString* host = base::SysUTF8ToNSString(_documentURL.host());
   NSArray* certChain = [self.webView certificateChain];
   BOOL hasOnlySecureContent = [self.webView hasOnlySecureContent];
   [_SSLStatusUpdater updateSSLStatusForNavigationItem:currentNavItem
                                          withCertHost:host
                                             certChain:certChain
                                  hasOnlySecureContent:hasOnlySecureContent];
 }
 
 - (void)didUpdateSSLStatusForCurrentNavigationItem {
   if ([_delegate respondsToSelector:
@@ skipping 485 matching lines @@
   DCHECK_EQ(self.webView, webView);
   _certVerificationErrors->Clear();
   // This point should closely approximate the document object change, so reset
   // the list of injected scripts to those that are automatically injected.
   [self clearInjectedScriptManagers];
   [self injectWindowID];
 
   // 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([self.webView URL])];
-  DCHECK(self.documentURL == self.lastRegisteredRequestURL);
-  self.webStateImpl->OnNavigationCommitted(self.documentURL);
+  DCHECK(_documentURL == self.lastRegisteredRequestURL);
+  self.webStateImpl->OnNavigationCommitted(_documentURL);
   [self commitPendingNavigationInfo];
   if ([self currentBackForwardListItemHolder]->navigation_type() ==
       WKNavigationTypeBackForward) {
     // A fast back/forward won't call decidePolicyForNavigationResponse, so
     // the MIME type needs to be updated explicitly.
     NSString* storedMIMEType =
         [self currentBackForwardListItemHolder]->mime_type();
     if (storedMIMEType) {
       self.webStateImpl->SetContentsMimeType(
           base::SysNSStringToUTF8(storedMIMEType));
     }
   }
   [self webPageChanged];
 
   [self updateSSLStatusForCurrentNavigationItem];
 
   // Report cases where SSL cert is missing for a secure connection.
-  if (self.documentURL.SchemeIsCryptographic()) {
+  if (_documentURL.SchemeIsCryptographic()) {
     scoped_refptr<net::X509Certificate> cert =
         web::CreateCertFromChain([self.webView certificateChain]);
     UMA_HISTOGRAM_BOOLEAN("WebController.WKWebViewHasCertForSecureConnection",
                           cert);
   }
 }
 
 - (void)webView:(WKWebView*)webView
     didFinishNavigation:(WKNavigation*)navigation {
   DCHECK(!self.isHalted);
@@ skipping 175 matching lines @@
   // could be a same-page navigation (in which case there may not be any other
   // callback about the URL having changed), then check the actual page URL via
   // JavaScript. If the origin of the new URL matches the last committed URL,
   // then check window.location.href, and if it matches, trust it. The origin
   // check ensures that if a site somehow corrupts window.location.href it can't
   // do a redirect to a slow-loading target page while it is still loading to
   // spoof the origin. On a document-changing URL change, the
   // window.location.href will match the previous URL at this stage, not the web
   // view's current URL.
   if (![self.webView isLoading]) {
-    if (self.documentURL == URL)
+    if (_documentURL == URL)
       return;
     [self URLDidChangeWithoutDocumentChange:URL];
   } else if ([self isKVOChangePotentialSameDocumentNavigationToURL:URL]) {
     [self.webView
         evaluateJavaScript:@"window.location.href"
          completionHandler:^(id result, NSError* error) {
            // If the web view has gone away, or the location
            // couldn't be retrieved, abort.
            if (!self.webView || ![result isKindOfClass:[NSString class]]) {
              return;
            }
            GURL JSURL([result UTF8String]);
            // Check that window.location matches the new URL. If
            // it does not, this is a document-changing URL change as
            // the window location would not have changed to the new
            // URL when the script was called.
            BOOL windowLocationMatchesNewURL = JSURL == URL;
            // Re-check origin in case navigaton has occured since
            // start of JavaScript evaluation.
            BOOL newURLOriginMatchesDocumentURLOrigin =
-               self.documentURL.GetOrigin() == URL.GetOrigin();
+               _documentURL.GetOrigin() == URL.GetOrigin();
            // Check that the web view URL still matches the new URL.
            // TODO(crbug.com/563568): webViewURLMatchesNewURL check
            // may drop same document URL changes if pending URL
            // change occurs immediately after. Revisit heuristics to
            // prevent this.
            BOOL webViewURLMatchesNewURL =
                net::GURLWithNSURL([self.webView URL]) == URL;
            // Check that the new URL is different from the current
            // document URL. If not, URL change should not be reported.
-           BOOL URLDidChangeFromDocumentURL = URL != self.documentURL;
+           BOOL URLDidChangeFromDocumentURL = URL != _documentURL;
            if (windowLocationMatchesNewURL &&
                newURLOriginMatchesDocumentURLOrigin &&
                webViewURLMatchesNewURL && URLDidChangeFromDocumentURL) {
              [self URLDidChangeWithoutDocumentChange:URL];
            }
          }];
   }
 }
 
 - (BOOL)isKVOChangePotentialSameDocumentNavigationToURL:(const GURL&)newURL {
   DCHECK([self.webView isLoading]);
   // If the origin changes, it can't be same-document.
-  if (self.documentURL.GetOrigin().is_empty() ||
-      self.documentURL.GetOrigin() != newURL.GetOrigin()) {
+  if (_documentURL.GetOrigin().is_empty() ||
+      _documentURL.GetOrigin() != newURL.GetOrigin()) {
     return NO;
   }
   if (self.loadPhase == web::LOAD_REQUESTED) {
     // Normally LOAD_REQUESTED indicates that this is a regular, pending
     // navigation, but it can also happen during a fast-back navigation across
     // a hash change, so that case is potentially a same-document navigation.
     return web::GURLByRemovingRefFromGURL(newURL) ==
-           web::GURLByRemovingRefFromGURL(self.documentURL);
+           web::GURLByRemovingRefFromGURL(_documentURL);
   }
   // If it passes all the checks above, it might be (but there's no guarantee
   // that it is).
   return YES;
 }
 
 - (void)URLDidChangeWithoutDocumentChange:(const GURL&)newURL {
   DCHECK(newURL == net::GURLWithNSURL([self.webView URL]));
-  DCHECK_EQ(self.documentURL.host(), newURL.host());
-  DCHECK(self.documentURL != newURL);
+  DCHECK_EQ(_documentURL.host(), newURL.host());
+  DCHECK(_documentURL != newURL);
 
   // If called during window.history.pushState or window.history.replaceState
   // JavaScript evaluation, only update the document URL. This callback does not
   // have any information about the state object and cannot create (or edit) the
   // navigation entry for this page change. Web controller will sync with
   // history changes when a window.history.didPushState or
   // window.history.didReplaceState message is received, which should happen in
   // 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.
   if (!self.changingHistoryState) {
     // If this wasn't a previously-expected load (e.g., certain back/forward
     // navigations), register the load request.
     if (![self isLoadRequestPendingForURL:newURL])
       [self registerLoadRequest:newURL];
   }
 
   [self setDocumentURL:newURL];
 
   if (!self.changingHistoryState) {
-    [self didStartLoadingURL:self.documentURL updateHistory:YES];
+    [self didStartLoadingURL:_documentURL updateHistory:YES];
     [self updateSSLStatusForCurrentNavigationItem];
     [self didFinishNavigation];
   }
 }
 
 - (BOOL)isLoadRequestPendingForURL:(const GURL&)targetURL {
   if (self.loadPhase != web::LOAD_REQUESTED)
     return NO;
 
   web::NavigationItem* pendingItem =
@@ skipping 114 matching lines @@
   }
 
   return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
 }
 
 - (NSString*)refererFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:@"Referer"];
 }
 
 @end