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

ios/chrome/browser/ui/contextual_search/touch_to_search_permissions_mediator_unittest.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/contextual_search/touch_to_search_permissions_mediator.h"
 
 #import <UIKit/UIKit.h>
 #include <memory>
 
 #include "base/command_line.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #import "base/test/ios/wait_util.h"
 #include "base/time/time.h"
 #include "components/prefs/pref_service.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "ios/chrome/browser/browser_state/test_chrome_browser_state.h"
 #include "ios/chrome/browser/chrome_switches.h"
 #include "ios/chrome/browser/pref_names.h"
 #include "ios/chrome/browser/search_engines/template_url_service_factory.h"
 #include "ios/chrome/browser/sync/ios_chrome_profile_sync_service_factory.h"
 #include "ios/chrome/browser/sync/ios_chrome_profile_sync_test_util.h"
 #include "ios/chrome/browser/sync/sync_setup_service_factory.h"
 #include "ios/chrome/browser/sync/sync_setup_service_mock.h"
 #import "ios/chrome/browser/ui/contextual_search/touch_to_search_permissions_mediator+testing.h"
 #include "ios/web/public/test/test_web_thread_bundle.h"
 #include "net/base/network_change_notifier.h"
 #import "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 #import "third_party/ocmock/OCMock/OCMock.h"
 #include "third_party/ocmock/gtest_support.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using testing::Return;
 
 @interface TestTouchToSearchPermissionsAudience
     : NSObject<TouchToSearchPermissionsChangeAudience>
 @property BOOL updated;
 @end
 
 @implementation TestTouchToSearchPermissionsAudience
 @synthesize updated = _updated;
 - (void)touchToSearchPermissionsUpdated {
@@ skipping 49 matching lines @@
     TestChromeBrowserState::Builder browserStateBuilder;
     browserStateBuilder.AddTestingFactory(
         SyncSetupServiceFactory::GetInstance(), &CreateSyncSetupService);
     browserStateBuilder.AddTestingFactory(
         ios::TemplateURLServiceFactory::GetInstance(),
         ios::TemplateURLServiceFactory::GetDefaultFactory());
     browser_state_ = browserStateBuilder.Build();
     template_url_service_ =
         ios::TemplateURLServiceFactory::GetForBrowserState(BrowserState());
     template_url_service_->Load();
-    tts_permissions_.reset([[TouchToSearchPermissionsMediator alloc]
-        initWithBrowserState:BrowserState()]);
+    tts_permissions_ = [[TouchToSearchPermissionsMediator alloc]
+        initWithBrowserState:BrowserState()];
   }
 
   ios::ChromeBrowserState* BrowserState() { return browser_state_.get(); }
 
   web::TestWebThreadBundle thread_bundle_;
   std::unique_ptr<TestChromeBrowserState> browser_state_;
