[ObjC ARC] Converts ios/web:web 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 <vector>
 
 #include "base/callback.h"
 #include "base/containers/mru_cache.h"
 #import "base/ios/block_types.h"
 #include "base/ios/ios_util.h"
 #import "base/ios/ns_error_util.h"
-#import "base/ios/weak_nsobject.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
-#import "base/mac/objc_property_releaser.h"
 #include "base/mac/scoped_cftyperef.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.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"
 #import "ios/net/http_response_headers_util.h"
@@ skipping 59 matching lines @@
 #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 "net/cert/x509_util_ios.h"
 #include "net/ssl/ssl_info.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 {
 
 // Struct to capture data about a user interaction. Records the time of the
 // interaction and the main document URL at that time.
@@ skipping 78 matching lines @@
 // Utility function for getting the source of NSErrors received by WKWebViews.
 WKWebViewErrorSource WKWebViewErrorSourceFromError(NSError* error) {
   DCHECK(error);
   return static_cast<WKWebViewErrorSource>(
       [error.userInfo[kWKWebViewErrorSourceKey] integerValue]);
 }
 // Utility function for converting the WKWebViewErrorSource to the NSError
 // received by WKWebViews.
 NSError* WKWebViewErrorWithSource(NSError* error, WKWebViewErrorSource source) {
   DCHECK(error);
-  base::scoped_nsobject<NSMutableDictionary> userInfo(
-      [error.userInfo mutableCopy]);
+  NSMutableDictionary* userInfo = [error.userInfo mutableCopy];
   [userInfo setObject:@(source) forKey:kWKWebViewErrorSourceKey];
   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 {
-  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 ()<CRWContextMenuDelegate,
                                CRWNativeContentDelegate,
                                CRWSSLStatusUpdaterDataSource,
                                CRWSSLStatusUpdaterDelegate,
                                CRWWebControllerContainerViewDelegate,
                                CRWWebViewScrollViewProxyObserver,
                                WKNavigationDelegate,
                                WKUIDelegate> {
-  base::WeakNSProtocol<id<CRWWebDelegate>> _delegate;
-  base::WeakNSProtocol<id<CRWNativeContentProvider>> _nativeProvider;
-  base::WeakNSProtocol<id<CRWSwipeRecognizerProvider>> _swipeRecognizerProvider;
+  __weak id<CRWWebDelegate> _delegate;
+  __weak id<CRWNativeContentProvider> _nativeProvider;
+  __weak id<CRWSwipeRecognizerProvider> _swipeRecognizerProvider;
   // The WKWebView managed by this instance.
-  base::scoped_nsobject<WKWebView> _webView;
+  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;
+  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;
+  CRWWebControllerContainerView* _containerView;
   // If |_contentView| contains a native view rather than a web view, this
   // is its controller. If it's a web view, this is nil.
-  base::scoped_nsprotocol<id<CRWNativeContent>> _nativeController;
+  id<CRWNativeContent> _nativeController;
   BOOL _isHalted;  // YES if halted. Halting happens prior to destruction.
   BOOL _isBeingDestroyed;  // YES if in the process of closing.
   // All CRWWebControllerObservers attached to the CRWWebController. A
   // specially-constructed set is used that does not retain its elements.
-  base::scoped_nsobject<NSMutableSet> _observers;
+  NSMutableSet* _observers;
   // 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.
   std::vector<std::unique_ptr<web::WebControllerObserverBridge>>
       _observerBridges;
   // 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
@@ skipping 12 matching lines @@
   // Page loading phase.
   web::LoadPhase _loadPhase;
   // The web::PageDisplayState recorded when the page starts loading.
   web::PageDisplayState _displayStateOnStartLoading;
   // Whether or not the page has zoomed since the current navigation has been
   // committed, either by user interaction or via |-restoreStateFromHistory|.
   BOOL _pageHasZoomed;
   // Whether a PageDisplayState is currently being applied.
   BOOL _applyingPageState;
   // Actions to execute once the page load is complete.
-  base::scoped_nsobject<NSMutableArray> _pendingLoadCompleteActions;
+  NSMutableArray* _pendingLoadCompleteActions;
   // UIGestureRecognizers to add to the web view.
-  base::scoped_nsobject<NSMutableArray> _gestureRecognizers;
+  NSMutableArray* _gestureRecognizers;
   // Toolbars to add to the web view.
-  base::scoped_nsobject<NSMutableArray> _webViewToolbars;
+  NSMutableArray* _webViewToolbars;
   // Flag to say if browsing is enabled.
   BOOL _webUsageEnabled;
   // Content view was reset due to low memory. Use the placeholder overlay on
   // next creation.
   BOOL _usePlaceholderOverlay;
   // The next time the view is requested, reload the page (using the placeholder
   // overlay until it's loaded).
   BOOL _requireReloadOnDisplay;
   // Overlay view used instead of webView.
-  base::scoped_nsobject<UIImageView> _placeholderOverlayView;
+  UIImageView* _placeholderOverlayView;
   // The touch tracking recognizer allowing us to decide if a navigation is
   // started by the user.
-  base::scoped_nsobject<CRWTouchTrackingRecognizer> _touchTrackingRecognizer;
+  CRWTouchTrackingRecognizer* _touchTrackingRecognizer;
   // The controller that tracks long press and check context menu trigger.
-  base::scoped_nsobject<CRWContextMenuController> _contextMenuController;
+  CRWContextMenuController* _contextMenuController;
   // Whether a click is in progress.
   BOOL _clickInProgress;
   // Data on the recorded last user interaction.
   std::unique_ptr<UserInteractionEvent> _lastUserInteraction;
   // YES if there has been user interaction with views owned by this controller.
   BOOL _userInteractedWithWebController;
   // The time of the last page transfer start, measured in seconds since Jan 1
   // 2001.
   CFAbsoluteTime _lastTransferTimeInSeconds;
   // Default URL (about:blank).
@@ skipping 10 matching lines @@
   // Set to YES on window.history.willChangeState message. To NO on
   // window.history.didPushState or window.history.didReplaceState.
   BOOL _changingHistoryState;
   // Set to YES when a hashchange event is manually dispatched for same-document
   // history navigations.
   BOOL _dispatchingSameDocumentHashChangeEvent;
   // YES if the web process backing _wkWebView is believed to currently be dead.
   BOOL _webProcessIsDead;
 
   // Object for loading POST requests with body.
-  base::scoped_nsobject<CRWJSPOSTRequestLoader> _POSTRequestLoader;
+  CRWJSPOSTRequestLoader* _POSTRequestLoader;
 
   // WebStateImpl instance associated with this CRWWebController, web controller
   // does not own this pointer.
   WebStateImpl* _webStateImpl;
 
   // A set of URLs opened in external applications; stored so that errors
   // from the web view can be identified as resulting from these events.
-  base::scoped_nsobject<NSMutableSet> _openedApplicationURL;
+  NSMutableSet* _openedApplicationURL;
 
   // A set of script managers whose scripts have been injected into the current
   // page.
   // TODO(stuartmorgan): Revisit this approach; it's intended only as a stopgap
   // measure to make all the existing script managers work. Longer term, there
   // should probably be a couple of points where managers can register to have
   // things happen automatically based on page lifecycle, and if they don't want
   // to use one of those fixed points, they should make their scripts internally
   // idempotent.
-  base::scoped_nsobject<NSMutableSet> _injectedScriptManagers;
+  NSMutableSet* _injectedScriptManagers;
 
   // Script manager for setting the windowID.
-  base::scoped_nsobject<CRWJSWindowIDManager> _windowIDJSManager;
+  CRWJSWindowIDManager* _windowIDJSManager;
 
   // The receiver of JavaScripts.
-  base::scoped_nsobject<CRWJSInjectionReceiver> _jsInjectionReceiver;
+  CRWJSInjectionReceiver* _jsInjectionReceiver;
 
   // Handles downloading PassKit data for WKWebView. Lazy initialized.
-  base::scoped_nsobject<CRWPassKitDownloader> _passKitDownloader;
+  CRWPassKitDownloader* _passKitDownloader;
 
   // Backs up property with the same name.
   std::unique_ptr<web::MojoFacade> _mojoFacade;
 
   // Referrer for the current page; does not include the fragment.
-  base::scoped_nsobject<NSString> _currentReferrerString;
+  NSString* _currentReferrerString;
 
   // Pending information for an in-progress page navigation. The lifetime of
   // this object starts at |decidePolicyForNavigationAction| where the info is
   // extracted from the request, and ends at either |didCommitNavigation| or
   // |didFailProvisionalNavigation|.
-  base::scoped_nsobject<CRWWebControllerPendingNavigationInfo>
-      _pendingNavigationInfo;
+  CRWWebControllerPendingNavigationInfo* _pendingNavigationInfo;
 
   // Holds all WKNavigation objects and their states which are currently in
   // flight.
-  base::scoped_nsobject<CRWWKNavigationStates> _navigationStates;
+  CRWWKNavigationStates* _navigationStates;
 
   // 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).
-  base::WeakNSObject<WKNavigation> _stoppedWKNavigation;
+  __weak WKNavigation* _stoppedWKNavigation;
 
   // CRWWebUIManager object for loading WebUI pages.
-  base::scoped_nsobject<CRWWebUIManager> _webUIManager;
+  CRWWebUIManager* _webUIManager;
 
   // Updates SSLStatus for current navigation item.
-  base::scoped_nsobject<CRWSSLStatusUpdater> _SSLStatusUpdater;
+  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;
+  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, readonly) WKWebView* webView;
+@property(weak, nonatomic, readonly) WKWebView* webView;
 // The scroll view of |webView|.
-@property(nonatomic, readonly) UIScrollView* webScrollView;
+@property(weak, 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, readwrite) id<CRWNativeContent> nativeController;
+@property(weak, nonatomic, readwrite) id<CRWNativeContent> nativeController;
 // Returns NavigationManager's session controller.
-@property(nonatomic, readonly) CRWSessionController* sessionController;
+@property(weak, nonatomic, readonly) CRWSessionController* sessionController;
 // The associated NavigationManagerImpl.
 @property(nonatomic, readonly) NavigationManagerImpl* navigationManagerImpl;
 // Whether the associated WebState has an opener.
 @property(nonatomic, readonly) BOOL hasOpener;
 // 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;
+@property(weak, nonatomic, readonly) NSDictionary* WKWebViewObservers;
 // Downloader for PassKit files. Lazy initialized.
-@property(nonatomic, readonly) CRWPassKitDownloader* passKitDownloader;
+@property(weak, 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 12 matching lines @@
 // TODO(crbug.com/692871): Remove these functions and replace with more
 // appropriate NavigationItem getters.
 // Returns the navigation item for the current page.
 @property(nonatomic, readonly) web::NavigationItemImpl* currentNavItem;
 // Returns the current transition type.
 @property(nonatomic, readonly) ui::PageTransition currentTransition;
 // Returns the referrer for current navigation item. May be empty.
 @property(nonatomic, readonly) web::Referrer currentNavItemReferrer;
 // The HTTP headers associated with the current navigation item. These are nil
 // unless the request was a POST.
-@property(nonatomic, readonly) NSDictionary* currentHTTPHeaders;
+@property(weak, nonatomic, readonly) NSDictionary* currentHTTPHeaders;
 
 // YES if a user interaction has been registered at any time since the page has
 // loaded.
 @property(nonatomic, readwrite) BOOL userInteractionRegistered;
 
 // Updates web view's user agent according to |userAgentType|. It is no-op if
 // |userAgentType| is NONE.
 - (void)updateWebViewUserAgentFromUserAgentType:
     (web::UserAgentType)userAgentType;
 
@@ skipping 444 matching lines @@
 - (instancetype)initWithWebState:(WebStateImpl*)webState {
   self = [super init];
   if (self) {
     _webStateImpl = webState;
     DCHECK(_webStateImpl);
     // Load phase when no WebView present is 'loaded' because this represents
     // the idle state.
     _loadPhase = web::PAGE_LOADED;
     // Content area is lazily instantiated.
     _defaultURL = GURL(url::kAboutBlankURL);
-    _jsInjectionReceiver.reset(
-        [[CRWJSInjectionReceiver alloc] initWithEvaluator:self]);
-    _webViewProxy.reset(
-        [[CRWWebViewProxyImpl alloc] initWithWebController:self]);
+    _jsInjectionReceiver =
+        [[CRWJSInjectionReceiver alloc] initWithEvaluator:self];
+    _webViewProxy = [[CRWWebViewProxyImpl alloc] initWithWebController:self];
     [[_webViewProxy scrollViewProxy] addObserver:self];
-    _gestureRecognizers.reset([[NSMutableArray alloc] init]);
-    _webViewToolbars.reset([[NSMutableArray alloc] init]);
-    _pendingLoadCompleteActions.reset([[NSMutableArray alloc] init]);
+    _gestureRecognizers = [[NSMutableArray alloc] init];
+    _webViewToolbars = [[NSMutableArray alloc] init];
+    _pendingLoadCompleteActions = [[NSMutableArray alloc] init];
     web::BrowserState* browserState = _webStateImpl->GetBrowserState();
-    _certVerificationController.reset([[CRWCertVerificationController alloc]
-        initWithBrowserState:browserState]);
+    _certVerificationController = [[CRWCertVerificationController alloc]
+        initWithBrowserState:browserState];
     _certVerificationErrors.reset(
         new CertVerificationErrorsCacheType(kMaxCertErrorsCount));
-    _navigationStates.reset([[CRWWKNavigationStates alloc] init]);
+    _navigationStates = [[CRWWKNavigationStates alloc] init];
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(orientationDidChange)
                name:UIApplicationDidChangeStatusBarOrientationNotification
              object:nil];
   }
   return self;
 }
 
 - (id<CRWNativeContentProvider>)nativeProvider {
-  return _nativeProvider.get();
+  return _nativeProvider;
 }
 
 - (void)setNativeProvider:(id<CRWNativeContentProvider>)nativeProvider {
-  _nativeProvider.reset(nativeProvider);
+  _nativeProvider = nativeProvider;
 }
 
 - (id<CRWSwipeRecognizerProvider>)swipeRecognizerProvider {
-  return _swipeRecognizerProvider.get();
+  return _swipeRecognizerProvider;
 }
 
 - (void)setSwipeRecognizerProvider:
     (id<CRWSwipeRecognizerProvider>)swipeRecognizerProvider {
-  _swipeRecognizerProvider.reset(swipeRecognizerProvider);
+  _swipeRecognizerProvider = swipeRecognizerProvider;
 }
 
 - (WebState*)webState {
   return _webStateImpl;
 }
 
 - (WebStateImpl*)webStateImpl {
   return _webStateImpl;
 }
 
@@ skipping 13 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();
+  return _delegate;
 }
 
 - (void)setDelegate:(id<CRWWebDelegate>)delegate {
-  _delegate.reset(delegate);
+  _delegate = delegate;
   if ([self.nativeController respondsToSelector:@selector(setDelegate:)])
     [self.nativeController setDelegate:self];
 }
 
 - (void)dealloc {
   DCHECK([NSThread isMainThread]);
   DCHECK(_isBeingDestroyed);  // 'close' must have been called already.
   DCHECK(!_webView);
-  [super dealloc];
 }
 
 - (void)dismissKeyboard {
   [_webView endEditing:YES];
   if ([self.nativeController respondsToSelector:@selector(dismissKeyboard)])
     [self.nativeController dismissKeyboard];
 }
 
 - (id<CRWNativeContent>)nativeController {
   return [_containerView nativeController];
@@ skipping 51 matching lines @@
   // WKWebView autoreleases its WKProcessPool on removal from superview.
   // Deferring WKProcessPool deallocation may lead to issues with cookie
   // clearing and and Browsing Data Partitioning implementation.
   @autoreleasepool {
     [self setNativeControllerWebUsageEnabled:_webUsageEnabled];
     if (enabled) {
       // Don't create the web view; let it be lazy created as needed.
     } else {
       [self clearTransientContentView];
       [self removeWebViewAllowingCachedReconstruction:YES];
-      _touchTrackingRecognizer.get().touchTrackingDelegate = nil;
-      _touchTrackingRecognizer.reset();
+      _touchTrackingRecognizer.touchTrackingDelegate = nil;
+      _touchTrackingRecognizer = nil;
       [self resetContainerView];
     }
   }
 }
 
 - (void)requirePageReconstruction {
   [self removeWebViewAllowingCachedReconstruction:NO];
 }
 
 - (void)requirePageReload {
   _requireReloadOnDisplay = YES;
 }
 
 - (void)resetContainerView {
   [_containerView removeFromSuperview];
-  _containerView.reset();
+  _containerView = nil;
 }
 
 - (void)handleLowMemory {
   [self removeWebViewAllowingCachedReconstruction:YES];
-  _touchTrackingRecognizer.get().touchTrackingDelegate = nil;
-  _touchTrackingRecognizer.reset();
+  _touchTrackingRecognizer.touchTrackingDelegate = nil;
+  _touchTrackingRecognizer = nil;
   [self resetContainerView];
   _usePlaceholderOverlay = YES;
 }
 
 - (void)reinitializeWebViewAndReload:(BOOL)reload {
   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();
+      _touchTrackingRecognizer.touchTrackingDelegate = nil;
+      _touchTrackingRecognizer = nil;
       [self resetContainerView];
     }
   }
 }
 
 - (BOOL)isViewAlive {
   return !_webProcessIsDead && [_containerView isViewAlive];
 }
 
 - (BOOL)contentIsHTML {
@@ skipping 18 matching lines @@
 
 - (void)dismissModals {
   if ([self.nativeController respondsToSelector:@selector(dismissModals)])
     [self.nativeController dismissModals];
 }
 
 // Caller must reset the delegate before calling.
 - (void)close {
   _webStateImpl->CancelDialogs();
 
-  _SSLStatusUpdater.reset();
+  _SSLStatusUpdater = nil;
 
   self.nativeProvider = nil;
   self.swipeRecognizerProvider = nil;
   if ([self.nativeController respondsToSelector:@selector(close)])
     [self.nativeController close];
 
-  base::scoped_nsobject<NSSet> observers([_observers copy]);
-  for (id it in observers.get()) {
+  NSSet* observers = [_observers copy];
+  for (id it in observers) {
     if ([it respondsToSelector:@selector(webControllerWillClose:)])
       [it webControllerWillClose:self];
   }
 
   if (!_isHalted) {
     [self terminateNetworkActivity];
   }
 
   DCHECK(!_isBeingDestroyed);
   DCHECK(!_delegate);  // Delegate should reset its association before closing.
   // Mark the destruction sequence has started, in case someone else holds a
   // strong reference and tries to continue using the tab.
   _isBeingDestroyed = YES;
 
   // Remove the web view now. Otherwise, delegate callbacks occur.
   [self removeWebViewAllowingCachedReconstruction:NO];
 
   _webStateImpl = nullptr;
 
   DCHECK(!_webView);
   // TODO(crbug.com/662860): Don't set the delegate to nil.
   [_containerView setDelegate:nil];
   if ([self.nativeController respondsToSelector:@selector(setDelegate:)]) {
     [self.nativeController setDelegate:nil];
   }
-  _touchTrackingRecognizer.get().touchTrackingDelegate = nil;
+  _touchTrackingRecognizer.touchTrackingDelegate = nil;
   [[_webViewProxy scrollViewProxy] removeObserver:self];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
 // TODO(crbug.com/661642): This code is shared with SnapshotManager. Remove this
 // and add it as part of WebDelegate delegate API such that a default image is
 // returned immediately.
 + (UIImage*)defaultSnapshotImage {
   static UIImage* defaultImage = nil;
 
   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] retain];
+    defaultImage = [result stretchableImageWithLeftCapWidth:1 topCapHeight:1];
   }
   return defaultImage;
 }
 
 - (CGPoint)scrollPosition {
   CGPoint position = CGPointMake(0.0, 0.0);
   if (!self.webScrollView)
     return position;
   return self.webScrollView.contentOffset;
 }
