[ObjC ARC] Converts ios/net to ARC.

ios/net/crn_http_protocol_handler_proxy_with_client_thread.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/net/crn_http_protocol_handler_proxy_with_client_thread.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/time/time.h"
 #import "ios/net/protocol_handler_util.h"
 #include "net/base/auth.h"
 #include "net/url_request/url_request.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 // When the protocol is invalidated, no synchronization (lock) is needed:
 // - The actual calls to the protocol and its invalidation are all done on
 //   clientThread_ and thus are serialized.
 // - When a proxy method is called, the protocol is compared to nil. There may
 //   be a conflict at this point, in the case the protocol is being invalidated
 //   during this comparison. However, in such a case, the actual value of the
 //   pointer does not matter: an invalid pointer will behave as a valid one and
 //   post a task on the clientThread_, and that task will be handled correctly,
 //   as described by the item above.
 
@@ skipping 40 matching lines @@
   DCHECK(clientThread);
   if ((self = [super init])) {
     _protocol = protocol;
     _url.reset([[[[protocol request] URL] absoluteString] copy]);
     _creationTime = base::Time::Now();
     _clientThread = clientThread;
     // Use the common run loop mode in addition to the client thread mode, in
     // hope that our tasks are executed even if the client thread changes mode
     // later on.
     if ([mode isEqualToString:NSRunLoopCommonModes])
-      _runLoopModes.reset([@[ NSRunLoopCommonModes ] retain]);
+      _runLoopModes.reset(@[ NSRunLoopCommonModes ]);
     else
-      _runLoopModes.reset([@[ mode, NSRunLoopCommonModes ] retain]);
+      _runLoopModes.reset(@[ mode, NSRunLoopCommonModes ]);
     _queuedInvocations.reset([[NSMutableArray alloc] init]);
   }
   return self;
 }
 
 - (void)invalidate {
   DCHECK([NSThread currentThread] == _clientThread);
   _protocol = nil;
   _requestComplete = YES;
   // Note that there may still be queued invocations here, if the chrome network
@@ skipping 30 matching lines @@
   NSMethodSignature* sig = [self methodSignatureForSelector:aSelector];
   DCHECK(sig != nil);
   NSInvocation* inv = [NSInvocation invocationWithMethodSignature:sig];
   [inv setTarget:self];
   [inv setSelector:aSelector];
   [inv retainArguments];
 
   size_t arg_index = 2;
   va_list args;
   va_start(args, aSelector);
-  NSObject* arg = va_arg(args, NSObject*);
+  __unsafe_unretained NSObject* arg = va_arg(args, NSObject*);
   while (arg != nil) {
     [inv setArgument:&arg atIndex:arg_index];
     arg = va_arg(args, NSObject*);
     arg_index++;
   }
   va_end(args);
 
   DCHECK(arg_index == sig.numberOfArguments);
   [self performSelector:@selector(invokeOnClientThread:)
                onThread:_clientThread
@@ skipping 117 matching lines @@
 }
 
 - (void)resume {
   DCHECK([NSThread currentThread] == _clientThread);
   DCHECK(!_requestComplete || !_protocol);
   _paused = NO;
   [self runInvocationQueueOnClientThread];
 }
 
 @end