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

ios/chrome/browser/ui/tab_switcher/tab_switcher_model_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.
 
 #include "ios/chrome/browser/ui/tab_switcher/tab_switcher_model.h"
 
-#include "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ios/chrome/browser/browser_state/test_chrome_browser_state.h"
 #include "ios/chrome/browser/ui/ntp/recent_tabs/synced_sessions.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_model_private.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_utils.h"
 #include "testing/platform_test.h"
 #import "third_party/ocmock/OCMock/OCMock.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 
 // A lightweight DistantTab.
 class LightDT {
  public:
   LightDT(std::string const& urlSuffix, std::string const& title = "")
       : url("http://www.foo.com/" + urlSuffix), title(title) {}
   std::string url;
   std::string title;
 };
 
 // A lightweight DistantSession.
 struct LightDS {
   std::string tag;
   std::vector<LightDT> distantTabs;
 };
 
 // A lightweight SyncedSessions.
 using LightSS = std::vector<LightDS>;
 
 }  // namespace
 
 // Helper class to test calls to the TabSwitcherModelDelegate.
 @interface DelegateTester : NSObject<TabSwitcherModelDelegate>
 @end
 
 @implementation DelegateTester {
-  base::scoped_nsobject<NSArray> _expectedSessionRemoved;
-  base::scoped_nsobject<NSArray> _expectedSessionInserted;
+  NSArray* _expectedSessionRemoved;
+  NSArray* _expectedSessionInserted;
   std::set<std::string> _expectedTagsOfTheSessionsNeedingUpdates;
 }
 
 - (void)expectSessionsRemoved:(NSArray*)expectedIndexes {
-  _expectedSessionRemoved.reset([expectedIndexes retain]);
+  _expectedSessionRemoved = expectedIndexes;
 }
 
 - (void)expectSessionsInserted:(NSArray*)expectedIndexes {
-  _expectedSessionInserted.reset([expectedIndexes retain]);
+  _expectedSessionInserted = expectedIndexes;
 }
 
 - (void)expectSessionMayNeedUpdate:(std::set<std::string> const&)tags {
   _expectedTagsOfTheSessionsNeedingUpdates = tags;
 }
 
 - (void)verify {
   EXPECT_EQ(0UL, [_expectedSessionRemoved count]);
   EXPECT_EQ(0UL, [_expectedSessionInserted count]);
   EXPECT_EQ(0UL, _expectedTagsOfTheSessionsNeedingUpdates.size());
 }
 
 #pragma mark - TabSwitcherModelDelegate
 
 - (void)distantSessionsRemovedAtSortedIndexes:(NSArray*)removedIndexes
                       insertedAtSortedIndexes:(NSArray*)insertedIndexes {
-  EXPECT_TRUE(removedIndexes == _expectedSessionRemoved.get() ||
-              [removedIndexes isEqualToArray:_expectedSessionRemoved.get()]);
-  EXPECT_TRUE(insertedIndexes == _expectedSessionInserted.get() ||
-              [insertedIndexes isEqualToArray:_expectedSessionInserted.get()]);
-  _expectedSessionRemoved.reset();
-  _expectedSessionInserted.reset();
+  EXPECT_TRUE(removedIndexes == _expectedSessionRemoved ||
+              [removedIndexes isEqualToArray:_expectedSessionRemoved]);
+  EXPECT_TRUE(insertedIndexes == _expectedSessionInserted ||
+              [insertedIndexes isEqualToArray:_expectedSessionInserted]);
+  _expectedSessionRemoved = nil;
+  _expectedSessionInserted = nil;
 }
 
 - (void)distantSessionMayNeedUpdate:(std::string const&)tag {
   EXPECT_EQ(1UL, _expectedTagsOfTheSessionsNeedingUpdates.erase(tag));
 }
 
 - (void)localSessionMayNeedUpdate:(TabSwitcherSessionType)type {
   NOTREACHED();
 }
 
 - (void)signInPanelChangedTo:(TabSwitcherSignInPanelsType)panelType {
   NOTREACHED();
 }
 - (CGSize)sizeForItemAtIndex:(NSUInteger)index
                    inSession:(TabSwitcherSessionType)session {
   return CGSizeZero;
 }
 @end
 
 namespace {
 
 class TabSwitcherModelTest : public PlatformTest {
  protected:
-  void SetUp() override { delegate_.reset([[DelegateTester alloc] init]); }
+  void SetUp() override { delegate_ = [[DelegateTester alloc] init]; }
 
   void AddSessionToSessions(synced_sessions::SyncedSessions& sessions,
                             std::string const& session_tag,
                             std::vector<size_t> const& tab_ids) {
     std::vector<LightDT> light_distant_tabs;
     for (size_t tab_id : tab_ids) {
       light_distant_tabs.push_back(LightDT(std::to_string(tab_id), ""));
     }
     AddDetailedSessionToSessions(sessions, session_tag, light_distant_tabs);
   }
@@ skipping 19 matching lines @@
 
     for (auto const& light_distant_tab : light_distant_tabs) {
       auto temp_tab = base::MakeUnique<synced_sessions::DistantTab>();
       temp_tab->virtual_url = GURL(light_distant_tab.url);
       temp_tab->title = base::ASCIIToUTF16(light_distant_tab.title);
       distant_session->tabs.push_back(std::move(temp_tab));
     }
 
     sessions.AddDistantSessionForTest(std::move(distant_session));
   }
-  base::scoped_nsobject<DelegateTester> delegate_;
-  base::scoped_nsobject<TabSwitcherModel> model_;
+  DelegateTester* delegate_;
+  TabSwitcherModel* model_;
 };
 
 TEST_F(TabSwitcherModelTest, TestNoDiffs) {
   // Test with 2 empty sessions.
   synced_sessions::SyncedSessions old_sessions_1;
   synced_sessions::SyncedSessions new_sessions_1;
   [TabSwitcherModel notifyDelegate:delegate_
                    aboutChangeFrom:old_sessions_1
                                 to:new_sessions_1];
   [delegate_ verify];
@@ skipping 265 matching lines @@
   [delegate_ expectSessionsRemoved:@[ @1 ]];
   [delegate_ expectSessionsInserted:@[ @0 ]];
 
   [TabSwitcherModel notifyDelegate:delegate_
                    aboutChangeFrom:*old_sessions
                                 to:*new_sessions];
   [delegate_ verify];
 }
 
 }  // namespace