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

chrome/browser/android/bookmarks/bookmark_bridge.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 "chrome/browser/android/bookmarks/bookmark_bridge.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/android/jni_array.h"
@@ skipping 563 matching lines @@
   }
 
   if (folder == bookmark_model_->mobile_node() &&
       partner_bookmarks_shim_->HasPartnerBookmarks()) {
     ExtractBookmarkNodeInformation(
         partner_bookmarks_shim_->GetPartnerBookmarksRoot(),
         j_result_obj);
   }
 
   if (j_callback_obj) {
-    Java_BookmarksCallback_onBookmarksAvailable(
-        env, j_callback_obj, folder_id_obj.obj(), j_result_obj);
+    Java_BookmarksCallback_onBookmarksAvailable(env, j_callback_obj,
+                                                folder_id_obj, j_result_obj);
   }
 }
 
 jboolean BookmarkBridge::IsFolderVisible(JNIEnv* env,
                                           const JavaParamRef<jobject>& obj,
                                           jlong id,
                                           jint type) {
   if (type == BookmarkType::BOOKMARK_TYPE_NORMAL) {
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(
         bookmark_model_, static_cast<int64_t>(id));
@@ skipping 28 matching lines @@
           env, folder->id(), GetBookmarkType(folder));
 
   // Get the folder hierarchy.
   const BookmarkNode* node = folder;
   while (node) {
     ExtractBookmarkNodeInformation(node, j_result_obj);
     node = GetParentNode(node);
   }
 
   Java_BookmarksCallback_onBookmarksFolderHierarchyAvailable(
-      env, j_callback_obj, folder_id_obj.obj(), j_result_obj);
+      env, j_callback_obj, folder_id_obj, j_result_obj);
 }
 
 void BookmarkBridge::SearchBookmarks(JNIEnv* env,
                                       const JavaParamRef<jobject>& obj,
                                       const JavaParamRef<jobject>& j_list,
                                       const JavaParamRef<jstring>& j_query,
                                       jint max_results) {
   DCHECK(bookmark_model_->loaded());
 
   std::vector<bookmarks::BookmarkMatch> results;
@@ skipping 14 matching lines @@
 
     std::vector<int> url_match_start_positions;
     std::vector<int> url_match_end_positions;
     for (auto position : match.url_match_positions) {
       url_match_start_positions.push_back(position.first);
       url_match_end_positions.push_back(position.second);
     }
 
     Java_BookmarkBridge_addToBookmarkMatchList(
         env, j_list, node->id(), node->type(),
-        ToJavaIntArray(env, title_match_start_positions).obj(),
-        ToJavaIntArray(env, title_match_end_positions).obj(),
-        ToJavaIntArray(env, url_match_start_positions).obj(),
-        ToJavaIntArray(env, url_match_end_positions).obj());
+        ToJavaIntArray(env, title_match_start_positions),
+        ToJavaIntArray(env, title_match_end_positions),
+        ToJavaIntArray(env, url_match_start_positions),
+        ToJavaIntArray(env, url_match_end_positions));
   }
 }
 
 ScopedJavaLocalRef<jobject> BookmarkBridge::AddFolder(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobject>& j_parent_id_obj,
     jint index,
     const JavaParamRef<jstring>& j_title) {
   DCHECK(IsLoaded());
@@ skipping 129 matching lines @@
   JNIEnv* env = AttachCurrentThread();
 
   const BookmarkNode* parent = GetParentNode(node);
   int64_t parent_id = parent ? parent->id() : -1;
 
   std::string url;
   if (node->is_url())
     url = node->url().spec();
 
   return Java_BookmarkBridge_createBookmarkItem(
-      env,
-      node->id(),
-      GetBookmarkType(node),
-      ConvertUTF16ToJavaString(env, GetTitle(node)).obj(),
-      ConvertUTF8ToJavaString(env, url).obj(),
-      node->is_folder(),
-      parent_id,
-      GetBookmarkType(parent),
-      IsEditable(node),
-      IsManaged(node));
+      env, node->id(), GetBookmarkType(node),
+      ConvertUTF16ToJavaString(env, GetTitle(node)),
+      ConvertUTF8ToJavaString(env, url), node->is_folder(), parent_id,
+      GetBookmarkType(parent), IsEditable(node), IsManaged(node));
 }
 
 void BookmarkBridge::ExtractBookmarkNodeInformation(const BookmarkNode* node,
                                                      jobject j_result_obj) {
   JNIEnv* env = AttachCurrentThread();
   if (!IsReachable(node))
     return;
-  Java_BookmarkBridge_addToList(
-      env, j_result_obj, CreateJavaBookmark(node).obj());
+  Java_BookmarkBridge_addToList(env, j_result_obj, CreateJavaBookmark(node));
 }
 
 const BookmarkNode* BookmarkBridge::GetNodeByID(long node_id, int type) {
   const BookmarkNode* node;
   if (type == BookmarkType::BOOKMARK_TYPE_PARTNER) {
     node = partner_bookmarks_shim_->GetNodeByID(static_cast<int64_t>(node_id));
   } else {
     node = bookmarks::GetBookmarkNodeByID(bookmark_model_,
                                           static_cast<int64_t>(node_id));
   }
@@ skipping 16 matching lines @@
 bool BookmarkBridge::IsEditBookmarksEnabled() const {
   return profile_->GetPrefs()->GetBoolean(
       bookmarks::prefs::kEditBookmarksEnabled);
 }
 
 void BookmarkBridge::EditBookmarksEnabledChanged() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_editBookmarksEnabledChanged(env, obj.obj());
+  Java_BookmarkBridge_editBookmarksEnabledChanged(env, obj);
 }
 
 bool BookmarkBridge::IsEditable(const BookmarkNode* node) const {
   if (!node || (node->type() != BookmarkNode::FOLDER &&
       node->type() != BookmarkNode::URL)) {
     return false;
   }
   if (!IsEditBookmarksEnabled())
     return false;
   if (partner_bookmarks_shim_->IsPartnerBookmark(node))
@@ skipping 50 matching lines @@
       (signin && signin->IsAuthenticated());
 }
 
 void BookmarkBridge::NotifyIfDoneLoading() {
   if (!IsLoaded())
     return;
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_bookmarkModelLoaded(env, obj.obj());
+  Java_BookmarkBridge_bookmarkModelLoaded(env, obj);
 }
 
 // ------------- Observer-related methods ------------- //
 
 void BookmarkBridge::BookmarkModelChanged() {
   if (!IsLoaded())
     return;
 
   // Called when there are changes to the bookmark model. It is most
   // likely changes to the partner bookmarks.
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_bookmarkModelChanged(env, obj.obj());
+  Java_BookmarkBridge_bookmarkModelChanged(env, obj);
 }
 
 void BookmarkBridge::BookmarkModelLoaded(BookmarkModel* model,
                                           bool ids_reassigned) {
   NotifyIfDoneLoading();
 }
 
 void BookmarkBridge::BookmarkModelBeingDeleted(BookmarkModel* model) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_bookmarkModelDeleted(env, obj.obj());
