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/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/files/file_util.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);
+}
+
+// Init network thread on Java side.
+void initJavaNetworkThread(
+    const base::android::ScopedJavaGlobalRef<jobject>& jowner) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_CronetUrlRequestContext_initNetworkThread(env, jowner.obj());
+}
+
 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);
+  base::Closure init_java_network_thread = base::Bind(&initJavaNetworkThread,
+                                                      jcaller_ref);
   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));
+                 init_java_network_thread));
 }
 
 void CronetURLRequestContextAdapter::InitializeOnNetworkThread(
     scoped_ptr<URLRequestContextConfig> config,
     const base::Closure& java_init_network_thread) {
   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(
-      new net::ProxyConfigServiceFixed(net::ProxyConfig()));
+  context_builder.set_proxy_config_service(proxy_config_service_.release());
   config->ConfigureURLRequestContextBuilder(&context_builder);
 
   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.
@@ skipping 42 matching lines @@
 
   java_init_network_thread.Run();
 
   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 26 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) {
+    JNIEnv* env, jobject jcaller, jstring jfile_name) {
+  std::string file_name =
+      base::android::ConvertJavaStringToUTF8(env, jfile_name);
   GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &CronetURLRequestContextAdapter::StartNetLogToFileOnNetworkThread,
           base::Unretained(this),
           file_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,
+                                         jobject jcaller,

[mef, 2015/02/17 10:02:43]

jcaller doesn't seem to be used here and below. Does it make sense to make these
methods static member functions of CronetURLRequestContextAdapter?

[xunjieli, 2015/02/17 15:54:09]

Done. Good catch! We should probably make them static. They look like they
should be static methods.

+                                         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, jobject 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