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

ios/chrome/app/application_delegate/app_state.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/app/application_delegate/app_state.h"
 
 #include "base/critical_closure.h"
 #import "base/mac/bind_objc_block.h"
-#import "base/mac/scoped_nsobject.h"
 #include "components/metrics/metrics_service.h"
+#import "ios/chrome/app/main_application_delegate.h"
 #import "ios/chrome/app/application_delegate/app_navigation.h"
 #import "ios/chrome/app/application_delegate/browser_launcher.h"
 #import "ios/chrome/app/application_delegate/memory_warning_helper.h"
 #import "ios/chrome/app/application_delegate/metrics_mediator.h"
 #import "ios/chrome/app/application_delegate/startup_information.h"
 #import "ios/chrome/app/application_delegate/tab_opening.h"
 #import "ios/chrome/app/application_delegate/tab_switching.h"
 #import "ios/chrome/app/application_delegate/user_activity_handler.h"
 #import "ios/chrome/app/deferred_initialization_runner.h"
 #import "ios/chrome/app/safe_mode/safe_mode_coordinator.h"
@@ skipping 12 matching lines @@
 #import "ios/chrome/browser/ui/browser_view_controller.h"
 #import "ios/chrome/browser/ui/main/browser_view_information.h"
 #include "ios/net/cookies/cookie_store_ios.h"
 #include "ios/net/cookies/system_cookie_util.h"
 #include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
 #include "ios/public/provider/chrome/browser/distribution/app_distribution_provider.h"
 #import "ios/public/provider/chrome/browser/user_feedback/user_feedback_provider.h"
 #include "ios/web/net/request_tracker_impl.h"
 #include "net/url_request/url_request_context.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 // Helper method to post |closure| on the UI thread.
 void PostTaskOnUIThread(const base::Closure& closure) {
   web::WebThread::PostTask(web::WebThread::UI, FROM_HERE, closure);
 }
 NSString* const kStartupAttemptReset = @"StartupAttempReset";
 }  // namespace
 
 @interface AppState ()<SafeModeCoordinatorDelegate> {
   // Container for startup information.
-  base::WeakNSProtocol<id<StartupInformation>> _startupInformation;
+  __weak id<StartupInformation> _startupInformation;
   // Browser launcher to launch browser in different states.
-  base::WeakNSProtocol<id<BrowserLauncher>> _browserLauncher;
+  __weak id<BrowserLauncher> _browserLauncher;
   // UIApplicationDelegate for the application.
-  base::WeakNSObject<MainApplicationDelegate> _mainApplicationDelegate;
+  __weak MainApplicationDelegate* _mainApplicationDelegate;
   // Window for the application.
-  base::WeakNSObject<UIWindow> _window;
+  __weak UIWindow* _window;
 
   // Variables backing properties of same name.
-  base::scoped_nsobject<SafeModeCoordinator> _safeModeCoordinator;
+  SafeModeCoordinator* _safeModeCoordinator;
 
   // Start of the current session, used for UMA.
   base::TimeTicks _sessionStartTime;
   // YES if the app is currently in the process of terminating.
   BOOL _appIsTerminating;
   // Indicates if an NTP tab should be opened once the application has become
   // active.
   BOOL _shouldOpenNTPTabOnActive;
   // Interstitial view used to block any incognito tabs after backgrounding.
-  base::scoped_nsobject<UIView> _incognitoBlocker;
+  UIView* _incognitoBlocker;
   // Whether the application is currently in the background.
   // This is a workaround for rdar://22392526 where
   // -applicationDidEnterBackground: can be called twice.
   // TODO(crbug.com/546196): Remove this once rdar://22392526 is fixed.
   BOOL _applicationInBackground;
   // YES if cookies are currently being flushed to disk.
   BOOL _savingCookies;
 }
 
 // Safe mode coordinator. If this is non-nil, the app is displaying the safe
 // mode UI.
