Migrate Chrome OS Bluetooth UI to the new discovery API.

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/logging.h"
@@ skipping 607 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) {
+    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));
@@ skipping 33 matching lines @@
 }
 
 void BluetoothAdapterChromeOS::AddDiscoverySession(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << __func__;
   if (discovery_request_pending_) {
     // The pending request is either to stop a previous session or to start a
     // new one. Either way, queue this one.
     DCHECK(num_discovery_sessions_ == 1 || num_discovery_sessions_ == 0);
-    VLOG(1) << "Pending request to initiate device discovery. Queueing request "
-            << "to start a new discovery session.";
+    VLOG(1) << "Pending request to start/stop device discovery. Queueing "
+            << "request to start a new discovery session.";
     discovery_request_queue_.push(std::make_pair(callback, error_callback));
     return;
   }
 
   // The adapter is already discovering.
   if (num_discovery_sessions_ > 0) {
     DCHECK(IsDiscovering());
     DCHECK(!discovery_request_pending_);
     num_discovery_sessions_++;
     callback.Run();
     return;
   }
 
   // There are no active discovery sessions.
   DCHECK(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));
 }
 
 void BluetoothAdapterChromeOS::RemoveDiscoverySession(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   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;
   }
 
   // If there is a pending request to BlueZ, then queue this request.
   if (discovery_request_pending_) {
-    VLOG(1) << "Pending request to initiate device discovery. Queueing request "
-            << "to stop discovery session.";
+    VLOG(1) << "Pending request to start/stop device discovery. Queueing "
+            << "request to stop discovery session.";
     error_callback.Run();
     return;
   }
 
   // There are no active sessions. Return error.
   if (num_discovery_sessions_ == 0) {
     // TODO(armansito): This should never happen once we have the
     // DiscoverySession API. Replace this case with an assert once it's
     // the deprecated methods have been removed. (See crbug.com/3445008).
     VLOG(1) << "No active discovery sessions. Returning error.";
@@ skipping 11 matching lines @@
           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) {
   // Report success on the original request and increment the count.
+  VLOG(1) << __func__;
   DCHECK(discovery_request_pending_);
   DCHECK(num_discovery_sessions_ == 0);
   discovery_request_pending_ = false;
   num_discovery_sessions_++;
   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) {
   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(num_discovery_sessions_ == 0);
   DCHECK(discovery_request_pending_);
   discovery_request_pending_ = false;
-  error_callback.Run();
+
+  // 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()) {
+    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) {
   // Report success on the original request and decrement the count.
+  VLOG(1) << __func__;
   DCHECK(discovery_request_pending_);
   DCHECK(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) {
   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(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