[Cronet] Integrate CrNet functionality into Cronet on iOS.

components/cronet/ios/Cronet.mm

 // Copyright 2016 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 "components/cronet/ios/Cronet.h"
 
 #include <memory>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/mac/scoped_block.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/cronet/ios/cronet_environment.h"
 #include "components/cronet/url_request_context_config.h"
+#include "ios/net/crn_http_protocol_handler.h"
+#include "ios/net/empty_nsurlcache.h"
+#include "net/cert/cert_verifier.h"
+#include "net/url_request/url_request_context_getter.h"
 
 namespace {
 
 // Currently there is one and only one instance of CronetEnvironment,
 // which is leaked at the shutdown. We should consider allowing multiple
 // instances if that makes sense in the future.
 base::LazyInstance<std::unique_ptr<cronet::CronetEnvironment>>::Leaky
     gChromeNet = LAZY_INSTANCE_INITIALIZER;
 
 BOOL gHttp2Enabled = YES;
 BOOL gQuicEnabled = NO;
 ScopedVector<cronet::URLRequestContextConfig::QuicHint> gQuicHints;
 NSString* gUserAgent = nil;
+std::unique_ptr<net::CertVerifier> gMockCertVerifierForTesting;

[kapishnikov, 2016/08/10 17:47:41]

Can we rely on Objective-C++ ARC instead of std::unique_ptr? 

[mef, 2016/08/26 14:58:06]

moved into CronetTestSupport.mm, changed to bool.

+NSString* gHostResolverRulesForTesting = @"";
 NSString* gSslKeyLogFileName = nil;
+RequestFilterBlock gRequestFilterBlock = nil;
+std::unique_ptr<net::HTTPProtocolHandlerDelegate> gHttpProtocolHandlerDelegate;
+
+// net::HTTPProtocolHandlerDelegate for Cronet.
+class CronetHttpProtocolHandlerDelegate
+    : public net::HTTPProtocolHandlerDelegate {
+ public:
+  CronetHttpProtocolHandlerDelegate(net::URLRequestContextGetter* getter,
+                                    RequestFilterBlock filter)
+      : getter_(getter), filter_(filter, base::scoped_policy::RETAIN) {}

[kapishnikov, 2016/08/10 17:47:41]

RequestFilterBlock is retained by Cronet and at the same time the block supplied
by the user can reference Cronet. This can create a cycle and the objects will
never be released. It is probably okay in this situation. Will it be better if
we do not retain the block and describe it in the setRequestFilterBlock method
documentation?

[mef, 2016/08/26 14:58:07]

Now allow to call setFilterBlock multiple times to release previous block.

+
+ private:
+  // net::HTTPProtocolHandlerDelegate implementation:
+  bool CanHandleRequest(NSURLRequest* request) override {
+    if (filter_) {
+      RequestFilterBlock block = filter_.get();
+      return block(request);
+    }
+    return true;
+  }
+
+  bool IsRequestSupported(NSURLRequest* request) override {
+    NSString* scheme = [[request URL] scheme];
+    if (!scheme)
+      return false;
+    return [scheme caseInsensitiveCompare:@"data"] == NSOrderedSame ||
+           [scheme caseInsensitiveCompare:@"http"] == NSOrderedSame ||
+           [scheme caseInsensitiveCompare:@"https"] == NSOrderedSame;
+  }
+
+  net::URLRequestContextGetter* GetDefaultURLRequestContext() override {
+    return getter_.get();
+  }
+
+  scoped_refptr<net::URLRequestContextGetter> getter_;
+  base::mac::ScopedBlock<RequestFilterBlock> filter_;
+};
 
 }  // namespace
 
 @implementation Cronet
 
 + (void)checkNotStarted {
   CHECK(gChromeNet == NULL) << "Cronet is already started.";
 }
 
 + (void)setHttp2Enabled:(BOOL)http2Enabled {
@@ skipping 10 matching lines @@
   [self checkNotStarted];
   gQuicHints.push_back(new cronet::URLRequestContextConfig::QuicHint(
       base::SysNSStringToUTF8(host), port, altPort));
 }
 
 + (void)setPartialUserAgent:(NSString*)userAgent {
   [self checkNotStarted];
   gUserAgent = userAgent;
 }
 
++ (void)setMockCertVerifierForTesting:(void*)mockCertVerifierForTesting {
+  [self checkNotStarted];
+  gMockCertVerifierForTesting.reset(
+      reinterpret_cast<net::CertVerifier*>(mockCertVerifierForTesting));
+}
+
++ (void)setHostResolverRulesForTesting:(NSString*)hostResolverRulesForTesting {
+  [self checkNotStarted];
+  gHostResolverRulesForTesting = hostResolverRulesForTesting;
+}
+
 + (void)setSslKeyLogFileName:(NSString*)sslKeyLogFileName {
   [self checkNotStarted];
   gSslKeyLogFileName = sslKeyLogFileName;
 }
 
++ (void)setRequestFilterBlock:(RequestFilterBlock)block {
+  [self checkNotStarted];
+  gRequestFilterBlock = block;
+}
+
 + (void)startInternal {
   cronet::CronetEnvironment::Initialize();
   std::string partialUserAgent = base::SysNSStringToUTF8(gUserAgent);
   gChromeNet.Get().reset(new cronet::CronetEnvironment(partialUserAgent));
 
   gChromeNet.Get()->set_http2_enabled(gHttp2Enabled);
   gChromeNet.Get()->set_quic_enabled(gQuicEnabled);
   gChromeNet.Get()->set_ssl_key_log_file_name(
       base::SysNSStringToUTF8(gSslKeyLogFileName));
   for (const auto* quicHint : gQuicHints) {
     gChromeNet.Get()->AddQuicHint(quicHint->host, quicHint->port,
                                   quicHint->alternate_port);
   }
+  gChromeNet.Get()->set_host_resolver_rules(
+      [gHostResolverRulesForTesting UTF8String]);
+  gChromeNet.Get()->set_cert_verifier(std::move(gMockCertVerifierForTesting));
+
   gChromeNet.Get()->Start();
+  gHttpProtocolHandlerDelegate.reset(new CronetHttpProtocolHandlerDelegate(
+      gChromeNet.Get()->GetURLRequestContextGetter(), gRequestFilterBlock));
+  net::HTTPProtocolHandlerDelegate::SetInstance(
+      gHttpProtocolHandlerDelegate.get());
 }
 
 + (void)start {
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
     if (![NSThread isMainThread]) {
       dispatch_sync(dispatch_get_main_queue(), ^(void) {
         [self startInternal];
       });
     } else {
       [self startInternal];
     }
   });
 }
 
++ (void)registerHttpProtocolHandler {
+  // Disable the default cache.
+  [NSURLCache setSharedURLCache:[EmptyNSURLCache emptyNSURLCache]];
+  // Register the chrome http protocol handler to replace the default one.
+  BOOL success =
+      [NSURLProtocol registerClass:[CRNPauseableHTTPProtocolHandler class]];
+  DCHECK(success);
+}
+
++ (void)unregisterHttpProtocolHandler {
+  // Set up an empty default cache, with default size.
+  [NSURLCache setSharedURLCache:[[[NSURLCache alloc] init] autorelease]];

[kapishnikov, 2016/08/10 17:47:41]

Should we remember the old value of NSURLCache in registerHttpProtocolHandler
and restore it here? I am not sure that [[NSURLCache alloc] init]] will produce
the desired object. The proper NSURLCache initializer is:
initWithMemoryCapacity:(NSUInteger)memoryCapacity
          diskCapacity:(NSUInteger)diskCapacity
              diskPath:(NSString *)path
It is probably called with specific parameters somewhere by the system .

[mef, 2016/08/26 14:58:06]

Done.

+  [NSURLProtocol unregisterClass:[CRNPauseableHTTPProtocolHandler class]];
+}
+
++ (void)installIntoSessionConfiguration:(NSURLSessionConfiguration*)config {
+  config.protocolClasses = @[ [CRNPauseableHTTPProtocolHandler class] ];
+}
+
 + (void)startNetLogToFile:(NSString*)fileName logBytes:(BOOL)logBytes {
   if (gChromeNet.Get().get() && [fileName length]) {
     gChromeNet.Get()->StartNetLog([fileName UTF8String], logBytes);
   }
 }
 
 + (void)stopNetLog {
   if (gChromeNet.Get().get()) {
     gChromeNet.Get()->StopNetLog();
   }
@@ skipping 11 matching lines @@
 + (cronet_engine*)getGlobalEngine {
   DCHECK(gChromeNet.Get().get());
   if (gChromeNet.Get().get()) {
     static cronet_engine engine;
     engine.obj = gChromeNet.Get().get();
     return &engine;
   }
   return nil;
 }
 
++ (NSData*)getGlobalMetricsDeltas {
+  if (!gChromeNet.Get().get()) {
+    return nil;
+  }
+  std::vector<uint8_t> deltas(gChromeNet.Get()->GetHistogramDeltas());
+  return [NSData dataWithBytes:deltas.data() length:deltas.size()];
+}
+
 // This is a non-public dummy method that prevents the linker from stripping out
 // the otherwise non-referenced methods from 'cronet_bidirectional_stream.cc'.
 + (void)preventStrippingCronetBidirectionalStream {
   cronet_bidirectional_stream_create(NULL, 0, 0);
 }
 
 @end