[ObjC ARC] Converts ios/chrome/browser/ui/contextual_search:contextual_search to ARC.

ios/chrome/browser/ui/contextual_search/contextual_search_controller.mm

 // Copyright 2014 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/chrome/browser/ui/contextual_search/contextual_search_controller.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/ios/ios_util.h"
-#import "base/ios/weak_nsobject.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_block.h"
-#include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/search_engines/template_url_service.h"
 #include "ios/chrome/browser/application_context.h"
 #import "ios/chrome/browser/procedural_block_types.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #import "ios/chrome/browser/ui/commands/UIKit+ChromeExecuteCommand.h"
@@ skipping 26 matching lines @@
 #import "ios/web/public/web_state/crw_web_view_scroll_view_proxy.h"
 #import "ios/web/public/web_state/js/crw_js_injection_receiver.h"
 #include "ios/web/public/web_state/web_state.h"
 #include "ios/web/public/web_state/web_state_observer.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
 // Returns |value| clamped so that min <= value <= max
 #define CLAMP(min, value, max) MAX(min, MIN(value, max))
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 // command prefix for injected JavaScript.
 const std::string kCommandPrefix = "contextualSearch";
 
 // Distance from edges of frame when scrolling to show selection.
 const CGFloat kYScrollMargin = 30.0;
 const CGFloat kXScrollMargin = 10.0;
 
 // Delay to check if there is a DOM modification (in second).
 // If delay is too short, JavaScript won't have time to handle the event and the
@@ skipping 43 matching lines @@
       rectBottom <= rectTop) {
     return CGRectNull;
   }
   CGRect rect =
       CGRectMake(rectLeft, rectTop, rectRight - rectLeft, rectBottom - rectTop);
   return rect;
 }
 
 NSArray* StringValueToRectArray(const std::string& list) {
   NSString* nsList = base::SysUTF8ToNSString(list);
-  NSMutableArray* rectsArray = [[[NSMutableArray alloc] init] autorelease];
+  NSMutableArray* rectsArray = [[NSMutableArray alloc] init];
   NSArray* items = [nsList componentsSeparatedByString:@","];
   for (NSString* item : items) {
     CGRect rect = StringValueToRect(item);
     if (CGRectIsNull(rect)) {
       return nil;
     }
     [rectsArray addObject:[NSValue valueWithCGRect:rect]];
   }
   return rectsArray;
 }
 
 }  // namespace
 
 @interface ContextualSearchController ()<DOMAltering,
                                          CRWWebViewScrollViewProxyObserver,
                                          UIGestureRecognizerDelegate,
                                          ContextualSearchHighlighterDelegate,
                                          ContextualSearchPromoViewDelegate,
                                          ContextualSearchPanelMotionObserver,
                                          ContextualSearchPanelTapHandler,
                                          ContextualSearchPreloadChecker,
                                          ContextualSearchTabPromoter,
                                          ContextualSearchWebStateDelegate,
                                          TouchToSearchPermissionsChangeAudience>
 
 // Controller delegate for the controller to call back to.
-@property(nonatomic, readwrite, assign) id<ContextualSearchControllerDelegate>
+@property(nonatomic, readwrite, weak) id<ContextualSearchControllerDelegate>
     controllerDelegate;
 
 // Permissions interface for this feature. Property is readwrite for testing.
-@property(nonatomic, readwrite, retain)
+@property(nonatomic, readwrite, strong)
     TouchToSearchPermissionsMediator* permissions;
 
 // Synchronous method executed by -asynchronouslyEnableContextualSearch:
 - (void)doEnableContextualSearch:(BOOL)enabled;
 
 // Handler for injected JavaScript callbacks.
 - (BOOL)handleScriptCommand:(const base::DictionaryValue&)JSONCommand;
 
 // Handle the selection change event if the DOM lock is acquired.
 // |selection| is the currently selected text in the webview.
