Pass method parameters as JavaParamRef in android_webview.

android_webview/native/aw_contents.cc

 // Copyright 2012 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 "android_webview/native/aw_contents.h"
 
 #include <limits>
 
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_browser_main_parts.h"
@@ skipping 195 matching lines @@
 
   AwAutofillClient* autofill_manager_delegate =
       AwAutofillClient::FromWebContents(web_contents_.get());
   if (autofill_manager_delegate)
     InitAutofillIfNecessary(autofill_manager_delegate->GetSaveFormData());
   content::SynchronousCompositor::SetClientForWebContents(
       web_contents_.get(), &browser_view_renderer_);
   AwContentsLifecycleNotifier::OnWebViewCreated();
 }
 
-void AwContents::SetJavaPeers(JNIEnv* env,
-                              jobject obj,
-                              jobject aw_contents,
-                              jobject web_contents_delegate,
-                              jobject contents_client_bridge,
-                              jobject io_thread_client,
-                              jobject intercept_navigation_delegate) {
+void AwContents::SetJavaPeers(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jobject>& aw_contents,
+    const JavaParamRef<jobject>& web_contents_delegate,
+    const JavaParamRef<jobject>& contents_client_bridge,
+    const JavaParamRef<jobject>& io_thread_client,
+    const JavaParamRef<jobject>& intercept_navigation_delegate) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // The |aw_content| param is technically spurious as it duplicates |obj| but
   // is passed over anyway to make the binding more explicit.
   java_ref_ = JavaObjectWeakGlobalRef(env, aw_contents);
 
   web_contents_delegate_.reset(
       new AwWebContentsDelegate(env, web_contents_delegate));
   web_contents_->SetDelegate(web_contents_delegate_.get());
 
   contents_client_bridge_.reset(
       new AwContentsClientBridge(env, contents_client_bridge));
   AwContentsClientBridgeBase::Associate(web_contents_.get(),
                                         contents_client_bridge_.get());
 
-  AwContentsIoThreadClientImpl::Associate(
-      web_contents_.get(), ScopedJavaLocalRef<jobject>(env, io_thread_client));
+  AwContentsIoThreadClientImpl::Associate(web_contents_.get(),

[Torne, 2015/12/03 14:56:30]

manual change here: no need to construct a temporary ScopedJavaLocalRef any
more, can just pass the existing JavaRef.

[sgurun-gerrit only, 2015/12/03 22:21:38]

yes. Although I did not see any reason for creating the temporary when it was
first written -- one could as well pass it as jobject.

+                                          io_thread_client);
 
   InterceptNavigationDelegate::Associate(
       web_contents_.get(),
       make_scoped_ptr(new InterceptNavigationDelegate(
           env, intercept_navigation_delegate)));
 
   // Finally, having setup the associations, release any deferred requests
   web_contents_->ForEachFrame(base::Bind(&OnIoThreadClientReady));
 }
 
@@ skipping 47 matching lines @@
   // without ever using another WebView.
   if (instance_count == 0) {
     // TODO(timvolodine): consider moving NotifyMemoryPressure to
     // AwContentsLifecycleNotifier (crbug.com/522988).
     base::MemoryPressureListener::NotifyMemoryPressure(
         base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
   }
   AwContentsLifecycleNotifier::OnWebViewDestroyed();
 }
 
