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

ios/chrome/browser/tabs/tab_model_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 <objc/runtime.h>
 
 #include "base/files/file_path.h"
-#include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "ios/chrome/browser/browser_state/test_chrome_browser_state.h"
 #include "ios/chrome/browser/browser_state/test_chrome_browser_state_manager.h"
 #include "ios/chrome/browser/chrome_url_constants.h"
 #include "ios/chrome/browser/infobars/infobar_manager_impl.h"
 #include "ios/chrome/browser/sessions/ios_chrome_session_tab_helper.h"
 #import "ios/chrome/browser/sessions/session_ios.h"
 #import "ios/chrome/browser/sessions/session_window_ios.h"
@@ skipping 17 matching lines @@
 #include "ios/web/public/test/test_web_thread_bundle.h"
 #include "ios/web/public/web_thread.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #import "ios/web/web_state/web_state_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "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
+
 // Defines a TabModelObserver for use in unittests.  This class can be used to
 // test if an observer method was called or not.
 @interface TabModelObserverPong : NSObject<TabModelObserver> {
   // TODO(crbug.com/661989): Add tests for the other observer methods.
   BOOL tabMovedWasCalled_;
 }
 @property(nonatomic, assign) BOOL tabMovedWasCalled;
 @end
 
 @implementation TabModelObserverPong
@@ skipping 17 matching lines @@
  public:
   TabModelTest()
       : scoped_browser_state_manager_(
             base::MakeUnique<TestChromeBrowserStateManager>(base::FilePath())),
         web_client_(base::MakeUnique<ChromeWebClient>()) {
     DCHECK_CURRENTLY_ON(web::WebThread::UI);
 
     TestChromeBrowserState::Builder test_cbs_builder;
     chrome_browser_state_ = test_cbs_builder.Build();
 
-    session_window_.reset([[SessionWindowIOS alloc] init]);
+    session_window_ = [[SessionWindowIOS alloc] init];
 
     // Create tab model with just a dummy session service so the async state
     // saving doesn't trigger unless actually wanted.
-    SetTabModel(
-        CreateTabModel([[[TestSessionService alloc] init] autorelease], nil));
+    SetTabModel(CreateTabModel([[TestSessionService alloc] init], nil));
   }
 
