Use @NativeClassQualifiedName in CronetUrlRequestContext.java

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/logging.h"
 #include "base/single_thread_task_runner.h"
+#include "base/values.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/cert/cert_verifier.h"
 #include "net/http/http_auth_handler_factory.h"
-#include "net/http/http_network_layer.h"
-#include "net/http/http_server_properties.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_service.h"
-#include "net/ssl/ssl_config_service_defaults.h"
-#include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
-#include "net/url_request/url_request_context_storage.h"
-#include "net/url_request/url_request_job_factory_impl.h"
 
 namespace {
 
 class BasicNetworkDelegate : public net::NetworkDelegateImpl {
  public:
   BasicNetworkDelegate() {}
   ~BasicNetworkDelegate() override {}
 
  private:
   // net::NetworkDelegate implementation.
@@ skipping 64 matching lines @@
     return false;
   }
 
   DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
 };
 
 }  // namespace
 
 namespace cronet {
 
+// Explicitly register static JNI functions.
+bool CronetUrlRequestContextAdapterRegisterJni(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
 CronetURLRequestContextAdapter::CronetURLRequestContextAdapter(
     scoped_ptr<URLRequestContextConfig> context_config)
     : network_thread_(new base::Thread("network")),
       context_config_(context_config.Pass()),
       is_context_initialized_(false),
       default_load_flags_(net::LOAD_NORMAL) {
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   network_thread_->StartWithOptions(options);
 }
 
 CronetURLRequestContextAdapter::~CronetURLRequestContextAdapter() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   StopNetLogOnNetworkThread();
 }
 
 void CronetURLRequestContextAdapter::InitRequestContextOnMainThread(
-    const base::Closure& java_init_network_thread) {
+    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_),
-                 java_init_network_thread));
+                 base::Unretained(this), Passed(&context_config_),
+                 jcaller_ref));
 }
 
 void CronetURLRequestContextAdapter::InitializeOnNetworkThread(
     scoped_ptr<URLRequestContextConfig> config,
-    const base::Closure& java_init_network_thread) {
+    const base::android::ScopedJavaGlobalRef<jobject>&
+        jcronet_url_request_context) {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   DCHECK(!is_context_initialized_);
   // 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(
       new net::ProxyConfigServiceFixed(net::ProxyConfig()));
   config->ConfigureURLRequestContextBuilder(&context_builder);
 
   context_.reset(context_builder.Build());
@@ skipping 40 matching lines @@
       net::HostPortPair quic_hint_host_port_pair(canon_host,
                                                  quic_hint.port);
       context_->http_server_properties()->SetAlternateProtocol(
           quic_hint_host_port_pair,
           static_cast<uint16>(quic_hint.alternate_port),
           net::AlternateProtocol::QUIC,
           1.0f);
     }
   }
 
-  java_init_network_thread.Run();
+  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();
   }
 }
 
-void CronetURLRequestContextAdapter::Destroy() {
+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;
 }
 
 net::URLRequestContext* CronetURLRequestContextAdapter::GetURLRequestContext() {
@@ skipping 25 matching lines @@
 
 bool CronetURLRequestContextAdapter::IsOnNetworkThread() const {
   return GetNetworkTaskRunner()->BelongsToCurrentThread();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 CronetURLRequestContextAdapter::GetNetworkTaskRunner() const {
   return network_thread_->task_runner();
 }
 
-void CronetURLRequestContextAdapter::StartNetLogToFile(
-    const std::string& file_name) {
+void CronetURLRequestContextAdapter::StartNetLogToFile(JNIEnv* env,
+                                                       jobject jcaller,
+                                                       jstring jfile_name) {
   GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &CronetURLRequestContextAdapter::StartNetLogToFileOnNetworkThread,
           base::Unretained(this),
-          file_name));
+          base::android::ConvertJavaStringToUTF8(env, jfile_name)));
 }
 
-void CronetURLRequestContextAdapter::StopNetLog() {
+void CronetURLRequestContextAdapter::StopNetLog(JNIEnv* env, jobject jcaller) {
   GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&CronetURLRequestContextAdapter::StopNetLogOnNetworkThread,
                  base::Unretained(this)));
 }
 
 void CronetURLRequestContextAdapter::StartNetLogToFileOnNetworkThread(
     const std::string& file_name) {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   // Do nothing if already logging to a file.
@@ skipping 11 matching lines @@
 }
 
 void CronetURLRequestContextAdapter::StopNetLogOnNetworkThread() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   if (net_log_logger_) {
     net_log_logger_->StopObserving();
     net_log_logger_.reset();
   }
 }
 
+// Creates RequestContextAdater if config is valid URLRequestContextConfig,
+// returns 0 otherwise.
+static jlong CreateRequestContextAdapter(JNIEnv* env,
+                                         jclass jcaller,
+                                         jobject japp_context,
+                                         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, 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