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

content/browser/web_contents/web_contents_android.cc

 // Copyright 2013 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 "content/browser/web_contents/web_contents_android.h"
 
 #include <stdint.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
@@ skipping 47 matching lines @@
 // destroyed WebContents object.
 base::LazyInstance<base::hash_set<WebContentsAndroid*> >::Leaky
     g_allocated_web_contents_androids = LAZY_INSTANCE_INITIALIZER;
 
 void JavaScriptResultCallback(const ScopedJavaGlobalRef<jobject>& callback,
                               const base::Value* result) {
   JNIEnv* env = base::android::AttachCurrentThread();
   std::string json;
   base::JSONWriter::Write(*result, &json);
   ScopedJavaLocalRef<jstring> j_json = ConvertUTF8ToJavaString(env, json);
-  Java_WebContentsImpl_onEvaluateJavaScriptResult(
-      env, j_json.obj(), callback.obj());
+  Java_WebContentsImpl_onEvaluateJavaScriptResult(env, j_json, callback);
 }
 
 struct AccessibilitySnapshotParams {
   AccessibilitySnapshotParams()
       : has_tree_data(false), should_select_leaf_nodes(false) {}
 
   bool has_tree_data;
   // The current text selection within this tree, if any, expressed as the
   // node ID and character offset of the anchor (selection start) and focus
   // (selection end).
@@ skipping 31 matching lines @@
 
   const gfx::Rect& absolute_rect = node->GetPageBoundsRect();
   gfx::Rect parent_relative_rect = absolute_rect;
   bool is_root = node->GetParent() == nullptr;
   if (!is_root) {
     parent_relative_rect.Offset(-parent_rect.OffsetFromOrigin());
   }
   ScopedJavaLocalRef<jobject> j_node =
       Java_WebContentsImpl_createAccessibilitySnapshotNode(
           env, parent_relative_rect.x(), parent_relative_rect.y(),
-          absolute_rect.width(), absolute_rect.height(), is_root, j_text.obj(),
-          color, bgcolor, size, text_style, j_class.obj());
+          absolute_rect.width(), absolute_rect.height(), is_root, j_text, color,
+          bgcolor, size, text_style, j_class);
 
   if (params->has_tree_data && node->PlatformIsLeaf()) {
     int start_selection = 0;
     int end_selection = 0;
     if (params->sel_anchor_object_id == node->GetId()) {
       start_selection = params->sel_anchor_offset;
       params->should_select_leaf_nodes = true;
     }
     if (params->should_select_leaf_nodes)
       end_selection = node->GetText().length();
 
     if (params->sel_focus_object_id == node->GetId()) {
       end_selection = params->sel_focus_offset;
       params->should_select_leaf_nodes = false;
     }
     if (end_selection > 0)
       Java_WebContentsImpl_setAccessibilitySnapshotSelection(
-          env, j_node.obj(), start_selection, end_selection);
+          env, j_node, start_selection, end_selection);
   }
 
   for (uint32_t i = 0; i < node->PlatformChildCount(); i++) {
     BrowserAccessibilityAndroid* child =
         static_cast<BrowserAccessibilityAndroid*>(
             node->PlatformGetChild(i));
     Java_WebContentsImpl_addAccessibilityNodeAsChild(
-        env, j_node.obj(),
-        WalkAXTreeDepthFirst(env, child, absolute_rect, params).obj());
+        env, j_node, WalkAXTreeDepthFirst(env, child, absolute_rect, params));
   }
   return j_node;
 }
 
 // Walks over the AXTreeUpdate and creates a light weight snapshot.
 void AXTreeSnapshotCallback(const ScopedJavaGlobalRef<jobject>& callback,
                             const ui::AXTreeUpdate& result) {
   JNIEnv* env = base::android::AttachCurrentThread();
   if (result.nodes.empty()) {
-    Java_WebContentsImpl_onAccessibilitySnapshot(env, nullptr, callback.obj());
+    Java_WebContentsImpl_onAccessibilitySnapshot(env, nullptr, callback);
     return;
   }
   std::unique_ptr<BrowserAccessibilityManagerAndroid> manager(
       static_cast<BrowserAccessibilityManagerAndroid*>(
           BrowserAccessibilityManager::Create(result, nullptr)));
   manager->set_prune_tree_for_screen_reader(false);
   BrowserAccessibilityAndroid* root =
       static_cast<BrowserAccessibilityAndroid*>(manager->GetRoot());
   AccessibilitySnapshotParams params;
   if (result.has_tree_data) {
     params.has_tree_data = true;
     params.sel_anchor_object_id = result.tree_data.sel_anchor_object_id;
     params.sel_anchor_offset = result.tree_data.sel_anchor_offset;
     params.sel_focus_object_id = result.tree_data.sel_focus_object_id;
     params.sel_focus_offset = result.tree_data.sel_focus_offset;
   }
   gfx::Rect parent_rect;
   ScopedJavaLocalRef<jobject> j_root =
       WalkAXTreeDepthFirst(env, root, parent_rect, &params);
-  Java_WebContentsImpl_onAccessibilitySnapshot(
-      env, j_root.obj(), callback.obj());
+  Java_WebContentsImpl_onAccessibilitySnapshot(env, j_root, callback);
 }
 
 }  // namespace
 
 // static
 WebContents* WebContents::FromJavaWebContents(
     jobject jweb_contents_android) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!jweb_contents_android)
     return NULL;
