Devices shoule not be found by Android enrollment app after successful enrollment.

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/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.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 {
 const int kReceiveSize = 16384;
 
-std::string GetChromeOSDeviceType() {
-  switch (chromeos::GetDeviceType()) {
-    case chromeos::DeviceType::kChromebox:
-      return std::string(kDeviceNamePrefix) + "box";
-    case chromeos::DeviceType::kChromebase:
-      return std::string(kDeviceNamePrefix) + "base";
-    case chromeos::DeviceType::kChromebit:
-      return std::string(kDeviceNamePrefix) + "bit";
-    case chromeos::DeviceType::kChromebook:
-      return std::string(kDeviceNamePrefix) + "book";
-    default:
-      return std::string(kDeviceNamePrefix) + "device";
-  }
-}
-
 pairing_api::HostStatusParameters::Connectivity PairingApiConnectivityStatus(
     HostPairingController::Connectivity connectivity_status) {
   switch (connectivity_status) {
     case HostPairingController::CONNECTIVITY_UNTESTED:
       return pairing_api::HostStatusParameters::CONNECTIVITY_UNTESTED;
     case HostPairingController::CONNECTIVITY_NONE:
       return pairing_api::HostStatusParameters::CONNECTIVITY_NONE;
     case HostPairingController::CONNECTIVITY_LIMITED:
       return pairing_api::HostStatusParameters::CONNECTIVITY_LIMITED;
     case HostPairingController::CONNECTIVITY_CONNECTING:
@@ skipping 129 matching lines @@
   OnForget();
 }
 
 void BluetoothHostPairingController::OnGetAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!adapter_.get());
   adapter_ = adapter;
 
   if (adapter_->IsPresent()) {
-    SetName();
+    SetPowered();
   } else {
     // Set the name once the adapter is present.
     adapter_->AddObserver(this);
   }
 }
 
-void BluetoothHostPairingController::SetName() {
-  // Hash the bluetooth address and take the lower 2 bytes to create a human
-  // readable device name.
-  const uint32_t device_id = base::Hash(adapter_->GetAddress()) & 0xFFFF;
-  device_name_ =
-      base::StringPrintf("%s_%04X", GetChromeOSDeviceType().c_str(), device_id);
-
-  adapter_->SetName(
-      device_name_,
-      base::Bind(&BluetoothHostPairingController::OnSetName,
-                 ptr_factory_.GetWeakPtr()),
-      base::Bind(&BluetoothHostPairingController::OnSetError,
-                 ptr_factory_.GetWeakPtr()));
-}
-
-void BluetoothHostPairingController::OnSetName() {
+void BluetoothHostPairingController::SetPowered() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (adapter_->IsPowered()) {
     was_powered_ = true;
     OnSetPowered();
   } else {
     adapter_->SetPowered(
         true,
         base::Bind(&BluetoothHostPairingController::OnSetPowered,
                    ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothHostPairingController::OnSetError,
@@ skipping 223 matching lines @@
   for (Observer& observer : observers_)
     observer.AddNetworkRequested(message.parameters().onc_spec());
 }
 
 void BluetoothHostPairingController::AdapterPresentChanged(
     device::BluetoothAdapter* adapter,
     bool present) {
   DCHECK_EQ(adapter, adapter_.get());
   if (present) {
     adapter_->RemoveObserver(this);
-    SetName();
+    SetPowered();
   }
 }
 
 void BluetoothHostPairingController::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void BluetoothHostPairingController::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 10 matching lines @@
     ChangeStage(STAGE_INITIALIZATION_ERROR);
     return;
   }
 
   device::BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothHostPairingController::OnGetAdapter,
                  ptr_factory_.GetWeakPtr()));
 }
 
 std::string BluetoothHostPairingController::GetDeviceName() {
-  return device_name_;
+  return adapter_.get() ? adapter_->GetName() : std::string();
 }
 
 std::string BluetoothHostPairingController::GetConfirmationCode() {
   DCHECK_EQ(current_stage_, STAGE_WAITING_FOR_CODE_CONFIRMATION);
   return confirmation_code_;
 }
 
 std::string BluetoothHostPairingController::GetEnrollmentDomain() {
   return enrollment_domain_;
 }
@@ skipping 79 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothHostPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos