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

ios/chrome/app/spotlight/topsites_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/topsites_spotlight_manager.h"
 
 #include <memory>
 
-#include "base/ios/weak_nsobject.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/history/core/browser/top_sites.h"
 #include "components/history/core/browser/top_sites_observer.h"
 #include "components/suggestions/suggestions_service.h"
 #include "ios/chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "ios/chrome/browser/favicon/ios_chrome_large_icon_service_factory.h"
 #include "ios/chrome/browser/history/top_sites_factory.h"
 #include "ios/chrome/browser/suggestions/suggestions_service_factory.h"
 #include "ios/chrome/browser/sync/ios_chrome_profile_sync_service_factory.h"
 #include "ios/chrome/browser/sync/sync_observer_bridge.h"
 #include "ios/chrome/browser/ui/ntp/google_landing_controller.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 class SpotlightTopSitesBridge;
 class SpotlightTopSitesCallbackBridge;
 class SpotlightSuggestionsBridge;
 
 @interface TopSitesSpotlightManager ()<SyncObserverModelBridge> {
   // Bridge to register for top sites changes. It's important that this instance
   // variable is released before the _topSite one.
   std::unique_ptr<SpotlightTopSitesBridge> _topSitesBridge;
 
   // Bridge to register for top sites callbacks.
@@ skipping 54 matching lines @@
   explicit SpotlightTopSitesCallbackBridge(TopSitesSpotlightManager* owner)
       : owner_(owner) {}
 
   SpotlightTopSitesCallbackBridge() {}
 
   void OnMostVisitedURLsAvailable(const history::MostVisitedURLList& data) {
     [owner_ onMostVisitedURLsAvailable:data];
   }
 
  private:
-  __unsafe_unretained TopSitesSpotlightManager* owner_;  // weak, owns us
+  __weak TopSitesSpotlightManager* owner_;
 };
 
 class SpotlightTopSitesBridge : public history::TopSitesObserver {
  public:
   explicit SpotlightTopSitesBridge(TopSitesSpotlightManager* owner)
       : owner_(owner) {
     owner.topSites->AddObserver(this);
   };
 
   ~SpotlightTopSitesBridge() override {
     owner_.topSites->RemoveObserver(this);
   };
 
   void TopSitesLoaded(history::TopSites* top_sites) override {}
 
   void TopSitesChanged(history::TopSites* top_sites,
                        ChangeReason change_reason) override {
     [owner_ updateAllTopSitesSpotlightItems];
   }
 
  private:
-  __unsafe_unretained TopSitesSpotlightManager* owner_;  // weak
+  __weak TopSitesSpotlightManager* owner_;
 };
 
 class SpotlightSuggestionsBridge
     : public base::SupportsWeakPtr<SpotlightSuggestionsBridge> {
  public:
   explicit SpotlightSuggestionsBridge(TopSitesSpotlightManager* owner)
       : owner_(owner) {}
 
   SpotlightSuggestionsBridge() {}
 
   void OnSuggestionsProfileAvailable(
       const suggestions::SuggestionsProfile& suggestions_profile) {
     [owner_ onSuggestionsProfileAvailable:suggestions_profile];
   }
 
  private:
-  __unsafe_unretained TopSitesSpotlightManager* owner_;  // weak, owns us
+  __weak TopSitesSpotlightManager* owner_;
 };
 
 @implementation TopSitesSpotlightManager
 @synthesize topSites = _topSites;
 
 + (TopSitesSpotlightManager*)topSitesSpotlightManagerWithBrowserState:
     (ios::ChromeBrowserState*)browserState {
-  return [[[TopSitesSpotlightManager alloc]
+  return [[TopSitesSpotlightManager alloc]
       initWithLargeIconService:IOSChromeLargeIconServiceFactory::
                                    GetForBrowserState(browserState)
                       topSites:ios::TopSitesFactory::GetForBrowserState(
                                    browserState)
                  bookmarkModel:ios::BookmarkModelFactory::GetForBrowserState(
                                    browserState)
             profileSyncService:IOSChromeProfileSyncServiceFactory::
                                    GetForBrowserState(browserState)
             suggestionsService:suggestions::SuggestionsServiceFactory::
-                                   GetForBrowserState(browserState)]
-      autorelease];
+                                   GetForBrowserState(browserState)];
 }
 
 - (instancetype)
 initWithLargeIconService:(favicon::LargeIconService*)largeIconService
                 topSites:(scoped_refptr<history::TopSites>)topSites
            bookmarkModel:(bookmarks::BookmarkModel*)bookmarkModel
       profileSyncService:(browser_sync::ProfileSyncService*)syncService
       suggestionsService:(suggestions::SuggestionsService*)suggestionsService {
   self = [super initWithLargeIconService:largeIconService
                                   domain:spotlight::DOMAIN_TOPSITES];
@@ skipping 10 matching lines @@
       _suggestionsServiceResponseSubscription = _suggestionService->AddCallback(
           base::Bind(&SpotlightSuggestionsBridge::OnSuggestionsProfileAvailable,
                      _suggestionsBridge->AsWeakPtr()));
       sync_observer_bridge_.reset(new SyncObserverBridge(self, syncService));
     }
   }
   return self;
 }
 
 - (void)updateAllTopSitesSpotlightItems {
-  base::WeakNSObject<TopSitesSpotlightManager> weakSelf(self);
+  __weak TopSitesSpotlightManager* weakSelf = self;
   [self clearAllSpotlightItems:^(NSError* error) {
     dispatch_async(dispatch_get_main_queue(), ^{
       [weakSelf addAllTopSitesSpotlightItems];
     });
   }];
 }
 
 - (void)addAllTopSitesSpotlightItems {
   if (_suggestionService) {
     [self addAllSuggestionsTopSitesItems];
@@ skipping 62 matching lines @@
   } else {
     [self addAllLocalTopSitesItems];
   }
 }
 
 - (void)reindexTopSites {
   if (_isReindexPending) {
     return;
   }
   _isReindexPending = true;
-  base::WeakNSObject<TopSitesSpotlightManager> weakSelf(self);
+  __weak TopSitesSpotlightManager* weakSelf = self;
   dispatch_after(
       dispatch_time(DISPATCH_TIME_NOW, static_cast<int64_t>(1 * NSEC_PER_SEC)),
       dispatch_get_main_queue(), ^{
-        [weakSelf updateAllTopSitesSpotlightItems];
-        weakSelf.get()->_isReindexPending = false;
+        TopSitesSpotlightManager* strongSelf = weakSelf;
+        if (!strongSelf) {
+          return;
+        }
+        [strongSelf updateAllTopSitesSpotlightItems];
+        strongSelf->_isReindexPending = false;
       });
 }
 
 #pragma mark -
 #pragma mark SyncObserverModelBridge
 
 - (void)onSyncStateChanged {
   [self updateAllTopSitesSpotlightItems];
 }
 
 @end