Remove now-unnecessary .obj() in Java method calls.

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 <utility>
 
 #include "android_webview/browser/aw_browser_context.h"
@@ skipping 261 matching lines @@
       base::android::GetDefaultLocale(),
       AutofillManager::DISABLE_AUTOFILL_DOWNLOAD_MANAGER);
 }
 
 void AwContents::SetAwAutofillClient(jobject client) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_AwContents_setAwAutofillClient(env, obj.obj(), client);
+  Java_AwContents_setAwAutofillClient(env, obj, client);
 }
 
 AwContents::~AwContents() {
   DCHECK_EQ(this, AwContents::FromWebContents(web_contents_.get()));
   web_contents_->RemoveUserData(kAwContentsUserDataKey);
   if (find_helper_.get())
     find_helper_->SetListener(NULL);
   if (icon_helper_.get())
     icon_helper_->SetListener(NULL);
   base::subtle::Atomic32 instance_count =
@@ skipping 77 matching lines @@
                                      jlong function_table) {}
 
 // static
 jint GetNativeInstanceCount(JNIEnv* env, const JavaParamRef<jclass>&) {
   return base::subtle::NoBarrier_Load(&g_instance_count);
 }
 
 namespace {
 void DocumentHasImagesCallback(const ScopedJavaGlobalRef<jobject>& message,
                                bool has_images) {
-  Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(),
-                                              has_images,
-                                              message.obj());
+  Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(), has_images,
+                                              message);
 }
 }  // namespace
 
 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_t 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());
+      env, ConvertUTF8ToJavaString(env, path.AsUTF8Unsafe()), size,
+      callback->obj());
 }
 }  // namespace
 
 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);
@@ skipping 18 matching lines @@
   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());
+  Java_AwContents_onReceivedHttpAuthRequest(env, obj, handler, jhost, jrealm);
   return true;
 }
 
 void AwContents::SetOffscreenPreRaster(bool enabled) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetOffscreenPreRaster(enabled);
 }
 
 void AwContents::AddVisitedLinks(
     JNIEnv* env,
@@ skipping 23 matching lines @@
 
 void ShowGeolocationPromptHelperTask(const JavaObjectWeakGlobalRef& java_ref,
                                      const GURL& origin) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_ref = java_ref.get(env);
   if (j_ref.obj()) {
     ScopedJavaLocalRef<jstring> j_origin(
         ConvertUTF8ToJavaString(env, origin.spec()));
     devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
         "onGeolocationPermissionsShowPrompt");
-    Java_AwContents_onGeolocationPermissionsShowPrompt(env,
-                                                       j_ref.obj(),
-                                                       j_origin.obj());
+    Java_AwContents_onGeolocationPermissionsShowPrompt(env, j_ref, j_origin);
   }
 }
 
 void ShowGeolocationPromptHelper(const JavaObjectWeakGlobalRef& java_ref,
                                  const GURL& origin) {
   JNIEnv* env = AttachCurrentThread();
   if (java_ref.get(env).obj()) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI,
         FROM_HERE,
@@ skipping 53 matching lines @@
       ++it;
     }
   }
 
   if (removed_current_outstanding_callback) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
     if (j_ref.obj()) {
       devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
           "onGeolocationPermissionsHidePrompt");
-      Java_AwContents_onGeolocationPermissionsHidePrompt(env, j_ref.obj());
+      Java_AwContents_onGeolocationPermissionsHidePrompt(env, j_ref);
     }
     if (!pending_geolocation_prompts_.empty()) {
       ShowGeolocationPromptHelper(java_ref_,
                             pending_geolocation_prompts_.front().first);
     }
   }
 }
 
 void AwContents::OnPermissionRequest(
     base::android::ScopedJavaLocalRef<jobject> j_request,
     AwPermissionRequest* request) {
   DCHECK(!j_request.is_null());
   DCHECK(request);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
   if (j_ref.is_null()) {
     permission_request_handler_->CancelRequest(request->GetOrigin(),
                                                request->GetResources());
     return;
   }
 
-  Java_AwContents_onPermissionRequest(env, j_ref.obj(), j_request.obj());
+  Java_AwContents_onPermissionRequest(env, j_ref, j_request);
 }
 
 void AwContents::OnPermissionRequestCanceled(AwPermissionRequest* request) {
   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());