@@ skipping 24 matching lines @@
       return [self.nativeController virtualURL];
     } else {
       return [self.nativeController url];
     }
   }
   web::NavigationItem* item = self.currentNavItem;
   return item ? item->GetVirtualURL() : GURL::EmptyGURL();
 }
 
 - (WKWebView*)webView {
-  return _webView.get();
+  return _webView;
 }
 
 - (UIScrollView*)webScrollView {
   return [_webView scrollView];
 }
 
 - (GURL)currentURL {
   web::URLVerificationTrustLevel trustLevel =
       web::URLVerificationTrustLevel::kNone;
   return [self currentURLWithTrustLevel:&trustLevel];
@@ skipping 130 matching lines @@
 
 - (UIView*)view {
   // Kick off the process of lazily creating the view and starting the load if
   // necessary; this creates _containerView if it doesn't exist.
   [self triggerPendingLoad];
   DCHECK(_containerView);
   return _containerView;
 }
 
 - (id<CRWWebViewProxy>)webViewProxy {
-  return _webViewProxy.get();
+  return _webViewProxy;
 }
 
 - (UIView*)viewForPrinting {
   // Printing is not supported for native controllers.
   return _webView;
 }
 
 - (double)loadingProgress {
   return [_webView estimatedProgress];
 }
@@ skipping 169 matching lines @@
   if (sameDocumentNavigation) {
     [script
         appendString:[self javaScriptToDispatchPopStateWithObject:stateObject]];
   }
   if (dispatchHashChange) {
     web::NavigationItemImpl* previousItem = self.sessionController.previousItem;
     const GURL oldURL = previousItem ? previousItem->GetURL() : GURL();
     [script appendString:[self javaScriptToDispatchHashChangeWithOldURL:oldURL
                                                                  newURL:URL]];
   }
-  base::WeakNSObject<CRWWebController> weakSelf(self);
+  __weak CRWWebController* weakSelf = self;
   [self executeJavaScript:script
         completionHandler:^(id, NSError*) {
-          if (!weakSelf || weakSelf.get()->_isBeingDestroyed)
+          CRWWebController* strongSelf = weakSelf;
+          if (!strongSelf || strongSelf->_isBeingDestroyed)
             return;
-          base::scoped_nsobject<CRWWebController> strongSelf([weakSelf retain]);
-          strongSelf.get()->_URLOnStartLoading = URL;
-          strongSelf.get()->_lastRegisteredRequestURL = URL;
+          strongSelf->_URLOnStartLoading = URL;
+          strongSelf->_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]);
+  _openedApplicationURL = [[NSMutableSet alloc] init];
 
   web::NavigationItem* item = self.currentNavItem;
   GURL targetURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
   // Load the url. The UIWebView delegate callbacks take care of updating the
   // session history and UI.
   if (!targetURL.is_valid()) {
     [self didFinishWithURL:targetURL loadSuccess:NO];
     return;
   }
 
   // JavaScript should never be evaluated here. User-entered JS should be
   // evaluated via stringByEvaluatingUserJavaScriptFromString.
   DCHECK(!targetURL.SchemeIs(url::kJavaScriptScheme));
 
   [self ensureWebViewCreated];
 
   // Update web view's user agent is called for every load, which may have
   // performance implications because update web view's user agent may
   // potentially send a message to a separate thread. However, this is not an
   // issue for WKWebView because WKWebView's |setCustomUserAgent| is non-op if
   // user agent stays thesame.
   [self updateWebViewUserAgentFromUserAgentType:self.userAgentType];
 
   [self loadRequestForCurrentNavigationItem];
 }
 
 - (void)updatePendingNavigationInfoFromNavigationAction:
     (WKNavigationAction*)action {
   if (action.targetFrame.mainFrame) {
-    _pendingNavigationInfo.reset(
-        [[CRWWebControllerPendingNavigationInfo alloc] init]);
+    _pendingNavigationInfo =
+        [[CRWWebControllerPendingNavigationInfo alloc] init];
     [_pendingNavigationInfo
         setReferrer:[self referrerFromNavigationAction:action]];
     [_pendingNavigationInfo setNavigationType:action.navigationType];
     [_pendingNavigationInfo setHTTPMethod:action.request.HTTPMethod];
   }
 }
 
 - (void)updatePendingNavigationInfoFromNavigationResponse:
     (WKNavigationResponse*)response {
   if (response.isForMainFrame) {
     if (!_pendingNavigationInfo) {
-      _pendingNavigationInfo.reset(
-          [[CRWWebControllerPendingNavigationInfo alloc] init]);
+      _pendingNavigationInfo =
+          [[CRWWebControllerPendingNavigationInfo alloc] init];
     }
     [_pendingNavigationInfo setMIMEType:response.response.MIMEType];
   }
 }
 
 - (void)commitPendingNavigationInfo {
   if ([_pendingNavigationInfo referrer]) {
-    _currentReferrerString.reset([[_pendingNavigationInfo referrer] copy]);
+    _currentReferrerString = [[_pendingNavigationInfo referrer] copy];
   }
   if ([_pendingNavigationInfo MIMEType]) {
     self.webStateImpl->SetContentsMimeType(
         base::SysNSStringToUTF8([_pendingNavigationInfo MIMEType]));
   }
   [self updateCurrentBackForwardListItemHolder];
 
-  _pendingNavigationInfo.reset();
+  _pendingNavigationInfo = nil;
 }
 
 - (NSMutableURLRequest*)requestForCurrentNavigationItem {
   web::NavigationItem* item = self.currentNavItem;
   const GURL currentNavigationURL =
       item ? item->GetVirtualURL() : GURL::EmptyGURL();
   NSMutableURLRequest* request = [NSMutableURLRequest
       requestWithURL:net::NSURLWithGURL(currentNavigationURL)];
   const web::Referrer referrer(self.currentNavItemReferrer);
   if (referrer.url.is_valid()) {
@@ skipping 235 matching lines @@
          !_webStateImpl->HasWebUI();
 }
 
 - (void)triggerPendingLoad {
   if (!_containerView) {
     DCHECK(!_isBeingDestroyed);
     // Create the top-level parent view, which will contain the content (whether
     // native or web). Note, this needs to be created with a non-zero size
     // to allow for (native) subviews with autosize constraints to be correctly
     // processed.
-    _containerView.reset(
-        [[CRWWebControllerContainerView alloc] initWithDelegate:self]);
+    _containerView =
+        [[CRWWebControllerContainerView alloc] initWithDelegate:self];
 
     // This will be resized later, but matching the final frame will minimize
     // re-rendering. Use the screen size because the application's key window
     // may still be nil.
     // TODO(crbug.com/688259): Stop subtracting status bar height.
     CGFloat statusBarHeight =
         [[UIApplication sharedApplication] statusBarFrame].size.height;
     CGRect containerViewFrame = [UIScreen mainScreen].bounds;
     containerViewFrame.origin.y += statusBarHeight;
     containerViewFrame.size.height -= statusBarHeight;
-    _containerView.get().frame = containerViewFrame;
-    DCHECK(!CGRectIsEmpty(_containerView.get().frame));
+    _containerView.frame = containerViewFrame;
+    DCHECK(!CGRectIsEmpty(_containerView.frame));
 
     // TODO(crbug.com/691116): Remove this workaround once tests are no longer
     // dependent upon this accessibility ID.
     if (!base::ios::IsRunningOnIOS10OrLater())
       [_containerView setAccessibilityIdentifier:@"Container View"];
 
     [_containerView addGestureRecognizer:[self touchTrackingRecognizer]];
     // Is |currentUrl| a web scheme or native chrome scheme.
     web::NavigationItem* item = self.currentNavItem;
     const GURL currentNavigationURL =
@@ skipping 32 matching lines @@
   return (transition & ui::PAGE_TRANSITION_FROM_ADDRESS_BAR) && item &&
          (destinationURL == item->GetURL() ||
           destinationURL == item->GetOriginalRequestURL());
 }
 
 - (void)reload {
   // 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();
+  _lastUserInteraction = nil;
   base::RecordAction(UserMetricsAction("Reload"));
   GURL url = self.currentNavItem->GetURL();
   if ([self shouldLoadURLInNativeView:url]) {
     std::unique_ptr<web::NavigationContextImpl> navigationContext = [self
         registerLoadRequestForURL:url
                          referrer:self.currentNavItemReferrer
                        transition:ui::PageTransition::PAGE_TRANSITION_RELOAD];
     [self didStartLoadingURL:url];
     [self.nativeController reload];
     _webStateImpl->OnNavigationFinished(navigationContext.get());
@@ skipping 103 matching lines @@
          (!_lastRegisteredRequestURL.is_valid() &&
           _documentURL.spec() == url::kAboutBlankURL))
       << std::endl
       << "currentURL = [" << currentURL << "]" << std::endl
       << "_lastRegisteredRequestURL = [" << _lastRegisteredRequestURL << "]";
 
   // Perform post-load-finished updates.
   [self didFinishWithURL:currentURL loadSuccess:loadSuccess];
 
   // Execute the pending LoadCompleteActions.
-  for (ProceduralBlock action in _pendingLoadCompleteActions.get()) {
+  for (ProceduralBlock action in _pendingLoadCompleteActions) {
     action();
   }
   [_pendingLoadCompleteActions removeAllObjects];
 }
 
 - (void)didFinishWithURL:(const GURL&)currentURL loadSuccess:(BOOL)loadSuccess {
   DCHECK(_loadPhase == web::PAGE_LOADED);
   // Rather than creating a new WKBackForwardListItem when loading WebUI pages,
   // WKWebView will cache the WebUI HTML in the previous WKBackForwardListItem
   // since it's loaded via |-loadHTML:forURL:| instead of an NSURLRequest.  As a
@@ skipping 92 matching lines @@
   if (!_mojoFacade) {
     service_manager::mojom::InterfaceProvider* interfaceProvider =
         _webStateImpl->GetWebStateInterfaceProvider();
     _mojoFacade.reset(new web::MojoFacade(interfaceProvider, self));
   }
   return _mojoFacade.get();
 }
 
 - (CRWPassKitDownloader*)passKitDownloader {
   if (_passKitDownloader) {
-    return _passKitDownloader.get();
+    return _passKitDownloader;
   }
-  base::WeakNSObject<CRWWebController> weakSelf(self);
+  __weak CRWWebController* weakSelf = self;
   web::PassKitCompletionHandler passKitCompletion = ^(NSData* data) {
-    base::scoped_nsobject<CRWWebController> strongSelf([weakSelf retain]);
+    CRWWebController* strongSelf = weakSelf;
     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]) {
       [delegate webController:strongSelf didLoadPassKitObject:data];
     }
   };
   web::BrowserState* browserState = self.webStateImpl->GetBrowserState();
-  _passKitDownloader.reset([[CRWPassKitDownloader alloc]
+  _passKitDownloader = [[CRWPassKitDownloader alloc]
       initWithContextGetter:browserState->GetRequestContext()
-          completionHandler:passKitCompletion]);
-  return _passKitDownloader.get();
+          completionHandler:passKitCompletion];
+  return _passKitDownloader;
 }
 
 - (void)updateWebViewUserAgentFromUserAgentType:
     (web::UserAgentType)userAgentType {
   if (userAgentType == web::UserAgentType::NONE)
     return;
 
   NSString* userAgent =
       base::SysUTF8ToNSString(web::GetWebClient()->GetUserAgent(userAgentType));
   [_webView setCustomUserAgent:userAgent];
 }
 
 #pragma mark -
 #pragma mark CRWWebControllerContainerViewDelegate
 
 - (CRWWebViewProxyImpl*)contentViewProxyForContainerView:
         (CRWWebControllerContainerView*)containerView {
-  return _webViewProxy.get();
+  return _webViewProxy;
 }
 
 - (CGFloat)headerHeightForContainerView:
         (CRWWebControllerContainerView*)containerView {
   return [self headerHeight];
 }
 
 #pragma mark -
 #pragma mark CRWJSInjectionEvaluator Methods
 
@@ skipping 21 matching lines @@
 #pragma mark -
 
 - (void)executeUserJavaScript:(NSString*)script
             completionHandler:(web::JavaScriptResultBlock)completion {
   // For security reasons, executing JavaScript on pages with app-specific URLs
   // is not allowed, because those pages may have elevated privileges.
   GURL lastCommittedURL = self.webState->GetLastCommittedURL();
   if (web::GetWebClient()->IsAppSpecificURL(lastCommittedURL)) {
     if (completion) {
       dispatch_async(dispatch_get_main_queue(), ^{
-        base::scoped_nsobject<NSError> error([[NSError alloc]
+        NSError* error = [[NSError alloc]
             initWithDomain:web::kJSEvaluationErrorDomain
                       code:web::JS_EVALUATION_ERROR_CODE_NO_WEB_VIEW
-                  userInfo:nil]);
+                  userInfo:nil];
         completion(nil, error);
       });
     }
     return;
   }
 
   [self setUserInteractionRegistered:YES];
   [self executeJavaScript:script completionHandler:completion];
 }
 
@@ skipping 243 matching lines @@
 
 - (BOOL)handleDocumentSubmitMessage:(base::DictionaryValue*)message
                             context:(NSDictionary*)context {
   std::string href;
   if (!message->GetString("href", &href)) {
     DLOG(WARNING) << "JS message parameter not found: href";
     return NO;
   }
   std::string formName;
   message->GetString("formName", &formName);
-  base::scoped_nsobject<NSSet> observers([_observers copy]);
+
   // We decide the form is user-submitted if the user has interacted with
   // the main page (using logic from the popup blocker), or if the keyboard
   // is visible.
   BOOL submittedByUser = [context[kUserIsInteractingKey] boolValue] ||
                          [_webViewProxy keyboardAccessory];
   _webStateImpl->OnDocumentSubmitted(formName, submittedByUser);
   return YES;
 }
 
 - (BOOL)handleFormActivityMessage:(base::DictionaryValue*)message
@@ skipping 125 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];
-  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];
-    [strongSelf didFinishNavigation:nil];
-  }];
+  __weak CRWWebController* weakSelf = self;
+  [self executeJavaScript:replaceWebViewJS
+        completionHandler:^(id, NSError*) {
+          CRWWebController* strongSelf = weakSelf;
+          if (!strongSelf || strongSelf->_isBeingDestroyed)
+            return;
+          [strongSelf optOutScrollsToTopForSubviews];
+          [strongSelf didFinishNavigation:nil];
+        }];
   return YES;
 }
 
 - (BOOL)handleWindowHistoryDidReplaceStateMessage:
     (base::DictionaryValue*)message
                                           context:(NSDictionary*)context {
   DCHECK(_changingHistoryState);
   _changingHistoryState = NO;
 
   std::string pageURL;
@@ skipping 28 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];
-  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:nil];
-  }];
+  __weak CRWWebController* weakSelf = self;
+  [self executeJavaScript:replaceStateJS
+        completionHandler:^(id, NSError*) {
+          CRWWebController* strongSelf = weakSelf;
+          if (!strongSelf || strongSelf->_isBeingDestroyed)
+            return;
+          [strongSelf didFinishNavigation:nil];
+        }];
   return YES;
 }
 
 #pragma mark -
 
 - (BOOL)wantsKeyboardShield {
   if ([self.nativeController
           respondsToSelector:@selector(wantsKeyboardShield)]) {
     return [self.nativeController wantsKeyboardShield];
   }
@@ skipping 25 matching lines @@
   }
 
   // TODO(stuartmorgan): This shouldn't be called for hash state or
   // push/replaceState.
   [self resetDocumentSpecificState];
 
   [self didStartLoadingURL:currentURL];
 }
 
 - (void)resetDocumentSpecificState {
-  _lastUserInteraction.reset();
+  _lastUserInteraction = nil;
   _clickInProgress = NO;
 }
 
 - (void)didStartLoadingURL:(const GURL&)URL {
   _loadPhase = web::PAGE_LOADING;
   _URLOnStartLoading = URL;
   _displayStateOnStartLoading = self.pageDisplayState;
 
   self.userInteractionRegistered = NO;
   _pageHasZoomed = NO;
@@ skipping 314 matching lines @@
 
 #pragma mark -
 #pragma mark WebUI
 
 - (void)createWebUIForURL:(const GURL&)URL {
   // |CreateWebUI| will do nothing if |URL| is not a WebUI URL and then
   // |HasWebUI| will return false.
   _webStateImpl->CreateWebUI(URL);
   bool isWebUIURL = _webStateImpl->HasWebUI();
   if (isWebUIURL) {
-    _webUIManager.reset(
-        [[CRWWebUIManager alloc] initWithWebState:_webStateImpl]);
+    _webUIManager = [[CRWWebUIManager alloc] initWithWebState:_webStateImpl];
   }
 }
 
 - (void)clearWebUI {
   _webStateImpl->ClearWebUI();
-  _webUIManager.reset();
+  _webUIManager = nil;
 }
 
 #pragma mark -
 #pragma mark Auth Challenge
 
 - (void)processAuthChallenge:(NSURLAuthenticationChallenge*)challenge
          forCertAcceptPolicy:(web::CertAcceptPolicy)policy
                   certStatus:(net::CertStatus)certStatus
            completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition,
                                        NSURLCredential*))completionHandler {
@@ skipping 35 matching lines @@
                      (void (^)(NSURLSessionAuthChallengeDisposition,
                                NSURLCredential*))completionHandler {
   NSURLProtectionSpace* space = challenge.protectionSpace;
   DCHECK(
       [space.authenticationMethod isEqual:NSURLAuthenticationMethodHTTPBasic] ||
       [space.authenticationMethod isEqual:NSURLAuthenticationMethodNTLM] ||
       [space.authenticationMethod isEqual:NSURLAuthenticationMethodHTTPDigest]);
 
   _webStateImpl->OnAuthRequired(
       space, challenge.proposedCredential,
-      base::BindBlock(^(NSString* user, NSString* password) {
+      base::BindBlockArc(^(NSString* user, NSString* password) {
         [CRWWebController processHTTPAuthForUser:user
                                         password:password
                                completionHandler:completionHandler];
       }));
 }
 
 + (void)processHTTPAuthForUser:(NSString*)user
                       password:(NSString*)password
              completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition,
                                          NSURLCredential*))completionHandler {
@@ skipping 21 matching lines @@
                        completion:(void (^)(BOOL, NSString*))completionHandler {
   DCHECK(completionHandler);
   if (self.shouldSuppressDialogs) {
     _webStateImpl->OnDialogSuppressed();
     completionHandler(NO, nil);
     return;
   }
 
   self.webStateImpl->RunJavaScriptDialog(
       net::GURLWithNSURL(frame.request.URL), type, message, defaultText,
-      base::BindBlock(^(bool success, NSString* input) {
+      base::BindBlockArc(^(bool success, NSString* input) {
         completionHandler(success, input);
       }));
 }
 
 #pragma mark -
 #pragma mark TouchTracking
 
 - (void)touched:(BOOL)touched {
   _clickInProgress = touched;
   if (touched) {
     self.userInteractionRegistered = YES;
     _userInteractedWithWebController = YES;
     if (_isBeingDestroyed)
       return;
     const web::NavigationManagerImpl& navigationManager =
         self.webStateImpl->GetNavigationManagerImpl();
     GURL mainDocumentURL =
         navigationManager.GetItemCount()
             ? navigationManager.GetLastCommittedItem()->GetURL()
             : [self currentURL];
-    _lastUserInteraction.reset(new UserInteractionEvent(mainDocumentURL));
+    _lastUserInteraction =
+        base::MakeUnique<UserInteractionEvent>(mainDocumentURL);
   }
 }
 
 - (CRWTouchTrackingRecognizer*)touchTrackingRecognizer {
   if (!_touchTrackingRecognizer) {
-    _touchTrackingRecognizer.reset(
-        [[CRWTouchTrackingRecognizer alloc] initWithDelegate:self]);
+    _touchTrackingRecognizer =
+        [[CRWTouchTrackingRecognizer alloc] initWithDelegate:self];
   }
-  return _touchTrackingRecognizer.get();
+  return _touchTrackingRecognizer;
 }
 
 - (BOOL)userIsInteracting {
   // If page transfer started after last click, user is deemed to be no longer
   // interacting.
   if (!_lastUserInteraction ||
       _lastTransferTimeInSeconds > _lastUserInteraction->time) {
     return NO;
   }
   return [self userClickedRecently];
@@ skipping 19 matching lines @@
 - (void)addPlaceholderOverlay {
   if (!_overlayPreviewMode) {
     // Create |kSnapshotOverlayDelay| second timer to remove image with
     // transition.
     [self performSelector:@selector(removePlaceholderOverlay)
                withObject:nil
                afterDelay:kSnapshotOverlayDelay];
   }
 
   // Add overlay image.
-  _placeholderOverlayView.reset([[UIImageView alloc] init]);
+  _placeholderOverlayView = [[UIImageView alloc] init];
   CGRect frame = [self visibleFrame];
   [_placeholderOverlayView setFrame:frame];
   [_placeholderOverlayView
       setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
                           UIViewAutoresizingFlexibleHeight];
   [_placeholderOverlayView setContentMode:UIViewContentModeScaleAspectFill];
   [_containerView addSubview:_placeholderOverlayView];
 
   id callback = ^(UIImage* image) {
     [_placeholderOverlayView setImage:image];
   };
   [_delegate webController:self retrievePlaceholderOverlayImage:callback];
 
-  if (!_placeholderOverlayView.get().image) {
-    _placeholderOverlayView.get().image = [[self class] defaultSnapshotImage];
+  if (!_placeholderOverlayView.image) {
+    _placeholderOverlayView.image = [[self class] defaultSnapshotImage];
   }
 }
 
 - (void)removePlaceholderOverlay {
   if (!_placeholderOverlayView || _overlayPreviewMode)
     return;
 
   [NSObject
       cancelPreviousPerformRequestsWithTarget:self
                                      selector:@selector(
                                                   removePlaceholderOverlay)
                                        object:nil];
   // Remove overlay with transition.
   [UIView animateWithDuration:kSnapshotOverlayTransition
       animations:^{
         [_placeholderOverlayView setAlpha:0.0f];
       }
       completion:^(BOOL finished) {
         [_placeholderOverlayView removeFromSuperview];
-        _placeholderOverlayView.reset();
+        _placeholderOverlayView = nil;
       }];
 }
 
 - (void)setOverlayPreviewMode:(BOOL)overlayPreviewMode {
   _overlayPreviewMode = overlayPreviewMode;
 
   // If we were showing the preview, remove it.
   if (!_overlayPreviewMode && _placeholderOverlayView) {
     [self resetContainerView];
     // Reset |_placeholderOverlayView| directly instead of calling
     // -removePlaceholderOverlay, which removes |_placeholderOverlayView| in an
     // animation.
     [_placeholderOverlayView removeFromSuperview];
-    _placeholderOverlayView.reset();
+    _placeholderOverlayView = nil;
     // 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 (_webView) {
       [[self view] addSubview:_webView];
     }
   }
 }
 
 #pragma mark -
@@ skipping 39 matching lines @@
   return currentItem ? currentItem->GetHttpRequestHeaders() : nil;
 }
 
 #pragma mark -
 #pragma mark CRWWebViewScrollViewProxyObserver
 
 - (void)webViewScrollViewDidZoom:
         (CRWWebViewScrollViewProxy*)webViewScrollViewProxy {
   _pageHasZoomed = YES;
 
-  base::WeakNSObject<UIScrollView> weakScrollView(self.webScrollView);
+  __weak UIScrollView* weakScrollView = self.webScrollView;
   [self extractViewportTagWithCompletion:^(
             const web::PageViewportState* viewportState) {
     if (!weakScrollView)
       return;
-    base::scoped_nsobject<UIScrollView> scrollView([weakScrollView retain]);
+    UIScrollView* scrollView = weakScrollView;
     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 : '';";
-  base::WeakNSObject<CRWWebController> weakSelf(self);
+  __weak 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;
-  base::WeakNSObject<CRWWebController> weakSelf(self);
+  __weak 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.
-    base::WeakNSObject<UIScrollView> weakScrollView(self.webScrollView);
-    base::scoped_nsprotocol<ProceduralBlock> action([^{
+    __weak UIScrollView* weakScrollView = self.webScrollView;
+    ProceduralBlock action = ^{
       [weakScrollView setContentOffset:scrollOffset];
-    } copy]);
+    };
     [_pendingLoadCompleteActions addObject:action];
   }
 }
 
 #pragma mark -
 #pragma mark Fullscreen
 
 - (CGRect)visibleFrame {
   CGRect frame = [_containerView bounds];
   CGFloat headerHeight = [self headerHeight];
@@ skipping 96 matching lines @@
     return;
   }
 
   web::NavigationManager* navManager = self.webState->GetNavigationManager();
   web::NavigationItem* currentNavItem = navManager->GetLastCommittedItem();
   if (!currentNavItem) {
     return;
   }
 
   if (!_SSLStatusUpdater) {
-    _SSLStatusUpdater.reset([[CRWSSLStatusUpdater alloc]
-        initWithDataSource:self
-         navigationManager:navManager]);
+    _SSLStatusUpdater =
+        [[CRWSSLStatusUpdater alloc] initWithDataSource:self
+                                      navigationManager:navManager];
     [_SSLStatusUpdater setDelegate:self];
   }
   NSString* host = base::SysUTF8ToNSString(_documentURL.host());
   BOOL hasOnlySecureContent = [_webView hasOnlySecureContent];
   base::ScopedCFTypeRef<SecTrustRef> trust;
   if (base::ios::IsRunningOnIOS10OrLater()) {
     trust.reset([_webView serverTrust], base::scoped_policy::RETAIN);
   } else {
     trust = web::CreateServerTrustFromChain([_webView certificateChain], host);
   }
@@ skipping 61 matching lines @@
       }
       UMA_HISTOGRAM_BOOLEAN("WebController.CertVerificationErrorsCacheHit",
                             cacheHit);
     }
   }
 
   // Ask web client if this cert error should be allowed.
   web::GetWebClient()->AllowCertificateError(
       _webStateImpl, net::MapCertStatusToNetError(info.cert_status), info,
       net::GURLWithNSURL(requestURL), recoverable,
-      base::BindBlock(^(bool proceed) {
+      base::BindBlockArc(^(bool proceed) {
         if (proceed) {
           DCHECK(recoverable);
           [_certVerificationController allowCert:leafCert
                                          forHost:host
                                           status:info.cert_status];
           _webStateImpl->GetSessionCertificatePolicyCache()
               ->RegisterAllowedCertificate(
                   leafCert, base::SysNSStringToUTF8(host), info.cert_status);
           [self loadCurrentURL];
         } else {
@@ skipping 41 matching lines @@
     // 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];
     }
 
-    _contextMenuController.reset([[CRWContextMenuController alloc]
-           initWithWebView:_webView
-        injectionEvaluator:self
-                  delegate:self]);
+    _contextMenuController =
+        [[CRWContextMenuController alloc] initWithWebView:_webView
+                                       injectionEvaluator:self
+                                                 delegate:self];
 
     // Add all additional gesture recognizers to the web view.
-    for (UIGestureRecognizer* recognizer in _gestureRecognizers.get()) {
+    for (UIGestureRecognizer* recognizer in _gestureRecognizers) {
       [_webView addGestureRecognizer:recognizer];
     }
 
     _URLOnStartLoading = _defaultURL;
 
     // WKWebViews with invalid or empty frames have exhibited rendering bugs, so
     // resize the view to match the container view upon creation.
     [_webView setFrame:[_containerView bounds]];
 
     // If the visible NavigationItem should be loaded in this web view, display
@@ skipping 10 matching lines @@
 
 - (WKWebView*)webViewWithConfiguration:(WKWebViewConfiguration*)config {
   // Do not attach the context menu controller immediately as the JavaScript
   // delegate must be specified.
   return web::BuildWKWebView(CGRectZero, config,
                              self.webStateImpl->GetBrowserState(),
                              self.userAgentType);
 }
 
 - (void)setWebView:(WKWebView*)webView {
-  DCHECK_NE(_webView.get(), webView);
+  DCHECK_NE(_webView, 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.WKWebViewObservers) {
     [_webView removeObserver:self forKeyPath:keyPath];
   }
 
-  _webView.reset([webView retain]);
+  _webView = webView;
 
   // Set up the new web view.
   if (webView) {
-    base::WeakNSObject<CRWWebController> weakSelf(self);
+    __weak CRWWebController* weakSelf = self;
     [messageRouter setScriptMessageHandler:^(WKScriptMessage* message) {
       [weakSelf didReceiveScriptMessage:message];
     }
                                       name:kScriptMessageName
                                    webView:webView];
-    _windowIDJSManager.reset(
-        [[CRWJSWindowIDManager alloc] initWithWebView:webView]);
+    _windowIDJSManager = [[CRWJSWindowIDManager alloc] initWithWebView:webView];
   } else {
-    _windowIDJSManager.reset();
+    _windowIDJSManager = nil;
   }
   [_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]);
+  _injectedScriptManagers = [[NSMutableSet alloc] init];
   [self setDocumentURL:_defaultURL];
 }
 
 - (void)displayWebView {
   if (!self.webView || [_containerView webViewContentView])
     return;
 
   // Add the web toolbars.
   [_containerView addToolbars:_webViewToolbars];
 
-  base::scoped_nsobject<CRWWebViewContentView> webViewContentView(
+  CRWWebViewContentView* webViewContentView =
       [[CRWWebViewContentView alloc] initWithWebView:_webView
-                                          scrollView:self.webScrollView]);
+                                          scrollView:self.webScrollView];
   [_containerView displayWebViewContentView:webViewContentView];
 }
 
 - (void)removeWebViewAllowingCachedReconstruction:(BOOL)allowCache {
   if (!_webView)
     return;
 
   _webStateImpl->CancelDialogs();
 
   web::NavigationItem* item = self.currentNavItem;
@@ skipping 22 matching lines @@
 
 - (WKNavigation*)loadRequest:(NSMutableURLRequest*)request {
   WKNavigation* navigation = [_webView loadRequest:request];
   [_navigationStates setState:web::WKNavigationState::REQUESTED
                 forNavigation:navigation];
   return navigation;
 }
 
 - (WKNavigation*)loadPOSTRequest:(NSMutableURLRequest*)request {
   if (!_POSTRequestLoader) {
-    _POSTRequestLoader.reset([[CRWJSPOSTRequestLoader alloc] init]);
+    _POSTRequestLoader = [[CRWJSPOSTRequestLoader alloc] init];
   }
 
   CRWWKScriptMessageRouter* messageRouter =
       [self webViewConfigurationProvider].GetScriptMessageRouter();
 
   return [_POSTRequestLoader
         loadPOSTRequest:request
               inWebView:_webView
           messageRouter:messageRouter
       completionHandler:^(NSError* loadError) {
@@ skipping 40 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.reset([_navigationStates lastAddedNavigation]);
+  _stoppedWKNavigation = [_navigationStates lastAddedNavigation];
 
   base::RecordAction(UserMetricsAction("Stop"));
   // Discard the pending and transient entried before notifying the tab model
   // observers of the change via |-abortLoad|.
   [[self sessionController] discardNonCommittedItems];
   [self abortLoad];
   web::NavigationItem* item = self.currentNavItem;
   GURL navigationURL = item ? item->GetVirtualURL() : GURL::EmptyGURL();
   // If discarding the non-committed entries results in an app-specific URL,
   // reload it in its native view.
@@ skipping 322 matching lines @@
     error = WKWebViewErrorWithSource(error, PROVISIONAL_LOAD);
 
     if (web::IsWKWebViewSSLCertError(error))
       [self handleSSLCertError:error forNavigation:navigation];
     else
       [self handleLoadError:error inMainFrame:YES forNavigation:navigation];
   }
 
   // This must be reset at the end, since code above may need information about
   // the pending load.
-  _pendingNavigationInfo.reset();
+  _pendingNavigationInfo = nil;
   _certVerificationErrors->Clear();
   [_navigationStates removeNavigation:navigation];
 }
 
 - (void)webView:(WKWebView*)webView
     didCommitNavigation:(WKNavigation*)navigation {
   [self displayWebView];
 
   // Record the navigation state.
   [_navigationStates setState:web::WKNavigationState::COMMITTED
@@ skipping 37 matching lines @@
     NSString* storedMIMEType =
         [self currentBackForwardListItemHolder]->mime_type();
     if (storedMIMEType) {
       self.webStateImpl->SetContentsMimeType(
           base::SysNSStringToUTF8(storedMIMEType));
     }
   }
 
   // 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]);
+  _injectedScriptManagers = [[NSMutableSet alloc] init];
   if ([self contentIsHTML] || self.webState->GetContentsMimeType().empty()) {
     // In unit tests MIME type will be empty, because loadHTML:forURL: does not
     // notify web view delegate about received response, so web controller does
     // not get a chance to properly update MIME type.
     [_windowIDJSManager inject];
   }
 
   if (isLastNavigation) {
     [self webPageChanged];
   } else {
@@ skipping 73 matching lines @@
   }
 
   if (![authMethod isEqual:NSURLAuthenticationMethodServerTrust]) {
     completionHandler(NSURLSessionAuthChallengeRejectProtectionSpace, nil);
     return;
   }
 
   SecTrustRef trust = challenge.protectionSpace.serverTrust;
   base::ScopedCFTypeRef<SecTrustRef> scopedTrust(trust,
                                                  base::scoped_policy::RETAIN);
-  base::WeakNSObject<CRWWebController> weakSelf(self);
+  __weak CRWWebController* weakSelf = self;
   [_certVerificationController
       decideLoadPolicyForTrust:scopedTrust
                           host:challenge.protectionSpace.host
              completionHandler:^(web::CertAcceptPolicy policy,
                                  net::CertStatus status) {
-               base::scoped_nsobject<CRWWebController> strongSelf(
-                   [weakSelf retain]);
+               CRWWebController* strongSelf = weakSelf;
                if (!strongSelf) {
                  completionHandler(
                      NSURLSessionAuthChallengeRejectProtectionSpace, nil);
                  return;
                }
                [strongSelf processAuthChallenge:challenge
                             forCertAcceptPolicy:policy
                                      certStatus:status
                               completionHandler:completionHandler];
              }];
@@ skipping 50 matching lines @@
 
 #pragma mark -
 #pragma mark KVO Observation
 
 - (void)observeValueForKeyPath:(NSString*)keyPath
                       ofObject:(id)object
                         change:(NSDictionary*)change
                        context:(void*)context {
   NSString* dispatcherSelectorName = self.WKWebViewObservers[keyPath];
   DCHECK(dispatcherSelectorName);
-  if (dispatcherSelectorName)
-    [self performSelector:NSSelectorFromString(dispatcherSelectorName)];
+  if (dispatcherSelectorName) {
+    // With ARC memory management, it is not known what a method called
+    // via a selector will return. If a method returns a retained value
+    // (e.g. NS_RETURNS_RETAINED) that returned object will leak as ARC is
+    // unable to property insert the correct release calls for it.
+    // We know that all selectors used here return void and take no parameters
+    // so we will manually call a function mapping to the method implementation.
+
+    SEL selector = NSSelectorFromString(dispatcherSelectorName);
+    IMP methodImplementation = [self methodForSelector:selector];
+    if (methodImplementation) {
+      void (*methodCallFunction)(id, SEL) =
+          (void (*)(id, SEL))methodImplementation;
+      methodCallFunction(self, selector);

[PL, 2017/06/01 01:56:21]

This is one manual piece of conversion work that might be worth discussing.

We can't easily change this code to not store selectors, that would be a large
architectural change. The comment here explains what is happening, but we could
also replace this with a pragma to turn off the selector warning.

I feel that this is more explicit than that. Open to discussion!

+    }
+  }
 }
 
 - (void)webViewEstimatedProgressDidChange {
   if (!_isBeingDestroyed) {
     self.webStateImpl->SendChangeLoadProgress([_webView estimatedProgress]);
   }
 }
 
 - (void)webViewSecurityFeaturesDidChange {
   if (self.loadPhase == web::LOAD_REQUESTED) {
@@ skipping 223 matching lines @@
     navigationContext->SetIsSameDocument(true);
     _webStateImpl->OnNavigationFinished(navigationContext);
 
     [self updateSSLStatusForCurrentNavigationItem];
     [self didFinishNavigation:nil];
   }
 }
 
 - (web::NavigationContextImpl*)contextForPendingNavigationWithURL:
     (const GURL&)URL {
-  for (id navigation in [_navigationStates pendingNavigations]) {
+  for (__strong id navigation in [_navigationStates pendingNavigations]) {
     if (navigation == [NSNull null]) {
       // null is a valid navigation object passed to WKNavigationDelegate
       // callbacks and represents window opening action.
       navigation = nil;
     }
 
     web::NavigationContextImpl* context =
         [_navigationStates contextForNavigation:navigation];
     if (context->GetUrl() == URL) {
       return context;
@@ skipping 109 matching lines @@
 
   if (!repostedForm || currentItem->ShouldSkipRepostFormConfirmation()) {
     webViewNavigationBlock();
     return;
   }
 
   // If the request is form submission or resubmission, then prompt the
   // user before proceeding.
   DCHECK(repostedForm);
   _webStateImpl->ShowRepostFormWarningDialog(
-      base::BindBlock(^(bool shouldContinue) {
+      base::BindBlockArc(^(bool shouldContinue) {
         if (shouldContinue)
           webViewNavigationBlock();
         else
           [self stopLoading];
       }));
 }
 
 - (void)reportBackForwardNavigationTypeForFastNavigation:(BOOL)isFast {
   // TODO(crbug.com/665189): Use NavigationManager::GetPendingItemIndex() once
   // it returns correct result.
@@ skipping 35 matching lines @@
 }
 
 - (void)addObserver:(id<CRWWebControllerObserver>)observer {
   DCHECK(observer);
   if (!_observers) {
     // We don't want our observer set to block dealloc on the observers. For the
     // observer container, make an object compatible with NSMutableSet that does
     // not perform retain or release on the contained objects (weak references).
     CFSetCallBacks callbacks =
         {0, NULL, NULL, CFCopyDescription, CFEqual, CFHash};
-    _observers.reset(base::mac::CFToNSCast(
-        CFSetCreateMutable(kCFAllocatorDefault, 1, &callbacks)));
+    _observers = base::mac::CFToNSCast(
+        CFSetCreateMutable(kCFAllocatorDefault, 1, &callbacks));
   }
   DCHECK(![_observers containsObject:observer]);
   [_observers addObject:observer];
   _observerBridges.push_back(base::MakeUnique<web::WebControllerObserverBridge>(
       observer, self.webStateImpl, self));
 
   if ([observer respondsToSelector:@selector(setWebViewProxy:controller:)])
     [observer setWebViewProxy:_webViewProxy controller:self];
 }
 
@@ skipping 14 matching lines @@
 - (NSUInteger)observerCount {
   DCHECK_EQ(_observerBridges.size(), [_observers count]);
   return [_observers count];
 }
 
 - (NSString*)referrerFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:kReferrerHeaderName];
 }
 
 @end