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

content/browser/android/content_view_core_impl.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 "content/browser/android/content_view_core_impl.h"
 
 #include <stddef.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
@@ skipping 252 matching lines @@
   FOR_EACH_OBSERVER(ContentViewCoreImplObserver,
                     observer_list_,
                     OnContentViewCoreDestroyed());
   observer_list_.Clear();
 
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   java_ref_.reset();
   if (!j_obj.is_null()) {
     Java_ContentViewCore_onNativeContentViewCoreDestroyed(
-        env, j_obj.obj(), reinterpret_cast<intptr_t>(this));
+        env, j_obj, reinterpret_cast<intptr_t>(this));
   }
 }
 
 void ContentViewCoreImpl::UpdateWindowAndroid(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     jlong window_android) {
   if (window_android) {
     DCHECK(!view_.GetWindowAndroid());
     ui::WindowAndroid* window =
@@ skipping 47 matching lines @@
           SetContentViewCore(this);
   DCHECK(!web_contents_->GetUserData(kContentViewUserDataKey));
   web_contents_->SetUserData(kContentViewUserDataKey,
                              new ContentViewUserData(this));
 }
 
 void ContentViewCoreImpl::RenderViewReady() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
-    Java_ContentViewCore_onRenderProcessChange(env, obj.obj());
+    Java_ContentViewCore_onRenderProcessChange(env, obj);
 
   if (device_orientation_ != 0)
     SendOrientationChangeEventInternal();
 }
 
 void ContentViewCoreImpl::RenderViewHostChanged(RenderViewHost* old_host,
                                                 RenderViewHost* new_host) {
   int old_pid = 0;
   if (old_host) {
     old_pid = GetRenderProcessIdFromRenderViewHost(old_host);
 
     RenderWidgetHostViewAndroid* view =
         static_cast<RenderWidgetHostViewAndroid*>(
             old_host->GetWidget()->GetView());
     if (view)
       view->SetContentViewCore(NULL);
 
     view = static_cast<RenderWidgetHostViewAndroid*>(
         new_host->GetWidget()->GetView());
     if (view)
       view->SetContentViewCore(this);
   }
   int new_pid = GetRenderProcessIdFromRenderViewHost(
       web_contents_->GetRenderViewHost());
   if (new_pid != old_pid) {
     // Notify the Java side that the renderer process changed.
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
     if (!obj.is_null()) {
-      Java_ContentViewCore_onRenderProcessChange(env, obj.obj());
+      Java_ContentViewCore_onRenderProcessChange(env, obj);
     }
   }
 
   SetFocusInternal(HasFocus());
   SetAccessibilityEnabledInternal(accessibility_enabled_);
 }
 
 RenderWidgetHostViewAndroid*
     ContentViewCoreImpl::GetRenderWidgetHostViewAndroid() const {
   RenderWidgetHostView* rwhv = NULL;
@@ skipping 58 matching lines @@
       selection_start.type() == gfx::SelectionBound::CENTER;
   const jboolean is_insertion_marker_visible = selection_start.visible();
   const jfloat insertion_marker_horizontal =
       has_insertion_marker ? selection_start.edge_top().x() : 0.0f;
   const jfloat insertion_marker_top =
       has_insertion_marker ? selection_start.edge_top().y() : 0.0f;
   const jfloat insertion_marker_bottom =
       has_insertion_marker ? selection_start.edge_bottom().y() : 0.0f;
 
   Java_ContentViewCore_updateFrameInfo(
-      env, obj.obj(),
-      scroll_offset.x(),
-      scroll_offset.y(),
-      page_scale_factor,
-      page_scale_factor_limits.x(),
-      page_scale_factor_limits.y(),
-      content_size.width(),
-      content_size.height(),
-      viewport_size.width(),
-      viewport_size.height(),
-      controls_offset.y(),
-      content_offset.y(),
-      is_mobile_optimized_hint,
-      has_insertion_marker,
-      is_insertion_marker_visible,
-      insertion_marker_horizontal,
-      insertion_marker_top,
-      insertion_marker_bottom);
+      env, obj, scroll_offset.x(), scroll_offset.y(), page_scale_factor,
+      page_scale_factor_limits.x(), page_scale_factor_limits.y(),
+      content_size.width(), content_size.height(), viewport_size.width(),
+      viewport_size.height(), controls_offset.y(), content_offset.y(),
+      is_mobile_optimized_hint, has_insertion_marker,
+      is_insertion_marker_visible, insertion_marker_horizontal,
+      insertion_marker_top, insertion_marker_bottom);
 }
 
 void ContentViewCoreImpl::SetTitle(const base::string16& title) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   ScopedJavaLocalRef<jstring> jtitle =
       ConvertUTF8ToJavaString(env, base::UTF16ToUTF8(title));
-  Java_ContentViewCore_setTitle(env, obj.obj(), jtitle.obj());
+  Java_ContentViewCore_setTitle(env, obj, jtitle);
 }
 
 void ContentViewCoreImpl::OnBackgroundColorChanged(SkColor color) {
   view_.GetLayer()->SetBackgroundColor(color);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_ContentViewCore_onBackgroundColorChanged(env, obj.obj(), color);
+  Java_ContentViewCore_onBackgroundColorChanged(env, obj, color);
 }
 
 void ContentViewCoreImpl::ShowSelectPopupMenu(
     RenderFrameHost* frame,
     const gfx::Rect& bounds,
     const std::vector<MenuItem>& items,
     int selected_item,
     bool multiple,
     bool right_aligned) {
   JNIEnv* env = AttachCurrentThread();
@@ skipping 37 matching lines @@
   }
   ScopedJavaLocalRef<jobjectArray> items_array(
       base::android::ToJavaArrayOfStrings(env, labels));
   select_popup_ = view_.AcquireAnchorView();
   const ScopedJavaLocalRef<jobject> popup_view = select_popup_.view();
   if (popup_view.is_null())
     return;
   view_.SetAnchorRect(popup_view,
                       gfx::ScaleRect(gfx::RectF(bounds), page_scale_));
   Java_ContentViewCore_showSelectPopup(
-      env, j_obj.obj(), popup_view.obj(), reinterpret_cast<intptr_t>(frame),
-      items_array.obj(), enabled_array.obj(), multiple, selected_array.obj(),
-      right_aligned);
+      env, j_obj, popup_view, reinterpret_cast<intptr_t>(frame), items_array,
+      enabled_array, multiple, selected_array, right_aligned);
 }
 
 void ContentViewCoreImpl::HideSelectPopupMenu() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (!j_obj.is_null())
-    Java_ContentViewCore_hideSelectPopup(env, j_obj.obj());
+    Java_ContentViewCore_hideSelectPopup(env, j_obj);
   select_popup_.Reset();
 }
 
 void ContentViewCoreImpl::OnGestureEventAck(const blink::WebGestureEvent& event,
                                             InputEventAckState ack_result) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
 
   switch (event.type) {
     case WebInputEvent::GestureFlingStart:
       if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED) {
         // The view expects the fling velocity in pixels/s.
-        Java_ContentViewCore_onFlingStartEventConsumed(env, j_obj.obj(),
-            event.data.flingStart.velocityX * dpi_scale(),
+        Java_ContentViewCore_onFlingStartEventConsumed(
+            env, j_obj, event.data.flingStart.velocityX * dpi_scale(),
             event.data.flingStart.velocityY * dpi_scale());
       } else {
         // If a scroll ends with a fling, a SCROLL_END event is never sent.
         // However, if that fling went unconsumed, we still need to let the
         // listeners know that scrolling has ended.
-        Java_ContentViewCore_onScrollEndEventAck(env, j_obj.obj());
+        Java_ContentViewCore_onScrollEndEventAck(env, j_obj);
       }
       break;
     case WebInputEvent::GestureFlingCancel:
-      Java_ContentViewCore_onFlingCancelEventAck(env, j_obj.obj());
+      Java_ContentViewCore_onFlingCancelEventAck(env, j_obj);
       break;
     case WebInputEvent::GestureScrollBegin:
-      Java_ContentViewCore_onScrollBeginEventAck(env, j_obj.obj());
+      Java_ContentViewCore_onScrollBeginEventAck(env, j_obj);
       break;
     case WebInputEvent::GestureScrollUpdate:
       if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
-        Java_ContentViewCore_onScrollUpdateGestureConsumed(env, j_obj.obj());
+        Java_ContentViewCore_onScrollUpdateGestureConsumed(env, j_obj);
       break;
     case WebInputEvent::GestureScrollEnd:
-      Java_ContentViewCore_onScrollEndEventAck(env, j_obj.obj());
+      Java_ContentViewCore_onScrollEndEventAck(env, j_obj);
       break;
     case WebInputEvent::GesturePinchBegin:
-      Java_ContentViewCore_onPinchBeginEventAck(env, j_obj.obj());
+      Java_ContentViewCore_onPinchBeginEventAck(env, j_obj);
       break;
     case WebInputEvent::GesturePinchEnd:
-      Java_ContentViewCore_onPinchEndEventAck(env, j_obj.obj());
+      Java_ContentViewCore_onPinchEndEventAck(env, j_obj);
       break;
     case WebInputEvent::GestureTap:
       Java_ContentViewCore_onSingleTapEventAck(
-          env,
-          j_obj.obj(),
-          ack_result == INPUT_EVENT_ACK_STATE_CONSUMED,
-          event.x * dpi_scale(),
-          event.y * dpi_scale());
+          env, j_obj, ack_result == INPUT_EVENT_ACK_STATE_CONSUMED,
+          event.x * dpi_scale(), event.y * dpi_scale());
       break;
     case WebInputEvent::GestureLongPress:
       if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