-base::android::ScopedJavaLocalRef<jobject>
-AwContents::GetWebContents(JNIEnv* env, jobject obj) {
+base::android::ScopedJavaLocalRef<jobject> AwContents::GetWebContents(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(web_contents_);
   if (!web_contents_)
     return base::android::ScopedJavaLocalRef<jobject>();
 
   return web_contents_->GetJavaWebContents();
 }
 
-void AwContents::Destroy(JNIEnv* env, jobject obj) {
+void AwContents::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   java_ref_.reset();
   delete this;
 }
 
 static jlong Init(JNIEnv* env,
                   const JavaParamRef<jclass>&,
                   const JavaParamRef<jobject>& browser_context) {
   // TODO(joth): Use |browser_context| to get the native BrowserContext, rather
   // than hard-code the default instance lookup here.
   scoped_ptr<WebContents> web_contents(content::WebContents::Create(
@@ skipping 23 matching lines @@
 
 static jlong GetAwDrawGLFunction(JNIEnv* env, const JavaParamRef<jclass>&) {
   return reinterpret_cast<intptr_t>(&DrawGLFunction);
 }
 
 // static
 jint GetNativeInstanceCount(JNIEnv* env, const JavaParamRef<jclass>&) {
   return base::subtle::NoBarrier_Load(&g_instance_count);
 }
 
-jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
+jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env,
+                                         const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return reinterpret_cast<intptr_t>(
       browser_view_renderer_.GetAwDrawGLViewContext());
 }
 
 namespace {
 void DocumentHasImagesCallback(const ScopedJavaGlobalRef<jobject>& message,
                                bool has_images) {
   Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(),
                                               has_images,
                                               message.obj());
 }
 }  // namespace
 
-void AwContents::DocumentHasImages(JNIEnv* env, jobject obj, jobject message) {
+void AwContents::DocumentHasImages(JNIEnv* env,
+                                   const JavaParamRef<jobject>& obj,
+                                   const JavaParamRef<jobject>& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ScopedJavaGlobalRef<jobject> j_message;
   j_message.Reset(env, message);
   render_view_host_ext_->DocumentHasImages(
       base::Bind(&DocumentHasImagesCallback, j_message));
 }
 
 namespace {
 void GenerateMHTMLCallback(ScopedJavaGlobalRef<jobject>* callback,
                            const base::FilePath& path, int64 size) {
   JNIEnv* env = AttachCurrentThread();
   // Android files are UTF8, so the path conversion below is safe.
   Java_AwContents_generateMHTMLCallback(
       env,
       ConvertUTF8ToJavaString(env, path.AsUTF8Unsafe()).obj(),
       size, callback->obj());
 }
 }  // namespace
 
-void AwContents::GenerateMHTML(JNIEnv* env, jobject obj,
-                               jstring jpath, jobject callback) {
+void AwContents::GenerateMHTML(JNIEnv* env,
+                               const JavaParamRef<jobject>& obj,
+                               const JavaParamRef<jstring>& jpath,
+                               const JavaParamRef<jobject>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ScopedJavaGlobalRef<jobject>* j_callback = new ScopedJavaGlobalRef<jobject>();
   j_callback->Reset(env, callback);
   base::FilePath target_path(ConvertJavaStringToUTF8(env, jpath));
   web_contents_->GenerateMHTML(
       target_path,
       base::Bind(&GenerateMHTMLCallback, base::Owned(j_callback), target_path));
 }
 
 void AwContents::CreatePdfExporter(JNIEnv* env,
-                                   jobject obj,
-                                   jobject pdfExporter) {
+                                   const JavaParamRef<jobject>& obj,
+                                   const JavaParamRef<jobject>& pdfExporter) {
   pdf_exporter_.reset(
       new AwPdfExporter(env,
                         pdfExporter,
                         web_contents_.get()));
 }
 
 bool AwContents::OnReceivedHttpAuthRequest(const JavaRef<jobject>& handler,
                                            const std::string& host,
                                            const std::string& realm) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
 
   ScopedJavaLocalRef<jstring> jhost = ConvertUTF8ToJavaString(env, host);
   ScopedJavaLocalRef<jstring> jrealm = ConvertUTF8ToJavaString(env, realm);
   devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
       "onReceivedHttpAuthRequest");
   Java_AwContents_onReceivedHttpAuthRequest(env, obj.obj(), handler.obj(),
       jhost.obj(), jrealm.obj());
   return true;
 }
 
 void AwContents::SetOffscreenPreRaster(bool enabled) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetOffscreenPreRaster(enabled);
 }
 
-void AwContents::AddVisitedLinks(JNIEnv* env,
-                                   jobject obj,
-                                   jobjectArray jvisited_links) {
+void AwContents::AddVisitedLinks(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jobjectArray>& jvisited_links) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::vector<base::string16> visited_link_strings;
   base::android::AppendJavaStringArrayToStringVector(
       env, jvisited_links, &visited_link_strings);
 
   std::vector<GURL> visited_link_gurls;
   std::vector<base::string16>::const_iterator itr;
   for (itr = visited_link_strings.begin(); itr != visited_link_strings.end();
        ++itr) {
     visited_link_gurls.push_back(GURL(*itr));
@@ skipping 45 matching lines @@
 
   GURL origin = requesting_frame.GetOrigin();
   bool show_prompt = pending_geolocation_prompts_.empty();
   pending_geolocation_prompts_.push_back(OriginCallback(origin, callback));
   if (show_prompt) {
     ShowGeolocationPromptHelper(java_ref_, origin);
   }
 }
 
 // Invoked from Java
-void AwContents::InvokeGeolocationCallback(JNIEnv* env,
-                                           jobject obj,
-                                           jboolean value,
-                                           jstring origin) {
+void AwContents::InvokeGeolocationCallback(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    jboolean value,
+    const JavaParamRef<jstring>& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (pending_geolocation_prompts_.empty())
     return;
 
   GURL callback_origin(base::android::ConvertJavaStringToUTF16(env, origin));
   if (callback_origin.GetOrigin() ==
       pending_geolocation_prompts_.front().first) {
     pending_geolocation_prompts_.front().second.Run(value);
     pending_geolocation_prompts_.pop_front();
     if (!pending_geolocation_prompts_.empty()) {
@@ skipping 54 matching lines @@
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_request = request->GetJavaObject();
   ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
   if (j_request.is_null() || j_ref.is_null())
     return;
 
   Java_AwContents_onPermissionRequestCanceled(
       env, j_ref.obj(), j_request.obj());
 }
 
-void AwContents::PreauthorizePermission(
-    JNIEnv* env,
-    jobject obj,
-    jstring origin,
-    jlong resources) {
+void AwContents::PreauthorizePermission(JNIEnv* env,
+                                        const JavaParamRef<jobject>& obj,
+                                        const JavaParamRef<jstring>& origin,
+                                        jlong resources) {
   permission_request_handler_->PreauthorizePermission(
       GURL(base::android::ConvertJavaStringToUTF8(env, origin)), resources);
 }
 
 void AwContents::RequestProtectedMediaIdentifierPermission(
     const GURL& origin,
     const base::Callback<void(bool)>& callback) {
   permission_request_handler_->SendRequest(
       scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
           origin, AwPermissionRequest::ProtectedMediaId, callback)));
@@ skipping 42 matching lines @@
   permission_request_handler_->SendRequest(
       scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
           origin, AwPermissionRequest::MIDISysex, callback)));
 }
 
 void AwContents::CancelMIDISysexPermissionRequests(const GURL& origin) {
   permission_request_handler_->CancelRequest(
       origin, AwPermissionRequest::AwPermissionRequest::MIDISysex);
 }
 
-void AwContents::FindAllAsync(JNIEnv* env, jobject obj, jstring search_string) {
+void AwContents::FindAllAsync(JNIEnv* env,
+                              const JavaParamRef<jobject>& obj,
+                              const JavaParamRef<jstring>& search_string) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   GetFindHelper()->FindAllAsync(ConvertJavaStringToUTF16(env, search_string));
 }
 
-void AwContents::FindNext(JNIEnv* env, jobject obj, jboolean forward) {
+void AwContents::FindNext(JNIEnv* env,
+                          const JavaParamRef<jobject>& obj,
+                          jboolean forward) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   GetFindHelper()->FindNext(forward);
 }
 
-void AwContents::ClearMatches(JNIEnv* env, jobject obj) {
+void AwContents::ClearMatches(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   GetFindHelper()->ClearMatches();
 }
 
-void AwContents::ClearCache(
-    JNIEnv* env,
-    jobject obj,
-    jboolean include_disk_files) {
+void AwContents::ClearCache(JNIEnv* env,
+                            const JavaParamRef<jobject>& obj,
+                            jboolean include_disk_files) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   render_view_host_ext_->ClearCache();
 
   if (include_disk_files) {
     RemoveHttpDiskCache(web_contents_->GetBrowserContext(),
                         web_contents_->GetRoutingID());
   }
 }
 
 FindHelper* AwContents::GetFindHelper() {
@@ skipping 77 matching lines @@
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null()) {
     devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
         "onNewPicture");
     Java_AwContents_onNewPicture(env, obj.obj());
   }
 }
 
 base::android::ScopedJavaLocalRef<jbyteArray> AwContents::GetCertificate(
     JNIEnv* env,
-    jobject obj) {
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   content::NavigationEntry* entry =
       web_contents_->GetController().GetLastCommittedEntry();
   if (!entry)
     return ScopedJavaLocalRef<jbyteArray>();
   // Get the certificate
   int cert_id = entry->GetSSL().cert_id;
   scoped_refptr<net::X509Certificate> cert;
   bool ok = content::CertStore::GetInstance()->RetrieveCert(cert_id, &cert);
   if (!ok)
     return ScopedJavaLocalRef<jbyteArray>();
 
   // Convert the certificate and return it
   std::string der_string;
   net::X509Certificate::GetDEREncoded(cert->os_cert_handle(), &der_string);
   return base::android::ToJavaByteArray(env,
       reinterpret_cast<const uint8*>(der_string.data()), der_string.length());
 }
 
 void AwContents::RequestNewHitTestDataAt(JNIEnv* env,
-                                         jobject obj,
+                                         const JavaParamRef<jobject>& obj,
                                          jfloat x,
                                          jfloat y,
                                          jfloat touch_major) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   gfx::PointF touch_center(x, y);
   gfx::SizeF touch_area(touch_major, touch_major);
   render_view_host_ext_->RequestNewHitTestDataAt(touch_center, touch_area);
 }
 
