Add Data Saver support to Cronet

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 "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/single_thread_task_runner.h"
 #include "base/values.h"
+#include "components/cronet/android/cronet_data_reduction_proxy.h"
 #include "components/cronet/url_request_context_config.h"
 #include "jni/CronetUrlRequestContext_jni.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_logger.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/proxy/proxy_service.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"
 
 namespace {
 
 class BasicNetworkDelegate : public net::NetworkDelegateImpl {
  public:
   BasicNetworkDelegate() {}
   ~BasicNetworkDelegate() override {}
 
  private:
   // net::NetworkDelegate implementation.
@@ skipping 90 matching lines @@
 CronetURLRequestContextAdapter::~CronetURLRequestContextAdapter() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   StopNetLogOnNetworkThread();
 }
 
 void CronetURLRequestContextAdapter::InitRequestContextOnMainThread(
     JNIEnv* env,
     jobject jcaller) {
   base::android::ScopedJavaGlobalRef<jobject> jcaller_ref;
   jcaller_ref.Reset(env, jcaller);
-  proxy_config_service_.reset(net::ProxyService::CreateSystemProxyConfigService(
-      GetNetworkTaskRunner(), nullptr));
   GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&CronetURLRequestContextAdapter::InitializeOnNetworkThread,
                  base::Unretained(this), Passed(&context_config_),
                  jcaller_ref));
 }
 
 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;
-  context_builder.set_network_delegate(new BasicNetworkDelegate());
-  context_builder.set_proxy_config_service(proxy_config_service_.release());
+  scoped_ptr<net::NetLog> net_log(new net::NetLog);
+  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->enable_data_reduction_proxy) {
+    data_reduction_proxy_.reset(
+        new CronetDataReductionProxy(
+            config->data_reduction_proxy_key,
+            config->data_reduction_proxy_options,
+            GetNetworkTaskRunner(),
+            net_log.get()));
+    context_builder.set_network_delegate(
+        data_reduction_proxy_->CreateNetworkDelegate(
+            make_scoped_ptr(new BasicNetworkDelegate())).release());
+    ScopedVector<net::URLRequestInterceptor> interceptors;
+    interceptors.push_back(data_reduction_proxy_->CreateInterceptor());
+    context_builder.SetInterceptors(interceptors.Pass());
+  } else {
+    context_builder.set_network_delegate(new BasicNetworkDelegate());
+  }
+  context_builder.set_proxy_service(
+      net::ProxyService::CreateWithoutProxyResolver(

[mmenke, 2015/04/01 15:46:14]

Why aren't you using CreateUsingSystemProxyResolver, like the builder does?

[bengr, 2015/04/24 02:30:43]

Done.

+          net::ProxyService::CreateSystemProxyConfigService(

[mmenke, 2015/04/01 15:46:14]

It's my understanding that the Java proxy config service needs to be created on
the main thread, to avoid any races.  All calls from the system to this service
are made on the main thread, and we aren't ready to receive them until we're
done creating the service.

[bengr, 2015/04/24 02:30:43]

Done.

+              GetNetworkTaskRunner(), nullptr),
+              net_log.get()));
   config->ConfigureURLRequestContextBuilder(&context_builder);
-
+  context_builder.set_net_log(net_log.release());
   context_.reset(context_builder.Build());
 
   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;
 
   // Currently (circa M39) enabling QUIC requires setting probability threshold.
   if (config->enable_quic) {
     context_->http_server_properties()
@@ skipping 40 matching lines @@
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_CronetUrlRequestContext_initNetworkThread(
       env, jcronet_url_request_context.obj());
 
   is_context_initialized_ = true;
   while (!tasks_waiting_for_context_.empty()) {
     tasks_waiting_for_context_.front().Run();
     tasks_waiting_for_context_.pop();
   }
+  if (data_reduction_proxy_) {
+    data_reduction_proxy_->Init(config->enable_data_reduction_proxy,
+                                GetURLRequestContext());
+  }
 }
 
 void CronetURLRequestContextAdapter::Destroy(JNIEnv* env, jobject jcaller) {
   DCHECK(!GetNetworkTaskRunner()->BelongsToCurrentThread());
   // Stick network_thread_ in a local, as |this| may be destroyed from the
   // network thread before delete network_thread is called.
   base::Thread* network_thread = network_thread_;
   GetNetworkTaskRunner()->DeleteSoon(FROM_HERE, this);
   // Deleting thread stops it after all tasks are completed.
   delete network_thread;
@@ skipping 95 matching lines @@
 }
 
 static jint SetMinLogLevel(JNIEnv* env, 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