[ObjC ARC] Clean up BVC from scoped_nsobject and weak_nsobject.

ios/chrome/browser/ui/browser_view_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/chrome/browser/ui/browser_view_controller.h"
 
 #import <AssetsLibrary/AssetsLibrary.h>
 #import <MobileCoreServices/MobileCoreServices.h>
 #import <PassKit/PassKit.h>
 #import <Photos/Photos.h>
 #import <QuartzCore/QuartzCore.h>
 
 #include <stdint.h>
 #include <cmath>
 #include <memory>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/i18n/rtl.h"
 #include "base/ios/block_types.h"
 #include "base/ios/ios_util.h"
-#include "base/ios/weak_nsobject.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
-
-#import "base/mac/scoped_block.h"
 #import "base/mac/scoped_nsobject.h"

[marq (ping after 24h), 2017/04/06 14:54:55]

Presumably this is still needed to access public scoped_nsobject properties or
variables of other objects?

[stkhapugin, 2017/04/06 14:58:29]

No, it's for HeaderDefinition struct that I remove in a follow-up CL.

 #include "base/macros.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/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/bookmarks/browser/base_bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_model.h"
@@ skipping 279 matching lines @@
                                     TabDialogDelegate,
                                     TabHeadersDelegate,
                                     TabModelObserver,
                                     TabSnapshottingDelegate,
                                     UIGestureRecognizerDelegate,
                                     UpgradeCenterClientProtocol,
                                     VoiceSearchBarDelegate,
                                     VoiceSearchBarOwner> {
   // The dependency factory passed on initialization.  Used to vend objects used
   // by the BVC.
-  base::scoped_nsobject<BrowserViewControllerDependencyFactory>
-      _dependencyFactory;
+  BrowserViewControllerDependencyFactory* _dependencyFactory;
 
   // The browser's tab model.
-  base::scoped_nsobject<TabModel> _model;
+  TabModel* _model;
 
   // Facade objects used by |_toolbarController|.
   // Must outlive |_toolbarController|.
   std::unique_ptr<ToolbarModelDelegateIOS> _toolbarModelDelegate;
   std::unique_ptr<ToolbarModelIOS> _toolbarModelIOS;
 
   // Preload controller.  Must outlive |_toolbarController|.
-  base::scoped_nsobject<PreloadController> _preloadController;
+  PreloadController* _preloadController;
 
   // The WebToolbarController used to display the omnibox.
-  base::scoped_nsobject<WebToolbarController> _toolbarController;
+  WebToolbarController* _toolbarController;
 
   // Controller for edge swipe gestures for page and tab navigation.
-  base::scoped_nsobject<SideSwipeController> _sideSwipeController;
+  SideSwipeController* _sideSwipeController;
 
   // Handles displaying the context menu for all form factors.
-  base::scoped_nsobject<ContextMenuCoordinator> _contextMenuCoordinator;
+  ContextMenuCoordinator* _contextMenuCoordinator;
 
   // Backing object for property of the same name.
-  base::scoped_nsobject<DialogPresenter> _dialogPresenter;
+  DialogPresenter* _dialogPresenter;
 
   // Handles presentation of JavaScript dialogs.
   std::unique_ptr<JavaScriptDialogPresenterImpl> _javaScriptDialogPresenter;
 
   // Keyboard commands provider.  It offloads most of the keyboard commands
   // management off of the BVC.
-  base::scoped_nsobject<KeyCommandsProvider> _keyCommandsProvider;
+  KeyCommandsProvider* _keyCommandsProvider;
 
   // Calls to |-relinquishedToolbarController| will set this to yes, and calls
   // to |-reparentToolbarController| will reset it to NO.
   BOOL _isToolbarControllerRelinquished;
 
   // The controller that owns the currently relinquished toolbar controller.
   // The reference is weak because it's possible for the toolbar owner to be
   // deallocated mid-animation due to memory pressure or a tab being closed
   // before the animation is finished.
-  base::WeakNSObject<id> _relinquishedToolbarOwner;
+  __weak id _relinquishedToolbarOwner;
 
   // Always present on tablet; always nil on phone.
-  base::scoped_nsobject<TabStripController> _tabStripController;
+  TabStripController* _tabStripController;
 
   // The contextual search controller.
-  base::scoped_nsobject<ContextualSearchController> _contextualSearchController;
+  ContextualSearchController* _contextualSearchController;
 
   // The contextual search panel (always a subview of |self.view| if it exists).
   ContextualSearchPanelView* _contextualSearchPanel;
 
   // The contextual search mask (always a subview of |self.view| if it exists).
   ContextualSearchMaskView* _contextualSearchMask;
 
   // Used to inject Javascript implementing the PaymentRequest API and to
   // display the UI.
-  base::scoped_nsobject<PaymentRequestManager> _paymentRequestManager;
+  PaymentRequestManager* _paymentRequestManager;
 
   // Used to display the Page Info UI.  Nil if not visible.
-  base::scoped_nsobject<PageInfoViewController> _pageInfoController;
+  PageInfoViewController* _pageInfoController;
 
   // Used to display the Voice Search UI.  Nil if not visible.
   scoped_refptr<VoiceSearchController> _voiceSearchController;
 
   // Used to display the QR Scanner UI. Nil if not visible.
-  base::scoped_nsobject<QRScannerViewController> _qrScannerViewController;
+  QRScannerViewController* _qrScannerViewController;
 
   // Used to display the Reading List.
-  base::scoped_nsobject<ReadingListCoordinator> _readingListCoordinator;
+  ReadingListCoordinator* _readingListCoordinator;
 
   // Used to display the Suggestions.
-  base::scoped_nsobject<ContentSuggestionsCoordinator>
-      _contentSuggestionsCoordinator;
+  ContentSuggestionsCoordinator* _contentSuggestionsCoordinator;
 
   // Used to display the Find In Page UI. Nil if not visible.
-  base::scoped_nsobject<FindBarControllerIOS> _findBarController;
+  FindBarControllerIOS* _findBarController;
 
   // Used to display the Print UI. Nil if not visible.
-  base::scoped_nsobject<PrintController> _printController;
+  PrintController* _printController;
 
   // Records the set of domains for which full screen alert has already been
   // shown.
-  base::scoped_nsobject<NSMutableSet> _fullScreenAlertShown;
+  NSMutableSet* _fullScreenAlertShown;
 
   // Adapter to let BVC be the delegate for WebState.
   std::unique_ptr<web::WebStateDelegateBridge> _webStateDelegate;
 
   // YES if new tab is animating in.
   BOOL _inNewTabAnimation;
 
   // YES if Voice Search should be started when the new tab animation is
   // finished.
   BOOL _startVoiceSearchAfterNewTabAnimation;
@@ skipping 20 matching lines @@
   // A single infobar container handles all infobars in all tabs. It keeps
   // track of infobars for current tab (accessed via infobar helper of
   // the current tab).
   std::unique_ptr<InfoBarContainerIOS> _infoBarContainer;
 
   // Bridge class to deliver container change notifications to BVC.
   std::unique_ptr<InfoBarContainerDelegateIOS> _infoBarContainerDelegate;
 
   // Voice search bar at the bottom of the view overlayed on |_contentArea|
   // when displaying voice search results.
-  base::scoped_nsprotocol<UIView<VoiceSearchBar>*> _voiceSearchBar;
+  UIView<VoiceSearchBar>* _voiceSearchBar;
 
   // The image fetcher used to save images and perform image-based searches.
   std::unique_ptr<image_fetcher::IOSImageDataFetcherWrapper> _imageFetcher;
 
   // Card side swipe view.
-  base::scoped_nsobject<CardSideSwipeView> _sideSwipeView;
+  CardSideSwipeView* _sideSwipeView;
 
   // Dominant color cache. Key: (NSString*)url, val: (UIColor*)dominantColor.
-  base::scoped_nsobject<NSMutableDictionary> _dominantColorCache;
+  NSMutableDictionary* _dominantColorCache;
 
   // Bridge to register for bookmark changes.
   std::unique_ptr<BrowserBookmarkModelBridge> _bookmarkModelBridge;
 
   // Cached pointer to the bookmarks model.
   bookmarks::BookmarkModel* _bookmarkModel;  // weak
 
   // The controller that shows the bookmarking UI after the user taps the star
   // button.
-  base::scoped_nsobject<BookmarkInteractionController>
-      _bookmarkInteractionController;
+  BookmarkInteractionController* _bookmarkInteractionController;
 
   // Used to remove unreferenced external files.
   std::unique_ptr<ExternalFileRemover> _externalFileRemover;
 
   // The currently displayed "Rate This App" dialog, if one exists.
-  base::scoped_nsprotocol<id<AppRatingPrompt>> _rateThisAppDialog;
+  id<AppRatingPrompt> _rateThisAppDialog;
 
   // Maps tab IDs to the most recent native content controller vended to that
   // tab's web controller.
-  base::scoped_nsobject<NSMapTable> _nativeControllersForTabIDs;
+  NSMapTable* _nativeControllersForTabIDs;
 
   // Notifies the toolbar menu of reading list changes.
-  base::scoped_nsobject<ReadingListMenuNotifier> _readingListMenuNotifier;
+  ReadingListMenuNotifier* _readingListMenuNotifier;
 
   // The sender for the last received IDC_VOICE_SEARCH command.
-  base::WeakNSObject<UIView> _voiceSearchButton;
+  __weak UIView* _voiceSearchButton;
 
   // Coordinator for displaying alerts.
-  base::scoped_nsobject<AlertCoordinator> _alertCoordinator;
-
-  // Releaser for properties that aren't backed by scoped_nsobjects.
+  AlertCoordinator* _alertCoordinator;
 }
 
 // The browser's side swipe controller.  Lazily instantiated on the first call.
 @property(nonatomic, strong, readonly) SideSwipeController* sideSwipeController;
 // The browser's preload controller.
 @property(nonatomic, strong, readonly) PreloadController* preloadController;
 // The dialog presenter for this BVC's tab model.
 @property(nonatomic, strong, readonly) DialogPresenter* dialogPresenter;
 // The object that manages keyboard commands on behalf of the BVC.
 @property(nonatomic, strong, readonly) KeyCommandsProvider* keyCommandsProvider;