-void AwContents::UpdateLastHitTestData(JNIEnv* env, jobject obj) {
+void AwContents::UpdateLastHitTestData(JNIEnv* env,
+                                       const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!render_view_host_ext_->HasNewHitTestData()) return;
 
   const AwHitTestData& data = render_view_host_ext_->GetLastHitTestData();
   render_view_host_ext_->MarkHitTestDataRead();
 
   // Make sure to null the Java object if data is empty/invalid.
   ScopedJavaLocalRef<jstring> extra_data_for_type;
   if (data.extra_data_for_type.length())
     extra_data_for_type = ConvertUTF8ToJavaString(
@@ skipping 13 matching lines @@
 
   Java_AwContents_updateHitTestData(env,
                                     obj,
                                     data.type,
                                     extra_data_for_type.obj(),
                                     href.obj(),
                                     anchor_text.obj(),
                                     img_src.obj());
 }
 
-void AwContents::OnSizeChanged(JNIEnv* env, jobject obj,
-                               int w, int h, int ow, int oh) {
+void AwContents::OnSizeChanged(JNIEnv* env,
+                               const JavaParamRef<jobject>& obj,
+                               int w,
+                               int h,
+                               int ow,
+                               int oh) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.OnSizeChanged(w, h);
 }
 
-void AwContents::SetViewVisibility(JNIEnv* env, jobject obj, bool visible) {
+void AwContents::SetViewVisibility(JNIEnv* env,
+                                   const JavaParamRef<jobject>& obj,
+                                   bool visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetViewVisibility(visible);
 }
 
-void AwContents::SetWindowVisibility(JNIEnv* env, jobject obj, bool visible) {
+void AwContents::SetWindowVisibility(JNIEnv* env,
+                                     const JavaParamRef<jobject>& obj,
+                                     bool visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetWindowVisibility(visible);
 }
 
-void AwContents::SetIsPaused(JNIEnv* env, jobject obj, bool paused) {
+void AwContents::SetIsPaused(JNIEnv* env,
+                             const JavaParamRef<jobject>& obj,
+                             bool paused) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetIsPaused(paused);
   ContentViewCore* cvc =
       ContentViewCore::FromWebContents(web_contents_.get());
   if (cvc) {
     cvc->PauseOrResumeGeolocation(paused);
   }
 }
 
-void AwContents::OnAttachedToWindow(JNIEnv* env, jobject obj, int w, int h) {
+void AwContents::OnAttachedToWindow(JNIEnv* env,
+                                    const JavaParamRef<jobject>& obj,
+                                    int w,
+                                    int h) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.OnAttachedToWindow(w, h);
 }
 
-void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
+void AwContents::OnDetachedFromWindow(JNIEnv* env,
+                                      const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.OnDetachedFromWindow();
 }
 
-bool AwContents::IsVisible(JNIEnv* env, jobject obj) {
+bool AwContents::IsVisible(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   return browser_view_renderer_.IsClientVisible();
 }
 
 void AwContents::DetachFunctorFromView() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
     Java_AwContents_detachFunctorFromView(env, obj.obj());
 }
 
-base::android::ScopedJavaLocalRef<jbyteArray>
-AwContents::GetOpaqueState(JNIEnv* env, jobject obj) {
+base::android::ScopedJavaLocalRef<jbyteArray> AwContents::GetOpaqueState(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Required optimization in WebViewClassic to not save any state if
   // there has been no navigations.
   if (!web_contents_->GetController().GetEntryCount())
     return ScopedJavaLocalRef<jbyteArray>();
 
   base::Pickle pickle;
   if (!WriteToPickle(*web_contents_, &pickle)) {
     return ScopedJavaLocalRef<jbyteArray>();
   } else {
     return base::android::ToJavaByteArray(env,
        reinterpret_cast<const uint8*>(pickle.data()), pickle.size());
   }
 }
 
 jboolean AwContents::RestoreFromOpaqueState(
-    JNIEnv* env, jobject obj, jbyteArray state) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jbyteArray>& state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // TODO(boliu): This copy can be optimized out if this is a performance
   // problem.
   std::vector<uint8> state_vector;
   base::android::JavaByteArrayToByteVector(env, state, &state_vector);
 
   base::Pickle pickle(reinterpret_cast<const char*>(state_vector.data()),
                       state_vector.size());
   base::PickleIterator iterator(pickle);
 
   return RestoreFromPickle(&iterator, web_contents_.get());
 }
 
 bool AwContents::OnDraw(JNIEnv* env,
-                        jobject obj,
-                        jobject canvas,
+                        const JavaParamRef<jobject>& obj,
+                        const JavaParamRef<jobject>& canvas,
                         jboolean is_hardware_accelerated,
                         jint scroll_x,
                         jint scroll_y,
                         jint visible_left,
                         jint visible_top,
                         jint visible_right,
                         jint visible_bottom) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   gfx::Vector2d scroll(scroll_x, scroll_y);
   browser_view_renderer_.PrepareToDraw(
@@ skipping 35 matching lines @@
                  << "popup window is still pending.";
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, pending.release());
     return;
   }
   pending_contents_.reset(new AwContents(pending.Pass()));
   // Set dip_scale for pending contents, which is necessary for the later
   // SynchronousCompositor and InputHandler setup.
   pending_contents_->SetDipScaleInternal(browser_view_renderer_.dip_scale());
 }
 
-void AwContents::FocusFirstNode(JNIEnv* env, jobject obj) {
+void AwContents::FocusFirstNode(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   web_contents_->FocusThroughTabTraversal(false);
 }
 
-void AwContents::SetBackgroundColor(JNIEnv* env, jobject obj, jint color) {
+void AwContents::SetBackgroundColor(JNIEnv* env,
+                                    const JavaParamRef<jobject>& obj,
+                                    jint color) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   render_view_host_ext_->SetBackgroundColor(color);
 }
 
 void AwContents::OnComputeScroll(JNIEnv* env,
-                                 jobject obj,
+                                 const JavaParamRef<jobject>& obj,
                                  jlong animation_time_millis) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.OnComputeScroll(
       base::TimeTicks() +
       base::TimeDelta::FromMilliseconds(animation_time_millis));
 }
 
-jlong AwContents::ReleasePopupAwContents(JNIEnv* env, jobject obj) {
+jlong AwContents::ReleasePopupAwContents(JNIEnv* env,
+                                         const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return reinterpret_cast<intptr_t>(pending_contents_.release());
 }
 
 gfx::Point AwContents::GetLocationOnScreen() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return gfx::Point();
@@ skipping 41 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_AwContents_didOverscroll(env, obj.obj(), overscroll_delta.x(),
                                 overscroll_delta.y(), overscroll_velocity.x(),
                                 overscroll_velocity.y());
 }
 
-void AwContents::SetDipScale(JNIEnv* env, jobject obj, jfloat dip_scale) {
+void AwContents::SetDipScale(JNIEnv* env,
+                             const JavaParamRef<jobject>& obj,
+                             jfloat dip_scale) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SetDipScaleInternal(dip_scale);
 }
 
 void AwContents::SetDipScaleInternal(float dip_scale) {
   browser_view_renderer_.SetDipScale(dip_scale);
 }
 
-void AwContents::ScrollTo(JNIEnv* env, jobject obj, jint x, jint y) {
+void AwContents::ScrollTo(JNIEnv* env,
+                          const JavaParamRef<jobject>& obj,
+                          jint x,
+                          jint y) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.ScrollTo(gfx::Vector2d(x, y));
 }
 
 void AwContents::SmoothScroll(JNIEnv* env,
-                              jobject obj,
+                              const JavaParamRef<jobject>& obj,
                               jint target_x,
                               jint target_y,
                               jlong duration_ms) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   float scale = browser_view_renderer_.dip_scale() *
                 browser_view_renderer_.page_scale_factor();
   render_view_host_ext_->SmoothScroll(target_x / scale, target_y / scale,
                                       duration_ms);
 }
