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 306 matching lines @@
       new BluetoothAudioSinkChromeOS(this));
   audio_sink->Register(
       options,
       base::Bind(&BluetoothAdapterChromeOS::OnRegisterAudioSink,
                  weak_ptr_factory_.GetWeakPtr(), 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());
+  if (!IsPresent())
+    return;

[armansito, 2015/02/19 01:44:47]

Since we don't really do anything, here I would just omit this. It's nice to at
least do the logging below.

[scheib, 2015/02/19 21:34:15]

Logging moved above return. The conditional return kept as the DCHECK for agent_
will fail after Shutdown().

   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) {
@@ skipping 122 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,
     scoped_refptr<BluetoothAudioSink> audio_sink) {
+  if (!IsPresent())

[armansito, 2015/02/19 01:44:47]

This really shouldn't happen, since this method gets called on the adapter. If
the adapter disappears during the call, then we won't get success here. If we
get success and the adapter disappears in the mean time, then the audio sink
will process it via the observer event.

In either case, we should notify the upper layer via |callback| or
|error_callback| here. I would bind the error_callback to the original call and
invoke it here if the adapter isn't present, and log an error message.

[scheib, 2015/02/19 21:34:15]

Done.

+    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;
+  }

[armansito, 2015/02/19 01:44:47]

nit: newline after '}'.

[scheib, 2015/02/19 21:34:15]

Done.

   // 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 32 matching lines @@
                      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 42 matching lines @@
 
   // 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());
+  if (!IsPresent()) {
+    error_callback.Run();
+    return;
+  }
   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
@@ skipping 21 matching lines @@
   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;
+  if (!IsPresent()) {
+    error_callback.Run();
+    return;
+  }

[armansito, 2015/02/19 01:44:47]

Wouldn't we want to clear the pending discovery requests here and invoke their
error callback?

[scheib, 2015/02/19 21:34:15]

Done.

 
   // 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