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

ios/chrome/browser/ui/bookmarks/bookmark_home_tablet_ntp_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/bookmarks/bookmark_home_tablet_ntp_controller.h"
 
 #include <memory>
 
 #include "base/ios/block_types.h"
-#import "base/ios/weak_nsobject.h"
 #include "base/logging.h"
-#include "base/mac/objc_property_releaser.h"
-#include "base/mac/scoped_nsobject.h"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/strings/grit/components_strings.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "ios/chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "ios/chrome/browser/bookmarks/bookmarks_utils.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #import "ios/chrome/browser/metrics/new_tab_page_uma.h"
@@ skipping 15 matching lines @@
 #import "ios/chrome/browser/ui/bookmarks/bookmark_utils_ios.h"
 #import "ios/chrome/browser/ui/rtl_geometry.h"
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
 #import "ios/chrome/browser/ui/url_loader.h"
 #include "ios/chrome/grit/ios_strings.h"
 #include "ios/web/public/referrer.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "ui/base/page_transition_types.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using bookmarks::BookmarkNode;
 
 namespace {
 // The width of the bookmark menu, displaying the different sections.
 const CGFloat kMenuWidth = 264.0;
 // The margin on top to the navigation bar.
 const CGFloat kNavigationBarTopMargin = 8.0;
 }  // namespace
 
 // A simple UIView subclass to pass on relayout information to its delegate.
 @protocol ContentViewDelegate<NSObject>
 - (void)willLayoutSubviews;
 @end
 
 @interface ContentView : UIView
-@property(nonatomic, assign) id<ContentViewDelegate> delegate;
+@property(nonatomic, weak) id<ContentViewDelegate> delegate;
 @end
 
 @implementation ContentView
 @synthesize delegate = _delegate;
 
 - (void)layoutSubviews {
   [self.delegate willLayoutSubviews];
   [super layoutSubviews];
 }
 @end
 
 @interface BookmarkHomeTabletNTPController ()<
     BookmarkEditViewControllerDelegate,
     BookmarkFolderCollectionViewDelegate,
     BookmarkFolderEditorViewControllerDelegate,
     BookmarkFolderViewControllerDelegate,
     BookmarkMenuViewDelegate,
     BookmarkModelBridgeObserver,
     BookmarkPromoControllerDelegate,
     ContentViewDelegate> {
   // Bridge to register for bookmark changes.
   std::unique_ptr<bookmarks::BookmarkModelBridge> _bridge;
   ios::ChromeBrowserState* _browserState;  // Weak.
-  id<UrlLoader> _loader;                   // Weak.
+  __weak id<UrlLoader> _loader;
 
   // The following 2 ivars both represent the set of nodes being edited.
   // The set is for fast lookup.
   // The vector maintains the order that edit nodes were added.
   // Use the relevant instance methods to modify these two ivars in tandem.
   // DO NOT modify these two ivars directly.
   std::set<const BookmarkNode*> _editNodes;
   std::vector<const BookmarkNode*> _editNodesOrdered;
-
-  base::mac::ObjCPropertyReleaser
-      _propertyReleaser_BookmarkHomeTabletNTPController;
 }
 
-@property(nonatomic, retain) BookmarkPanelView* panelView;
+@property(nonatomic, strong) BookmarkPanelView* panelView;
 
 #pragma mark - Properties and methods akin to BookmarkHomeViewController
 
 // Whether the view controller is in editing mode.
 @property(nonatomic, assign) BOOL editing;
 // The set of edited index paths.
-@property(nonatomic, retain) NSMutableArray* editIndexPaths;
+@property(nonatomic, strong) NSMutableArray* editIndexPaths;
 // The bookmark model used.
 @property(nonatomic, assign, readonly) bookmarks::BookmarkModel* bookmarks;
 // The user's browser state model used.
 @property(nonatomic, assign, readonly)
     ios::ChromeBrowserState* browserState;  // from superclass.
 
 // Replaces |_editNodes| and |_editNodesOrdered| with new container objects.
 - (void)resetEditNodes;
 // Adds |node| corresponding to a |cell| if it isn't already present.
 - (void)insertEditNode:(const BookmarkNode*)node
            atIndexPath:(NSIndexPath*)indexPath;
 // Removes |node| corresponding to a |cell| if it's present.
 - (void)removeEditNode:(const BookmarkNode*)node
            atIndexPath:(NSIndexPath*)indexPath;
 // This method updates the property, and resets the edit nodes.
 - (void)setEditing:(BOOL)editing animated:(BOOL)animated;
 
 #pragma mark - Properties and methods akin to BookmarkHomeHandsetViewController
 
 // This views holds the primary content of this controller. At any point in
 // time, it contains exactly one of the BookmarkCollectionView subclasses.
