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

ui/events/android/motion_event_android.cc

 // Copyright 2014 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 "ui/events/android/motion_event_android.h"
 
 #include <android/input.h>
 
 #include <cmath>
 
@@ skipping 195 matching lines @@
 }
 
 size_t MotionEventAndroid::GetPointerCount() const {
   return cached_pointer_count_;
 }
 
 int MotionEventAndroid::GetPointerId(size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_pointers_[pointer_index].id;
-  return Java_MotionEvent_getPointerId(
-      AttachCurrentThread(), event_.obj(), pointer_index);
+  return Java_MotionEvent_getPointerId(AttachCurrentThread(), event_,
+                                       pointer_index);
 }
 
 float MotionEventAndroid::GetX(size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_pointers_[pointer_index].position.x();
-  return ToDips(Java_MotionEvent_getXF_I(
-      AttachCurrentThread(), event_.obj(), pointer_index));
+  return ToDips(
+      Java_MotionEvent_getXF_I(AttachCurrentThread(), event_, pointer_index));
 }
 
 float MotionEventAndroid::GetY(size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_pointers_[pointer_index].position.y();
-  return ToDips(Java_MotionEvent_getYF_I(
-      AttachCurrentThread(), event_.obj(), pointer_index));
+  return ToDips(
+      Java_MotionEvent_getYF_I(AttachCurrentThread(), event_, pointer_index));
 }
 
 float MotionEventAndroid::GetRawX(size_t pointer_index) const {
   return GetX(pointer_index) + cached_raw_position_offset_.x();
 }
 
 float MotionEventAndroid::GetRawY(size_t pointer_index) const {
   return GetY(pointer_index) + cached_raw_position_offset_.y();
 }
 
 float MotionEventAndroid::GetTouchMajor(size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_pointers_[pointer_index].touch_major;
-  return ToDips(Java_MotionEvent_getTouchMajorF_I(
-      AttachCurrentThread(), event_.obj(), pointer_index));
+  return ToDips(Java_MotionEvent_getTouchMajorF_I(AttachCurrentThread(), event_,
+                                                  pointer_index));
 }
 
 float MotionEventAndroid::GetTouchMinor(size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_pointers_[pointer_index].touch_minor;
-  return ToDips(Java_MotionEvent_getTouchMinorF_I(
-      AttachCurrentThread(), event_.obj(), pointer_index));
+  return ToDips(Java_MotionEvent_getTouchMinorF_I(AttachCurrentThread(), event_,
+                                                  pointer_index));
 }
 
 float MotionEventAndroid::GetOrientation(size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_pointers_[pointer_index].orientation;
   return ToValidFloat(Java_MotionEvent_getOrientationF_I(
-      AttachCurrentThread(), event_.obj(), pointer_index));
+      AttachCurrentThread(), event_, pointer_index));
 }
 
 float MotionEventAndroid::GetPressure(size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   // Note that this early return is a special case exercised only in testing, as
   // caching the pressure values is not a worthwhile optimization (they're
   // accessed at most once per event instance).
   if (!event_.obj())
     return 0.f;
-  return Java_MotionEvent_getPressureF_I(
-      AttachCurrentThread(), event_.obj(), pointer_index);
+  return Java_MotionEvent_getPressureF_I(AttachCurrentThread(), event_,
+                                         pointer_index);
 }
 
 float MotionEventAndroid::GetTilt(size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_pointers_[pointer_index].tilt;
   if (!event_.obj())
     return 0.f;
   return ToValidFloat(Java_MotionEvent_getAxisValueF_I_I(
-      AttachCurrentThread(), event_.obj(), AXIS_TILT, pointer_index));
+      AttachCurrentThread(), event_, AXIS_TILT, pointer_index));
 }
 
 base::TimeTicks MotionEventAndroid::GetEventTime() const {
   return cached_time_;
 }
 
 size_t MotionEventAndroid::GetHistorySize() const {
   return cached_history_size_;
 }
 
 base::TimeTicks MotionEventAndroid::GetHistoricalEventTime(
     size_t historical_index) const {
   return FromAndroidTime(Java_MotionEvent_getHistoricalEventTime(
-      AttachCurrentThread(), event_.obj(), historical_index));
+      AttachCurrentThread(), event_, historical_index));
 }
 
 float MotionEventAndroid::GetHistoricalTouchMajor(
     size_t pointer_index,
     size_t historical_index) const {
   return ToDips(Java_MotionEvent_getHistoricalTouchMajorF_I_I(
-      AttachCurrentThread(), event_.obj(), pointer_index, historical_index));
+      AttachCurrentThread(), event_, pointer_index, historical_index));
 }
 
 float MotionEventAndroid::GetHistoricalX(size_t pointer_index,
                                          size_t historical_index) const {
   return ToDips(Java_MotionEvent_getHistoricalXF_I_I(
-      AttachCurrentThread(), event_.obj(), pointer_index, historical_index));
+      AttachCurrentThread(), event_, pointer_index, historical_index));
 }
 
 float MotionEventAndroid::GetHistoricalY(size_t pointer_index,
                                          size_t historical_index) const {
   return ToDips(Java_MotionEvent_getHistoricalYF_I_I(
-      AttachCurrentThread(), event_.obj(), pointer_index, historical_index));
+      AttachCurrentThread(), event_, pointer_index, historical_index));
 }
 
 ui::MotionEvent::ToolType MotionEventAndroid::GetToolType(
     size_t pointer_index) const {
   DCHECK_LT(pointer_index, cached_pointer_count_);
   if (pointer_index < MAX_POINTERS_TO_CACHE)
     return cached_pointers_[pointer_index].tool_type;
   return FromAndroidToolType(Java_MotionEvent_getToolType(
-      AttachCurrentThread(), event_.obj(), pointer_index));
+      AttachCurrentThread(), event_, pointer_index));
 }
 
 int MotionEventAndroid::GetButtonState() const {
   return cached_button_state_;
 }
 
 int MotionEventAndroid::GetFlags() const {
   return cached_flags_;
 }
 
 float MotionEventAndroid::ToDips(float pixels) const {
   return pixels * pix_to_dip_;
 }
 
 MotionEventAndroid::CachedPointer MotionEventAndroid::FromAndroidPointer(
     const Pointer& pointer) const {
   CachedPointer result;
   result.id = pointer.id;
   result.position =
       gfx::PointF(ToDips(pointer.pos_x_pixels), ToDips(pointer.pos_y_pixels));
   result.touch_major = ToDips(pointer.touch_major_pixels);
   result.touch_minor = ToDips(pointer.touch_minor_pixels);
   result.orientation = ToValidFloat(pointer.orientation_rad);
   result.tilt = ToValidFloat(pointer.tilt_rad);
   result.tool_type = FromAndroidToolType(pointer.tool_type);
   return result;
 }
 
 }  // namespace content