-  base::scoped_nsobject<TouchToSearchPermissionsMediator> tts_permissions_;
+  TouchToSearchPermissionsMediator* tts_permissions_;
   TemplateURLService* template_url_service_;
 };
 
 TEST_F(TouchToSearchPermissionsMediatorTest, PrefStates) {
   // Expect empty browser state to have undecided pref value.
   EXPECT_EQ(TouchToSearch::UNDECIDED, [tts_permissions_ preferenceState]);
 
   const struct {
     const std::string pref_value;
     TouchToSearch::TouchToSearchPreferenceState state;
@@ skipping 135 matching lines @@
                 [tts_permissions_ canPreloadSearchResults]);
     }
   }
 }
 
 TEST_F(TouchToSearchPermissionsMediatorTest,
        AreQueriesDisallowedWithoutTemplateService) {
   TestChromeBrowserState::Builder browserStateBuilder;
   std::unique_ptr<TestChromeBrowserState> browser_state(
       browserStateBuilder.Build());
-  base::scoped_nsobject<TouchToSearchPermissionsMediator> tts_permissions(
+  TouchToSearchPermissionsMediator* tts_permissions =
       [[TouchToSearchPermissionsMediator alloc]
-          initWithBrowserState:browser_state.get()]);
+          initWithBrowserState:browser_state.get()];
   EXPECT_FALSE([tts_permissions areContextualSearchQueriesSupported]);
 }
 
 TEST_F(TouchToSearchPermissionsMediatorTest, AreQueriesAllowed) {
   // The initial default search engine should support contextual search.
   EXPECT_TRUE([tts_permissions_ areContextualSearchQueriesSupported]);
 
   // Make a user-defined search engine and set it as the default.
   TemplateURLData data;
   data.SetShortName(base::ASCIIToUTF16("cs-not-supported"));
 
   TemplateURL* newUrl = template_url_service_->Add(
       std::unique_ptr<TemplateURL>(new TemplateURL(data)));
   // |template_url_service_| will take ownership of newUrl
   ASSERT_TRUE(newUrl);
   template_url_service_->SetUserSelectedDefaultSearchProvider(newUrl);
 
   // The newly-selected search engine doesn't support contextual search.
   EXPECT_FALSE([tts_permissions_ areContextualSearchQueriesSupported]);
 }
 
 TEST_F(TouchToSearchPermissionsMediatorTest, CanEnable) {
-  base::scoped_nsobject<MockTouchToSearchPermissionsMediator> permissions(
+  MockTouchToSearchPermissionsMediator* permissions =
       [[MockTouchToSearchPermissionsMediator alloc]
-          initWithBrowserState:BrowserState()]);
+          initWithBrowserState:BrowserState()];
 
   const struct {
     BOOL enabled_on_device;
     TouchToSearch::TouchToSearchPreferenceState prefState;
     BOOL voiceover_enabled;
     BOOL queries_allowed;
     BOOL expect_available;
   } tests[] = {
       // clang-format off
       // Enabled cases:
@@ skipping 24 matching lines @@
       {YES, TouchToSearch::UNDECIDED, YES, YES, NO},
       {YES, TouchToSearch::ENABLED,   NO,  NO,  NO},
       {YES, TouchToSearch::ENABLED,   YES, NO,  NO},
       {YES, TouchToSearch::ENABLED,   YES, YES, NO},
       // clang-format on
   };
 
   for (const auto& test : tests) {
     [[permissions class]
         setIsTouchToSearchAvailableOnDevice:test.enabled_on_device];
-    permissions.get().preferenceState = test.prefState;
-    permissions.get().isVoiceOverEnabled = test.voiceover_enabled;
-    permissions.get().areContextualSearchQueriesSupported =
-        test.queries_allowed;
+    permissions.preferenceState = test.prefState;
+    permissions.isVoiceOverEnabled = test.voiceover_enabled;
+    permissions.areContextualSearchQueriesSupported = test.queries_allowed;
     EXPECT_EQ(test.expect_available, [permissions canEnable]);
   }
 }
 
 TEST_F(TouchToSearchPermissionsMediatorTest, AudienceNotifications) {
-  base::scoped_nsobject<id> audience(
-      [[TestTouchToSearchPermissionsAudience alloc] init]);
+  id audience = [[TestTouchToSearchPermissionsAudience alloc] init];
   [tts_permissions_ setAudience:audience];
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(50);
   [[NSNotificationCenter defaultCenter]
       postNotificationName:UIApplicationWillEnterForegroundNotification
                     object:[UIApplication sharedApplication]];
   // Audience call is asynchronous, so expect nothing yet.
   EXPECT_FALSE([audience updated]);
   // Wait for async call.
   base::test::ios::WaitUntilCondition(
       ^bool(void) {
@@ skipping 59 matching lines @@
   BrowserState()->GetPrefs()->SetString(prefs::kContextualSearchEnabled,
                                         "true");
   // Audience call is asynchronous, so expect nothing yet.
   EXPECT_FALSE([audience updated]);
   // Wait long enough for async call not to occur.
   base::test::ios::SpinRunLoopWithMaxDelay(delay);
   EXPECT_FALSE([audience updated]);
   // Reset |audience|.
   [audience setUpdated:NO];
 
-  base::scoped_nsobject<id> audience2(
-      [[TestTouchToSearchPermissionsAudience alloc] init]);
+  id audience2 = [[TestTouchToSearchPermissionsAudience alloc] init];
   // If the permissions object is destroyed, queued notifications should still
   // be sent.
   [tts_permissions_ setAudience:audience2];
   [[NSNotificationCenter defaultCenter]
       postNotificationName:UIAccessibilityVoiceOverStatusChanged
                     object:nil];
-  tts_permissions_.reset();
+  tts_permissions_ = nil;
   base::test::ios::WaitUntilCondition(
       ^bool(void) {
         return [audience2 updated];
       },
       false, delay);
   EXPECT_TRUE([audience2 updated]);
 }
 
 TEST_F(TouchToSearchPermissionsMediatorTest, AudiencePrefsSynchronous) {
   id audience = [OCMockObject
       niceMockForProtocol:@protocol(TouchToSearchPermissionsChangeAudience)];
   [tts_permissions_ setAudience:audience];
 
   // Test that setting preferences through the same permissions object triggers
   // audience methods.
   [[audience expect]
       touchToSearchDidChangePreferenceState:TouchToSearch::ENABLED];
   [tts_permissions_ setPreferenceState:TouchToSearch::ENABLED];
   EXPECT_OCMOCK_VERIFY(audience);
   [tts_permissions_ setPreferenceState:TouchToSearch::DISABLED];
 
   // Test that setting preferences through another permissions object triggers
   // audience methods.
-  base::scoped_nsobject<TouchToSearchPermissionsMediator> other_permissions(
+  TouchToSearchPermissionsMediator* other_permissions =
       [[TouchToSearchPermissionsMediator alloc]
-          initWithBrowserState:BrowserState()]);
+          initWithBrowserState:BrowserState()];
   [[audience expect]
       touchToSearchDidChangePreferenceState:TouchToSearch::ENABLED];
   [other_permissions setPreferenceState:TouchToSearch::ENABLED];
   EXPECT_OCMOCK_VERIFY(audience);
   [tts_permissions_ setPreferenceState:TouchToSearch::DISABLED];
 
   // Test that setting preferences through the prefs system triggers audience
   // methods.
   [[audience expect]
       touchToSearchDidChangePreferenceState:TouchToSearch::ENABLED];
   BrowserState()->GetPrefs()->SetString(prefs::kContextualSearchEnabled,
                                         "true");
   EXPECT_OCMOCK_VERIFY(audience);
 }
 
 TEST_F(TouchToSearchPermissionsMediatorTest, OTR) {
   ios::ChromeBrowserState* otr_state =
       BrowserState()->GetOffTheRecordChromeBrowserState();
-  base::scoped_nsobject<TouchToSearchPermissionsMediator> permissions([
-      [TouchToSearchPermissionsMediator alloc] initWithBrowserState:otr_state]);
+  TouchToSearchPermissionsMediator* permissions =
+      [[TouchToSearchPermissionsMediator alloc] initWithBrowserState:otr_state];
 
   EXPECT_FALSE([permissions canEnable]);
   EXPECT_FALSE([permissions canSendPageURLs]);
   EXPECT_FALSE([permissions canEnable]);
   EXPECT_FALSE([permissions canPreloadSearchResults]);
   EXPECT_EQ(TouchToSearch::DISABLED, [permissions preferenceState]);
 
   otr_state->GetPrefs()->SetString(prefs::kContextualSearchEnabled, "true");
   EXPECT_EQ(TouchToSearch::DISABLED, [permissions preferenceState]);
   EXPECT_FALSE([permissions canEnable]);
 
   EXPECT_EQ(nil, [permissions audience]);
   id audience = [OCMockObject
       niceMockForProtocol:@protocol(TouchToSearchPermissionsChangeAudience)];
   [permissions setAudience:audience];
   EXPECT_EQ(nil, [permissions audience]);
 }
 
 TEST_F(TouchToSearchPermissionsMediatorTest, AudienceRemovedNotifications) {
   @autoreleasepool {
-    base::scoped_nsobject<id> audience(
-        [[TestTouchToSearchPermissionsAudience alloc] init]);
+    id audience = [[TestTouchToSearchPermissionsAudience alloc] init];
     [tts_permissions_ setAudience:audience];
     EXPECT_TRUE([tts_permissions_ observing]);
-    audience.reset();
+    audience = nil;
   }
   // Permissions shouldn't be observing after notifying a nil audience.
   [[NSNotificationCenter defaultCenter]
       postNotificationName:UIAccessibilityVoiceOverStatusChanged
                     object:nil];
   EXPECT_FALSE([tts_permissions_ observing]);
 
   // Permissions shouldn't observe while still observing.
-  base::scoped_nsobject<id> audience(
-      [[TestTouchToSearchPermissionsAudience alloc] init]);
+  id audience = [[TestTouchToSearchPermissionsAudience alloc] init];
   [tts_permissions_ setAudience:audience];
-  audience.reset();
-  audience.reset([[TestTouchToSearchPermissionsAudience alloc] init]);
+  audience = nil;
+  audience = [[TestTouchToSearchPermissionsAudience alloc] init];
   [tts_permissions_ setAudience:audience];
 }
 
 #pragma mark - Unit tests for availability class method.
 
 TEST(TouchToSearchPermissionsAvailabilityTest, CommandLinePermissions) {
   const struct {
     bool set_disable;
     bool set_enable;
     bool expect_available;
@@ skipping 46 matching lines @@
     }
     EXPECT_EQ(
         [TouchToSearchPermissionsMediator isTouchToSearchAvailableOnDevice],
         test.expect_available);
   }
 }
 
 #pragma mark - Unit tests for mock class
 
 TEST(MockTouchToSearchPermissionsTest, Mocking) {
-  base::scoped_nsobject<MockTouchToSearchPermissionsMediator>
-      scoped_permissions([[MockTouchToSearchPermissionsMediator alloc]
-          initWithBrowserState:nullptr]);
+  MockTouchToSearchPermissionsMediator* scoped_permissions =
+      [[MockTouchToSearchPermissionsMediator alloc]
+          initWithBrowserState:nullptr];
   MockTouchToSearchPermissionsMediator* permissions = scoped_permissions;
 
   const GURL test_urls[] = {
       GURL("https://www.some-website.com/"),
       GURL("http://www.some-website.com/"), GURL(""),
   };
 
   // Default expectations from mocked methods.
   EXPECT_TRUE([[permissions class] isTouchToSearchAvailableOnDevice]);
   EXPECT_TRUE([permissions canSendPageURLs]);
@@ skipping 25 matching lines @@
       TouchToSearch::DISABLED, TouchToSearch::UNDECIDED, TouchToSearch::ENABLED,
   };
 
   for (const auto& state : states) {
     permissions.preferenceState = state;
     EXPECT_EQ(state, permissions.preferenceState);
   }
 }
 
 }  // namespace