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

device/bluetooth/bluetooth_adapter_android.cc

 // Copyright 2015 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 "device/bluetooth/bluetooth_adapter_android.h"
 
 #include <memory>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 46 matching lines @@
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 // static
 bool BluetoothAdapterAndroid::RegisterJNI(JNIEnv* env) {
   return RegisterNativesImpl(env);  // Generated in BluetoothAdapter_jni.h
 }
 
 std::string BluetoothAdapterAndroid::GetAddress() const {
   return ConvertJavaStringToUTF8(Java_ChromeBluetoothAdapter_getAddress(
-      AttachCurrentThread(), j_adapter_.obj()));
+      AttachCurrentThread(), j_adapter_));
 }
 
 std::string BluetoothAdapterAndroid::GetName() const {
-  return ConvertJavaStringToUTF8(Java_ChromeBluetoothAdapter_getName(
-      AttachCurrentThread(), j_adapter_.obj()));
+  return ConvertJavaStringToUTF8(
+      Java_ChromeBluetoothAdapter_getName(AttachCurrentThread(), j_adapter_));
 }
 
 void BluetoothAdapterAndroid::SetName(const std::string& name,
                                       const base::Closure& callback,
                                       const ErrorCallback& error_callback) {
   NOTIMPLEMENTED();
 }
 
 bool BluetoothAdapterAndroid::IsInitialized() const {
   return true;
 }
 
 bool BluetoothAdapterAndroid::IsPresent() const {
   return Java_ChromeBluetoothAdapter_isPresent(AttachCurrentThread(),
-                                               j_adapter_.obj());
+                                               j_adapter_);
 }
 
 bool BluetoothAdapterAndroid::IsPowered() const {
   return Java_ChromeBluetoothAdapter_isPowered(AttachCurrentThread(),
-                                               j_adapter_.obj());
+                                               j_adapter_);
 }
 
 void BluetoothAdapterAndroid::SetPowered(bool powered,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
-  if (Java_ChromeBluetoothAdapter_setPowered(AttachCurrentThread(),
-                                             j_adapter_.obj(), powered)) {
+  if (Java_ChromeBluetoothAdapter_setPowered(AttachCurrentThread(), j_adapter_,
+                                             powered)) {
     callback.Run();
   } else {
     error_callback.Run();
   }
 }
 
 bool BluetoothAdapterAndroid::IsDiscoverable() const {
   return Java_ChromeBluetoothAdapter_isDiscoverable(AttachCurrentThread(),
-                                                    j_adapter_.obj());
+                                                    j_adapter_);
 }
 
 void BluetoothAdapterAndroid::SetDiscoverable(
     bool discoverable,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   NOTIMPLEMENTED();
 }
 
 bool BluetoothAdapterAndroid::IsDiscovering() const {
   return Java_ChromeBluetoothAdapter_isDiscovering(AttachCurrentThread(),
-                                                   j_adapter_.obj());
+                                                   j_adapter_);
 }
 
 BluetoothAdapter::UUIDList BluetoothAdapterAndroid::GetUUIDs() const {
   NOTIMPLEMENTED();
   return UUIDList();
 }
 
 void BluetoothAdapterAndroid::CreateRfcommService(
     const BluetoothUUID& uuid,
     const ServiceOptions& options,
@@ skipping 76 matching lines @@
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceChanged(this, device_android));
   }
 }
 
 BluetoothAdapterAndroid::BluetoothAdapterAndroid() : weak_ptr_factory_(this) {
 }
 
 BluetoothAdapterAndroid::~BluetoothAdapterAndroid() {
   Java_ChromeBluetoothAdapter_onBluetoothAdapterAndroidDestruction(
-      AttachCurrentThread(), j_adapter_.obj());
+      AttachCurrentThread(), j_adapter_);
 }
 
 void BluetoothAdapterAndroid::PurgeTimedOutDevices() {
   RemoveTimedOutDevices();
   if (IsDiscovering()) {
     ui_task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&BluetoothAdapterAndroid::PurgeTimedOutDevices,
                               weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kActivePollInterval));
   } else {
     ui_task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&BluetoothAdapterAndroid::RemoveTimedOutDevices,
                               weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kPassivePollInterval));
   }
 }
 
 void BluetoothAdapterAndroid::AddDiscoverySession(
     BluetoothDiscoveryFilter* discovery_filter,
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   // TODO(scheib): Support filters crbug.com/490401
   bool session_added = false;
   if (IsPowered()) {
     if (num_discovery_sessions_ > 0) {
       session_added = true;
     } else if (Java_ChromeBluetoothAdapter_startScan(AttachCurrentThread(),
-                                                     j_adapter_.obj())) {
+                                                     j_adapter_)) {
       session_added = true;
 
       // Using a delayed task in order to give the adapter some time
       // to settle before purging devices.
       ui_task_runner_->PostDelayedTask(
           FROM_HERE, base::Bind(&BluetoothAdapterAndroid::PurgeTimedOutDevices,
                                 weak_ptr_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kPurgeDelay));
     }
   } else {
@@ skipping 18 matching lines @@
   bool session_removed = false;
   if (num_discovery_sessions_ == 0) {
     VLOG(1) << "RemoveDiscoverySession: No scan in progress.";
     NOTREACHED();
   } else {
     --num_discovery_sessions_;
     session_removed = true;
     if (num_discovery_sessions_ == 0) {
       VLOG(1) << "RemoveDiscoverySession: Now 0 sessions. Stopping scan.";
       session_removed = Java_ChromeBluetoothAdapter_stopScan(
-          AttachCurrentThread(), j_adapter_.obj());
+          AttachCurrentThread(), j_adapter_);
     } else {
       VLOG(1) << "RemoveDiscoverySession: Now "
               << unsigned(num_discovery_sessions_) << " sessions.";
     }
   }
 
   if (session_removed) {
     callback.Run();
   } else {
     // TODO(scheib): Eventually wire the SCAN_FAILED result through to here.
     error_callback.Run(UMABluetoothDiscoverySessionOutcome::UNKNOWN);
   }
 }
 
 void BluetoothAdapterAndroid::SetDiscoveryFilter(
     std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter,
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   // TODO(scheib): Support filters crbug.com/490401
   NOTIMPLEMENTED();
   error_callback.Run(UMABluetoothDiscoverySessionOutcome::NOT_IMPLEMENTED);
 }
 
 void BluetoothAdapterAndroid::RemovePairingDelegateInternal(
     device::BluetoothDevice::PairingDelegate* pairing_delegate) {
 }
 
 }  // namespace device