-  ~TabModelTest() override {
-    [tab_model_ browserStateDestroyed];
+  ~TabModelTest() override = default;
+
+  void TearDown() override {
+    SetTabModel(nil);
+    PlatformTest::TearDown();
   }
 
-  void SetTabModel(base::scoped_nsobject<TabModel> tab_model) {
+  void SetTabModel(TabModel* tab_model) {
     if (tab_model_) {
       @autoreleasepool {
         [tab_model_ browserStateDestroyed];
-        tab_model_.reset();
+        tab_model_ = nil;
       }
     }
 
     tab_model_ = tab_model;
   }
 
-  base::scoped_nsobject<TabModel> CreateTabModel(
-      SessionServiceIOS* session_service,
-      SessionWindowIOS* session_window) {
-    base::scoped_nsobject<TabModel> tab_model([[TabModel alloc]
+  TabModel* CreateTabModel(SessionServiceIOS* session_service,
+                           SessionWindowIOS* session_window) {
+    TabModel* tab_model([[TabModel alloc]
         initWithSessionWindow:session_window
                sessionService:session_service
                  browserState:chrome_browser_state_.get()]);
     [tab_model setWebUsageEnabled:NO];
     [tab_model setPrimary:YES];
     return tab_model;
   }
 
  protected:
   // Creates a session window with entries named "restored window 1",
   // "restored window 2" and "restored window 3" and the second entry
   // marked as selected.
-  base::scoped_nsobject<SessionWindowIOS> CreateSessionWindow() {
+  SessionWindowIOS* CreateSessionWindow() {
     NSMutableArray<CRWSessionStorage*>* sessions = [NSMutableArray array];
     for (int i = 0; i < 3; i++) {
-      CRWSessionStorage* session_storage =
-          [[[CRWSessionStorage alloc] init] autorelease];
+      CRWSessionStorage* session_storage = [[CRWSessionStorage alloc] init];
       [sessions addObject:session_storage];
     }
     return base::scoped_nsobject<SessionWindowIOS>(
         [[SessionWindowIOS alloc] initWithSessions:sessions selectedIndex:1]);
   }
 
   web::TestWebThreadBundle thread_bundle_;
   IOSChromeScopedTestingChromeBrowserStateManager scoped_browser_state_manager_;
   web::ScopedTestingWebClient web_client_;
-  base::scoped_nsobject<SessionWindowIOS> session_window_;
+  SessionWindowIOS* session_window_;
   std::unique_ptr<TestChromeBrowserState> chrome_browser_state_;
-  base::mac::ScopedNSAutoreleasePool pool_;
-  base::scoped_nsobject<TabModel> tab_model_;
+  TabModel* tab_model_;
 };
 
 TEST_F(TabModelTest, IsEmpty) {
   EXPECT_EQ([tab_model_ count], 0U);
   EXPECT_TRUE([tab_model_ isEmpty]);
   [tab_model_ insertTabWithURL:GURL(kURL1)
                       referrer:web::Referrer()
                     transition:ui::PAGE_TRANSITION_TYPED
                         opener:nil
                    openedByDOM:NO
@@ skipping 191 matching lines @@
 
 TEST_F(TabModelTest, RestoreSessionOnNTPTest) {
   Tab* tab = [tab_model_ insertTabWithURL:GURL(kChromeUINewTabURL)
                                  referrer:web::Referrer()
                                transition:ui::PAGE_TRANSITION_TYPED
                                    opener:nil
                               openedByDOM:NO
                                   atIndex:0
                              inBackground:NO];
 
-  base::scoped_nsobject<SessionWindowIOS> window(CreateSessionWindow());
-  [tab_model_ restoreSessionWindow:window.get()];
+  SessionWindowIOS* window(CreateSessionWindow());
+  [tab_model_ restoreSessionWindow:window];
 
   ASSERT_EQ(3U, [tab_model_ count]);
   EXPECT_NSEQ([tab_model_ tabAtIndex:1], [tab_model_ currentTab]);
   EXPECT_NSNE(tab, [tab_model_ tabAtIndex:0]);
   EXPECT_NSNE(tab, [tab_model_ tabAtIndex:1]);
   EXPECT_NSNE(tab, [tab_model_ tabAtIndex:2]);
 }
 
 TEST_F(TabModelTest, RestoreSessionOn2NtpTest) {
   Tab* tab0 = [tab_model_ insertTabWithURL:GURL(kChromeUINewTabURL)
                                   referrer:web::Referrer()
                                 transition:ui::PAGE_TRANSITION_TYPED
                                     opener:nil
                                openedByDOM:NO
                                    atIndex:0
                               inBackground:NO];
   Tab* tab1 = [tab_model_ insertTabWithURL:GURL(kChromeUINewTabURL)
                                   referrer:web::Referrer()
                                 transition:ui::PAGE_TRANSITION_TYPED
                                     opener:nil
                                openedByDOM:NO
                                    atIndex:1
                               inBackground:NO];
 
-  base::scoped_nsobject<SessionWindowIOS> window(CreateSessionWindow());
-  [tab_model_ restoreSessionWindow:window.get()];
+  SessionWindowIOS* window(CreateSessionWindow());
+  [tab_model_ restoreSessionWindow:window];
 
   ASSERT_EQ(5U, [tab_model_ count]);
   EXPECT_NSEQ([tab_model_ tabAtIndex:3], [tab_model_ currentTab]);
   EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:0]);
   EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:1]);
   EXPECT_NSNE(tab0, [tab_model_ tabAtIndex:2]);
   EXPECT_NSNE(tab0, [tab_model_ tabAtIndex:3]);
   EXPECT_NSNE(tab0, [tab_model_ tabAtIndex:4]);
   EXPECT_NSNE(tab1, [tab_model_ tabAtIndex:2]);
   EXPECT_NSNE(tab1, [tab_model_ tabAtIndex:3]);
   EXPECT_NSNE(tab1, [tab_model_ tabAtIndex:4]);
 }
 
 TEST_F(TabModelTest, RestoreSessionOnAnyTest) {
   Tab* tab = [tab_model_ insertTabWithURL:GURL(kURL1)
                                  referrer:web::Referrer()
                                transition:ui::PAGE_TRANSITION_TYPED
                                    opener:nil
                               openedByDOM:NO
                                   atIndex:0
                              inBackground:NO];
 
-  base::scoped_nsobject<SessionWindowIOS> window(CreateSessionWindow());
-  [tab_model_ restoreSessionWindow:window.get()];
+  SessionWindowIOS* window(CreateSessionWindow());
+  [tab_model_ restoreSessionWindow:window];
 
   ASSERT_EQ(4U, [tab_model_ count]);
   EXPECT_NSEQ([tab_model_ tabAtIndex:2], [tab_model_ currentTab]);
   EXPECT_NSEQ(tab, [tab_model_ tabAtIndex:0]);
   EXPECT_NSNE(tab, [tab_model_ tabAtIndex:1]);
   EXPECT_NSNE(tab, [tab_model_ tabAtIndex:2]);
   EXPECT_NSNE(tab, [tab_model_ tabAtIndex:3]);
 }
 
 TEST_F(TabModelTest, CloseAllTabs) {
@@ skipping 605 matching lines @@
                                    atIndex:[tab_model_ count]
                               inBackground:NO];
 
   // Basic sanity checks before moving on.
   ASSERT_EQ(3U, [tab_model_ count]);
   ASSERT_NSEQ(tab0, [tab_model_ tabAtIndex:0]);
   ASSERT_NSEQ(tab1, [tab_model_ tabAtIndex:1]);
   ASSERT_NSEQ(tab2, [tab_model_ tabAtIndex:2]);
 
   // Check that observer methods are called.
-  base::scoped_nsobject<TabModelObserverPong> tab_model_observer;
-  tab_model_observer.reset([[TabModelObserverPong alloc] init]);
-  [tab_model_ addObserver:tab_model_observer.get()];
+  TabModelObserverPong* tab_model_observer;
+  tab_model_observer = [[TabModelObserverPong alloc] init];
+  [tab_model_ addObserver:tab_model_observer];
 
   // Move a tab from index 1 to index 0 (move tab left by one).
   [tab_model_observer setTabMovedWasCalled:NO];
   [tab_model_ moveTab:[tab_model_ tabAtIndex:1] toIndex:0];
   ASSERT_EQ(3U, [tab_model_ count]);
   EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:0]);
   EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:1]);
   EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:2]);
   EXPECT_TRUE([tab_model_observer tabMovedWasCalled]);
 
@@ skipping 28 matching lines @@
   [tab_model_observer setTabMovedWasCalled:NO];
   [tab_model_ moveTab:[tab_model_ tabAtIndex:2] toIndex:2];
   ASSERT_EQ(3U, [tab_model_ count]);
   EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:0]);
   EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:1]);
   EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:2]);
   EXPECT_FALSE([tab_model_observer tabMovedWasCalled]);
 
   // TabModel asserts that there are no observer when it is deallocated,
   // so remove the observer before the end of the method.
-  [tab_model_ removeObserver:tab_model_observer.get()];
+  [tab_model_ removeObserver:tab_model_observer];
 }
 
 TEST_F(TabModelTest, ParentTabModel) {
   std::unique_ptr<web::WebState> web_state = web::WebState::Create(
       web::WebState::CreateParams(chrome_browser_state_.get()));
   AttachTabHelpers(web_state.get());
 
   Tab* tab = LegacyTabHelper::GetTabForWebState(web_state.get());
   EXPECT_NSEQ(nil, [tab parentTabModel]);
 
   [tab_model_ webStateList]->InsertWebState(0, std::move(web_state));
-  EXPECT_NSEQ(tab_model_.get(), [tab parentTabModel]);
+  EXPECT_NSEQ(tab_model_, [tab parentTabModel]);
 }
 
 TEST_F(TabModelTest, TabCreatedOnInsertion) {
   std::unique_ptr<web::WebState> web_state = web::WebState::Create(
       web::WebState::CreateParams(chrome_browser_state_.get()));
 
   EXPECT_NSEQ(nil, LegacyTabHelper::GetTabForWebState(web_state.get()));
 
   web::WebState* web_state_ptr = web_state.get();
   [tab_model_ webStateList]->InsertWebState(0, std::move(web_state));
   EXPECT_NSNE(nil, LegacyTabHelper::GetTabForWebState(web_state_ptr));
 }
 
 TEST_F(TabModelTest, PersistSelectionChange) {
   NSString* stashPath =
       base::SysUTF8ToNSString(chrome_browser_state_->GetStatePath().value());
 
   // Reset the TabModel with a custom SessionServiceIOS (to control whether
   // data is saved to disk).
-  base::scoped_nsobject<TestSessionService> test_session_service(
-      [[TestSessionService alloc] init]);
-  SetTabModel(CreateTabModel(test_session_service.get(), nil));
+  TestSessionService* test_session_service = [[TestSessionService alloc] init];
+  SetTabModel(CreateTabModel(test_session_service, nil));
 
   [tab_model_ insertTabWithURL:GURL(kURL1)
                       referrer:web::Referrer()
                     transition:ui::PAGE_TRANSITION_TYPED
                         opener:nil
                    openedByDOM:NO
                        atIndex:[tab_model_ count]
                   inBackground:NO];
   [tab_model_ insertTabWithURL:GURL(kURL1)
                       referrer:web::Referrer()
@@ skipping 26 matching lines @@
   [test_session_service setPerformIO:NO];
 
   NSString* state_path = base::SysUTF8ToNSString(
       chrome_browser_state_->GetStatePath().AsUTF8Unsafe());
   SessionIOS* session =
       [test_session_service loadSessionFromDirectory:state_path];
   ASSERT_EQ(1u, session.sessionWindows.count);
   SessionWindowIOS* session_window = session.sessionWindows[0];
 
   // Create tab model from saved session.
-  SetTabModel(CreateTabModel(test_session_service.get(), session_window));
+  SetTabModel(CreateTabModel(test_session_service, session_window));
 
   ASSERT_EQ(3u, [tab_model_ count]);
 
   EXPECT_EQ([tab_model_ tabAtIndex:1], [tab_model_ currentTab]);
   EXPECT_EQ(nil, [tab_model_ openerOfTab:[tab_model_ tabAtIndex:1]]);
   EXPECT_EQ([tab_model_ tabAtIndex:1],
             [tab_model_ openerOfTab:[tab_model_ tabAtIndex:2]]);
   EXPECT_EQ([tab_model_ tabAtIndex:2],
             [tab_model_ openerOfTab:[tab_model_ tabAtIndex:0]]);
 
   // Clean up.
   EXPECT_TRUE([[NSFileManager defaultManager] removeItemAtPath:stashPath
                                                          error:nullptr]);
 }
 
 }  // anonymous namespace