[ios] Convert //ios/chrome/browser/tabs:unit_tests to ARC.

ios/chrome/browser/tabs/tab_unittest.mm

 // Copyright 2012 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 <UIKit/UIKit.h>
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/ios/block_types.h"
-#import "base/ios/weak_nsobject.h"
-#include "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/keyed_service/core/service_access_type.h"
 #include "ios/chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "ios/chrome/browser/browser_state/test_chrome_browser_state.h"
@@ skipping 25 matching lines @@
 #include "ios/web/public/test/test_web_thread_bundle.h"
 #import "ios/web/web_state/navigation_context_impl.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #import "ios/web/web_state/web_state_impl.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 #import "third_party/ocmock/OCMock/OCMock.h"
 
-using web::WebStateImpl;
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
 
-static const char kAppSettingsUrl[] = "app-settings://";
-static const char kNewTabUrl[] = "chrome://newtab/";
-static const char kGoogleUserUrl[] = "http://google.com";
-static const char kGoogleRedirectUrl[] = "http://www.google.fr/";
+namespace {
+const char kAppSettingsUrl[] = "app-settings://";
+const char kNewTabUrl[] = "chrome://newtab/";
+const char kGoogleUserUrl[] = "http://google.com";
+const char kGoogleRedirectUrl[] = "http://www.google.fr/";
 static NSString* const kGoogleTitle = @"Google";
-static const char kOtherUserUrl[] = "http://other.com";
-static const char kOtherRedirectUrl[] = "http://other.fr/";
-static NSString* const kOtherTitle = @"Other";
+const char kOtherUserUrl[] = "http://other.com";
+const char kOtherRedirectUrl[] = "http://other.fr/";
+NSString* const kOtherTitle = @"Other";
 const char kContentDispositionWithFilename[] =
     "attachment; filename=\"suggested_filename.pdf\"";
 const char kContentDispositionWithoutFilename[] =
     "attachment; parameter=parameter_value";
 const char kInvalidFilenameUrl[] = "http://www.hostname.com/";
 const char kValidFilenameUrl[] = "http://www.hostname.com/filename.pdf";
+}  // namespace
 
 @interface ArrayTabModel : TabModel {
  @private
-  base::scoped_nsobject<NSMutableArray> tabsForTesting_;
+  NSMutableArray* _tabsForTesting;
 }
 @end
 
 @implementation ArrayTabModel
-- (id)init {
+- (instancetype)init {
   if ((self = [super init]))
-    tabsForTesting_.reset([[NSMutableArray alloc] initWithCapacity:1]);
+    _tabsForTesting = [[NSMutableArray alloc] initWithCapacity:1];
   return self;
 }
 
 - (void)addTabForTesting:(Tab*)tab {
-  [tabsForTesting_ addObject:tab];
+  [_tabsForTesting addObject:tab];
 }
 
 - (NSUInteger)indexOfTab:(Tab*)tab {
-  return [tabsForTesting_ indexOfObject:tab];
+  return [_tabsForTesting indexOfObject:tab];
 }
 
 - (NSUInteger)count {
-  return [tabsForTesting_ count];
+  return [_tabsForTesting count];
 }
 
 - (void)closeTabAtIndex:(NSUInteger)index {
-  [tabsForTesting_ removeObjectAtIndex:index];
+  [_tabsForTesting removeObjectAtIndex:index];
 }
 @end
 
 @interface ExternalAppLauncherMock : OCMockComplexTypeHelper
 @end
 
 @implementation ExternalAppLauncherMock
 typedef BOOL (^openURLBlockType)(const GURL&, BOOL);
 
 - (BOOL)openURL:(const GURL&)url linkClicked:(BOOL)linkClicked {
@@ skipping 28 matching lines @@
   history::QueryResults results_;
   base::RunLoop* run_loop_;
 };
 
 HistoryQueryResultsObserver::~HistoryQueryResultsObserver() {}
 
 class FakeChromeBrowserProvider : public ios::TestChromeBrowserProvider {
  public:
   FakeChromeBrowserProvider(id<NativeAppMetadata> metadata) {
     FakeNativeAppWhitelistManager* fakeManager =
-        [[[FakeNativeAppWhitelistManager alloc] init] autorelease];
+        [[FakeNativeAppWhitelistManager alloc] init];
     fakeManager.metadata = metadata;
-    manager_.reset([fakeManager retain]);
+    manager_.reset(fakeManager);
   }
   ~FakeChromeBrowserProvider() override {}
 
   id<NativeAppWhitelistManager> GetNativeAppWhitelistManager() const override {
     return manager_;
   }
 
  private:
   base::scoped_nsprotocol<id<NativeAppWhitelistManager>> manager_;
 };
@@ skipping 16 matching lines @@
         setCallbackSchemeForTesting:@"chromium"];
 
     // Set up the testing profiles.
     TestChromeBrowserState::Builder test_cbs_builder;
     chrome_browser_state_ = test_cbs_builder.Build();
     chrome_browser_state_->CreateBookmarkModel(false);
     bookmarks::test::WaitForBookmarkModelToLoad(
         ios::BookmarkModelFactory::GetForBrowserState(
             chrome_browser_state_.get()));
     ASSERT_TRUE(chrome_browser_state_->CreateHistoryService(true));
-    history_service_ = ios::HistoryServiceFactory::GetForBrowserState(
-        chrome_browser_state_.get(), ServiceAccessType::EXPLICIT_ACCESS);
 
     ios::ChromeBrowserState* browser_state = chrome_browser_state_.get();
     if (UseOffTheRecordBrowserState())
       browser_state = browser_state->GetOffTheRecordChromeBrowserState();
 
     mock_web_controller_ =
         [OCMockObject niceMockForClass:[CRWWebController class]];
     web::WebState::CreateParams create_params(browser_state);
-    web_state_impl_ = base::MakeUnique<WebStateImpl>(create_params);
+    web_state_impl_ = base::MakeUnique<web::WebStateImpl>(create_params);
     web_state_impl_->SetWebController(mock_web_controller_);
     web_state_impl_->GetNavigationManagerImpl().InitializeSession();
     web::WebStateImpl* web_state_impl = web_state_impl_.get();
     [[[static_cast<OCMockObject*>(mock_web_controller_) stub]
         andReturnValue:OCMOCK_VALUE(web_state_impl)] webStateImpl];
-    web_controller_view_.reset([[UIView alloc] init]);
+    web_controller_view_ = [[UIView alloc] init];
     [[[static_cast<OCMockObject*>(mock_web_controller_) stub]
-        andReturn:web_controller_view_.get()] view];
+        andReturn:web_controller_view_] view];
     LegacyTabHelper::CreateForWebState(web_state_impl_.get());
-    tab_.reset(LegacyTabHelper::GetTabForWebState(web_state_impl_.get()));
+    tab_ = LegacyTabHelper::GetTabForWebState(web_state_impl_.get());
     web::NavigationManager::WebLoadParams load_params(
         GURL("chrome://version/"));
     [tab_ navigationManager]->LoadURLWithParams(load_params);
 
     // There should be no entries in the history at this point.
     history::QueryResults results;
     QueryAllHistory(&results);
     EXPECT_EQ(0UL, results.size());