@@ skipping 48 matching lines @@
 }
 
 WebContentsAndroid::WebContentsAndroid(WebContentsImpl* web_contents)
     : web_contents_(web_contents),
       navigation_controller_(&(web_contents->GetController())),
       synchronous_compositor_client_(nullptr),
       weak_factory_(this) {
   g_allocated_web_contents_androids.Get().insert(this);
   JNIEnv* env = AttachCurrentThread();
   obj_.Reset(env,
-             Java_WebContentsImpl_create(
-                 env,
-                 reinterpret_cast<intptr_t>(this),
-                 navigation_controller_.GetJavaObject().obj()).obj());
+             Java_WebContentsImpl_create(env, reinterpret_cast<intptr_t>(this),
+                                         navigation_controller_.GetJavaObject())
+                 .obj());
   RendererPreferences* prefs = web_contents_->GetMutableRendererPrefs();
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   prefs->network_contry_iso =
       command_line->HasSwitch(switches::kNetworkCountryIso) ?
           command_line->GetSwitchValueASCII(switches::kNetworkCountryIso)
           : net::android::GetTelephonyNetworkCountryIso();
 }
 
 WebContentsAndroid::~WebContentsAndroid() {
   DCHECK(g_allocated_web_contents_androids.Get().find(this) !=
       g_allocated_web_contents_androids.Get().end());
   g_allocated_web_contents_androids.Get().erase(this);
-  Java_WebContentsImpl_clearNativePtr(AttachCurrentThread(), obj_.obj());
+  Java_WebContentsImpl_clearNativePtr(AttachCurrentThread(), obj_);
 }
 
 base::android::ScopedJavaLocalRef<jobject>
 WebContentsAndroid::GetJavaObject() {
   return base::android::ScopedJavaLocalRef<jobject>(obj_);
 }
 
 ScopedJavaLocalRef<jstring> WebContentsAndroid::GetTitle(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) const {
@@ skipping 412 matching lines @@
 
 void WebContentsAndroid::OnFinishGetContentBitmap(
     ScopedJavaGlobalRef<jobject>* obj,
     ScopedJavaGlobalRef<jobject>* callback,
     const SkBitmap& bitmap,
     ReadbackResponse response) {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> java_bitmap;
   if (response == READBACK_SUCCESS)
     java_bitmap = gfx::ConvertToJavaBitmap(&bitmap);
-  Java_WebContentsImpl_onGetContentBitmapFinished(env,
-                                                  obj->obj(),
-                                                  callback->obj(),
-                                                  java_bitmap.obj(),
-                                                  response);
+  Java_WebContentsImpl_onGetContentBitmapFinished(
+      env, obj->obj(), callback->obj(), java_bitmap, response);
 }
 
 void WebContentsAndroid::OnFinishDownloadImage(
     base::android::ScopedJavaGlobalRef<jobject>* obj,
     base::android::ScopedJavaGlobalRef<jobject>* callback,
     int id,
     int http_status_code,
     const GURL& url,
     const std::vector<SkBitmap>& bitmaps,
     const std::vector<gfx::Size>& sizes) {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> jbitmaps =
       Java_WebContentsImpl_createBitmapList(env);
   ScopedJavaLocalRef<jobject> jsizes =
       Java_WebContentsImpl_createSizeList(env);
   ScopedJavaLocalRef<jstring> jurl =
       base::android::ConvertUTF8ToJavaString(env, url.spec());
 
   for (const SkBitmap& bitmap : bitmaps) {
     // WARNING: convering to java bitmaps results in duplicate memory
     // allocations, which increases the chance of OOMs if DownloadImage() is
     // misused.
     ScopedJavaLocalRef<jobject> jbitmap = gfx::ConvertToJavaBitmap(&bitmap);
-    Java_WebContentsImpl_addToBitmapList(env, jbitmaps.obj(), jbitmap.obj());
+    Java_WebContentsImpl_addToBitmapList(env, jbitmaps, jbitmap);
   }
   for (const gfx::Size& size : sizes) {
-    Java_WebContentsImpl_createSizeAndAddToList(
-        env, jsizes.obj(), size.width(), size.height());
+    Java_WebContentsImpl_createSizeAndAddToList(env, jsizes, size.width(),
+                                                size.height());
   }
-  Java_WebContentsImpl_onDownloadImageFinished(
-      env, obj->obj(), callback->obj(), id,
-      http_status_code, jurl.obj(), jbitmaps.obj(), jsizes.obj());
+  Java_WebContentsImpl_onDownloadImageFinished(env, obj->obj(), callback->obj(),
+                                               id, http_status_code, jurl,
+                                               jbitmaps, jsizes);
 }
 }  // namespace content