favor DCHECK_CURRENTLY_ON for better logs in extensions/

extensions/browser/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 "extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_event_router.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 169 matching lines @@
   return error_status;
 }
 
 }  // namespace
 
 namespace extensions {
 
 BluetoothLowEnergyEventRouter::BluetoothLowEnergyEventRouter(
     content::BrowserContext* context)
     : adapter_(NULL), browser_context_(context), weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(browser_context_);
   VLOG(1) << "Initializing BluetoothLowEnergyEventRouter.";
 
   if (!IsBluetoothSupported()) {
     VLOG(1) << "Bluetooth not supported on the current platform.";
     return;
   }
 }
 
 BluetoothLowEnergyEventRouter::~BluetoothLowEnergyEventRouter() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!adapter_.get())
     return;
 
   adapter_->RemoveObserver(this);
   adapter_ = NULL;
 }
 
 bool BluetoothLowEnergyEventRouter::IsBluetoothSupported() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return adapter_.get() ||
          BluetoothAdapterFactory::IsBluetoothAdapterAvailable();
 }
 
 bool BluetoothLowEnergyEventRouter::InitializeAdapterAndInvokeCallback(
     const base::Closure& callback) {
   if (!IsBluetoothSupported())
     return false;
 
   if (adapter_.get()) {
@@ skipping 11 matching lines @@
 bool BluetoothLowEnergyEventRouter::HasAdapter() const {
   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));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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) {
@@ skipping 34 matching lines @@
                  extension_id,
                  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));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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) {
@@ skipping 14 matching lines @@
       base::Bind(&BluetoothLowEnergyEventRouter::OnDisconnect,
                  weak_ptr_factory_.GetWeakPtr(),
                  extension_id,
                  device_address,
                  callback));
 }
 
 bool BluetoothLowEnergyEventRouter::GetServices(
     const std::string& device_address,
     ServiceList* out_services) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(out_services);
   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 @@
 
     out_services->push_back(api_service);
   }
 
   return true;
 }
 
 BluetoothLowEnergyEventRouter::Status BluetoothLowEnergyEventRouter::GetService(
     const std::string& instance_id,
     apibtle::Service* out_service) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(out_service);
   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_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(out_services);
   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 16 matching lines @@
   }
 
   return kStatusSuccess;
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetCharacteristics(
     const Extension* extension,
     const std::string& instance_id,
     CharacteristicList* out_characteristics) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   DCHECK(out_characteristics);
   if (!adapter_.get()) {
     VLOG(1) << "BlutoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattService* service = FindServiceById(instance_id);
   if (!service) {
     VLOG(1) << "Service not found: " << instance_id;
@@ skipping 25 matching lines @@
   }
 
   return kStatusSuccess;
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetCharacteristic(
     const Extension* extension,
     const std::string& instance_id,
     apibtle::Characteristic* out_characteristic) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   DCHECK(out_characteristic);
   if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattCharacteristic* characteristic =
       FindCharacteristicById(instance_id);
   if (!characteristic) {
@@ skipping 11 matching lines @@
 
   PopulateCharacteristic(characteristic, out_characteristic);
   return kStatusSuccess;
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetDescriptors(
     const Extension* extension,
     const std::string& instance_id,
     DescriptorList* out_descriptors) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   DCHECK(out_descriptors);
   if (!adapter_.get()) {
     VLOG(1) << "BlutoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattCharacteristic* characteristic =
       FindCharacteristicById(instance_id);
   if (!characteristic) {
@@ skipping 26 matching lines @@
   }
 
   return kStatusSuccess;
 }
 
 BluetoothLowEnergyEventRouter::Status
 BluetoothLowEnergyEventRouter::GetDescriptor(
     const Extension* extension,
     const std::string& instance_id,
     core_api::bluetooth_low_energy::Descriptor* out_descriptor) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   DCHECK(out_descriptor);
   if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     return kStatusErrorFailed;
   }
 
   BluetoothGattDescriptor* descriptor = FindDescriptorById(instance_id);
   if (!descriptor) {
     VLOG(1) << "Descriptor not found: " << instance_id;
@@ skipping 10 matching lines @@
 
   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_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   BluetoothGattCharacteristic* characteristic =
       FindCharacteristicById(instance_id);
   if (!characteristic) {
@@ skipping 19 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  error_callback));
 }
 
 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_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   if (!adapter_.get()) {
     VLOG(1) << "BluetoothAdapter not ready.";
     error_callback.Run(kStatusErrorFailed);
     return;
   }
 
   BluetoothGattCharacteristic* characteristic =
       FindCharacteristicById(instance_id);
   if (!characteristic) {
@@ skipping 18 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  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));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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) {
@@ skipping 44 matching lines @@
                  extension_id,
                  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));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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);
@@ skipping 10 matching lines @@
                  extension_id,
                  instance_id,
                  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_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   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;
@@ skipping 18 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  error_callback));
 }
 
 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_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(extension);
   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;
@@ skipping 21 matching lines @@
 void BluetoothLowEnergyEventRouter::SetAdapterForTesting(
     device::BluetoothAdapter* adapter) {
   adapter_ = adapter;
   InitializeIdentifierMappings();
 }
 
 void BluetoothLowEnergyEventRouter::GattServiceAdded(
     BluetoothAdapter* adapter,
     BluetoothDevice* device,
     BluetoothGattService* service) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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_CURRENTLY_ON(BrowserThread::UI);
   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_CURRENTLY_ON(BrowserThread::UI);
   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_CURRENTLY_ON(BrowserThread::UI);
   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_CURRENTLY_ON(BrowserThread::UI);
   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_CURRENTLY_ON(BrowserThread::UI);
   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_CURRENTLY_ON(BrowserThread::UI);
   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_CURRENTLY_ON(BrowserThread::UI);
   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_CURRENTLY_ON(BrowserThread::UI);
   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()) !=
@@ skipping 13 matching lines @@
       apibtle::OnCharacteristicValueChanged::kEventName,
       service->GetUUID(),
       characteristic->GetIdentifier(),
       args.Pass());
 }
 
 void BluetoothLowEnergyEventRouter::GattDescriptorValueChanged(
     BluetoothAdapter* adapter,
     BluetoothGattDescriptor* descriptor,
     const std::vector<uint8>& value) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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 20 matching lines @@
 
   // Initialize instance ID mappings for all discovered GATT objects and add
   // observers.
   InitializeIdentifierMappings();
   adapter_->AddObserver(this);
 
   callback.Run();
 }
 
 void BluetoothLowEnergyEventRouter::InitializeIdentifierMappings() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(service_id_to_device_address_.empty());
   DCHECK(chrc_id_to_service_id_.empty());
 
   // Devices
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   for (BluetoothAdapter::DeviceList::iterator iter = devices.begin();
        iter != devices.end();
        ++iter) {
     BluetoothDevice* device = *iter;
 
@@ skipping 409 matching lines @@
       continue;
 
     manager->Remove(extension_id, *iter);
     return true;
   }
 
   return false;
 }
 
 }  // namespace extensions