bluetooth: Modify DCHECK to conditionals in several BluetoothAdapterChromeOS methods.

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 298 matching lines @@
     const device::BluetoothAdapter::AcquiredCallback& callback,
     const BluetoothAudioSink::ErrorCallback& error_callback) {
   VLOG(1) << "Registering audio sink";
   if (!this->IsPresent()) {
     error_callback.Run(BluetoothAudioSink::ERROR_INVALID_ADAPTER);
     return;
   }
   scoped_refptr<BluetoothAudioSinkChromeOS> audio_sink(
       new BluetoothAudioSinkChromeOS(this));
   audio_sink->Register(
-      options,
-      base::Bind(&BluetoothAdapterChromeOS::OnRegisterAudioSink,
-                 weak_ptr_factory_.GetWeakPtr(), callback, audio_sink),
+      options, base::Bind(&BluetoothAdapterChromeOS::OnRegisterAudioSink,
+                          weak_ptr_factory_.GetWeakPtr(), callback,
+                          error_callback, audio_sink),
       error_callback);
 }
 
 void BluetoothAdapterChromeOS::RemovePairingDelegateInternal(
     BluetoothDevice::PairingDelegate* pairing_delegate) {
-  DCHECK(IsPresent());
   // 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.
   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)
@@ skipping 136 matching lines @@
 
   // 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())
     NotifyDeviceChanged(device_chromeos);
 }
 
 void BluetoothAdapterChromeOS::Released() {
-  DCHECK(IsPresent());
+  VLOG(1) << "Release";
+  if (!IsPresent())
+    return;
   DCHECK(agent_.get());
-  VLOG(1) << "Release";
 
   // Called after we unregister the pairing agent, e.g. when changing I/O
   // capabilities. Nothing much to be done right now.
 }
 
 void BluetoothAdapterChromeOS::RequestPinCode(
     const dbus::ObjectPath& device_path,
     const PinCodeCallback& callback) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
@@ skipping 120 matching lines @@
   callback.Run(REJECTED);
 }
 
 void BluetoothAdapterChromeOS::Cancel() {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
   VLOG(1) << "Cancel";
 }
 
 void BluetoothAdapterChromeOS::OnRegisterAgent() {
-  DCHECK(IsPresent());
   VLOG(1) << "Pairing agent registered, requesting to be made default";
 
   DBusThreadManager::Get()->GetBluetoothAgentManagerClient()->
       RequestDefaultAgent(
           dbus::ObjectPath(kAgentPath),
           base::Bind(&BluetoothAdapterChromeOS::OnRequestDefaultAgent,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&BluetoothAdapterChromeOS::OnRequestDefaultAgentError,
                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothAdapterChromeOS::OnRegisterAgentError(
     const std::string& error_name,
     const std::string& error_message) {
-  DCHECK(IsPresent());
   // Our agent being already registered isn't an error.
   if (error_name == bluetooth_agent_manager::kErrorAlreadyExists)
     return;
 
   LOG(WARNING) << ": Failed to register pairing agent: "
                << error_name << ": " << error_message;
 }
 
 void BluetoothAdapterChromeOS::OnRequestDefaultAgent() {
-  DCHECK(IsPresent());
   VLOG(1) << "Pairing agent now default";
 }
 
 void BluetoothAdapterChromeOS::OnRequestDefaultAgentError(
     const std::string& error_name,
     const std::string& error_message) {
-  DCHECK(IsPresent());
   LOG(WARNING) << ": Failed to make pairing agent default: "
                << error_name << ": " << error_message;
 }
 
 void BluetoothAdapterChromeOS::OnRegisterAudioSink(
     const device::BluetoothAdapter::AcquiredCallback& callback,
+    const device::BluetoothAudioSink::ErrorCallback& error_callback,
     scoped_refptr<BluetoothAudioSink> audio_sink) {
+  if (!IsPresent()) {
+    VLOG(1) << "Failed to register audio sink, adapter not present";
+    error_callback.Run(BluetoothAudioSink::ERROR_INVALID_ADAPTER);
+    return;
+  }
   DCHECK(audio_sink.get());
   callback.Run(audio_sink);
 }
 
 BluetoothDeviceChromeOS*
 BluetoothAdapterChromeOS::GetDeviceWithPath(
     const dbus::ObjectPath& object_path) {
   if (!IsPresent())
     return NULL;
 
@@ skipping 335 matching lines @@
                << ": Failed to register profile: " << error_name << ": "
                << error_message;
   error_callback.Run(error_message);
   ReleaseProfile(uuid);
 }
 
 void BluetoothAdapterChromeOS::OnSetDiscoverable(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     bool success) {
-  DCHECK(IsPresent());
+  if (!IsPresent()) {
+    error_callback.Run();
+    return;
+  }
+
   // Set the discoverable_timeout property to zero so the adapter remains
   // discoverable forever.
   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
       GetProperties(object_path_)->discoverable_timeout.Set(
           0,
           base::Bind(&BluetoothAdapterChromeOS::OnPropertyChangeCompleted,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback,
                      error_callback));
 }
 
 void BluetoothAdapterChromeOS::OnPropertyChangeCompleted(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     bool success) {
-  DCHECK(IsPresent());
-  if (success)
+  if (IsPresent() && success)
     callback.Run();
   else
     error_callback.Run();
 }
 
 void BluetoothAdapterChromeOS::AddDiscoverySession(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run();
@@ skipping 17 matching lines @@
     num_discovery_sessions_++;
     callback.Run();
     return;
   }
 
   // There are no active discovery sessions.
   DCHECK_EQ(num_discovery_sessions_, 0);
 
   // 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),
-          base::Bind(&BluetoothAdapterChromeOS::OnStartDiscoveryError,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback,
-                     error_callback));
+  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));
 }
 
 void BluetoothAdapterChromeOS::RemoveDiscoverySession(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
-  DCHECK(IsPresent());
+  if (!IsPresent()) {
+    error_callback.Run();
+    return;
+  }
+
   VLOG(1) << __func__;
   // There are active sessions other than the one currently being removed.
   if (num_discovery_sessions_ > 1) {
     DCHECK(IsDiscovering());
     DCHECK(!discovery_request_pending_);
     num_discovery_sessions_--;
     callback.Run();
     return;
   }
 
@@ skipping 23 matching lines @@
       StopDiscovery(
           object_path_,
           base::Bind(&BluetoothAdapterChromeOS::OnStopDiscovery,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback),
           base::Bind(&BluetoothAdapterChromeOS::OnStopDiscoveryError,
                      weak_ptr_factory_.GetWeakPtr(),
                      error_callback));
 }
 
