Clean up protocol for Bluetooth Pairing.

components/pairing/bluetooth_controller_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_controller_pairing_controller.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 74 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   std::set<std::string>::iterator ix =
       discovered_devices_.find(device->GetAddress());
   if (ix != discovered_devices_.end()) {
     discovered_devices_.erase(ix);
     FOR_EACH_OBSERVER(ControllerPairingController::Observer, observers_,
                       DiscoveredDevicesListChanged());
   }
 }
 
+void BluetoothControllerPairingController::SendBuffer(
+    int size, scoped_refptr<net::IOBuffer> io_buffer) {
+  socket_->Send(
+      io_buffer, size,
+      base::Bind(&BluetoothControllerPairingController::OnSendComplete,
+                 ptr_factory_.GetWeakPtr()),
+      base::Bind(&BluetoothControllerPairingController::OnErrorWithMessage,
+                 ptr_factory_.GetWeakPtr()));
+}
+
 void BluetoothControllerPairingController::OnSetPowered() {
   DCHECK(thread_checker_.CalledOnValidThread());
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothControllerPairingController::OnStartDiscoverySession,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothControllerPairingController::OnError,
                  ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothControllerPairingController::OnGetAdapter(
@@ skipping 63 matching lines @@
 
   socket_->Receive(
       kReceiveSize,
       base::Bind(&BluetoothControllerPairingController::OnReceiveComplete,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothControllerPairingController::OnReceiveError,
                  ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothControllerPairingController::OnError() {
-  // TODO(zork): Add a stage for initialization error. (http://crbug.com/405744)
   LOG(ERROR) << "Pairing initialization failed";
+  ChangeStage(STAGE_INITIALIZATION_ERROR);
   Reset();
 }
 
 void BluetoothControllerPairingController::OnErrorWithMessage(
     const std::string& message) {
-  // TODO(zork): Add a stage for initialization error. (http://crbug.com/405744)
   LOG(ERROR) << message;
+  ChangeStage(STAGE_INITIALIZATION_ERROR);
   Reset();
 }
 
 void BluetoothControllerPairingController::OnConnectError(
     device::BluetoothDevice::ConnectErrorCode error_code) {
   DCHECK(thread_checker_.CalledOnValidThread());
   device::BluetoothDevice* device = GetController();
 
   if (device && device->IsPaired()) {
     // The connection attempt is only used to start the pairing between the
@@ skipping 24 matching lines @@
 BluetoothControllerPairingController::GetCurrentStage() {
   return current_stage_;
 }
 
 void BluetoothControllerPairingController::StartPairing() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(current_stage_ == STAGE_NONE ||
          current_stage_ == STAGE_DEVICE_NOT_FOUND ||
          current_stage_ == STAGE_ESTABLISHING_CONNECTION_ERROR ||
          current_stage_ == STAGE_HOST_ENROLLMENT_ERROR);
-  // TODO(zork): Add a stage for no bluetooth. (http://crbug.com/405744)
   if (!device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
-    ChangeStage(STAGE_DEVICE_NOT_FOUND);
+    ChangeStage(STAGE_INITIALIZATION_ERROR);
     return;
   }
 
   device::BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothControllerPairingController::OnGetAdapter,
                  ptr_factory_.GetWeakPtr()));
 
 }
 
 ControllerPairingController::DeviceIdList
@@ skipping 58 matching lines @@
     RepeatDiscovery();
   }
 }
 
 void BluetoothControllerPairingController::SetHostConfiguration(
     bool accepted_eula,
     const std::string& lang,
     const std::string& timezone,
     bool send_reports,
     const std::string& keyboard_layout) {
-  // TODO(zork): Get configuration from UI and send to Host.
-  // (http://crbug.com/405744)
+
+  pairing_api::ConfigureHost host_config;
+  host_config.set_api_version(kPairingAPIVersion);
+  host_config.mutable_parameters()->set_accepted_eula(accepted_eula);
+  host_config.mutable_parameters()->set_lang(lang);
+  host_config.mutable_parameters()->set_timezone(timezone);
+  host_config.mutable_parameters()->set_send_reports(send_reports);
+  host_config.mutable_parameters()->set_keyboard_layout(keyboard_layout);
+
+  int size = 0;
+  scoped_refptr<net::IOBuffer> io_buffer(
+      ProtoDecoder::SendConfigureHost(host_config, &size));
+
+  SendBuffer(size, io_buffer);
 }
 
 void BluetoothControllerPairingController::OnAuthenticationDone(
     const std::string& domain,
     const std::string& auth_token) {
   DCHECK_EQ(current_stage_, STAGE_WAITING_FOR_CREDENTIALS);
 
   pairing_api::PairDevices pair_devices;
   pair_devices.set_api_version(kPairingAPIVersion);
   pair_devices.mutable_parameters()->set_admin_access_token(auth_token);
 
   int size = 0;
   scoped_refptr<net::IOBuffer> io_buffer(
       ProtoDecoder::SendPairDevices(pair_devices, &size));
 
-  socket_->Send(
-      io_buffer, size,
-      base::Bind(&BluetoothControllerPairingController::OnSendComplete,
-                 ptr_factory_.GetWeakPtr()),
-      base::Bind(&BluetoothControllerPairingController::OnErrorWithMessage,
-                 ptr_factory_.GetWeakPtr()));
+  SendBuffer(size, io_buffer);
   ChangeStage(STAGE_HOST_ENROLLMENT_IN_PROGRESS);
 }
 
 void BluetoothControllerPairingController::StartSession() {
   DCHECK_EQ(current_stage_, STAGE_PAIRING_DONE);
   ChangeStage(STAGE_FINISHED);
 }
 
 // ProtoDecoder::Observer:
 void BluetoothControllerPairingController::OnHostStatusMessage(
     const pairing_api::HostStatus& message) {
   if (got_initial_status_) {
     // TODO(zork): Check that the domain matches. (http://crbug.com/405761)
     // TODO(zork): Handling updating stages (http://crbug.com/405754).
     pairing_api::CompleteSetup complete_setup;
     complete_setup.set_api_version(kPairingAPIVersion);
     // TODO(zork): Get AddAnother from UI (http://crbug.com/405757)
     complete_setup.mutable_parameters()->set_add_another(false);
 
     int size = 0;
     scoped_refptr<net::IOBuffer> io_buffer(
         ProtoDecoder::SendCompleteSetup(complete_setup, &size));
 
-    socket_->Send(
-        io_buffer, size,
-        base::Bind(&BluetoothControllerPairingController::OnSendComplete,
-                   ptr_factory_.GetWeakPtr()),
-        base::Bind(
-            &BluetoothControllerPairingController::OnErrorWithMessage,
-            ptr_factory_.GetWeakPtr()));
+    SendBuffer(size, io_buffer);
     ChangeStage(STAGE_PAIRING_DONE);
   } else {
     got_initial_status_ = true;
 
     // TODO(zork): Check domain. (http://crbug.com/405761)
     ChangeStage(STAGE_WAITING_FOR_CREDENTIALS);
   }
 }
 
 void BluetoothControllerPairingController::OnConfigureHostMessage(
@@ skipping 72 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothControllerPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos