Use webView instance variable instead of getter.

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 1106 matching lines @@
   return _UIDelegate.get();
 }
 
 - (void)setUIDelegate:(id<CRWWebUserInterfaceDelegate>)UIDelegate {
   _UIDelegate.reset(UIDelegate);
 }
 
 - (void)dealloc {
   DCHECK([NSThread isMainThread]);
   DCHECK(_isBeingDestroyed);  // 'close' must have been called already.
-  DCHECK(!self.webView);
+  DCHECK(!_webView);
   _touchTrackingRecognizer.get().touchTrackingDelegate = nil;
   [[_webViewProxy scrollViewProxy] removeObserver:self];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [super dealloc];
 }
 
 - (BOOL)runUnloadListenerBeforeClosing {
   // There's not much that can be done since there's limited access to WebKit.
   // Always return that it's ok to close immediately.
   return YES;
 }
 
 - (void)dismissKeyboard {
-  [self.webView endEditing:YES];
+  [_webView endEditing:YES];
   if ([self.nativeController respondsToSelector:@selector(dismissKeyboard)])
     [self.nativeController dismissKeyboard];
 }
 
 - (id<CRWNativeContent>)nativeController {
   return [_containerView nativeController];
 }
 
 - (void)setNativeController:(id<CRWNativeContent>)nativeController {
   // Check for pointer equality.
@@ skipping 79 matching lines @@
 
 - (void)handleLowMemory {
   [self removeWebViewAllowingCachedReconstruction:YES];
   _touchTrackingRecognizer.get().touchTrackingDelegate = nil;
   _touchTrackingRecognizer.reset();
   [self resetContainerView];
   _usePlaceholderOverlay = YES;
 }
 
 - (void)reinitializeWebViewAndReload:(BOOL)reload {
-  if (self.webView) {
+  if (_webView) {
     [self removeWebViewAllowingCachedReconstruction:NO];
     if (reload) {
       [self loadCurrentURLInWebView];
     } else {
       // Clear the space for the web view to lazy load when needed.
       _usePlaceholderOverlay = YES;
       _touchTrackingRecognizer.get().touchTrackingDelegate = nil;
       _touchTrackingRecognizer.reset();
       [self resetContainerView];
     }
@@ skipping 54 matching lines @@
   _isBeingDestroyed = YES;
 
   // Remove the web view now. Otherwise, delegate callbacks occur.
   [self removeWebViewAllowingCachedReconstruction:NO];
 
   _webStateImpl = nullptr;
 }
 
 - (void)checkLinkPresenceUnderGesture:(UIGestureRecognizer*)gestureRecognizer
                     completionHandler:(void (^)(BOOL))completionHandler {
-  CGPoint webViewPoint = [gestureRecognizer locationInView:self.webView];
+  CGPoint webViewPoint = [gestureRecognizer locationInView:_webView];
   base::WeakNSObject<CRWWebController> weakSelf(self);
   [self
       fetchDOMElementAtPoint:webViewPoint
            completionHandler:^(std::unique_ptr<base::DictionaryValue> element) {
              std::string link;
              BOOL hasLink =
                  element && element->GetString("href", &link) && link.size();
              completionHandler(hasLink);
            }];
 }
@@ skipping 10 matching lines @@
 
   // We don't want ongoing notification that the long press is held.
   if ([gestureRecognizer state] != UIGestureRecognizerStateBegan)
     return;
 
   if (!_DOMElementForLastTouch || _DOMElementForLastTouch->empty())
     return;
 
   NSDictionary* info =
       [self contextMenuInfoForElement:_DOMElementForLastTouch.get()];
-  CGPoint point = [gestureRecognizer locationInView:self.webView];
+  CGPoint point = [gestureRecognizer locationInView:_webView];
 
   // Cancelling all touches has the intended side effect of suppressing the
   // system's context menu.
   [self cancelAllTouches];
   [self.UIDelegate webController:self
                   runContextMenu:info
                          atPoint:point
-                          inView:self.webView];
+                          inView:_webView];
 }
 
 - (BOOL)supportsCustomContextMenu {
   SEL runMenuSelector = @selector(webController:runContextMenu:atPoint:inView:);
   return [self.UIDelegate respondsToSelector:runMenuSelector];
 }
 
 - (void)cancelAllTouches {
   // Disable web view scrolling.
   CancelTouches(self.webScrollView.panGestureRecognizer);
@@ skipping 43 matching lines @@
 }
 
 - (CGPoint)scrollPosition {
   CGPoint position = CGPointMake(0.0, 0.0);
   if (!self.webScrollView)
     return position;
   return self.webScrollView.contentOffset;
 }
 
 - (BOOL)atTop {
-  if (!self.webView)
+  if (!_webView)
     return YES;
   UIScrollView* scrollView = self.webScrollView;
   return scrollView.contentOffset.y == -scrollView.contentInset.top;
 }
 
 - (void)setShouldSuppressDialogs:(BOOL)shouldSuppressDialogs {
   _shouldSuppressDialogs = shouldSuppressDialogs;
-  if (self.webView) {
+  if (_webView) {
     NSString* const kSetSuppressDialogs = [NSString
         stringWithFormat:@"__gCrWeb.setSuppressGeolocationDialogs(%d);",
                          shouldSuppressDialogs];
     [self evaluateJavaScript:kSetSuppressDialogs stringResultHandler:nil];
   } else {
     _shouldSuppressDialogsOnWindowIDInjection = shouldSuppressDialogs;
   }
 }
 
 - (GURL)currentURLWithTrustLevel:(web::URLVerificationTrustLevel*)trustLevel {
   DCHECK(trustLevel) << "Verification of the trustLevel state is mandatory";
-  if (self.webView) {
+  if (_webView) {
     GURL url([self webURLWithTrustLevel:trustLevel]);
     // Web views treat all about: URLs as the same origin, which makes it
     // possible for pages to document.write into about:<foo> pages, where <foo>
     // can be something misleading. Report any about: URL as about:blank to
     // prevent that. See crbug.com/326118
     if (url.scheme() == url::kAboutScheme)
       return GURL(url::kAboutBlankURL);
     return url;
   }
   // Any non-web URL source is trusted.
@@ skipping 98 matching lines @@
     case WKNavigationTypeOther:
       return [self userClickedRecently];
     default:
       return NO;
   }
 }
 
 - (BOOL)isBackForwardListItemValid:(WKBackForwardListItem*)item {
   // The current back-forward list item MUST be in the WKWebView's back-forward
   // list to be valid.
-  WKBackForwardList* list = [self.webView backForwardList];
+  WKBackForwardList* list = [_webView backForwardList];
   return list.currentItem == item ||
          [list.forwardList indexOfObject:item] != NSNotFound ||
          [list.backList indexOfObject:item] != NSNotFound;
 }
 
 - (GURL)URLForHistoryNavigationFromItem:(web::NavigationItem*)fromItem
                                  toItem:(web::NavigationItem*)toItem {
   // If navigating with native API, i.e. using a back forward list item,
   // hashchange events will be triggered automatically, so no URL tampering is
   // required.
@@ skipping 82 matching lines @@
   return _containerView;
 }
 
 - (id<CRWWebViewProxy>)webViewProxy {
   return _webViewProxy.get();
 }
 
 - (UIView*)viewForPrinting {
   // TODO(ios): crbug.com/227944. Printing is not supported for native
   // controllers.
-  return self.webView;
+  return _webView;
 }
 
 - (void)registerLoadRequest:(const GURL&)URL {
   // Get the navigation type from the last main frame load request, and try to
   // map that to a PageTransition.
   WKNavigationType navigationType =
       _pendingNavigationInfo ? [_pendingNavigationInfo navigationType]
                              : WKNavigationTypeOther;
   ui::PageTransition transition = ui::PAGE_TRANSITION_CLIENT_REDIRECT;
   switch (navigationType) {
@@ skipping 206 matching lines @@
   // page, and should not be associated.
   if (_webUIManager)
     return;
 
   web::WKBackForwardListItemHolder* holder =
       [self currentBackForwardListItemHolder];
 
   WKNavigationType navigationType =
       _pendingNavigationInfo ? [_pendingNavigationInfo navigationType]
                              : WKNavigationTypeOther;
-  holder->set_back_forward_list_item(
-      [self.webView backForwardList].currentItem);
+  holder->set_back_forward_list_item([_webView backForwardList].currentItem);
   holder->set_navigation_type(navigationType);
 
   // 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]);
 }
 
@@ skipping 198 matching lines @@
     }
 
     // Display overlay view until current url has finished loading or delay and
     // then transition away.
     if ((_overlayPreviewMode || _usePlaceholderOverlay) && !isChromeScheme)
       [self addPlaceholderOverlay];
 
     // Don't reset the overlay flag if in preview mode.
     if (!_overlayPreviewMode)
       _usePlaceholderOverlay = NO;
-  } else if (_requireReloadOnDisplay && self.webView) {
+  } else if (_requireReloadOnDisplay && _webView) {
     _requireReloadOnDisplay = NO;
     [self addPlaceholderOverlay];
     [self loadCurrentURL];
   }
 }
 
 - (BOOL)shouldReload:(const GURL&)destinationURL
           transition:(ui::PageTransition)transition {
   // Do a reload if the user hits enter in the address bar or re-types a URL.
   CRWSessionController* sessionController =
       _webStateImpl->GetNavigationManagerImpl().GetSessionController();
   web::NavigationItem* item =
       _webStateImpl->GetNavigationManagerImpl().GetVisibleItem();
   return (transition & ui::PAGE_TRANSITION_FROM_ADDRESS_BAR) && item &&
          (destinationURL == item->GetURL() ||
           destinationURL == [sessionController currentEntry].originalUrl);
 }
 
 // Reload either the web view or the native content depending on which is
 // displayed.
 - (void)reloadInternal {
   // Clear last user interaction.
   // TODO(crbug.com/546337): Move to after the load commits, in the subclass
   // implementation. This will be inaccurate if the reload fails or is
   // cancelled.
   _lastUserInteraction.reset();
   web::RecordAction(UserMetricsAction("Reload"));
-  if (self.webView) {
+  if (_webView) {
     web::NavigationItem* transientItem =
         _webStateImpl->GetNavigationManagerImpl().GetTransientItem();
     if (transientItem) {
       // If there's a transient item, a reload is considered a new navigation to
       // the transient item's URL (as on other platforms).
       NavigationManager::WebLoadParams reloadParams(transientItem->GetURL());
       reloadParams.transition_type = ui::PAGE_TRANSITION_RELOAD;
       reloadParams.extra_headers.reset(
           [transientItem->GetHttpRequestHeaders() copy]);
       [self loadWithParams:reloadParams];
@@ skipping 54 matching lines @@
       break;
     case web::PAGE_LOADED:
       break;
   }
 }
 
 - (void)prepareForGoBack {
   // Make sure any transitions that may have occurred have been seen and acted
   // on by the CRWWebController, so the history stack and state of the
   // CRWWebController is 100% up to date before the stack navigation starts.
-  if (self.webView) {
+  if (_webView) {
     [self injectWindowID];
   }
 
   bool wasShowingInterstitial = _webStateImpl->IsShowingWebInterstitial();
 
   // Before changing the current session history entry, record the tab state.
   if (!wasShowingInterstitial) {
     [self recordStateInHistory];
   }
 }
@@ skipping 49 matching lines @@
   [self loadCompleteWithSuccess:YES];
 }
 
 - (void)loadCompleteWithSuccess:(BOOL)loadSuccess {
   [self removePlaceholderOverlay];
   // The webView may have been torn down (or replaced by a native view). Be
   // safe and do nothing if that's happened.
   if (_loadPhase != web::PAGE_LOADING)
     return;
 
-  DCHECK(self.webView);
+  DCHECK(_webView);
 
   const GURL currentURL([self currentURL]);
 
   _loadPhase = web::PAGE_LOADED;
 
   [self optOutScrollsToTopForSubviews];
 
   // Ensure the URL is as expected (and already reported to the delegate).
   DCHECK(currentURL == _lastRegisteredRequestURL)
       << std::endl
@@ skipping 79 matching lines @@
                base::JSONReader::Read(base::SysNSStringToUTF8(stringResult)));
            handler(std::move(result), error);
          }
        }];
 }
 
 - (void)addGestureRecognizerToWebView:(UIGestureRecognizer*)recognizer {
   if ([_gestureRecognizers containsObject:recognizer])
     return;
 
-  [self.webView addGestureRecognizer:recognizer];
+  [_webView addGestureRecognizer:recognizer];
   [_gestureRecognizers addObject:recognizer];
 }
 
 - (void)removeGestureRecognizerFromWebView:(UIGestureRecognizer*)recognizer {
   if (![_gestureRecognizers containsObject:recognizer])
     return;
 
-  [self.webView removeGestureRecognizer:recognizer];
+  [_webView removeGestureRecognizer:recognizer];
   [_gestureRecognizers removeObject:recognizer];
 }
 
 - (void)addToolbarViewToWebView:(UIView*)toolbarView {
   DCHECK(toolbarView);
   if ([_webViewToolbars containsObject:toolbarView])
     return;
   [_webViewToolbars addObject:toolbarView];
-  if (self.webView)
+  if (_webView)
     [_containerView addToolbar:toolbarView];
 }
 
 - (void)removeToolbarViewFromWebView:(UIView*)toolbarView {
   if (![_webViewToolbars containsObject:toolbarView])
     return;
   [_webViewToolbars removeObject:toolbarView];
-  if (self.webView)
+  if (_webView)
     [_containerView removeToolbar:toolbarView];
 }
 
 - (CRWJSInjectionReceiver*)jsInjectionReceiver {
   return _jsInjectionReceiver;
 }
 
 - (BOOL)shouldClosePageOnNativeApplicationLoad {
   // The page should be closed if it was initiated by the DOM and there has been
   // no user interaction with the page since the web view was created, or if
@@ skipping 50 matching lines @@
         (CRWWebControllerContainerView*)containerView {
   return [self headerHeight];
 }
 
 #pragma mark -
 #pragma mark CRWJSInjectionEvaluator Methods
 
 - (void)evaluateJavaScript:(NSString*)script
        stringResultHandler:(web::JavaScriptCompletion)handler {
   NSString* safeScript = [self scriptByAddingWindowIDCheckForScript:script];
-  web::EvaluateJavaScript(self.webView, safeScript, handler);
+  web::EvaluateJavaScript(_webView, safeScript, handler);
 }
 
 - (void)executeJavaScript:(NSString*)script
         completionHandler:(web::JavaScriptResultBlock)completionHandler {
   NSString* safeScript = [self scriptByAddingWindowIDCheckForScript:script];
-  web::ExecuteJavaScript(self.webView, safeScript, completionHandler);
+  web::ExecuteJavaScript(_webView, safeScript, completionHandler);
 }
 
 - (BOOL)scriptHasBeenInjectedForClass:(Class)JSInjectionManagerClass
                        presenceBeacon:(NSString*)beacon {
   return [_injectedScriptManagers containsObject:JSInjectionManagerClass];
 }
 
 - (void)injectScript:(NSString*)script forClass:(Class)JSInjectionManagerClass {
   // Skip evaluation if there's no content (e.g., if what's being injected is
   // an umbrella manager).
   if ([script length]) {
     // Every injection except windowID requires windowID check.
     if (JSInjectionManagerClass != [CRWJSWindowIdManager class])
       script = [self scriptByAddingWindowIDCheckForScript:script];
-    web::ExecuteJavaScript(self.webView, script, nil);
+    web::ExecuteJavaScript(_webView, script, nil);
   }
   [_injectedScriptManagers addObject:JSInjectionManagerClass];
 }
 
 #pragma mark -
 
 - (void)evaluateUserJavaScript:(NSString*)script {
   [self setUserInteractionRegistered:YES];
-  web::ExecuteJavaScript(self.webView, script, nil);
+  web::ExecuteJavaScript(_webView, script, nil);
 }
 
 - (BOOL)respondToMessage:(base::DictionaryValue*)message
        userIsInteracting:(BOOL)userIsInteracting
                originURL:(const GURL&)originURL {
   std::string command;
   if (!message->GetString("command", &command)) {
     DLOG(WARNING) << "JS message parameter not found: command";
     return NO;
   }
@@ skipping 112 matching lines @@
     return NO;
   }
   base::DictionaryValue* command = nullptr;
   if (!message->GetDictionary("crwCommand", &command)) {
     return NO;
   }
   if ([scriptMessage.name isEqualToString:kScriptImmediateName] ||
       [scriptMessage.name isEqualToString:kScriptMessageName]) {
     return [self respondToMessage:command
                 userIsInteracting:[self userIsInteracting]
-                        originURL:net::GURLWithNSURL([self.webView URL])];
+                        originURL:net::GURLWithNSURL([_webView URL])];
   }
 
   NOTREACHED();
   return NO;
 }
 
 #pragma mark -
 #pragma mark JavaScript message handlers
 
 - (BOOL)handleAddPluginPlaceholdersMessage:(base::DictionaryValue*)message