-void BluetoothAdapterChromeOS::OnStartDiscovery(const base::Closure& callback) {
-  DCHECK(IsPresent());
+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_++;
-  callback.Run();
+  if (IsPresent())
+    callback.Run();
+  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) {
-  DCHECK(IsPresent());
   LOG(WARNING) << object_path_.value() << ": Failed to start discovery: "
                << error_name << ": " << error_message;
 
   // Failed to start discovery. This can only happen if the count is at 0.
   DCHECK_EQ(num_discovery_sessions_, 0);
   DCHECK(discovery_request_pending_);
   discovery_request_pending_ = false;
 
   // Discovery request may fail if discovery was previously initiated by Chrome,
   // but the session were invalidated due to the discovery state unexpectedly
   // changing to false and then back to true. In this case, report success.
-  if (error_name == bluetooth_device::kErrorInProgress && IsDiscovering()) {
+  if (IsPresent() && error_name == bluetooth_device::kErrorInProgress &&
+      IsDiscovering()) {
     VLOG(1) << "Discovery previously initiated. Reporting success.";
     num_discovery_sessions_++;
     callback.Run();
   } else {
     error_callback.Run();
   }
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterChromeOS::OnStopDiscovery(const base::Closure& callback) {
-  DCHECK(IsPresent());
   // Report success on the original request and decrement the count.
   VLOG(1) << __func__;
   DCHECK(discovery_request_pending_);
   DCHECK_EQ(num_discovery_sessions_, 1);
   discovery_request_pending_ = false;
   num_discovery_sessions_--;
   callback.Run();
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterChromeOS::OnStopDiscoveryError(
     const ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
-  DCHECK(IsPresent());
   LOG(WARNING) << object_path_.value() << ": Failed to stop discovery: "
                << error_name << ": " << error_message;
 
   // Failed to stop discovery. This can only happen if the count is at 1.
   DCHECK(discovery_request_pending_);
   DCHECK_EQ(num_discovery_sessions_, 1);
   discovery_request_pending_ = false;
   error_callback.Run();
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterChromeOS::ProcessQueuedDiscoveryRequests() {
   while (!discovery_request_queue_.empty()) {
     VLOG(1) << "Process queued discovery request.";
     DiscoveryCallbackPair callbacks = discovery_request_queue_.front();
     discovery_request_queue_.pop();
     AddDiscoverySession(callbacks.first, callbacks.second);
 
     // 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