Bootstrapping: Send meaningful error code/message from Slave to Master

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"
@@ skipping 132 matching lines @@
       ProtoDecoder::SendHostStatus(host_status, &size));
 
   controller_socket_->Send(
       io_buffer, size,
       base::Bind(&BluetoothHostPairingController::OnSendComplete,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnSendError,
                  ptr_factory_.GetWeakPtr()));
 }
 
+void BluetoothHostPairingController::SendErrorCodeAndMessage() {
+  if (error_code_ ==
+      static_cast<int>(HostPairingController::ErrorCode::ERROR_NONE)) {
+    return;
+  }
+
+  pairing_api::Error error_status;
+  error_status.set_api_version(kPairingAPIVersion);
+  error_status.mutable_parameters()->set_code(error_code_);
+  error_status.mutable_parameters()->set_description(error_message_);
+
+  int size = 0;
+  scoped_refptr<net::IOBuffer> io_buffer(
+      ProtoDecoder::SendError(error_status, &size));
+
+  controller_socket_->Send(
+      io_buffer, size,
+      base::Bind(&BluetoothHostPairingController::OnSendComplete,
+                 ptr_factory_.GetWeakPtr()),
+      base::Bind(&BluetoothHostPairingController::OnSendError,
+                 ptr_factory_.GetWeakPtr()));
+}
+
 void BluetoothHostPairingController::Reset() {
   if (adapter_.get()) {
     device::BluetoothDevice* device =
         adapter_->GetDevice(controller_device_address_);
     if (device && device->IsPaired()) {
       device->Forget(base::Bind(&BluetoothHostPairingController::OnForget,
                                 ptr_factory_.GetWeakPtr()),
                      base::Bind(&BluetoothHostPairingController::OnForget,
                                 ptr_factory_.GetWeakPtr()));
       return;
@@ skipping 306 matching lines @@
   return confirmation_code_;
 }
 
 std::string BluetoothHostPairingController::GetEnrollmentDomain() {
   return enrollment_domain_;
 }
 
 void BluetoothHostPairingController::OnNetworkConnectivityChanged(
     Connectivity connectivity_status) {
   connectivity_status_ = connectivity_status;
-  if (connectivity_status == CONNECTIVITY_NONE)
+  if (connectivity_status == CONNECTIVITY_NONE) {
     ChangeStage(STAGE_SETUP_NETWORK_ERROR);
-  SendHostStatus();
+    SendErrorCodeAndMessage();
+  } else {
+    SendHostStatus();
+  }
 }
 
 void BluetoothHostPairingController::OnUpdateStatusChanged(
     UpdateStatus update_status) {
   update_status_ = update_status;
   if (update_status == UPDATE_STATUS_UPDATED)
     ChangeStage(STAGE_WAITING_FOR_CREDENTIALS);
   SendHostStatus();
 }
 
 void BluetoothHostPairingController::OnEnrollmentStatusChanged(
     EnrollmentStatus enrollment_status) {
   DCHECK_EQ(current_stage_, STAGE_ENROLLING);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   enrollment_status_ = enrollment_status;
   if (enrollment_status == ENROLLMENT_STATUS_SUCCESS) {
     ChangeStage(STAGE_ENROLLMENT_SUCCESS);
+    SendHostStatus();
   } else if (enrollment_status == ENROLLMENT_STATUS_FAILURE) {
     ChangeStage(STAGE_ENROLLMENT_ERROR);
+    SendErrorCodeAndMessage();
   }
-  SendHostStatus();
 }
 
 void BluetoothHostPairingController::SetPermanentId(
     const std::string& permanent_id) {
   permanent_id_ = permanent_id;
 }
 
+void BluetoothHostPairingController::SetErrorCodeAndMessage(
+    int error_code,
+    const std::string& error_message) {
+  error_code_ = error_code;
+  error_message_ = error_message;
+}
+
 void BluetoothHostPairingController::RequestPinCode(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 void BluetoothHostPairingController::RequestPasskey(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
@@ skipping 33 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothHostPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos