Remove implicit conversions from scoped_refptr to T* in chrome/browser/extensions/api/

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_event_router.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 "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_event_router.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_connection.h"
@@ skipping 193 matching lines @@
   return (adapter_.get() != NULL);
 }
 
 void BluetoothLowEnergyEventRouter::Connect(
     bool persistent,
     const Extension* extension,
     const std::string& device_address,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   const std::string extension_id = extension->id();
   const std::string connect_id = extension_id + device_address;
 
   if (connecting_devices_.count(connect_id) != 0) {
     error_callback.Run(kStatusErrorInProgress);
@@ skipping 34 matching lines @@
                  device_address,
                  error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::Disconnect(
     const Extension* extension,
     const std::string& device_address,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   const std::string extension_id = extension->id();
   const std::string disconnect_id = extension_id + device_address;
 
   if (disconnecting_devices_.count(disconnect_id) != 0) {
     error_callback.Run(kStatusErrorInProgress);
@@ skipping 15 matching lines @@
                  extension_id,
                  device_address,
                  callback));
 }
 
 bool BluetoothLowEnergyEventRouter::GetServices(
     const std::string& device_address,
     ServiceList* out_services) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(out_services);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     return false;
   }
 
   BluetoothDevice* device = adapter_->GetDevice(device_address);
   if (!device) {
     VLOG(1) << "Bluetooth device not found: " << device_address;
     return false;
   }
 
@@ skipping 14 matching lines @@
   }
 
   return true;
 }
 
 BluetoothLowEnergyEventRouter::Status BluetoothLowEnergyEventRouter::GetService(
     const std::string& instance_id,
     apibtle::Service* out_service) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(out_service);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattService* gatt_service = FindServiceById(instance_id);
   if (!gatt_service) {
     VLOG(1) << "Service not found: " << instance_id;
     return kStatusErrorNotFound;
   }
 
   PopulateService(gatt_service, out_service);
   return kStatusSuccess;
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetIncludedServices(
     const std::string& instance_id,
     ServiceList* out_services) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(out_services);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattService* service = FindServiceById(instance_id);
   if (!service) {
     VLOG(1) << "Service not found: " << instance_id;
     return kStatusErrorNotFound;
   }
 
@@ skipping 17 matching lines @@
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetCharacteristics(
     const Extension* extension,
     const std::string& instance_id,
     CharacteristicList* out_characteristics) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
   DCHECK(out_characteristics);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BlutoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattService* service = FindServiceById(instance_id);
   if (!service) {
     VLOG(1) << "Service not found: " << instance_id;
     return kStatusErrorNotFound;
   }
 
@@ skipping 25 matching lines @@
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetCharacteristic(
     const Extension* extension,
     const std::string& instance_id,
     apibtle::Characteristic* out_characteristic) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
   DCHECK(out_characteristic);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattCharacteristic* characteristic =
       FindCharacteristicById(instance_id);
   if (!characteristic) {
     VLOG(1) << "Characteristic not found: " << instance_id;
     return kStatusErrorNotFound;
   }
@@ skipping 11 matching lines @@
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetDescriptors(
     const Extension* extension,
     const std::string& instance_id,
     DescriptorList* out_descriptors) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
   DCHECK(out_descriptors);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BlutoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattCharacteristic* characteristic =
       FindCharacteristicById(instance_id);
   if (!characteristic) {
     VLOG(1) << "Characteristic not found: " << instance_id;
     return kStatusErrorNotFound;
   }
@@ skipping 26 matching lines @@
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetDescriptor(
     const Extension* extension,
     const std::string& instance_id,
     api::bluetooth_low_energy::Descriptor* out_descriptor) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
   DCHECK(out_descriptor);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattDescriptor* descriptor = FindDescriptorById(instance_id);
   if (!descriptor) {
     VLOG(1) << "Descriptor not found: " << instance_id;
     return kStatusErrorNotFound;
   }
 
   BluetoothPermissionRequest request(
       descriptor->GetCharacteristic()->GetService()->GetUUID().value());
   if (!BluetoothManifestData::CheckRequest(extension, request)) {
     VLOG(1) << "App has no permission to access this descriptor: "
             << instance_id;
     return kStatusErrorPermissionDenied;
   }
 
   PopulateDescriptor(descriptor, out_descriptor);
   return kStatusSuccess;
 }
 
 void BluetoothLowEnergyEventRouter::ReadCharacteristicValue(
     const Extension* extension,
     const std::string& instance_id,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   BluetoothGattCharacteristic* characteristic =
       FindCharacteristicById(instance_id);
   if (!characteristic) {
     VLOG(1) << "Characteristic not found: " << instance_id;
     error_callback.Run(kStatusErrorNotFound);
@@ skipping 19 matching lines @@
 }
 
 void BluetoothLowEnergyEventRouter::WriteCharacteristicValue(
     const Extension* extension,
     const std::string& instance_id,
     const std::vector<uint8>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   BluetoothGattCharacteristic* characteristic =
       FindCharacteristicById(instance_id);
   if (!characteristic) {
     VLOG(1) << "Characteristic not found: " << instance_id;
     error_callback.Run(kStatusErrorNotFound);
@@ skipping 17 matching lines @@
                  error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::StartCharacteristicNotifications(
     bool persistent,
     const Extension* extension,
     const std::string& instance_id,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   const std::string extension_id = extension->id();
   const std::string session_id = extension_id + instance_id;
 
   if (pending_session_calls_.count(session_id) != 0) {
     error_callback.Run(kStatusErrorInProgress);
@@ skipping 44 matching lines @@
                  instance_id,
                  error_callback));
 }
 
 void BluetoothLowEnergyEventRouter::StopCharacteristicNotifications(
     const Extension* extension,
     const std::string& instance_id,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   const std::string extension_id = extension->id();
 
   BluetoothLowEnergyNotifySession* session =
       FindNotifySession(extension_id, instance_id);
   if (!session || !session->GetSession()->IsActive()) {
@@ skipping 11 matching lines @@
                  callback));
 }
 
 void BluetoothLowEnergyEventRouter::ReadDescriptorValue(
     const Extension* extension,
     const std::string& instance_id,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   BluetoothGattDescriptor* descriptor = FindDescriptorById(instance_id);
   if (!descriptor) {
     VLOG(1) << "Descriptor not found: " << instance_id;
     error_callback.Run(kStatusErrorNotFound);
     return;
@@ skipping 18 matching lines @@
 }
 
 void BluetoothLowEnergyEventRouter::WriteDescriptorValue(
     const Extension* extension,
     const std::string& instance_id,
     const std::vector<uint8>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
-  if (!adapter_) {
+  if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   BluetoothGattDescriptor* descriptor = FindDescriptorById(instance_id);
   if (!descriptor) {
     VLOG(1) << "Descriptor not found: " << instance_id;
     error_callback.Run(kStatusErrorNotFound);
     return;
@@ skipping 20 matching lines @@
     device::BluetoothAdapter* adapter) {
   adapter_ = adapter;
   InitializeIdentifierMappings();
 }
 
 void BluetoothLowEnergyEventRouter::GattServiceAdded(
     BluetoothAdapter* adapter,
     BluetoothDevice* device,
     BluetoothGattService* service) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT service added: " << service->GetIdentifier();
 
   DCHECK(service_id_to_device_address_.find(service->GetIdentifier()) ==
          service_id_to_device_address_.end());
 
   service_id_to_device_address_[service->GetIdentifier()] =
       device->GetAddress();
 }
 
 void BluetoothLowEnergyEventRouter::GattServiceRemoved(
     BluetoothAdapter* adapter,
     BluetoothDevice* device,
     BluetoothGattService* service) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT service removed: " << service->GetIdentifier();
 
   DCHECK(service_id_to_device_address_.find(service->GetIdentifier()) !=
          service_id_to_device_address_.end());
 
   DCHECK(device->GetAddress() ==
          service_id_to_device_address_[service->GetIdentifier()]);
   service_id_to_device_address_.erase(service->GetIdentifier());
 
   // Signal API event.
   apibtle::Service api_service;
   PopulateService(service, &api_service);
 
   scoped_ptr<base::ListValue> args =
       apibtle::OnServiceRemoved::Create(api_service);
   scoped_ptr<Event> event(
       new Event(apibtle::OnServiceRemoved::kEventName, args.Pass()));
   EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 }
 
 void BluetoothLowEnergyEventRouter::GattDiscoveryCompleteForService(
     BluetoothAdapter* adapter,
     BluetoothGattService* service) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT service discovery complete: " << service->GetIdentifier();
 
   DCHECK(service_id_to_device_address_.find(service->GetIdentifier()) !=
          service_id_to_device_address_.end());
 
   // Signal the service added event here.
   apibtle::Service api_service;
   PopulateService(service, &api_service);
 
   scoped_ptr<base::ListValue> args =
       apibtle::OnServiceAdded::Create(api_service);
   scoped_ptr<Event> event(
       new Event(apibtle::OnServiceAdded::kEventName, args.Pass()));
   EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 }
 
 void BluetoothLowEnergyEventRouter::GattServiceChanged(
     BluetoothAdapter* adapter,
     BluetoothGattService* service) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT service changed: " << service->GetIdentifier();
   DCHECK(service_id_to_device_address_.find(service->GetIdentifier()) !=
          service_id_to_device_address_.end());
 
   // Signal API event.
   apibtle::Service api_service;
   PopulateService(service, &api_service);
 
   DispatchEventToExtensionsWithPermission(
       apibtle::OnServiceChanged::kEventName,
       service->GetUUID(),
       "" /* characteristic_id */,
       apibtle::OnServiceChanged::Create(api_service));
 }
 
 void BluetoothLowEnergyEventRouter::GattCharacteristicAdded(
     BluetoothAdapter* adapter,
     BluetoothGattCharacteristic* characteristic) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT characteristic added: " << characteristic->GetIdentifier();
 
   BluetoothGattService* service = characteristic->GetService();
   DCHECK(service);
 
   DCHECK(chrc_id_to_service_id_.find(characteristic->GetIdentifier()) ==
          chrc_id_to_service_id_.end());
   DCHECK(service_id_to_device_address_.find(service->GetIdentifier()) !=
          service_id_to_device_address_.end());
 
   chrc_id_to_service_id_[characteristic->GetIdentifier()] =
       service->GetIdentifier();
 }
 
 void BluetoothLowEnergyEventRouter::GattCharacteristicRemoved(
     BluetoothAdapter* adapter,
     BluetoothGattCharacteristic* characteristic) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT characteristic removed: " << characteristic->GetIdentifier();
 
   BluetoothGattService* service = characteristic->GetService();
   DCHECK(service);
 
   DCHECK(chrc_id_to_service_id_.find(characteristic->GetIdentifier()) !=
          chrc_id_to_service_id_.end());
   DCHECK(service->GetIdentifier() ==
          chrc_id_to_service_id_[characteristic->GetIdentifier()]);
 
   chrc_id_to_service_id_.erase(characteristic->GetIdentifier());
 }
 
 void BluetoothLowEnergyEventRouter::GattDescriptorAdded(
     BluetoothAdapter* adapter,
     BluetoothGattDescriptor* descriptor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT descriptor added: " << descriptor->GetIdentifier();
 
   BluetoothGattCharacteristic* characteristic = descriptor->GetCharacteristic();
   DCHECK(characteristic);
 
   DCHECK(desc_id_to_chrc_id_.find(descriptor->GetIdentifier()) ==
          desc_id_to_chrc_id_.end());
   DCHECK(chrc_id_to_service_id_.find(characteristic->GetIdentifier()) !=
          chrc_id_to_service_id_.end());
 
   desc_id_to_chrc_id_[descriptor->GetIdentifier()] =
       characteristic->GetIdentifier();
 }
 
 void BluetoothLowEnergyEventRouter::GattDescriptorRemoved(
     BluetoothAdapter* adapter,
     BluetoothGattDescriptor* descriptor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT descriptor removed: " << descriptor->GetIdentifier();
 
   BluetoothGattCharacteristic* characteristic = descriptor->GetCharacteristic();
   DCHECK(characteristic);
 
   DCHECK(desc_id_to_chrc_id_.find(descriptor->GetIdentifier()) !=
          desc_id_to_chrc_id_.end());
   DCHECK(characteristic->GetIdentifier() ==
          desc_id_to_chrc_id_[descriptor->GetIdentifier()]);
 
   desc_id_to_chrc_id_.erase(descriptor->GetIdentifier());
 }
 
 void BluetoothLowEnergyEventRouter::GattCharacteristicValueChanged(
     BluetoothAdapter* adapter,
     BluetoothGattCharacteristic* characteristic,
     const std::vector<uint8>& value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT characteristic value changed: "
           << characteristic->GetIdentifier();
 
   BluetoothGattService* service = characteristic->GetService();
   DCHECK(service);
 
   DCHECK(service_id_to_device_address_.find(service->GetIdentifier()) !=
          service_id_to_device_address_.end());
   DCHECK(chrc_id_to_service_id_.find(characteristic->GetIdentifier()) !=
          chrc_id_to_service_id_.end());
@@ skipping 13 matching lines @@
       service->GetUUID(),
       characteristic->GetIdentifier(),
       args.Pass());
 }
 
 void BluetoothLowEnergyEventRouter::GattDescriptorValueChanged(
     BluetoothAdapter* adapter,
     BluetoothGattDescriptor* descriptor,
     const std::vector<uint8>& value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(adapter, adapter_);
+  DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT descriptor value changed: " << descriptor->GetIdentifier();
 
   BluetoothGattCharacteristic* characteristic = descriptor->GetCharacteristic();
   DCHECK(characteristic);
 
   DCHECK(desc_id_to_chrc_id_.find(descriptor->GetIdentifier()) !=
          desc_id_to_chrc_id_.end());
   DCHECK(characteristic->GetIdentifier() ==
          desc_id_to_chrc_id_[descriptor->GetIdentifier()]);
 
@@ skipping 431 matching lines @@
       continue;
 
     manager->Remove(extension_id, *iter);
     return true;
   }
 
   return false;
 }
 
 }  // namespace extensions