-        Java_ContentViewCore_performLongPressHapticFeedback(env, j_obj.obj());
+        Java_ContentViewCore_performLongPressHapticFeedback(env, j_obj);
       break;
     default:
       break;
   }
 }
 
 bool ContentViewCoreImpl::FilterInputEvent(const blink::WebInputEvent& event) {
   if (event.type != WebInputEvent::GestureTap &&
       event.type != WebInputEvent::GestureDoubleTap &&
       event.type != WebInputEvent::GestureLongTap &&
       event.type != WebInputEvent::GestureLongPress)
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return false;
 
   const blink::WebGestureEvent& gesture =
       static_cast<const blink::WebGestureEvent&>(event);
   int gesture_type = ToGestureEventType(event.type);
-  return Java_ContentViewCore_filterTapOrPressEvent(env,
-                                                    j_obj.obj(),
-                                                    gesture_type,
+  return Java_ContentViewCore_filterTapOrPressEvent(env, j_obj, gesture_type,
                                                     gesture.x * dpi_scale(),
                                                     gesture.y * dpi_scale());
 }
 
 bool ContentViewCoreImpl::HasFocus() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
-  return Java_ContentViewCore_hasFocus(env, obj.obj());
+  return Java_ContentViewCore_hasFocus(env, obj);
 }
 
 void ContentViewCoreImpl::RequestDisallowInterceptTouchEvent() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
-    Java_ContentViewCore_requestDisallowInterceptTouchEvent(env, obj.obj());
+    Java_ContentViewCore_requestDisallowInterceptTouchEvent(env, obj);
 }
 
 void ContentViewCoreImpl::OnSelectionChanged(const std::string& text) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   ScopedJavaLocalRef<jstring> jtext = ConvertUTF8ToJavaString(env, text);
-  Java_ContentViewCore_onSelectionChanged(env, obj.obj(), jtext.obj());
+  Java_ContentViewCore_onSelectionChanged(env, obj, jtext);
 }
 
 void ContentViewCoreImpl::OnSelectionEvent(ui::SelectionEventType event,
                                            const gfx::PointF& selection_anchor,
                                            const gfx::RectF& selection_rect) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
 
   gfx::PointF selection_anchor_pix =
       gfx::ScalePoint(selection_anchor, dpi_scale());
   gfx::RectF selection_rect_pix = gfx::ScaleRect(selection_rect, dpi_scale());
   Java_ContentViewCore_onSelectionEvent(
-      env, j_obj.obj(), event, selection_anchor_pix.x(),
-      selection_anchor_pix.y(), selection_rect_pix.x(), selection_rect_pix.y(),
+      env, j_obj, event, selection_anchor_pix.x(), selection_anchor_pix.y(),
+      selection_rect_pix.x(), selection_rect_pix.y(),
       selection_rect_pix.right(), selection_rect_pix.bottom());
 }
 
 bool ContentViewCoreImpl::ShowPastePopup(int x_dip, int y_dip) {
   RenderWidgetHostViewAndroid* view = GetRenderWidgetHostViewAndroid();
   if (!view)
     return false;
 
   view->OnShowingPastePopup(gfx::PointF(x_dip, y_dip));
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
   return Java_ContentViewCore_showPastePopupWithFeedback(
-      env, obj.obj(), static_cast<jint>(x_dip * dpi_scale()),
+      env, obj, static_cast<jint>(x_dip * dpi_scale()),
       static_cast<jint>(y_dip * dpi_scale()));
 }
 
 void ContentViewCoreImpl::StartContentIntent(const GURL& content_url,
                                              bool is_main_frame) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
   ScopedJavaLocalRef<jstring> jcontent_url =
       ConvertUTF8ToJavaString(env, content_url.spec());
-  Java_ContentViewCore_startContentIntent(env,
-                                          j_obj.obj(),
-                                          jcontent_url.obj(),
+  Java_ContentViewCore_startContentIntent(env, j_obj, jcontent_url,
                                           is_main_frame);
 }
 
 void ContentViewCoreImpl::ShowDisambiguationPopup(
     const gfx::Rect& rect_pixels,
     const SkBitmap& zoomed_bitmap) {
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
   ScopedJavaLocalRef<jobject> rect_object(CreateJavaRect(env, rect_pixels));
 
   ScopedJavaLocalRef<jobject> java_bitmap =
       gfx::ConvertToJavaBitmap(&zoomed_bitmap);
   DCHECK(!java_bitmap.is_null());
 
-  Java_ContentViewCore_showDisambiguationPopup(env,
-                                               obj.obj(),
-                                               rect_object.obj(),
-                                               java_bitmap.obj());
+  Java_ContentViewCore_showDisambiguationPopup(env, obj, rect_object,
+                                               java_bitmap);
 }
 
 ScopedJavaLocalRef<jobject>
 ContentViewCoreImpl::CreateMotionEventSynthesizer() {
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return ScopedJavaLocalRef<jobject>();
-  return Java_ContentViewCore_createMotionEventSynthesizer(env, obj.obj());
+  return Java_ContentViewCore_createMotionEventSynthesizer(env, obj);
 }
 
 bool ContentViewCoreImpl::ShouldBlockMediaRequest(const GURL& url) {
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return true;
   ScopedJavaLocalRef<jstring> j_url = ConvertUTF8ToJavaString(env, url.spec());
-  return Java_ContentViewCore_shouldBlockMediaRequest(env, obj.obj(),
-                                                      j_url.obj());
+  return Java_ContentViewCore_shouldBlockMediaRequest(env, obj, j_url);
 }
 
 void ContentViewCoreImpl::DidStopFlinging() {
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
-    Java_ContentViewCore_onNativeFlingStopped(env, obj.obj());
+    Java_ContentViewCore_onNativeFlingStopped(env, obj);
 }
 
 ScopedJavaLocalRef<jobject> ContentViewCoreImpl::GetContext() const {
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return ScopedJavaLocalRef<jobject>();
 
-  return Java_ContentViewCore_getContext(env, obj.obj());
+  return Java_ContentViewCore_getContext(env, obj);
 }
 
 gfx::Size ContentViewCoreImpl::GetViewSizeWithOSKHidden() const {
   gfx::Size size_pix;
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return size_pix = gfx::Size();
   size_pix = gfx::Size(
-      Java_ContentViewCore_getViewportWidthPix(env, j_obj.obj()),
-      Java_ContentViewCore_getViewportHeightWithOSKHiddenPix(env, j_obj.obj()));
+      Java_ContentViewCore_getViewportWidthPix(env, j_obj),
+      Java_ContentViewCore_getViewportHeightWithOSKHiddenPix(env, j_obj));
 
   gfx::Size size_dip = gfx::ScaleToCeiledSize(size_pix, 1.0f / dpi_scale());
   if (DoTopControlsShrinkBlinkSize())
     size_dip.Enlarge(0, -GetTopControlsHeightDip());
   return size_dip;
 }
 
 gfx::Size ContentViewCoreImpl::GetViewSize() const {
   gfx::Size size = GetViewportSizeDip();
   if (DoTopControlsShrinkBlinkSize())
     size.Enlarge(0, -GetTopControlsHeightDip());
   return size;
 }
 
 gfx::Size ContentViewCoreImpl::GetPhysicalBackingSize() const {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return gfx::Size();
   return gfx::Size(
-      Java_ContentViewCore_getPhysicalBackingWidthPix(env, j_obj.obj()),
-      Java_ContentViewCore_getPhysicalBackingHeightPix(env, j_obj.obj()));
+      Java_ContentViewCore_getPhysicalBackingWidthPix(env, j_obj),
+      Java_ContentViewCore_getPhysicalBackingHeightPix(env, j_obj));
 }
 
 gfx::Size ContentViewCoreImpl::GetViewportSizePix() const {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return gfx::Size();
-  return gfx::Size(
-      Java_ContentViewCore_getViewportWidthPix(env, j_obj.obj()),
-      Java_ContentViewCore_getViewportHeightPix(env, j_obj.obj()));
+  return gfx::Size(Java_ContentViewCore_getViewportWidthPix(env, j_obj),
+                   Java_ContentViewCore_getViewportHeightPix(env, j_obj));
 }
 
 int ContentViewCoreImpl::GetTopControlsHeightPix() const {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return 0;
-  return Java_ContentViewCore_getTopControlsHeightPix(env, j_obj.obj());
+  return Java_ContentViewCore_getTopControlsHeightPix(env, j_obj);
 }
 
 gfx::Size ContentViewCoreImpl::GetViewportSizeDip() const {
   return gfx::ScaleToCeiledSize(GetViewportSizePix(), 1.0f / dpi_scale());
 }
 
 bool ContentViewCoreImpl::DoTopControlsShrinkBlinkSize() const {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return false;
-  return Java_ContentViewCore_doTopControlsShrinkBlinkSize(env, j_obj.obj());
+  return Java_ContentViewCore_doTopControlsShrinkBlinkSize(env, j_obj);
 }
 
 float ContentViewCoreImpl::GetTopControlsHeightDip() const {
   return GetTopControlsHeightPix() / dpi_scale();
 }
 
 void ContentViewCoreImpl::AttachLayer(scoped_refptr<cc::Layer> layer) {
   view_.GetLayer()->InsertChild(layer, 0);
   view_.GetLayer()->SetIsDrawable(false);
 }
@@ skipping 468 matching lines @@
   if (!rwhva)
     return 0;
   return rwhva->GetNativeImeAdapter();
 }
 
 void ContentViewCoreImpl::ForceUpdateImeAdapter(long native_ime_adapter) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
-  Java_ContentViewCore_forceUpdateImeAdapter(env, obj.obj(),
-                                             native_ime_adapter);
+  Java_ContentViewCore_forceUpdateImeAdapter(env, obj, native_ime_adapter);
 }
 
 void ContentViewCoreImpl::UpdateImeAdapter(long native_ime_adapter,
                                            int text_input_type,
                                            int text_input_flags,
                                            const std::string& text,
                                            int selection_start,
                                            int selection_end,
                                            int composition_start,
                                            int composition_end,
                                            bool show_ime_if_needed,
                                            bool is_non_ime_change) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
   ScopedJavaLocalRef<jstring> jstring_text = ConvertUTF8ToJavaString(env, text);
-  Java_ContentViewCore_updateImeAdapter(env,
-                                        obj.obj(),
-                                        native_ime_adapter,
-                                        text_input_type,
-                                        text_input_flags,
-                                        jstring_text.obj(),
-                                        selection_start,
-                                        selection_end,
-                                        composition_start,
-                                        composition_end,
-                                        show_ime_if_needed,
-                                        is_non_ime_change);
+  Java_ContentViewCore_updateImeAdapter(
+      env, obj, native_ime_adapter, text_input_type, text_input_flags,
+      jstring_text, selection_start, selection_end, composition_start,
+      composition_end, show_ime_if_needed, is_non_ime_change);
 }
 
 void ContentViewCoreImpl::SetAccessibilityEnabled(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     bool enabled) {
   SetAccessibilityEnabledInternal(enabled);
 }
 
 void ContentViewCoreImpl::SetTextTrackSettings(
@@ skipping 24 matching lines @@
   params.text_track_text_size = ConvertJavaStringToUTF8(
       env, textTrackTextSize);
   web_contents_->GetMainFrame()->SetTextTrackSettings(params);
 }
 
 bool ContentViewCoreImpl::IsFullscreenRequiredForOrientationLock() const {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return true;
-  return Java_ContentViewCore_isFullscreenRequiredForOrientationLock(env,
-                                                                     obj.obj());
+  return Java_ContentViewCore_isFullscreenRequiredForOrientationLock(env, obj);
 }
 
 void ContentViewCoreImpl::SetAccessibilityEnabledInternal(bool enabled) {
   accessibility_enabled_ = enabled;
   BrowserAccessibilityStateImpl* accessibility_state =
       BrowserAccessibilityStateImpl::GetInstance();
   if (enabled) {
     // First check if we already have a BrowserAccessibilityManager that
     // just needs to be connected to the ContentViewCore.
     if (web_contents_) {
@@ skipping 132 matching lines @@
       break;
   }
 }
 
 void ContentViewCoreImpl::OnShowUnhandledTapUIIfNeeded(int x_dip, int y_dip) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_ContentViewCore_onShowUnhandledTapUIIfNeeded(
-      env, obj.obj(), static_cast<jint>(x_dip * dpi_scale()),
+      env, obj, static_cast<jint>(x_dip * dpi_scale()),
       static_cast<jint>(y_dip * dpi_scale()));
 }
 
 void ContentViewCoreImpl::HidePopupsAndPreserveSelection() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
-  Java_ContentViewCore_hidePopupsAndPreserveSelection(env, obj.obj());
+  Java_ContentViewCore_hidePopupsAndPreserveSelection(env, obj);
 }
 
 void ContentViewCoreImpl::OnSmartClipDataExtracted(
     const base::string16& text,
     const base::string16& html,
     const gfx::Rect& clip_rect) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   ScopedJavaLocalRef<jstring> jtext = ConvertUTF16ToJavaString(env, text);
   ScopedJavaLocalRef<jstring> jhtml = ConvertUTF16ToJavaString(env, html);
   ScopedJavaLocalRef<jobject> clip_rect_object(CreateJavaRect(env, clip_rect));
-  Java_ContentViewCore_onSmartClipDataExtracted(
-      env, obj.obj(), jtext.obj(), jhtml.obj(), clip_rect_object.obj());
+  Java_ContentViewCore_onSmartClipDataExtracted(env, obj, jtext, jhtml,
+                                                clip_rect_object);
 }
 
 void ContentViewCoreImpl::WebContentsDestroyed() {
   WebContentsViewAndroid* wcva = static_cast<WebContentsViewAndroid*>(
       static_cast<WebContentsImpl*>(web_contents())->GetView());
   DCHECK(wcva);
   wcva->SetContentViewCore(NULL);
 }
 
 bool ContentViewCoreImpl::PullStart() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
-    return Java_ContentViewCore_onOverscrollRefreshStart(env, obj.obj());
+    return Java_ContentViewCore_onOverscrollRefreshStart(env, obj);
   return false;
 }
 
 void ContentViewCoreImpl::PullUpdate(float delta) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
-    Java_ContentViewCore_onOverscrollRefreshUpdate(env, obj.obj(), delta);
+    Java_ContentViewCore_onOverscrollRefreshUpdate(env, obj, delta);
 }
 
 void ContentViewCoreImpl::PullRelease(bool allow_refresh) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null()) {
-    Java_ContentViewCore_onOverscrollRefreshRelease(env, obj.obj(),
-                                                    allow_refresh);
+    Java_ContentViewCore_onOverscrollRefreshRelease(env, obj, allow_refresh);
   }
 }
 
 void ContentViewCoreImpl::PullReset() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
-    Java_ContentViewCore_onOverscrollRefreshReset(env, obj.obj());
+    Java_ContentViewCore_onOverscrollRefreshReset(env, obj);
 }
 
 // This is called for each ContentView.
 jlong Init(JNIEnv* env,
            const JavaParamRef<jobject>& obj,
            const JavaParamRef<jobject>& web_contents,
            const JavaParamRef<jobject>& view_android_delegate,
            jlong window_android,
            const JavaParamRef<jobject>& retained_objects_set) {
   ContentViewCoreImpl* view = new ContentViewCoreImpl(
@@ skipping 17 matching lines @@
     return ScopedJavaLocalRef<jobject>();
 
   return view->GetJavaObject();
 }
 
 bool RegisterContentViewCore(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content