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

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

 // Copyright 2016 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.
 
 #include "ios/chrome/browser/ui/contextual_search/contextual_search_results_view.h"
 
 #include <memory>
 
-#import "base/ios/weak_nsobject.h"
-#include "base/mac/scoped_nsobject.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #import "ios/chrome/browser/ui/contextual_search/contextual_search_metrics.h"
 #import "ios/chrome/browser/ui/contextual_search/contextual_search_panel_view.h"
 #import "ios/chrome/browser/ui/contextual_search/contextual_search_web_state_observer.h"
 #import "ios/chrome/common/material_timing.h"
 #include "ios/web/public/load_committed_details.h"
 #import "ios/web/public/web_state/crw_web_view_proxy.h"
 #import "ios/web/public/web_state/crw_web_view_scroll_view_proxy.h"
 #import "ios/web/public/web_state/ui/crw_native_content_provider.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 enum SearchResultsViewVisibility { OFFSCREEN, PRELOAD, VISIBLE };
 }
 
 @interface ContextualSearchResultsView ()<ContextualSearchWebStateDelegate,
                                           CRWNativeContentProvider>
 
 // Can the search results be scrolled currently?
 @property(nonatomic, assign, getter=isScrollEnabled) BOOL scrollEnabled;
 @end
 
 @implementation ContextualSearchResultsView {
-  base::WeakNSProtocol<id<ContextualSearchTabPromoter>> _promoter;
-  base::WeakNSProtocol<id<ContextualSearchPreloadChecker>> _preloadChecker;
   std::unique_ptr<ContextualSearchWebStateObserver> _webStateObserver;
 
   // Tab that loads the search results.
-  base::scoped_nsobject<Tab> _tab;
+  Tab* _tab;
 
   // Access to the search tab's web view proxy.
-  base::scoped_nsprotocol<id<CRWWebViewProxy>> _webViewProxy;
+  id<CRWWebViewProxy> _webViewProxy;
 
   BOOL _loaded;
   BOOL _displayed;
   BOOL _loadingError;
   BOOL _waitingForInitialSearchTabLoad;
   BOOL _loadInProgress;
   BOOL _shouldScroll;
 
   BOOL _preloadEnabled;
 
   SearchResultsViewVisibility _visibility;
 
   // Time of starting a search results page load.
   base::Time _loadStartTime;
 }
 
 @synthesize active = _active;
 @synthesize opener = _opener;
