Submission for C++ Readability

device/bluetooth/bluetooth_adapter_chromeos.cc

 // Copyright 2013 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_chromeos.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 49 matching lines @@
 }  // namespace
 
 namespace device {
 
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter(
     const InitCallback& init_callback) {
   return chromeos::BluetoothAdapterChromeOS::CreateAdapter();
 }
 
-}
+}  // namespace device
 
 namespace chromeos {
 
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapterChromeOS::CreateAdapter() {
   BluetoothAdapterChromeOS* adapter = new BluetoothAdapterChromeOS();
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 void BluetoothAdapterChromeOS::Shutdown() {
   if (dbus_is_shutdown_)
     return;
   DCHECK(DBusThreadManager::IsInitialized())
       << "Call BluetoothAdapterFactory::Shutdown() before "
          "DBusThreadManager::Shutdown().";
 
   if (IsPresent())
     RemoveAdapter();  // Also deletes devices_.
   DCHECK(devices_.empty());
-  // profiles_ should be empty because all BluetoothSockets have been signaled
+  // profiles_ is empty because all BluetoothSockets have been notified
   // that this adapter is disappearing.
   DCHECK(profiles_.empty());
 
   for (auto& it : profile_queues_)
     delete it.second;
   profile_queues_.clear();
 
   DBusThreadManager::Get()->GetBluetoothAdapterClient()->RemoveObserver(this);
   DBusThreadManager::Get()->GetBluetoothDeviceClient()->RemoveObserver(this);
   DBusThreadManager::Get()->GetBluetoothInputClient()->RemoveObserver(this);
@@ skipping 216 matching lines @@
     scoped_ptr<device::BluetoothAdvertisement::Data> advertisement_data,
     const CreateAdvertisementCallback& callback,
     const CreateAdvertisementErrorCallback& error_callback) {
   scoped_refptr<BluetoothAdvertisementChromeOS> advertisement(
       new BluetoothAdvertisementChromeOS(advertisement_data.Pass(), this));
   advertisement->Register(base::Bind(callback, advertisement), error_callback);
 }
 
 void BluetoothAdapterChromeOS::RemovePairingDelegateInternal(
     BluetoothDevice::PairingDelegate* pairing_delegate) {
-  // Before removing a pairing delegate make sure that there aren't any devices
-  // currently using it; if there are, clear the pairing context which will
-  // make any responses no-ops.
+  // Check if any device is using the pairing delegate.
+  // If so, clear the pairing context which will make any responses no-ops.
   for (DevicesMap::iterator iter = devices_.begin();
        iter != devices_.end(); ++iter) {
     BluetoothDeviceChromeOS* device_chromeos =
         static_cast<BluetoothDeviceChromeOS*>(iter->second);
 
     BluetoothPairingChromeOS* pairing = device_chromeos->GetPairing();
     if (pairing && pairing->GetPairingDelegate() == pairing_delegate)
       device_chromeos->EndPairing();
   }
 }
@@ skipping 15 matching lines @@
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   if (object_path != object_path_)
     return;
   DCHECK(IsPresent());
 
   BluetoothAdapterClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
           GetProperties(object_path_);
 
-  if (property_name == properties->powered.name())
+  if (property_name == properties->powered.name()) {
     PoweredChanged(properties->powered.value());
-  else if (property_name == properties->discoverable.name())
+  } else if (property_name == properties->discoverable.name()) {
     DiscoverableChanged(properties->discoverable.value());
-  else if (property_name == properties->discovering.name())
+  } else if (property_name == properties->discovering.name()) {
     DiscoveringChanged(properties->discovering.value());
+  }
 }
 
 void BluetoothAdapterChromeOS::DeviceAdded(
   const dbus::ObjectPath& object_path) {
   DCHECK(DBusThreadManager::Get());
   BluetoothDeviceClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothDeviceClient()->
           GetProperties(object_path);
   if (!properties || properties->adapter.value() != object_path_)
     return;
@@ skipping 41 matching lines @@
           GetProperties(object_path);
 
   if (property_name == properties->bluetooth_class.name() ||
       property_name == properties->address.name() ||
       property_name == properties->alias.name() ||
       property_name == properties->paired.name() ||
       property_name == properties->trusted.name() ||
       property_name == properties->connected.name() ||
       property_name == properties->uuids.name() ||
       property_name == properties->rssi.name() ||
-      property_name == properties->tx_power.name())
+      property_name == properties->tx_power.name()) {
     NotifyDeviceChanged(device_chromeos);
+  }
 
   // When a device becomes paired, mark it as trusted so that the user does
   // not need to approve every incoming connection
   if (property_name == properties->paired.name() &&
-      properties->paired.value() && !properties->trusted.value())
+      properties->paired.value() && !properties->trusted.value()) {
     device_chromeos->SetTrusted();
+  }
 
   // UMA connection counting
   if (property_name == properties->connected.name()) {
     // PlayStation joystick tries to reconnect after disconnection from USB.
     // If it is still not trusted, set it, so it becomes available on the
     // list of known devices.
     if (properties->connected.value() && device_chromeos->IsTrustable() &&
         !properties->trusted.value())
       device_chromeos->SetTrusted();
 
@@ skipping 16 matching lines @@
   if (!device_chromeos)
     return;
 
   BluetoothInputClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothInputClient()->
           GetProperties(object_path);
 
   // Properties structure can be removed, which triggers a change in the
   // BluetoothDevice::IsConnectable() property, as does a change in the
   // actual reconnect_mode property.
-  if (!properties ||
-      property_name == properties->reconnect_mode.name())
+  if (!properties || property_name == properties->reconnect_mode.name()) {
     NotifyDeviceChanged(device_chromeos);
+  }
 }
 
 void BluetoothAdapterChromeOS::Released() {
   VLOG(1) << "Release";
   if (!IsPresent())
     return;
   DCHECK(agent_.get());
 
   // Called after we unregister the pairing agent, e.g. when changing I/O
   // capabilities. Nothing much to be done right now.
@@ skipping 177 matching lines @@
     return;
   }
   DCHECK(audio_sink.get());
   callback.Run(audio_sink);
 }
 
 BluetoothDeviceChromeOS*
 BluetoothAdapterChromeOS::GetDeviceWithPath(
     const dbus::ObjectPath& object_path) {
   if (!IsPresent())
-    return NULL;
+    return nullptr;
 
   for (DevicesMap::iterator iter = devices_.begin(); iter != devices_.end();
        ++iter) {
     BluetoothDeviceChromeOS* device_chromeos =
         static_cast<BluetoothDeviceChromeOS*>(iter->second);
     if (device_chromeos->object_path() == object_path)
       return device_chromeos;
   }
 
-  return NULL;
+  return nullptr;
 }
 
 BluetoothPairingChromeOS* BluetoothAdapterChromeOS::GetPairing(
     const dbus::ObjectPath& object_path) {
   DCHECK(IsPresent());
   BluetoothDeviceChromeOS* device_chromeos = GetDeviceWithPath(object_path);
   if (!device_chromeos) {
     LOG(WARNING) << "Pairing Agent request for unknown device: "
                  << object_path.value();
-    return NULL;
+    return nullptr;
   }
 
   BluetoothPairingChromeOS* pairing = device_chromeos->GetPairing();
   if (pairing)
     return pairing;
 
   // The device doesn't have its own pairing context, so this is an incoming
   // pairing request that should use our best default delegate (if we have one).
   BluetoothDevice::PairingDelegate* pairing_delegate = DefaultPairingDelegate();
   if (!pairing_delegate)
-    return NULL;
+    return nullptr;
 
   return device_chromeos->BeginPairing(pairing_delegate);
 }
 
 void BluetoothAdapterChromeOS::SetAdapter(const dbus::ObjectPath& object_path) {
   DCHECK(!IsPresent());
   DCHECK(!dbus_is_shutdown_);
   object_path_ = object_path;
 
   VLOG(1) << object_path_.value() << ": using adapter.";
@@ skipping 88 matching lines @@
 void BluetoothAdapterChromeOS::DiscoverableChanged(bool discoverable) {
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     AdapterDiscoverableChanged(this, discoverable));
 }
 
 void BluetoothAdapterChromeOS::DiscoveringChanged(
     bool discovering) {
   // If the adapter stopped discovery due to a reason other than a request by
   // us, reset the count to 0.
   VLOG(1) << "Discovering changed: " << discovering;
-  if (!discovering && !discovery_request_pending_
-      && num_discovery_sessions_ > 0) {
+  if (!discovering && !discovery_request_pending_ &&
+      num_discovery_sessions_ > 0) {
     VLOG(1) << "Marking sessions as inactive.";
     num_discovery_sessions_ = 0;
     MarkDiscoverySessionsAsInactive();
   }
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     AdapterDiscoveringChanged(this, discovering));
 }
 
 void BluetoothAdapterChromeOS::PresentChanged(bool present) {
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     AdapterPresentChanged(this, present));
 }
 
 void BluetoothAdapterChromeOS::NotifyDeviceChanged(
     BluetoothDeviceChromeOS* device) {
+  DCHECK(device);
   DCHECK(device->adapter_ == this);
 
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     DeviceChanged(this, device));
 }
 
 void BluetoothAdapterChromeOS::NotifyGattServiceAdded(
     BluetoothRemoteGattServiceChromeOS* service) {
   DCHECK_EQ(service->GetAdapter(), this);
   DCHECK_EQ(
@@ skipping 228 matching lines @@
           base::Bind(&BluetoothAdapterChromeOS::OnPropertyChangeCompleted,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback,
                      error_callback));
 }
 
 void BluetoothAdapterChromeOS::OnPropertyChangeCompleted(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     bool success) {
-  if (IsPresent() && success)
+  if (IsPresent() && success) {
     callback.Run();
-  else
+  } else {
     error_callback.Run();
+  }
 }
 
 void BluetoothAdapterChromeOS::AddDiscoverySession(
     BluetoothDiscoveryFilter* discovery_filter,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run();
     return;
   }
@@ skipping 29 matching lines @@
     scoped_ptr<BluetoothDiscoveryFilter> df(new BluetoothDiscoveryFilter(
         BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL));
     df->CopyFrom(*discovery_filter);
     SetDiscoveryFilter(
         df.Pass(),
         base::Bind(&BluetoothAdapterChromeOS::OnPreSetDiscoveryFilter,
                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
         base::Bind(&BluetoothAdapterChromeOS::OnPreSetDiscoveryFilterError,
                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
     return;
-  } else
+  } else {
     current_filter_.reset();
+  }
 
   // This is the first request to start device discovery.
   discovery_request_pending_ = true;
   DBusThreadManager::Get()->GetBluetoothAdapterClient()->StartDiscovery(
       object_path_,
       base::Bind(&BluetoothAdapterChromeOS::OnStartDiscovery,
                  weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
       base::Bind(&BluetoothAdapterChromeOS::OnStartDiscoveryError,
                  weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
@@ skipping 123 matching lines @@
 
 void BluetoothAdapterChromeOS::OnStartDiscovery(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   // Report success on the original request and increment the count.
   VLOG(1) << __func__;
   DCHECK(discovery_request_pending_);
   DCHECK_EQ(num_discovery_sessions_, 0);
   discovery_request_pending_ = false;
   num_discovery_sessions_++;
-  if (IsPresent())
+  if (IsPresent()) {
     callback.Run();
-  else
+  } else {
     error_callback.Run();
+  }
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterChromeOS::OnStartDiscoveryError(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
@@ skipping 83 matching lines @@
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterChromeOS::OnSetDiscoveryFilter(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   // Report success on the original request and increment the count.
   VLOG(1) << __func__;
-  if (IsPresent())
+  if (IsPresent()) {
     callback.Run();
-  else
+  } else {
     error_callback.Run();
+  }
 }
 
 void BluetoothAdapterChromeOS::OnSetDiscoveryFilterError(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   LOG(WARNING) << object_path_.value()
                << ": Failed to set discovery filter: " << error_name << ": "
                << error_message;
@@ skipping 14 matching lines @@
 
     // If the queued request resulted in a pending call, then let it
     // asynchonously process the remaining queued requests once the pending
     // call returns.
     if (discovery_request_pending_)
       return;
   }
 }
 
 }  // namespace chromeos