[Cronet] Use Https for Quic Test Server

components/cronet/android/cronet_url_request_context_adapter.cc

 // Copyright 2014 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.
 
 #include "components/cronet/android/cronet_url_request_context_adapter.h"
 
 #include <map>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 23 matching lines @@
 #include "net/proxy/proxy_service.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_interceptor.h"
 
 #if defined(DATA_REDUCTION_PROXY_SUPPORT)
 #include "components/cronet/android/cronet_data_reduction_proxy.h"
 #endif
 
+#if defined(CRONET_TEST)
+#include "net/base/test_data_directory.h"
+#include "net/cert/cert_verifier.h"
+#include "net/cert/cert_verify_result.h"
+#include "net/cert/mock_cert_verifier.h"
+#include "net/test/cert_test_util.h"
+#endif
+
 namespace {
 
 const char kHttpServerProperties[] = "net.http_server_properties";
 
 class BasicNetworkDelegate : public net::NetworkDelegateImpl {
  public:
   BasicNetworkDelegate() {}
   ~BasicNetworkDelegate() override {}
 
  private:
@@ skipping 217 matching lines @@
   context_builder.set_net_log(net_log_.get());
 
   // Android provides a local HTTP proxy server that handles proxying when a PAC
   // URL is present. Create a proxy service without a resolver and rely on this
   // local HTTP proxy. See: crbug.com/432539.
   context_builder.set_proxy_service(
       net::ProxyService::CreateWithoutProxyResolver(
           proxy_config_service_.Pass(), net_log_.get()));
   config->ConfigureURLRequestContextBuilder(&context_builder);
 
+#if defined(CRONET_TEST)
+  ConfigureURLRequestContextBuilderForTesting(config.get(), &context_builder);
+#endif
+
   // Set up pref file if storage path is specified.
   if (!config->storage_path.empty()) {
     base::FilePath filepath(config->storage_path);
     filepath = filepath.Append(FILE_PATH_LITERAL("local_prefs.json"));
     json_pref_store_ = new JsonPrefStore(
         filepath, GetFileThread()->task_runner(), scoped_ptr<PrefFilter>());
     context_builder.SetFileTaskRunner(GetFileThread()->task_runner());
 
     // Set up HttpServerPropertiesManager.
     base::PrefServiceFactory factory;
@@ skipping 206 matching lines @@
 void CronetURLRequestContextAdapter::OnThroughputObservation(
     int32_t throughput_kbps,
     const base::TimeTicks& timestamp,
     net::NetworkQualityEstimator::ObservationSource source) {
   Java_CronetUrlRequestContext_onThroughputObservation(
       base::android::AttachCurrentThread(), jcronet_url_request_context_.obj(),
       throughput_kbps,
       (timestamp - base::TimeTicks::UnixEpoch()).InMilliseconds(), source);
 }
 
+#if defined(CRONET_TEST)
+void CronetURLRequestContextAdapter::
+    ConfigureURLRequestContextBuilderForTesting(
+        URLRequestContextConfig* config,
+        net::URLRequestContextBuilder* builder) {
+  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
+  DCHECK(!mock_cert_verifier_);
+
+  if (config->mock_certs_for_testing.empty())
+    return;
+
+  base::StringTokenizer tokens(config->mock_certs_for_testing, ",");
+  mock_cert_verifier_.reset(new net::MockCertVerifier());
+  while (tokens.GetNext()) {
+    net::CertVerifyResult verify_result;
+    verify_result.verified_cert =
+        net::ImportCertFromFile(net::GetTestCertsDirectory(), tokens.token());
+    mock_cert_verifier_->AddResultForCert(verify_result.verified_cert.get(),
+                                          verify_result, net::OK);
+  }
+  builder->set_cert_verifier(mock_cert_verifier_.get());
+}
+#endif
+
 // Creates RequestContextAdater if config is valid URLRequestContextConfig,
 // returns 0 otherwise.
 static jlong CreateRequestContextAdapter(JNIEnv* env,
                                          const JavaParamRef<jclass>& jcaller,
                                          const JavaParamRef<jstring>& jconfig) {
   std::string config_string =
       base::android::ConvertJavaStringToUTF8(env, jconfig);
   scoped_ptr<URLRequestContextConfig> context_config(
       new URLRequestContextConfig());
   if (!context_config->LoadFromJSON(config_string))
     return 0;
 
   CronetURLRequestContextAdapter* context_adapter =
       new CronetURLRequestContextAdapter(context_config.Pass());
   return reinterpret_cast<jlong>(context_adapter);
 }
 
 static jint SetMinLogLevel(JNIEnv* env,
                            const JavaParamRef<jclass>& jcaller,
                            jint jlog_level) {
   jint old_log_level = static_cast<jint>(logging::GetMinLogLevel());
   // MinLogLevel is global, shared by all URLRequestContexts.
   logging::SetMinLogLevel(static_cast<int>(jlog_level));
   return old_log_level;
 }
 
 }  // namespace cronet