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

ios/chrome/browser/ui/ntp/new_tab_page_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/ntp/new_tab_page_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
-#import "base/ios/weak_nsobject.h"
 #include "base/logging.h"
-#include "base/mac/objc_property_releaser.h"
+
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "components/prefs/pref_service.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/strings/grit/components_strings.h"
 #include "components/sync_sessions/synced_session.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/pref_names.h"
 #include "ios/chrome/browser/search_engines/template_url_service_factory.h"
 #include "ios/chrome/browser/sync/sync_setup_service.h"
@@ skipping 11 matching lines @@
 #import "ios/chrome/browser/ui/ntp/new_tab_page_view.h"
 #import "ios/chrome/browser/ui/ntp/recent_tabs/recent_tabs_panel_controller.h"
 #import "ios/chrome/browser/ui/rtl_geometry.h"
 #include "ios/chrome/browser/ui/toolbar/toolbar_model_ios.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #include "ios/chrome/grit/ios_strings.h"
 #import "ios/web/web_state/ui/crw_swipe_recognizer_provider.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using base::UserMetricsAction;
 
 namespace {
 const char* kMostVisitedFragment = "most_visited";
 const char* kBookmarksFragment = "bookmarks";
 const char* kOpenTabsFragment = "open_tabs";
 const char* kIncognitoFragment = "incognito";
 const CGFloat kToolbarHeight = 56;
 }
 
@@ skipping 48 matching lines @@
 enum {
   INDEX_MASK = (1 << kPageIdOffset) - 1,
   MOST_VISITED_PAGE_ID = 1 << kPageIdOffset,
   BOOKMARKS_PAGE_ID = 3 << kPageIdOffset,
   OPEN_TABS_PAGE_ID = 4 << kPageIdOffset,
 };
 
 }  // anonymous namespace
 
 @interface NewTabPageController () {
-  ios::ChromeBrowserState* browserState_;                   // Weak.
-  id<UrlLoader> loader_;                                    // Weak.
-  id<CRWSwipeRecognizerProvider> swipeRecognizerProvider_;  // Weak.
-  id<NewTabPageControllerObserver> newTabPageObserver_;     // Weak.
+  ios::ChromeBrowserState* browserState_;  // weak.
+  __weak id<UrlLoader> loader_;
+  __weak id<NewTabPageControllerObserver> newTabPageObserver_;
+  BookmarkHomeTabletNTPController* bookmarkController_;
+  GoogleLandingViewController* googleLandingController_;
+  id<NewTabPagePanelProtocol> incognitoController_;
+  // The currently visible controller, one of the above.
+  __weak id<NewTabPagePanelProtocol> currentController_;
 
-  NewTabPageView* newTabPageView_;
+  GoogleLandingMediator* googleLandingMediator_;
 
-  base::scoped_nsobject<GoogleLandingMediator> googleLandingMediator_;
-
-  base::scoped_nsobject<RecentTabsPanelController> openTabsController_;
+  RecentTabsPanelController* openTabsController_;
   // Has the scrollView been initialized.
   BOOL scrollInitialized_;
 
   // Dominant color cache. Key: (NSString*)url, val: (UIColor*)dominantColor.
-  NSMutableDictionary* dominantColorCache_;  // Weak, owned by bvc.
+  __weak NSMutableDictionary* dominantColorCache_;  // Owned by bvc.
 
   // Delegate to focus and blur the omnibox.
-  base::WeakNSProtocol<id<OmniboxFocuser>> focuser_;
+  __weak id<OmniboxFocuser> focuser_;
 
   // Delegate to fetch the ToolbarModel and current web state from.
-  base::WeakNSProtocol<id<WebToolbarDelegate>> webToolbarDelegate_;
+  __weak id<WebToolbarDelegate> webToolbarDelegate_;
 
-  base::scoped_nsobject<TabModel> tabModel_;
-
-  base::mac::ObjCPropertyReleaser propertyReleaser_NewTabPageController_;
+  TabModel* tabModel_;
 }
 
 // Load and bring panel into view.
 - (void)showPanel:(NewTabPageBarItem*)item;
 // Load panel on demand.
 - (BOOL)loadPanel:(NewTabPageBarItem*)item;
 // After a panel changes, update metrics and prefs information.
 - (void)panelChanged:(NewTabPageBarItem*)item;
 // Update current controller and tab bar index.  Used to call reload.
 - (void)updateCurrentController:(NewTabPageBarItem*)item
                           index:(NSUInteger)index;
 // Bring panel into scroll view.
 - (void)scrollToPanel:(NewTabPageBarItem*)item animate:(BOOL)animate;
 // Returns index of item in tab bar.
 - (NSUInteger)tabBarItemIndex:(NewTabPageBarItem*)item;
 // Call loadPanel by item index.
 - (void)loadControllerWithIndex:(NSUInteger)index;
 // Initialize scroll view.
 - (void)setUpScrollView;
 // Update overlay scroll view value.
 - (void)updateOverlayScrollPosition;
 // Disable the horizontal scroll view.
 - (void)disableScroll;
 // Enable the horizontal scroll view.
 - (void)enableScroll;
 // Returns the ID for the currently selected panel.
 - (NewTabPage::PanelIdentifier)selectedPanelID;
 
-@property(nonatomic, retain) NewTabPageView* ntpView;
+@property(nonatomic, strong) NewTabPageView* ntpView;
 
 // To ease modernizing the NTP only the internal panels are being converted
 // to UIViewControllers.  This means all the plumbing between the
 // BrowserViewController and the internal NTP panels (WebController, NTP)
 // hierarchy is skipped.  While normally the logic to push and pop a view
 // controller would be owned by a coordinator, in this case the old NTP
 // controller adds and removes child view controllers itself when a load
 // is initiated, and when WebController calls -willBeDismissed.
-@property(nonatomic, assign) UIViewController* parentViewController;
+@property(nonatomic, weak) UIViewController* parentViewController;
 
 // To ease modernizing the NTP a non-descript CommandDispatcher is passed thru
 // to be used by the reuabled NTP panels.
-@property(nonatomic, assign) id dispatcher;
+@property(nonatomic, weak) id dispatcher;
 
 @end
 
 @implementation NewTabPageController
 
-@synthesize ntpView = newTabPageView_;
+@synthesize ntpView = ntpView_;
 @synthesize swipeRecognizerProvider = swipeRecognizerProvider_;
 @synthesize parentViewController = parentViewController_;
 @synthesize dispatcher = dispatcher_;
 
 - (id)initWithUrl:(const GURL&)url
                   loader:(id<UrlLoader>)loader
                  focuser:(id<OmniboxFocuser>)focuser
              ntpObserver:(id<NewTabPageControllerObserver>)ntpObserver
             browserState:(ios::ChromeBrowserState*)browserState
               colorCache:(NSMutableDictionary*)colorCache
       webToolbarDelegate:(id<WebToolbarDelegate>)webToolbarDelegate
                 tabModel:(TabModel*)tabModel
     parentViewController:(UIViewController*)parentViewController
               dispatcher:(id)dispatcher {
   self = [super initWithNibName:nil url:url];
   if (self) {
     DCHECK(browserState);
-    propertyReleaser_NewTabPageController_.Init(self,
-                                                [NewTabPageController class]);
     browserState_ = browserState;
     loader_ = loader;
     newTabPageObserver_ = ntpObserver;
     parentViewController_ = parentViewController;
     dispatcher_ = dispatcher;
-    focuser_.reset(focuser);
-    webToolbarDelegate_.reset(webToolbarDelegate);
-    tabModel_.reset([tabModel retain]);
+    focuser_ = focuser;
+    webToolbarDelegate_ = webToolbarDelegate;
+    tabModel_ = tabModel;
     dominantColorCache_ = colorCache;
     self.title = l10n_util::GetNSString(IDS_NEW_TAB_TITLE);
     scrollInitialized_ = NO;
 
-    base::scoped_nsobject<UIScrollView> scrollView(
-        [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 412)]);
+    UIScrollView* scrollView =
+        [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 320, 412)];
     [scrollView setAutoresizingMask:(UIViewAutoresizingFlexibleWidth |
                                      UIViewAutoresizingFlexibleHeight)];
-    base::scoped_nsobject<NewTabPageBar> tabBar(
-        [[NewTabPageBar alloc] initWithFrame:CGRectMake(0, 412, 320, 48)]);
-    newTabPageView_ =
-        [[NewTabPageView alloc] initWithFrame:CGRectMake(0, 0, 320, 460)
-                                andScrollView:scrollView
-                                    andTabBar:tabBar];
+    NewTabPageBar* tabBar =
+        [[NewTabPageBar alloc] initWithFrame:CGRectMake(0, 412, 320, 48)];
+    ntpView_ = [[NewTabPageView alloc] initWithFrame:CGRectMake(0, 0, 320, 460)
+                                       andScrollView:scrollView
+                                           andTabBar:tabBar];
     // TODO(crbug.com/607113): Merge view and ntpView.
