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

ios/chrome/browser/ui/settings/settings_egtest.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 <EarlGrey/EarlGrey.h>
 #import <UIKit/UIKit.h>
 #import <XCTest/XCTest.h>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 33 matching lines @@
 #import "ios/web/public/test/web_view_interaction_test_util.h"
 #import "ios/web/public/web_state/web_state.h"
 #include "ios/web/public/web_thread.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/channel_id_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using chrome_test_util::ButtonWithAccessibilityLabelId;
 using chrome_test_util::NavigationBarDoneButton;
 
 namespace {
 
 const char kTestOrigin1[] = "http://host1:1/";
 
 const char kUrl[] = "http://foo/browsing";
 const char kUrlWithSetCookie[] = "http://foo/set_cookie";
 const char kResponse[] = "bar";
@@ skipping 117 matching lines @@
 }
 
 // Set certificate for host |kTestOrigin1| for testing.
 void SetCertificate() {
   ios::ChromeBrowserState* browserState =
       chrome_test_util::GetOriginalBrowserState();
   dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
   scoped_refptr<net::URLRequestContextGetter> getter =
       browserState->GetRequestContext();
   web::WebThread::PostTask(
-      web::WebThread::IO, FROM_HERE, base::BindBlock(^{
+      web::WebThread::IO, FROM_HERE, base::BindBlockArc(^{
         net::ChannelIDService* channel_id_service =
             getter->GetURLRequestContext()->channel_id_service();
         net::ChannelIDStore* channel_id_store =
             channel_id_service->GetChannelIDStore();
         base::Time now = base::Time::Now();
         channel_id_store->SetChannelID(
             base::MakeUnique<net::ChannelIDStore::ChannelID>(
                 kTestOrigin1, now, crypto::ECPrivateKey::Create()));
       }));
 
   // The ChannelIDStore may not be loaded, so adding the new cert may not happen
   // immediately.  This posted task signals the semaphore if the cert was added,
   // or re-posts itself to check again later otherwise.
   web::WebThread::PostTask(web::WebThread::IO, FROM_HERE,
                            base::Bind(&CheckCertificate, getter, semaphore));
 
   dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
-  dispatch_release(semaphore);
 }
 
 // Fetching channel id is expected to complete immediately in this test, so a
 // dummy callback function is set for testing.
 void CertCallback(int err,
                   const std::string& server_identifier,
                   std::unique_ptr<crypto::ECPrivateKey> key) {}
 
 // Check if certificate is empty for host |kTestOrigin1|.
 bool IsCertificateCleared() {
   ios::ChromeBrowserState* browserState =
       chrome_test_util::GetOriginalBrowserState();
   __block int result;
   dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
   scoped_refptr<net::URLRequestContextGetter> getter =
       browserState->GetRequestContext();
   web::WebThread::PostTask(
-      web::WebThread::IO, FROM_HERE, base::BindBlock(^{
+      web::WebThread::IO, FROM_HERE, base::BindBlockArc(^{
         net::ChannelIDService* channel_id_service =
             getter->GetURLRequestContext()->channel_id_service();
         std::unique_ptr<crypto::ECPrivateKey> dummy_key;
         result = channel_id_service->GetChannelIDStore()->GetChannelID(
             kTestOrigin1, &dummy_key, base::Bind(CertCallback));
         dispatch_semaphore_signal(semaphore);
       }));
   dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
-  dispatch_release(semaphore);
   return result == net::ERR_FILE_NOT_FOUND;
 }
 
 }  // namespace
 
 // Settings tests for Chrome.
 @interface SettingsTestCase : ChromeTestCase
 @end
 
 @implementation SettingsTestCase
@@ skipping 418 matching lines @@
                                           kResponse)]
       assertWithMatcher:grey_notNil()];
 
   cookies = [ChromeEarlGrey cookies];
   GREYAssertEqualObjects(kCookieValue, cookies[kCookieName],
                          @"Failed to set cookie.");
   GREYAssertEqual(1U, cookies.count, @"Only one cookie should be found.");
 
   // Restore the Clear Browsing Data checkmarks prefs to their default state
   // in Teardown.
