[ObjC ARC] Converts ios/chrome/app/application_delegate:unit_tests to ARC.

ios/chrome/app/application_delegate/metrics_mediator_unittest.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 "ios/chrome/app/application_delegate/metrics_mediator.h"
 #import "ios/chrome/app/application_delegate/metrics_mediator_testing.h"
 
 #import <Foundation/Foundation.h>
 
 #include "base/mac/scoped_block.h"
-#include "base/mac/scoped_nsobject.h"
 #import "breakpad/src/client/ios/BreakpadController.h"
 #include "components/metrics/metrics_service.h"
 #import "ios/chrome/app/application_delegate/startup_information.h"
 #include "ios/chrome/browser/application_context.h"
 #import "ios/chrome/browser/metrics/previous_session_info.h"
 #import "ios/chrome/browser/metrics/previous_session_info_private.h"
 #import "ios/chrome/browser/tabs/tab_model.h"
 #import "ios/chrome/browser/ui/main/browser_view_information.h"
 #import "ios/chrome/test/base/scoped_block_swizzler.h"
 #import "ios/chrome/test/ocmock/OCMockObject+BreakpadControllerTesting.h"
 #include "net/base/network_change_notifier.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
+
 #pragma mark - connectionTypeChanged tests.
 
 // Mock class for testing MetricsMediator.
 @interface MetricsMediatorMock : MetricsMediator
 @property(nonatomic) NSInteger reportingValue;
 @property(nonatomic) NSInteger breakpadUpload;
 - (void)reset;
 - (void)setReporting:(BOOL)enableReporting;
 @end
 
@@ skipping 49 matching lines @@
 int getExpectedValue(int number) {
   if (number > 2 && number < 6)
     return 0;
   return 1;
 }
 
 // Verifies that connectionTypeChanged correctly enables or disables the
 // uploading in the breakpad and in the metrics service.
 TEST(MetricsMediatorTest, connectionTypeChanged) {
   [[PreviousSessionInfo sharedInstance] setIsFirstSessionAfterUpgrade:NO];
-  base::scoped_nsobject<MetricsMediatorMock> mock_metrics_helper(
-      [[MetricsMediatorMock alloc] init]);
+  MetricsMediatorMock* mock_metrics_helper = [[MetricsMediatorMock alloc] init];
 
   // Checks all different scenarios.
   for (int i = 0; i < 8; ++i) {
     [mock_metrics_helper reset];
     [mock_metrics_helper connectionTypeChanged:getConnectionType(i)];
     EXPECT_EQ(getExpectedValue(i), [mock_metrics_helper reportingValue]);
     EXPECT_EQ(getExpectedValue(i), [mock_metrics_helper breakpadUpload]);
   }
 
   // Checks that no new ConnectionType has been added.
@@ skipping 11 matching lines @@
  protected:
   MetricsMediatorLogLaunchTest() : has_been_called_(FALSE) {}
 
   void initiateMetricsMediator(BOOL coldStart, int tabCount) {
     id mainTabModel = [OCMockObject mockForClass:[TabModel class]];
     [[[mainTabModel stub] andReturnValue:@(tabCount)] count];
     browser_view_information_ =
         [OCMockObject mockForProtocol:@protocol(BrowserViewInformation)];
     [[[browser_view_information_ stub] andReturn:mainTabModel] mainTabModel];
 
-    swizzle_block_.reset([^(id self, int numTab) {
+    swizzle_block_ = [^(id self, int numTab) {
       has_been_called_ = YES;
       // Tests.
       EXPECT_EQ(tabCount, numTab);
-    } copy]);
+    } copy];
     if (coldStart) {
       uma_histogram_swizzler_.reset(new ScopedBlockSwizzler(
           [MetricsMediator class], @selector(recordNumTabAtStartup:),
           swizzle_block_));
     } else {
       uma_histogram_swizzler_.reset(new ScopedBlockSwizzler(
           [MetricsMediator class], @selector(recordNumTabAtResume:),
           swizzle_block_));
     }
   }
 
   void verifySwizzleHasBeenCalled() { EXPECT_TRUE(has_been_called_); }
 
   id getBrowserViewInformation() { return browser_view_information_; }
 
  private:
   id browser_view_information_;
   __block BOOL has_been_called_;
-  base::mac::ScopedBlock<logLaunchMetricsBlock> swizzle_block_;
+  logLaunchMetricsBlock swizzle_block_;
   std::unique_ptr<ScopedBlockSwizzler> uma_histogram_swizzler_;
 };
 
 // Verifies that the log of the number of open tabs is sent and verifies
 TEST_F(MetricsMediatorLogLaunchTest,
        logLaunchMetricsWithEnteredBackgroundDate) {
   // Setup.
   BOOL coldStart = YES;
   initiateMetricsMediator(coldStart, 23);
 
@@ skipping 75 matching lines @@
 
 class MetricsMediatorShutdownTypeTest : public testing::TestWithParam<int> {};
 
 // Verifies that the Breakpad controller gets called appropriately when
 // processCrashReportsPresentAtStartup is invoked.
 //
 // This parameterized test receives an int parameter that is the crash log
 // count waiting to be processed.
 TEST_P(MetricsMediatorShutdownTypeTest, ProcessCrashReportsPresentAtStartup) {
   // Create a MainController.
-  base::scoped_nsobject<MetricsMediator> metric_helper(
-      [[MetricsMediator alloc] init]);
+  MetricsMediator* metric_helper = [[MetricsMediator alloc] init];
 
   // Create a mock for BreakpadController and swizzle
   // +[BreakpadController sharedInstance] to return the mock instead of the
   // normal singleton instance.
-  base::scoped_nsobject<id> mock_breakpad_controller(
-      [[OCMockObject mockForClass:[BreakpadController class]] retain]);
+  id mock_breakpad_controller =
+      [OCMockObject mockForClass:[BreakpadController class]];
 
   id implementation_block = ^BreakpadController*(id self) {
-    return mock_breakpad_controller.get();
+    return mock_breakpad_controller;
   };
   ScopedBlockSwizzler breakpad_controller_shared_instance_swizzler(
       [BreakpadController class], @selector(sharedInstance),
       implementation_block);
 
   // Create the mock expectation for calling
   // -[BreakpadController getCrashReportCount].
   [mock_breakpad_controller cr_expectGetCrashReportCount:GetParam()];
 
   // Now call the method under test and verify that the Breakpad controller got
   // called appropriately.
   [metric_helper processCrashReportsPresentAtStartup];
-  EXPECT_OCMOCK_VERIFY(mock_breakpad_controller.get());
+  EXPECT_OCMOCK_VERIFY(mock_breakpad_controller);
 }
 
 INSTANTIATE_TEST_CASE_P(/* No InstantiationName */,
                         MetricsMediatorShutdownTypeTest,
                         ::testing::Values(0, 1, 42));