bluetooth: macOS: Removing useless |.get()|

device/bluetooth/bluetooth_remote_gatt_characteristic_mac.mm

 // Copyright 2016 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_remote_gatt_characteristic_mac.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 56 matching lines @@
 }  // namespace
 
 BluetoothRemoteGattCharacteristicMac::BluetoothRemoteGattCharacteristicMac(
     BluetoothRemoteGattServiceMac* gatt_service,
     CBCharacteristic* cb_characteristic)
     : is_discovery_complete_(false),
       discovery_pending_count_(0),
       gatt_service_(gatt_service),
       cb_characteristic_(cb_characteristic, base::scoped_policy::RETAIN),
       weak_ptr_factory_(this) {
-  uuid_ = BluetoothAdapterMac::BluetoothUUIDWithCBUUID(
-      [cb_characteristic_.get() UUID]);
+  uuid_ =
+      BluetoothAdapterMac::BluetoothUUIDWithCBUUID([cb_characteristic_ UUID]);
   identifier_ = base::SysNSStringToUTF8(
       [NSString stringWithFormat:@"%s-%p", uuid_.canonical_value().c_str(),
                                  (void*)cb_characteristic_]);
 }
 
 BluetoothRemoteGattCharacteristicMac::~BluetoothRemoteGattCharacteristicMac() {
   if (HasPendingRead()) {
     std::pair<ValueCallback, ErrorCallback> callbacks;
     callbacks.swap(read_characteristic_value_callbacks_);
     callbacks.second.Run(BluetoothGattService::GATT_ERROR_FAILED);
   }
   if (HasPendingWrite()) {
     std::pair<base::Closure, ErrorCallback> callbacks;
     callbacks.swap(write_characteristic_value_callbacks_);
     callbacks.second.Run(BluetoothGattService::GATT_ERROR_FAILED);
   }
 }
 
 std::string BluetoothRemoteGattCharacteristicMac::GetIdentifier() const {
   return identifier_;
 }
 
 BluetoothUUID BluetoothRemoteGattCharacteristicMac::GetUUID() const {
   return uuid_;
 }
 
 BluetoothGattCharacteristic::Properties
 BluetoothRemoteGattCharacteristicMac::GetProperties() const {
-  return ConvertProperties(cb_characteristic_.get().properties);
+  return ConvertProperties([cb_characteristic_ properties]);
 }
 
 BluetoothGattCharacteristic::Permissions
 BluetoothRemoteGattCharacteristicMac::GetPermissions() const {
   // Not supported for remote characteristics for CoreBluetooth.
   NOTIMPLEMENTED();
   return PERMISSION_NONE;
 }
 
 const std::vector<uint8_t>& BluetoothRemoteGattCharacteristicMac::GetValue()
     const {
   return value_;
 }
 
 BluetoothRemoteGattService* BluetoothRemoteGattCharacteristicMac::GetService()
     const {
   return static_cast<BluetoothRemoteGattService*>(gatt_service_);
 }
 
 bool BluetoothRemoteGattCharacteristicMac::IsNotifying() const {
-  return cb_characteristic_.get().isNotifying == YES;
+  return [cb_characteristic_ isNotifying] == YES;
 }
 
 std::vector<BluetoothRemoteGattDescriptor*>
 BluetoothRemoteGattCharacteristicMac::GetDescriptors() const {
   std::vector<BluetoothRemoteGattDescriptor*> gatt_descriptors;
   for (const auto& iter : gatt_descriptor_macs_) {
     BluetoothRemoteGattDescriptor* gatt_descriptor =
         static_cast<BluetoothRemoteGattDescriptor*>(iter.second.get());
     gatt_descriptors.push_back(gatt_descriptor);
   }
@@ skipping 77 matching lines @@
     BluetoothRemoteGattDescriptor* ccc_descriptor,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << *this << ": Subscribe to characteristic.";
   DCHECK(subscribe_to_notification_callbacks_.first.is_null());
   DCHECK(subscribe_to_notification_callbacks_.second.is_null());
   DCHECK(unsubscribe_from_notification_callbacks_.first.is_null());
   DCHECK(unsubscribe_from_notification_callbacks_.second.is_null());
   subscribe_to_notification_callbacks_ =
       std::make_pair(callback, error_callback);
-  [GetCBPeripheral() setNotifyValue:YES
-                  forCharacteristic:cb_characteristic_.get()];
+  [GetCBPeripheral() setNotifyValue:YES forCharacteristic:cb_characteristic_];
 }
 
 void BluetoothRemoteGattCharacteristicMac::UnsubscribeFromNotifications(
     BluetoothRemoteGattDescriptor* ccc_descriptor,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << *this << ": Unsubscribe from characteristic.";
   DCHECK(subscribe_to_notification_callbacks_.first.is_null());
   DCHECK(subscribe_to_notification_callbacks_.second.is_null());
   DCHECK(unsubscribe_from_notification_callbacks_.first.is_null());
   DCHECK(unsubscribe_from_notification_callbacks_.second.is_null());
   unsubscribe_from_notification_callbacks_ =
       std::make_pair(callback, error_callback);
-  [GetCBPeripheral() setNotifyValue:NO
-                  forCharacteristic:cb_characteristic_.get()];
+  [GetCBPeripheral() setNotifyValue:NO forCharacteristic:cb_characteristic_];
 }
 
 void BluetoothRemoteGattCharacteristicMac::DiscoverDescriptors() {
   VLOG(1) << *this << ": Discover descriptors.";
   is_discovery_complete_ = false;
   ++discovery_pending_count_;
-  [GetCBPeripheral()
-      discoverDescriptorsForCharacteristic:cb_characteristic_.get()];
+  [GetCBPeripheral() discoverDescriptorsForCharacteristic:cb_characteristic_];
 }
 
 void BluetoothRemoteGattCharacteristicMac::DidUpdateValue(NSError* error) {
   CHECK_EQ(GetCBPeripheral().state, CBPeripheralStateConnected);
   // This method is called when the characteristic is read and when a
   // notification is received.
   if (HasPendingRead()) {
     std::pair<ValueCallback, ErrorCallback> callbacks;
     callbacks.swap(read_characteristic_value_callbacks_);
     if (error) {
@@ skipping 18 matching lines @@
     // In case of buggy device, nothing should be done if receiving extra
     // read confirmation.
     VLOG(1)
         << *this
         << ": Characteristic value updated while having no pending read nor "
            "notification.";
   }
 }
 
 void BluetoothRemoteGattCharacteristicMac::UpdateValue() {
-  NSData* nsdata_value = cb_characteristic_.get().value;
+  NSData* nsdata_value = [cb_characteristic_ value];
   const uint8_t* buffer = static_cast<const uint8_t*>(nsdata_value.bytes);
   value_.assign(buffer, buffer + nsdata_value.length);
 }
 
 void BluetoothRemoteGattCharacteristicMac::DidWriteValue(NSError* error) {
   // We could have called cancelPeripheralConnection, which causes
   // [CBPeripheral state] to be CBPeripheralStateDisconnected, before or during
   // a write without response callback so we flush all pending writes.
   // TODO(crbug.com/726534): Remove once we can avoid calling DidWriteValue
   // when we disconnect before or during a write without response call.
@@ skipping 65 matching lines @@
             << ": Unmatch DiscoverDescriptors and DidDiscoverDescriptors.";
     return;
   }
   VLOG(1) << *this << ": Did discover descriptors.";
   --discovery_pending_count_;
   std::unordered_set<std::string> descriptor_identifier_to_remove;
   for (const auto& iter : gatt_descriptor_macs_) {
     descriptor_identifier_to_remove.insert(iter.first);
   }
 
-  for (CBDescriptor* cb_descriptor in cb_characteristic_.get().descriptors) {
+  for (CBDescriptor* cb_descriptor in [cb_characteristic_ descriptors]) {
     BluetoothRemoteGattDescriptorMac* gatt_descriptor_mac =
         GetBluetoothRemoteGattDescriptorMac(cb_descriptor);
     if (gatt_descriptor_mac) {
       VLOG(1) << *gatt_descriptor_mac << ": Known descriptor.";
       const std::string& identifier = gatt_descriptor_mac->GetIdentifier();
       descriptor_identifier_to_remove.erase(identifier);
       continue;
     }
     gatt_descriptor_mac =
         new BluetoothRemoteGattDescriptorMac(this, cb_descriptor);
@@ skipping 34 matching lines @@
 
 CBCharacteristicWriteType BluetoothRemoteGattCharacteristicMac::GetCBWriteType()
     const {
   return (GetProperties() & BluetoothGattCharacteristic::PROPERTY_WRITE)
              ? CBCharacteristicWriteWithResponse
              : CBCharacteristicWriteWithoutResponse;
 }
 
 CBCharacteristic* BluetoothRemoteGattCharacteristicMac::GetCBCharacteristic()
     const {
-  return cb_characteristic_.get();
+  return cb_characteristic_;
 }
 
 BluetoothAdapterMac* BluetoothRemoteGattCharacteristicMac::GetMacAdapter()
     const {
   return gatt_service_->GetMacAdapter();
 }
 
 CBPeripheral* BluetoothRemoteGattCharacteristicMac::GetCBPeripheral() const {
   return gatt_service_->GetCBPeripheral();
 }
@@ skipping 26 matching lines @@
   const BluetoothRemoteGattServiceMac* service_mac =
       static_cast<const BluetoothRemoteGattServiceMac*>(
           characteristic.GetService());
   return out << "<BluetoothRemoteGattCharacteristicMac "
              << characteristic.GetUUID().canonical_value() << "/"
              << &characteristic
              << ", service: " << service_mac->GetUUID().canonical_value() << "/"
              << service_mac << ">";
 }
 }  // namespace device.