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

ios/chrome/browser/ui/authentication/authentication_flow.mm

 // Copyright 2014 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/authentication/authentication_flow.h"
 
-#include "base/ios/weak_nsobject.h"
 #include "base/logging.h"
-#include "base/mac/objc_property_releaser.h"
 #include "base/mac/scoped_block.h"
-#include "base/mac/scoped_nsobject.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/signin/authentication_service.h"
 #include "ios/chrome/browser/signin/authentication_service_factory.h"
 #include "ios/chrome/browser/signin/constants.h"
 #import "ios/chrome/browser/ui/authentication/authentication_flow_performer.h"
 #include "ios/chrome/grit/ios_strings.h"
 #import "ios/public/provider/chrome/browser/chrome_browser_provider.h"
 #import "ios/public/provider/chrome/browser/signin/chrome_identity.h"
 #include "ios/public/provider/chrome/browser/signin/chrome_identity_service.h"
 #include "ios/public/provider/chrome/browser/signin/signin_error_provider.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using signin_ui::CompletionCallback;
 
 namespace {
 
 // The states of the sign-in flow state machine.
 enum AuthenticationState {
   BEGIN,
   CHECK_SIGNIN_STEPS,
   FETCH_MANAGED_STATUS,
   CHECK_MERGE_CASE,
@@ skipping 39 matching lines @@
 - (void)cancelFlow;
 
 // Handles an authentication error and show an alert to the user.
 - (void)handleAuthenticationError:(NSError*)error;
 
 @end
 
 @implementation AuthenticationFlow {
   ShouldClearData _shouldClearData;
   PostSignInAction _postSignInAction;
-  base::scoped_nsobject<UIViewController> _presentingViewController;
-  base::mac::ScopedBlock<CompletionCallback> _signInCompletion;
-  base::scoped_nsobject<AuthenticationFlowPerformer> _performer;
+  UIViewController* _presentingViewController;
+  CompletionCallback _signInCompletion;
+  AuthenticationFlowPerformer* _performer;
 
   // State machine tracking.
   AuthenticationState _state;
   BOOL _didSignIn;
   BOOL _failedOrCancelled;
   BOOL _shouldSignIn;
   BOOL _shouldSignOut;
   BOOL _shouldShowManagedConfirmation;
   BOOL _shouldStartSync;
   ios::ChromeBrowserState* _browserState;
-  base::scoped_nsobject<ChromeIdentity> _browserStateIdentity;
-  base::scoped_nsobject<ChromeIdentity> _identityToSignIn;
-  base::scoped_nsobject<NSString> _identityToSignInHostedDomain;
+  ChromeIdentity* _browserStateIdentity;
+  ChromeIdentity* _identityToSignIn;
+  NSString* _identityToSignInHostedDomain;
 
   // This AuthenticationFlow keeps a reference to |self| while a sign-in flow is
   // is in progress to ensure it outlives any attempt to destroy it in
   // |_signInCompletion|.
-  base::scoped_nsobject<AuthenticationFlow> _selfRetainer;
-
-  base::mac::ObjCPropertyReleaser _propertyReleaser_AuthenticationFlow;
+  AuthenticationFlow* _selfRetainer;
 }
 
 @synthesize handlingError = _handlingError;
 
 #pragma mark - Public methods
 
 - (instancetype)initWithBrowserState:(ios::ChromeBrowserState*)browserState
                             identity:(ChromeIdentity*)identity
                      shouldClearData:(ShouldClearData)shouldClearData
                     postSignInAction:(PostSignInAction)postSignInAction
             presentingViewController:
                 (UIViewController*)presentingViewController {
   if ((self = [super init])) {
     DCHECK(browserState);
     DCHECK(presentingViewController);
     _browserState = browserState;
-    _identityToSignIn.reset([identity retain]);
+    _identityToSignIn = identity;
     _shouldClearData = shouldClearData;
     _postSignInAction = postSignInAction;
-    _presentingViewController.reset([presentingViewController retain]);
+    _presentingViewController = presentingViewController;
     _state = BEGIN;
-    _propertyReleaser_AuthenticationFlow.Init(self, [AuthenticationFlow class]);
   }
   return self;
 }
 
 - (void)startSignInWithCompletion:(CompletionCallback)completion {
   DCHECK_EQ(BEGIN, _state);
   DCHECK(!_signInCompletion);
   DCHECK(completion);
-  _signInCompletion.reset(completion, base::scoped_policy::RETAIN);
-  _selfRetainer.reset([self retain]);
+  _signInCompletion = completion;
+  _selfRetainer = self;
   // Kick off the state machine.
   if (!_performer) {
-    _performer.reset(
-        [[AuthenticationFlowPerformer alloc] initWithDelegate:self]);
+    _performer = [[AuthenticationFlowPerformer alloc] initWithDelegate:self];
   }
   [self continueSignin];
 }
 
 - (void)cancelAndDismiss {
   if (_state == DONE)
     return;
 
   [_performer cancelAndDismiss];
   if (_state != DONE) {
     // The performer might not have been able to continue the flow if it was
     // waiting for a callback (e.g. waiting for AccountReconcilor). In this
     // case, we force the flow to finish synchronously.
     [self cancelFlow];
   }
 
   DCHECK_EQ(DONE, _state);
 }
 
 - (void)setPresentingViewController:
     (UIViewController*)presentingViewController {
-  _presentingViewController.reset([presentingViewController retain]);
+  _presentingViewController = presentingViewController;
 }
 
 #pragma mark State machine management
 
 - (AuthenticationState)nextStateFailedOrCancelled {
   DCHECK(_failedOrCancelled);
   switch (_state) {
     case BEGIN:
     case CHECK_SIGNIN_STEPS:
     case FETCH_MANAGED_STATUS:
@@ skipping 134 matching lines @@
 
     case COMPLETE_WITH_FAILURE:
       if (_didSignIn) {
         [_performer signOutImmediatelyFromBrowserState:_browserState];
         // Enabling/disabling sync does not take effect in the sync backend
         // until committing changes.
         [_performer commitSyncForBrowserState:_browserState];
       }
       [self completeSignInWithSuccess:NO];
       return;
-    case CLEANUP_BEFORE_DONE:
+    case CLEANUP_BEFORE_DONE: {
       // Clean up asynchronously to ensure that |self| does not die while
       // the flow is running.
       DCHECK([NSThread isMainThread]);
       dispatch_async(dispatch_get_main_queue(), ^{
-        _selfRetainer.reset();
+        _selfRetainer = nil;
       });
       [self continueSignin];
       return;
+    }
     case DONE:
       return;
   }
   NOTREACHED();
 }
 
 - (void)checkSigninSteps {
-  _browserStateIdentity.reset(
-      [AuthenticationServiceFactory::GetForBrowserState(_browserState)
-              ->GetAuthenticatedIdentity() retain]);
+  _browserStateIdentity =
+      AuthenticationServiceFactory::GetForBrowserState(_browserState)
+          ->GetAuthenticatedIdentity();
   if (_browserStateIdentity)
     _shouldSignOut = YES;
 
   _shouldSignIn = YES;
   _shouldStartSync = _postSignInAction == POST_SIGNIN_ACTION_START_SYNC;
 }
 
 - (void)signInIdentity:(ChromeIdentity*)identity {
   if (ios::GetChromeBrowserProvider()
           ->GetChromeIdentityService()
           ->IsValidIdentity(identity)) {
     [_performer signInIdentity:identity
               withHostedDomain:_identityToSignInHostedDomain
                 toBrowserState:_browserState];
     _didSignIn = YES;
     [self continueSignin];
   } else {
     // Handle the case where the identity is no longer valid.
     [self handleAuthenticationError:IdentityMissingError()];
   }
 }
 
 - (void)completeSignInWithSuccess:(BOOL)success {
   DCHECK(_signInCompletion)
       << "|completeSignInWithSuccess| should not be called twice.";
-  _signInCompletion.get()(success);
-  _signInCompletion.reset();
+  _signInCompletion(success);
+  _signInCompletion = nil;
   [self continueSignin];
 }
 
 - (void)cancelFlow {
   if (_failedOrCancelled) {
     // Avoid double handling of cancel or error.
     return;
   }
   _failedOrCancelled = YES;
   [self continueSignin];
 }
 
 - (void)handleAuthenticationError:(NSError*)error {
   if (_failedOrCancelled) {
     // Avoid double handling of cancel or error.
     return;
   }
   DCHECK(error);
   _failedOrCancelled = YES;
   self.handlingError = YES;
-  base::WeakNSObject<AuthenticationFlow> weakSelf(self);
+  __weak AuthenticationFlow* weakSelf = self;
   [_performer showAuthenticationError:error
                        withCompletion:^{
-                         base::scoped_nsobject<AuthenticationFlow> strongSelf(
-                             [weakSelf retain]);
+                         AuthenticationFlow* strongSelf = weakSelf;
                          if (!strongSelf)
                            return;
                          [strongSelf setHandlingError:NO];
                          [strongSelf continueSignin];
                        }
                        viewController:_presentingViewController];
 }
 
 #pragma mark AuthenticationFlowPerformerDelegate
 
@@ skipping 12 matching lines @@
   [self continueSignin];
 }
 
 - (void)didChooseCancel {
   [self cancelFlow];
 }
 
 - (void)didFetchManagedStatus:(NSString*)hostedDomain {
   DCHECK_EQ(FETCH_MANAGED_STATUS, _state);
   _shouldShowManagedConfirmation = [hostedDomain length] > 0;
-  _identityToSignInHostedDomain.reset([hostedDomain retain]);
+  _identityToSignInHostedDomain = hostedDomain;
   [self continueSignin];
 }
 
 - (void)didFailFetchManagedStatus:(NSError*)error {
   DCHECK_EQ(FETCH_MANAGED_STATUS, _state);
   NSError* flowError =
       [NSError errorWithDomain:kAuthenticationErrorDomain
                           code:AUTHENTICATION_FLOW_ERROR
                       userInfo:@{
                         NSLocalizedDescriptionKey :
@@ skipping 11 matching lines @@
   [self cancelFlow];
 }
 
 - (UIViewController*)presentingViewController {
   return _presentingViewController;
 }
 
 #pragma mark - Used for testing
 
 - (void)setPerformerForTesting:(AuthenticationFlowPerformer*)performer {
-  _performer.reset([performer retain]);
+  _performer = performer;
 }
 
 @end