@@ skipping 67 matching lines @@
 // - vertical: put |_highlightBoundingRect| at |kYScrollMargin| from top edge.
 - (void)scrollToShowSelection:(CRWWebViewScrollViewProxy*)scrollView;
 
 // Creates, enables or disables the dismiss recognizer based on state_.
 - (void)updateDismissRecognizer;
 
 @end
 
 @implementation ContextualSearchController {
   // Permissions interface for this feature.
-  base::scoped_nsobject<TouchToSearchPermissionsMediator> _permissions;
+  TouchToSearchPermissionsMediator* _permissions;
 
   // WebState for the tab this object is attached to.
   web::WebState* _webState;
 
   // Access to the web view from |_webState|.
-  base::scoped_nsprotocol<id<CRWWebViewProxy>> _webViewProxy;
+  id<CRWWebViewProxy> _webViewProxy;
 
   // Observer for |_webState|.
   std::unique_ptr<ContextualSearchWebStateObserver> _webStateObserver;
 
   // Observer for search tab's web state.
   std::unique_ptr<ContextualSearchWebStateObserver> _searchTabWebStateObserver;
 
   // Object that manages find_in_page.js injection into the web view.
-  base::WeakNSObject<JsContextualSearchManager> _contextualSearchJsManager;
+  __weak JsContextualSearchManager* _contextualSearchJsManager;
 
   // Gesture reccognizer for contextual search taps.
-  base::scoped_nsobject<UITapGestureRecognizer> _tapRecognizer;
+  UITapGestureRecognizer* _tapRecognizer;
 
   // Gesture reccognizer for double tap. It is used to prevent |_tapRecognizer|
   // from firing if there is a double tap on the web view. It is disabled when
   // the panel is displayed, since any tap will dismiss the panel in that case.
-  base::scoped_nsobject<UITapGestureRecognizer> _doubleTapRecognizer;
+  UITapGestureRecognizer* _doubleTapRecognizer;
 
   // Gesture recognizer for long-tap copy.
-  base::scoped_nsobject<UILongPressGestureRecognizer> _copyGestureRecognizer;
+  UILongPressGestureRecognizer* _copyGestureRecognizer;
 
   // Gesture recognizer to detect taps outside of the CS interface that would
   // cause it to dismiss.
-  base::scoped_nsobject<WindowGestureObserver> _dismissRecognizer;
+  WindowGestureObserver* _dismissRecognizer;
 
   // Context information retrieved from a search tap.
   std::shared_ptr<ContextualSearchContext> _searchContext;
 
   // Resolved search information generated from the context or text selection.
   ContextualSearchDelegate::SearchResolution _resolvedSearch;
 
   // Delegate for fetching search information.
   std::unique_ptr<ContextualSearchDelegate> _delegate;
 
   // The panel view controlled by this object; it is created externally and
   // owned by its superview. There is no guarantee about its lifetime.
-  base::WeakNSObject<ContextualSearchPanelView> _panelView;
+  __weak ContextualSearchPanelView* _panelView;
 
   // The view containing the highlighting of the search terms.
-  base::WeakNSObject<ContextualSearchHighlighterView> _contextualHighlightView;
+  __weak ContextualSearchHighlighterView* _contextualHighlightView;
 
   // Content view displayed in the peeking section of the panel.
-  base::scoped_nsobject<ContextualSearchHeaderView> _headerView;
+  ContextualSearchHeaderView* _headerView;
 
   // Vertical constraints for layout of the search tab.
-  base::scoped_nsobject<NSArray> _searchTabVerticalConstraints;
+  NSArray* _searchTabVerticalConstraints;
 
   // Container view for the opt-out promo and the search tab view.
-  base::scoped_nsobject<ContextualSearchResultsView> _searchResultsView;
+  ContextualSearchResultsView* _searchResultsView;
 
   // View for the opt-out promo.
-  base::scoped_nsobject<ContextualSearchPromoView> _promoView;
+  ContextualSearchPromoView* _promoView;
 
   // The tab that should be used as the opener for the search tab.
   Tab* _opener;
 
   // YES if a cancel event was received since last tap, meaning the current tap
   // must not result in a search.
   BOOL _currentTapCancelled;
 
   // The current selection text.
   std::string _selectedText;
@@ skipping 55 matching lines @@
   // True when closed has been called and contextual search controller
   // has been destroyed.
   BOOL _closed;
 
   // When view is resized, JavaScript and UIView sizes are not updated at the
   // same time. Computing a scroll delta to make selection visible in these
   // conditions will likely scroll to a random position.
   BOOL _preventScrollToShowSelection;
 
   // The time of the last dismiss.
-  base::scoped_nsobject<NSDate> _lastDismiss;
+  NSDate* _lastDismiss;
 }
 
 @synthesize enabled = _enabled;
 @synthesize controllerDelegate = _controllerDelegate;
 @synthesize webState = _webState;
 
 - (instancetype)initWithBrowserState:(ios::ChromeBrowserState*)browserState
                             delegate:(id<ContextualSearchControllerDelegate>)
                                          delegate {
   if ((self = [super init])) {
-    _permissions.reset([[TouchToSearchPermissionsMediator alloc]
-        initWithBrowserState:browserState]);
+    _permissions = [[TouchToSearchPermissionsMediator alloc]
+        initWithBrowserState:browserState];
     [_permissions setAudience:self];
 
     self.controllerDelegate = delegate;
 
     // Set up the web state observer. This lasts as long as this object does,
     // but it will observe and un-observe the web tabs as it changes over time.
     _webStateObserver.reset(new ContextualSearchWebStateObserver(self));
 
-    _copyGestureRecognizer.reset([[UILongPressGestureRecognizer alloc]
+    _copyGestureRecognizer = [[UILongPressGestureRecognizer alloc]
         initWithTarget:self
-                action:@selector(handleLongPressFrom:)]);
+                action:@selector(handleLongPressFrom:)];
 
-    base::WeakNSObject<ContextualSearchController> weakself(self);
-    auto callback = base::BindBlock(
+    __weak ContextualSearchController* weakself = self;
+    auto callback = base::BindBlockArc(
         ^(ContextualSearchDelegate::SearchResolution resolution) {
           [weakself updateForResolvedSearch:resolution];
         });
 
     _delegate.reset(new ContextualSearchDelegate(browserState, callback));
   }
   return self;
 }
 
 - (TouchToSearchPermissionsMediator*)permissions {
   return _permissions;
 }
 
 - (void)setPermissions:(TouchToSearchPermissionsMediator*)permissions {
-  _permissions.reset(permissions);
+  _permissions = permissions;
 }
 
 - (ContextualSearchPanelView*)panel {
   return _panelView;
 }
 
 - (void)setPanel:(ContextualSearchPanelView*)panel {
   DCHECK(!_panelView);
   DCHECK(panel);
 
   // Save the new panel, set up observation and delegation relationships.
-  _panelView.reset(panel);
+  _panelView = panel;
   [_panelView addMotionObserver:self];
   [_dismissRecognizer setViewToExclude:_panelView];
 
   // Create new subviews.
   NSMutableArray* panelContents = [NSMutableArray arrayWithCapacity:3];
 
-  _headerView.reset([[ContextualSearchHeaderView alloc]
-      initWithHeight:[_panelView configuration].peekingHeight]);
+  _headerView = [[ContextualSearchHeaderView alloc]
+      initWithHeight:[_panelView configuration].peekingHeight];
   [_headerView addGestureRecognizer:_copyGestureRecognizer];
   [_headerView setTapHandler:self];
 
   [panelContents addObject:_headerView];
 
   if (self.permissions.preferenceState == TouchToSearch::UNDECIDED) {
-    _promoView.reset([[ContextualSearchPromoView alloc] initWithFrame:CGRectZero
-                                                             delegate:self]);
+    _promoView = [[ContextualSearchPromoView alloc] initWithFrame:CGRectZero
+                                                         delegate:self];
     [panelContents addObject:_promoView];
   }
 
-  _searchResultsView.reset(
-      [[ContextualSearchResultsView alloc] initWithFrame:CGRectZero]);
+  _searchResultsView =
+      [[ContextualSearchResultsView alloc] initWithFrame:CGRectZero];
   [_searchResultsView setPromoter:self];
   [_searchResultsView setPreloadChecker:self];
   [panelContents addObject:_searchResultsView];
 
   [_panelView addContentViews:panelContents];
 }
 
 - (void)enableContextualSearch:(BOOL)enabled {
   // Asynchronously enables contextual search, so that some preferences
   // (UIAccessibilityIsVoiceOverRunning(), for example) have time to synchronize
   // with their own notifications.
-  base::WeakNSObject<ContextualSearchController> weakSelf(self);
+  __weak ContextualSearchController* weakSelf = self;
   dispatch_async(dispatch_get_main_queue(), ^{
     [weakSelf doEnableContextualSearch:enabled];
   });
 }
 
 - (void)doEnableContextualSearch:(BOOL)enabled {
   enabled = enabled && [self.permissions canEnable];
 
   BOOL changing = _enabled != enabled;
   if (changing) {
     if (!enabled) {
       [self dismissPane:ContextualSearch::RESET];
     }
     _enabled = enabled;
     [self enableCurrentWebState];
   }
 }
 
 - (void)updateWebViewProxy:(id<CRWWebViewProxy>)webViewProxy {
   if (_webViewProxy) {
     [[_webViewProxy scrollViewProxy] removeObserver:self];
   }
-  _webViewProxy.reset([webViewProxy retain]);
+  _webViewProxy = webViewProxy;
   if (_webViewProxy) {
     [[_webViewProxy scrollViewProxy] addObserver:self];
   }
 }
 
 - (void)setTab:(Tab*)tab {
   [self setWebState:tab.webState];
   [_searchResultsView setOpener:tab];
 }
 
 - (void)setWebState:(web::WebState*)webState {
   [self disconnectWebState];
   if (webState) {
-    _contextualSearchJsManager.reset(static_cast<JsContextualSearchManager*>(
+    _contextualSearchJsManager = static_cast<JsContextualSearchManager*>(
         [webState->GetJSInjectionReceiver()
-            instanceOfClass:[JsContextualSearchManager class]]));
+            instanceOfClass:[JsContextualSearchManager class]]);
     _webState = webState;
     _webStateObserver->ObserveWebState(webState);
     [self updateWebViewProxy:webState->GetWebViewProxy()];
     [self enableCurrentWebState];
   } else {
     _webState = nullptr;
   }
 }
 
 - (void)enableCurrentWebState {
   if (![self webState])
     return;
   if (_enabled && [self webState]->ContentIsHTML()) {
     if (!_webStateEnabled) {
       DOMAlteringLock::CreateForWebState([self webState]);
 
-      base::WeakNSObject<ContextualSearchController> weakSelf(self);
-      auto callback =
-          base::BindBlock(^bool(const base::DictionaryValue& JSON,
-                                const GURL& originURL, bool userIsInteracting) {
-            base::scoped_nsobject<ContextualSearchController> strongSelf(
-                [weakSelf retain]);
+      __weak ContextualSearchController* weakSelf = self;
+      auto callback = base::BindBlockArc(
+          ^bool(const base::DictionaryValue& JSON, const GURL& originURL,
+                bool userIsInteracting) {
+            ContextualSearchController* strongSelf = weakSelf;
             // |originURL| and |isInteracting| aren't used.
             return [strongSelf handleScriptCommand:JSON];
           });
       [self webState]->AddScriptCommandCallback(callback, kCommandPrefix);
 
       // |_doubleTapRecognizer| should be added to the web view before
       // |_tapRecognizer| so |_tapRecognizer| can require it to fail.
-      _doubleTapRecognizer.reset([[UITapGestureRecognizer alloc]
-          initWithTarget:self
-                  action:@selector(ignoreTap:)]);
+      _doubleTapRecognizer =
+          [[UITapGestureRecognizer alloc] initWithTarget:self
+                                                  action:@selector(ignoreTap:)];
       [_doubleTapRecognizer setDelegate:self];
       [_doubleTapRecognizer setNumberOfTapsRequired:2];
       [_webViewProxy addGestureRecognizer:_doubleTapRecognizer];
 
-      _tapRecognizer.reset([[UITapGestureRecognizer alloc]
+      _tapRecognizer = [[UITapGestureRecognizer alloc]
           initWithTarget:self
-                  action:@selector(handleTapFrom:)]);
+                  action:@selector(handleTapFrom:)];
       [_tapRecognizer setDelegate:self];
       [_webViewProxy addGestureRecognizer:_tapRecognizer];
 
       // Make sure that |_tapRecogngizer| doesn't fire if the web view's other
       // non-single-finger non-single-tap recognizers fire.
       for (UIGestureRecognizer* recognizer in
            [[_tapRecognizer view] gestureRecognizers]) {
         if ([recognizer isKindOfClass:[UITapGestureRecognizer class]] &&
             ([static_cast<UITapGestureRecognizer*>(recognizer)
                  numberOfTapsRequired] > 1 ||
@@ skipping 22 matching lines @@
     _webState->RemoveScriptCommandCallback(kCommandPrefix);
     DOMAlteringLock::FromWebState(_webState)->Release(self);
     [_webViewProxy removeGestureRecognizer:_tapRecognizer];
     [_webViewProxy removeGestureRecognizer:_doubleTapRecognizer];
     _webStateEnabled = NO;
   }
 }
 
 - (void)disconnectWebState {
   if (_webState) {
-    _contextualSearchJsManager.reset();
+    _contextualSearchJsManager = nil;
     _webStateObserver->ObserveWebState(nullptr);
     [self updateWebViewProxy:nil];
     [self disableCurrentWebState];
   }
 }
 
 - (void)updateDismissRecognizer {
   if (!_panelView)
     return;
   if (!_dismissRecognizer) {
-    _dismissRecognizer.reset([[WindowGestureObserver alloc]
+    _dismissRecognizer = [[WindowGestureObserver alloc]
         initWithTarget:self
-                action:@selector(handleWindowGesture:)]);
+                action:@selector(handleWindowGesture:)];
     [_dismissRecognizer setViewToExclude:_panelView];
     [[_panelView window] addGestureRecognizer:_dismissRecognizer];
   }
 
   [_dismissRecognizer
       setEnabled:[_panelView state] >= ContextualSearch::PEEKING];
 }
 
 - (void)showLearnMore {
   [self dismissPane:ContextualSearch::UNKNOWN];
   GURL learnMoreUrl = google_util::AppendGoogleLocaleParam(
       GURL(l10n_util::GetStringUTF8(IDS_IOS_CONTEXTUAL_SEARCH_LEARN_MORE_URL)),
       GetApplicationContext()->GetApplicationLocale());
   [_controllerDelegate createTabFromContextualSearchController:learnMoreUrl];
 }
 
 - (void)dealloc {
   [self close];
-  [super dealloc];
 }
 
 - (void)handleWindowGesture:(UIGestureRecognizer*)recognizer {
-  DCHECK(recognizer == _dismissRecognizer.get());
+  DCHECK(recognizer == _dismissRecognizer);
   [self dismissPane:ContextualSearch::BASE_PAGE_TAP];
 }
 
 - (BOOL)canExtractTapContext {
   web::URLVerificationTrustLevel trustLevel = web::kNone;
   GURL pageURL = [self webState]->GetCurrentURL(&trustLevel);
   return [self.permissions canExtractTapContextForURL:pageURL];
 }
 
 - (void)initializeWebViewForContextualSearch {
@@ skipping 65 matching lines @@
   if (command == "contextualSearch.selectionChanged") {
     std::string selectedText;
     if (!JSONCommand.GetString("text", &selectedText))
       return NO;
     bool selectionUpdated;
     if (!JSONCommand.GetBoolean("updated", &selectionUpdated))
       selectionUpdated = false;
     bool selectionValid;
     if (!JSONCommand.GetBoolean("valid", &selectionValid))
       selectionValid = true;
-    base::WeakNSObject<ContextualSearchController> weakSelf(self);
+    __weak ContextualSearchController* weakSelf = self;
     ProceduralBlockWithBool lockAction = ^(BOOL lockAcquired) {
       if (lockAcquired) {
         [weakSelf handleSelectionChanged:selectedText
                         selectionUpdated:selectionUpdated
                           selectionValid:selectionValid];
       }
     };
     DOMAlteringLock::FromWebState([self webState])->Acquire(self, lockAction);
     return YES;
   }
   if (command == "contextualSearch.mutationEvent") {
     if ([_panelView state] <= ContextualSearch::PEEKING &&
         !_searchTermResolved) {
       [self dismissPane:ContextualSearch::UNKNOWN];
     }
     return YES;
   }
   return NO;
 }
 
 - (void)ignoreTap:(UIGestureRecognizer*)recognizer {
   // This method is intentionally empty. It is intended to ignore the tap.
 }
 
 - (void)handleTapFrom:(UIGestureRecognizer*)recognizer {
-  DCHECK(recognizer == _tapRecognizer.get());
+  DCHECK(recognizer == _tapRecognizer);
   // Taps will be triggered by long-presses to make a selection in the webview,
   // as well as 'regular' taps. Long-presses that create a selection will set
   // |_newSelectionDisplaying| as well as populating _selectedText (this happens
   // in -handleScriptCommand:).
 
   // If we just dismissed, do not consider this tap.
   NSTimeInterval dismissTimeout = [_lastDismiss timeIntervalSinceNow] +
                                   kPreventTriggerAfterDismissDelaySeconds;
 
   // If the panel is already displayed, just dismiss it and return, unless the
@@ skipping 21 matching lines @@
     CGPoint tapPoint = [recognizer locationInView:recognizer.view];
     // tapPoint is the coordinate of the tap in the webView. If the view is
     // currently offset because a header is displayed, offset the tapPoint.
     tapPoint.y -= [_controllerDelegate currentHeaderHeight];
 
     // Handle tap asynchronously to monitor DOM modifications. See comment
     // of |kDOMModificationDelaySeconds| for details.
     dispatch_time_t dispatch = dispatch_time(
         DISPATCH_TIME_NOW,
         static_cast<int64_t>(kDOMModificationDelaySeconds * NSEC_PER_SEC));
-    base::WeakNSObject<ContextualSearchController> weakSelf(self);
+    __weak ContextualSearchController* weakSelf = self;
     dispatch_after(dispatch, dispatch_get_main_queue(), ^{
       [weakSelf handleTapAtPoint:tapPoint];
     });
   };
   DOMAlteringLock::FromWebState([self webState])->Acquire(self, lockAction);
 }
 
 - (void)handleLongPressFrom:(UIGestureRecognizer*)recognizer {
-  DCHECK(recognizer == _copyGestureRecognizer.get());
+  DCHECK(recognizer == _copyGestureRecognizer);
   if (recognizer.state != UIGestureRecognizerStateEnded)
     return;
 
   // Put the resolved search term (or the current selected text) into the
   // pasteboard.
   std::string text;
   if (!_resolvedSearch.display_text.empty()) {
     text = _resolvedSearch.display_text;
   }
 
@@ skipping 23 matching lines @@
   std::string encoding = "UTF-8";
 
   CGPoint relativeTapPoint = point;
   CGSize contentSize = [_webViewProxy scrollViewProxy].contentSize;
   relativeTapPoint.x += [_webViewProxy scrollViewProxy].contentOffset.x;
   relativeTapPoint.y += [_webViewProxy scrollViewProxy].contentOffset.y;
 
   relativeTapPoint.x /= contentSize.width;
   relativeTapPoint.y /= contentSize.height;
 
-  base::WeakNSProtocol<id<CRWWebViewProxy>> weakWebViewProxy(
-      _webViewProxy.get());
+  __weak id<CRWWebViewProxy> weakWebViewProxy = _webViewProxy;
   void (^handler)(NSString*) = ^(NSString* result) {
     [_tapRecognizer setEnabled:YES];
     // If there has been an error in the javascript, return can be nil.
     if (!result || _currentTapCancelled)
       return;
 
     // Parse JSON.
     const std::string json = base::SysNSStringToUTF8(result);
     std::unique_ptr<base::Value> parsedResult(
         base::JSONReader::Read(json, false));
@@ skipping 173 matching lines @@
 
   if (_resolvedSearch.is_invalid) {
     [self dismissPane:ContextualSearch::UNKNOWN];
   } else {
     _searchTermResolved = YES;
     [_headerView
         setSearchTerm:base::SysUTF8ToNSString(_resolvedSearch.display_text)
              animated:[_panelView state] != ContextualSearch::DISMISSED];
     if (_resolvedSearch.start_offset != -1 &&
         _resolvedSearch.end_offset != -1) {
-      base::WeakNSObject<ContextualSearchController> weakSelf(self);
+      __weak ContextualSearchController* weakSelf = self;
       [_contextualSearchJsManager
           expandHighlightToStartOffset:_resolvedSearch.start_offset
                              endOffset:_resolvedSearch.end_offset
                      completionHandler:^(id result, NSError* error) {
                        [weakSelf handleHighlightJSResult:result
                                                withError:error];
                      }];
     }
     GURL url = _delegate->GetURLForResolvedSearch(_resolvedSearch, true);
     [_searchResultsView createTabForSearch:url
@@ skipping 33 matching lines @@
                     animated:[_panelView state] != ContextualSearch::DISMISSED];
     }
   } else {
     ContextualSearch::RecordSelectionIsValid(false);
     [self dismissPane:ContextualSearch::INVALID_SELECTION];
   }
 }
 - (void)scrollToShowSelection:(CRWWebViewScrollViewProxy*)scrollView {
   if (!scrollView || _preventScrollToShowSelection)
     return;
-  if (!_contextualHighlightView.get()) {
+  if (!_contextualHighlightView) {
     return;
   }
   CGRect highlightBoundingRect = [_contextualHighlightView boundingRect];
   if (CGRectIsNull(highlightBoundingRect)) {
     return;
   }
 
   // Do the maths without the insets.
   CGPoint scrollPoint = [scrollView contentOffset];
   scrollPoint.y += scrollView.contentInset.top;
@@ skipping 67 matching lines @@
 
   scrollPoint.y -= scrollView.contentInset.top;
   scrollPoint.x -= scrollView.contentInset.left;
   [scrollView setContentOffset:scrollPoint animated:YES];
 }
 
 - (void)highlightRects:(NSArray*)rects {
   if (![self webState]) {
     return;
   }
-  if (!_contextualHighlightView.get() && [rects count]) {
+  if (!_contextualHighlightView && [rects count]) {
     CGRect frame = [[self webState]->GetWebViewProxy() frame];
     ContextualSearchHighlighterView* highlightView =
-        [[[ContextualSearchHighlighterView alloc] initWithFrame:frame
-                                                       delegate:self]
-            autorelease];
-    _contextualHighlightView.reset(highlightView);
+        [[ContextualSearchHighlighterView alloc] initWithFrame:frame
+                                                      delegate:self];
+    _contextualHighlightView = highlightView;
     [[self webState]->GetWebViewProxy() addSubview:highlightView];
   }
   CGPoint scroll = [[_webViewProxy scrollViewProxy] contentOffset];
   [_contextualHighlightView
       highlightRects:rects
           withOffset:[_controllerDelegate currentHeaderHeight]
                 zoom:[[_webViewProxy scrollViewProxy] zoomScale]
               scroll:scroll];
 }
 
@@ skipping 22 matching lines @@
   if (_closed)
     return;
 
   _closed = YES;
   [self disableCurrentWebState];
   [self setWebState:nil];
   [_headerView removeGestureRecognizer:_copyGestureRecognizer];
   [[_panelView window] removeGestureRecognizer:_dismissRecognizer];
   _delegate.reset();
   [_searchResultsView setActive:NO];
-  _searchResultsView.reset();
+  _searchResultsView = nil;
 }
 
 #pragma mark - Promo view management
 
 - (void)userOptedInFromPromo:(BOOL)optIn {
   if (optIn) {
     self.permissions.preferenceState = TouchToSearch::ENABLED;
     [_promoView closeAnimated:YES];
     [_promoView setDisabled:YES];
   } else {
@@ skipping 55 matching lines @@
       // Dragged up.
       [self coverPane:ContextualSearch::SWIPE];
     }
   }
   [self updateHighlight];
 }
 
 - (void)panelWillPromote:(ContextualSearchPanelView*)panel {
   DCHECK(panel == _panelView);
   [panel removeMotionObserver:self];
-  _panelView.reset();
+  _panelView = nil;
   [self setState:ContextualSearch::DISMISSED
           reason:ContextualSearch::TAB_PROMOTION];
 }
 
 #pragma mark - ContextualSearchPanelTapHandler
 
 - (void)panelWasTapped:(UIGestureRecognizer*)gesture {
   // Tapping when peeking switches to previewing.
   // Tapping otherwise turns the panel into a tab.
   if ([_panelView state] == ContextualSearch::PEEKING) {
@@ skipping 113 matching lines @@
 - (void)
 dismissPaneWithJavascriptCompletionHandler:(ProceduralBlock)completionHandler
                                     reason:(ContextualSearch::StateChangeReason)
                                                reason {
   [self cleanUpWebStateForDismissWithCompletion:completionHandler];
   [self setState:ContextualSearch::DISMISSED reason:reason];
 }
 
 - (void)cleanUpWebStateForDismissWithCompletion:
     (ProceduralBlock)completionHandler {
-  _lastDismiss.reset([[NSDate date] retain]);
+  _lastDismiss = [NSDate date];
   _currentTapCancelled = YES;
   ContextualSearch::PanelState originalState = [_panelView state];
   if (originalState == ContextualSearch::DISMISSED) {
     DCHECK(![_searchResultsView active]);
     if ([self webState]) {
       DOMAlteringLock* lock = DOMAlteringLock::FromWebState([self webState]);
       if (lock) {
         lock->Release(self);
       }
     }
     if (completionHandler)
       completionHandler();
     return;
   }
 
   [_doubleTapRecognizer setEnabled:YES];
   _searchContext.reset();
   [_searchResultsView setActive:NO];
   _delegate->CancelSearchTermRequest();
   _selectedText = "";
 
   ContextualSearchDelegate::SearchResolution blank;
   _resolvedSearch = blank;
   if (completionHandler) {
-    base::WeakNSObject<ContextualSearchController> weakSelf(self);
+    __weak ContextualSearchController* weakSelf = self;
     ProceduralBlock javaScriptCompletion = ^{
-      if ([self webState]) {
-        DOMAlteringLock::FromWebState([self webState])->Release(self);
+      if ([weakSelf webState]) {
+        DOMAlteringLock::FromWebState([weakSelf webState])->Release(weakSelf);
         completionHandler();
       }
     };
     [self highlightRects:nil];
     [_contextualSearchJsManager clearHighlight];
     javaScriptCompletion();
   } else {
     [self highlightRects:nil];
     [_contextualSearchJsManager clearHighlight];
     DOMAlteringLock::FromWebState([self webState])->Release(self);
@@ skipping 48 matching lines @@
 
 - (void)promoViewAcceptTapped {
   [self userOptedInFromPromo:YES];
 }
 
 - (void)promoViewDeclineTapped {
   [self userOptedInFromPromo:NO];
 }
 
 - (void)promoViewSettingsTapped {
-  base::scoped_nsobject<GenericChromeCommand> command(
-      [[GenericChromeCommand alloc]
-          initWithTag:IDC_SHOW_CONTEXTUAL_SEARCH_SETTINGS]);
+  GenericChromeCommand* command = [[GenericChromeCommand alloc]
+      initWithTag:IDC_SHOW_CONTEXTUAL_SEARCH_SETTINGS];
   UIWindow* main_window = [[UIApplication sharedApplication] keyWindow];
   [main_window chromeExecuteCommand:command];
 }
 
 #pragma mark - ContextualSearchWebStateObserver methods
 
 - (void)webState:(web::WebState*)webState
     pageLoadedWithStatus:(web::PageLoadCompletionStatus)loadStatus {
   if (loadStatus != web::PageLoadCompletionStatus::SUCCESS)
     return;
 
   [self movePanelOffscreen];
   _isScriptInjected = NO;
   [self enableCurrentWebState];
 }
 
 - (void)webStateDestroyed:(web::WebState*)webState {
   [self updateWebViewProxy:nil];
 }
 
 #pragma mark - UIGestureRecognizerDelegate Methods
 
 // Ensures that |_tapRecognizer| and |_doubleTapRecognizer| cooperate with all
 // other gesture recognizers.
 - (BOOL)gestureRecognizer:(UIGestureRecognizer*)gestureRecognizer
     shouldRecognizeSimultaneouslyWithGestureRecognizer:
         (UIGestureRecognizer*)otherGestureRecognizer {
-  return gestureRecognizer == _tapRecognizer.get() ||
-         gestureRecognizer == _doubleTapRecognizer.get();
+  return gestureRecognizer == _tapRecognizer ||
+         gestureRecognizer == _doubleTapRecognizer;
 }
 
 #pragma mark - CRWWebViewScrollViewObserver methods
 
 - (void)webViewScrollViewWillBeginDragging:
     (CRWWebViewScrollViewProxy*)webViewScrollViewProxy {
   [self dismissPane:ContextualSearch::BASE_PAGE_SCROLL];
   [_tapRecognizer setEnabled:NO];
 }
 
@@ skipping 51 matching lines @@
 
 - (void)touchToSearchPermissionsUpdated {
   // This method is already invoked asynchronously, so it's safe to
   // synchronously attempt to enable the feature.
   [self enableContextualSearch:YES];
 }
 
 #pragma mark - ContextualSearchHighlighterDelegate methods
 
 - (void)updateHighlight {
-  base::WeakNSObject<ContextualSearchController> weakSelf(self);
+  __weak ContextualSearchController* weakSelf = self;
   [_contextualSearchJsManager
       highlightRectsWithCompletionHandler:^void(id result, NSError* error) {
         [weakSelf handleHighlightJSResult:result withError:error];
       }];
 }
 
 @end