@@ skipping 638 matching lines @@
     if ([self shouldClosePageOnNativeApplicationLoad])
       [_delegate webPageOrderedClose];
     [self stopLoading];
     [_openedApplicationURL addObject:request.URL];
     return NO;
   }
 
   // The WebDelegate may instruct the CRWWebController to stop loading, and
   // instead instruct the next page to be loaded in an animation.
   GURL mainDocumentURL = net::GURLWithNSURL(request.mainDocumentURL);
-  DCHECK(self.webView);
+  DCHECK(_webView);
   if (![self shouldOpenURL:requestURL
            mainDocumentURL:mainDocumentURL
                linkClicked:isLinkClick]) {
     return NO;
   }
 
   // If the URL doesn't look like one we can show, try to open the link with an
   // external application.
   // TODO(droger):  Check transition type before opening an external
   // application? For example, only allow it for TYPED and LINK transitions.
@@ skipping 185 matching lines @@
   }
 
   // This is custom long press gesture recognizer. By the time the gesture is
   // recognized the web controller needs to know if there is a link under the
   // touch. If there a link, the web controller will reject system's context
   // menu and show another one. If for some reason context menu info is not
   // fetched - system context menu will be shown.
   [self setDOMElementForLastTouch:nullptr];
   base::WeakNSObject<CRWWebController> weakSelf(self);
   [self
-      fetchDOMElementAtPoint:[touch locationInView:self.webView]
+      fetchDOMElementAtPoint:[touch locationInView:_webView]
            completionHandler:^(std::unique_ptr<base::DictionaryValue> element) {
              [weakSelf setDOMElementForLastTouch:std::move(element)];
            }];
   return YES;
 }
 
 - (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer*)gestureRecognizer {
   // Expect only _contextMenuRecognizer.
   DCHECK([gestureRecognizer isEqual:_contextMenuRecognizer]);
-  if (!self.webView || ![self supportsCustomContextMenu]) {
+  if (!_webView || ![self supportsCustomContextMenu]) {
     // Show the context menu iff currently displaying a web view.
     // Do nothing for native views.
     return NO;
   }
 
   // Fetching is considered as successful even if |_DOMElementForLastTouch| is
   // empty. However if |_DOMElementForLastTouch| is empty then custom context
   // menu should not be shown.
   UMA_HISTOGRAM_BOOLEAN("WebController.FetchContextMenuInfoAsyncSucceeded",
                         !!_DOMElementForLastTouch);
@@ skipping 324 matching lines @@
   if (!_overlayPreviewMode && _placeholderOverlayView) {
     [self resetContainerView];
     // Reset |_placeholderOverlayView| directly instead of calling
     // -removePlaceholderOverlay, which removes |_placeholderOverlayView| in an
     // animation.
     [_placeholderOverlayView removeFromSuperview];
     _placeholderOverlayView.reset();
     // There are cases when resetting the contentView, above, may happen after
     // the web view has been created. Re-add it here, rather than
     // relying on a subsequent call to loadCurrentURLInWebView.
-    if (self.webView) {
-      [[self view] addSubview:self.webView];
+    if (_webView) {
+      [[self view] addSubview:_webView];
     }
   }
 }
 
 #pragma mark -
 #pragma mark Session Information
 
 - (CRWSessionController*)sessionController {
   return _webStateImpl
       ? _webStateImpl->GetNavigationManagerImpl().GetSessionController()
@@ skipping 115 matching lines @@
 }
 
 - (void)restoreStateFromHistory {
   CRWSessionEntry* current = [self currentSessionEntry];
   if ([current navigationItem])
     self.pageDisplayState = [current navigationItem]->GetPageDisplayState();
 }
 
 - (web::PageDisplayState)pageDisplayState {
   web::PageDisplayState displayState;
-  if (self.webView) {
+  if (_webView) {
     CGPoint scrollOffset = [self scrollPosition];
     displayState.scroll_state().set_offset_x(std::floor(scrollOffset.x));
     displayState.scroll_state().set_offset_y(std::floor(scrollOffset.y));
     UIScrollView* scrollView = self.webScrollView;
     displayState.zoom_state().set_minimum_zoom_scale(
         scrollView.minimumZoomScale);
     displayState.zoom_state().set_maximum_zoom_scale(
         scrollView.maximumZoomScale);
     displayState.zoom_state().set_zoom_scale(scrollView.zoomScale);
   } else {
     // TODO(crbug.com/546146): Handle native views.
   }
   return displayState;
 }
 
 - (void)setPageDisplayState:(web::PageDisplayState)displayState {
   if (!displayState.IsValid())
     return;
-  if (self.webView) {
+  if (_webView) {
     // Page state is restored after a page load completes.  If the user has
     // scrolled or changed the zoom scale while the page is still loading, don't
     // restore any state since it will confuse the user.
     web::PageDisplayState currentPageDisplayState = self.pageDisplayState;
     if (currentPageDisplayState.scroll_state().offset_x() ==
             _displayStateOnStartLoading.scroll_state().offset_x() &&
         currentPageDisplayState.scroll_state().offset_y() ==
             _displayStateOnStartLoading.scroll_state().offset_y() &&
         !_pageHasZoomed) {
       [self applyPageDisplayState:displayState];
@@ skipping 27 matching lines @@
 
 - (void)orientationDidChange {
   // When rotating, the available zoom scale range may change, zoomScale's
   // percentage into this range should remain constant.  However, there are
   // two known bugs with respect to adjusting the zoomScale on rotation:
   // - WKWebView sometimes erroneously resets the scroll view's zoom scale to
   // an incorrect value ( rdar://20100815 ).
   // - After zooming occurs in a UIWebView that's displaying a page with a hard-
   // coded viewport width, the zoom will not be updated upon rotation
   // ( crbug.com/485055 ).
-  if (!self.webView)
+  if (!_webView)
     return;
   web::NavigationItem* currentItem = self.currentNavItem;
   if (!currentItem)
     return;
   web::PageDisplayState displayState = currentItem->GetPageDisplayState();
   if (!displayState.IsValid())
     return;
   CGFloat zoomPercentage = (displayState.zoom_state().zoom_scale() -
                             displayState.zoom_state().minimum_zoom_scale()) /
                            displayState.zoom_state().GetMinMaxZoomDifference();
@@ skipping 35 matching lines @@
   if (isUserScalable) {
     [self prepareToApplyWebViewScrollZoomScale];
     [self applyWebViewScrollZoomScaleFromZoomState:displayState.zoom_state()];
     [self finishApplyingWebViewScrollZoomScale];
   }
   [self applyWebViewScrollOffsetFromScrollState:displayState.scroll_state()];
   _applyingPageState = NO;
 }
 
 - (void)prepareToApplyWebViewScrollZoomScale {
-  id webView = self.webView;
+  id webView = _webView;
   if (![webView respondsToSelector:@selector(viewForZoomingInScrollView:)]) {
     return;
   }
 
   UIView* contentView = [webView viewForZoomingInScrollView:self.webScrollView];
 
   if ([webView
           respondsToSelector:@selector(scrollViewWillBeginZooming:withView:)]) {
     [webView scrollViewWillBeginZooming:self.webScrollView
                                withView:contentView];
   }
 }
 
 - (void)finishApplyingWebViewScrollZoomScale {
-  id webView = self.webView;
+  id webView = _webView;
   if ([webView respondsToSelector:@selector(scrollViewDidEndZooming:
                                                            withView:
                                                             atScale:)] &&
       [webView respondsToSelector:@selector(viewForZoomingInScrollView:)]) {
     // This correctly sets the content's frame in the scroll view to
     // fit the web page and upscales the content so that it isn't
     // blurry.
     UIView* contentView =
         [webView viewForZoomingInScrollView:self.webScrollView];
     [webView scrollViewDidEndZooming:self.webScrollView
@@ skipping 34 matching lines @@
       [weakScrollView setContentOffset:scrollOffset];
     } copy]);
     [_pendingLoadCompleteActions addObject:action];
   }
 }
 
 #pragma mark -
 #pragma mark Web Page Features
 
 - (void)fetchWebPageWidthWithCompletionHandler:(void (^)(CGFloat))handler {
-  if (!self.webView) {
+  if (!_webView) {
     handler(0);
     return;
   }
 
   [self evaluateJavaScript:@"__gCrWeb.getPageWidth();"
        stringResultHandler:^(NSString* pageWidthAsString, NSError*) {
          handler([pageWidthAsString floatValue]);
        }];
 }
 
@@ skipping 235 matching lines @@
   }
 
   if (!_SSLStatusUpdater) {
     _SSLStatusUpdater.reset([[CRWSSLStatusUpdater alloc]
         initWithDataSource:self
          navigationManager:navManager
                certGroupID:self.certGroupID]);
     [_SSLStatusUpdater setDelegate:self];
   }
   NSString* host = base::SysUTF8ToNSString(_documentURL.host());
-  NSArray* certChain = [self.webView certificateChain];
-  BOOL hasOnlySecureContent = [self.webView hasOnlySecureContent];
+  NSArray* certChain = [_webView certificateChain];
+  BOOL hasOnlySecureContent = [_webView hasOnlySecureContent];
   [_SSLStatusUpdater updateSSLStatusForNavigationItem:currentNavItem
                                          withCertHost:host
                                             certChain:certChain
                                  hasOnlySecureContent:hasOnlySecureContent];
 }
 
 - (void)didUpdateSSLStatusForCurrentNavigationItem {
   if ([_delegate respondsToSelector:
           @selector(
               webControllerDidUpdateSSLStatusForCurrentNavigationItem:)]) {
@@ skipping 87 matching lines @@
   [self ensureWebViewCreatedWithConfiguration:config];
 }
 
 - (void)ensureWebViewCreatedWithConfiguration:(WKWebViewConfiguration*)config {
   if (!_webView) {
     [self setWebView:[self createWebViewWithConfiguration:config]];
     // The following is not called in -setWebView: as the latter used in unit
     // tests with fake web view, which cannot be added to view hierarchy.
     CHECK(_webUsageEnabled) << "Tried to create a web view while suspended!";
 
-    UIView* webView = self.webView;
-    DCHECK(webView);
+    DCHECK(_webView);
 
-    [webView setTag:kWebViewTag];
-    [webView setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
-                                 UIViewAutoresizingFlexibleHeight];
-    [webView setBackgroundColor:[UIColor colorWithWhite:0.2 alpha:1.0]];
+    [_webView setTag:kWebViewTag];
+    [_webView setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
+                                  UIViewAutoresizingFlexibleHeight];
+    [_webView setBackgroundColor:[UIColor colorWithWhite:0.2 alpha:1.0]];
 
     // Create a dependency between the |webView| pan gesture and BVC side swipe
     // gestures. Note: This needs to be added before the longPress recognizers
     // below, or the longPress appears to deadlock the remaining recognizers,
     // thereby breaking scroll.
     NSSet* recognizers = [_swipeRecognizerProvider swipeRecognizers];
     for (UISwipeGestureRecognizer* swipeRecognizer in recognizers) {
       [self.webScrollView.panGestureRecognizer
           requireGestureRecognizerToFail:swipeRecognizer];
     }
@@ skipping 11 matching lines @@
     // detection duration a little lower than that (see
     // kLongPressDurationSeconds). It also points the delegate to this class
     // that
     // allows simultaneously operate along with the other recognizers.
     _contextMenuRecognizer.reset([[UILongPressGestureRecognizer alloc]
         initWithTarget:self
                 action:@selector(showContextMenu:)]);
     [_contextMenuRecognizer setMinimumPressDuration:kLongPressDurationSeconds];
     [_contextMenuRecognizer setAllowableMovement:kLongPressMoveDeltaPixels];
     [_contextMenuRecognizer setDelegate:self];
-    [webView addGestureRecognizer:_contextMenuRecognizer];
+    [_webView addGestureRecognizer:_contextMenuRecognizer];
     // Certain system gesture handlers are known to conflict with our context
     // menu handler, causing extra events to fire when the context menu is
     // active.
 
     // A number of solutions have been investigated. The lowest-risk solution
     // appears to be to recurse through the web controller's recognizers,
     // looking
     // for fingerprints of the recognizers known to cause problems, which are
     // then
     // de-prioritized (below our own long click handler).
     // Hunting for description fragments of system recognizers is undeniably
     // brittle for future versions of iOS. If it does break the context menu
     // events may leak (regressing b/5310177), but the app will otherwise work.
     [CRWWebController requireGestureRecognizerToFail:_contextMenuRecognizer
-                                              inView:webView
+                                              inView:_webView
                                containingDescription:
                                    @"action=_highlightLongPressRecognized:"];
 
     // Add all additional gesture recognizers to the web view.
     for (UIGestureRecognizer* recognizer in _gestureRecognizers.get()) {
-      [webView addGestureRecognizer:recognizer];
+      [_webView addGestureRecognizer:recognizer];
     }
 
     _URLOnStartLoading = _defaultURL;
 
     // Add the web toolbars.
     [_containerView addToolbars:_webViewToolbars];
 
     base::scoped_nsobject<CRWWebViewContentView> webViewContentView(
-        [[CRWWebViewContentView alloc] initWithWebView:self.webView
+        [[CRWWebViewContentView alloc] initWithWebView:_webView
                                             scrollView:self.webScrollView]);
     [_containerView displayWebViewContentView:webViewContentView];
   }
 }
 
 - (WKWebView*)createWebViewWithConfiguration:(WKWebViewConfiguration*)config {
   return [web::CreateWKWebView(CGRectZero, config,
                                self.webStateImpl->GetBrowserState(),
                                [self useDesktopUserAgent]) autorelease];
 }
@@ skipping 34 matching lines @@
   [_webView setNavigationDelegate:self];
   [_webView setUIDelegate:self];
   for (NSString* keyPath in self.WKWebViewObservers) {
     [_webView addObserver:self forKeyPath:keyPath options:0 context:nullptr];
   }
   _injectedScriptManagers.reset([[NSMutableSet alloc] init]);
   [self setDocumentURL:_defaultURL];
 }
 
 - (void)removeWebViewAllowingCachedReconstruction:(BOOL)allowCache {
-  if (!self.webView)
+  if (!_webView)
     return;
 
   SEL cancelDialogsSelector = @selector(cancelDialogsForWebController:);
   if ([self.UIDelegate respondsToSelector:cancelDialogsSelector])
     [self.UIDelegate cancelDialogsForWebController:self];
 
   if (allowCache)
     _expectedReconstructionURL = [self currentNavigationURL];
   else
     _expectedReconstructionURL = GURL();
 
   [self abortLoad];
-  [self.webView removeFromSuperview];
+  [_webView removeFromSuperview];
   [_containerView resetContent];
   [self setWebView:nil];
 }
 
 - (void)webViewWebProcessDidCrash {
   _webProcessIsDead = YES;
 
   SEL cancelDialogsSelector = @selector(cancelDialogsForWebController:);
   if ([self.UIDelegate respondsToSelector:cancelDialogsSelector])
     [self.UIDelegate cancelDialogsForWebController:self];
 
   SEL rendererCrashSelector = @selector(webControllerWebProcessDidCrash:);
   if ([self.delegate respondsToSelector:rendererCrashSelector])
     [self.delegate webControllerWebProcessDidCrash:self];
 }
 
 - (web::WKWebViewConfigurationProvider&)webViewConfigurationProvider {
   web::BrowserState* browserState = self.webStateImpl->GetBrowserState();
   return web::WKWebViewConfigurationProvider::FromBrowserState(browserState);
 }
 
 - (web::WebViewDocumentType)webViewDocumentType {
   // This happens during tests.
-  if (!self.webView) {
+  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([[self.webView loadRequest:request] retain]);
+  _latestWKNavigation.reset([[_webView loadRequest:request] retain]);
 }
 
 - (void)loadPOSTRequest:(NSMutableURLRequest*)request {
   if (!_POSTRequestLoader) {
     _POSTRequestLoader.reset([[CRWJSPOSTRequestLoader alloc] init]);
   }
 
   CRWWKScriptMessageRouter* messageRouter =
       [self webViewConfigurationProvider].GetScriptMessageRouter();
 
   [_POSTRequestLoader loadPOSTRequest:request
                             inWebView:_webView
                         messageRouter:messageRouter
                     completionHandler:^(NSError* loadError) {
                       if (loadError)
                         [self handleLoadError:loadError inMainFrame:YES];
                       else
                         self.webStateImpl->SetContentsMimeType("text/html");
                     }];
 }
 
 - (void)loadHTML:(NSString*)HTML forURL:(const GURL&)URL {
   // Remove the transient content view.
   [self clearTransientContentView];
 
-  DLOG_IF(WARNING, !self.webView)
-      << "self.webView null while trying to load HTML";
+  DLOG_IF(WARNING, !_webView) << "_webView null while trying to load HTML";
   _loadPhase = web::LOAD_REQUESTED;
-  [self.webView loadHTMLString:HTML baseURL:net::NSURLWithGURL(URL)];
+  [_webView loadHTMLString:HTML baseURL:net::NSURLWithGURL(URL)];
 }
 
 - (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 41 matching lines @@
   }
 
   CRWWebController* child = [self createChildWebController];
   // WKWebView requires WKUIDelegate to return a child view created with
   // exactly the same |configuration| object (exception is raised if config is
   // different). |configuration| param and config returned by
   // WKWebViewConfigurationProvider are different objects because WKWebView
   // makes a shallow copy of the config inside init, so every WKWebView
   // owns a separate shallow copy of WKWebViewConfiguration.
   [child ensureWebViewCreatedWithConfiguration:configuration];
-  return [child webView];
+  return child.webView;

[Eugene But (OOO till 7-30), 2016/04/26 18:00:41]

child->_webView could work, but I would keep webView property and use it only
here (your current code).

 }
 
 - (void)webViewDidClose:(WKWebView*)webView {
   if (self.sessionController.openedByDOM) {
     [self.delegate webPageOrderedClose];
   }
 }
 
 - (void)webView:(WKWebView*)webView
     runJavaScriptAlertPanelWithMessage:(NSString*)message
@@ skipping 243 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 {
-  DCHECK_EQ(self.webView, webView);
+  DCHECK_EQ(_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.
   _injectedScriptManagers.reset([[NSMutableSet alloc] init]);
   [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])];
+  [self setDocumentURL:net::GURLWithNSURL([_webView URL])];
   DCHECK(_documentURL == _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 (_documentURL.SchemeIsCryptographic()) {
     scoped_refptr<net::X509Certificate> cert =
-        web::CreateCertFromChain([self.webView certificateChain]);
+        web::CreateCertFromChain([_webView certificateChain]);
     UMA_HISTOGRAM_BOOLEAN("WebController.WKWebViewHasCertForSecureConnection",
                           cert);
   }
 }
 
 - (void)webView:(WKWebView*)webView
     didFinishNavigation:(WKNavigation*)navigation {
   DCHECK(!_isHalted);
   // Trigger JavaScript driven post-document-load-completion tasks.
   // TODO(crbug.com/546350): Investigate using
@@ skipping 109 matching lines @@
 - (void)webViewSecurityFeaturesDidChange {
   if (self.loadPhase == web::LOAD_REQUESTED) {
     // Do not update SSL Status for pending load. It will be updated in
     // |webView:didCommitNavigation:| callback.
     return;
   }
   [self updateSSLStatusForCurrentNavigationItem];
 }
 
 - (void)webViewLoadingStateDidChange {
-  if ([self.webView isLoading]) {
+  if ([_webView isLoading]) {
     [self addActivityIndicatorTask];
   } else {
     [self clearActivityIndicatorTasks];
     if ([self currentNavItem] &&
         [self currentBackForwardListItemHolder]->navigation_type() ==
             WKNavigationTypeBackForward) {
       // A fast back/forward may not call |webView:didFinishNavigation:|, so
       // finishing the navigation should be signalled explicitly.
       [self didFinishNavigation];
     }
@@ skipping 11 matching lines @@
   if ([self.delegate
           respondsToSelector:@selector(webController:titleDidChange:)]) {
     DCHECK([_webView title]);
     [self.delegate webController:self titleDidChange:[_webView title]];
   }
 }
 
 - (void)webViewURLDidChange {
   // TODO(stuartmorgan): Determine if there are any cases where this still
   // happens, and if so whether anything should be done when it does.
-  if (![self.webView URL]) {
+  if (![_webView URL]) {
     DVLOG(1) << "Received nil URL callback";
     return;
   }
-  GURL URL(net::GURLWithNSURL([self.webView URL]));
+  GURL URL(net::GURLWithNSURL([_webView URL]));
   // URL changes happen at three points:
   // 1) When a load starts; at this point, the load is provisional, and
   //    it should be ignored until it's committed, since the document/window
   //    objects haven't changed yet.
   // 2) When a non-document-changing URL change happens (hash change,
   //    history.pushState, etc.). This URL change happens instantly, so should
   //    be reported.
   // 3) When a navigation error occurs after provisional navigation starts,
   //    the URL reverts to the previous URL without triggering a new navigation.
   //
   // If |isLoading| is NO, then it must be case 2 or 3. If the last committed
   // URL (_documentURL) matches the current URL, assume that it is a revert from
   // navigation failure and do nothing. If the URL does not match, assume it is
   // a non-document-changing URL change, and handle accordingly.
   //
   // If |isLoading| is YES, then it could either be case 1, or it could be case
   // 2 on a page that hasn't finished loading yet. If it's possible that it
   // 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 (![_webView isLoading]) {
     if (_documentURL == URL)
       return;
     [self URLDidChangeWithoutDocumentChange:URL];
   } else if ([self isKVOChangePotentialSameDocumentNavigationToURL:URL]) {
-    [self.webView
+    [_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]]) {
+           if (!_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 =
                _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;
+               net::GURLWithNSURL([_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 != _documentURL;
            if (windowLocationMatchesNewURL &&
                newURLOriginMatchesDocumentURLOrigin &&
                webViewURLMatchesNewURL && URLDidChangeFromDocumentURL) {
              [self URLDidChangeWithoutDocumentChange:URL];
            }
          }];
   }
 }
 
 - (BOOL)isKVOChangePotentialSameDocumentNavigationToURL:(const GURL&)newURL {
-  DCHECK([self.webView isLoading]);
+  DCHECK([_webView isLoading]);
   // If the origin changes, it can't be same-document.
   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(_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(newURL == net::GURLWithNSURL([_webView URL]));
   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.
@@ skipping 23 matching lines @@
 - (BOOL)isLoadRequestPendingForURL:(const GURL&)targetURL {
   if (self.loadPhase != web::LOAD_REQUESTED)
     return NO;
 
   web::NavigationItem* pendingItem =
       self.webState->GetNavigationManager()->GetPendingItem();
   return pendingItem && pendingItem->GetURL() == targetURL;
 }
 
 - (void)loadRequestForCurrentNavigationItem {
-  DCHECK(self.webView && !self.nativeController);
+  DCHECK(_webView && !self.nativeController);
   DCHECK([self currentSessionEntry]);
   // If a load is kicked off on a WKWebView with a frame whose size is {0, 0} or
   // that has a negative dimension for a size, rendering issues occur that
   // manifest in erroneous scrolling and tap handling (crbug.com/574996,
   // crbug.com/577793).
-  DCHECK_GT(CGRectGetWidth(self.webView.frame), 0.0);
-  DCHECK_GT(CGRectGetHeight(self.webView.frame), 0.0);
+  DCHECK_GT(CGRectGetWidth([_webView frame]), 0.0);
+  DCHECK_GT(CGRectGetHeight([_webView frame]), 0.0);
 
   web::WKBackForwardListItemHolder* holder =
       [self currentBackForwardListItemHolder];
   BOOL isFormResubmission =
       (holder->navigation_type() == WKNavigationTypeFormResubmitted ||
        holder->navigation_type() == WKNavigationTypeFormSubmitted);
   web::NavigationItemImpl* currentItem =
       [self currentSessionEntry].navigationItemImpl;
   NSData* POSTData = currentItem->GetPostData();
   NSMutableURLRequest* request = [self requestForCurrentNavigationItem];
@@ skipping 29 matching lines @@
   }
 
   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]
                      referrer:[self currentSessionEntryReferrer]
                    transition:[self currentTransition]];
-    if ([self currentNavigationURL] == net::GURLWithNSURL([self.webView URL])) {
-      [self.webView reload];
+    if ([self currentNavigationURL] == net::GURLWithNSURL([_webView URL])) {
+      [_webView reload];
     } else {
-      [self.webView goToBackForwardListItem:holder->back_forward_list_item()];
+      [_webView goToBackForwardListItem:holder->back_forward_list_item()];
     }
   };
 
   // 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 (!isFormResubmission ||
       currentItem->ShouldSkipResubmitDataConfirmation()) {
     webViewNavigationBlock();
     return;
@@ skipping 93 matching lines @@
   }
 
   return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
 }
 
 - (NSString*)refererFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:@"Referer"];
 }
 
 @end