-@property(nonatomic, retain) SafeModeCoordinator* safeModeCoordinator;
+@property(nonatomic, strong) SafeModeCoordinator* safeModeCoordinator;
 
 // Return value for -requiresHandlingAfterLaunchWithOptions that determines if
 // UIKit should make followup delegate calls such as
 // -performActionForShortcutItem or -openURL.
 @property(nonatomic, assign) BOOL shouldPerformAdditionalDelegateHandling;
 
 // This method is the first to be called when user launches the application.
 // Depending on the background tasks history, the state of the application is
 // either INITIALIZATION_STAGE_BASIC or INITIALIZATION_STAGE_BACKGROUND so this
 // step cannot be included in the |startUpBrowserToStage:| method.
@@ skipping 13 matching lines @@
   NOTREACHED();
   return nil;
 }
 
 - (instancetype)
 initWithBrowserLauncher:(id<BrowserLauncher>)browserLauncher
      startupInformation:(id<StartupInformation>)startupInformation
     applicationDelegate:(MainApplicationDelegate*)applicationDelegate {
   self = [super init];
   if (self) {
-    _startupInformation.reset(startupInformation);
-    _browserLauncher.reset(browserLauncher);
-    _mainApplicationDelegate.reset(applicationDelegate);
+    _startupInformation = startupInformation;
+    _browserLauncher = browserLauncher;
+    _mainApplicationDelegate = applicationDelegate;
   }
   return self;
 }
 
 #pragma mark - Properties implementation
 
 - (SafeModeCoordinator*)safeModeCoordinator {
   return _safeModeCoordinator;
 }
 
 - (void)setSafeModeCoordinator:(SafeModeCoordinator*)safeModeCoordinator {
-  _safeModeCoordinator.reset([safeModeCoordinator retain]);
+  _safeModeCoordinator = safeModeCoordinator;
 }
 
 - (void)setWindow:(UIWindow*)window {
-  _window.reset(window);
+  _window = window;
 }
 
 - (UIWindow*)window {
   return _window;
 }
 
 #pragma mark - Public methods.
 
 - (void)applicationDidEnterBackground:(UIApplication*)application
                          memoryHelper:(MemoryWarningHelper*)memoryHelper