+@synthesize promoter = _promoter;
+@synthesize preloadChecker = _preloadChecker;
 
 - (instancetype)initWithFrame:(CGRect)frame {
   if ((self = [super initWithFrame:frame])) {
     self.translatesAutoresizingMaskIntoConstraints = NO;
     self.backgroundColor = [UIColor whiteColor];
     self.accessibilityIdentifier = @"contextualSearchResultsView";
     self.clipsToBounds = YES;
     _webStateObserver.reset(new ContextualSearchWebStateObserver(self));
     _visibility = OFFSCREEN;
   }
@@ skipping 11 matching lines @@
   [[_webViewProxy scrollViewProxy] setBounces:NO];
 }
 
 #pragma mark - public properties
 
 - (id<ContextualSearchTabPromoter>)promoter {
   return _promoter;
 }
 
 - (void)setPromoter:(id<ContextualSearchTabPromoter>)promoter {
-  _promoter.reset(promoter);
+  _promoter = promoter;
 }
 
 - (id<ContextualSearchPreloadChecker>)preloadChecker {
   return _preloadChecker;
 }
 
 - (void)setPreloadChecker:(id<ContextualSearchPreloadChecker>)preloadChecker {
-  _preloadChecker.reset(preloadChecker);
+  _preloadChecker = preloadChecker;
 }
 
 - (BOOL)contentVisible {
   return _loaded && _visibility == VISIBLE;
 }
 
 - (void)setActive:(BOOL)active {
   if (active) {
     // Start watching the embedded Tab's web activity.
     _webStateObserver->ObserveWebState([_tab webState]);
     [[_tab webController] setShouldSuppressDialogs:NO];
-    _webViewProxy.reset([[[_tab webController] webViewProxy] retain]);
+    _webViewProxy = [[_tab webController] webViewProxy];
     [[_webViewProxy scrollViewProxy] setBounces:NO];
   } else {
     // Stop watching the embedded Tab's web activity.
     _webStateObserver->ObserveWebState(nullptr);
-    _webViewProxy.reset(nil);
+    _webViewProxy = nil;
   }
 
   _active = active;
 }
 
 #pragma mark - public methods
 
 - (void)scrollToTopAnimated:(BOOL)animated {
   [[_webViewProxy scrollViewProxy] setBounces:YES];
   // Scroll the search tab's view to the top.
@@ skipping 13 matching lines @@
 
   ui::PageTransition transition = ui::PAGE_TRANSITION_FROM_ADDRESS_BAR;
   Tab* tab = [Tab newPreloadingTabWithBrowserState:self.opener.browserState
                                                url:url
                                           referrer:web::Referrer()
                                         transition:transition
                                           provider:self
                                             opener:self.opener
                                   desktopUserAgent:false
                                      configuration:searchTabConfiguration];
-  _tab.reset([tab retain]);
+  _tab = tab;
   // Don't actually start the page load yet -- that happens in -loadTab
 
   _preloadEnabled = preloadEnabled;
   [self loadPendingSearchIfPossible];
 }
 
 - (Tab*)releaseTab {
   [self disconnectTab];
   // Allow the search tab to be sized by autoresizing mask again.
   [[_tab view] setTranslatesAutoresizingMaskIntoConstraints:YES];
-  return [_tab.release() autorelease];
+  Tab* tab = _tab;
+  _tab = nil;
+  return tab;
 }
 
 - (void)recordFinishedSearchChained:(BOOL)chained {
   base::TimeDelta duration = base::Time::Now() - _loadStartTime;
   ContextualSearch::RecordDuration(self.contentVisible, chained, duration);
 }
 
 #pragma mark - private methods
 
 - (void)disconnectTab {
   [[_tab view] removeFromSuperview];
   [[_tab webController] setNativeProvider:nil];
   self.active = NO;
-  _webViewProxy.reset();
+  _webViewProxy = nil;
 }
 
 - (void)cancelLoad {
   [self disconnectTab];
   _loadInProgress = NO;
   _loaded = NO;
   [_tab close];
-  _tab.reset();
+  _tab = nil;
 }
 
 - (void)loadPendingSearchIfPossible {
   // If the search tab hasn't been created, or if it's already loaded, no-op.
-  if (!_tab.get() || _loadInProgress || self.active || _visibility == OFFSCREEN)
+  if (!_tab || _loadInProgress || self.active || _visibility == OFFSCREEN)
     return;
 
   // If this view is in a position where loading would be "preloading", check
   // if that's allowed.
   if (_visibility == PRELOAD &&
       !([_preloadChecker canPreloadSearchResults] && _preloadEnabled)) {
     return;
   }
   [self loadTab];
 }
 
 - (void)loadTab {
-  DCHECK(_tab.get());
+  DCHECK(_tab);
   // Start observing the search tab.
   self.active = YES;
   // TODO(crbug.com/546223): See if |_waitingForInitialSearchTabLoad| and
   // |_loadInProgress| can be consolidated.
   _waitingForInitialSearchTabLoad = YES;
   // Mark the start of the time for the search.
   _loadStartTime = base::Time::Now();
   // Start the load by asking for the tab's view, but making it hidden.
   [_tab view].hidden = YES;
   [self addSubview:[_tab view]];
@@ skipping 140 matching lines @@
                                                        withError:error
                                                           isPost:isPost];
 
   if ([errorController respondsToSelector:@selector(setScrollEnabled:)]) {
     [errorController setScrollEnabled:NO];
   }
   return errorController;
 }
 
 @end