+  Java_AwContents_onPermissionRequestCanceled(env, j_ref, j_request);
 }
 
 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);
 }
 
@@ skipping 12 matching lines @@
 }
 
 void AwContents::RequestGeolocationPermission(
     const GURL& origin,
     const base::Callback<void(bool)>& callback) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
-  if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj.obj())) {
+  if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj)) {
     ShowGeolocationPrompt(origin, callback);
     return;
   }
   permission_request_handler_->SendRequest(
       std::unique_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
           origin, AwPermissionRequest::Geolocation, callback)));
 }
 
 void AwContents::CancelGeolocationPermissionRequests(const GURL& origin) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
-  if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj.obj())) {
+  if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj)) {
     HideGeolocationPrompt(origin);
     return;
   }
   permission_request_handler_->CancelRequest(
       origin, AwPermissionRequest::Geolocation);
 }
 
 void AwContents::RequestMIDISysexPermission(
     const GURL& origin,
     const base::Callback<void(bool)>& callback) {
@@ skipping 47 matching lines @@
 
 void AwContents::OnFindResultReceived(int active_ordinal,
                                       int match_count,
                                       bool finished) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
-  Java_AwContents_onFindResultReceived(
-      env, obj.obj(), active_ordinal, match_count, finished);
+  Java_AwContents_onFindResultReceived(env, obj, active_ordinal, match_count,
+                                       finished);
 }
 
 bool AwContents::ShouldDownloadFavicon(const GURL& icon_url) {
   return g_should_download_favicons;
 }
 
 void AwContents::OnReceivedIcon(const GURL& icon_url, const SkBitmap& bitmap) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
   content::NavigationEntry* entry =
       web_contents_->GetController().GetLastCommittedEntry();
 
   if (entry) {
     entry->GetFavicon().valid = true;
     entry->GetFavicon().url = icon_url;
     entry->GetFavicon().image = gfx::Image::CreateFrom1xBitmap(bitmap);
   }
 
-  Java_AwContents_onReceivedIcon(
-      env, obj.obj(), gfx::ConvertToJavaBitmap(&bitmap).obj());
+  Java_AwContents_onReceivedIcon(env, obj, gfx::ConvertToJavaBitmap(&bitmap));
 }
 
 void AwContents::OnReceivedTouchIconUrl(const std::string& url,
                                         bool precomposed) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
   Java_AwContents_onReceivedTouchIconUrl(
-      env, obj.obj(), ConvertUTF8ToJavaString(env, url).obj(), precomposed);
+      env, obj, ConvertUTF8ToJavaString(env, url), precomposed);
 }
 
 void AwContents::PostInvalidate() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
-    Java_AwContents_postInvalidateOnAnimation(env, obj.obj());
+    Java_AwContents_postInvalidateOnAnimation(env, obj);
 }
 
 void AwContents::OnNewPicture() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null()) {
     devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
         "onNewPicture");
-    Java_AwContents_onNewPicture(env, obj.obj());
+    Java_AwContents_onNewPicture(env, obj);
   }
 }
 
 base::android::ScopedJavaLocalRef<jbyteArray> AwContents::GetCertificate(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   content::NavigationEntry* entry =
       web_contents_->GetController().GetLastCommittedEntry();
   if (!entry)
@@ skipping 43 matching lines @@
     href = ConvertUTF16ToJavaString(env, data.href);
 
   ScopedJavaLocalRef<jstring> anchor_text;
   if (data.anchor_text.length())
     anchor_text = ConvertUTF16ToJavaString(env, data.anchor_text);
 
   ScopedJavaLocalRef<jstring> img_src;
   if (data.img_src.is_valid())
     img_src = ConvertUTF8ToJavaString(env, data.img_src.spec());
 
-  Java_AwContents_updateHitTestData(env,
-                                    obj,
-                                    data.type,
-                                    extra_data_for_type.obj(),
-                                    href.obj(),
-                                    anchor_text.obj(),
-                                    img_src.obj());
+  Java_AwContents_updateHitTestData(env, obj, data.type, extra_data_for_type,
+                                    href, anchor_text, img_src);
 }
 
 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);
