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

ios/chrome/browser/ui/ntp/google_landing_mediator.mm

 // Copyright 2017 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/ntp/google_landing_mediator.h"
 
-#import "base/ios/weak_nsobject.h"
 #include "base/mac/bind_objc_block.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 "base/task/cancelable_task_tracker.h"
 #include "components/favicon/core/large_icon_service.h"
 #include "components/favicon_base/fallback_icon_style.h"
 #include "components/ntp_tiles/metrics.h"
 #include "components/ntp_tiles/most_visited_sites.h"
 #include "components/ntp_tiles/ntp_tile.h"
 #include "components/rappor/rappor_service_impl.h"
@@ skipping 17 matching lines @@
 #import "ios/chrome/browser/ui/toolbar/web_toolbar_controller.h"
 #import "ios/chrome/browser/ui/url_loader.h"
 #import "ios/chrome/browser/web_state_list/web_state_list.h"
 #import "ios/chrome/browser/web_state_list/web_state_list_observer_bridge.h"
 #include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
 #include "ios/public/provider/chrome/browser/voice/voice_search_provider.h"
 #import "ios/shared/chrome/browser/ui/commands/command_dispatcher.h"
 #include "ios/web/public/web_state/web_state.h"
 #include "skia/ext/skia_utils_ios.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using base::UserMetricsAction;
 
 namespace {
 
 const CGFloat kFaviconMinSize = 32;
 const NSInteger kMaxNumMostVisitedFavicons = 8;
 
 }  // namespace
 
 @interface GoogleLandingMediator (UsedBySearchEngineObserver)
 // Check to see if the logo visibility should change.
 - (void)updateShowLogo;
 @end
 
 namespace google_landing {
 
 // Observer used to hide the Google logo and doodle if the TemplateURLService
 // changes.
 class SearchEngineObserver : public TemplateURLServiceObserver {
  public:
   SearchEngineObserver(GoogleLandingMediator* owner,
                        TemplateURLService* urlService);
   ~SearchEngineObserver() override;
   void OnTemplateURLServiceChanged() override;
 
  private:
-  base::WeakNSObject<GoogleLandingMediator> _owner;
+  __weak GoogleLandingMediator* _owner;
   TemplateURLService* _templateURLService;  // weak
 };
 
 SearchEngineObserver::SearchEngineObserver(GoogleLandingMediator* owner,
                                            TemplateURLService* urlService)
     : _owner(owner), _templateURLService(urlService) {
   _templateURLService->AddObserver(this);
 }
 
 SearchEngineObserver::~SearchEngineObserver() {
   _templateURLService->RemoveObserver(this);
 }
 
 void SearchEngineObserver::OnTemplateURLServiceChanged() {
   [_owner updateShowLogo];
 }
 
 }  // namespace google_landing
 
 @interface GoogleLandingMediator ()<GoogleLandingDataSource,
                                     MostVisitedSitesObserving,
                                     WebStateListObserving> {
   // The ChromeBrowserState associated with this mediator.
   ios::ChromeBrowserState* _browserState;  // Weak.
 
   // |YES| if impressions were logged already and shouldn't be logged again.
   BOOL _recordedPageImpression;
 
   // Controller to fetch and show doodles or a default Google logo.
-  base::scoped_nsprotocol<id<LogoVendor>> _doodleController;
+  id<LogoVendor> _doodleController;
 
   // Listen for default search engine changes.
   std::unique_ptr<google_landing::SearchEngineObserver> _observer;
   TemplateURLService* _templateURLService;  // weak
 
   // A MostVisitedSites::Observer bridge object to get notified of most visited
   // sites changes.
   std::unique_ptr<ntp_tiles::MostVisitedSitesObserverBridge>
       _mostVisitedObserverBridge;
 
   std::unique_ptr<ntp_tiles::MostVisitedSites> _mostVisitedSites;
 
   // Most visited data from the MostVisitedSites service currently in use.
   ntp_tiles::NTPTilesVector _mostVisitedData;
 
   // Observes the WebStateList so that this mediator can update the UI when the
   // active WebState changes.
   std::unique_ptr<WebStateListObserverBridge> _webStateListObserver;
 
   // What's new promo.
   std::unique_ptr<NotificationPromoWhatsNew> _notification_promo;
 
   // Used to cancel tasks for the LargeIconService.
   base::CancelableTaskTracker _cancelable_task_tracker;
 }
 
 // Consumer to handle google landing update notifications.
-@property(nonatomic) id<GoogleLandingConsumer> consumer;
+@property(weak, nonatomic) id<GoogleLandingConsumer> consumer;

[marq (ping after 24h), 2017/06/29 11:57:15]

nit: nonatomic, weak

[stkhapugin, 2017/06/29 15:04:49]

Done.

 
 // The WebStateList that is being observed by this mediator.
 @property(nonatomic, assign) WebStateList* webStateList;
 
 // The dispatcher for this mediator.
-@property(nonatomic, assign) id<ChromeExecuteCommand, UrlLoader> dispatcher;
+@property(nonatomic, weak) id<ChromeExecuteCommand, UrlLoader> dispatcher;
 
 // Most visited data from the MostVisitedSites service (copied upon receiving
 // the callback), not yet used.
 @property(nonatomic, assign) ntp_tiles::NTPTilesVector freshMostVisitedData;
 
 // Perform initial setup.
 - (void)setUp;
 
 // If there is some fresh most visited tiles, they become the current tiles and
 // the consumer gets notified.
@@ skipping 45 matching lines @@
     [_consumer setCanGoForward:nav->CanGoForward()];
     [_consumer setCanGoBack:nav->CanGoBack()];
   }
 
   // Set up template URL service to listen for default search engine changes.
   _templateURLService =
       ios::TemplateURLServiceFactory::GetForBrowserState(_browserState);
   _observer.reset(
       new google_landing::SearchEngineObserver(self, _templateURLService));
   _templateURLService->Load();
-  _doodleController.reset(ios::GetChromeBrowserProvider()->CreateLogoVendor(
-      _browserState, self.dispatcher));
+  _doodleController = ios::GetChromeBrowserProvider()->CreateLogoVendor(
+      _browserState, self.dispatcher);
   [_consumer setLogoVendor:_doodleController];
   [self updateShowLogo];
 
   // Set up most visited sites.  This call may have the side effect of
   // triggering -onMostVisitedURLsAvailable immediately, which can load the
   // view before dataSource is set.
   _mostVisitedSites =
       IOSMostVisitedSitesFactory::NewForBrowserState(_browserState);
   _mostVisitedObserverBridge.reset(
       new ntp_tiles::MostVisitedSitesObserverBridge(self));
@@ skipping 74 matching lines @@
   }
 }
 
 - (void)getFaviconForURL:(GURL)URL
                     size:(CGFloat)size
                 useCache:(BOOL)useCache
            imageCallback:(void (^)(UIImage* favicon))imageCallback
         fallbackCallback:(void (^)(UIColor* textColor,
                                    UIColor* backgroundColor,
                                    BOOL isDefaultColor))fallbackCallback {
-  base::WeakNSObject<GoogleLandingMediator> weakSelf(self);
+  __weak GoogleLandingMediator* weakSelf = self;
 
   void (^faviconBlock)(const favicon_base::LargeIconResult&) = ^(
       const favicon_base::LargeIconResult& result) {
     if (result.bitmap.is_valid()) {
       scoped_refptr<base::RefCountedMemory> data =
           result.bitmap.bitmap_data.get();
       UIImage* favicon = [UIImage
           imageWithData:[NSData dataWithBytes:data->front() length:data->size()]
                   scale:[UIScreen mainScreen].scale];
       imageCallback(favicon);
     } else if (result.fallback_icon_style) {
       UIColor* backgroundColor = skia::UIColorFromSkColor(
           result.fallback_icon_style->background_color);
       UIColor* textColor =
           skia::UIColorFromSkColor(result.fallback_icon_style->text_color);
       BOOL isDefaultColor =
           result.fallback_icon_style->is_default_background_color;
       fallbackCallback(textColor, backgroundColor, isDefaultColor);
     }
 
-    base::scoped_nsobject<GoogleLandingMediator> strongSelf([weakSelf retain]);
+    GoogleLandingMediator* strongSelf = weakSelf;
     if (strongSelf &&
         (result.bitmap.is_valid() || result.fallback_icon_style)) {
       [strongSelf largeIconCache]->SetCachedResult(URL, result);
     }
   };
 
   if (useCache) {
     std::unique_ptr<favicon_base::LargeIconResult> cached_result =
         [self largeIconCache]->GetCachedResult(URL);
     if (cached_result) {
       faviconBlock(*cached_result);
     }
   }
 
   CGFloat faviconSize = [UIScreen mainScreen].scale * size;
   CGFloat faviconMinSize = [UIScreen mainScreen].scale * kFaviconMinSize;
   [self largeIconService]->GetLargeIconOrFallbackStyle(
-      URL, faviconMinSize, faviconSize, base::BindBlock(faviconBlock),
+      URL, faviconMinSize, faviconSize, base::BindBlockArc(faviconBlock),
       &_cancelable_task_tracker);
 }
 
 #pragma mark - WebStateListObserving
 
 - (void)webStateList:(WebStateList*)webStateList
     didInsertWebState:(web::WebState*)webState
               atIndex:(int)index {
   [self.consumer setTabCount:self.webStateList->count()];
 }
@@ skipping 74 matching lines @@
 
   if (_notification_promo->IsURLPromo()) {
     [self.dispatcher webPageOrderedOpen:_notification_promo->url()
                                referrer:web::Referrer()
                            inBackground:NO
                                appendTo:kCurrentTab];
     return;
   }
 
   if (_notification_promo->IsChromeCommand()) {
-    base::scoped_nsobject<GenericChromeCommand> command(
-        [[GenericChromeCommand alloc]
-            initWithTag:_notification_promo->command_id()]);
+    GenericChromeCommand* command = [[GenericChromeCommand alloc]
+        initWithTag:_notification_promo->command_id()];
     [self.dispatcher chromeExecuteCommand:command];
     return;
   }
   NOTREACHED();
 }
 
 #pragma mark - Private
 
 - (void)useFreshData {
   _mostVisitedData = self.freshMostVisitedData;
   [self.consumer mostVisitedDataUpdated];
 }
 
 @end