QUIC/Cronet - Add Java glue layer to serialize and de-serialize

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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
+#include "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/cronet/histogram_manager.h"
 #include "components/cronet/url_request_context_config.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_filter.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/pref_service_factory.h"
 #include "jni/CronetUrlRequestContext_jni.h"
 #include "net/base/load_flags.h"
 #include "net/base/logging_network_change_observer.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/url_util.h"
+#include "net/cert/caching_cert_verifier.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cookies/cookie_monster.h"
+#include "net/extras/cert/cert_verifier_cache_persister.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/nqe/external_estimate_provider.h"
 #include "net/proxy/proxy_config_service_android.h"
 #include "net/proxy/proxy_service.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
@@ skipping 564 matching lines @@
 
       url::SchemeHostPort quic_server("https", canon_host, quic_hint.port);
       net::AlternativeService alternative_service(
           net::AlternateProtocol::QUIC, "",
           static_cast<uint16_t>(quic_hint.alternate_port));
       context_->http_server_properties()->SetAlternativeService(
           quic_server, alternative_service, base::Time::Max());
     }
   }
 
+  // If there is a cert_verifier, then pouplate it's cache with
+  // |cert_verifier_data|.
+  if (!config->cert_verifier_data.empty() && context_->cert_verifier()) {
+    std::string data;
+    if (base::Base64Decode(config->cert_verifier_data, &data)) {
+      net::CertVerifierCachePersister persister(
+          reinterpret_cast<net::CachingCertVerifier*>(
+              context_->cert_verifier()));
+      persister.LoadCache(data);
+    }
+  }
+
   // Iterate through PKP configuration for every host.
   for (const auto& pkp : config->pkp_list) {
     // Add the host pinning.
     context_->transport_security_state()->AddHPKP(
         pkp->host, pkp->expiration_date, pkp->include_subdomains,
         pkp->pin_hashes, GURL::EmptyGURL());
   }
 
   JNIEnv* env = base::android::AttachCurrentThread();
   jcronet_url_request_context_.Reset(env, jcronet_url_request_context.obj());
@@ skipping 74 matching lines @@
 
 void CronetURLRequestContextAdapter::StopNetLog(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller) {
   PostTaskToNetworkThread(
       FROM_HERE,
       base::Bind(&CronetURLRequestContextAdapter::StopNetLogOnNetworkThread,
                  base::Unretained(this)));
 }
 
+void CronetURLRequestContextAdapter::GetCertVerifierData(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller) {
+  PostTaskToNetworkThread(
+      FROM_HERE,
+      base::Bind(
+          &CronetURLRequestContextAdapter::GetCertVerifierDataOnNetworkThread,
+          base::Unretained(this)));
+}
+
 void CronetURLRequestContextAdapter::StartNetLogToFileOnNetworkThread(
     const std::string& file_name, bool log_all) {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   DCHECK(is_context_initialized_);
   DCHECK(context_);
   // Do nothing if already logging to a file.
   if (write_to_file_observer_)
     return;
   base::FilePath file_path(file_name);
   base::ScopedFILE file(base::OpenFile(file_path, "w"));
@@ skipping 12 matching lines @@
 }
 
 void CronetURLRequestContextAdapter::StopNetLogOnNetworkThread() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   if (write_to_file_observer_) {
     write_to_file_observer_->StopObserving(context_.get());
     write_to_file_observer_.reset();
   }
 }
 
+void CronetURLRequestContextAdapter::GetCertVerifierDataOnNetworkThread() {
+  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
+  std::string encoded_data;
+  if (is_context_initialized_ && context_->cert_verifier()) {
+    std::string data;
+    net::CertVerifierCachePersister persister(
+        reinterpret_cast<net::CachingCertVerifier*>(context_->cert_verifier()));
+    persister.SerializeCache(&data);
+    base::Base64Encode(data, &encoded_data);
+  }
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_CronetUrlRequestContext_onGetCertVerifierData(
+      env, jcronet_url_request_context_.obj(),
+      base::android::ConvertUTF8ToJavaString(env, encoded_data).obj());
+}
+
 base::Thread* CronetURLRequestContextAdapter::GetFileThread() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   if (!file_thread_) {
     file_thread_.reset(new base::Thread("Network File Thread"));
     file_thread_->Start();
   }
   return file_thread_.get();
 }
 
 void CronetURLRequestContextAdapter::OnRTTObservation(
@@ skipping 27 matching lines @@
     jboolean jhttp2_enabled,
     jboolean jsdch_enabled,
     const JavaParamRef<jstring>& jdata_reduction_proxy_key,
     const JavaParamRef<jstring>& jdata_reduction_proxy_primary_proxy,
     const JavaParamRef<jstring>& jdata_reduction_proxy_fallback_proxy,
     const JavaParamRef<jstring>& jdata_reduction_proxy_secure_proxy_check_url,
     jboolean jdisable_cache,
     jint jhttp_cache_mode,
     jlong jhttp_cache_max_size,
     const JavaParamRef<jstring>& jexperimental_quic_connection_options,
-    jlong jmock_cert_verifier) {
+    jlong jmock_cert_verifier,
+    const JavaParamRef<jstring>& jcert_verifier_data) {
   return reinterpret_cast<jlong>(new URLRequestContextConfig(
       jquic_enabled,
       ConvertNullableJavaStringToUTF8(env, jquic_default_user_agent_id),
       jhttp2_enabled, jsdch_enabled,
       static_cast<URLRequestContextConfig::HttpCacheType>(jhttp_cache_mode),
       jhttp_cache_max_size, jdisable_cache,
       ConvertNullableJavaStringToUTF8(env, jstorage_path),
       ConvertNullableJavaStringToUTF8(env, juser_agent),
       ConvertNullableJavaStringToUTF8(env,
                                       jexperimental_quic_connection_options),
       ConvertNullableJavaStringToUTF8(env, jdata_reduction_proxy_key),
       ConvertNullableJavaStringToUTF8(env, jdata_reduction_proxy_primary_proxy),
       ConvertNullableJavaStringToUTF8(env,
                                       jdata_reduction_proxy_fallback_proxy),
       ConvertNullableJavaStringToUTF8(
           env, jdata_reduction_proxy_secure_proxy_check_url),
       base::WrapUnique(
-          reinterpret_cast<net::CertVerifier*>(jmock_cert_verifier))));
+          reinterpret_cast<net::CertVerifier*>(jmock_cert_verifier)),
+      ConvertNullableJavaStringToUTF8(env, jcert_verifier_data)));
 }
 
 // Add a QUIC hint to a URLRequestContextConfig.
 static void AddQuicHint(JNIEnv* env,
                         const JavaParamRef<jclass>& jcaller,
                         jlong jurl_request_context_config,
                         const JavaParamRef<jstring>& jhost,
                         jint jport,
                         jint jalternate_port) {
   URLRequestContextConfig* config =
@@ skipping 72 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jclass>& jcaller) {
   base::StatisticsRecorder::Initialize();
   std::vector<uint8_t> data;
   if (!HistogramManager::GetInstance()->GetDeltas(&data))
     return ScopedJavaLocalRef<jbyteArray>();
   return base::android::ToJavaByteArray(env, &data[0], data.size());
 }
 
 }  // namespace cronet