-    mock_external_app_launcher_.reset([[ExternalAppLauncherMock alloc]
+    mock_external_app_launcher_ = [[ExternalAppLauncherMock alloc]
         initWithRepresentedObject:
-            [OCMockObject mockForClass:[ExternalAppLauncher class]]]);
+            [OCMockObject mockForClass:[ExternalAppLauncher class]]];
     [tab_ replaceExternalAppLauncher:mock_external_app_launcher_];
   }
 
   void TearDown() override {
     // Ensure that the Tab is destroyed before the autorelease pool is cleared.
     web_state_impl_.reset();
     BlockCleanupTest::TearDown();
   }
 
   void BrowseTo(const GURL& userUrl, const GURL& redirectUrl, NSString* title) {
-    DCHECK_EQ(tab_.get().webState, web_state_impl_.get());
+    DCHECK_EQ(tab_.webState, web_state_impl_.get());
 
     [tab_ webWillAddPendingURL:userUrl transition:ui::PAGE_TRANSITION_TYPED];
     std::unique_ptr<web::NavigationContext> context1 =
         web::NavigationContextImpl::CreateNavigationContext(
             web_state_impl_.get(), userUrl);
     web_state_impl_->OnNavigationStarted(context1.get());
     [tab_ webWillAddPendingURL:redirectUrl
                     transition:ui::PAGE_TRANSITION_CLIENT_REDIRECT];
 
     web::Referrer empty_referrer;
@@ skipping 13 matching lines @@
     base::string16 new_title = base::SysNSStringToUTF16(title);
     [tab_ navigationManager]->GetLastCommittedItem()->SetTitle(new_title);
 
     web_state_impl_->OnTitleChanged();
     [[[(id)mock_web_controller_ expect]
         andReturnValue:OCMOCK_VALUE(kPageLoaded)] loadPhase];
     web_state_impl_->OnPageLoaded(redirectUrl, true);
   }
 
   void BrowseToNewTab() {
-    DCHECK_EQ(tab_.get().webState, web_state_impl_.get());
+    DCHECK_EQ(tab_.webState, web_state_impl_.get());
     const GURL url(kNewTabUrl);
     // TODO(crbug.com/661992): This will not work with a mock CRWWebController.
     // The only test that uses it is currently disabled.
     web::NavigationManager::WebLoadParams params(url);
     params.transition_type = ui::PAGE_TRANSITION_TYPED;
     [tab_ navigationManager]->LoadURLWithParams(params);
     [[[(id)mock_web_controller_ expect]
         andReturnValue:OCMOCK_VALUE(kPageLoading)] loadPhase];
     [[[(id)mock_web_controller_ expect]
         andReturnValue:OCMOCK_VALUE(kPageLoaded)] loadPhase];
     web_state_impl_->OnPageLoaded(url, true);
     web_state_impl_->OnTitleChanged();
   }
 
   void QueryAllHistory(history::QueryResults* results) {
     base::CancelableTaskTracker tracker;
     base::RunLoop run_loop;
     scoped_refptr<HistoryQueryResultsObserver> observer(
         new HistoryQueryResultsObserver(&run_loop));
-    history_service_->QueryHistory(
+    history::HistoryService* history_service =
+        ios::HistoryServiceFactory::GetForBrowserState(
+            chrome_browser_state_.get(), ServiceAccessType::EXPLICIT_ACCESS);
+    history_service->QueryHistory(
         base::string16(), history::QueryOptions(),
         base::Bind(&HistoryQueryResultsObserver::ProcessResults, observer),
         &tracker);
     run_loop.Run();
     results->Swap(observer->results());
   }
 
   void CheckHistoryResult(const history::URLResult& historyResult,
                           const GURL& expectedUrl,
                           NSString* expectedTitle) {
@@ skipping 25 matching lines @@
   }
 #endif
 
   virtual bool UseOffTheRecordBrowserState() const { return false; }
 
  protected:
   web::TestWebThreadBundle thread_bundle_;
   IOSChromeScopedTestingChromeBrowserStateManager scoped_browser_state_manager_;
   std::unique_ptr<TestChromeBrowserState> chrome_browser_state_;
   std::unique_ptr<web::WebStateImpl> web_state_impl_;
-  history::HistoryService* history_service_;  // weak
-  CRWWebController* mock_web_controller_;     // weak
-  base::scoped_nsobject<UIView> web_controller_view_;
-  base::scoped_nsobject<ArrayTabModel> tabModel_;
-  base::scoped_nsobject<id> mock_external_app_launcher_;
-  base::WeakNSObject<Tab> tab_;
+  __weak CRWWebController* mock_web_controller_;
+  UIView* web_controller_view_;
+  ArrayTabModel* tabModel_;
+  id mock_external_app_launcher_;
+  __weak Tab* tab_;
 };
 
 TEST_F(TabTest, AddToHistoryWithRedirect) {
   BrowseTo(GURL(kGoogleUserUrl), GURL(kGoogleRedirectUrl), kGoogleTitle);
   history::QueryResults results;
   QueryAllHistory(&results);
   EXPECT_EQ(1U, results.size());
   CheckHistoryResult(results[0], GURL(kGoogleRedirectUrl), kGoogleTitle);
   CheckCurrentItem(results[0]);
 }
