jni_generator: Pass object parameters as JavaParamRef.

components/cronet/android/chromium_url_request.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/chromium_url_request.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/macros.h"
 #include "components/cronet/android/url_request_adapter.h"
@@ skipping 89 matching lines @@
 };
 
 }  // namespace
 
 // Explicitly register static JNI functions.
 bool ChromiumUrlRequestRegisterJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 static jlong CreateRequestAdapter(JNIEnv* env,
-                                  jobject jcaller,
+                                  const JavaParamRef<jobject>& jcaller,
                                   jlong jurl_request_context_adapter,
-                                  jstring jurl,
+                                  const JavaParamRef<jstring>& jurl,
                                   jint jrequest_priority) {
   URLRequestContextAdapter* context_adapter =
       reinterpret_cast<URLRequestContextAdapter*>(jurl_request_context_adapter);
   DCHECK(context_adapter);
 
   GURL url(ConvertJavaStringToUTF8(env, jurl));
 
   VLOG(1) << "New chromium network request: " << url.possibly_invalid_spec();
 
   URLRequestAdapter* adapter = new URLRequestAdapter(
       context_adapter, new JniURLRequestAdapterDelegate(env, jcaller), url,
       ConvertRequestPriority(jrequest_priority));
 
   return reinterpret_cast<jlong>(adapter);
 }
 
 // synchronized
 static void AddHeader(JNIEnv* env,
-                      jobject jcaller,
+                      const JavaParamRef<jobject>& jcaller,
                       jlong jurl_request_adapter,
-                      jstring jheader_name,
-                      jstring jheader_value) {
+                      const JavaParamRef<jstring>& jheader_name,
+                      const JavaParamRef<jstring>& jheader_value) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
 
   std::string header_name(ConvertJavaStringToUTF8(env, jheader_name));
   std::string header_value(ConvertJavaStringToUTF8(env, jheader_value));
 
   request_adapter->AddHeader(header_name, header_value);
 }
 
 static void SetMethod(JNIEnv* env,
-                      jobject jcaller,
+                      const JavaParamRef<jobject>& jcaller,
                       jlong jurl_request_adapter,
-                      jstring jmethod) {
+                      const JavaParamRef<jstring>& jmethod) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
 
   std::string method(ConvertJavaStringToUTF8(env, jmethod));
 
   request_adapter->SetMethod(method);
 }
 
 static void SetUploadData(JNIEnv* env,
-                          jobject jcaller,
+                          const JavaParamRef<jobject>& jcaller,
                           jlong jurl_request_adapter,
-                          jstring jcontent_type,
-                          jbyteArray jcontent) {
+                          const JavaParamRef<jstring>& jcontent_type,
+                          const JavaParamRef<jbyteArray>& jcontent) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   SetPostContentType(env, request_adapter, jcontent_type);
 
   if (jcontent != NULL) {
     jsize size = env->GetArrayLength(jcontent);
     if (size > 0) {
       jbyte* content_bytes = env->GetByteArrayElements(jcontent, NULL);
       request_adapter->SetUploadContent(
           reinterpret_cast<const char*>(content_bytes), size);
       env->ReleaseByteArrayElements(jcontent, content_bytes, 0);
     }
   }
 }
 
 static void SetUploadChannel(JNIEnv* env,
-                             jobject jcaller,
+                             const JavaParamRef<jobject>& jcaller,
                              jlong jurl_request_adapter,
-                             jstring jcontent_type,
+                             const JavaParamRef<jstring>& jcontent_type,
                              jlong jcontent_length) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   SetPostContentType(env, request_adapter, jcontent_type);
 
   request_adapter->SetUploadChannel(env, jcontent_length);
 }
 
 static void EnableChunkedUpload(JNIEnv* env,
-                                jobject jcaller,
+                                const JavaParamRef<jobject>& jcaller,
                                 jlong jurl_request_adapter,
-                                jstring jcontent_type) {
+                                const JavaParamRef<jstring>& jcontent_type) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   SetPostContentType(env, request_adapter, jcontent_type);
 
   request_adapter->EnableChunkedUpload();
 }
 
 static void AppendChunk(JNIEnv* env,
-                        jobject jcaller,
+                        const JavaParamRef<jobject>& jcaller,
                         jlong jurl_request_adapter,
-                        jobject jchunk_byte_buffer,
+                        const JavaParamRef<jobject>& jchunk_byte_buffer,
                         jint jchunk_size,
                         jboolean jis_last_chunk) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   DCHECK(jchunk_byte_buffer);
 
   void* chunk = env->GetDirectBufferAddress(jchunk_byte_buffer);
   request_adapter->AppendChunk(reinterpret_cast<const char*>(chunk),
                                jchunk_size, jis_last_chunk);
 }
 
 /* synchronized */