@@ skipping 13 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_AwContents_onWebLayoutContentsSizeChanged(
       env, obj.obj(), contents_size.width(), contents_size.height());
 }
 
 jlong AwContents::CapturePicture(JNIEnv* env,
-                                 jobject obj,
+                                 const JavaParamRef<jobject>& obj,
                                  int width,
                                  int height) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return reinterpret_cast<intptr_t>(
       new AwPicture(browser_view_renderer_.CapturePicture(width, height)));
 }
 
 void AwContents::EnableOnNewPicture(JNIEnv* env,
-                                    jobject obj,
+                                    const JavaParamRef<jobject>& obj,
                                     jboolean enabled) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.EnableOnNewPicture(enabled);
 }
 
 namespace {
 void InvokeVisualStateCallback(const JavaObjectWeakGlobalRef& java_ref,
                                jlong request_id,
                                ScopedJavaGlobalRef<jobject>* callback,
                                bool result) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref.get(env);
   if (obj.is_null())
      return;
   Java_AwContents_invokeVisualStateCallback(
       env, obj.obj(), callback->obj(), request_id);
 }
 }  // namespace
 
 void AwContents::InsertVisualStateCallback(
-    JNIEnv* env, jobject obj, jlong request_id, jobject callback) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    jlong request_id,
+    const JavaParamRef<jobject>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ScopedJavaGlobalRef<jobject>* j_callback = new ScopedJavaGlobalRef<jobject>();
   j_callback->Reset(env, callback);
   web_contents_->GetMainFrame()->InsertVisualStateCallback(
       base::Bind(&InvokeVisualStateCallback, java_ref_, request_id,
                  base::Owned(j_callback)));
 }
 
