[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"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_filter.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/pref_service_factory.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/cronet/url_request_context_config.h"
 #include "jni/CronetUrlRequestContext_jni.h"
 #include "net/base/external_estimate_provider.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
+#include "net/cert/cert_verifier.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/log/write_to_file_net_log_observer.h"
 #include "net/proxy/proxy_config_service_android.h"
 #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"
 
@@ skipping 191 matching lines @@
 void CronetURLRequestContextAdapter::ProvideThroughputObservations(
     JNIEnv* env,
     jobject jcaller,
     bool should) {
   PostTaskToNetworkThread(
       FROM_HERE, base::Bind(&CronetURLRequestContextAdapter::
                                 ProvideThroughputObservationsOnNetworkThread,
                             base::Unretained(this), should));
 }
 
+void CronetURLRequestContextAdapter::SetMockCertVerifierForTesting(
+    JNIEnv* env,
+    jobject jcaller,
+    jlong jmock_verifier) {
+  DCHECK(!GetNetworkTaskRunner()->BelongsToCurrentThread());
+  // Not using RunTaskAfterContextInitOnNetworkThread so verifier can be set
+  // before the context is initialized.
+  GetNetworkTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&CronetURLRequestContextAdapter::
+                                SetMockCertVerifierForTestingOnNetworkThread,
+                            base::Unretained(this), jmock_verifier));
+}
+
+void CronetURLRequestContextAdapter::
+    SetMockCertVerifierForTestingOnNetworkThread(jlong jmock_verifier) {
+  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
+  DCHECK(!context_builder_);
+
+  context_builder_.reset(new net::URLRequestContextBuilder);
+  net::CertVerifier* cert_verifier =
+      reinterpret_cast<net::CertVerifier*>(jmock_verifier);
+  context_builder_->set_cert_verifier(cert_verifier);
+}
+
 void CronetURLRequestContextAdapter::InitializeOnNetworkThread(
     scoped_ptr<URLRequestContextConfig> config,
     const base::android::ScopedJavaGlobalRef<jobject>&
         jcronet_url_request_context) {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   DCHECK(!is_context_initialized_);
   DCHECK(proxy_config_service_);
   // TODO(mmenke):  Add method to have the builder enable SPDY.
-  net::URLRequestContextBuilder context_builder;
+  if (!context_builder_)
+    context_builder_.reset(new net::URLRequestContextBuilder());
 
   net_log_.reset(new net::NetLog);
   scoped_ptr<net::NetworkDelegate> network_delegate(new BasicNetworkDelegate());
 #if defined(DATA_REDUCTION_PROXY_SUPPORT)
   DCHECK(!data_reduction_proxy_);
   // For now, the choice to enable the data reduction proxy happens once,
   // at initialization. It cannot be disabled thereafter.
   if (!config->data_reduction_proxy_key.empty()) {
     data_reduction_proxy_.reset(new CronetDataReductionProxy(
         config->data_reduction_proxy_key, config->data_reduction_primary_proxy,
         config->data_reduction_fallback_proxy,
         config->data_reduction_secure_proxy_check_url, config->user_agent,
         GetNetworkTaskRunner(), net_log_.get()));
     network_delegate =
         data_reduction_proxy_->CreateNetworkDelegate(network_delegate.Pass());
     ScopedVector<net::URLRequestInterceptor> interceptors;
     interceptors.push_back(data_reduction_proxy_->CreateInterceptor());
-    context_builder.SetInterceptors(interceptors.Pass());
+    context_builder_->SetInterceptors(interceptors.Pass());
   }
 #endif  // defined(DATA_REDUCTION_PROXY_SUPPORT)
-  context_builder.set_network_delegate(network_delegate.Pass());
-  context_builder.set_net_log(net_log_.get());
+  context_builder_->set_network_delegate(network_delegate.Pass());
+  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(
+  context_builder_->set_proxy_service(
       net::ProxyService::CreateWithoutProxyResolver(
           proxy_config_service_.Pass(), net_log_.get()));
-  config->ConfigureURLRequestContextBuilder(&context_builder);
+  config->ConfigureURLRequestContextBuilder(context_builder_.get());
 
   // 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());
+    context_builder_->SetFileTaskRunner(GetFileThread()->task_runner());
 
     // Set up HttpServerPropertiesManager.
     base::PrefServiceFactory factory;
     factory.set_user_prefs(json_pref_store_);
     scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple());
     registry->RegisterDictionaryPref(kHttpServerProperties,
                                      new base::DictionaryValue());
     pref_service_ = factory.Create(registry.get()).Pass();
 
     scoped_ptr<net::HttpServerPropertiesManager> http_server_properties_manager(
         new net::HttpServerPropertiesManager(pref_service_.get(),
                                              kHttpServerProperties,
                                              GetNetworkTaskRunner()));
     http_server_properties_manager->InitializeOnNetworkThread();
     http_server_properties_manager_ = http_server_properties_manager.get();
-    context_builder.SetHttpServerProperties(
+    context_builder_->SetHttpServerProperties(
         http_server_properties_manager.Pass());
   }
 
-  context_ = context_builder.Build().Pass();
+  context_ = context_builder_->Build().Pass();
 
   default_load_flags_ = net::LOAD_DO_NOT_SAVE_COOKIES |
                         net::LOAD_DO_NOT_SEND_COOKIES;
   if (config->load_disable_cache)
     default_load_flags_ |= net::LOAD_DISABLE_CACHE;
 
   if (config->enable_sdch) {
     DCHECK(context_->sdch_manager());
     sdch_owner_.reset(
         new net::SdchOwner(context_->sdch_manager(), context_.get()));
@@ skipping 206 matching lines @@
 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