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

chrome/browser/android/tab_android.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 "chrome/browser/android/tab_android.h"
 
 #include <stddef.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 117 matching lines @@
     : weak_java_tab_(env, obj),
       content_layer_(cc::Layer::Create()),
       tab_content_manager_(NULL),
       synced_tab_delegate_(new browser_sync::SyncedTabDelegateAndroid(this)) {
   Java_Tab_setNativePtr(env, obj, reinterpret_cast<intptr_t>(this));
 }
 
 TabAndroid::~TabAndroid() {
   GetContentLayer()->RemoveAllChildren();
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Tab_clearNativePtr(env, weak_java_tab_.get(env).obj());
+  Java_Tab_clearNativePtr(env, weak_java_tab_.get(env));
 }
 
 base::android::ScopedJavaLocalRef<jobject> TabAndroid::GetJavaObject() {
   JNIEnv* env = base::android::AttachCurrentThread();
   return weak_java_tab_.get(env);
 }
 
 scoped_refptr<cc::Layer> TabAndroid::GetContentLayer() const {
   return content_layer_;
 }
 
 int TabAndroid::GetAndroidId() const {
   JNIEnv* env = base::android::AttachCurrentThread();
-  return Java_Tab_getId(env, weak_java_tab_.get(env).obj());
+  return Java_Tab_getId(env, weak_java_tab_.get(env));
 }
 
 int TabAndroid::GetSyncId() const {
   JNIEnv* env = base::android::AttachCurrentThread();
-  return Java_Tab_getSyncId(env, weak_java_tab_.get(env).obj());
+  return Java_Tab_getSyncId(env, weak_java_tab_.get(env));
 }
 
 base::string16 TabAndroid::GetTitle() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   return base::android::ConvertJavaStringToUTF16(
-      Java_Tab_getTitle(env, weak_java_tab_.get(env).obj()));
+      Java_Tab_getTitle(env, weak_java_tab_.get(env)));
 }
 
 GURL TabAndroid::GetURL() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   return GURL(base::android::ConvertJavaStringToUTF8(
-      Java_Tab_getUrl(env, weak_java_tab_.get(env).obj())));
+      Java_Tab_getUrl(env, weak_java_tab_.get(env))));
 }
 
 bool TabAndroid::LoadIfNeeded() {
   JNIEnv* env = base::android::AttachCurrentThread();
-  return Java_Tab_loadIfNeeded(env, weak_java_tab_.get(env).obj());
+  return Java_Tab_loadIfNeeded(env, weak_java_tab_.get(env));
 }
 
 Profile* TabAndroid::GetProfile() const {
   if (!web_contents())
     return NULL;
 
   return Profile::FromBrowserContext(web_contents()->GetBrowserContext());
 }
 
 browser_sync::SyncedTabDelegate* TabAndroid::GetSyncedTabDelegate() const {
   return synced_tab_delegate_.get();
 }
 
 void TabAndroid::SetWindowSessionID(SessionID::id_type window_id) {
   session_window_id_.set_id(window_id);
 
   if (!web_contents())
     return;
 
   SessionTabHelper* session_tab_helper =
           SessionTabHelper::FromWebContents(web_contents());
   session_tab_helper->SetWindowID(session_window_id_);
 }
 
 void TabAndroid::SetSyncId(int sync_id) {
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Tab_setSyncId(env, weak_java_tab_.get(env).obj(), sync_id);
+  Java_Tab_setSyncId(env, weak_java_tab_.get(env), sync_id);
 }
 
 void TabAndroid::HandlePopupNavigation(chrome::NavigateParams* params) {
   DCHECK(params->source_contents == web_contents());
   DCHECK(params->target_contents == NULL ||
          params->target_contents == web_contents());
 
   WindowOpenDisposition disposition = params->disposition;
   const GURL& url = params->url;
 
   if (disposition == NEW_POPUP ||
       disposition == NEW_FOREGROUND_TAB ||
       disposition == NEW_BACKGROUND_TAB ||
       disposition == NEW_WINDOW ||
       disposition == OFF_THE_RECORD) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jobject> jobj = weak_java_tab_.get(env);
     ScopedJavaLocalRef<jstring> jurl(ConvertUTF8ToJavaString(env, url.spec()));
     ScopedJavaLocalRef<jstring> jheaders(
         ConvertUTF8ToJavaString(env, params->extra_headers));
     ScopedJavaLocalRef<jobject> jpost_data;
     if (params->uses_post && params->post_data)
       jpost_data = params->post_data->ToJavaObject(env);
-    Java_Tab_openNewTab(env,
-                        jobj.obj(),
-                        jurl.obj(),
-                        jheaders.obj(),
-                        jpost_data.obj(),
-                        disposition,
+    Java_Tab_openNewTab(env, jobj, jurl, jheaders, jpost_data, disposition,
                         params->created_with_opener,
                         params->is_renderer_initiated);
   } else {
     NOTIMPLEMENTED();
   }
 }
 
 bool TabAndroid::HasPrerenderedUrl(GURL gurl) {
   prerender::PrerenderManager* prerender_manager = GetPrerenderManager();
   if (!prerender_manager)
@@ skipping 11 matching lines @@
     }
   }
   return false;
 }
 
 void TabAndroid::SwapTabContents(content::WebContents* old_contents,
                                  content::WebContents* new_contents,
                                  bool did_start_load,
                                  bool did_finish_load) {
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Tab_swapWebContents(
-      env,
-      weak_java_tab_.get(env).obj(),
-      new_contents->GetJavaWebContents().obj(),
-      did_start_load,
-      did_finish_load);
+  Java_Tab_swapWebContents(env, weak_java_tab_.get(env),
+                           new_contents->GetJavaWebContents(), did_start_load,
+                           did_finish_load);
 }
 
 void TabAndroid::DefaultSearchProviderChanged(
     bool google_base_url_domain_changed) {
   // TODO(kmadhusu): Move this function definition to a common place and update
   // BrowserInstantController::DefaultSearchProviderChanged to use the same.
   if (!web_contents())
     return;
 
   InstantService* instant_service =
@@ skipping 18 matching lines @@
   InfoBarService::FromWebContents(web_contents())->set_ignore_next_reload();
 }
 
 void TabAndroid::OnWebContentsInstantSupportDisabled(
     const content::WebContents* contents) {
   DCHECK(contents);
   if (web_contents() != contents)
     return;
 
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Tab_onWebContentsInstantSupportDisabled(env,
-                                               weak_java_tab_.get(env).obj());
+  Java_Tab_onWebContentsInstantSupportDisabled(env, weak_java_tab_.get(env));
 }
 
 void TabAndroid::Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details) {
   JNIEnv* env = base::android::AttachCurrentThread();
   switch (type) {
     case chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED: {
       TabSpecificContentSettings* settings =
           TabSpecificContentSettings::FromWebContents(web_contents());
       if (!settings->IsBlockageIndicated(CONTENT_SETTINGS_TYPE_POPUPS)) {
         // TODO(dfalcantara): Create an InfoBarDelegate to keep the
         // PopupBlockedInfoBar logic native-side instead of straddling the JNI
         // boundary.
         int num_popups = 0;
         PopupBlockerTabHelper* popup_blocker_helper =
             PopupBlockerTabHelper::FromWebContents(web_contents());
         if (popup_blocker_helper)
           num_popups = popup_blocker_helper->GetBlockedPopupsCount();
 
         if (num_popups > 0)
           PopupBlockedInfoBarDelegate::Create(web_contents(), num_popups);
 
         settings->SetBlockageHasBeenIndicated(CONTENT_SETTINGS_TYPE_POPUPS);
       }
       break;
     }
     case content::NOTIFICATION_NAV_ENTRY_CHANGED:
-      Java_Tab_onNavEntryChanged(env, weak_java_tab_.get(env).obj());
+      Java_Tab_onNavEntryChanged(env, weak_java_tab_.get(env));
       break;
     default:
       NOTREACHED() << "Unexpected notification " << type;
       break;
   }
 }
 
 void TabAndroid::OnFaviconUpdated(favicon::FaviconDriver* favicon_driver,
                                   NotificationIconType notification_icon_type,
                                   const GURL& icon_url,
                                   bool icon_url_changed,
                                   const gfx::Image& image) {
   if (notification_icon_type != NON_TOUCH_LARGEST &&
       notification_icon_type != TOUCH_LARGEST) {
     return;
   }
 
   SkBitmap favicon = image.AsImageSkia().GetRepresentation(1.0f).sk_bitmap();
   if (favicon.empty())
     return;
 
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Tab_onFaviconAvailable(env, weak_java_tab_.get(env).obj(),
-                              gfx::ConvertToJavaBitmap(&favicon).obj());
+  Java_Tab_onFaviconAvailable(env, weak_java_tab_.get(env),
+                              gfx::ConvertToJavaBitmap(&favicon));
 }
 
 void TabAndroid::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
 void TabAndroid::InitWebContents(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     jboolean incognito,
@@ skipping 263 matching lines @@
       printing::PrintViewManagerBasic::FromWebContents(web_contents());
   if (print_view_manager == NULL)
     return false;
 
   print_view_manager->PrintNow();
   return true;
 }
 
 void TabAndroid::SetPendingPrint() {
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Tab_setPendingPrint(env, weak_java_tab_.get(env).obj());
+  Java_Tab_setPendingPrint(env, weak_java_tab_.get(env));
 }
 
 ScopedJavaLocalRef<jobject> TabAndroid::GetFavicon(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
   ScopedJavaLocalRef<jobject> bitmap;
   favicon::FaviconDriver* favicon_driver =
       favicon::ContentFaviconDriver::FromWebContents(web_contents_.get());
 
   if (!favicon_driver)
@@ skipping 112 matching lines @@
     if (only_editable && !managed->CanBeEditedByUser(nodes[i]))
       continue;
     return nodes[i]->id();
   }
 
   return -1;
 }
 
 void TabAndroid::ShowOfflinePages() {
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Tab_showOfflinePages(env, weak_java_tab_.get(env).obj());
+  Java_Tab_showOfflinePages(env, weak_java_tab_.get(env));
 }
 
 void TabAndroid::OnLoFiResponseReceived(bool is_preview) {
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_Tab_onLoFiResponseReceived(env, weak_java_tab_.get(env).obj(),
-                                  is_preview);
+  Java_Tab_onLoFiResponseReceived(env, weak_java_tab_.get(env), is_preview);
 }
 
 jboolean TabAndroid::IsOfflinePage(JNIEnv* env,
                                    const JavaParamRef<jobject>& obj) {
   return offline_pages::OfflinePageUtils::GetOfflinePageFromWebContents(
       web_contents()) != nullptr;
 }
 
 ScopedJavaLocalRef<jobject> TabAndroid::GetOfflinePage(
     JNIEnv* env,
@@ skipping 90 matching lines @@
 static void Init(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   TRACE_EVENT0("native", "TabAndroid::Init");
   // This will automatically bind to the Java object and pass ownership there.
   new TabAndroid(env, obj);
 }
 
 // static
 bool TabAndroid::RegisterTabAndroid(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }