Revert of [ObjC ARC] Converts crw_web_controller to ARC.

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>
 
 #include <cmath>
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/containers/mru_cache.h"
 #include "base/ios/block_types.h"
 #include "base/ios/ios_util.h"
 #import "base/ios/ns_error_util.h"
+#include "base/ios/weak_nsobject.h"
 #include "base/json/json_reader.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
+#include "base/mac/objc_property_releaser.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
@@ skipping 61 matching lines @@
 #import "ios/web/web_state/wk_web_view_security_util.h"
 #import "ios/web/webui/crw_web_ui_manager.h"
 #import "ios/web/webui/mojo_facade.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/base/net_errors.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
 #include "ui/base/page_transition_types.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
 
-#if !defined(__has_feature) || !__has_feature(objc_arc)
-#error "This file requires ARC support."
-#endif
-
 using base::UserMetricsAction;
 using web::NavigationManager;
 using web::NavigationManagerImpl;
 using web::WebState;
 using web::WebStateImpl;
 
 namespace web {
 NSString* const kContainerViewID = @"Container View";
 const char* kWindowNameSeparator = "#";
 NSString* const kUserIsInteractingKey = @"userIsInteracting";
@@ skipping 124 matching lines @@
   return
       [NSError errorWithDomain:error.domain code:error.code userInfo:userInfo];
 }
 }  // namespace
 
 #pragma mark -
 
 // A container object for any navigation information that is only available
 // during pre-commit delegate callbacks, and thus must be held until the
 // navigation commits and the informatino can be used.
-@interface CRWWebControllerPendingNavigationInfo : NSObject
+@interface CRWWebControllerPendingNavigationInfo : NSObject {
+  base::mac::ObjCPropertyReleaser
+      _propertyReleaser_CRWWebControllerPendingNavigationInfo;
+}
 // The referrer for the page.
 @property(nonatomic, copy) NSString* referrer;
 // The MIME type for the page.
 @property(nonatomic, copy) NSString* MIMEType;
 // The navigation type for the load.
 @property(nonatomic, assign) WKNavigationType navigationType;
 // HTTP request method for the load.
 @property(nonatomic, copy) NSString* HTTPMethod;
 // Whether the pending navigation has been directly cancelled before the
 // navigation is committed.
 // Cancelled navigations should be simply discarded without handling any
 // specific error.
 @property(nonatomic, assign) BOOL cancelled;
 @end
 
 @implementation CRWWebControllerPendingNavigationInfo
 @synthesize referrer = _referrer;
 @synthesize MIMEType = _MIMEType;
 @synthesize navigationType = _navigationType;
 @synthesize HTTPMethod = _HTTPMethod;
 @synthesize cancelled = _cancelled;
 
 - (instancetype)init {
   if ((self = [super init])) {
+    _propertyReleaser_CRWWebControllerPendingNavigationInfo.Init(
+        self, [CRWWebControllerPendingNavigationInfo class]);
     _navigationType = WKNavigationTypeOther;
   }
   return self;
 }
 @end
 
 @interface CRWWebController ()<CRWNativeContentDelegate,
                                CRWSSLStatusUpdaterDataSource,
                                CRWSSLStatusUpdaterDelegate,
                                CRWWebControllerContainerViewDelegate,
                                CRWWebViewScrollViewProxyObserver,
                                WKNavigationDelegate,
                                WKUIDelegate> {
+  base::WeakNSProtocol<id<CRWWebDelegate>> _delegate;
+  base::WeakNSProtocol<id<CRWWebUserInterfaceDelegate>> _UIDelegate;
+  base::WeakNSProtocol<id<CRWNativeContentProvider>> _nativeProvider;
+  base::WeakNSProtocol<id<CRWSwipeRecognizerProvider>> _swipeRecognizerProvider;
   // The WKWebView managed by this instance.
   base::scoped_nsobject<WKWebView> _webView;
   // The CRWWebViewProxy is the wrapper to give components access to the
   // web view in a controlled and limited way.
   base::scoped_nsobject<CRWWebViewProxyImpl> _webViewProxy;
   // The view used to display content.  Must outlive |_webViewProxy|. The
   // container view should be accessed through this property rather than
   // |self.view| from within this class, as |self.view| triggers creation while
   // |self.containerView| will return nil if the view hasn't been instantiated.
   base::scoped_nsobject<CRWWebControllerContainerView> _containerView;
@@ skipping 138 matching lines @@
   // |didFailProvisionalNavigation|.
   base::scoped_nsobject<CRWWebControllerPendingNavigationInfo>
       _pendingNavigationInfo;
 
   // The WKNavigation for the most recent load request.
   base::scoped_nsobject<WKNavigation> _latestWKNavigation;
 
   // The WKNavigation captured when |stopLoading| was called. Used for reporting
   // WebController.EmptyNavigationManagerCausedByStopLoading UMA metric which
   // helps with diagnosing a navigation related crash (crbug.com/565457).
-  __weak WKNavigation* _stoppedWKNavigation;
+  base::WeakNSObject<WKNavigation> _stoppedWKNavigation;
 
   // CRWWebUIManager object for loading WebUI pages.
   base::scoped_nsobject<CRWWebUIManager> _webUIManager;
 
   // Updates SSLStatus for current navigation item.
   base::scoped_nsobject<CRWSSLStatusUpdater> _SSLStatusUpdater;
 
   // Controller used for certs verification to help with blocking requests with
   // bad SSL cert, presenting SSL interstitials and determining SSL status for
   // Navigation Items.
   base::scoped_nsobject<CRWCertVerificationController>
       _certVerificationController;
 
   // CertVerification errors which happened inside
   // |webView:didReceiveAuthenticationChallenge:completionHandler:|.
   // Key is leaf-cert/host pair. This storage is used to carry calculated
   // cert status from |didReceiveAuthenticationChallenge:| to
   // |didFailProvisionalNavigation:| delegate method.
   std::unique_ptr<CertVerificationErrorsCacheType> _certVerificationErrors;
 }
 
 // If |contentView_| contains a web view, this is the web view it contains.
 // If not, it's nil.