+  Java_BookmarkBridge_bookmarkModelDeleted(env, obj);
 }
 
 void BookmarkBridge::BookmarkNodeMoved(BookmarkModel* model,
                                         const BookmarkNode* old_parent,
                                         int old_index,
                                         const BookmarkNode* new_parent,
                                         int new_index) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_BookmarkBridge_bookmarkNodeMoved(
-      env,
-      obj.obj(),
-      CreateJavaBookmark(old_parent).obj(),
-      old_index,
-      CreateJavaBookmark(new_parent).obj(),
-      new_index);
+      env, obj, CreateJavaBookmark(old_parent), old_index,
+      CreateJavaBookmark(new_parent), new_index);
 }
 
 void BookmarkBridge::BookmarkNodeAdded(BookmarkModel* model,
                                         const BookmarkNode* parent,
                                         int index) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_bookmarkNodeAdded(
-      env,
-      obj.obj(),
-      CreateJavaBookmark(parent).obj(),
-      index);
+  Java_BookmarkBridge_bookmarkNodeAdded(env, obj, CreateJavaBookmark(parent),
+                                        index);
 }
 
 void BookmarkBridge::BookmarkNodeRemoved(BookmarkModel* model,
                                           const BookmarkNode* parent,
                                           int old_index,
                                           const BookmarkNode* node,
                                           const std::set<GURL>& removed_urls) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_bookmarkNodeRemoved(
-      env,
-      obj.obj(),
-      CreateJavaBookmark(parent).obj(),
-      old_index,
-      CreateJavaBookmark(node).obj());
+  Java_BookmarkBridge_bookmarkNodeRemoved(env, obj, CreateJavaBookmark(parent),
+                                          old_index, CreateJavaBookmark(node));
 }
 
 void BookmarkBridge::BookmarkAllUserNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_bookmarkAllUserNodesRemoved(env, obj.obj());
+  Java_BookmarkBridge_bookmarkAllUserNodesRemoved(env, obj);
 }
 
 void BookmarkBridge::BookmarkNodeChanged(BookmarkModel* model,
                                           const BookmarkNode* node) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_bookmarkNodeChanged(
-      env,
-      obj.obj(),
-      CreateJavaBookmark(node).obj());
+  Java_BookmarkBridge_bookmarkNodeChanged(env, obj, CreateJavaBookmark(node));
 }
 
 void BookmarkBridge::BookmarkNodeChildrenReordered(BookmarkModel* model,
                                                     const BookmarkNode* node) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_bookmarkNodeChildrenReordered(
-      env,
-      obj.obj(),
-      CreateJavaBookmark(node).obj());
+  Java_BookmarkBridge_bookmarkNodeChildrenReordered(env, obj,
+                                                    CreateJavaBookmark(node));
 }
 
 void BookmarkBridge::ExtensiveBookmarkChangesBeginning(BookmarkModel* model) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_extensiveBookmarkChangesBeginning(env, obj.obj());
+  Java_BookmarkBridge_extensiveBookmarkChangesBeginning(env, obj);
 }
 
 void BookmarkBridge::ExtensiveBookmarkChangesEnded(BookmarkModel* model) {
   if (!IsLoaded())
     return;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_BookmarkBridge_extensiveBookmarkChangesEnded(env, obj.obj());
+  Java_BookmarkBridge_extensiveBookmarkChangesEnded(env, obj);
 }
 
 void BookmarkBridge::PartnerShimChanged(PartnerBookmarksShim* shim) {
   if (!IsLoaded())
     return;
 
   BookmarkModelChanged();
 }
 
 void BookmarkBridge::PartnerShimLoaded(PartnerBookmarksShim* shim) {
   NotifyIfDoneLoading();
 }
 
 void BookmarkBridge::ShimBeingDeleted(PartnerBookmarksShim* shim) {
   partner_bookmarks_shim_ = NULL;
 }