Fix BluetoothAdapterProfileChromeOS lifecycle management

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 67 matching lines @@
 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());
+  DCHECK(profiles_.empty());

[armansito, 2015/02/24 23:32:51]

Is this because RemoveAdapter clears |profiles_|? If so, add a note above ("//
Cleans up |devices_| and |profiles_|.")

[Marie Janssen, 2015/02/27 18:56:58]

RemoveAdapter() signals the profiles through PresentChanged(false), which should
clean up all the profiles_.  Added a clarifying comment.

 
   DBusThreadManager::Get()->GetBluetoothAdapterClient()->RemoveObserver(this);
   DBusThreadManager::Get()->GetBluetoothDeviceClient()->RemoveObserver(this);
   DBusThreadManager::Get()->GetBluetoothInputClient()->RemoveObserver(this);
 
   VLOG(1) << "Unregistering pairing agent";
   DBusThreadManager::Get()->GetBluetoothAgentManagerClient()->UnregisterAgent(
       dbus::ObjectPath(kAgentPath), base::Bind(&base::DoNothing),
       base::Bind(&OnUnregisterAgentError));
 
@@ skipping 859 matching lines @@
 
   if (profiles_.find(uuid) != profiles_.end()) {
     // TODO(jamuraa) check that the options are the same and error when they are
     // not.
     SetProfileDelegate(uuid, device_path, delegate, success_callback,
                        error_callback);
     return;
   }
 
   profiles_[uuid] = BluetoothAdapterProfileChromeOS::Register(
-      this, uuid, options,
+      uuid, options,
       base::Bind(&BluetoothAdapterChromeOS::OnRegisterProfile, this, uuid,
                  device_path, delegate, success_callback, error_callback),
       base::Bind(&BluetoothAdapterChromeOS::OnRegisterProfileError, this, uuid,
                  error_callback));
 }
 
-void BluetoothAdapterChromeOS::ReleaseProfile(const BluetoothUUID& uuid) {
+void BluetoothAdapterChromeOS::ReleaseProfile(
+    const dbus::ObjectPath& device_path,
+    BluetoothAdapterProfileChromeOS* profile) {

[armansito, 2015/02/24 23:32:51]

Add VLOG

[Marie Janssen, 2015/02/27 18:56:58]

Done.

+  profile->RemoveDelegate(
+      device_path, base::Bind(&BluetoothAdapterChromeOS::RemoveProfile,
+                              weak_ptr_factory_.GetWeakPtr(), profile->uuid()));
+}
+
+void BluetoothAdapterChromeOS::RemoveProfile(const BluetoothUUID& uuid) {
   if (profiles_.find(uuid) != profiles_.end()) {
     delete profiles_[uuid];
     profiles_.erase(uuid);
   }
 }
 
 void BluetoothAdapterChromeOS::OnRegisterProfile(
     const BluetoothUUID& uuid,
     const dbus::ObjectPath& device_path,
     BluetoothProfileServiceProvider::Delegate* delegate,
@@ skipping 16 matching lines @@
   // Already set
   error_callback.Run(bluetooth_agent_manager::kErrorAlreadyExists);
   return false;
 }
 
 void BluetoothAdapterChromeOS::OnRegisterProfileError(
     const BluetoothUUID& uuid,
     const ErrorCompletionCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   LOG(WARNING) << object_path_.value()

[armansito, 2015/02/24 23:32:51]

Change this to VLOG

[Marie Janssen, 2015/02/27 18:56:58]

Done.

                << ": Failed to register profile: " << error_name << ": "
                << error_message;
+  delete profiles_[uuid];
+  profiles_.erase(uuid);

[armansito, 2015/02/24 23:32:51]

I think you can simplify the memory management here. Instead of returning a
profile pointer directly from BluetoothAdapterProfileChromeOS::Register, you can
change the success callback signature to accept a
scoped_ptr<BluetoothAdapterProfileChromeOS>. In the success callback, you could
then take ownership of the scoped_ptr while setting profiles_[uuid] and simply
do nothing in the error callback.

This would mean that you would have to change how you condition the
SetProfileDelegate case in ::UseProfile above but I think it's already
inconsistent in the following case:

1. I call UseProfile, it tries to register BluetoothAdapterProfileChromeOS, the
call is pending.

2. I call UseProfile, it calls SetProfileDelegate and calls my success callback
with a pointer to the profile.

3. My call from #1 fails, the profile gets deleted and my error callback is
called. The initial pointer that I received in the intermediate success callback
is invalid.

[Marie Janssen, 2015/02/27 18:56:58]

I've reworked this to avoid these problems.  Now the callbacks go onto a queue
for when the profile suceeds / fails, with all clients getting the profile (or
error) when the single RegisterProfile returns.

   error_callback.Run(error_message);
-  ReleaseProfile(uuid);
 }
 
 void BluetoothAdapterChromeOS::OnSetDiscoverable(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     bool success) {
   DCHECK(IsPresent());
   // Set the discoverable_timeout property to zero so the adapter remains
   // discoverable forever.
   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
@@ skipping 191 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