CrNet: add pauseable NSURLProtocol and switch to using it

ios/net/crn_http_protocol_handler.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.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_nsobject.h"
@@ skipping 850 matching lines @@
 }
 
 - (void)stream:(NSStream*)theStream handleEvent:(NSStreamEvent)streamEvent {
   _core->HandleStreamEvent(theStream, streamEvent);
 }
 @end
 
 #pragma mark -
 #pragma mark HttpProtocolHandler
 
+@interface CRNHTTPProtocolHandler (Private) {}
+
+- (id<CRNHTTPProtocolHandlerProxy>)getProtocolHandlerProxy;
+- (void)cancelRequest;
+
+@end
+
 // The HttpProtocolHandler is called by the iOS system to handle the
 // NSURLRequest.
 @implementation CRNHTTPProtocolHandler {
   scoped_refptr<net::HttpProtocolHandlerCore> _core;
   base::scoped_nsprotocol<id<CRNHTTPProtocolHandlerProxy>> _protocolProxy;
   BOOL _supportedURL;
 }
 
 #pragma mark NSURLProtocol methods
 
@@ skipping 42 matching lines @@
     if (url)
       [dictionary setObject:url forKey:NSURLErrorKey];
 
     NSError* error = [NSError errorWithDomain:NSURLErrorDomain
                                          code:NSURLErrorUnsupportedURL
                                      userInfo:dictionary];
     [[self client] URLProtocol:self didFailWithError:error];
     return;
   }
 
-  _protocolProxy.reset([[CRNHTTPProtocolHandlerProxyWithClientThread alloc]
-      initWithProtocol:self
-          clientThread:[NSThread currentThread]
-           runLoopMode:[[NSRunLoop currentRunLoop] currentMode]]);
   g_protocol_handler_delegate->GetDefaultURLRequestContext()
       ->GetNetworkTaskRunner()
       ->PostTask(FROM_HERE, base::Bind(&net::HttpProtocolHandlerCore::Start,
-                                       _core, _protocolProxy));
+                                       _core, [self getProtocolHandlerProxy]));
 }
 
-- (void)stopLoading {
+- (id<CRNHTTPProtocolHandlerProxy>)getProtocolHandlerProxy {
+  if (!_protocolProxy.get()) {
+    _protocolProxy.reset([[CRNHTTPProtocolHandlerProxyWithClientThread alloc]
+        initWithProtocol:self
+            clientThread:[NSThread currentThread]
+             runLoopMode:[[NSRunLoop currentRunLoop] currentMode]]);
+  }
+  return _protocolProxy.get();
+}
+
+- (void)cancelRequest {
   g_protocol_handler_delegate->GetDefaultURLRequestContext()
       ->GetNetworkTaskRunner()
       ->PostTask(FROM_HERE,
                  base::Bind(&net::HttpProtocolHandlerCore::Cancel, _core));
   [_protocolProxy invalidate];
+}
+
+- (void)stopLoading {
+  [self cancelRequest];
   _protocolProxy.reset();
 }
 
 @end
+
+#pragma mark -
+#pragma mark PauseableHttpProtocolHandler
+
+// The HttpProtocolHandler is called by the iOS system to handle the
+// NSURLRequest. This HttpProtocolHandler conforms to the observed semantics of
+// NSURLProtocol when used with NSURLSession on iOS 8 - i.e., |-startLoading|
+// means "start or resume request" and |-stopLoading| means "pause request".
+// Since there is no way to actually pause a request in the network stack, this
+// is implemented using a subclass of CRNHTTPProtocolHandlerProxy that knows how
+// to defer callbacks.
+// A bunch of this code is somewhat duplicated from CRNHTTPProtocolHandler.
+// TODO(ellyjones): restructure so that is not true.
+@implementation CRNPauseableHTTPProtocolHandler {
+  BOOL _started;
+}
+
+#pragma mark NSURLProtocol methods
+
+- (instancetype)initWithRequest:(NSURLRequest*)request
+                 cachedResponse:(NSCachedURLResponse*)cachedResponse
+                         client:(id<NSURLProtocolClient>)client {
+  DCHECK(!cachedResponse);
+  self = [super initWithRequest:request
+                 cachedResponse:cachedResponse
+                         client:client];
+  if (self) {
+    _started = NO;
+  }
+  return self;
+}
+
+- (void)dealloc {

[droger, 2015/05/27 17:09:00]

I am concerned that dealloc might be called from any thread, but cancelRequest
expects to be called from the "client" thread.

[Elly Fong-Jones, 2015/06/10 17:06:35]

Okay, I think I've fixed this. It's somewhat of a bad hack; I added a method to
the parent class to schedule a cancel to be performed on the client thread,
since we are guaranteed by the iOS docs that the client thread will run its run
loop even after dealloc is run, which is very convenient for us.

+  [self cancelRequest];
+  [super dealloc];
+}
+
+#pragma mark NSURLProtocol overrides.
+
+- (void)startLoading {
+  if (_started) {
+    [[self getProtocolHandlerProxy] resume];
+    return;
+  }
+
+  _started = YES;
+  [super startLoading];
+}
+
+- (void)stopLoading {
+  [[self getProtocolHandlerProxy] pause];
+}
+
+@end