+  __weak SettingsTestCase* weakSelf = self;
   [self setTearDownHandler:^{
-    [self restoreClearBrowsingDataCheckmarksToDefault];
+    [weakSelf restoreClearBrowsingDataCheckmarksToDefault];
   }];
 
   // Clear all cookies.
   [self clearCookiesAndSiteData];
 
   // Reload and test that there are no cookies left.
   [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kUrl)];
   [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kResponse)]
       assertWithMatcher:grey_notNil()];
 
   cookies = [ChromeEarlGrey cookies];
   GREYAssertEqual(0U, cookies.count, @"No cookie should be found.");
 
   chrome_test_util::CloseAllTabs();
 }
 
 // Verifies that logging into a form on a web page allows the user to save and
 // then clear a password.
 - (void)testClearPasswords {
   ios::ChromeBrowserState* browserState =
       chrome_test_util::GetOriginalBrowserState();
   PrefService* preferences = browserState->GetPrefs();
   bool defaultPasswordManagerSavingPref = preferences->GetBoolean(
       password_manager::prefs::kPasswordManagerSavingEnabled);
 
   [self enablePasswordManagement];
+  __weak SettingsTestCase* weakSelf = self;
   [self setTearDownHandler:^{
-    [self passwordsTearDown:defaultPasswordManagerSavingPref];
+    [weakSelf passwordsTearDown:defaultPasswordManagerSavingPref];
   }];
 
   // Clear passwords and check that none are saved.
   [self clearPasswords];
   [self checkIfPasswordsSaved:NO];
 
   // Login to page and click to save password and check that its saved.
   [self loadFormAndLogin];
   [self checkIfPasswordsSaved:YES];
 }
@@ skipping 33 matching lines @@
   chrome_test_util::SetFirstLaunchStateTo(YES);
   [self assertsMetricsPrefsForService:kBreakpadFirstLaunch];
 }
 
 // Set a server bound certificate, clears the site data through the UI and
 // checks that the certificate is deleted.
 - (void)testClearCertificates {
   SetCertificate();
   // Restore the Clear Browsing Data checkmarks prefs to their default state in
   // Teardown.
+  __weak SettingsTestCase* weakSelf = self;
   [self setTearDownHandler:^{
-    [self restoreClearBrowsingDataCheckmarksToDefault];
+    [weakSelf restoreClearBrowsingDataCheckmarksToDefault];
   }];
   GREYAssertFalse(IsCertificateCleared(), @"Failed to set certificate.");
   [self clearCookiesAndSiteData];
   GREYAssertTrue(IsCertificateCleared(),
                  @"Certificate is expected to be deleted.");
 }
 
 // Verifies that Settings opens when signed-out and in Incognito mode.
 // This tests that crbug.com/607335 has not regressed.
 - (void)testSettingsSignedOutIncognito {
@@ skipping 171 matching lines @@
   [self clearPasswords];
   [self checkIfPasswordsSaved:NO];
 
   ios::ChromeBrowserState* browserState =
       chrome_test_util::GetOriginalBrowserState();
   PrefService* preferences = browserState->GetPrefs();
   bool defaultPasswordManagerSavingPref = preferences->GetBoolean(
       password_manager::prefs::kPasswordManagerSavingEnabled);
 
   [self enablePasswordManagement];
+  __weak SettingsTestCase* weakSelf = self;
   [self setTearDownHandler:^{
-    [self passwordsTearDown:defaultPasswordManagerSavingPref];
+    [weakSelf passwordsTearDown:defaultPasswordManagerSavingPref];
   }];
 
   [self loadFormAndLogin];
   [self openPasswordSettings];
 
   // Switch on edit mode.
   [[EarlGrey selectElementWithMatcher:ButtonWithAccessibilityLabelId(
                                           IDS_IOS_NAVIGATION_BAR_EDIT_BUTTON)]
       performAction:grey_tap()];
   chrome_test_util::VerifyAccessibilityForCurrentScreen();
@@ skipping 61 matching lines @@
       performAction:grey_tap()];
   [[EarlGrey selectElementWithMatcher:PrivacyButton()]
       performAction:grey_tap()];
   [[EarlGrey selectElementWithMatcher:SendUsageDataButton()]
       performAction:grey_tap()];
   chrome_test_util::VerifyAccessibilityForCurrentScreen();
   [self closeSubSettingsMenu];
 }
 
 @end