@@ skipping 144 matching lines @@
 TEST_F(TabOpenAppTest, testURL) {
   // TODO(crbug/711511): Remove this test when Native App Launcher has been
   // fully deprecated.
   if (!experimental_flags::IsNativeAppLauncherEnabled())
     return;
 
   EXPECT_FALSE([tab_ browserState]->IsOffTheRecord());
 
   GURL testURL("http://www.youtube.com/");
   // Fake metadata object to enable and disable autoopenlinks for testURL.
-  base::scoped_nsobject<FakeNativeAppMetadata> metadata(
-      [[FakeNativeAppMetadata alloc] init]);
+  FakeNativeAppMetadata* metadata = [[FakeNativeAppMetadata alloc] init];
   IOSChromeScopedTestingChromeBrowserProvider provider(
       base::MakeUnique<FakeChromeBrowserProvider>(metadata));
   // Turn auto open on.
   int expectedCallCount = 1;
   [metadata setShouldAutoOpenLinks:YES];
   TestOpenNativeAppURL(testURL, YES, expectedCallCount, YES);
   TestOpenNativeAppURL(testURL, NO, expectedCallCount, NO);
 
   // Turn auto open off.
   expectedCallCount = 0;
   [metadata setShouldAutoOpenLinks:NO];
   TestOpenNativeAppURL(testURL, NO, expectedCallCount, NO);
 }
 
 // TODO(crbug.com/330189): This test fails if Google Maps is installed (usually
 // on device).
 TEST_F(TabOpenAppTest, DISABLED_testResetShouldAutoOpenOnFailure) {
   // TODO(crbug/711511): Remove this test when Native App Launcher has been
   // fully deprecated.
   if (!experimental_flags::IsNativeAppLauncherEnabled())
     return;
 
   EXPECT_FALSE([tab_ browserState]->IsOffTheRecord());
 
   // With a regular profile.
   GURL testURL("http://maps.google.com/");
   // Fake metadata object
-  base::scoped_nsobject<FakeNativeAppMetadata> metadata(
-      [[FakeNativeAppMetadata alloc] init]);
+  FakeNativeAppMetadata* metadata = [[FakeNativeAppMetadata alloc] init];
 
   // Turn auto open on.
   [metadata setShouldAutoOpenLinks:YES];
   int expectedCallCount = 2;
   TestOpenNativeAppURL(testURL, NO, expectedCallCount, NO);
   EXPECT_FALSE([metadata shouldAutoOpenLinks]);
 }
 
 // Tests the opening of matching native apps with off-the-record browser state.
 TEST_F(TabOpenAppOffTheRecordTest, testDummyURL) {
@@ skipping 12 matching lines @@
   // TODO(crbug/711511): Remove this test when Native App Launcher has been
   // fully deprecated.
   if (!experimental_flags::IsNativeAppLauncherEnabled())
     return;
 
   EXPECT_TRUE([tab_ browserState]->IsOffTheRecord());
 
   // With a regular chrome browser state.
   GURL testURL("http://www.youtube.com/");
   // Mock metadata object to enable and disable autoopenlinks for testURL.
-  base::scoped_nsobject<FakeNativeAppMetadata> metadata(
-      [[FakeNativeAppMetadata alloc] init]);
+  FakeNativeAppMetadata* metadata = [[FakeNativeAppMetadata alloc] init];
   IOSChromeScopedTestingChromeBrowserProvider provider(
       base::MakeUnique<FakeChromeBrowserProvider>(metadata));
 
   // Turn auto open on.
   [metadata setShouldAutoOpenLinks:YES];
   TestOpenNativeAppURL(testURL, NO, 0, NO);
 
   // Turn auto open off.
   [metadata setShouldAutoOpenLinks:NO];
   TestOpenNativeAppURL(testURL, NO, 0, NO);
 }
 
 // TODO(crbug.com/330189): This test fails if Google Maps is installed (usually
 // on device).
 TEST_F(TabOpenAppOffTheRecordTest, DISABLED_testResetShouldAutoOpenOnFailure) {
   // TODO(crbug/711511): Remove this test when Native App Launcher has been
   // fully deprecated.
   if (!experimental_flags::IsNativeAppLauncherEnabled())
     return;
 
   EXPECT_TRUE([tab_ browserState]->IsOffTheRecord());
 
   // With a regular profile.
   GURL testURL("http://maps.google.com/");
   // Fake metadata object.
-  base::scoped_nsobject<FakeNativeAppMetadata> metadata(
-      [[FakeNativeAppMetadata alloc] init]);
+  FakeNativeAppMetadata* metadata = [[FakeNativeAppMetadata alloc] init];
 
   // Turn auto open on.
   [metadata setShouldAutoOpenLinks:YES];
   int expectedCallCount = 2;
   TestOpenNativeAppURL(testURL, NO, expectedCallCount, NO);
   EXPECT_FALSE([metadata shouldAutoOpenLinks]);
 }
 
 }  // namespace