Clean up protocol for Bluetooth Pairing.

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/logging.h"
 #include "base/strings/stringprintf.h"
 #include "components/pairing/bluetooth_pairing_constants.h"
@@ skipping 100 matching lines @@
 
   if (adapter_->IsPresent()) {
     SetName();
   } else {
     // Set the name once the adapter is present.
     adapter_->AddObserver(this);
   }
 }
 
 void BluetoothHostPairingController::SetName() {
-  // TODO(zork): Make the device name prettier. (http://crbug.com/405774)
-  device_name_ = base::StringPrintf("%s%s", kDeviceNamePrefix,
-                                    adapter_->GetAddress().c_str());
+  int device_id = 0;
+  for (size_t i = 0; i < adapter_->GetAddress().length(); ++i) {
+    int value = adapter_->GetAddress()[i];
+    if (i % 2) {
+      value *= 0x100;
+    }
+    device_id ^= value;
+  }
+

[dzhioev (left Google), 2014/09/18 04:12:37]

Does this cycle calculate some hash function?
Can we replace it with "devise_id = base::Hash(adapter_->GetAddress()) &
0xFFFF"?

[Zachary Kuznia, 2014/09/18 08:45:47]

Good call, done and done.

+  device_name_ = base::StringPrintf("%s%04X", kDeviceNamePrefix, device_id);

[dzhioev (left Google), 2014/09/18 04:12:37]

You should use 'unsigned int' with 'X' flag.

[Zachary Kuznia, 2014/09/18 08:45:47]

Done.

 
   adapter_->SetName(
       device_name_,
       base::Bind(&BluetoothHostPairingController::OnSetName,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnSetError,
                  ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothHostPairingController::OnSetName() {
@@ skipping 91 matching lines @@
       kReceiveSize,
       base::Bind(&BluetoothHostPairingController::OnReceiveComplete,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnReceiveError,
                  ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothHostPairingController::OnCreateServiceError(
     const std::string& message) {
   LOG(ERROR) << message;
-  // TODO(zork): Add a stage for initialization error. (http://crbug.com/405744)
-  ChangeStage(STAGE_NONE);
+  ChangeStage(STAGE_INITIALIZATION_ERROR);
 }
 
 void BluetoothHostPairingController::OnSetError() {
   adapter_->RemovePairingDelegate(this);
-  // TODO(zork): Add a stage for initialization error. (http://crbug.com/405744)
-  ChangeStage(STAGE_NONE);
+  ChangeStage(STAGE_INITIALIZATION_ERROR);
 }
 
 void BluetoothHostPairingController::OnAcceptError(
     const std::string& error_message) {
   LOG(ERROR) << error_message;
   Reset();
 }
 
 void BluetoothHostPairingController::OnSendError(
     const std::string& error_message) {
   LOG(ERROR) << error_message;
 }
 
 void BluetoothHostPairingController::OnReceiveError(
     device::BluetoothSocket::ErrorReason reason,
     const std::string& error_message) {
   LOG(ERROR) << reason << ", " << error_message;
   Reset();
 }
 
 void BluetoothHostPairingController::OnHostStatusMessage(
     const pairing_api::HostStatus& message) {
   NOTREACHED();
 }
 
 void BluetoothHostPairingController::OnConfigureHostMessage(
     const pairing_api::ConfigureHost& message) {
-  // TODO(zork): Add event to API to handle this case. (http://crbug.com/405744)
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    ConfigureHost(message.parameters().accepted_eula(),
+                                  message.parameters().lang(),
+                                  message.parameters().timezone(),
+                                  message.parameters().send_reports(),
+                                  message.parameters().keyboard_layout()));
 }
 
 void BluetoothHostPairingController::OnPairDevicesMessage(
     const pairing_api::PairDevices& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (current_stage_ != STAGE_WAITING_FOR_CREDENTIALS) {
     AbortWithError(PAIRING_ERROR_PAIRING_OR_ENROLLMENT, kErrorInvalidProtocol);
     return;
   }
 
@@ skipping 49 matching lines @@
 }
 
 HostPairingController::Stage BluetoothHostPairingController::GetCurrentStage() {
   return current_stage_;
 }
 
 void BluetoothHostPairingController::StartPairing() {
   DCHECK_EQ(current_stage_, STAGE_NONE);
   bool bluetooth_available =
       device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable();
-  // TODO(zork): Add a stage for initialization error. (http://crbug.com/405744)
-  if (!bluetooth_available)
+  if (!bluetooth_available) {
+    ChangeStage(STAGE_INITIALIZATION_ERROR);
     return;
+  }
 
   device::BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothHostPairingController::OnGetAdapter,
                  ptr_factory_.GetWeakPtr()));
 }
 
 std::string BluetoothHostPairingController::GetDeviceName() {
   return device_name_;
 }
 
@@ skipping 52 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothHostPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos