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

components/web_contents_delegate_android/web_contents_delegate_android.cc

 // Copyright (c) 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 "components/web_contents_delegate_android/web_contents_delegate_android.h"
 
 #include <android/keycodes.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
@@ skipping 75 matching lines @@
       disposition == NEW_BACKGROUND_TAB ||
       disposition == OFF_THE_RECORD) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jstring> java_url =
         ConvertUTF8ToJavaString(env, url.spec());
     ScopedJavaLocalRef<jstring> extra_headers =
             ConvertUTF8ToJavaString(env, params.extra_headers);
     ScopedJavaLocalRef<jobject> post_data;
     if (params.uses_post && params.post_data)
       post_data = params.post_data->ToJavaObject(env);
-    Java_WebContentsDelegateAndroid_openNewTab(env,
-                                               obj.obj(),
-                                               java_url.obj(),
-                                               extra_headers.obj(),
-                                               post_data.obj(),
-                                               disposition,
-                                               params.is_renderer_initiated);
+    Java_WebContentsDelegateAndroid_openNewTab(
+        env, obj, java_url, extra_headers, post_data, disposition,
+        params.is_renderer_initiated);
     return NULL;
   }
 
   // content::OpenURLParams -> content::NavigationController::LoadURLParams
   content::NavigationController::LoadURLParams load_params(url);
   load_params.referrer = params.referrer;
   load_params.frame_tree_node_id = params.frame_tree_node_id;
   load_params.redirect_chain = params.redirect_chain;
   load_params.transition_type = params.transition;
   load_params.extra_headers = params.extra_headers;
@@ skipping 10 matching lines @@
 
   return source;
 }
 
 void WebContentsDelegateAndroid::NavigationStateChanged(
     WebContents* source, content::InvalidateTypes changed_flags) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_navigationStateChanged(
-      env,
-      obj.obj(),
-      changed_flags);
+  Java_WebContentsDelegateAndroid_navigationStateChanged(env, obj,
+                                                         changed_flags);
 }
 
 void WebContentsDelegateAndroid::VisibleSSLStateChanged(
     const WebContents* source) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_visibleSSLStateChanged(
-      env,
-      obj.obj());
+  Java_WebContentsDelegateAndroid_visibleSSLStateChanged(env, obj);
 }
 
 void WebContentsDelegateAndroid::ActivateContents(WebContents* contents) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_activateContents(env, obj.obj());
+  Java_WebContentsDelegateAndroid_activateContents(env, obj);
 }
 
 void WebContentsDelegateAndroid::LoadingStateChanged(WebContents* source,
     bool to_different_document) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
-  Java_WebContentsDelegateAndroid_loadingStateChanged(env,
-                                                      obj.obj(),
+  Java_WebContentsDelegateAndroid_loadingStateChanged(env, obj,
                                                       to_different_document);
 }
 
 void WebContentsDelegateAndroid::LoadProgressChanged(WebContents* source,
                                                      double progress) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_notifyLoadProgressChanged(
-      env,
-      obj.obj(),
-      progress);
+  Java_WebContentsDelegateAndroid_notifyLoadProgressChanged(env, obj, progress);
 }
 
 void WebContentsDelegateAndroid::RendererUnresponsive(WebContents* source) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_rendererUnresponsive(env, obj.obj());
+  Java_WebContentsDelegateAndroid_rendererUnresponsive(env, obj);
 }
 
 void WebContentsDelegateAndroid::RendererResponsive(WebContents* source) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_rendererResponsive(env, obj.obj());
+  Java_WebContentsDelegateAndroid_rendererResponsive(env, obj);
 }
 
 bool WebContentsDelegateAndroid::ShouldCreateWebContents(
     WebContents* web_contents,
     int32_t route_id,
     int32_t main_frame_route_id,
     int32_t main_frame_widget_route_id,
     WindowContainerType window_container_type,
     const std::string& frame_name,
     const GURL& target_url,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return true;
   ScopedJavaLocalRef<jstring> java_url =
       ConvertUTF8ToJavaString(env, target_url.spec());
-  return Java_WebContentsDelegateAndroid_shouldCreateWebContents(env, obj.obj(),
-      java_url.obj());
+  return Java_WebContentsDelegateAndroid_shouldCreateWebContents(env, obj,
+                                                                 java_url);
 }
 
 bool WebContentsDelegateAndroid::OnGoToEntryOffset(int offset) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return true;
-  return Java_WebContentsDelegateAndroid_onGoToEntryOffset(env, obj.obj(),
-      offset);
+  return Java_WebContentsDelegateAndroid_onGoToEntryOffset(env, obj, offset);
 }
 
 void WebContentsDelegateAndroid::WebContentsCreated(
     WebContents* source_contents, int opener_render_frame_id,
     const std::string& frame_name, const GURL& target_url,
     WebContents* new_contents) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
 
   ScopedJavaLocalRef<jobject> jsource_contents;
   if (source_contents)
     jsource_contents = source_contents->GetJavaWebContents();
   ScopedJavaLocalRef<jobject> jnew_contents;
   if (new_contents)
     jnew_contents = new_contents->GetJavaWebContents();
 
   Java_WebContentsDelegateAndroid_webContentsCreated(
-      env, obj.obj(), jsource_contents.obj(), opener_render_frame_id,
-      base::android::ConvertUTF8ToJavaString(env, frame_name).obj(),
-      base::android::ConvertUTF8ToJavaString(env, target_url.spec()).obj(),
-      jnew_contents.obj());
+      env, obj, jsource_contents, opener_render_frame_id,
+      base::android::ConvertUTF8ToJavaString(env, frame_name),
+      base::android::ConvertUTF8ToJavaString(env, target_url.spec()),
+      jnew_contents);
 }
 
 void WebContentsDelegateAndroid::CloseContents(WebContents* source) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_closeContents(env, obj.obj());
+  Java_WebContentsDelegateAndroid_closeContents(env, obj);
 }
 
 void WebContentsDelegateAndroid::MoveContents(WebContents* source,
                                               const gfx::Rect& pos) {
   // Do nothing.
 }
 
 bool WebContentsDelegateAndroid::AddMessageToConsole(
     WebContents* source,
     int32_t level,
@@ skipping 19 matching lines @@
     case logging::LOG_WARNING:
       jlevel = WEB_CONTENTS_DELEGATE_LOG_LEVEL_WARNING;
       break;
     case logging::LOG_ERROR:
       jlevel = WEB_CONTENTS_DELEGATE_LOG_LEVEL_ERROR;
       break;
     default:
       NOTREACHED();
   }
   return Java_WebContentsDelegateAndroid_addMessageToConsole(
-      env,
-      GetJavaDelegate(env).obj(),
-      jlevel,
-      jmessage.obj(),
-      line_no,
-      jsource_id.obj());
+      env, GetJavaDelegate(env), jlevel, jmessage, line_no, jsource_id);
 }
 
 // This is either called from TabContents::DidNavigateMainFramePostCommit() with
 // an empty GURL or responding to RenderViewHost::OnMsgUpateTargetURL(). In
 // Chrome, the latter is not always called, especially not during history
 // navigation. So we only handle the first case and pass the source TabContents'
 // url to Java to update the UI.
 void WebContentsDelegateAndroid::UpdateTargetURL(WebContents* source,
                                                  const GURL& url) {
   if (!url.is_empty())
     return;
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
   ScopedJavaLocalRef<jstring> java_url =
       ConvertUTF8ToJavaString(env, source->GetURL().spec());
-  Java_WebContentsDelegateAndroid_onUpdateUrl(env,
-                                              obj.obj(),
-                                              java_url.obj());
+  Java_WebContentsDelegateAndroid_onUpdateUrl(env, obj, java_url);
 }
 
 void WebContentsDelegateAndroid::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   jobject key_event = event.os_event;
   if (key_event) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
     if (obj.is_null())
       return;
-    Java_WebContentsDelegateAndroid_handleKeyboardEvent(
-        env, obj.obj(), key_event);
+    Java_WebContentsDelegateAndroid_handleKeyboardEvent(env, obj, key_event);
   }
 }
 
 bool WebContentsDelegateAndroid::TakeFocus(WebContents* source, bool reverse) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return WebContentsDelegate::TakeFocus(source, reverse);
-  return Java_WebContentsDelegateAndroid_takeFocus(
-      env, obj.obj(), reverse);
+  return Java_WebContentsDelegateAndroid_takeFocus(env, obj, reverse);
 }
 
 void WebContentsDelegateAndroid::ShowRepostFormWarningDialog(
     WebContents* source) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_showRepostFormWarningDialog(env, obj.obj());
+  Java_WebContentsDelegateAndroid_showRepostFormWarningDialog(env, obj);
 }
 
 void WebContentsDelegateAndroid::EnterFullscreenModeForTab(
     WebContents* web_contents,
     const GURL& origin) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_toggleFullscreenModeForTab(env, obj.obj(),
-                                                             true);
+  Java_WebContentsDelegateAndroid_toggleFullscreenModeForTab(env, obj, true);
 }
 
 void WebContentsDelegateAndroid::ExitFullscreenModeForTab(
     WebContents* web_contents) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return;
-  Java_WebContentsDelegateAndroid_toggleFullscreenModeForTab(env, obj.obj(),
-                                                             false);
+  Java_WebContentsDelegateAndroid_toggleFullscreenModeForTab(env, obj, false);
 }
 
 bool WebContentsDelegateAndroid::IsFullscreenForTabOrPending(
     const WebContents* web_contents) const {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = GetJavaDelegate(env);
   if (obj.is_null())
     return false;
-  return Java_WebContentsDelegateAndroid_isFullscreenForTabOrPending(
-      env, obj.obj());
+  return Java_WebContentsDelegateAndroid_isFullscreenForTabOrPending(env, obj);
 }
 
 void WebContentsDelegateAndroid::ShowValidationMessage(
     WebContents* web_contents,
     const gfx::Rect& anchor_in_root_view,
     const base::string16& main_text,
     const base::string16& sub_text) {
   RenderWidgetHostView* rwhv = web_contents->GetRenderWidgetHostView();
   if (rwhv) {
     validation_message_bubble_.reset(
@@ skipping 19 matching lines @@
     validation_message_bubble_->SetPositionRelativeToAnchor(
         rwhv->GetRenderWidgetHost(), anchor_in_root_view);
   }
 }
 
 void WebContentsDelegateAndroid::RequestAppBannerFromDevTools(
     content::WebContents* web_contents) {
 }
 
 }  // namespace web_contents_delegate_android