[ObjC ARC] Converts ios/chrome/app/spotlight:spotlight to ARC.

ios/chrome/app/spotlight/bookmarks_spotlight_manager.mm

 // Copyright 2015 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/app/spotlight/bookmarks_spotlight_manager.h"
 
 #include <memory>
 
 #import <CoreSpotlight/CoreSpotlight.h>
 
-#include "base/ios/weak_nsobject.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/version.h"
 #include "components/bookmarks/browser/base_bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "ios/chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "ios/chrome/browser/favicon/ios_chrome_large_icon_service_factory.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 // Limit the size of the initial indexing. This will not limit the size of the
 // index as new bookmarks can be added afterwards.
 const int kMaxInitialIndexSize = 1000;
 
 // Minimum delay between two global indexing of bookmarks.
 const int kDelayBetweenTwoIndexingInSeconds = 7 * 86400;  // One week.
 
 }  // namespace
 
 class SpotlightBookmarkModelBridge;
 
 // Called from the BrowserBookmarkModelBridge from C++ -> ObjC.
 @interface BookmarksSpotlightManager () {
-  base::WeakNSProtocol<id<BookmarkUpdatedDelegate>> _delegate;
+  __weak id<BookmarkUpdatedDelegate> _delegate;
 
   // Bridge to register for bookmark changes.
   std::unique_ptr<SpotlightBookmarkModelBridge> _bookmarkModelBridge;
 
   // Keep a reference to detach before deallocing. Life cycle of _bookmarkModel
   // is longer than life cycle of a SpotlightManager as
   // |BookmarkModelBeingDeleted| will cause deletion of SpotlightManager.
   bookmarks::BookmarkModel* _bookmarkModel;  // weak
 
   // Number of nodes indexed in initial scan.
@@ skipping 89 matching lines @@
 
   void BookmarkNodeMoved(bookmarks::BookmarkModel* model,
                          const bookmarks::BookmarkNode* old_parent,
                          int old_index,
                          const bookmarks::BookmarkNode* new_parent,
                          int new_index) override {
     [owner_ refreshNodeInIndex:new_parent->GetChild(new_index) initial:NO];
   };
 
  private:
-  __unsafe_unretained BookmarksSpotlightManager* owner_;  // Weak.
+  __weak BookmarksSpotlightManager* owner_;
 };
 
 @implementation BookmarksSpotlightManager
 
 + (BookmarksSpotlightManager*)bookmarksSpotlightManagerWithBrowserState:
     (ios::ChromeBrowserState*)browserState {
-  return [[[BookmarksSpotlightManager alloc]
+  return [[BookmarksSpotlightManager alloc]
       initWithLargeIconService:IOSChromeLargeIconServiceFactory::
                                    GetForBrowserState(browserState)
                  bookmarkModel:ios::BookmarkModelFactory::GetForBrowserState(
-                                   browserState)] autorelease];
+                                   browserState)];
 }
 
 - (instancetype)
 initWithLargeIconService:(favicon::LargeIconService*)largeIconService
            bookmarkModel:(bookmarks::BookmarkModel*)bookmarkModel {
   self = [super initWithLargeIconService:largeIconService
                                   domain:spotlight::DOMAIN_BOOKMARKS];
   if (self) {
     _bookmarkModelBridge.reset(new SpotlightBookmarkModelBridge(self));
     _bookmarkModel = bookmarkModel;
     bookmarkModel->AddObserver(_bookmarkModelBridge.get());
   }
   return self;
 }
 
 - (void)dealloc {
   [self detachBookmarkModel];
-  [super dealloc];
 }
 
 - (void)detachBookmarkModel {
   [self cancelAllLargeIconPendingTasks];
   if (_bookmarkModelBridge.get()) {
     _bookmarkModel->RemoveObserver(_bookmarkModelBridge.get());
     _bookmarkModelBridge.reset();
   }
 }
 
 - (id<BookmarkUpdatedDelegate>)delegate {
   return _delegate;
 }
 
 - (void)setDelegate:(id<BookmarkUpdatedDelegate>)delegate {
-  _delegate.reset(delegate);
+  _delegate = delegate;
 }
 
 - (void)getParentKeywordsForNode:(const bookmarks::BookmarkNode*)node
                          inArray:(NSMutableArray*)keywords {
   if (!node) {
     return;
   }
   if (node->is_folder() && !_bookmarkModel->is_permanent_node(node)) {
     [keywords addObject:base::SysUTF16ToNSString(node->GetTitle())];
   }
   [self getParentKeywordsForNode:node->parent() inArray:keywords];
 }
 
 - (void)removeNodeFromIndex:(const bookmarks::BookmarkNode*)node {
   if (node->is_url()) {
     GURL url(node->url());
     NSString* title = base::SysUTF16ToNSString(node->GetTitle());
     NSString* spotlightID = [self spotlightIDForURL:url title:title];
-    base::WeakNSObject<BookmarksSpotlightManager> weakself(self);
+    __weak BookmarksSpotlightManager* weakself = self;
     BlockWithError completion = ^(NSError* error) {
       dispatch_async(dispatch_get_main_queue(), ^{
         [weakself refreshItemsWithURL:url title:nil];
         [_delegate bookmarkUpdated];
       });
     };
     spotlight::DeleteItemsWithIdentifiers(@[ spotlightID ], completion);
     return;
   }
   int childCount = node->child_count();
@@ skipping 58 matching lines @@
   }
   int childCount = node->child_count();
   for (int child = 0; child < childCount; child++) {
     [self refreshNodeInIndex:node->GetChild(child) initial:initial];
   }
 }
 
 - (NSArray*)spotlightItemsWithURL:(const GURL&)URL
                           favicon:(UIImage*)favicon
                      defaultTitle:(NSString*)defaultTitle {
-  base::scoped_nsobject<NSMutableDictionary> spotlightItems(
-      [[NSMutableDictionary alloc] init]);
+  NSMutableDictionary* spotlightItems = [[NSMutableDictionary alloc] init];
   std::vector<const bookmarks::BookmarkNode*> nodes;
   _bookmarkModel->GetNodesByURL(URL, &nodes);
   for (auto node : nodes) {
     NSString* nodeTitle = base::SysUTF16ToNSString(node->GetTitle());
     NSString* spotlightID = [self spotlightIDForURL:URL title:nodeTitle];
     CSSearchableItem* item = [spotlightItems objectForKey:spotlightID];
     if (!item) {
       item = [[super spotlightItemsWithURL:URL
                                    favicon:favicon
                               defaultTitle:nodeTitle] objectAtIndex:0];
     }
-    base::scoped_nsobject<NSMutableArray> nodeKeywords(
-        [[NSMutableArray alloc] init]);
-    [self getParentKeywordsForNode:node inArray:nodeKeywords.get()];
+    NSMutableArray* nodeKeywords = [[NSMutableArray alloc] init];
+    [self getParentKeywordsForNode:node inArray:nodeKeywords];
     [self addKeywords:nodeKeywords toSearchableItem:item];
     [spotlightItems setObject:item forKey:spotlightID];
   }
   return [spotlightItems allValues];
 }
 
 - (void)clearAndReindexModel {
   [self cancelAllLargeIconPendingTasks];
-  base::WeakNSObject<BookmarksSpotlightManager> weakself(self);
+  __weak BookmarksSpotlightManager* weakself = self;
   BlockWithError completion = ^(NSError* error) {
     if (!error) {
       dispatch_async(dispatch_get_main_queue(), ^{
-        base::scoped_nsobject<BookmarksSpotlightManager> strongSelf(
-            [weakself retain]);
+        BookmarksSpotlightManager* strongSelf = weakself;
         if (!strongSelf)
           return;
 
         NSDate* startOfReindexing = [NSDate date];
-        strongSelf.get()->_nodesIndexed = 0;
-        [strongSelf
-            refreshNodeInIndex:strongSelf.get()->_bookmarkModel->root_node()
-                       initial:YES];
+        strongSelf->_nodesIndexed = 0;
+        [strongSelf refreshNodeInIndex:strongSelf->_bookmarkModel->root_node()
+                               initial:YES];
         NSDate* endOfReindexing = [NSDate date];
         NSTimeInterval indexingDuration =
             [endOfReindexing timeIntervalSinceDate:startOfReindexing];
         UMA_HISTOGRAM_TIMES(
             "IOS.Spotlight.BookmarksIndexingDuration",
             base::TimeDelta::FromMillisecondsD(1000 * indexingDuration));
         UMA_HISTOGRAM_COUNTS_1000("IOS.Spotlight.BookmarksInitialIndexSize",
                                   [strongSelf pendingLargeIconTasksCount]);
         [[NSUserDefaults standardUserDefaults]
             setObject:endOfReindexing
                forKey:@(spotlight::kSpotlightLastIndexingDateKey)];
 
         [[NSUserDefaults standardUserDefaults]
             setObject:[NSNumber numberWithInteger:
                                     spotlight::kCurrentSpotlightIndexVersion]
                forKey:@(spotlight::kSpotlightLastIndexingVersionKey)];
         [_delegate bookmarkUpdated];
       });
     }
   };
   [self clearAllSpotlightItems:completion];
 }
 
 @end