[ObjC ARC] Converts ios/chrome/browser/web:unit_tests_internal to ARC.

ios/chrome/browser/web/auto_reload_controller_unittest.mm

 // Copyright 2014 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/web/auto_reload_controller.h"
 
 #include <memory>
 
-#include "base/mac/scoped_nsobject.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 @interface AutoReloadController (Testing)
 
 - (void)setTimerForTesting:(std::unique_ptr<base::Timer>)timer;
 
 @end
 
 @interface TestAutoReloadDelegate : NSObject<AutoReloadDelegate>
 @end
 
 @implementation TestAutoReloadDelegate {
@@ skipping 10 matching lines @@
 
 @end
 
 class AutoReloadControllerTest : public testing::Test {
  public:
   AutoReloadControllerTest() : timer_(new base::MockTimer(false, false)) {}
 
  protected:
   void SetUp() override {
     testing::Test::SetUp();
-    delegate_.reset([[TestAutoReloadDelegate alloc] init]);
-    controller_.reset([[AutoReloadController alloc]
-        initWithDelegate:delegate_.get()
-            onlineStatus:YES]);
+    delegate_ = [[TestAutoReloadDelegate alloc] init];
+    controller_ = [[AutoReloadController alloc] initWithDelegate:delegate_
+                                                    onlineStatus:YES];
     // Note: even though setTimerForTesting theoretically passes ownership of
     // the timer to the controller, this class retains a weak pointer to the
     // timer so it can query or fire it for testing. The only reason this is
     // safe is that this class owns the controller which now owns the timer, so
     // the timer has the same lifetime as this class.
     [controller_ setTimerForTesting:std::unique_ptr<base::Timer>(timer_)];
   }
 
   // Synthesize a failing page load.
   void DoFailingLoad(const GURL& url) {
     [controller_ loadStartedForURL:url];
     [controller_ loadFailedForURL:url wasPost:NO];
   }
 
   // Synthesize a succeeding page load.
   void DoSucceedingLoad(const GURL& url) {
     [controller_ loadStartedForURL:url];
     [controller_ loadFinishedForURL:url wasPost:NO];
   }
 
-  base::scoped_nsobject<TestAutoReloadDelegate> delegate_;
-  base::scoped_nsobject<AutoReloadController> controller_;
+  TestAutoReloadDelegate* delegate_;
+  AutoReloadController* controller_;
   base::MockTimer* timer_;  // weak
 };
 
 TEST_F(AutoReloadControllerTest, AutoReloadSucceeds) {
   const GURL kTestUrl("https://www.google.com");
   DoFailingLoad(kTestUrl);
   EXPECT_TRUE(timer_->IsRunning());
   EXPECT_EQ(0, [delegate_ reloads]);
   timer_->Fire();
   EXPECT_EQ(1, [delegate_ reloads]);
@@ skipping 94 matching lines @@
   EXPECT_TRUE(timer_->IsRunning());
   EXPECT_EQ(delay, timer_->GetCurrentDelay());
 }
 
 TEST_F(AutoReloadControllerTest, AutoReloadDoesNotReloadPosts) {
   const GURL kTestUrl("https://www.google.com");
   [controller_ loadStartedForURL:kTestUrl];
   [controller_ loadFailedForURL:kTestUrl wasPost:YES];
   EXPECT_FALSE(timer_->IsRunning());
 }