-@property(nonatomic, retain) ContentView* contentView;
+@property(nonatomic, strong) ContentView* contentView;
 // The possible views that can be shown from the menu.
-@property(nonatomic, retain) BookmarkFolderCollectionView* folderView;
+@property(nonatomic, strong) BookmarkFolderCollectionView* folderView;
 // This view is created and used if the model is not fully loaded yet by the
 // time this controller starts.
-@property(nonatomic, retain) BookmarkHomeWaitingView* waitForModelView;
+@property(nonatomic, strong) BookmarkHomeWaitingView* waitForModelView;
 
 // The menu with all the folders and special entries.
-@property(nonatomic, retain) BookmarkMenuView* menuView;
+@property(nonatomic, strong) BookmarkMenuView* menuView;
 // At any point in time, there is exactly one collection view whose view is part
 // of the view hierarchy. This property determines which collection view is
 // visible. Not by accident, this property also reflects the selected menu item
 // in the BookmarkMenuView.
-@property(nonatomic, retain) BookmarkMenuItem* primaryMenuItem;
+@property(nonatomic, strong) BookmarkMenuItem* primaryMenuItem;
 // When the view is first shown on the screen, this property represents the
 // cached value of the y of the content offset of the primary view. This
 // property is set to nil after it is used.
-@property(nonatomic, retain)
+@property(nonatomic, strong)
     NSNumber* cachedContentPosition;  // FIXME: INACTIVE
 
 // The navigation bar sits on top of the main content.
-@property(nonatomic, retain) BookmarkNavigationBar* navigationBar;
+@property(nonatomic, strong) BookmarkNavigationBar* navigationBar;
 // The editing bar present when items are selected.
-@property(nonatomic, retain) BookmarkEditingBar* editingBar;
+@property(nonatomic, strong) BookmarkEditingBar* editingBar;
 
 // The action sheet coordinator used when trying to edit a single bookmark.
-@property(nonatomic, retain) ActionSheetCoordinator* actionSheetCoordinator;
+@property(nonatomic, strong) ActionSheetCoordinator* actionSheetCoordinator;
 // The view controller used to view and edit a single bookmark.
-@property(nonatomic, retain) BookmarkEditViewController* editViewController;
+@property(nonatomic, strong) BookmarkEditViewController* editViewController;
 // The view controller used to pick a folder in which to move the selected
 // bookmarks.
-@property(nonatomic, retain) BookmarkFolderViewController* folderSelector;
+@property(nonatomic, strong) BookmarkFolderViewController* folderSelector;
 // The view controller to present when editing the current folder.
-@property(nonatomic, retain)
+@property(nonatomic, strong)
     BookmarkFolderEditorViewController* folderEditor;  // FIX
 // The controller managing the display of the promo cell and the promo view
 // controller.
-@property(nonatomic, retain) BookmarkPromoController* bookmarkPromoController;
+@property(nonatomic, strong) BookmarkPromoController* bookmarkPromoController;
 
 #pragma mark Specific to this class.
 
 // Either the menu or the primaryView can scrollToTop.
 @property(nonatomic, assign) BOOL scrollToTop;
 
 // Opens the url.
 - (void)loadURL:(const GURL&)url;
 #pragma mark View loading, laying out, and switching.
 // This method is called if the view needs to be loaded and the model is not
