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

chrome/browser/android/foreign_session_helper.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/foreign_session_helper.h"
 
 #include <jni.h>
 #include <stddef.h>
 
 #include "base/android/jni_string.h"
@@ skipping 80 matching lines @@
   int selected_index = tab.normalized_navigation_index();
   DCHECK_GE(selected_index, 0);
   DCHECK_LT(selected_index, static_cast<int>(tab.navigations.size()));
 
   const sessions::SerializedNavigationEntry& current_navigation =
       tab.navigations.at(selected_index);
 
   GURL tab_url = current_navigation.virtual_url();
 
   Java_ForeignSessionHelper_pushTab(
-      env, j_window.obj(),
-      ConvertUTF8ToJavaString(env, tab_url.spec()).obj(),
-      ConvertUTF16ToJavaString(env, current_navigation.title()).obj(),
-      tab.timestamp.ToJavaTime(),
-      tab.tab_id.id());
+      env, j_window, ConvertUTF8ToJavaString(env, tab_url.spec()),
+      ConvertUTF16ToJavaString(env, current_navigation.title()),
+      tab.timestamp.ToJavaTime(), tab.tab_id.id());
 }
 
 void CopyWindowToJava(
     JNIEnv* env,
     const sessions::SessionWindow& window,
     ScopedJavaLocalRef<jobject>& j_window) {
   for (std::vector<sessions::SessionTab*>::const_iterator tab_it =
            window.tabs.begin(); tab_it != window.tabs.end(); ++tab_it) {
     const sessions::SessionTab &session_tab = **tab_it;
 
     if (ShouldSkipTab(session_tab))
       return;
 
     CopyTabToJava(env, session_tab, j_window);
   }
 }
 
 void CopySessionToJava(
     JNIEnv* env,
     const SyncedSession& session,
     ScopedJavaLocalRef<jobject>& j_session) {
   for (SyncedSession::SyncedWindowMap::const_iterator it =
       session.windows.begin(); it != session.windows.end(); ++it) {
     const sessions::SessionWindow &window = *(it->second);
 
     if (ShouldSkipWindow(window))
       continue;
 
     ScopedJavaLocalRef<jobject> last_pushed_window;
-    last_pushed_window.Reset(
-        Java_ForeignSessionHelper_pushWindow(
-            env, j_session.obj(),
-            window.timestamp.ToJavaTime(),
-            window.window_id.id()));
+    last_pushed_window.Reset(Java_ForeignSessionHelper_pushWindow(
+        env, j_session, window.timestamp.ToJavaTime(), window.window_id.id()));
 
     CopyWindowToJava(env, window, last_pushed_window);
   }
 }
 
 }  // namespace
 
 static jlong Init(JNIEnv* env,
                   const JavaParamRef<jclass>& clazz,
                   const JavaParamRef<jobject>& profile) {
@@ skipping 45 matching lines @@
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobject>& callback) {
   callback_.Reset(env, callback);
 }
 
 void ForeignSessionHelper::FireForeignSessionCallback() {
   if (callback_.is_null())
     return;
 
   JNIEnv* env = AttachCurrentThread();
-  Java_ForeignSessionCallback_onUpdated(env, callback_.obj());
+  Java_ForeignSessionCallback_onUpdated(env, callback_);
 }
 
 void ForeignSessionHelper::OnSyncConfigurationCompleted() {
   FireForeignSessionCallback();
 }
 
 void ForeignSessionHelper::OnForeignSessionUpdated() {
   FireForeignSessionCallback();
 }
 
@@ skipping 25 matching lines @@
   for (size_t i = 0; i < sessions.size(); ++i) {
     const sync_driver::SyncedSession& session = *(sessions[i]);
     if (ShouldSkipSession(session))
       continue;
 
     const bool is_collapsed = collapsed_sessions->HasKey(session.session_tag);
 
     if (is_collapsed)
       pref_collapsed_sessions->SetBoolean(session.session_tag, true);
 
-    last_pushed_session.Reset(
-        Java_ForeignSessionHelper_pushSession(
-            env,
-            result,
-            ConvertUTF8ToJavaString(env, session.session_tag).obj(),
-            ConvertUTF8ToJavaString(env, session.session_name).obj(),
-            session.device_type,
-            session.modified_time.ToJavaTime()));
+    last_pushed_session.Reset(Java_ForeignSessionHelper_pushSession(
+        env, result, ConvertUTF8ToJavaString(env, session.session_tag),
+        ConvertUTF8ToJavaString(env, session.session_name), session.device_type,
+        session.modified_time.ToJavaTime()));
 
     const std::string group_name =
         base::FieldTrialList::FindFullName("TabSyncByRecency");
     if (group_name == "Enabled") {
       // Create a custom window with tabs from all windows included and ordered
       // by recency (GetForeignSessionTabs will do ordering automatically).
       std::vector<const sessions::SessionTab*> tabs;
       open_tabs->GetForeignSessionTabs(session.session_tag, &tabs);
       ScopedJavaLocalRef<jobject> last_pushed_window(
           Java_ForeignSessionHelper_pushWindow(
-              env, last_pushed_session.obj(),
-              session.modified_time.ToJavaTime(), 0));
+              env, last_pushed_session, session.modified_time.ToJavaTime(), 0));
       for (const sessions::SessionTab* tab : tabs) {
          if (ShouldSkipTab(*tab))
            continue;
          CopyTabToJava(env, *tab, last_pushed_window);
       }
     } else {
       // Push the full session, with tabs ordered by visual position.
       CopySessionToJava(env, session, last_pushed_session);
     }
   }
@@ skipping 50 matching lines @@
     const JavaParamRef<jstring>& session_tag) {
   OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
   if (open_tabs)
     open_tabs->DeleteForeignSession(ConvertJavaStringToUTF8(env, session_tag));
 }
 
 // static
 bool ForeignSessionHelper::RegisterForeignSessionHelper(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }