[Merge to M50] [Chrome OS Bootstrapping]: Do not always power off the Bluetooth adapter.

components/pairing/bluetooth_host_pairing_controller.cc

 // Copyright 2014 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 "components/pairing/bluetooth_host_pairing_controller.h"
 
 #include "base/bind.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
+#include "base/task_runner_util.h"
 #include "chromeos/system/devicetype.h"
 #include "components/pairing/bluetooth_pairing_constants.h"
 #include "components/pairing/pairing_api.pb.h"
 #include "components/pairing/proto_decoder.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "net/base/io_buffer.h"
 
 namespace pairing_chromeos {
 
 namespace {
@@ skipping 60 matching lines @@
     case HostPairingController::ENROLLMENT_STATUS_FAILURE:
       return pairing_api::HostStatusParameters::ENROLLMENT_STATUS_FAILURE;
     case HostPairingController::ENROLLMENT_STATUS_SUCCESS:
       return pairing_api::HostStatusParameters::ENROLLMENT_STATUS_SUCCESS;
     default:
       NOTREACHED();
       return pairing_api::HostStatusParameters::ENROLLMENT_STATUS_UNKNOWN;
   }
 }
 
+std::vector<BluetoothHostPairingController::InputDeviceInfo> GetDevices() {
+  std::vector<BluetoothHostPairingController::InputDeviceInfo> devices;
+  if (device::InputServiceLinux::HasInstance())
+    device::InputServiceLinux::GetInstance()->GetDevices(&devices);
+  return devices;
+}
+
 }  // namespace
 
-BluetoothHostPairingController::BluetoothHostPairingController()
+BluetoothHostPairingController::BluetoothHostPairingController(
+    const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
     : current_stage_(STAGE_NONE),
       connectivity_status_(CONNECTIVITY_UNTESTED),
       update_status_(UPDATE_STATUS_UNKNOWN),
       enrollment_status_(ENROLLMENT_STATUS_UNKNOWN),
       proto_decoder_(new ProtoDecoder(this)),
+      file_task_runner_(file_task_runner),
       ptr_factory_(this) {}
 
 BluetoothHostPairingController::~BluetoothHostPairingController() {
   Reset();
 }
 
 void BluetoothHostPairingController::ChangeStage(Stage new_stage) {
   if (current_stage_ == new_stage)
     return;
   VLOG(1) << "ChangeStage " << new_stage;
@@ skipping 29 matching lines @@
       io_buffer, size,
       base::Bind(&BluetoothHostPairingController::OnSendComplete,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnSendError,
                  ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothHostPairingController::Reset() {
   if (controller_socket_.get()) {
     controller_socket_->Close();
-    controller_socket_ = NULL;
+    controller_socket_ = nullptr;
   }
 
   if (service_socket_.get()) {
     service_socket_->Close();
-    service_socket_ = NULL;
+    service_socket_ = nullptr;
   }
 
   if (adapter_.get()) {
     if (adapter_->IsDiscoverable()) {
       adapter_->SetDiscoverable(false, base::Bind(&base::DoNothing),
                                 base::Bind(&base::DoNothing));
     }
-    if (!was_powered_) {
-      adapter_->SetPowered(false, base::Bind(&base::DoNothing),
-                           base::Bind(&base::DoNothing));
-    }
-    adapter_->RemoveObserver(this);
-    adapter_ = NULL;
+
+    base::PostTaskAndReplyWithResult(
+        file_task_runner_.get(), FROM_HERE, base::Bind(&GetDevices),
+        base::Bind(&BluetoothHostPairingController::PowerOffAdapterIfApplicable,
+                   ptr_factory_.GetWeakPtr()));
   }
   ChangeStage(STAGE_NONE);
 }
 
 void BluetoothHostPairingController::OnGetAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!adapter_.get());
   adapter_ = adapter;
 
@@ skipping 75 matching lines @@
     scoped_refptr<device::BluetoothSocket> socket) {
   DCHECK(thread_checker_.CalledOnValidThread());
   adapter_->SetDiscoverable(
       false,
       base::Bind(&BluetoothHostPairingController::OnSetDiscoverable,
                  ptr_factory_.GetWeakPtr(), false),
       base::Bind(&BluetoothHostPairingController::OnSetError,
                  ptr_factory_.GetWeakPtr()));
 
   controller_socket_ = socket;
-  service_socket_ = NULL;
+  service_socket_ = nullptr;
 
   SendHostStatus();
 
   controller_socket_->Receive(
       kReceiveSize,
       base::Bind(&BluetoothHostPairingController::OnReceiveComplete,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnReceiveError,
                  ptr_factory_.GetWeakPtr()));
 }
@@ skipping 42 matching lines @@
 
 void BluetoothHostPairingController::OnSendError(
     const std::string& error_message) {
   LOG(ERROR) << error_message;
   if (enrollment_status_ != ENROLLMENT_STATUS_ENROLLING &&
       enrollment_status_ != ENROLLMENT_STATUS_SUCCESS) {
     ChangeStage(STAGE_CONTROLLER_CONNECTION_ERROR);
   }
 }
 
+void BluetoothHostPairingController::PowerOffAdapterIfApplicable(
+    const std::vector<InputDeviceInfo>& devices) {
+  bool use_bluetooth = false;
+  for (const auto& device : devices) {
+    if (device.type == InputDeviceInfo::TYPE_BLUETOOTH) {
+      use_bluetooth = true;
+      break;
+    }
+  }
+  if (!was_powered_ && !use_bluetooth) {
+    adapter_->SetPowered(false, base::Bind(&base::DoNothing),
+                         base::Bind(&base::DoNothing));
+  }
+  adapter_->RemoveObserver(this);
+  adapter_ = nullptr;
+}
+
 void BluetoothHostPairingController::OnReceiveError(
     device::BluetoothSocket::ErrorReason reason,
     const std::string& error_message) {
   LOG(ERROR) << reason << ", " << error_message;
   ChangeStage(STAGE_CONTROLLER_CONNECTION_ERROR);
 }
 
 void BluetoothHostPairingController::OnHostStatusMessage(
     const pairing_api::HostStatus& message) {
   NOTREACHED();
@@ skipping 175 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothHostPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos