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

ios/chrome/browser/ui/main/browser_view_wrangler.mm

 // Copyright 2016 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/main/browser_view_wrangler.h"
 
-#include "base/mac/objc_property_releaser.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "ios/chrome/browser/application_context.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #import "ios/chrome/browser/browsing_data/browsing_data_removal_controller.h"
 #include "ios/chrome/browser/browsing_data/ios_chrome_browsing_data_remover.h"
 #include "ios/chrome/browser/crash_report/crash_report_helper.h"
 #import "ios/chrome/browser/device_sharing/device_sharing_manager.h"
 #import "ios/chrome/browser/physical_web/start_physical_web_discovery.h"
 #import "ios/chrome/browser/sessions/session_ios.h"
 #import "ios/chrome/browser/sessions/session_service_ios.h"
 #import "ios/chrome/browser/sessions/session_window_ios.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #import "ios/chrome/browser/tabs/tab_model.h"
 #import "ios/chrome/browser/tabs/tab_model_observer.h"
 #import "ios/chrome/browser/ui/browser_view_controller.h"
 #import "ios/chrome/browser/ui/browser_view_controller_dependency_factory.h"
 #include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 @interface BrowserViewWrangler ()<TabModelObserver> {
   ios::ChromeBrowserState* _browserState;
   __unsafe_unretained id<TabModelObserver> _tabModelObserver;
   BOOL _isShutdown;
-
-  base::mac::ObjCPropertyReleaser _propertyReleaser_BrowserViewWrangler;
 }
 
 // Responsible for maintaining all state related to sharing to other devices.
 // Redeclared readwrite from the readonly declaration in the Testing interface.
-@property(nonatomic, retain, readwrite)
+@property(nonatomic, strong, readwrite)
     DeviceSharingManager* deviceSharingManager;
 
 // Creates a new autoreleased tab model for |browserState|; if |empty| is NO,
 // then any existing tabs that have been saved for |browserState| will be
 // loaded; otherwise, the tab model will be created empty.
 - (TabModel*)tabModelForBrowserState:(ios::ChromeBrowserState*)browserState
                                empty:(BOOL)empty;
 
 // Creates a new off-the-record ("incognito") browser state for |_browserState|,
 // then calls -tabModelForBrowserState:empty: and returns the (autoreleased)
@@ skipping 14 matching lines @@
 @synthesize mainTabModel = _mainTabModel;
 @synthesize otrBVC = _otrBVC;
 @synthesize otrTabModel = _otrTabModel;
 @synthesize currentBVC = _currentBVC;
 // Private properies.
 @synthesize deviceSharingManager = _deviceSharingManager;
 
 - (instancetype)initWithBrowserState:(ios::ChromeBrowserState*)browserState
                     tabModelObserver:(id<TabModelObserver>)tabModelObserver {
   if ((self = [super init])) {
-    _propertyReleaser_BrowserViewWrangler.Init(self,
-                                               [BrowserViewWrangler class]);
     _browserState = browserState;
     _tabModelObserver = tabModelObserver;
   }
   return self;
 }
 
 - (instancetype)init {
   NOTREACHED();
   return nil;
 }
 
 - (void)dealloc {
   DCHECK(_isShutdown) << "-shutdown must be called before -dealloc";
-  [super dealloc];
 }
 
 #pragma mark - BrowserViewInformation property implementations
 
 - (BrowserViewController*)mainBVC {
   if (!_mainBVC) {
     // |_browserState| should always be set before trying to create
     // |_mainBVC|.
     DCHECK(_browserState);
     self.mainBVC =
         [self bvcForBrowserState:_browserState tabModel:self.mainTabModel];
     DCHECK(_mainBVC);
   }
   return _mainBVC;
 }
 
 - (void)setMainBVC:(BrowserViewController*)mainBVC {
   if (_mainBVC == mainBVC)
     return;
 
   if (_mainBVC) {
     [_mainBVC browserStateDestroyed];
     [_mainBVC shutdown];
-    [_mainBVC autorelease];
   }
 
-  _mainBVC = [mainBVC retain];
+  _mainBVC = mainBVC;
 }
 
 - (TabModel*)mainTabModel {
   if (!_mainTabModel) {
     self.mainTabModel = [self tabModelForBrowserState:_browserState empty:NO];
     // Follow loaded URLs in the main tab model to send those in case of
     // crashes.
     ios_internal::breakpad::MonitorURLsForTabModel(_mainTabModel);
     ios::GetChromeBrowserProvider()->InitializeCastService(_mainTabModel);
   }
   return _mainTabModel;
 }
 
 - (void)setMainTabModel:(TabModel*)mainTabModel {
   if (_mainTabModel == mainTabModel)
     return;
 
   if (_mainTabModel) {
     [_mainTabModel browserStateDestroyed];
     if (_tabModelObserver) {
       [_mainTabModel removeObserver:_tabModelObserver];
     }
     [_mainTabModel removeObserver:self];
-    [_mainTabModel autorelease];
   }
 
-  _mainTabModel = [mainTabModel retain];
+  _mainTabModel = mainTabModel;
 }
 
 - (BrowserViewController*)otrBVC {
   if (!_otrBVC) {
     // |_browserState| should always be set before trying to create
     // |_otrBVC|.
     DCHECK(_browserState);
     ios::ChromeBrowserState* otrBrowserState =
         _browserState->GetOffTheRecordChromeBrowserState();
     DCHECK(otrBrowserState);
     self.otrBVC =
         [self bvcForBrowserState:otrBrowserState tabModel:self.otrTabModel];
     DCHECK(_otrBVC);
   }
   return _otrBVC;
 }
 
 - (void)setOtrBVC:(BrowserViewController*)otrBVC {
   if (_otrBVC == otrBVC)
     return;
 
   if (_otrBVC) {
     [_otrBVC browserStateDestroyed];
     [_otrBVC shutdown];
-    [_otrBVC autorelease];
   }
 
-  _otrBVC = [otrBVC retain];
+  _otrBVC = otrBVC;
 }
 
 - (TabModel*)otrTabModel {
   if (!_otrTabModel) {
     self.otrTabModel = [self buildOtrTabModel:NO];
   }
   return _otrTabModel;
 }
 
 - (void)setOtrTabModel:(TabModel*)otrTabModel {
   if (_otrTabModel == otrTabModel)
     return;
 
   if (_otrTabModel) {
     [_otrTabModel browserStateDestroyed];
     if (_tabModelObserver) {
       [_otrTabModel removeObserver:_tabModelObserver];
     }
     [_otrTabModel removeObserver:self];
-    [_otrTabModel autorelease];
   }
 
-  _otrTabModel = [otrTabModel retain];
+  _otrTabModel = otrTabModel;
 }
 
 - (void)setCurrentBVC:(BrowserViewController*)bvc
       storageSwitcher:(id<BrowserStateStorageSwitching>)storageSwitcher {
   DCHECK(bvc != nil);
   // |bvc| should be one of the BrowserViewControllers this class already owns.
   DCHECK(_mainBVC == bvc || _otrBVC == bvc);
   if (self.currentBVC == bvc) {
     return;
   }
@@ skipping 49 matching lines @@
 }
 
 - (void)tabModel:(TabModel*)model didChangeTab:(Tab*)tab {
   [self updateDeviceSharingManager];
 }
 
 #pragma mark - Other public methods
 
 - (void)updateDeviceSharingManager {
   if (!self.deviceSharingManager) {
-    self.deviceSharingManager =
-        [[[DeviceSharingManager alloc] init] autorelease];
+    self.deviceSharingManager = [[DeviceSharingManager alloc] init];
   }
   [self.deviceSharingManager updateBrowserState:_browserState];
 
   GURL activeURL;
   Tab* currentTab = [self.currentBVC tabModel].currentTab;
   // Set the active URL if there's a current tab and the current BVC is not OTR.
   if (currentTab && self.currentBVC != self.otrBVC) {
     activeURL = currentTab.visibleURL;
   }
   [self.deviceSharingManager updateActiveURL:activeURL];
@@ skipping 94 matching lines @@
     SessionIOS* session =
         [[SessionServiceIOS sharedService] loadSessionFromDirectory:statePath];
     if (session) {
       DCHECK_EQ(session.sessionWindows.count, 1u);
       sessionWindow = session.sessionWindows[0];
     }
   }
 
   // Create tab model from saved session (nil is ok).
   TabModel* tabModel =
-      [[[TabModel alloc] initWithSessionWindow:sessionWindow
-                                sessionService:[SessionServiceIOS sharedService]
-                                  browserState:browserState] autorelease];
+      [[TabModel alloc] initWithSessionWindow:sessionWindow
+                               sessionService:[SessionServiceIOS sharedService]
+                                 browserState:browserState];
   // Add observers.
   if (_tabModelObserver) {
     [tabModel addObserver:_tabModelObserver];
     [tabModel addObserver:self];
   }
   ios_internal::breakpad::MonitorTabStateForTabModel(tabModel);
 
   return tabModel;
 }
 
 - (BrowserViewController*)bvcForBrowserState:
                               (ios::ChromeBrowserState*)browserState
                                     tabModel:(TabModel*)tabModel {
-  base::scoped_nsobject<BrowserViewControllerDependencyFactory> factory(
+  BrowserViewControllerDependencyFactory* factory =
       [[BrowserViewControllerDependencyFactory alloc]
-          initWithBrowserState:browserState]);
-  return [[[BrowserViewController alloc] initWithTabModel:tabModel
-                                             browserState:browserState
-                                        dependencyFactory:factory] autorelease];
+          initWithBrowserState:browserState];
+  return [[BrowserViewController alloc] initWithTabModel:tabModel
+                                            browserState:browserState
+                                       dependencyFactory:factory];
 }
 
 @end