Migrate Chrome OS Bluetooth UI to the new discovery API.

chrome/browser/ui/webui/options/chromeos/bluetooth_options_handler.cc

 // Copyright (c) 2012 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 "chrome/browser/ui/webui/options/chromeos/bluetooth_options_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 37 matching lines @@
 const char kConfirmPasskey[] = "bluetoothConfirmPasskey";
 
 // An invalid |entered| value to represent the "undefined" value.
 const int kInvalidEntered = 0xFFFF;
 
 }  // namespace
 
 namespace chromeos {
 namespace options {
 
-BluetoothOptionsHandler::BluetoothOptionsHandler() :
-    discovering_(false),
-    pairing_device_passkey_(1000000),
-    pairing_device_entered_(kInvalidEntered),
-    weak_ptr_factory_(this) {
+BluetoothOptionsHandler::BluetoothOptionsHandler()
+    : should_run_device_discovery_(false),
+      pairing_device_passkey_(1000000),
+      pairing_device_entered_(kInvalidEntered),
+      weak_ptr_factory_(this) {
 }
 
 BluetoothOptionsHandler::~BluetoothOptionsHandler() {
-  if (discovering_) {
-    adapter_->StopDiscovering(
-        base::Bind(&base::DoNothing),
-        base::Bind(&base::DoNothing));
-    discovering_ = false;
-  }
   if (adapter_.get())
     adapter_->RemoveObserver(this);
 }
 
 void BluetoothOptionsHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
   static OptionsStringResource resources[] = {
     { "bluetooth", IDS_OPTIONS_SETTINGS_SECTION_TITLE_BLUETOOTH },
@@ skipping 146 matching lines @@
                                   weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothOptionsHandler::EnableChangeError() {
   VLOG(1) << "Failed to change power state.";
   ReportError("bluetoothChangePowerFailed", std::string());
 }
 
 void BluetoothOptionsHandler::FindDevicesCallback(
     const base::ListValue* args) {
-  if (!discovering_) {
-    discovering_ = true;
-    adapter_->StartDiscovering(
-        base::Bind(&base::DoNothing),
-        base::Bind(&BluetoothOptionsHandler::FindDevicesError,
-                   weak_ptr_factory_.GetWeakPtr()));
+  if (discovery_session_.get() && discovery_session_->IsActive()) {
+    VLOG(1) << "Already have an active discovery session.";
+    return;
   }
+  should_run_device_discovery_ = true;
+  adapter_->StartDiscoverySession(
+      base::Bind(&BluetoothOptionsHandler::OnStartDiscoverySession,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&BluetoothOptionsHandler::FindDevicesError,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void BluetoothOptionsHandler::OnStartDiscoverySession(
+    scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
+  // If the discovery session was returned after a request to stop discovery
+  // (e.g. the "Add Device" dialog was dismissed), don't claim the discovery
+  // session and let it clean up.
+  if (!should_run_device_discovery_)
+    return;
+  discovery_session_ = discovery_session.Pass();
 }
 
 void BluetoothOptionsHandler::FindDevicesError() {
   VLOG(1) << "Failed to start discovery.";
   ReportError("bluetoothStartDiscoveryFailed", std::string());
 }
 
 void BluetoothOptionsHandler::UpdateDeviceCallback(
     const base::ListValue* args) {
   std::string address;
@@ skipping 140 matching lines @@
   ReportError("bluetoothDisconnectFailed", address);
 }
 
 void BluetoothOptionsHandler::ForgetError(const std::string& address) {
   VLOG(1) << "Failed to disconnect and unpair device: " << address;
   ReportError("bluetoothForgetFailed", address);
 }
 
 void BluetoothOptionsHandler::StopDiscoveryCallback(
     const base::ListValue* args) {
-  if (discovering_) {
-    adapter_->StopDiscovering(
-        base::Bind(&base::DoNothing),
-        base::Bind(&BluetoothOptionsHandler::StopDiscoveryError,
-                   weak_ptr_factory_.GetWeakPtr()));
-    discovering_ = false;
+  should_run_device_discovery_ = false;
+  if (!discovery_session_.get() || !discovery_session_->IsActive()) {
+    VLOG(1) << "No active discovery session.";
+    return;
   }
+  discovery_session_->Stop(
+      base::Bind(&base::DoNothing),
+      base::Bind(&BluetoothOptionsHandler::StopDiscoveryError,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothOptionsHandler::StopDiscoveryError() {
   VLOG(1) << "Failed to stop discovery.";
   ReportError("bluetoothStopDiscoveryFailed", std::string());
 }
 
 void BluetoothOptionsHandler::GetPairedDevicesCallback(
     const base::ListValue* args) {
   device::BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
@@ skipping 145 matching lines @@
 void BluetoothOptionsHandler::DeviceConnecting(
     device::BluetoothDevice* device) {
   DCHECK(device);
   base::DictionaryValue params;
   params.SetString("pairing", kStartConnecting);
   SendDeviceNotification(device, &params);
 }
 
 }  // namespace options
 }  // namespace chromeos