-static void Start(JNIEnv* env, jobject jcaller, jlong jurl_request_adapter) {
+static void Start(JNIEnv* env,
+                  const JavaParamRef<jobject>& jcaller,
+                  jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   if (request_adapter != NULL)
     request_adapter->Start();
 }
 
 /* synchronized */
 static void DestroyRequestAdapter(JNIEnv* env,
-                                  jobject jcaller,
+                                  const JavaParamRef<jobject>& jcaller,
                                   jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   if (request_adapter != NULL)
     request_adapter->Destroy();
 }
 
 /* synchronized */
-static void Cancel(JNIEnv* env, jobject jcaller, jlong jurl_request_adapter) {
+static void Cancel(JNIEnv* env,
+                   const JavaParamRef<jobject>& jcaller,
+                   jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   if (request_adapter != NULL)
     request_adapter->Cancel();
 }
 
 static jint GetErrorCode(JNIEnv* env,
-                         jobject jcaller,
+                         const JavaParamRef<jobject>& jcaller,
                          jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   int error_code = request_adapter->error_code();
   switch (error_code) {
     // TODO(mef): Investigate returning success on positive values, too, as
     // they technically indicate success.
     case net::OK:
       return REQUEST_ERROR_SUCCESS;
@@ skipping 19 matching lines @@
       return REQUEST_ERROR_CONNECTION_TIMED_OUT;
 
     case net::ERR_NAME_NOT_RESOLVED:
       return REQUEST_ERROR_UNKNOWN_HOST;
     case net::ERR_TOO_MANY_REDIRECTS:
       return REQUEST_ERROR_TOO_MANY_REDIRECTS;
   }
   return REQUEST_ERROR_UNKNOWN;
 }
 
-static ScopedJavaLocalRef<jstring> GetErrorString(JNIEnv* env,
-                                                  jobject jcaller,
-                                                  jlong jurl_request_adapter) {
+static ScopedJavaLocalRef<jstring> GetErrorString(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   int error_code = request_adapter->error_code();
   char buffer[200];
   std::string error_string = net::ErrorToString(error_code);
   snprintf(buffer,
            sizeof(buffer),
            "System error: %s(%d)",
            error_string.c_str(),
            error_code);
   return ConvertUTF8ToJavaString(env, buffer);
 }
 
 static jint GetHttpStatusCode(JNIEnv* env,
-                              jobject jcaller,
+                              const JavaParamRef<jobject>& jcaller,
                               jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   return request_adapter->http_status_code();
 }
 
-static ScopedJavaLocalRef<jstring>
-GetHttpStatusText(JNIEnv* env, jobject jcaller, jlong jurl_request_adapter) {
+static ScopedJavaLocalRef<jstring> GetHttpStatusText(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   return ConvertUTF8ToJavaString(env, request_adapter->http_status_text());
 }
 
-static ScopedJavaLocalRef<jstring> GetContentType(JNIEnv* env,
-                                                  jobject jcaller,
-                                                  jlong jurl_request_adapter) {
+static ScopedJavaLocalRef<jstring> GetContentType(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   std::string type = request_adapter->content_type();
   if (!type.empty()) {
     return ConvertUTF8ToJavaString(env, type.c_str());
   } else {
     return ScopedJavaLocalRef<jstring>();
   }
 }
 
 static jlong GetContentLength(JNIEnv* env,
-                              jobject jcaller,
+                              const JavaParamRef<jobject>& jcaller,
                               jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   return request_adapter->content_length();
 }
 
-static ScopedJavaLocalRef<jstring> GetHeader(JNIEnv* env,
-                                             jobject jcaller,
-                                             jlong jurl_request_adapter,
-                                             jstring jheader_name) {
+static ScopedJavaLocalRef<jstring> GetHeader(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jlong jurl_request_adapter,
+    const JavaParamRef<jstring>& jheader_name) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
   std::string header_name = ConvertJavaStringToUTF8(env, jheader_name);
   std::string header_value = request_adapter->GetHeader(header_name);
   if (!header_value.empty())
     return ConvertUTF8ToJavaString(env, header_value.c_str());
   return ScopedJavaLocalRef<jstring>();
 }
 
 static void GetAllHeaders(JNIEnv* env,
-                          jobject jcaller,
+                          const JavaParamRef<jobject>& jcaller,
                           jlong jurl_request_adapter,
-                          jobject jheaders_map) {
+                          const JavaParamRef<jobject>& jheaders_map) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
 
   net::HttpResponseHeaders* headers = request_adapter->GetResponseHeaders();
   if (headers == NULL)
     return;
 
   void* iter = NULL;
   std::string header_name;
@@ skipping 10 matching lines @@
   // Some implementations (notably HttpURLConnection) include a mapping for the
   // null key; in HTTP's case, this maps to the HTTP status line.
   ScopedJavaLocalRef<jstring> status_line =
       ConvertUTF8ToJavaString(env, headers->GetStatusLine());
   Java_ChromiumUrlRequest_onAppendResponseHeader(env, jcaller, jheaders_map,
                                                  NULL, status_line.obj());
 }
 
 static ScopedJavaLocalRef<jstring> GetNegotiatedProtocol(
     JNIEnv* env,
-    jobject jcaller,
+    const JavaParamRef<jobject>& jcaller,
     jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
 
   std::string negotiated_protocol = request_adapter->GetNegotiatedProtocol();
   return ConvertUTF8ToJavaString(env, negotiated_protocol.c_str());
 }
 
 static jboolean GetWasCached(JNIEnv* env,
-                             jobject jcaller,
+                             const JavaParamRef<jobject>& jcaller,
                              jlong jurl_request_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter);
   DCHECK(request_adapter);
 
   bool was_cached = request_adapter->GetWasCached();
   return was_cached ? JNI_TRUE : JNI_FALSE;
 }
 
-static void DisableRedirects(JNIEnv* env, jobject jcaller,
+static void DisableRedirects(JNIEnv* env,
+                             const JavaParamRef<jobject>& jcaller,
                              jlong jrequest_adapter) {
   URLRequestAdapter* request_adapter =
       reinterpret_cast<URLRequestAdapter*>(jrequest_adapter);
   DCHECK(request_adapter);
   request_adapter->DisableRedirects();
 }
 
 }  // namespace cronet