@@ skipping 121 matching lines @@
 // Property declared in NewTabPagePanelProtocol.
 @synthesize delegate = _delegate;
 
 - (id)initWithLoader:(id<UrlLoader>)loader
         browserState:(ios::ChromeBrowserState*)browserState {
   self = [super init];
   if (self) {
     DCHECK(browserState);
     _browserState = browserState->GetOriginalChromeBrowserState();
     _loader = loader;
-    _propertyReleaser_BookmarkHomeTabletNTPController.Init(
-        self, [BookmarkHomeTabletNTPController class]);
 
     _bookmarks = ios::BookmarkModelFactory::GetForBrowserState(_browserState);
     _bridge.reset(new bookmarks::BookmarkModelBridge(self, _bookmarks));
     _editIndexPaths = [[NSMutableArray alloc] init];
     // It is important to initialize the promo controller with the browser state
     // passed in, as it could be incognito.
     _bookmarkPromoController =
         [[BookmarkPromoController alloc] initWithBrowserState:browserState
                                                      delegate:self];
   }
   return self;
 }
 
 - (void)dealloc {
   _contentView.delegate = nil;
 
   _folderView.delegate = nil;
 
   _menuView.delegate = nil;
 
   _editViewController.delegate = nil;
   _folderSelector.delegate = nil;
-
-  [super dealloc];
 }
 
 - (ios::ChromeBrowserState*)browserState {
   return _browserState;
 }
 
 #pragma mark - ContentViewDelegate method.
 
 - (void)willLayoutSubviews {
   if (![self primaryView] && ![self primaryMenuItem] &&
@@ skipping 93 matching lines @@
       rendererInitiated:NO];
 }
 
 #pragma mark - Views
 
 - (void)loadWaitingView {
   DCHECK(!self.waitForModelView);
   DCHECK(self.contentView);
 
   // Present a waiting view.
-  base::scoped_nsobject<BookmarkHomeWaitingView> waitingView(
-      [[BookmarkHomeWaitingView alloc] initWithFrame:self.view.bounds]);
+  BookmarkHomeWaitingView* waitingView =
+      [[BookmarkHomeWaitingView alloc] initWithFrame:self.view.bounds];
   self.waitForModelView = waitingView;
   [self.view addSubview:self.waitForModelView];
   [self.waitForModelView startWaiting];
 }
 
 - (void)updateMenuViewLayout {
   LayoutRect menuLayout =
       LayoutRectMake(0, self.view.bounds.size.width, 0, self.menuWidth,
                      self.view.bounds.size.height);
   self.menuView.frame = LayoutRectGetRect(menuLayout);
 }
 
 - (void)loadBookmarkViews {
   DCHECK(self.bookmarks->loaded());
 
   // Create the menu.
   LayoutRect menuLayout =
       LayoutRectMake(0, self.view.bounds.size.width, 0, self.menuWidth,
                      self.view.bounds.size.height);
-  self.menuView =
-      base::scoped_nsobject<BookmarkMenuView>([[BookmarkMenuView alloc]
-          initWithBrowserState:self.browserState
-                         frame:LayoutRectGetRect(menuLayout)]);
+  self.menuView = [[BookmarkMenuView alloc]
+      initWithBrowserState:self.browserState
+                     frame:LayoutRectGetRect(menuLayout)];
   self.menuView.delegate = self;
   self.menuView.autoresizingMask = UIViewAutoresizingFlexibleHeight;
 
   [self moveMenuAndPrimaryViewToAdequateParent];
 
   // Load the last primary menu item which the user had active.
   BookmarkMenuItem* item = nil;
   CGFloat position = 0;
   BOOL found =
       bookmark_utils_ios::GetPositionCache(self.bookmarks, &item, &position);
@@ skipping 14 matching lines @@
       // out.
       self.cachedContentPosition = [NSNumber numberWithFloat:position];
     }
   }
 }
 
 - (void)ensureFolderViewExists {
   if (self.folderView)
     return;
 
-  base::scoped_nsobject<BookmarkFolderCollectionView> view(
-      [[BookmarkFolderCollectionView alloc]
-          initWithBrowserState:self.browserState
-                         frame:CGRectZero]);
+  BookmarkFolderCollectionView* view = [[BookmarkFolderCollectionView alloc]
+      initWithBrowserState:self.browserState
+                     frame:CGRectZero];
   self.folderView = view;
   self.folderView.delegate = self;
   [self.folderView setEditing:self.editing animated:NO];
   self.folderView.autoresizingMask =
       UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
 }
 
 - (void)updatePrimaryMenuItem:(BookmarkMenuItem*)menuItem
                      animated:(BOOL)animated {
   DCHECK(menuItem.type == bookmarks::MenuItemFolder);
@@ skipping 52 matching lines @@
     [self.menuView removeFromSuperview];
   if ([self.panelView superview])
     [self.panelView removeFromSuperview];
   UIView* primaryView = [self primaryView];
   if ([primaryView superview])
     [primaryView removeFromSuperview];
 
   if ([self shouldPresentMenuInSlideInPanel]) {
     // Create (if needed), and add the panelView to the view hierarchy.
     if (!self.panelView) {
-      self.panelView = base::scoped_nsobject<BookmarkPanelView>(
+      self.panelView =
           [[BookmarkPanelView alloc] initWithFrame:CGRectZero
-                                     menuViewWidth:[self menuWidth]]);
+                                     menuViewWidth:[self menuWidth]];
     }
     [self.view addSubview:self.panelView];
     CGSize size = self.contentView.bounds.size;
     CGFloat navBarHeight = CGRectGetHeight([self navigationBarFrame]);
     LayoutRect panelLayout = LayoutRectMake(
         0, size.width, navBarHeight, size.width, size.height - navBarHeight);
 
     // Initialize the panelView with the menuView and the primaryView.
     [self.panelView setFrame:LayoutRectGetRect(panelLayout)];
     [self.panelView.menuView addSubview:self.menuView];
@@ skipping 32 matching lines @@
 }
 
 - (void)updateEditingStateAnimated:(BOOL)animated {
   if (!self.editing) {
     [self hideEditingBarAnimated:animated];
     [self updateEditBarShadow];
     return;
   }
 
   if (!self.editingBar) {
-    self.editingBar = base::scoped_nsobject<BookmarkEditingBar>(
-        [[BookmarkEditingBar alloc] initWithFrame:[self editingBarFrame]]);
+    self.editingBar =
+        [[BookmarkEditingBar alloc] initWithFrame:[self editingBarFrame]];
     [self.editingBar setCancelTarget:self action:@selector(editingBarCancel)];
     [self.editingBar setDeleteTarget:self action:@selector(editingBarDelete)];
     [self.editingBar setMoveTarget:self action:@selector(editingBarMove)];
     [self.editingBar setEditTarget:self action:@selector(editingBarEdit)];
 
     [self.view addSubview:self.editingBar];
     self.editingBar.hidden = YES;
   }
 
   int bookmarkCount = 0;
@@ skipping 163 matching lines @@
     [self loadURL:localUrl];
   });
 }
 
 - (void)bookmarkCollectionView:(BookmarkCollectionView*)collectionView
           wantsMenuForBookmark:(const BookmarkNode*)node
                         onView:(UIView*)view
                        forCell:(BookmarkItemCell*)cell {
   DCHECK(!self.editViewController);
   DCHECK(!self.actionSheetCoordinator);
-  self.actionSheetCoordinator = [[[ActionSheetCoordinator alloc]
+  self.actionSheetCoordinator = [[ActionSheetCoordinator alloc]
       initWithBaseViewController:self.view.window.rootViewController
                            title:nil
                          message:nil
                             rect:view.bounds
-                            view:view] autorelease];
-  base::WeakNSObject<BookmarkHomeTabletNTPController> weakSelf(self);
+                            view:view];
+  __weak BookmarkHomeTabletNTPController* weakSelf = self;
 
   // Select action.
   [self.actionSheetCoordinator
       addItemWithTitle:l10n_util::GetNSString(IDS_IOS_BOOKMARK_ACTION_SELECT)
                 action:^{
                   [weakSelf selectFirstNode:node withCell:cell];
-                  weakSelf.get().actionSheetCoordinator = nil;
+                  weakSelf.actionSheetCoordinator = nil;
                 }
                  style:UIAlertActionStyleDefault];
 
   // Edit action.
   [self.actionSheetCoordinator
       addItemWithTitle:l10n_util::GetNSString(IDS_IOS_BOOKMARK_ACTION_EDIT)
                 action:^{
                   BookmarkItemCell* itemCell = nil;
                   if ([cell isKindOfClass:[BookmarkItemCell class]])
                     itemCell = static_cast<BookmarkItemCell*>(cell);
                   [weakSelf editNode:node withCell:itemCell];
-                  weakSelf.get().actionSheetCoordinator = nil;
+                  weakSelf.actionSheetCoordinator = nil;
                 }
                  style:UIAlertActionStyleDefault];
 
   // Move action.
   [self.actionSheetCoordinator
       addItemWithTitle:l10n_util::GetNSString(IDS_IOS_BOOKMARK_ACTION_MOVE)
                 action:^{
                   std::set<const BookmarkNode*> nodes;
                   nodes.insert(node);
                   [weakSelf moveNodes:nodes];
-                  weakSelf.get().actionSheetCoordinator = nil;
+                  weakSelf.actionSheetCoordinator = nil;
                 }
                  style:UIAlertActionStyleDefault];
 
   // Delete action.
   [self.actionSheetCoordinator
       addItemWithTitle:l10n_util::GetNSString(IDS_IOS_BOOKMARK_ACTION_DELETE)
                 action:^{
                   std::set<const BookmarkNode*> nodes;
                   nodes.insert(node);
                   [weakSelf deleteNodes:nodes];
-                  weakSelf.get().actionSheetCoordinator = nil;
+                  weakSelf.actionSheetCoordinator = nil;
                 }
                  style:UIAlertActionStyleDestructive];
 
   // Cancel action.
   [self.actionSheetCoordinator
       addItemWithTitle:l10n_util::GetNSString(IDS_CANCEL)
                 action:^{
-                  weakSelf.get().actionSheetCoordinator = nil;
+                  weakSelf.actionSheetCoordinator = nil;
                 }
                  style:UIAlertActionStyleCancel];
 
   [self.actionSheetCoordinator start];
 }
 
 - (void)bookmarkCollectionView:(BookmarkCollectionView*)view
               didLongPressCell:(UICollectionViewCell*)cell
                    forBookmark:(const BookmarkNode*)node {
   DCHECK(!self.editing);
@@ skipping 29 matching lines @@
   if (node->is_folder()) {
     BookmarkFolderEditorViewController* folderEditor =
         [BookmarkFolderEditorViewController
             folderEditorWithBookmarkModel:self.bookmarks
                                    folder:node
                              browserState:self.browserState];
     folderEditor.delegate = self;
     self.folderEditor = folderEditor;
     editorController = folderEditor;
   } else {
-    base::scoped_nsobject<BookmarkEditViewController> controller([
-        [BookmarkEditViewController alloc] initWithBookmark:node
-                                               browserState:self.browserState]);
+    BookmarkEditViewController* controller =
+        [[BookmarkEditViewController alloc] initWithBookmark:node
+                                                browserState:self.browserState];
     self.editViewController = controller;
     self.editViewController.delegate = self;
     editorController = self.editViewController;
   }
   DCHECK(editorController);
-  base::scoped_nsobject<UINavigationController> navController(
-      [[BookmarkNavigationController alloc]
-          initWithRootViewController:editorController]);
-  navController.get().modalPresentationStyle = UIModalPresentationFormSheet;
+  UINavigationController* navController = [[BookmarkNavigationController alloc]
+      initWithRootViewController:editorController];
+  navController.modalPresentationStyle = UIModalPresentationFormSheet;
   [self.view.window.rootViewController presentViewController:navController
                                                     animated:YES
                                                   completion:NULL];
 }
 
 - (void)moveNodes:(const std::set<const BookmarkNode*>&)nodes {
   DCHECK(!self.folderSelector);
   DCHECK(nodes.size() > 0);
   const BookmarkNode* editedNode = *(nodes.begin());
   const BookmarkNode* selectedFolder = editedNode->parent();
-  self.folderSelector = base::scoped_nsobject<BookmarkFolderViewController>(
-      [[BookmarkFolderViewController alloc]
-          initWithBookmarkModel:self.bookmarks
-               allowsNewFolders:YES
-                    editedNodes:nodes
-                   allowsCancel:YES
-                 selectedFolder:selectedFolder]);
+  self.folderSelector = [[BookmarkFolderViewController alloc]
+      initWithBookmarkModel:self.bookmarks
+           allowsNewFolders:YES
+                editedNodes:nodes
+               allowsCancel:YES
+             selectedFolder:selectedFolder];
   self.folderSelector.delegate = self;
-  base::scoped_nsobject<UINavigationController> controller(
-      [[BookmarkNavigationController alloc]
-          initWithRootViewController:self.folderSelector]);
-  controller.get().modalPresentationStyle = UIModalPresentationFormSheet;
+  UINavigationController* controller = [[BookmarkNavigationController alloc]
+      initWithRootViewController:self.folderSelector];
+  controller.modalPresentationStyle = UIModalPresentationFormSheet;
   [self.view.window.rootViewController presentViewController:controller
                                                     animated:YES
                                                   completion:NULL];
 }
 
 - (void)deleteNodes:(const std::set<const BookmarkNode*>&)nodes {
   DCHECK_GE(nodes.size(), 1u);
   bookmark_utils_ios::DeleteBookmarksWithUndoToast(nodes, self.bookmarks,
                                                    self.browserState);
 }