@@ skipping 38 matching lines @@
   if (([[_browserLauncher browserViewInformation] currentBrowserState] &&
        [[_browserLauncher browserViewInformation] currentBrowserState]
            ->IsOffTheRecord()) ||
       (tabSwitcherIsActive &&
        ![[[_browserLauncher browserViewInformation] otrTabModel] isEmpty])) {
     // Cover the largest area potentially shown in the app switcher, in case the
     // screenshot is reused in a different orientation or size class.
     CGRect screenBounds = [[UIScreen mainScreen] bounds];
     CGFloat maxDimension =
         std::max(CGRectGetWidth(screenBounds), CGRectGetHeight(screenBounds));
-    _incognitoBlocker.reset([[UIView alloc]
-        initWithFrame:CGRectMake(0, 0, maxDimension, maxDimension)]);
+    _incognitoBlocker = [[UIView alloc]
+        initWithFrame:CGRectMake(0, 0, maxDimension, maxDimension)];
     InstallBackgroundInView(_incognitoBlocker);
     [_window addSubview:_incognitoBlocker];
   }
 
   // Do not save cookies if it is already in progress.
   if ([[_browserLauncher browserViewInformation] currentBVC].browserState &&
       !_savingCookies) {
     // Save cookies to disk. The empty critical closure guarantees that the task
     // will be run before backgrounding.
     scoped_refptr<net::URLRequestContextGetter> getter =
         [[_browserLauncher browserViewInformation] currentBVC]
             .browserState->GetRequestContext();
     _savingCookies = YES;
-    base::Closure criticalClosure = base::MakeCriticalClosure(base::BindBlock(^{
-      DCHECK_CURRENTLY_ON(web::WebThread::UI);
-      _savingCookies = NO;
-    }));
+    base::Closure criticalClosure =
+        base::MakeCriticalClosure(base::BindBlockArc(^{
+          DCHECK_CURRENTLY_ON(web::WebThread::UI);
+          _savingCookies = NO;
+        }));
     web::WebThread::PostTask(
-        web::WebThread::IO, FROM_HERE, base::BindBlock(^{
+        web::WebThread::IO, FROM_HERE, base::BindBlockArc(^{
           net::CookieStoreIOS* store = static_cast<net::CookieStoreIOS*>(
               getter->GetURLRequestContext()->cookie_store());
           // FlushStore() runs its callback on any thread. Jump back to UI.
           store->FlushStore(base::Bind(&PostTaskOnUIThread, criticalClosure));
         }));
   }
 
   // Mark the startup as clean if it hasn't already been.
   [[DeferredInitializationRunner sharedInstance]
       runBlockIfNecessary:kStartupAttemptReset];
@@ skipping 26 matching lines @@
     // is not complete.
     [self initializeUI];
     return;
   }
   if ([self isInSafeMode])
     return;
 
   _applicationInBackground = NO;
 
   [_incognitoBlocker removeFromSuperview];
-  _incognitoBlocker.reset();
+  _incognitoBlocker = nil;
 
   breakpad_helper::SetCurrentlyInBackground(false);
 
   // Update the state of metrics and crash reporting, as the method of
   // communication may have changed while the app was in the background.
   [metricsMediator updateMetricsStateBasedOnPrefsUserTriggered:NO];
 
   // Send any feedback that might be still on temporary storage.
   ios::GetChromeBrowserProvider()->GetUserFeedbackProvider()->Synchronize();
 
@@ skipping 35 matching lines @@
     UMA_HISTOGRAM_COUNTS_10000("CookieIOS.CookieCountOnForegrounding",
                                cookie_count);
     net::CheckForCookieLoss(cookie_count,
                             net::COOKIES_APPLICATION_FOREGROUNDED);
   }
 }
 
 - (void)resumeSessionWithTabOpener:(id<TabOpening>)tabOpener
                        tabSwitcher:(id<TabSwitching>)tabSwitcher {
   [_incognitoBlocker removeFromSuperview];
-  _incognitoBlocker.reset();
+  _incognitoBlocker = nil;
 
   DCHECK([_browserLauncher browserInitializationStage] ==
          INITIALIZATION_STAGE_FOREGROUND);
   _sessionStartTime = base::TimeTicks::Now();
   [[[_browserLauncher browserViewInformation] mainTabModel]
       resetSessionMetrics];
 
   if ([_startupInformation startupParameters]) {
     [UserActivityHandler
         handleStartupParametersWithTabOpener:tabOpener
@@ skipping 107 matching lines @@
 
 #pragma mark - Internal methods.
 
 - (void)initializeUI {
   _userInteracted = YES;
   [self saveLaunchDetailsToDefaults];
 
   DCHECK([_window rootViewController] == nil);
   if ([SafeModeCoordinator shouldStart]) {
     SafeModeCoordinator* safeModeCoordinator =
-        [[[SafeModeCoordinator alloc] initWithWindow:_window] autorelease];
+        [[SafeModeCoordinator alloc] initWithWindow:_window];
 
     self.safeModeCoordinator = safeModeCoordinator;
     [self.safeModeCoordinator setDelegate:self];
 
     // Activate the main window, which will prompt the views to load.
     [_window makeKeyAndVisible];
 
     [self.safeModeCoordinator start];
     return;
   }
@@ skipping 33 matching lines @@
   self = [self initWithBrowserLauncher:browserLauncher
                     startupInformation:startupInformation
                    applicationDelegate:applicationDelegate];
   if (self) {
     _shouldOpenNTPTabOnActive = shouldOpenNTP;
   }
   return self;
 }
 
 @end