@@ skipping 314 matching lines @@
     *arrow_half_width = 0;
     *bar_height = animation.CurrentValueBetween(0, bar_target_height);
   }
 
   void InfoBarContainerStateChanged(bool is_animating) override {
     [controller_ infoBarContainerStateChanged:is_animating];
   }
 
   bool DrawInfoBarArrows(int* x) const override { return false; }
 
-  BrowserViewController* controller_;  // weak
+  __weak BrowserViewController* controller_;  // weak
 };
 
 // Called from the BrowserBookmarkModelBridge from C++ -> ObjC.
 @interface BrowserViewController (BookmarkBridgeMethods)
 // If a bookmark matching the currentTab url is added or moved, update the
 // toolbar state so the star highlight is in sync.
 - (void)bookmarkNodeModified:(const BookmarkNode*)node;
 - (void)allBookmarksRemoved;
 @end
 
@@ skipping 38 matching lines @@
   void BookmarkNodeChildrenReordered(bookmarks::BookmarkModel* model,
                                      const BookmarkNode* node) override {}
 
   void BookmarkAllUserNodesRemoved(
       bookmarks::BookmarkModel* model,
       const std::set<GURL>& removed_urls) override {
     [owner_ allBookmarksRemoved];
   }
 
  private:
-  BrowserViewController* owner_;  // Weak.
+  __weak BrowserViewController* owner_;
 };
 
 @implementation BrowserViewController
 
 @synthesize contentArea = _contentArea;
 @synthesize typingShield = _typingShield;
 @synthesize active = _active;
 @synthesize visible = _visible;
 @synthesize viewVisible = _viewVisible;
 @synthesize dismissingModal = _dismissingModal;
 @synthesize hideStatusBar = _hideStatusBar;
 @synthesize activityOverlayCoordinator = _activityOverlayCoordinator;
 @synthesize presenting = _presenting;
 
 #pragma mark - Object lifecycle
 
 - (instancetype)initWithTabModel:(TabModel*)model
                     browserState:(ios::ChromeBrowserState*)browserState
                dependencyFactory:
                    (BrowserViewControllerDependencyFactory*)factory {
   self = [super initWithNibName:nil bundle:base::mac::FrameworkBundle()];
   if (self) {
     DCHECK(factory);
 
-    _dependencyFactory.reset(factory);
-    _nativeControllersForTabIDs.reset([NSMapTable strongToWeakObjectsMapTable]);
-    _dialogPresenter.reset([[DialogPresenter alloc] initWithDelegate:self
-                                            presentingViewController:self]);
+    _dependencyFactory = factory;
+    _nativeControllersForTabIDs = [NSMapTable strongToWeakObjectsMapTable];
+    _dialogPresenter = [[DialogPresenter alloc] initWithDelegate:self
+                                        presentingViewController:self];
     _javaScriptDialogPresenter.reset(
         new JavaScriptDialogPresenterImpl(_dialogPresenter));
     _webStateDelegate.reset(new web::WebStateDelegateBridge(self));
     // TODO(leng): Delay this.
     [[UpgradeCenter sharedInstance] registerClient:self];
     _inNewTabAnimation = NO;
     if (model && browserState)
       [self updateWithTabModel:model browserState:browserState];
     if ([[NSUserDefaults standardUserDefaults]
             boolForKey:@"fullScreenShowAlert"]) {
-      _fullScreenAlertShown.reset([[NSMutableSet alloc] init]);
+      _fullScreenAlertShown = [[NSMutableSet alloc] init];
     }
   }
   return self;
 }
 
 - (instancetype)initWithNibName:(NSString*)nibNameOrNil
                          bundle:(NSBundle*)nibBundleOrNil {
   NOTREACHED();
   return nil;
 }
 
 - (instancetype)initWithCoder:(NSCoder*)aDecoder {
   NOTREACHED();
   return nil;
 }
 
 - (void)dealloc {
-  _tabStripController.reset();
-  _infoBarContainer.reset();
-  _readingListMenuNotifier.reset();
+  _tabStripController = nil;
+  _infoBarContainer = nil;
+  _readingListMenuNotifier = nil;
   if (_bookmarkModel)
     _bookmarkModel->RemoveObserver(_bookmarkModelBridge.get());
   [_model removeObserver:self];
   [[UpgradeCenter sharedInstance] unregisterClient:self];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [_toolbarController setDelegate:nil];
-  if (_voiceSearchController.get())
+  if (_voiceSearchController)
     _voiceSearchController->SetDelegate(nil);
   [_rateThisAppDialog setDelegate:nil];
   [_model closeAllTabs];
 }
 
 #pragma mark - Accessibility
 
 - (BOOL)accessibilityPerformEscape {
   [self dismissPopups];
   return YES;
@@ skipping 59 matching lines @@
 
 - (BOOL)isPlayingTTS {
   return _voiceSearchController && _voiceSearchController->IsPlayingAudio();
 }
 
 - (ios::ChromeBrowserState*)browserState {
   return _browserState;
 }
 
 - (TabModel*)tabModel {
-  return _model.get();
+  return _model;
 }
 
 - (SideSwipeController*)sideSwipeController {
   if (!_sideSwipeController) {
-    _sideSwipeController.reset([[SideSwipeController alloc]
-        initWithTabModel:_model
-            browserState:_browserState]);
+    _sideSwipeController =
+        [[SideSwipeController alloc] initWithTabModel:_model
+                                         browserState:_browserState];
     [_sideSwipeController setSnapshotDelegate:self];
     [_sideSwipeController setSwipeDelegate:self];
   }
   return _sideSwipeController;
 }
 
 - (PreloadController*)preloadController {
-  return _preloadController.get();
+  return _preloadController;
 }
 
 - (DialogPresenter*)dialogPresenter {
   return _dialogPresenter;
 }
 
 - (BOOL)canUseReaderMode {
   Tab* tab = [_model currentTab];
   if ([self isTabNativePage:tab])
     return NO;
@@ skipping 127 matching lines @@
   // Install fake status bar for iPad iOS7
   [self installFakeStatusBar];
   [self buildToolbarAndTabStrip];
   [self setUpViewLayout];
   // If the tab model and browser state are valid, finish initialization.
   if (_model && _browserState)
     [self addUIFunctionalityForModelAndBrowserState];
 
   // Add a tap gesture recognizer to save the last tap location for the source
   // location of the new tab animation.
-  base::scoped_nsobject<UITapGestureRecognizer> tapRecognizer(
-      [[UITapGestureRecognizer alloc]
-          initWithTarget:self
-                  action:@selector(saveContentAreaTapLocation:)]);
+  UITapGestureRecognizer* tapRecognizer = [[UITapGestureRecognizer alloc]
+      initWithTarget:self
+              action:@selector(saveContentAreaTapLocation:)];
   [tapRecognizer setDelegate:self];
   [tapRecognizer setCancelsTouchesInView:NO];
   [_contentArea addGestureRecognizer:tapRecognizer];
 }
 
 - (void)viewDidAppear:(BOOL)animated {
   [super viewDidAppear:animated];
   self.viewVisible = YES;
   [self updateDialogPresenterActiveState];
 }
@@ skipping 70 matching lines @@
             _browserState);
     if (loader)
       loader->PurgeCache();
   }
 
   if (![self isViewLoaded]) {
     // Do not release |_infoBarContainer|, as this must have the same lifecycle
     // as the BrowserViewController.
     self.contentArea = nil;
     self.typingShield = nil;
-    if (_voiceSearchController.get())
+    if (_voiceSearchController)
       _voiceSearchController->SetDelegate(nil);
-    _contentSuggestionsCoordinator.reset();
-    _qrScannerViewController.reset();
-    _readingListCoordinator.reset();
-    _toolbarController.reset();
-    _toolbarModelDelegate.reset();
-    _toolbarModelIOS.reset();
-    _tabStripController.reset();
-    _sideSwipeController.reset();
+    _contentSuggestionsCoordinator = nil;
+    _qrScannerViewController = nil;
+    _readingListCoordinator = nil;
+    _toolbarController = nil;
+    _toolbarModelDelegate = nil;
+    _toolbarModelIOS = nil;
+    _tabStripController = nil;
+    _sideSwipeController = nil;
   }
 }
 
 - (void)traitCollectionDidChange:(UITraitCollection*)previousTraitCollection {
   [super traitCollectionDidChange:previousTraitCollection];
   // TODO(crbug.com/527092): - traitCollectionDidChange: is not always forwarded
   // because in some cases the presented view controller isn't a child of the
   // BVC in the view controller hierarchy (some intervening object isn't a
   // view controller).
   [self.presentedViewController
@@ skipping 14 matching lines @@
 - (void)reshowFindBarIfNeededWithCoordinator:
     (id<UIViewControllerTransitionCoordinator>)coordinator {
   if (![_findBarController isFindInPageShown])
     return;
 
   // Record focused state.
   BOOL isFocusedBeforeReshow = [_findBarController isFocused];
 
   [self hideFindBarWithAnimation:NO];
 
-  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  __weak BrowserViewController* weakSelf = self;
   void (^completion)(id<UIViewControllerTransitionCoordinatorContext>) = ^(
       id<UIViewControllerTransitionCoordinatorContext> context) {
-    base::scoped_nsobject<BrowserViewController> strongSelf(weakSelf);
+    BrowserViewController* strongSelf = weakSelf;
     if (strongSelf)
       [strongSelf showFindBarWithAnimation:NO
                                 selectText:NO
                                shouldFocus:isFocusedBeforeReshow];
   };
 
   BOOL enqueued =
       [coordinator animateAlongsideTransition:nil completion:completion];
   if (!enqueued) {
     completion(nil);
   }
 }
 
 - (void)dismissViewControllerAnimated:(BOOL)flag
                            completion:(void (^)())completion {
   self.dismissingModal = YES;
-  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  __weak BrowserViewController* weakSelf = self;
   [super dismissViewControllerAnimated:flag
                             completion:^{
-                              base::scoped_nsobject<BrowserViewController>
-                                  strongSelf(weakSelf);
+                              BrowserViewController* strongSelf = weakSelf;
                               [strongSelf setDismissingModal:NO];
                               [strongSelf setPresenting:NO];
                               if (completion)
                                 completion();
                               [[strongSelf dialogPresenter] tryToPresent];
                             }];
 }
 
 - (void)presentViewController:(UIViewController*)viewControllerToPresent
                      animated:(BOOL)flag
                    completion:(void (^)())completion {
-  base::mac::ScopedBlock<ProceduralBlock> finalCompletionHandler(
-      [completion copy]);
+  ProceduralBlock finalCompletionHandler = [completion copy];
   // TODO(crbug.com/580098) This is an interim fix for the flicker between the
   // launch screen and the FRE Animation. The fix is, if the FRE is about to be
   // presented, to show a temporary view of the launch screen and then remove it
   // when the controller for the FRE has been presented. This fix should be
   // removed when the FRE startup code is rewritten.
   BOOL firstRunLaunch = (FirstRun::IsChromeFirstRun() ||
                          experimental_flags::AlwaysDisplayFirstRun()) &&
                         !tests_hook::DisableFirstRun();
   // These if statements check that |presentViewController| is being called for
   // the FRE case.
@@ skipping 15 matching lines @@
       // |launchScreenView| is loaded as an autoreleased object, and is retained
       // by the |completion| block below.
       UIView* launchScreenView = launchScreenController.view;
       launchScreenView.userInteractionEnabled = NO;
       launchScreenView.frame = self.view.window.bounds;
       [self.view.window addSubview:launchScreenView];
 
       // Replace the completion handler sent to the superclass with one which
       // removes |launchScreenView| and resets the status bar. If |completion|
       // exists, it is called from within the new completion handler.
-      base::WeakNSObject<BrowserViewController> weakSelf(self);
-      finalCompletionHandler.reset([^{
+      __weak BrowserViewController* weakSelf = self;
+      finalCompletionHandler = ^{
         [launchScreenView removeFromSuperview];
-        weakSelf.get().hideStatusBar = NO;
+        weakSelf.hideStatusBar = NO;
         if (completion)
           completion();
-      } copy]);
+      };
     }
   }
 
   self.presenting = YES;
   if ([_sideSwipeController inSwipe]) {
     [_sideSwipeController resetContentView];
   }
 
   [super presentViewController:viewControllerToPresent
                       animated:flag
@@ skipping 155 matching lines @@
           startVoiceSearchIfNecessaryBlock();
         });
   } else {
     // -updateSnapshotWithOverlay will force a screen redraw, so take the
     // snapshot before adding the views needed for the background animation.
     Tab* topTab = [_model currentTab];
     UIImage* image = [topTab updateSnapshotWithOverlay:YES
                                       visibleFrameOnly:self.isToolbarOnScreen];
     // Add three layers in order on top of the contentArea for the animation:
     // 1. The black "background" screen.
-    base::scoped_nsobject<UIView> background(
-        [[UIView alloc] initWithFrame:[_contentArea bounds]]);
+    UIView* background = [[UIView alloc] initWithFrame:[_contentArea bounds]];
     InstallBackgroundInView(background);
     [_contentArea addSubview:background];
 
     // 2. A CardView displaying the data from the current tab.
     CardView* topCard = [self addCardViewInFullscreen:!self.isToolbarOnScreen];
     NSString* title = [topTab title];
     if (![title length])
       title = [topTab urlDisplayString];
     [topCard setTitle:title];
     [topCard setFavicon:[topTab favicon]];
@@ skipping 20 matching lines @@
 #pragma mark - UI Configuration and Layout
 
 - (void)updateWithTabModel:(TabModel*)model
               browserState:(ios::ChromeBrowserState*)browserState {
   DCHECK(model);
   DCHECK(browserState);
   DCHECK(!_model);
   DCHECK(!_browserState);
   _browserState = browserState;
   _isOffTheRecord = browserState->IsOffTheRecord() ? YES : NO;
-  _model.reset(model);
+  _model = model;
   [_model addObserver:self];
 
   if (!_isOffTheRecord) {
     [DefaultIOSWebViewFactory
         registerWebViewFactory:[ChromeWebViewFactory class]];
   }
   NSUInteger count = [_model count];
   for (NSUInteger index = 0; index < count; ++index)
     [self installDelegatesForTab:[_model tabAtIndex:index]];
 
   [self registerForNotifications];
 
   _imageFetcher = base::MakeUnique<image_fetcher::IOSImageDataFetcherWrapper>(
       _browserState->GetRequestContext(), web::WebThread::GetBlockingPool());
-  _dominantColorCache.reset([[NSMutableDictionary alloc] init]);
+  _dominantColorCache = [[NSMutableDictionary alloc] init];
 
   // Register for bookmark changed notification (BookmarkModel may be null
   // during testing, so explicitly support this).
   _bookmarkModel = ios::BookmarkModelFactory::GetForBrowserState(_browserState);
   if (_bookmarkModel) {
     _bookmarkModelBridge.reset(new BrowserBookmarkModelBridge(self));
     _bookmarkModel->AddObserver(_bookmarkModelBridge.get());
   }
 }
 
 - (void)ensureViewCreated {
   ignore_result([self view]);
 }
 
 - (void)browserStateDestroyed {
   [self setActive:NO];
   // Reset the toolbar opacity in case it was changed for contextual search.
   [self updateToolbarControlsAlpha:1.0];
   [self updateToolbarBackgroundAlpha:1.0];
   [_contextualSearchController close];
-  _contextualSearchController.reset();
+  _contextualSearchController = nil;
   [_contextualSearchPanel removeFromSuperview];
   [_contextualSearchMask removeFromSuperview];
   [_paymentRequestManager close];
-  _paymentRequestManager.reset();
+  _paymentRequestManager = nil;
   [_toolbarController browserStateDestroyed];
   [_model browserStateDestroyed];
   [_preloadController browserStateDestroyed];
-  _preloadController.reset();
+  _preloadController = nil;
   // The file remover needs the browser state, so needs to be destroyed now.
-  _externalFileRemover.reset();
+  _externalFileRemover = nil;
   _browserState = nullptr;
 }
 
 - (void)installFakeStatusBar {
   if (IsIPadIdiom()) {
     CGFloat statusBarHeight = StatusBarHeight();
     CGRect statusBarFrame =
         CGRectMake(0, 0, [[self view] frame].size.width, statusBarHeight);
-    base::scoped_nsobject<UIView> statusBarView(
-        [[UIView alloc] initWithFrame:statusBarFrame]);
+    UIView* statusBarView = [[UIView alloc] initWithFrame:statusBarFrame];
     [statusBarView setBackgroundColor:TabStrip::BackgroundColor()];
     [statusBarView setAutoresizingMask:UIViewAutoresizingFlexibleWidth];
     [statusBarView layer].zPosition = 99;
     [[self view] addSubview:statusBarView];
   }
 
   // Add a white bar on phone so that the status bar on the NTP is white.
   if (!IsIPadIdiom()) {
     CGFloat statusBarHeight = StatusBarHeight();
     CGRect statusBarFrame =
         CGRectMake(0, 0, [[self view] frame].size.width, statusBarHeight);
-    base::scoped_nsobject<UIView> statusBarView(
-        [[UIView alloc] initWithFrame:statusBarFrame]);
+    UIView* statusBarView = [[UIView alloc] initWithFrame:statusBarFrame];
     [statusBarView setBackgroundColor:[UIColor whiteColor]];
     [statusBarView setAutoresizingMask:UIViewAutoresizingFlexibleWidth];
     [self.view insertSubview:statusBarView atIndex:0];
   }
 }
 
 // Create the UI elements.  May or may not have valid browser state & tab model.
 - (void)buildToolbarAndTabStrip {
   DCHECK([self isViewLoaded]);
   DCHECK(!_toolbarModelDelegate);
 
   // Create the preload controller before the toolbar controller.
   if (!_preloadController) {
-    _preloadController.reset([_dependencyFactory newPreloadController]);
+    _preloadController = [_dependencyFactory newPreloadController];
     [_preloadController setDelegate:self];
   }
 
   // Create the toolbar model and controller.
   _toolbarModelDelegate.reset(
       new ToolbarModelDelegateIOS([_model webStateList]));
   _toolbarModelIOS.reset([_dependencyFactory
       newToolbarModelIOSWithDelegate:_toolbarModelDelegate.get()]);
-  _toolbarController.reset([_dependencyFactory
+  _toolbarController = [_dependencyFactory
       newWebToolbarControllerWithDelegate:self
                                 urlLoader:self
-                          preloadProvider:_preloadController.get()]);
+                          preloadProvider:_preloadController];
   [_toolbarController setTabCount:[_model count]];
-  if (_voiceSearchController.get())
+  if (_voiceSearchController)
     _voiceSearchController->SetDelegate(_toolbarController);
 
   // If needed, create the tabstrip.
   if (IsIPadIdiom()) {
-    _tabStripController.reset(
-        [_dependencyFactory newTabStripControllerWithTabModel:_model]);
-    _tabStripController.get().fullscreenDelegate = self;
+    _tabStripController =
+        [_dependencyFactory newTabStripControllerWithTabModel:_model];
+    _tabStripController.fullscreenDelegate = self;
   }
 
   // Create infobar container.
   if (!_infoBarContainerDelegate) {
     _infoBarContainerDelegate.reset(new InfoBarContainerDelegateIOS(self));
     _infoBarContainer.reset(
         new InfoBarContainerIOS(_infoBarContainerDelegate.get()));
   }
 }
 
@@ skipping 12 matching lines @@
 
   // Create contextual search views and controller.
   if ([TouchToSearchPermissionsMediator isTouchToSearchAvailableOnDevice] &&
       !_browserState->IsOffTheRecord()) {
     _contextualSearchMask = [[ContextualSearchMaskView alloc] init];
     [self.view insertSubview:_contextualSearchMask
                 belowSubview:[_toolbarController view]];
     _contextualSearchPanel = [self createPanelView];
     [self.view insertSubview:_contextualSearchPanel
                 aboveSubview:[_toolbarController view]];
-    _contextualSearchController.reset([[ContextualSearchController alloc]
-        initWithBrowserState:_browserState
-                    delegate:self]);
+    _contextualSearchController =
+        [[ContextualSearchController alloc] initWithBrowserState:_browserState
+                                                        delegate:self];
     [_contextualSearchController setPanel:_contextualSearchPanel];
     [_contextualSearchController setTab:[_model currentTab]];
   }
 
   if (experimental_flags::IsPaymentRequestEnabled()) {
-    _paymentRequestManager.reset([[PaymentRequestManager alloc]
+    _paymentRequestManager = [[PaymentRequestManager alloc]
         initWithBaseViewController:self
-                      browserState:_browserState]);
+                      browserState:_browserState];
     [_paymentRequestManager setWebState:[_model currentTab].webState];
   }
 }
 
 // Set the frame for the various views. View must be loaded.
 - (void)setUpViewLayout {
   DCHECK([self isViewLoaded]);
 
   CGFloat widthOfView = CGRectGetWidth([self view].bounds);
 
@@ skipping 84 matching lines @@
   if (newSelection)
     [_toolbarController selectedTabChanged];
 
   // Notify the Tab that it was displayed.
   [tab wasShown];
 }
 
 - (void)initializeBookmarkInteractionController {
   if (_bookmarkInteractionController)
     return;
-  _bookmarkInteractionController.reset([[BookmarkInteractionController alloc]
-      initWithBrowserState:_browserState
-                    loader:self
-          parentController:self]);
+  _bookmarkInteractionController =
+      [[BookmarkInteractionController alloc] initWithBrowserState:_browserState
+                                                           loader:self
+                                                 parentController:self];
 }
 
 // Update the state of back and forward buttons, hiding the forward button if
 // there is nowhere to go. Assumes the model's current tab is up to date.
 - (void)updateToolbar {
   // If the BVC has been partially torn down for low memory, wait for the
   // view rebuild to handle toolbar updates.
   if (!(_toolbarModelIOS && _browserState))
     return;
 
@@ skipping 241 matching lines @@
   if (!self.visible || ![_model webUsageEnabled])
     return;
 
   [self displayTab:tab isNewSelection:YES];
 
   if (_expectingForegroundTab && !_inNewTabAnimation) {
     // Now that the new tab has been displayed, return to normal. Rather than
     // keep a reference to the previous tab, just turn off preview mode for all
     // tabs (since doing so is a no-op for the tabs that don't have it set).
     _expectingForegroundTab = NO;
-    for (Tab* tab in _model.get()) {
+    for (Tab* tab in _model) {
       [tab.webController setOverlayPreviewMode:NO];
     }
   }
 }
 
 #pragma mark - External files
 
 - (NSSet*)referencedExternalFiles {
   NSSet* filesReferencedByTabs = [_model currentlyReferencedExternalFiles];
 
@@ skipping 33 matching lines @@
 #pragma mark - SnapshotOverlayProvider methods
 
 - (NSArray*)snapshotOverlaysForTab:(Tab*)tab {
   NSMutableArray* overlays = [NSMutableArray array];
   if (![_model webUsageEnabled]) {
     return overlays;
   }
   UIView* voiceSearchView = [self voiceSearchOverlayViewForTab:tab];
   if (voiceSearchView) {
     CGFloat voiceSearchYOffset = [self voiceSearchOverlayYOffsetForTab:tab];
-    base::scoped_nsobject<SnapshotOverlay> voiceSearchOverlay(
+    SnapshotOverlay* voiceSearchOverlay =
         [[SnapshotOverlay alloc] initWithView:voiceSearchView
-                                      yOffset:voiceSearchYOffset]);
+                                      yOffset:voiceSearchYOffset];
     [overlays addObject:voiceSearchOverlay];
   }
   UIView* infoBarView = [self infoBarOverlayViewForTab:tab];
   if (infoBarView) {
     CGFloat infoBarYOffset = [self infoBarOverlayYOffsetForTab:tab];
-    base::scoped_nsobject<SnapshotOverlay> infoBarOverlay(
+    SnapshotOverlay* infoBarOverlay =
         [[SnapshotOverlay alloc] initWithView:infoBarView
-                                      yOffset:infoBarYOffset]);
+                                      yOffset:infoBarYOffset];
     [overlays addObject:infoBarOverlay];
   }
   return overlays;
 }
 
 #pragma mark -
 
 - (UIView*)infoBarOverlayViewForTab:(Tab*)tab {
   if (IsIPadIdiom()) {
     // Not using overlays on iPad because the content is pushed down by
     // infobar and the transition between snapshot and fresh page can
     // cause both snapshot and real infobars to appear at the same time.
     return nil;
   }
   Tab* currentTab = [_model currentTab];
   if (tab && tab == currentTab) {
     infobars::InfoBarManager* infoBarManager = [currentTab infoBarManager];
     if (infoBarManager->infobar_count() > 0) {
       DCHECK(_infoBarContainer);
       return _infoBarContainer->view();
     }
   }
   return nil;
 }
 
 - (CGFloat)infoBarOverlayYOffsetForTab:(Tab*)tab {
-  if (tab != [_model currentTab] || !_infoBarContainer.get()) {
+  if (tab != [_model currentTab] || !_infoBarContainer) {
     // There is no UI representation for non-current tabs or there is
     // no _infoBarContainer instantiated yet.
     // Return offset outside of tab.
     return CGRectGetMaxY(self.view.frame);
   } else if (IsIPadIdiom()) {
     // The infobars on iPad are display at the top of a tab.
     return CGRectGetMinY([[_model currentTab].webController visibleFrame]);
   } else {
     // The infobars on iPhone are displayed at the bottom of a tab.
     CGRect visibleFrame = [[_model currentTab].webController visibleFrame];
@@ skipping 17 matching lines @@
     // no visible voice search. Return offset outside of tab.
     return CGRectGetMaxY(self.view.frame);
   } else {
     // The voice search bar on iPhone is displayed at the bottom of a tab.
     CGRect visibleFrame = [[_model currentTab].webController visibleFrame];
     return CGRectGetMaxY(visibleFrame) - kVoiceSearchBarHeight;
   }
 }
 
 - (void)ensureVoiceSearchControllerCreated {
-  if (!_voiceSearchController.get()) {
+  if (!_voiceSearchController) {
     VoiceSearchProvider* provider =
         ios::GetChromeBrowserProvider()->GetVoiceSearchProvider();
     if (provider) {
       _voiceSearchController =
           provider->CreateVoiceSearchController(_browserState);
       _voiceSearchController->SetDelegate(_toolbarController);
     }
   }
 }
 
 - (void)ensureVoiceSearchBarCreated {
   if (_voiceSearchBar)
     return;
 
   CGFloat width = CGRectGetWidth([[self view] bounds]);
   CGFloat y = CGRectGetHeight([[self view] bounds]) - kVoiceSearchBarHeight;
   CGRect frame = CGRectMake(0.0, y, width, kVoiceSearchBarHeight);
-  _voiceSearchBar.reset(ios::GetChromeBrowserProvider()
-                            ->GetVoiceSearchProvider()
-                            ->BuildVoiceSearchBar(frame));
+  _voiceSearchBar = ios::GetChromeBrowserProvider()
+                        ->GetVoiceSearchProvider()
+                        ->BuildVoiceSearchBar(frame);
   [_voiceSearchBar setVoiceSearchBarDelegate:self];
   [_voiceSearchBar setHidden:YES];
   [_voiceSearchBar setAutoresizingMask:UIViewAutoresizingFlexibleTopMargin |
                                        UIViewAutoresizingFlexibleWidth];
   [self.view insertSubview:_voiceSearchBar
               belowSubview:_infoBarContainer->view()];
 }
 
 - (void)updateVoiceSearchBarVisibilityAnimated:(BOOL)animated {
   // Voice search bar exists and is shown/hidden.
   BOOL show = self.shouldShowVoiceSearchBar;
-  if (_voiceSearchBar && _voiceSearchBar.get().hidden != show)
+  if (_voiceSearchBar && _voiceSearchBar.hidden != show)
     return;
 
   // Voice search bar doesn't exist and thus is not visible.
   if (!_voiceSearchBar && !show)
     return;
 
   if (animated)
-    [_voiceSearchBar.get() animateToBecomeVisible:show];
+    [_voiceSearchBar animateToBecomeVisible:show];
   else
-    _voiceSearchBar.get().hidden = !show;
+    _voiceSearchBar.hidden = !show;
 }
 
 - (id<LogoAnimationControllerOwner>)currentLogoAnimationControllerOwner {
   Protocol* ownerProtocol = @protocol(LogoAnimationControllerOwner);
   if ([_voiceSearchBar conformsToProtocol:ownerProtocol] &&
       self.shouldShowVoiceSearchBar) {
     // Use |_voiceSearchBar| for VoiceSearch results tab and dismissal
     // animations.
-    return static_cast<id<LogoAnimationControllerOwner>>(_voiceSearchBar.get());
+    return static_cast<id<LogoAnimationControllerOwner>>(_voiceSearchBar);
   }
   id currentNativeController =
       [self nativeControllerForTab:self.tabModel.currentTab];
   Protocol* possibleOwnerProtocol =
       @protocol(LogoAnimationControllerOwnerOwner);
   if ([currentNativeController conformsToProtocol:possibleOwnerProtocol] &&
       [currentNativeController logoAnimationControllerOwner]) {
     // If the current native controller is showing a GLIF view (e.g. the NTP
     // when there is no doodle), use that GLIFControllerOwner.
     return [currentNativeController logoAnimationControllerOwner];
   }
   return nil;
 }
 
 #pragma mark - PassKitDialogProvider methods
 
 - (void)presentPassKitDialog:(NSData*)data {
   NSError* error = nil;
-  base::scoped_nsobject<PKPass> pass;
+  PKPass* pass = nil;
   if (data)
-    pass.reset([[PKPass alloc] initWithData:data error:&error]);
+    pass = [[PKPass alloc] initWithData:data error:&error];
   if (error || !data) {
     if ([_model currentTab]) {
       infobars::InfoBarManager* infoBarManager =
           [[_model currentTab] infoBarManager];
       // TODO(crbug.com/227994): Infobar cleanup (infoBarManager should never be
       //            NULL, replace if with DCHECK).
       if (infoBarManager)
         [_dependencyFactory showPassKitErrorInfoBarForManager:infoBarManager];
     }
   } else {
@@ skipping 112 matching lines @@
   }
 
   // No custom context menu if no valid url is available in |params|.
   if (!params.link_url.is_valid() && !params.src_url.is_valid()) {
     return NO;
   }
 
   DCHECK(_browserState);
   DCHECK([_model currentTab]);
 
-  _contextMenuCoordinator.reset([[ContextMenuCoordinator alloc]
-      initWithBaseViewController:self
-                          params:params]);
+  _contextMenuCoordinator =
+      [[ContextMenuCoordinator alloc] initWithBaseViewController:self
+                                                          params:params];
 
   NSString* title = nil;
   ProceduralBlock action = nil;
 
-  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  __weak BrowserViewController* weakSelf = self;
   GURL link = params.link_url;
   bool isLink = link.is_valid();
   GURL imageUrl = params.src_url;
   bool isImage = imageUrl.is_valid();
 
   if (isLink) {
     if (link.SchemeIs(url::kJavaScriptScheme)) {
       // Open
       title = l10n_util::GetNSStringWithFixup(IDS_IOS_CONTENT_CONTEXT_OPEN);
       action = ^{
@@ skipping 604 matching lines @@
       break;
     }
   }
 }
 
 #pragma mark - Context menu methods
 
 - (void)searchByImageAtURL:(const GURL&)url
                   referrer:(const web::Referrer)referrer {
   DCHECK(url.is_valid());
-  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  __weak BrowserViewController* weakSelf = self;
   const GURL image_source_url = url;
   image_fetcher::IOSImageDataFetcherCallback callback = ^(
       NSData* data, const image_fetcher::RequestMetadata& metadata) {
     DCHECK(data);
     dispatch_async(dispatch_get_main_queue(), ^{
       [weakSelf searchByImageData:data atURL:image_source_url];
     });
   };
   _imageFetcher->FetchImageDataWebpDecoded(
       url, callback, web::ReferrerHeaderValueForNavigation(url, referrer),
@@ skipping 158 matching lines @@
 
 - (void)displayImageErrorAlertWithSettings:(NSURL*)settingURL {
   // Dismiss current alert.
   [_alertCoordinator stop];
 
   NSString* title =
       l10n_util::GetNSString(IDS_IOS_SAVE_IMAGE_PRIVACY_ALERT_TITLE);
   NSString* message = l10n_util::GetNSString(
       IDS_IOS_SAVE_IMAGE_PRIVACY_ALERT_MESSAGE_GO_TO_SETTINGS);
 
-  _alertCoordinator.reset([[AlertCoordinator alloc]
-      initWithBaseViewController:self
-                           title:title
-                         message:message]);
+  _alertCoordinator =
+      [[AlertCoordinator alloc] initWithBaseViewController:self
+                                                     title:title
+                                                   message:message];
 
   [_alertCoordinator addItemWithTitle:l10n_util::GetNSString(IDS_CANCEL)
                                action:nil
                                 style:UIAlertActionStyleCancel];
 
   [_alertCoordinator
       addItemWithTitle:l10n_util::GetNSString(
                            IDS_IOS_SAVE_IMAGE_PRIVACY_ALERT_GO_TO_SETTINGS)
                 action:^{
                   OpenUrlWithCompletionHandler(settingURL, nil);
@@ skipping 38 matching lines @@
   DCHECK(_browserState);
   DCHECK(self.visible || self.dismissingModal);
 
   // Dismiss the omnibox (if open).
   [_toolbarController cancelOmniboxEdit];
   // Dismiss the soft keyboard (if open).
   [[_model currentTab].webController dismissKeyboard];
   // Dismiss Find in Page focus.
   [self updateFindBar:NO shouldFocus:NO];
 
-  base::scoped_nsobject<ToolsMenuConfiguration> configuration(
-      [[ToolsMenuConfiguration alloc] initWithDisplayView:[self view]]);
+  ToolsMenuConfiguration* configuration =
+      [[ToolsMenuConfiguration alloc] initWithDisplayView:[self view]];
   if ([_model count] == 0)
     [configuration setNoOpenedTabs:YES];
 
   if (_isOffTheRecord)
     [configuration setInIncognito:YES];
 
   if (!_readingListMenuNotifier) {
-    _readingListMenuNotifier.reset([[ReadingListMenuNotifier alloc]
+    _readingListMenuNotifier = [[ReadingListMenuNotifier alloc]
         initWithReadingList:ReadingListModelFactory::GetForBrowserState(
-                                _browserState)]);
+                                _browserState)];
   }
   [configuration setReadingListMenuNotifier:_readingListMenuNotifier];
 
   [configuration setUserAgentType:self.userAgentType];
 
   [_toolbarController showToolsMenuPopupWithConfiguration:configuration];
 
   ToolsPopupController* toolsPopupController =
       [_toolbarController toolsPopupController];
   if ([_model currentTab]) {
@@ skipping 41 matching lines @@
   [[NSNotificationCenter defaultCenter]
       postNotificationName:ios_internal::kPageInfoWillShowNotification
                     object:nil];
 
   // TODO(rohitrao): Get rid of PageInfoModel completely.
   PageInfoModelBubbleBridge* bridge = new PageInfoModelBubbleBridge();
   PageInfoModel* pageInfoModel = new PageInfoModel(
       _browserState, navItem->GetURL(), navItem->GetSSL(), bridge);
 
   UIView* view = [self view];
-  _pageInfoController.reset([[PageInfoViewController alloc]
+  _pageInfoController = [[PageInfoViewController alloc]
       initWithModel:pageInfoModel
              bridge:bridge
         sourceFrame:[sourceView convertRect:[sourceView bounds] toView:view]
-         parentView:view]);
-  bridge->set_controller(_pageInfoController.get());
+         parentView:view];
+  bridge->set_controller(_pageInfoController);
 }
 
 - (void)hidePageInfoPopupForView:(UIView*)sourceView {
   [_pageInfoController dismiss];
-  _pageInfoController.reset();
+  _pageInfoController = nil;
 }
 
 - (void)showSecurityHelpPage {
   [self webPageOrderedOpen:GURL(kPageInfoHelpCenterURL)
                   referrer:web::Referrer()
               inBackground:NO
                   appendTo:kCurrentTab];
   [self hidePageInfoPopupForView:nil];
 }
 
@@ skipping 40 matching lines @@
   Tab* currentTab = [_model currentTab];
   // The UI should prevent users from printing non-printable pages. However, a
   // redirection to an un-printable page can happen before it is reflected in
   // the UI.
   if (![currentTab viewForPrinting]) {
     TriggerHapticFeedbackForNotification(UINotificationFeedbackTypeError);
     [self showSnackbar:l10n_util::GetNSString(IDS_IOS_CANNOT_PRINT_PAGE_ERROR)];
     return;
   }
   DCHECK(_browserState);
-  if (!_printController.get()) {
-    _printController.reset([[PrintController alloc]
-        initWithContextGetter:_browserState->GetRequestContext()]);
+  if (!_printController) {
+    _printController = [[PrintController alloc]
+        initWithContextGetter:_browserState->GetRequestContext()];
   }
   [_printController printView:[currentTab viewForPrinting]
                     withTitle:[currentTab title]
                viewController:self];
 }
 
 - (void)addToReadingListURL:(const GURL&)URL title:(NSString*)title {
   base::RecordAction(UserMetricsAction("MobileReadingListAdd"));
 
   ReadingListModel* readingModel =
@@ skipping 11 matching lines @@
 - (BOOL)shouldRegisterKeyboardCommands {
   if ([self presentedViewController])
     return NO;
 
   if (_voiceSearchController && _voiceSearchController->IsVisible())
     return NO;
 
   // If there is no first responder, try to make the webview the first
   // responder.
   if (!GetFirstResponder()) {
-    [_model.get().currentTab.webController.webViewProxy becomeFirstResponder];
+    [_model.currentTab.webController.webViewProxy becomeFirstResponder];
   }
 
   return YES;
 }
 
 - (KeyCommandsProvider*)keyCommandsProvider {
   if (!_keyCommandsProvider) {
-    _keyCommandsProvider.reset([_dependencyFactory newKeyCommandsProvider]);
+    _keyCommandsProvider = [_dependencyFactory newKeyCommandsProvider];
   }
-  return _keyCommandsProvider.get();
+  return _keyCommandsProvider;
 }
 
 #pragma mark - KeyCommandsPlumbing
 
 - (BOOL)isOffTheRecord {
   return _isOffTheRecord;
 }
 
 - (NSUInteger)tabsCount {
   return [_model count];
@@ skipping 213 matching lines @@
     [self webPageOrderedOpen:url
                     referrer:referrer
                 inBackground:inBackground
                     appendTo:appendTo];
     return;
   }
   // When sending an open command that switches modes, ensure the tab
   // ends up appended to the end of the model, not just next to what is
   // currently selected in the other mode. This is done with the |append|
   // parameter.
-  base::scoped_nsobject<OpenUrlCommand> command([[OpenUrlCommand alloc]
+  OpenUrlCommand* command = [[OpenUrlCommand alloc]
        initWithURL:url
           referrer:web::Referrer()  // Strip referrer when switching modes.
        inIncognito:inIncognito
       inBackground:inBackground
-          appendTo:kLastTab]);
+          appendTo:kLastTab];
   [self chromeExecuteCommand:command];
 }
 
 - (void)loadSessionTab:(const sessions::SessionTab*)sessionTab {
   [[_model currentTab] loadSessionTab:sessionTab];
 }
 
 - (void)openJavascript:(NSString*)javascript {
   DCHECK(javascript);
   javascript = [javascript stringByRemovingPercentEncoding];
@@ skipping 60 matching lines @@
     web::WebState* webState = [_model currentTab].webState;
     if (!_toolbarModelIOS->IsLoading() && webState)
       webState->GetNavigationManager()->Reload(web::ReloadType::NORMAL,
                                                false /* check_for_repost */);
   }
 }
 
 - (IBAction)locationBarBeganEdit:(id)sender {
   // On handsets, if a page is currently loading it should be stopped.
   if (!IsIPadIdiom() && _toolbarModelIOS->IsLoading()) {
-    base::scoped_nsobject<GenericChromeCommand> command(
-        [[GenericChromeCommand alloc] initWithTag:IDC_STOP]);
+    GenericChromeCommand* command =
+        [[GenericChromeCommand alloc] initWithTag:IDC_STOP];
     [self chromeExecuteCommand:command];
     _locationBarEditCancelledLoad = YES;
   }
 }
 
 - (IBAction)prepareToEnterTabSwitcher:(id)sender {
   [[_model currentTab] updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
 }
 
 - (ToolbarModelIOS*)toolbarModelIOS {
@@ skipping 211 matching lines @@
     case IDC_RATE_THIS_APP:
       [self showRateThisAppDialog];
       break;
     case IDC_SHOW_READING_LIST:
       [self showReadingList];
       break;
     case IDC_VOICE_SEARCH:
       // If the voice search command is coming from a UIView sender, store it
       // before sending the command up the responder chain.
       if ([sender isKindOfClass:[UIView class]])
-        _voiceSearchButton.reset(sender);
+        _voiceSearchButton = sender;
       [super chromeExecuteCommand:sender];
       break;
     case IDC_SHOW_QR_SCANNER:
       [self showQRScanner];
       break;
     case IDC_SHOW_SUGGESTIONS:
       if (experimental_flags::IsSuggestionsUIEnabled()) {
         [self showSuggestionsUI];
       }
       break;
@@ skipping 67 matching lines @@
     if (findHelper) {
       findHelper->StopFinding(^{
         [self updateFindBar:NO shouldFocus:NO];
       });
     }
   }
 
   [_contextualSearchController movePanelOffscreen];
   [_paymentRequestManager cancelRequest];
   [_printController dismissAnimated:YES];
-  _printController.reset();
+  _printController = nil;
   [_toolbarController dismissToolsMenuPopup];
   [_contextMenuCoordinator stop];
   [self dismissRateThisAppDialog];
 
   [_contentSuggestionsCoordinator stop];
 
   if (self.presentedViewController) {
     // Dismisses any other modal controllers that may be present, e.g. Recent
     // Tabs.
     // Note that currently, some controllers like the bookmark ones were already
@@ skipping 74 matching lines @@
                           selectText:selectText];
   [self updateFindBar:YES shouldFocus:shouldFocus];
 }
 
 // Create find bar controller and pass it to the web controller.
 - (void)initFindBarForTab {
   if (!self.canShowFindBar)
     return;
 
   if (!_findBarController)
-    _findBarController.reset(
-        [[FindBarControllerIOS alloc] initWithIncognito:_isOffTheRecord]);
+    _findBarController =
+        [[FindBarControllerIOS alloc] initWithIncognito:_isOffTheRecord];
 
   Tab* tab = [_model currentTab];
   DCHECK(tab);
   auto* helper = FindTabHelper::FromWebState(tab.webState);
   DCHECK(!helper->IsFindUIActive());
   helper->SetFindUIActive(true);
   [self showFindBarWithAnimation:YES selectText:YES shouldFocus:YES];
 }
 
 - (void)searchFindInPage {
   DCHECK([_model currentTab]);
   auto* helper = FindTabHelper::FromWebState([_model currentTab].webState);
-  base::WeakNSObject<BrowserViewController> weakSelf(self);
-  helper->StartFinding([_findBarController searchTerm],
-                       ^(FindInPageModel* model) {
-                         [_findBarController updateResultsCount:model];
-                       });
+  __weak BrowserViewController* weakSelf = self;
+  helper->StartFinding(
+      [_findBarController searchTerm], ^(FindInPageModel* model) {
+        BrowserViewController* strongSelf = weakSelf;
+        if (!strongSelf) {
+          return;
+        }
+        [strongSelf->_findBarController updateResultsCount:model];
+      });
 
   if (!_isOffTheRecord)
     helper->PersistSearchTerm();
 }
 
 - (void)closeFindInPage {
-  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  __weak BrowserViewController* weakSelf = self;
   Tab* currentTab = [_model currentTab];
   if (currentTab) {
     FindTabHelper::FromWebState(currentTab.webState)->StopFinding(^{
       [weakSelf updateFindBar:NO shouldFocus:NO];
     });
   }
 }
 
 - (void)updateFindBar:(BOOL)initialUpdate shouldFocus:(BOOL)shouldFocus {
   DCHECK([_model currentTab]);
@@ skipping 16 matching lines @@
 - (void)showAllBookmarks {
   DCHECK(self.visible || self.dismissingModal);
   GURL URL(kChromeUIBookmarksURL);
   Tab* tab = [_model currentTab];
   web::NavigationManager::WebLoadParams params(URL);
   params.transition_type = ui::PAGE_TRANSITION_AUTO_BOOKMARK;
   [tab navigationManager]->LoadURLWithParams(params);
 }
 
 - (void)showReadingList {
-  _readingListCoordinator.reset([[ReadingListCoordinator alloc]
+  _readingListCoordinator = [[ReadingListCoordinator alloc]
       initWithBaseViewController:self
                     browserState:self.browserState
-                          loader:self]);
+                          loader:self];
 
   [_readingListCoordinator start];
 }
 
 - (void)showQRScanner {
-  _qrScannerViewController.reset(
-      [[QRScannerViewController alloc] initWithDelegate:_toolbarController]);
+  _qrScannerViewController =
+      [[QRScannerViewController alloc] initWithDelegate:_toolbarController];
   [self presentViewController:[_qrScannerViewController
                                   getViewControllerToPresent]
                      animated:YES
                    completion:nil];
 }
 
 - (void)showSuggestionsUI {
   if (!_contentSuggestionsCoordinator) {
-    _contentSuggestionsCoordinator.reset([[ContentSuggestionsCoordinator alloc]
-        initWithBaseViewController:self]);
+    _contentSuggestionsCoordinator =
+        [[ContentSuggestionsCoordinator alloc] initWithBaseViewController:self];
     [_contentSuggestionsCoordinator setURLLoader:self];
   }
   [_contentSuggestionsCoordinator setBrowserState:_browserState];
   [_contentSuggestionsCoordinator start];
 }
 
 - (void)showNTPPanel:(NewTabPage::PanelIdentifier)panel {
   DCHECK(self.visible || self.dismissingModal);
   GURL url(kChromeUINewTabURL);
   std::string fragment(NewTabPage::FragmentFromIdentifier(panel));
   if (fragment != "") {
     GURL::Replacements replacement;
     replacement.SetRefStr(fragment);
     url = url.ReplaceComponents(replacement);
   }
   Tab* tab = [_model currentTab];
   web::NavigationManager::WebLoadParams params(url);
   params.transition_type = ui::PAGE_TRANSITION_AUTO_BOOKMARK;
   [tab navigationManager]->LoadURLWithParams(params);
 }
 
 - (void)showRateThisAppDialog {
-  DCHECK(!_rateThisAppDialog.get());
+  DCHECK(!_rateThisAppDialog);
 
   // Store the current timestamp whenever this dialog is shown.
   _browserState->GetPrefs()->SetInt64(prefs::kRateThisAppDialogLastShownTime,
                                       base::Time::Now().ToInternalValue());
 
   // Some versions of iOS7 do not support linking directly to the "Ratings and
   // Reviews" appstore page.  For iOS7 fall back to an alternative URL that
   // links to the main appstore page for the Chrome app.
   NSURL* storeURL =
       [NSURL URLWithString:(@"itms-apps://itunes.apple.com/WebObjects/"
                             @"MZStore.woa/wa/"
                             @"viewContentsUserReviews?type=Purple+Software&id="
                             @"535886823&pt=9008&ct=rating")];
 
   base::RecordAction(base::UserMetricsAction("IOSRateThisAppDialogShown"));
   [self clearPresentedStateWithCompletion:nil];
 
-  _rateThisAppDialog.reset(
-      ios::GetChromeBrowserProvider()->CreateAppRatingPrompt());
+  _rateThisAppDialog = ios::GetChromeBrowserProvider()->CreateAppRatingPrompt();
   [_rateThisAppDialog setAppStoreURL:storeURL];
   [_rateThisAppDialog setDelegate:self];
   [_rateThisAppDialog show];
 }
 
 - (void)dismissRateThisAppDialog {
-  if (_rateThisAppDialog.get()) {
+  if (_rateThisAppDialog) {
     base::RecordAction(base::UserMetricsAction(
         "IOSRateThisAppDialogDismissedProgramatically"));
     [_rateThisAppDialog dismiss];
-    _rateThisAppDialog.reset();
+    _rateThisAppDialog = nil;
   }
 }
 
 #if !defined(NDEBUG)
 - (void)viewSource {
   Tab* tab = [_model currentTab];
   DCHECK(tab);
   CRWWebController* webController = tab.webController;
   NSString* script = @"document.documentElement.outerHTML;";
-  base::WeakNSObject<Tab> weakTab(tab);
-  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  __weak Tab* weakTab = tab;
+  __weak BrowserViewController* weakSelf = self;
   web::JavaScriptResultBlock completionHandlerBlock = ^(id result, NSError*) {
-    base::scoped_nsobject<Tab> strongTab(weakTab);
+    Tab* strongTab = weakTab;
     if (!strongTab)
       return;
     if (![result isKindOfClass:[NSString class]])
       result = @"Not an HTML page";
     std::string base64HTML;
     base::Base64Encode(base::SysNSStringToUTF8(result), &base64HTML);
     GURL URL(std::string("data:text/plain;charset=utf-8;base64,") + base64HTML);
     web::Referrer referrer([strongTab url], web::ReferrerPolicyDefault);
 
     [[weakSelf tabModel]
@@ skipping 40 matching lines @@
 
   ToolbarController* relinquishedToolbarController = nil;
   if ([_toolbarController view].hidden) {
     Tab* currentTab = [_model currentTab];
     if (currentTab && UrlHasChromeScheme(currentTab.url)) {
       // Use the native content controller's toolbar when the BVC's is hidden.
       id nativeController = [self nativeControllerForTab:currentTab];
       if ([nativeController conformsToProtocol:@protocol(ToolbarOwner)]) {
         relinquishedToolbarController =
             [nativeController relinquishedToolbarController];
-        _relinquishedToolbarOwner.reset(nativeController);
+        _relinquishedToolbarOwner = nativeController;
       }
     }
   } else {
-    relinquishedToolbarController = _toolbarController.get();
+    relinquishedToolbarController = _toolbarController;
   }
   _isToolbarControllerRelinquished = (relinquishedToolbarController != nil);
   return relinquishedToolbarController;
 }
 
 - (void)reparentToolbarController {
   if (_isToolbarControllerRelinquished) {
     if ([[_toolbarController view] isDescendantOfView:self.view]) {
       // A native content controller's toolbar has been relinquished.
       [_relinquishedToolbarOwner reparentToolbarController];
-      _relinquishedToolbarOwner.reset();
+      _relinquishedToolbarOwner = nil;
     } else if ([_findBarController isFindInPageShown]) {
       [self.view insertSubview:[_toolbarController view]
                   belowSubview:[_findBarController view]];
     } else {
       [self.view addSubview:[_toolbarController view]];
     }
     if (_contextualSearchPanel) {
       // Move panel back into its correct place.
       [self.view insertSubview:_contextualSearchPanel
                   aboveSubview:[_toolbarController view]];
@@ skipping 20 matching lines @@
 
 // Observer method, active tab changed.
 - (void)tabModel:(TabModel*)model
     didChangeActiveTab:(Tab*)newTab
            previousTab:(Tab*)previousTab
                atIndex:(NSUInteger)index {
   // TODO(rohitrao): tabSelected expects to always be called with a non-nil tab.
   // Currently this observer method is always called with a non-nil |newTab|,
   // but that may change in the future.  Remove this DCHECK when it does.
   DCHECK(newTab);
-  if (_infoBarContainer.get()) {
+  if (_infoBarContainer) {
     infobars::InfoBarManager* infoBarManager = [newTab infoBarManager];
     _infoBarContainer->ChangeInfoBarManager(infoBarManager);
   }
   [self updateVoiceSearchBarVisibilityAnimated:NO];
 
   [_contextualSearchController setTab:newTab];
   [_paymentRequestManager setWebState:newTab.webState];
 
   [self tabSelected:newTab];
   DCHECK_EQ(newTab, [model currentTab]);
@@ skipping 58 matching lines @@
 // Called when the number of tabs changes. Update the toolbar accordingly.
 - (void)tabModelDidChangeTabCount:(TabModel*)model {
   DCHECK(model == _model);
   [_toolbarController setTabCount:[_model count]];
 }
 
 #pragma mark - Upgrade Detection
 
 - (void)showUpgrade:(UpgradeCenter*)center {
   // Add an infobar on all the open tabs.
-  for (Tab* tab in _model.get()) {
+  for (Tab* tab in _model) {
     NSString* tabId = tab.tabId;
     DCHECK([tab infoBarManager]);
     [center addInfoBarToManager:[tab infoBarManager] forTabId:tabId];
   }
 }
 
 #pragma mark - ContextualSearchControllerDelegate
 
 - (void)createTabFromContextualSearchController:(const GURL&)url {
   Tab* currentTab = [_model currentTab];
@@ skipping 375 matching lines @@
   NSString* title = l10n_util::GetNSString(titleMessageId);
   NSString* message = l10n_util::GetNSString(messageId);
   [self showErrorAlertWithStringTitle:title message:message];
 }
 
 - (void)showErrorAlertWithStringTitle:(NSString*)title
                               message:(NSString*)message {
   // Dismiss current alert.
   [_alertCoordinator stop];
 
-  _alertCoordinator.reset([_dependencyFactory alertCoordinatorWithTitle:title
-                                                                message:message
-                                                         viewController:self]);
+  _alertCoordinator = [_dependencyFactory alertCoordinatorWithTitle:title
+                                                            message:message
+                                                     viewController:self];
   [_alertCoordinator start];
 }
 
 - (void)showSnackbar:(NSString*)message {
   [_dependencyFactory showSnackbarWithMessage:message];
 }
 
 #pragma mark - Show Mail Composer methods
 
 - (void)showMailComposer:(id)sender {
   ShowMailComposerCommand* command = (ShowMailComposerCommand*)sender;
   if (![MFMailComposeViewController canSendMail]) {
     NSString* alertTitle =
         l10n_util::GetNSString([command emailNotConfiguredAlertTitleId]);
     NSString* alertMessage =
         l10n_util::GetNSString([command emailNotConfiguredAlertMessageId]);
     [self showErrorAlertWithStringTitle:alertTitle message:alertMessage];
     return;
   }
-  base::scoped_nsobject<MFMailComposeViewController> mailViewController(
-      [[MFMailComposeViewController alloc] init]);
+  MFMailComposeViewController* mailViewController =
+      [[MFMailComposeViewController alloc] init];
   [mailViewController setModalPresentationStyle:UIModalPresentationFormSheet];
   [mailViewController setToRecipients:[command toRecipients]];
   [mailViewController setSubject:[command subject]];
   [mailViewController setMessageBody:[command body] isHTML:NO];
 
   const base::FilePath& textFile = [command textFileToAttach];
   if (!textFile.empty()) {
     NSString* filename = base::SysUTF8ToNSString(textFile.value());
     NSData* data = [NSData dataWithContentsOfFile:filename];
     if (data) {
@@ skipping 22 matching lines @@
 - (void)productViewControllerDidFinish:
     (SKStoreProductViewController*)viewController {
   [self dismissViewControllerAnimated:YES completion:nil];
 }
 
 - (void)openAppStore:(NSString*)appId {
   if (![appId length])
     return;
   NSDictionary* product =
       @{SKStoreProductParameterITunesItemIdentifier : appId};
-  base::scoped_nsobject<SKStoreProductViewController> storeViewController(
-      [[SKStoreProductViewController alloc] init]);
+  SKStoreProductViewController* storeViewController =
+      [[SKStoreProductViewController alloc] init];
   [storeViewController setDelegate:self];
   [storeViewController loadProductWithParameters:product completionBlock:nil];
   [self presentViewController:storeViewController animated:YES completion:nil];
 }
 
 #pragma mark - TabDialogDelegate methods
 
 - (void)cancelDialogForTab:(Tab*)tab {
   [self.dialogPresenter cancelDialogForWebState:tab.webState];
 }
 
 #pragma mark - FKFeedbackPromptDelegate methods
 
 - (void)userTappedRateApp:(UIView*)view {
   base::RecordAction(base::UserMetricsAction("IOSRateThisAppRateChosen"));
-  _rateThisAppDialog.reset();
+  _rateThisAppDialog = nil;
 }
 
 - (void)userTappedSendFeedback:(UIView*)view {
   base::RecordAction(base::UserMetricsAction("IOSRateThisAppFeedbackChosen"));
-  _rateThisAppDialog.reset();
-  base::scoped_nsobject<GenericChromeCommand> command(
-      [[GenericChromeCommand alloc] initWithTag:IDC_REPORT_AN_ISSUE]);
+  _rateThisAppDialog = nil;
+  GenericChromeCommand* command =
+      [[GenericChromeCommand alloc] initWithTag:IDC_REPORT_AN_ISSUE];
   [self chromeExecuteCommand:command];
 }
 
 - (void)userTappedDismiss:(UIView*)view {
   base::RecordAction(base::UserMetricsAction("IOSRateThisAppDismissChosen"));
-  _rateThisAppDialog.reset();
+  _rateThisAppDialog = nil;
 }
 
 #pragma mark - VoiceSearchBarDelegate
 
 - (BOOL)isTTSEnabledForVoiceSearchBar:(id<VoiceSearchBar>)voiceSearchBar {
-  DCHECK_EQ(_voiceSearchBar.get(), voiceSearchBar);
+  DCHECK_EQ(_voiceSearchBar, voiceSearchBar);
   [self ensureVoiceSearchControllerCreated];
   return _voiceSearchController->IsTextToSpeechEnabled() &&
          _voiceSearchController->IsTextToSpeechSupported();
 }
 
 - (void)voiceSearchBarDidUpdateButtonState:(id<VoiceSearchBar>)voiceSearchBar {
-  DCHECK_EQ(_voiceSearchBar.get(), voiceSearchBar);
+  DCHECK_EQ(_voiceSearchBar, voiceSearchBar);
   [self.tabModel.currentTab updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
 }
 
 #pragma mark - VoiceSearchPresenter
 
 - (UIView*)voiceSearchButton {
   return _voiceSearchButton;
 }
 
 - (id<LogoAnimationControllerOwner>)logoAnimationControllerOwner {
   return [self currentLogoAnimationControllerOwner];
 }
 
 @end