CrNet: add pauseable NSURLProtocol and switch to using it

ios/net/crn_http_protocol_handler_pauseable_proxy.mm

+// Copyright 2015 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_pauseable_proxy.h"
+
+@interface CRNHTTPProtocolHandlerProxyWithClientThread () {}
+
+- (void)performSelectorOnClientThread:(SEL)aSelector withObject:(id)arg;
+
+@end
+
+// The |QueuedSelector| class represents a single queued callback, with the

[marq (ping after 24h), 2015/05/22 16:56:53]

Just use NSInvocation to instead of a custom class here.

[Elly Fong-Jones, 2015/05/26 21:16:09]

Done.

+// selector to be performed and the object on which to perform it.
+@interface QueuedSelector : NSObject {
+  SEL _selector;
+  id _object;
+}
+
+- (id)initWithSelector:(SEL)selector
+              withObject:(id)object;
+- (SEL)selector;
+- (id)object;
+
+@end
+
+@implementation QueuedSelector
+
+- (id)initWithSelector:(SEL)selector
+              withObject:(id)object {
+  if ((self = [super init])) {
+    _selector = selector;
+    _object = object;
+  }
+  return self;
+}
+
+- (SEL)selector {
+  return _selector;
+}
+
+- (id)object {
+  return _object;
+}
+
+@end
+
+@interface CRNHTTPProtocolHandlerPauseableProxy () {
+  BOOL _paused;
+  NSMutableArray* _queuedSelectors;
+}
+
+@end
+
+@implementation CRNHTTPProtocolHandlerPauseableProxy
+
+- (instancetype)initWithProtocol:(NSURLProtocol*)protocol
+                    clientThread:(NSThread*)clientThread
+                     runLoopMode:(NSString*)mode {
+  if ((self = [super initWithProtocol:protocol
+                         clientThread:clientThread
+                          runLoopMode:mode])) {
+    _paused = NO;
+    _queuedSelectors = [[NSMutableArray alloc] init];
+  }
+  return self;
+}
+
+// Overridden from CRNHTTPProtocolHandlerProxyWithClientThread. If |_paused| is
+// YES, we queue the selector/object pair in |_queuedSelectors|; otherwise, we
+// invoke the given selector directly on the client thread.
+- (void)performSelectorOnClientThread:(SEL)aSelector withObject:(id)arg {
+  if (!_paused) {
+    [super performSelectorOnClientThread:aSelector withObject:arg];
+  } else {
+    QueuedSelector* qs = [[QueuedSelector alloc]
+        initWithSelector:aSelector
+        withObject:arg];

[marq (ping after 24h), 2015/05/22 16:56:53]

(This is a memory leak, BTW).

+    [_queuedSelectors addObject:qs];

[marq (ping after 24h), 2015/05/22 16:56:53]

Try this:

scoped_nsobject<NSInvocation> qs([[NSInvocation alloc] init]);
[qs setSelector:aSelector];
[qs setTarget:arg];
[_queuedSelectors addObject:qs];

+  }
+}
+
+- (void)pause {
+  _paused = YES;
+}
+
+- (void)resume {
+  _paused = NO;
+  for (QueuedSelector* qs : _queuedSelectors) {

[marq (ping after 24h), 2015/05/22 16:56:53]

for (NSInvocation* qs : _queuedSelectors) {
  [self performSelectorOnClientThread:[qs selector] withObject:[qs target]];
}

+    [self performSelectorOnClientThread:[qs selector] withObject:[qs object]];

[marq (ping after 24h), 2015/05/22 16:56:53]

What if [self pause] is a queued selector, or executing the selector causes a
pause? 

I think it's safer to iteratively drain the queued selectors while unpaused,
instead of assuming that each 'resume' can execute all of the queued messages. 

+  }
+  [_queuedSelectors removeAllObjects];
+}
+
+@end