-    self.view = newTabPageView_;
+    self.view = ntpView_;
     [tabBar setDelegate:self];
 
     bool isIncognito = browserState_->IsOffTheRecord();
 
     NSString* incognito = l10n_util::GetNSString(IDS_IOS_NEW_TAB_INCOGNITO);
     NSString* mostVisited =
         l10n_util::GetNSString(IDS_IOS_NEW_TAB_MOST_VISITED);
     NSString* bookmarks =
         l10n_util::GetNSString(IDS_IOS_NEW_TAB_BOOKMARKS_PAGE_TITLE_MOBILE);
     NSString* openTabs = l10n_util::GetNSString(IDS_IOS_NEW_TAB_RECENT_TABS);
@@ skipping 73 matching lines @@
   // CRWNativeContent leaks, this will not be called.
   // TODO(crbug.com/708319): Also call -removeFromParentViewController for
   // open tabs and incognito here.
   [googleLandingController_ removeFromParentViewController];
   [bookmarkController_ removeFromParentViewController];
 
   [googleLandingController_ setDelegate:nil];
   [bookmarkController_ setDelegate:nil];
   [openTabsController_ setDelegate:nil];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
-  [super dealloc];
 }
 
 #pragma mark - CRWNativeContent
 
 - (void)willBeDismissed {
   // This methods is called by //web immediately before |self|'s view is removed
   // from the view hierarchy, making it an ideal spot to intiate view controller
   // containment methods.
   // TODO(crbug.com/708319): Also call -willMoveToParentViewController:nil for
   // open tabs and incognito here.
@@ skipping 195 matching lines @@
 }
 
 - (BOOL)loadPanel:(NewTabPageBarItem*)item {
   DCHECK(self.parentViewController);
   UIView* view = nil;
   UIViewController* panelController = nil;
   BOOL created = NO;
   // Only load the controllers once.
   if (item.identifier == NewTabPage::kBookmarksPanel) {
     if (!bookmarkController_) {
-      base::scoped_nsobject<BookmarkControllerFactory> factory(
-          [[BookmarkControllerFactory alloc] init]);
-      bookmarkController_.reset([[factory
-          bookmarkPanelControllerForBrowserState:browserState_
-                                          loader:loader_
-                                      colorCache:dominantColorCache_] retain]);
+      BookmarkControllerFactory* factory =
+          [[BookmarkControllerFactory alloc] init];
+      bookmarkController_ =
+          [factory bookmarkPanelControllerForBrowserState:browserState_
+                                                   loader:loader_
+                                               colorCache:dominantColorCache_];
     }
     panelController = bookmarkController_;
     view = [bookmarkController_ view];
     [bookmarkController_ setDelegate:self];
   } else if (item.identifier == NewTabPage::kMostVisitedPanel) {
     if (!googleLandingController_) {
-      googleLandingController_.reset(
-          [[GoogleLandingViewController alloc] init]);
+      googleLandingController_ = [[GoogleLandingViewController alloc] init];
       [googleLandingController_ setDispatcher:self.dispatcher];
-      googleLandingMediator_.reset([[GoogleLandingMediator alloc]
+      googleLandingMediator_ = [[GoogleLandingMediator alloc]
           initWithConsumer:googleLandingController_
               browserState:browserState_
                 dispatcher:self.dispatcher
-              webStateList:[tabModel_ webStateList]]);
+              webStateList:[tabModel_ webStateList]];
       [googleLandingController_ setDataSource:googleLandingMediator_];
     }
     panelController = googleLandingController_;
     view = [googleLandingController_ view];
     [googleLandingController_ setDelegate:self];
   } else if (item.identifier == NewTabPage::kOpenTabsPanel) {
     if (!openTabsController_)
-      openTabsController_.reset([[RecentTabsPanelController alloc]
-          initWithLoader:loader_
-            browserState:browserState_]);
+      openTabsController_ =
+          [[RecentTabsPanelController alloc] initWithLoader:loader_
+                                               browserState:browserState_];
     // TODO(crbug.com/708319): Also set panelController for opentabs here.
     view = [openTabsController_ view];
     [openTabsController_ setDelegate:self];
   } else if (item.identifier == NewTabPage::kIncognitoPanel) {
     if (!incognitoController_)
-      incognitoController_.reset([[IncognitoPanelController alloc]
-              initWithLoader:loader_
-                browserState:browserState_
-          webToolbarDelegate:webToolbarDelegate_]);
+      incognitoController_ =
+          [[IncognitoPanelController alloc] initWithLoader:loader_
+                                              browserState:browserState_
+                                        webToolbarDelegate:webToolbarDelegate_];
     // TODO(crbug.com/708319): Also set panelController for incognito here.
     view = [incognitoController_ view];
   } else {
     NOTREACHED();
     return NO;
   }
 
   // Add the panel views to the scroll view in the proper location.
   NSUInteger index = [self tabBarItemIndex:item];
   if (view.superview == nil) {
@@ skipping 20 matching lines @@
 }
 
 - (void)scrollToPanel:(NewTabPageBarItem*)item animate:(BOOL)animate {
   NSUInteger index = [self tabBarItemIndex:item];
   if (IsIPadIdiom()) {
     CGRect itemFrame = [self.ntpView panelFrameForItemAtIndex:index];
     CGPoint point = CGPointMake(CGRectGetMinX(itemFrame), 0);
     [self.ntpView.scrollView setContentOffset:point animated:animate];
   } else {
     if (item.identifier == NewTabPage::kBookmarksPanel) {
-      base::scoped_nsobject<GenericChromeCommand> command(
-          [[GenericChromeCommand alloc] initWithTag:IDC_SHOW_BOOKMARK_MANAGER]);
+      GenericChromeCommand* command =
+          [[GenericChromeCommand alloc] initWithTag:IDC_SHOW_BOOKMARK_MANAGER];
       [self.ntpView chromeExecuteCommand:command];
     } else if (item.identifier == NewTabPage::kOpenTabsPanel) {
-      base::scoped_nsobject<GenericChromeCommand> command(
-          [[GenericChromeCommand alloc] initWithTag:IDC_SHOW_OTHER_DEVICES]);
+      GenericChromeCommand* command =
+          [[GenericChromeCommand alloc] initWithTag:IDC_SHOW_OTHER_DEVICES];
       [self.ntpView chromeExecuteCommand:command];
     }
   }
 
   if (currentController_ == nil) {
     [self updateCurrentController:item index:index];
   }
 }
 
 // Return the index of the tab item.  For iPhone always return 0 since the
@@ skipping 24 matching lines @@
   if (!IsIPadIdiom() && (item.identifier == NewTabPage::kBookmarksPanel ||
                          item.identifier == NewTabPage::kOpenTabsPanel)) {
     // Don't update |currentController_| for iPhone since Bookmarks and Recent
     // Tabs are presented in a modal view controller.
     return;
   }
 
   id<NewTabPagePanelProtocol> oldController = currentController_;
   self.ntpView.tabBar.selectedIndex = index;
   if (item.identifier == NewTabPage::kBookmarksPanel)
-    currentController_ = bookmarkController_.get();
+    currentController_ = bookmarkController_;
   else if (item.identifier == NewTabPage::kMostVisitedPanel)
-    currentController_ = googleLandingController_.get();
+    currentController_ = googleLandingController_;
   else if (item.identifier == NewTabPage::kOpenTabsPanel)
-    currentController_ = openTabsController_.get();
+    currentController_ = openTabsController_;
   else if (item.identifier == NewTabPage::kIncognitoPanel)
-    currentController_ = incognitoController_.get();
+    currentController_ = incognitoController_;
 
   [bookmarkController_
-      setScrollsToTop:(currentController_ == bookmarkController_.get())];
+      setScrollsToTop:(currentController_ == bookmarkController_)];
   [googleLandingController_
-      setScrollsToTop:(currentController_ == googleLandingController_.get())];
+      setScrollsToTop:(currentController_ == googleLandingController_)];
   [openTabsController_
-      setScrollsToTop:(currentController_ == openTabsController_.get())];
+      setScrollsToTop:(currentController_ == openTabsController_)];
   [self.ntpView.tabBar
       setShadowAlpha:[currentController_ alphaForBottomShadow]];
 
   if (oldController != currentController_) {
     [currentController_ wasShown];
     [oldController wasHidden];
   }
 }
 
 - (void)panelChanged:(NewTabPageBarItem*)item {
@@ skipping 51 matching lines @@
 
 - (void)updateNtpBarShadowForPanelController:
     (id<NewTabPagePanelProtocol>)ntpPanelController {
   if (currentController_ != ntpPanelController)
     return;
   [self.ntpView.tabBar
       setShadowAlpha:[ntpPanelController alphaForBottomShadow]];
 }
 
 @end
+
+@implementation NewTabPageController (TestSupport)
+
+- (id<NewTabPagePanelProtocol>)currentController {
+  return currentController_;
+}
+
+- (BookmarkHomeTabletNTPController*)bookmarkController {
+  return bookmarkController_;
+}
+
+- (GoogleLandingViewController*)googleLandingController {
+  return googleLandingController_;
+}
+
+- (id<NewTabPagePanelProtocol>)incognitoController {
+  return incognitoController_;
+}
+
+@end