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"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #import "ios/net/clients/crn_network_client_protocol.h"
+#import "ios/net/crn_http_protocol_handler_pauseable_proxy.h"
 #import "ios/net/crn_http_protocol_handler_proxy_with_client_thread.h"
 #import "ios/net/http_protocol_logging.h"
 #include "ios/net/nsurlrequest_util.h"
 #import "ios/net/protocol_handler_util.h"
 #include "ios/net/request_tracker.h"
 #include "net/base/auth.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #import "net/base/mac/url_conversions.h"
@@ skipping 916 matching lines @@
 - (void)stopLoading {
   g_protocol_handler_delegate->GetDefaultURLRequestContext()
       ->GetNetworkTaskRunner()
       ->PostTask(FROM_HERE,
                  base::Bind(&net::HttpProtocolHandlerCore::Cancel, _core));
   [_protocolProxy invalidate];
   _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.

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

Yes -- can this class just be a specialization of CRNHTTPProtocolHandler?

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

Done.

+@implementation CRNPauseableHTTPProtocolHandler {
+  scoped_refptr<net::HttpProtocolHandlerCore> _core;
+  base::scoped_nsobject<CRNHTTPProtocolHandlerPauseableProxy> _protocolProxy;
+  BOOL _supportedURL;
+  BOOL _started;
+}
+
+#pragma mark NSURLProtocol methods
+
++ (BOOL)canInitWithRequest:(NSURLRequest*)request {
+  DVLOG(5) << "canInitWithRequest " << net::FormatUrlRequestForLogging(request);
+  return g_protocol_handler_delegate->CanHandleRequest(request);
+}
+
++ (NSURLRequest*)canonicalRequestForRequest:(NSURLRequest*)request {
+  // TODO(droger): Is this used if we disable the cache of UIWebView? If it is,
+  // then we need a real implementation, even though Chrome network stack does
+  // not need it (GURLs are automatically canonized).
+  return request;
+}
+
+- (instancetype)initWithRequest:(NSURLRequest*)request
+                 cachedResponse:(NSCachedURLResponse*)cachedResponse
+                         client:(id<NSURLProtocolClient>)client {
+  DCHECK(!cachedResponse);
+  self = [super initWithRequest:request
+                 cachedResponse:cachedResponse
+                         client:client];
+  if (self) {
+    _supportedURL = g_protocol_handler_delegate->IsRequestSupported(request);
+    _core = new net::HttpProtocolHandlerCore(request);
+    _started = NO;
+  }
+  return self;
+}
+
+- (void)dealloc {
+  g_protocol_handler_delegate->GetDefaultURLRequestContext()
+      ->GetNetworkTaskRunner()
+      ->PostTask(FROM_HERE,
+                 base::Bind(&net::HttpProtocolHandlerCore::Cancel, _core));
+  [_protocolProxy invalidate];
+  [super dealloc];
+}
+
+#pragma mark NSURLProtocol overrides.
+
+- (NSCachedURLResponse*)cachedResponse {
+  // We do not use the UIWebView cache.
+  // TODO(droger): Disable the UIWebView cache.
+  return nil;
+}
+
+- (void)startLoading {
+  if (_started) {
+    [_protocolProxy resume];
+    return;
+  }
+
+  // If the scheme is not valid, just return an error right away.
+  if (!_supportedURL) {
+    NSMutableDictionary* dictionary = [NSMutableDictionary dictionary];
+
+    // It is possible for URL to be nil, so check for that
+    // before creating the error object. See http://crbug/349051
+    NSURL* url = [[self request] URL];
+    if (url)
+      [dictionary setObject:url forKey:NSURLErrorKey];
+
+    NSError* error = [NSError errorWithDomain:NSURLErrorDomain
+                                         code:NSURLErrorUnsupportedURL
+                                     userInfo:dictionary];
+    [[self client] URLProtocol:self didFailWithError:error];
+    return;
+  }
+
+  _started = YES;
+  _protocolProxy.reset([[CRNHTTPProtocolHandlerPauseableProxy 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));
+}
+
+- (void)stopLoading {
+  [_protocolProxy pause];
+}
+
+@end