[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 "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 "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "net/base/io_buffer.h"
 
 namespace pairing_chromeos {
 
 namespace {
 const int kReceiveSize = 16384;
 
 std::string GetChromeOSDeviceType() {
   switch (chromeos::GetDeviceType()) {
@@ skipping 56 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()
     : current_stage_(STAGE_NONE),
       connectivity_status_(CONNECTIVITY_UNTESTED),
       update_status_(UPDATE_STATUS_UNKNOWN),
       enrollment_status_(ENROLLMENT_STATUS_UNKNOWN),
       proto_decoder_(new ProtoDecoder(this)),
       ptr_factory_(this) {}
 
@@ skipping 50 matching lines @@
   if (service_socket_.get()) {
     service_socket_->Close();
     service_socket_ = NULL;
   }
 
   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;
+
+    content::BrowserThread::PostTaskAndReplyWithResult(
+        content::BrowserThread::FILE, FROM_HERE, base::Bind(&GetDevices),

[achuithb, 2016/05/02 23:02:40]

BrowserThread::FILE is deprecated, please use BlockingPool instead.

Something like this:
https://code.google.com/p/chromium/codesearch#chromium/src/components/feedbac...

[xdai1, 2016/05/03 00:30:26]

I'm not sure I should do that.. In
https://code.google.com/p/chromium/codesearch#chromium/src/device/hid/input_s...
it says all methods in InputServiceLinux should be called from the FILE thread. 

+        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 138 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 (auto& iter : devices) {

[achuithb, 2016/05/02 23:02:40]

const auto& device

The iterator should be const, and device is a better name than iter

[xdai1, 2016/05/03 00:30:26]

Done.

+    if (iter.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_ = NULL;

[achuithb, 2016/05/02 23:02:40]

nullptr here and everywhere in this file please

[xdai1, 2016/05/03 00:30:26]

Done.

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