[ObjC ARC] Converts ios/chrome/browser/ui/stack_view:perf_tests to ARC.

ios/chrome/browser/ui/stack_view/stack_view_controller_perftest.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 "base/callback_helpers.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/strings/sys_string_conversions.h"
 #import "base/test/ios/wait_util.h"
 #import "ios/chrome/browser/snapshots/snapshot_manager.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #import "ios/chrome/browser/tabs/tab_model.h"
 #include "ios/chrome/browser/test/perf_test_with_bvc_ios.h"
 #import "ios/chrome/browser/ui/browser_view_controller.h"
 #import "ios/chrome/browser/ui/fullscreen_controller.h"
 #import "ios/chrome/browser/ui/stack_view/stack_view_controller.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #include "ios/web/public/referrer.h"
 #import "net/base/mac/url_conversions.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 // These tests measure the performance of opening the stack view controller on
 // an iPhone. On an iPad, the tests do not run, as the iPad does not use the
 // stack view controller.
 
 // Opening the SVC smoothly and quickly is critical to the user experience, and
 // any sort of pause or delay is awkward and gives a poor impression.
 // The target time of opening SVC is less than 250 ms. In order to target
 // optimizations and ensure that improvements actually lower the time, this test
 // aims to mimic as closely as possible the application experience.
 
@@ skipping 13 matching lines @@
 // take a snapshot of the toolbar for the toolbar animation.
 @interface StackViewControllerPerfTestDelegate
     : NSObject<TabSwitcherDelegate, StackViewControllerTestDelegate> {
  @private
   BOOL showAnimationStarted_;
   BOOL showAnimationEnded_;
   BOOL dismissAnimationStarted_;
   BOOL dismissAnimationEnded_;
   BOOL preloadCardViewsEnded_;
  @public
-  BrowserViewController* bvc_;  // weak
+  __weak BrowserViewController* bvc_;
 }
 
 - (void)reinitialize;
 
 @property(nonatomic, assign) BOOL showAnimationStarted;
 @property(nonatomic, assign) BOOL showAnimationEnded;
 @property(nonatomic, assign) BOOL dismissAnimationStarted;
 @property(nonatomic, assign) BOOL dismissAnimationEnded;
 @property(nonatomic, assign) BOOL preloadCardViewsEnded;
 
@@ skipping 92 matching lines @@
     if (IsIPadIdiom())
       return;
 
     // Base class does most of the setup.
     PerfTestWithBVC::SetUp();
 
     current_url_index_ = 0;
     reuse_svc_ = false;
 
     // The testing delegate will receive stack view animation notifications.
-    delegate_.reset([[StackViewControllerPerfTestDelegate alloc]
-        initWithBrowserViewController:bvc_]);
+    delegate_ = [[StackViewControllerPerfTestDelegate alloc]
+        initWithBrowserViewController:bvc_];
   }
   void TearDown() override {
     // Opening a StackViewController is done only on iPhones, not on iPads.
     // This test is meaningless on an iPad.
     if (IsIPadIdiom())
       return;
 
     PerfTestWithBVC::TearDown();
   }
 
  protected:
   // Stack view controller & delegate.
-  base::scoped_nsobject<StackViewControllerPerfTestDelegate> delegate_;
-  base::scoped_nsobject<StackViewController> view_controller_;
+  StackViewControllerPerfTestDelegate* delegate_;
+  StackViewController* view_controller_;
 
   int current_url_index_;
   BOOL reuse_svc_;
 
   // Utility function to print out timing information for testing
   // with |number_of_tabs| tabs opened.
   void PrintTestResult(std::string test_description,
                        int number_of_tabs,
                        base::TimeDelta elapsed) {
     std::stringstream test_name;
@@ skipping 84 matching lines @@
   // Note that if the code there changes, this code should change to match.
   Tab* currentTab = [[bvc_ tabModel] currentTab];
 
   // In order to generate the transition between the current browser view
   // controller and the tab switcher controller it's possible that multiple
   // screenshots of the same tab are taken. Since taking a screenshot is
   // expensive we activate snapshot coalescing in the scope of this function
   // which will cache the first snapshot for the tab and reuse it instead of
   // regenerating a new one each time.
   [currentTab setSnapshotCoalescingEnabled:YES];
-  base::ScopedClosureRunner runner(base::BindBlock(^{
+  base::ScopedClosureRunner runner(base::BindBlockArc(^{
     [currentTab setSnapshotCoalescingEnabled:NO];
   }));
 
   if (!view_controller_) {
-    view_controller_.reset([[StackViewController alloc]
-        initWithMainTabModel:tab_model_
-                 otrTabModel:otr_tab_model_
-              activeTabModel:tab_model_]);
+    view_controller_ =
+        [[StackViewController alloc] initWithMainTabModel:tab_model_
+                                              otrTabModel:otr_tab_model_
+                                           activeTabModel:tab_model_];
   } else {
     [view_controller_ restoreInternalStateWithMainTabModel:tab_model_
                                                otrTabModel:otr_tab_model_
                                             activeTabModel:tab_model_];
   }
   [view_controller_ setDelegate:delegate_];
 
   // The only addition to the function for testing.
   [view_controller_ setTestDelegate:delegate_];
 
-  [bvc_ presentViewController:view_controller_.get()
+  [bvc_ presentViewController:view_controller_
                      animated:NO
                    completion:^{
                      [view_controller_ showWithSelectedTabAnimation];
                      EXPECT_TRUE([delegate_ showAnimationStarted]);
                      EXPECT_FALSE([delegate_ showAnimationEnded]);
                    }];
 }
 
 base::TimeDelta StackViewControllerPerfTest::CloseStackView() {
   base::Time startTime = base::Time::NowFromSystemTime();
   // Spin and wait for the dismiss stack view animation to finish.
   base::test::ios::TimeUntilCondition(
       ^{
         [view_controller_ dismissWithSelectedTabAnimation];
         EXPECT_TRUE([delegate_ dismissAnimationStarted]);
         EXPECT_FALSE([delegate_ dismissAnimationEnded]);
       },
       ^bool() {
         return [delegate_ dismissAnimationEnded];
       },
       false, base::TimeDelta::FromSecondsD(kTotalSpinDelay));
 
   [view_controller_ dismissViewControllerAnimated:NO completion:nil];
   if (!reuse_svc_)
-    view_controller_.reset();
+    view_controller_ = nil;
 
   base::TimeDelta closeTime = base::Time::NowFromSystemTime() - startTime;
 
   // Run the runloop a bit longer to give time for temporary retains that happen
   // in the OS during view teardown to resolve, so that the view gets its
   // dismissal callbacks.
   base::test::ios::WaitUntilCondition(
       nil, false, base::TimeDelta::FromSecondsD(kSpinDelay));
 
   return closeTime;
@@ skipping 53 matching lines @@
       CalculateAverage(close_times + 1, kNumTests - 1, NULL, &max_close);
   LogPerfTiming("Open cold", open_times[0]);
   LogPerfTiming("Open warm avg", open_avg);
   LogPerfTiming("Open warm max", max_open);
   LogPerfTiming("Close cold", close_times[0]);
   LogPerfTiming("Close cold avg", close_avg);
   LogPerfTiming("Close cold max", max_close);
 }
 
 }  // anonymous namespace