@@ skipping 160 matching lines @@
   DCHECK(self.primaryMenuItem.type == bookmarks::MenuItemFolder);
   const BookmarkNode* folder = self.primaryMenuItem.folder;
   BookmarkFolderEditorViewController* folderEditor =
       [BookmarkFolderEditorViewController
           folderEditorWithBookmarkModel:self.bookmarks
                                  folder:folder
                            browserState:self.browserState];
   folderEditor.delegate = self;
   self.folderEditor = folderEditor;
 
-  base::scoped_nsobject<BookmarkNavigationController> navController(
+  BookmarkNavigationController* navController =
       [[BookmarkNavigationController alloc]
-          initWithRootViewController:self.folderEditor]);
-  navController.get().modalPresentationStyle = UIModalPresentationFormSheet;
+          initWithRootViewController:self.folderEditor];
+  navController.modalPresentationStyle = UIModalPresentationFormSheet;
   [self.view.window.rootViewController presentViewController:navController
                                                     animated:YES
                                                   completion:NULL];
 }
 
 - (void)navigationBarBack:(id)sender {
   DCHECK([self shouldShowBackButton]);
 
   // Go to the parent folder.
   DCHECK(self.primaryMenuItem.type == bookmarks::MenuItemFolder);
@@ skipping 34 matching lines @@
   self.scrollToTop = enabled;
   [[self primaryView] setScrollsToTop:self.scrollToTop];
 }
 
 - (UIView*)view {
   if (!self.contentView) {
     _contentView = [[ContentView alloc] initWithFrame:CGRectZero];
     _contentView.delegate = self;
     self.contentView.backgroundColor =
         bookmark_utils_ios::mainBackgroundColor();
-    base::scoped_nsobject<BookmarkNavigationBar> bar(
-        [[BookmarkNavigationBar alloc] initWithFrame:CGRectZero]);
+    BookmarkNavigationBar* bar =
+        [[BookmarkNavigationBar alloc] initWithFrame:CGRectZero];
     self.navigationBar = bar;
     self.navigationBar.autoresizingMask = UIViewAutoresizingFlexibleWidth;
 
     [self.navigationBar setEditTarget:self
                                action:@selector(navigationBarWantsEditing:)];
     [self.navigationBar setBackTarget:self
                                action:@selector(navigationBarBack:)];
 
     [self.navigationBar setMenuTarget:self
                                action:@selector(toggleMenuAnimated)];
@@ skipping 12 matching lines @@
   return 0;
 }
 
 #pragma mark - BookmarkModelBridgeObserver
 
 - (void)bookmarkModelLoaded {
   if (!self.contentView)
     return;
 
   DCHECK(self.waitForModelView);
-  base::WeakNSObject<BookmarkHomeTabletNTPController> weakSelf(self);
+  __weak BookmarkHomeTabletNTPController* weakSelf = self;
   [self.waitForModelView stopWaitingWithCompletion:^{
-    base::scoped_nsobject<BookmarkHomeTabletNTPController> strongSelf(
-        [weakSelf retain]);
+    BookmarkHomeTabletNTPController* strongSelf = weakSelf;
     // Early return if the controller has been deallocated.
     if (!strongSelf)
       return;
     [UIView animateWithDuration:0.2
         animations:^{
-          strongSelf.get().waitForModelView.alpha = 0.0;
+          strongSelf.waitForModelView.alpha = 0.0;
         }
         completion:^(BOOL finished) {
-          [strongSelf.get().waitForModelView removeFromSuperview];
-          strongSelf.get().waitForModelView = nil;
+          [strongSelf.waitForModelView removeFromSuperview];
+          strongSelf.waitForModelView = nil;
         }];
     [strongSelf loadBookmarkViews];
   }];
 }
 
 - (void)bookmarkNodeChanged:(const BookmarkNode*)bookmarkNode {
   // The title of the folder may have changed.
   if (self.primaryMenuItem.type == bookmarks::MenuItemFolder &&
       self.primaryMenuItem.folder == bookmarkNode) {
     UIInterfaceOrientation orient = GetInterfaceOrientation();
@@ skipping 30 matching lines @@
 }
 
 - (NSIndexPath*)indexPathForCell:(UICollectionViewCell*)cell {
   DCHECK([self primaryView].collectionView);
   NSIndexPath* indexPath =
       [[self primaryView].collectionView indexPathForCell:cell];
   return indexPath;
 }
 
 @end