-void AwContents::ClearView(JNIEnv* env, jobject obj) {
+void AwContents::ClearView(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.ClearView();
 }
 
-void AwContents::SetExtraHeadersForUrl(JNIEnv* env, jobject obj,
-                                       jstring url, jstring jextra_headers) {
+void AwContents::SetExtraHeadersForUrl(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jstring>& url,
+    const JavaParamRef<jstring>& jextra_headers) {
   std::string extra_headers;
   if (jextra_headers)
     extra_headers = ConvertJavaStringToUTF8(env, jextra_headers);
   AwResourceContext* resource_context = static_cast<AwResourceContext*>(
       AwBrowserContext::FromWebContents(web_contents_.get())->
       GetResourceContext());
   resource_context->SetExtraHeaders(GURL(ConvertJavaStringToUTF8(env, url)),
                                     extra_headers);
 }
 
 void AwContents::SetJsOnlineProperty(JNIEnv* env,
-                                     jobject obj,
+                                     const JavaParamRef<jobject>& obj,
                                      jboolean network_up) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   render_view_host_ext_->SetJsOnlineProperty(network_up);
 }
 
 void AwContents::TrimMemory(JNIEnv* env,
-                            jobject obj,
+                            const JavaParamRef<jobject>& obj,
                             jint level,
                             jboolean visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.TrimMemory(level, visible);
 }
 
 // TODO(sgurun) add support for posting a frame whose name is known (only
 //               main frame is supported at this time, see crbug.com/389721)
-void AwContents::PostMessageToFrame(JNIEnv* env, jobject obj,
-    jstring frame_name, jstring message, jstring target_origin,
-    jintArray sent_ports) {
-
+void AwContents::PostMessageToFrame(JNIEnv* env,
+                                    const JavaParamRef<jobject>& obj,
+                                    const JavaParamRef<jstring>& frame_name,
+                                    const JavaParamRef<jstring>& message,
+                                    const JavaParamRef<jstring>& target_origin,
+                                    const JavaParamRef<jintArray>& sent_ports) {
   // Use an empty source origin for android webview.
   base::string16 source_origin;
   base::string16 j_target_origin(ConvertJavaStringToUTF16(env, target_origin));
   base::string16 j_message(ConvertJavaStringToUTF16(env, message));
   std::vector<int> j_ports;
 
   if (sent_ports != nullptr) {
     base::android::JavaIntArrayToIntVector(env, sent_ports, &j_ports);
     BrowserThread::PostTask(
         BrowserThread::IO,
@@ skipping 18 matching lines @@
   if (message_port_message_filter_.get() == nullptr) {
     message_port_message_filter_ =
         new AwMessagePortMessageFilter(
             web_contents_->GetMainFrame()->GetRoutingID());
     web_contents_->GetRenderProcessHost()->AddFilter(
         message_port_message_filter_.get());
   }
   return message_port_message_filter_;
 }
 
-void AwContents::CreateMessageChannel(JNIEnv* env, jobject obj,
-    jobjectArray ports) {
-
+void AwContents::CreateMessageChannel(JNIEnv* env,
+                                      const JavaParamRef<jobject>& obj,
+                                      const JavaParamRef<jobjectArray>& ports) {
   AwMessagePortServiceImpl::GetInstance()->CreateMessageChannel(env, ports,
       GetMessagePortMessageFilter());
 }
 
-void AwContents::GrantFileSchemeAccesstoChildProcess(JNIEnv* env, jobject obj) {
+void AwContents::GrantFileSchemeAccesstoChildProcess(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   content::ChildProcessSecurityPolicy::GetInstance()->GrantScheme(
       web_contents_->GetRenderProcessHost()->GetID(), url::kFileScheme);
 }
 
-void AwContents::ResumeLoadingCreatedPopupWebContents(JNIEnv* env,
-                                                      jobject obj) {
+void AwContents::ResumeLoadingCreatedPopupWebContents(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   web_contents_->ResumeLoadingCreatedWebContents();
 }
 
 void SetShouldDownloadFavicons(JNIEnv* env,
                                const JavaParamRef<jclass>& jclazz) {
   g_should_download_favicons = true;
 }
 
 }  // namespace android_webview