-@property(nonatomic, strong, readonly) WKWebView* webView;
+@property(nonatomic, readonly) WKWebView* webView;
 // The scroll view of |webView|.
-@property(nonatomic, strong, readonly) UIScrollView* webScrollView;
+@property(nonatomic, readonly) UIScrollView* webScrollView;
 // The current page state of the web view. Writing to this property
 // asynchronously applies the passed value to the current web view.
 @property(nonatomic, readwrite) web::PageDisplayState pageDisplayState;
 // The currently displayed native controller, if any.
-@property(nonatomic, strong) id<CRWNativeContent> nativeController;
+@property(nonatomic, readwrite) id<CRWNativeContent> nativeController;
 // Returns NavigationManager's session controller.
-@property(nonatomic, strong, readonly) CRWSessionController* sessionController;
+@property(nonatomic, readonly) CRWSessionController* sessionController;
 // Activity indicator group ID for this web controller.
-@property(nonatomic, copy, readonly) NSString* activityIndicatorGroupID;
-// List of keypaths observed on WKWebView. All KVO-observed keypaths have to
-// be added to this list.
-@property(nonatomic, strong, readonly) NSArray* observedKeyPaths;
+@property(nonatomic, readonly) NSString* activityIndicatorGroupID;
+// Dictionary where keys are the names of WKWebView properties and values are
+// selector names which should be called when a corresponding property has
+// changed. e.g. @{ @"URL" : @"webViewURLDidChange" } means that
+// -[self webViewURLDidChange] must be called every time when WKWebView.URL is
+// changed.
+@property(nonatomic, readonly) NSDictionary* WKWebViewObservers;
 // Downloader for PassKit files. Lazy initialized.
-@property(nonatomic, strong, readonly) CRWPassKitDownloader* passKitDownloader;
+@property(nonatomic, readonly) CRWPassKitDownloader* passKitDownloader;
 
 // The web view's view of the current URL. During page transitions
 // this may not be the same as the session history's view of the current URL.
 // This method can change the state of the CRWWebController, as it will display
 // an error if the returned URL is not reliable from a security point of view.
 // Note that this method is expensive, so it should always be cached locally if
 // it's needed multiple times in a method.
 @property(nonatomic, readonly) GURL currentURL;
 // Returns the referrer for the current page.
 @property(nonatomic, readonly) web::Referrer currentReferrer;
@@ skipping 508 matching lines @@
 const NSTimeInterval kSnapshotOverlayTransition = 0.5;
 
 }  // namespace
 
 @implementation CRWWebController
 
 @synthesize webUsageEnabled = _webUsageEnabled;
 @synthesize usePlaceholderOverlay = _usePlaceholderOverlay;
 @synthesize loadPhase = _loadPhase;
 @synthesize shouldSuppressDialogs = _shouldSuppressDialogs;
-@synthesize delegate = _delegate;
-@synthesize UIDelegate = _UIDelegate;
-@synthesize nativeProvider = _nativeProvider;
-@synthesize swipeRecognizerProvider = _swipeRecognizerProvider;
 
 - (instancetype)initWithWebState:(WebStateImpl*)webState {
   self = [super init];
   if (self) {
     _webStateImpl = webState;
     DCHECK(_webStateImpl);
     _webStateImpl->InitializeRequestTracker(self);
     // Load phase when no WebView present is 'loaded' because this represents
     // the idle state.
     _loadPhase = web::PAGE_LOADED;
@@ skipping 14 matching lines @@
         new CertVerificationErrorsCacheType(kMaxCertErrorsCount));
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(orientationDidChange)
                name:UIApplicationDidChangeStatusBarOrientationNotification
              object:nil];
   }
   return self;
 }
 
