[ObjC ARC] Converts ios/web:ios_web_net_unittests to ARC.

ios/web/net/request_tracker_impl_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 "ios/web/net/request_tracker_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/logging.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "ios/web/public/cert_policy.h"
 #include "ios/web/public/certificate_policy_cache.h"
 #include "ios/web/public/ssl_status.h"
 #include "ios/web/public/test/fakes/test_browser_state.h"
 #include "ios/web/public/test/test_web_thread.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #import "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
+
 @interface RequestTrackerNotificationReceiverTest
     : NSObject<CRWRequestTrackerDelegate> {
  @public
   float value_;
   float max_;
  @private
-  base::scoped_nsobject<NSString> error_;
+  NSString* error_;
   scoped_refptr<net::HttpResponseHeaders> headers_;
 }
 
 - (NSString*)error;
 - (net::HttpResponseHeaders*)headers;
 @end
 
 @implementation RequestTrackerNotificationReceiverTest
 
 - (id)init {
   self = [super init];
   if (self) {
     value_ = 0.0f;
     max_ = 0.0f;
   }
   return self;
 }
 
 - (void)updatedProgress:(float)progress {
   if (progress > 0.0f) {
     if (progress < value_) {
-      error_.reset(
-          [[NSString stringWithFormat:
-              @"going down from %f to %f", value_, progress] retain]);
+      error_ = [NSString
+          stringWithFormat:@"going down from %f to %f", value_, progress];
     }
     value_ = progress;
   } else {
     value_ = 0.0f;
   }
   if (value_ > max_) {
     max_ = value_;
   }
 }
 
@@ skipping 50 matching lines @@
  public:
   RequestTrackerTest()
       : loop_(base::MessageLoop::TYPE_IO),
         ui_thread_(web::WebThread::UI, &loop_),
         io_thread_(web::WebThread::IO, &loop_){};
 
   ~RequestTrackerTest() override {}
 
   void SetUp() override {
     DCHECK_CURRENTLY_ON(web::WebThread::UI);
-    request_group_id_.reset(
-        [[NSString stringWithFormat:@"test%d", g_count++] retain]);
+    request_group_id_ = [NSString stringWithFormat:@"test%d", g_count++];
 
-    receiver_.reset([[RequestTrackerNotificationReceiverTest alloc] init]);
+    receiver_ = [[RequestTrackerNotificationReceiverTest alloc] init];
     tracker_ = web::RequestTrackerImpl::CreateTrackerForRequestGroupID(
         request_group_id_,
         &browser_state_,
         browser_state_.GetRequestContext(),
         receiver_);
   }
 
   void TearDown() override {
     DCHECK_CURRENTLY_ON(web::WebThread::UI);
     tracker_->Close();
   }
 
   base::MessageLoop loop_;
   web::TestWebThread ui_thread_;
   web::TestWebThread io_thread_;
 
-  base::scoped_nsobject<RequestTrackerNotificationReceiverTest> receiver_;
+  RequestTrackerNotificationReceiverTest* receiver_;
   scoped_refptr<web::RequestTrackerImpl> tracker_;
-  base::scoped_nsobject<NSString> request_group_id_;
+  NSString* request_group_id_;
   web::TestBrowserState browser_state_;
   std::vector<std::unique_ptr<net::URLRequestContext>> contexts_;
   std::vector<std::unique_ptr<net::URLRequest>> requests_;
   net::URLRequestJobFactoryImpl job_factory_;
 
   GURL GetURL(size_t i) {
     std::stringstream ss;
     ss << "http://www/";
     ss << i;
     return GURL(ss.str());
@@ skipping 23 matching lines @@
       if (base::Time::Now() > maxDate)
         return @"Time is up, too slow to go";
       base::RunLoop().RunUntilIdle();
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
     }
     return nil;
   }
 
   NSString* CheckActive() {
     NSString* message = WaitUntilLoop(^{
-      return (receiver_.get()->value_ > 0.0f);
+      return (receiver_->value_ > 0.0f);
     });
 
-    if (!message && (receiver_.get()->max_ == 0.0f))
+    if (!message && (receiver_->max_ == 0.0f))
       message = @"Max should be greater than 0.0";
     return message;
   }
 
   void TrimRequest(NSString* tab_id, const GURL& url) {
     DCHECK_CURRENTLY_ON(web::WebThread::UI);
-    receiver_.get()->value_ = 0.0f;
-    receiver_.get()->max_ = 0.0f;
+    receiver_->value_ = 0.0f;
+    receiver_->max_ = 0.0f;
     tracker_->StartPageLoad(url, nil);
   }
 
   void EndPage(NSString* tab_id, const GURL& url) {
     DCHECK_CURRENTLY_ON(web::WebThread::UI);
     tracker_->FinishPageLoad(url, false);
-    receiver_.get()->value_ = 0.0f;
-    receiver_.get()->max_ = 0.0f;
+    receiver_->value_ = 0.0f;
+    receiver_->max_ = 0.0f;
     base::RunLoop().RunUntilIdle();
   }
 
   net::TestJobInterceptor* AddInterceptorToRequest(size_t i) {
     // |interceptor| will be deleted from |job_factory_|'s destructor.
     net::TestJobInterceptor* protocol_handler = new net::TestJobInterceptor();
     job_factory_.SetProtocolHandler("http", base::WrapUnique(protocol_handler));
     contexts_[i]->set_job_factory(&job_factory_);
     return protocol_handler;
   }
@@ skipping 255 matching lines @@
                                   base::Bind(&TwoStartsSSLCallback,
                                              &request_0_called));
   tracker_->OnSSLCertificateError(GetSecureRequest(1), ssl_info, true,
                                   base::Bind(&TwoStartsSSLCallback,
                                              &request_1_called));
   EXPECT_TRUE(request_0_called);
   EXPECT_TRUE(request_1_called);
 }
 
 }  // namespace