@@ skipping 173 matching lines @@
 }
 
 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();
   std::vector<int> location;
   base::android::JavaIntArrayToIntVector(
-      env,
-      Java_AwContents_getLocationOnScreen(env, obj.obj()).obj(),
-      &location);
+      env, Java_AwContents_getLocationOnScreen(env, obj).obj(), &location);
   return gfx::Point(location[0], location[1]);
 }
 
 void AwContents::ScrollContainerViewTo(const gfx::Vector2d& new_value) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_AwContents_scrollContainerViewTo(
-      env, obj.obj(), new_value.x(), new_value.y());
+  Java_AwContents_scrollContainerViewTo(env, obj, new_value.x(), new_value.y());
 }
 
 void AwContents::UpdateScrollState(const gfx::Vector2d& max_scroll_offset,
                                    const gfx::SizeF& contents_size_dip,
                                    float page_scale_factor,
                                    float min_page_scale_factor,
                                    float max_page_scale_factor) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_AwContents_updateScrollState(env,
-                                    obj.obj(),
-                                    max_scroll_offset.x(),
-                                    max_scroll_offset.y(),
-                                    contents_size_dip.width(),
-                                    contents_size_dip.height(),
-                                    page_scale_factor,
-                                    min_page_scale_factor,
-                                    max_page_scale_factor);
+  Java_AwContents_updateScrollState(
+      env, obj, max_scroll_offset.x(), max_scroll_offset.y(),
+      contents_size_dip.width(), contents_size_dip.height(), page_scale_factor,
+      min_page_scale_factor, max_page_scale_factor);
 }
 
 void AwContents::DidOverscroll(const gfx::Vector2d& overscroll_delta,
                                const gfx::Vector2dF& overscroll_velocity) {
   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(),
+  Java_AwContents_didOverscroll(env, obj, overscroll_delta.x(),
                                 overscroll_delta.y(), overscroll_velocity.x(),
                                 overscroll_velocity.y());
 }
 
 void AwContents::SetDipScale(JNIEnv* env,
                              const JavaParamRef<jobject>& obj,
                              jfloat dip_scale) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SetDipScaleInternal(dip_scale);
 }
@@ skipping 22 matching lines @@
   render_view_host_ext_->SmoothScroll(target_x / scale, target_y / scale,
                                       duration_ms);
 }
 
 void AwContents::OnWebLayoutPageScaleFactorChanged(float page_scale_factor) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_AwContents_onWebLayoutPageScaleFactorChanged(env, obj.obj(),
-                                                         page_scale_factor);
+  Java_AwContents_onWebLayoutPageScaleFactorChanged(env, obj,
+                                                    page_scale_factor);
 }
 
 void AwContents::OnWebLayoutContentsSizeChanged(
     const gfx::Size& contents_size) {
   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());
+      env, obj, contents_size.width(), contents_size.height());
 }
 
 jlong AwContents::CapturePicture(JNIEnv* env,
                                  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,
                                     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);
+  Java_AwContents_invokeVisualStateCallback(env, obj, callback->obj(),
+                                            request_id);
 }
 }  // namespace
 
 void AwContents::InsertVisualStateCallback(
     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>();
@@ skipping 132 matching lines @@
   int routing_id = new_host->GetRoutingID();
   // At this point, the current RVH may or may not contain a compositor. So
   // compositor_ may be nullptr, in which case
   // BrowserViewRenderer::DidInitializeCompositor() callback is time when the
   // new compositor is constructed.
   browser_view_renderer_.SetActiveCompositorID(
       CompositorID(process_id, routing_id));
 }
 
 }  // namespace android_webview