+- (id<CRWNativeContentProvider>)nativeProvider {
+  return _nativeProvider.get();
+}
+
+- (void)setNativeProvider:(id<CRWNativeContentProvider>)nativeProvider {
+  _nativeProvider.reset(nativeProvider);
+}
+
+- (id<CRWSwipeRecognizerProvider>)swipeRecognizerProvider {
+  return _swipeRecognizerProvider.get();
+}
+
+- (void)setSwipeRecognizerProvider:
+    (id<CRWSwipeRecognizerProvider>)swipeRecognizerProvider {
+  _swipeRecognizerProvider.reset(swipeRecognizerProvider);
+}
+
 - (WebState*)webState {
   return _webStateImpl;
 }
 
 - (WebStateImpl*)webStateImpl {
   return _webStateImpl;
 }
 
 - (void)clearTransientContentView {
   // Early return if there is no transient content view.
@@ skipping 10 matching lines @@
 
 - (void)showTransientContentView:(CRWContentView*)contentView {
   DCHECK(contentView);
   DCHECK(contentView.scrollView);
   // TODO(crbug.com/556848) Reenable DCHECK when |CRWWebControllerContainerView|
   // is restructured so that subviews are not added during |layoutSubviews|.
   // DCHECK([contentView.scrollView isDescendantOfView:contentView]);
   [_containerView displayTransientContent:contentView];
 }
 
+- (id<CRWWebDelegate>)delegate {
+  return _delegate.get();
+}
 
 - (void)setDelegate:(id<CRWWebDelegate>)delegate {
-  _delegate = delegate;
+  _delegate.reset(delegate);
   if ([self.nativeController respondsToSelector:@selector(setDelegate:)]) {
     if ([_delegate respondsToSelector:@selector(webController:titleDidChange:)])
       [self.nativeController setDelegate:self];
     else
       [self.nativeController setDelegate:nil];
   }
 }
 
+- (id<CRWWebUserInterfaceDelegate>)UIDelegate {
+  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(!_webView);
   [_containerView setDelegate:nil];
   _touchTrackingRecognizer.get().touchTrackingDelegate = nil;
   [[_webViewProxy scrollViewProxy] removeObserver:self];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [super dealloc];
 }
 
 - (void)dismissKeyboard {
   [_webView endEditing:YES];
   if ([self.nativeController respondsToSelector:@selector(dismissKeyboard)])
     [self.nativeController dismissKeyboard];
 }
 
 - (id<CRWNativeContent>)nativeController {
   return [_containerView nativeController];
@@ skipping 11 matching lines @@
   [_containerView displayNativeContent:nativeController];
   [self setNativeControllerWebUsageEnabled:_webUsageEnabled];
 }
 
 - (NSString*)activityIndicatorGroupID {
   return [NSString
       stringWithFormat:@"WebController.NetworkActivityIndicatorKey.%@",
                        self.webStateImpl->GetRequestGroupID()];
 }
 
-- (NSArray*)observedKeyPaths {
-  return @[
-    @"certificateChain", @"estimatedProgress", @"hasOnlySecureContent",
-    @"loading", @"title", @"URL"
-  ];
+- (NSDictionary*)WKWebViewObservers {
+  return @{
+    @"certificateChain" : @"webViewSecurityFeaturesDidChange",
+    @"estimatedProgress" : @"webViewEstimatedProgressDidChange",
+    @"hasOnlySecureContent" : @"webViewSecurityFeaturesDidChange",
+    @"loading" : @"webViewLoadingStateDidChange",
+    @"title" : @"webViewTitleDidChange",
+    @"URL" : @"webViewURLDidChange",
+  };
 }
 
 // NativeControllerDelegate method, called to inform that title has changed.
 - (void)nativeContent:(id)content titleDidChange:(NSString*)title {
   // Responsiveness to delegate method was checked in setDelegate:.
   [_delegate webController:self titleDidChange:title];
 }
 
 - (void)setNativeControllerWebUsageEnabled:(BOOL)webUsageEnabled {
   if ([self.nativeController
@@ skipping 125 matching lines @@
 - (void)showContextMenu:(UIGestureRecognizer*)gestureRecognizer {
   // We don't want ongoing notification that the long press is held.
   if ([gestureRecognizer state] != UIGestureRecognizerStateBegan)
     return;
 
   if (![_DOMElementForLastTouch count])
     return;
 
   web::ContextMenuParams params =
       [self contextMenuParamsForElement:_DOMElementForLastTouch.get()];
-  params.view.reset(_webView);
+  params.view.reset([_webView retain]);
   params.location = [gestureRecognizer locationInView:_webView];
   if (self.webStateImpl->HandleContextMenu(params)) {
     // Cancelling all touches has the intended side effect of suppressing the
     // system's context menu.
     [self cancelAllTouches];
   }
 }
 
 - (void)cancelAllTouches {
   // Disable web view scrolling.
@@ skipping 22 matching lines @@
 
   if (!defaultImage) {
     CGRect frame = CGRectMake(0, 0, 2, 2);
     UIGraphicsBeginImageContext(frame.size);
     [[UIColor whiteColor] setFill];
     CGContextFillRect(UIGraphicsGetCurrentContext(), frame);
 
     UIImage* result = UIGraphicsGetImageFromCurrentImageContext();
     UIGraphicsEndImageContext();
 
-    defaultImage = [result stretchableImageWithLeftCapWidth:1 topCapHeight:1];
+    defaultImage =
+        [[result stretchableImageWithLeftCapWidth:1 topCapHeight:1] retain];
   }
   return defaultImage;
 }
 
 - (BOOL)canGoBack {
   return _webStateImpl->GetNavigationManagerImpl().CanGoBack();
 }
 
 - (BOOL)canGoForward {
   return _webStateImpl->GetNavigationManagerImpl().CanGoForward();
@@ skipping 217 matching lines @@
     if (iRecognizer != recognizer) {
       NSString* description = [iRecognizer description];
       if ([description rangeOfString:fragment].length) {
         [iRecognizer requireGestureRecognizerToFail:recognizer];
         // requireGestureRecognizerToFail: doesn't retain the recognizer, so it
         // is possible for |iRecognizer| to outlive |recognizer| and end up with
         // a dangling pointer. Add a retaining associative reference to ensure
         // that the lifetimes work out.
         // Note that normally using the value as the key wouldn't make any
         // sense, but here it's fine since nothing needs to look up the value.
-        objc_setAssociatedObject(view, (__bridge void*)recognizer, recognizer,
+        objc_setAssociatedObject(view, recognizer, recognizer,
                                  OBJC_ASSOCIATION_RETAIN_NONATOMIC);
       }
     }
   }
 }
 
 - (CRWWebController*)createChildWebController {
   CRWWebController* result = [self.delegate webPageOrderedOpen];
   DCHECK(!result || result.sessionController.openedByDOM);
   return result;
@@ skipping 191 matching lines @@
     [script
         appendString:[self javaScriptToDispatchPopStateWithObject:stateObject]];
   }
   if (dispatchHashChange) {
     web::NavigationItemImpl* previousItem =
         self.sessionController.previousEntry.navigationItemImpl;
     const GURL oldURL = previousItem ? previousItem->GetURL() : GURL();
     [script appendString:[self javaScriptToDispatchHashChangeWithOldURL:oldURL
                                                                  newURL:URL]];
   }
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   [self executeJavaScript:script
         completionHandler:^(id, NSError*) {
-          base::scoped_nsobject<CRWWebController> strongSelf(weakSelf);
-          if (!strongSelf || strongSelf.get()->_isBeingDestroyed)
+          if (!weakSelf || weakSelf.get()->_isBeingDestroyed)
             return;
+          base::scoped_nsobject<CRWWebController> strongSelf([weakSelf retain]);
           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]);
 
@@ skipping 460 matching lines @@
 
   if (delta >= 0 || !_webStateImpl->IsShowingWebInterstitial()) {
     [self recordStateInHistory];
   }
 
   CRWSessionController* sessionController =
       _webStateImpl->GetNavigationManagerImpl().GetSessionController();
   // fromEntry is retained because it has the potential to be released
   // by goDelta: if it has not been committed.
   base::scoped_nsobject<CRWSessionEntry> fromEntry(
-      [sessionController currentEntry]);
+      [[sessionController currentEntry] retain]);
   [sessionController goDelta:delta];
   if (fromEntry) {
     [self finishHistoryNavigationFromEntry:fromEntry];
   }
 }
 
 - (BOOL)isLoaded {
   return _loadPhase == web::PAGE_LOADED;
 }
 
@@ skipping 174 matching lines @@
         _webStateImpl->GetMojoInterfaceRegistry();
     _mojoFacade.reset(new web::MojoFacade(interfaceProvider, self));
   }
   return _mojoFacade.get();
 }
 
 - (CRWPassKitDownloader*)passKitDownloader {
   if (_passKitDownloader) {
     return _passKitDownloader.get();
   }
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   web::PassKitCompletionHandler passKitCompletion = ^(NSData* data) {
-    base::scoped_nsobject<CRWWebController> strongSelf(weakSelf);
+    base::scoped_nsobject<CRWWebController> strongSelf([weakSelf retain]);
     if (!strongSelf) {
       return;
     }
     // Cancel load to update web state, since the PassKit download happens
     // through a separate flow. This follows the same flow as when PassKit is
     // downloaded through UIWebView.
     [strongSelf loadCancelled];
     SEL didLoadPassKitObject = @selector(webController:didLoadPassKitObject:);
     id<CRWWebDelegate> delegate = [strongSelf delegate];
     if ([delegate respondsToSelector:didLoadPassKitObject]) {
@@ skipping 596 matching lines @@
   // TODO(crbug.com/549301): Improve transition detection.
   ui::PageTransition transition = self.userInteractionRegistered
                                       ? ui::PAGE_TRANSITION_LINK
                                       : ui::PAGE_TRANSITION_CLIENT_REDIRECT;
   [self pushStateWithPageURL:pushURL
                  stateObject:stateObject
                   transition:transition];
 
   NSString* replaceWebViewJS =
       [self javaScriptToReplaceWebViewURL:pushURL stateObjectJSON:stateObject];
-  __weak CRWWebController* weakSelf = self;
-  [self executeJavaScript:replaceWebViewJS
-        completionHandler:^(id, NSError*) {
-          base::scoped_nsobject<CRWWebController> strongSelf(weakSelf);
-          if (!strongSelf || strongSelf.get()->_isBeingDestroyed)
-            return;
-          [strongSelf optOutScrollsToTopForSubviews];
-          // Notify the observers.
-          strongSelf.get()->_webStateImpl->OnHistoryStateChanged();
-          [strongSelf didFinishNavigation];
-        }];
-
+  base::WeakNSObject<CRWWebController> weakSelf(self);
+  [self executeJavaScript:replaceWebViewJS completionHandler:^(id, NSError*) {
+    if (!weakSelf || weakSelf.get()->_isBeingDestroyed)
+      return;
+    base::scoped_nsobject<CRWWebController> strongSelf([weakSelf retain]);
+    [strongSelf optOutScrollsToTopForSubviews];
+    // Notify the observers.
+    strongSelf.get()->_webStateImpl->OnHistoryStateChanged();
+    [strongSelf didFinishNavigation];
+  }];
   return YES;
 }
 
 - (BOOL)handleWindowHistoryDidReplaceStateMessage:
     (base::DictionaryValue*)message
                                           context:(NSDictionary*)context {
   DCHECK(_changingHistoryState);
   _changingHistoryState = NO;
 
   std::string pageURL;
@@ skipping 29 matching lines @@
   if (!message->GetString("stateObject", &stateObjectJSON)) {
     DLOG(WARNING) << "JS message parameter not found: stateObject";
     return NO;
   }
   NSString* stateObject = base::SysUTF8ToNSString(stateObjectJSON);
   _URLOnStartLoading = replaceURL;
   _lastRegisteredRequestURL = replaceURL;
   [self replaceStateWithPageURL:replaceURL stateObject:stateObject];
   NSString* replaceStateJS = [self javaScriptToReplaceWebViewURL:replaceURL
                                                  stateObjectJSON:stateObject];
-  __weak CRWWebController* weakSelf = self;
-  [self executeJavaScript:replaceStateJS
-        completionHandler:^(id, NSError*) {
-          base::scoped_nsobject<CRWWebController> strongSelf(weakSelf);
-          if (!strongSelf || strongSelf.get()->_isBeingDestroyed)
-            return;
-          [strongSelf didFinishNavigation];
-        }];
+  base::WeakNSObject<CRWWebController> weakSelf(self);
+  [self executeJavaScript:replaceStateJS completionHandler:^(id, NSError*) {
+    if (!weakSelf || weakSelf.get()->_isBeingDestroyed)
+      return;
+    base::scoped_nsobject<CRWWebController> strongSelf([weakSelf retain]);
+    [strongSelf didFinishNavigation];
+  }];
   return YES;
 }
 
 #pragma mark -
 
 - (BOOL)wantsKeyboardShield {
   if ([self.nativeController
           respondsToSelector:@selector(wantsKeyboardShield)]) {
     return [self.nativeController wantsKeyboardShield];
   }
@@ skipping 395 matching lines @@
        shouldReceiveTouch:(UITouch*)touch {
   // Expect only _contextMenuRecognizer.
   DCHECK([gestureRecognizer isEqual:_contextMenuRecognizer]);
 
   // 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:nil];
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   [self fetchDOMElementAtPoint:[touch locationInView:_webView]
              completionHandler:^(NSDictionary* element) {
                [weakSelf setDOMElementForLastTouch:element];
              }];
   return YES;
 }
 
 - (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer*)gestureRecognizer {
   // Expect only _contextMenuRecognizer.
   DCHECK([gestureRecognizer isEqual:_contextMenuRecognizer]);
@@ skipping 94 matching lines @@
   return [_delegate webController:self
           shouldBlockPopupWithURL:popupURL
                         sourceURL:sourceURL];
 }
 
 - (void)openPopupWithInfo:(const web::NewWindowInfo&)windowInfo {
   const GURL url(windowInfo.url);
   const GURL currentURL([self currentNavigationURL]);
   NSString* windowName = windowInfo.window_name.get();
   web::Referrer referrer(currentURL, windowInfo.referrer_policy);
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   void (^showPopupHandler)() = ^{
     CRWWebController* child = [[weakSelf delegate] webPageOrderedOpen:url
                                                              referrer:referrer
                                                            windowName:windowName
                                                          inBackground:NO];
     DCHECK(!child || child.sessionController.openedByDOM);
   };
 
   BOOL showPopup = windowInfo.user_is_interacting ||
                    (![self shouldBlockPopupWithURL:url sourceURL:currentURL]);
@@ skipping 294 matching lines @@
   return [self currentSessionEntry].navigationItem->GetHttpRequestHeaders();
 }
 
 #pragma mark -
 #pragma mark CRWWebViewScrollViewProxyObserver
 
 - (void)webViewScrollViewDidZoom:
         (CRWWebViewScrollViewProxy*)webViewScrollViewProxy {
   _pageHasZoomed = YES;
 
-  __weak UIScrollView* weakScrollView = self.webScrollView;
+  base::WeakNSObject<UIScrollView> weakScrollView(self.webScrollView);
   [self extractViewportTagWithCompletion:^(
             const web::PageViewportState* viewportState) {
     if (!weakScrollView)
       return;
-    base::scoped_nsobject<UIScrollView> scrollView(weakScrollView);
+    base::scoped_nsobject<UIScrollView> scrollView([weakScrollView retain]);
     if (viewportState && !viewportState->viewport_tag_present() &&
         [scrollView minimumZoomScale] == [scrollView maximumZoomScale] &&
         [scrollView zoomScale] > 1.0) {
       UMA_HISTOGRAM_BOOLEAN(kUMAViewportZoomBugCount, true);
     }
   }];
 }
 
 - (void)webViewScrollViewDidResetContentSize:
     (CRWWebViewScrollViewProxy*)webViewScrollViewProxy {
@@ skipping 94 matching lines @@
 - (void)extractViewportTagWithCompletion:(ViewportStateCompletion)completion {
   DCHECK(completion);
   web::NavigationItem* currentItem = [self currentNavItem];
   if (!currentItem) {
     completion(nullptr);
     return;
   }
   NSString* const kViewportContentQuery =
       @"var viewport = document.querySelector('meta[name=\"viewport\"]');"
        "viewport ? viewport.content : '';";
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   int itemID = currentItem->GetUniqueID();
   [self executeJavaScript:kViewportContentQuery
         completionHandler:^(id viewportContent, NSError*) {
           web::NavigationItem* item = [weakSelf currentNavItem];
           if (item && item->GetUniqueID() == itemID) {
             web::PageViewportState viewportState(
                 base::mac::ObjCCast<NSString>(viewportContent));
             completion(&viewportState);
           } else {
             completion(nullptr);
@@ skipping 28 matching lines @@
   displayState.zoom_state().set_zoom_scale(
       displayState.zoom_state().minimum_zoom_scale() +
       zoomPercentage * displayState.zoom_state().GetMinMaxZoomDifference());
   currentItem->SetPageDisplayState(displayState);
   [self applyPageDisplayState:currentItem->GetPageDisplayState()];
 }
 
 - (void)applyPageDisplayState:(const web::PageDisplayState&)displayState {
   if (!displayState.IsValid())
     return;
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   web::PageDisplayState displayStateCopy = displayState;
   [self extractViewportTagWithCompletion:^(
             const web::PageViewportState* viewportState) {
     if (viewportState) {
       [weakSelf applyPageDisplayState:displayStateCopy
                          userScalable:viewportState->user_scalable()];
     }
   }];
 }
 
@@ skipping 68 matching lines @@
     (const web::PageScrollState&)scrollState {
   DCHECK(scrollState.IsValid());
   CGPoint scrollOffset =
       CGPointMake(scrollState.offset_x(), scrollState.offset_y());
   if (_loadPhase == web::PAGE_LOADED) {
     // If the page is loaded, update the scroll immediately.
     [self.webScrollView setContentOffset:scrollOffset];
   } else {
     // If the page isn't loaded, store the action to update the scroll
     // when the page finishes loading.
-    __weak UIScrollView* weakScrollView = self.webScrollView;
+    base::WeakNSObject<UIScrollView> weakScrollView(self.webScrollView);
     base::scoped_nsprotocol<ProceduralBlock> action([^{
       [weakScrollView setContentOffset:scrollOffset];
     } copy]);
     [_pendingLoadCompleteActions addObject:action];
   }
 }
 
 #pragma mark -
 #pragma mark Web Page Features
 
 - (void)fetchWebPageWidthWithCompletionHandler:(void (^)(CGFloat))handler {
   if (!_webView) {
     handler(0);
     return;
   }
 
   [self executeJavaScript:@"__gCrWeb.getPageWidth();"
         completionHandler:^(id pageWidth, NSError*) {
           handler([base::mac::ObjCCastStrict<NSNumber>(pageWidth) floatValue]);
         }];
 }
 
 - (void)fetchDOMElementAtPoint:(CGPoint)point
              completionHandler:(void (^)(NSDictionary*))handler {
   DCHECK(handler);
   // Convert point into web page's coordinate system (which may be scaled and/or
   // scrolled).
   CGPoint scrollOffset = self.scrollPosition;
   CGFloat webViewContentWidth = self.webScrollView.contentSize.width;
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   [self fetchWebPageWidthWithCompletionHandler:^(CGFloat pageWidth) {
     CGFloat scale = pageWidth / webViewContentWidth;
     CGPoint localPoint = CGPointMake((point.x + scrollOffset.x) * scale,
                                      (point.y + scrollOffset.y) * scale);
     NSString* const kGetElementScript =
         [NSString stringWithFormat:@"__gCrWeb.getElementFromPoint(%g, %g);",
                                    localPoint.x, localPoint.y];
     [weakSelf executeJavaScript:kGetElementScript
               completionHandler:^(id element, NSError*) {
                 handler(base::mac::ObjCCastStrict<NSDictionary>(element));
@@ skipping 11 matching lines @@
       title = @"JavaScript";
     } else {
       base::string16 URLText = url_formatter::FormatUrl(params.link_url);
       title = base::SysUTF16ToNSString(URLText);
     }
   }
   NSString* src = element[@"src"];
   if (src) {
     params.src_url = GURL(base::SysNSStringToUTF8(src));
     if (!title)
-      title = [src copy];
+      title = [[src copy] autorelease];
     if ([title hasPrefix:base::SysUTF8ToNSString(url::kDataScheme)])
       title = nil;
   }
   NSString* titleAttribute = element[@"title"];
   if (titleAttribute)
     title = titleAttribute;
   if (title) {
     params.menu_title.reset([title copy]);
   }
   NSString* referrerPolicy = element[@"referrerPolicy"];
@@ skipping 54 matching lines @@
     [_delegate webControllerDidSuppressDialog:self];
 }
 
 - (void)didBlockPopupWithURL:(GURL)popupURL
                    sourceURL:(GURL)sourceURL
               referrerPolicy:(const std::string&)referrerPolicyString {
   web::ReferrerPolicy referrerPolicy =
       web::ReferrerPolicyFromString(referrerPolicyString);
   web::Referrer referrer(sourceURL, referrerPolicy);
   NSString* const kWindowName = @"";  // obsoleted
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   void (^showPopupHandler)() = ^{
     // On Desktop cross-window comunication is not supported for unblocked
     // popups; so it's ok to create a new independent page.
     CRWWebController* child =
         [[weakSelf delegate] webPageOrderedOpen:popupURL
                                        referrer:referrer
                                      windowName:kWindowName
                                    inBackground:NO];
     DCHECK(!child || child.sessionController.openedByDOM);
   };
 
   web::BlockedPopupInfo info(popupURL, referrer, kWindowName, showPopupHandler);
   [self.delegate webController:self didBlockPopup:info];
 }
 
 - (void)didBlockPopupWithURL:(GURL)popupURL sourceURL:(GURL)sourceURL {
   if ([_delegate respondsToSelector:@selector(webController:didBlockPopup:)]) {
-    __weak CRWWebController* weakSelf = self;
+    base::WeakNSObject<CRWWebController> weakSelf(self);
     dispatch_async(dispatch_get_main_queue(), ^{
       [self queryPageReferrerPolicy:^(NSString* policy) {
         [weakSelf didBlockPopupWithURL:popupURL
                              sourceURL:sourceURL
                         referrerPolicy:base::SysNSStringToUTF8(policy)];
       }];
     });
   }
 }
 
@@ skipping 245 matching lines @@
     [_containerView addToolbars:_webViewToolbars];
 
     base::scoped_nsobject<CRWWebViewContentView> webViewContentView(
         [[CRWWebViewContentView alloc] initWithWebView:_webView
                                             scrollView:self.webScrollView]);
     [_containerView displayWebViewContentView:webViewContentView];
   }
 }
 
 - (WKWebView*)createWebViewWithConfiguration:(WKWebViewConfiguration*)config {
-  return web::CreateWKWebView(CGRectZero, config,
-                              self.webStateImpl->GetBrowserState(),
-                              [self useDesktopUserAgent]);
+  return [web::CreateWKWebView(CGRectZero, config,
+                               self.webStateImpl->GetBrowserState(),
+                               [self useDesktopUserAgent]) autorelease];
 }
 
 - (void)setWebView:(WKWebView*)webView {
   DCHECK_NE(_webView.get(), webView);
 
   // Unwind the old web view.
   // TODO(eugenebut): Remove CRWWKScriptMessageRouter once crbug.com/543374 is
   // fixed.
   CRWWKScriptMessageRouter* messageRouter =
       [self webViewConfigurationProvider].GetScriptMessageRouter();
   if (_webView) {
     [messageRouter removeAllScriptMessageHandlersForWebView:_webView];
   }
   [_webView setNavigationDelegate:nil];
   [_webView setUIDelegate:nil];
-  for (NSString* keyPath in self.observedKeyPaths) {
+  for (NSString* keyPath in self.WKWebViewObservers) {
     [_webView removeObserver:self forKeyPath:keyPath];
   }
   [self clearActivityIndicatorTasks];
 
-  _webView.reset(webView);
+  _webView.reset([webView retain]);
 
   // Set up the new web view.
   if (webView) {
-    __weak CRWWebController* weakSelf = self;
+    base::WeakNSObject<CRWWebController> weakSelf(self);
     [messageRouter setScriptMessageHandler:^(WKScriptMessage* message) {
       [weakSelf didReceiveScriptMessage:message];
     }
                                       name:kScriptMessageName
                                    webView:webView];
     _windowIDJSManager.reset(
         [[CRWJSWindowIDManager alloc] initWithWebView:webView]);
   } else {
     _windowIDJSManager.reset();
   }
   [_webView setNavigationDelegate:self];
   [_webView setUIDelegate:self];
-  for (NSString* keyPath in self.observedKeyPaths) {
+  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 (!_webView)
     return;
 
@@ skipping 35 matching lines @@
   // This happens during tests.
   if (!_webView) {
     return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
   }
 
   std::string MIMEType = self.webState->GetContentsMimeType();
   return [self documentTypeFromMIMEType:base::SysUTF8ToNSString(MIMEType)];
 }
 
 - (void)loadRequest:(NSMutableURLRequest*)request {
-  _latestWKNavigation.reset([_webView loadRequest:request]);
+  _latestWKNavigation.reset([[_webView loadRequest:request] retain]);
 }
 
 - (void)loadPOSTRequest:(NSMutableURLRequest*)request {
   if (!_POSTRequestLoader) {
     _POSTRequestLoader.reset([[CRWJSPOSTRequestLoader alloc] init]);
   }
 
   CRWWKScriptMessageRouter* messageRouter =
       [self webViewConfigurationProvider].GetScriptMessageRouter();
 
@@ skipping 25 matching lines @@
 - (void)loadHTML:(NSString*)HTML forAppSpecificURL:(const GURL&)URL {
   CHECK(web::GetWebClient()->IsAppSpecificURL(URL));
   [self loadHTML:HTML forURL:URL];
 }
 
 - (void)loadHTMLForCurrentURL:(NSString*)HTML {
   [self loadHTML:HTML forURL:self.currentURL];
 }
 
 - (void)stopLoading {
-  _stoppedWKNavigation = _latestWKNavigation;
+  _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];
   // 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]]) {
@@ skipping 276 matching lines @@
         [self loadWithParams:params];
       }
       return;
     } else {
       [self registerLoadRequest:webViewURL];
     }
   }
   // Ensure the URL is registered and loadPhase is as expected.
   DCHECK(_lastRegisteredRequestURL == webViewURL);
   DCHECK(self.loadPhase == web::LOAD_REQUESTED);
-  _latestWKNavigation.reset(navigation);
+  _latestWKNavigation.reset([navigation retain]);
 }
 
 - (void)webView:(WKWebView*)webView
     didReceiveServerRedirectForProvisionalNavigation:(WKNavigation*)navigation {
   [self registerLoadRequest:net::GURLWithNSURL(webView.URL)
                    referrer:[self currentReferrer]
                  transition:ui::PAGE_TRANSITION_SERVER_REDIRECT];
 }
 
 - (void)webView:(WKWebView*)webView
@@ skipping 128 matching lines @@
   }
 
   if (![authMethod isEqual:NSURLAuthenticationMethodServerTrust]) {
     completionHandler(NSURLSessionAuthChallengeRejectProtectionSpace, nil);
     return;
   }
 
   SecTrustRef trust = challenge.protectionSpace.serverTrust;
   base::ScopedCFTypeRef<SecTrustRef> scopedTrust(trust,
                                                  base::scoped_policy::RETAIN);
-  __weak CRWWebController* weakSelf = self;
+  base::WeakNSObject<CRWWebController> weakSelf(self);
   [_certVerificationController
       decideLoadPolicyForTrust:scopedTrust
                           host:challenge.protectionSpace.host
              completionHandler:^(web::CertAcceptPolicy policy,
                                  net::CertStatus status) {
-               base::scoped_nsobject<CRWWebController> strongSelf(weakSelf);
+               base::scoped_nsobject<CRWWebController> strongSelf(
+                   [weakSelf retain]);
                if (!strongSelf) {
                  completionHandler(
                      NSURLSessionAuthChallengeRejectProtectionSpace, nil);
                  return;
                }
                [strongSelf processAuthChallenge:challenge
                             forCertAcceptPolicy:policy
                                      certStatus:status
                               completionHandler:completionHandler];
              }];
@@ skipping 25 matching lines @@
   }
 }
 
 #pragma mark -
 #pragma mark KVO Observation
 
 - (void)observeValueForKeyPath:(NSString*)keyPath
                       ofObject:(id)object
                         change:(NSDictionary*)change
                        context:(void*)context {
-  // All observed keypaths have to be present in |self.observedKeyPaths|.
-  DCHECK([self.observedKeyPaths containsObject:keyPath]);
-  if ([keyPath isEqualToString:@"certificateChain"]) {
-    [self webViewSecurityFeaturesDidChange];
-  } else if ([keyPath isEqualToString:@"estimatedProgress"]) {
-    [self webViewEstimatedProgressDidChange];
-  } else if ([keyPath isEqualToString:@"hasOnlySecureContent"]) {
-    [self webViewSecurityFeaturesDidChange];
-  } else if ([keyPath isEqualToString:@"loading"]) {
-    [self webViewLoadingStateDidChange];
-  } else if ([keyPath isEqualToString:@"title"]) {
-    [self webViewTitleDidChange];
-  } else if ([keyPath isEqualToString:@"URL"]) {
-    [self webViewURLDidChange];
-  } else {
-    NOTREACHED();
-  }
+  NSString* dispatcherSelectorName = self.WKWebViewObservers[keyPath];
+  DCHECK(dispatcherSelectorName);
+  if (dispatcherSelectorName)
+    [self performSelector:NSSelectorFromString(dispatcherSelectorName)];
 }
 
 - (void)webViewEstimatedProgressDidChange {
   if (!_isBeingDestroyed) {
     self.webStateImpl->SendChangeLoadProgress([_webView estimatedProgress]);
   }
 }
 
 - (void)webViewSecurityFeaturesDidChange {
   if (self.loadPhase == web::LOAD_REQUESTED) {
@@ skipping 371 matching lines @@
   }
 
   return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
 }
 
 - (NSString*)refererFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:@"Referer"];
 }
 
 @end