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

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

 // Copyright 2015 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 <memory>
 
 #import "base/mac/scoped_block.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/ios/wait_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/sync_preferences/pref_service_mock_factory.h"
 #include "components/sync_preferences/pref_service_syncable.h"
 #include "ios/chrome/browser/browser_state/test_chrome_browser_state.h"
 #include "ios/chrome/browser/prefs/browser_prefs.h"
 #include "ios/chrome/browser/signin/authentication_service_factory.h"
 #import "ios/chrome/browser/signin/authentication_service_fake.h"
 #import "ios/chrome/browser/ui/authentication/authentication_flow_performer.h"
 #include "ios/public/provider/chrome/browser/signin/fake_chrome_identity_service.h"
 #include "ios/web/public/test/test_web_thread_bundle.h"
 #import "testing/gtest_mac.h"
 #import "testing/platform_test.h"
 #import "third_party/ocmock/gtest_support.h"
 #import "third_party/ocmock/ocmock_extensions.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 
 class AuthenticationFlowTest : public PlatformTest {
  protected:
   void SetUp() override {
     PlatformTest::SetUp();
 
     TestChromeBrowserState::Builder builder;
     builder.AddTestingFactory(
         AuthenticationServiceFactory::GetInstance(),
         AuthenticationServiceFake::CreateAuthenticationService);
     builder.SetPrefService(CreatePrefService());
     browser_state_ = builder.Build();
     ios::FakeChromeIdentityService* identityService =
         ios::FakeChromeIdentityService::GetInstanceFromChromeProvider();
     identityService->AddIdentities(@[ @"identity1", @"identity2" ]);
     identity1_ =
         [identityService->GetAllIdentitiesSortedForDisplay() objectAtIndex:0];
     identity2_ =
         [identityService->GetAllIdentitiesSortedForDisplay() objectAtIndex:1];
-    sign_in_completion_.reset(
-        ^(BOOL success) {
-          finished_ = true;
-          signed_in_success_ = success;
-        },
-        base::scoped_policy::RETAIN);
+    sign_in_completion_ = ^(BOOL success) {
+      finished_ = true;
+      signed_in_success_ = success;
+    };
     finished_ = false;
     signed_in_success_ = false;
   }
 
   std::unique_ptr<sync_preferences::PrefServiceSyncable> CreatePrefService() {
     sync_preferences::PrefServiceMockFactory factory;
     scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
         new user_prefs::PrefRegistrySyncable);
     std::unique_ptr<sync_preferences::PrefServiceSyncable> prefs =
         factory.CreateSyncable(registry.get());
     RegisterBrowserStatePrefs(registry.get());
     return prefs;
   }
 
   AuthenticationFlowPerformer* GetAuthenticationFlowPerformer() {
-    return static_cast<AuthenticationFlowPerformer*>(performer_.get());
+    return static_cast<AuthenticationFlowPerformer*>(performer_);
   }
 
   // Creates a new AuthenticationFlow with default values for fields that are
   // not directly useful.
   void CreateAuthenticationFlow(ShouldClearData shouldClearData,
                                 PostSignInAction postSignInAction) {
     ChromeIdentity* identity = identity1_;
-    view_controller_.reset(
-        [[OCMockObject niceMockForClass:[UIViewController class]] retain]);
-    authentication_flow_.reset([[AuthenticationFlow alloc]
-            initWithBrowserState:browser_state_.get()
-                        identity:identity
-                 shouldClearData:shouldClearData
-                postSignInAction:postSignInAction
-        presentingViewController:view_controller_]);
-    performer_.reset([[OCMockObject
-        mockForClass:[AuthenticationFlowPerformer class]] retain]);
+    view_controller_ = [OCMockObject niceMockForClass:[UIViewController class]];
+    authentication_flow_ =
+        [[AuthenticationFlow alloc] initWithBrowserState:browser_state_.get()
+                                                identity:identity
+                                         shouldClearData:shouldClearData
+                                        postSignInAction:postSignInAction
+                                presentingViewController:view_controller_];
+    performer_ =
+        [OCMockObject mockForClass:[AuthenticationFlowPerformer class]];
     [authentication_flow_
         setPerformerForTesting:GetAuthenticationFlowPerformer()];
   }
 
   // Checks if the AuthenticationFlow operation has completed, and whether it
   // was successful.
   void CheckSignInCompletion(bool expectedSignedIn) {
     base::test::ios::WaitUntilCondition(^bool {
       return finished_;
     });
     EXPECT_EQ(true, finished_);
     EXPECT_EQ(expectedSignedIn, signed_in_success_);
     [performer_ verify];
   }
 
   web::TestWebThreadBundle thread_bundle_;
-  base::scoped_nsobject<AuthenticationFlow> authentication_flow_;
+  AuthenticationFlow* authentication_flow_;
   std::unique_ptr<TestChromeBrowserState> browser_state_;
   ChromeIdentity* identity1_;
   ChromeIdentity* identity2_;
-  base::scoped_nsobject<OCMockObject> performer_;
-  base::mac::ScopedBlock<signin_ui::CompletionCallback> sign_in_completion_;
-  base::scoped_nsobject<UIViewController> view_controller_;
+  OCMockObject* performer_;
+  signin_ui::CompletionCallback sign_in_completion_;
+  UIViewController* view_controller_;
 
   // State of the flow
   bool finished_;
   bool signed_in_success_;
 };
 
 // Tests a Sign In of a normal account on the same profile, merging user data
 // and showing the sync settings.
 TEST_F(AuthenticationFlowTest, TestSignInSimple) {
   CreateAuthenticationFlow(SHOULD_CLEAR_DATA_MERGE_DATA,
@@ skipping 125 matching lines @@
   CreateAuthenticationFlow(SHOULD_CLEAR_DATA_MERGE_DATA,
                            POST_SIGNIN_ACTION_START_SYNC);
 
   NSError* error = [NSError errorWithDomain:@"foo" code:0 userInfo:nil];
   [[[performer_ expect] andDo:^(NSInvocation*) {
     [authentication_flow_ didFailFetchManagedStatus:error];
   }] fetchManagedStatus:browser_state_.get()
              forIdentity:identity1_];
 
   [[[performer_ expect] andDo:^(NSInvocation* invocation) {
-    ProceduralBlock completionBlock;
+    __unsafe_unretained ProceduralBlock completionBlock;
     [invocation getArgument:&completionBlock atIndex:3];
     completionBlock();
   }] showAuthenticationError:[OCMArg any]
                withCompletion:[OCMArg any]
                viewController:view_controller_];
 
   [authentication_flow_ startSignInWithCompletion:sign_in_completion_];
 
   CheckSignInCompletion(false);
 }
@@ skipping 27 matching lines @@
                        toBrowserState:browser_state_.get()];
 
   [[performer_ expect] commitSyncForBrowserState:browser_state_.get()];
 
   [authentication_flow_ startSignInWithCompletion:sign_in_completion_];
 
   CheckSignInCompletion(true);
 }
 
 }  // namespace