Fix update and enrollment flow

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 "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;
+
+pairing_api::HostStatusParameters::UpdateStatus PairingApiUpdateStatus(
+    HostPairingController::UpdateStatus update_status) {
+  switch(update_status) {
+    case HostPairingController::UPDATE_STATUS_UNKNOWN:
+      return pairing_api::HostStatusParameters::UPDATE_STATUS_UNKNOWN;
+    case HostPairingController::UPDATE_STATUS_UPDATING:
+      return pairing_api::HostStatusParameters::UPDATE_STATUS_UPDATING;
+    case HostPairingController::UPDATE_STATUS_REBOOTING:
+      return pairing_api::HostStatusParameters::UPDATE_STATUS_REBOOTING;
+    case HostPairingController::UPDATE_STATUS_UPDATED:
+      return pairing_api::HostStatusParameters::UPDATE_STATUS_UPDATED;
+    default:
+      NOTREACHED();
+      return pairing_api::HostStatusParameters::UPDATE_STATUS_UNKNOWN;
+  }
 }
 
-namespace pairing_chromeos {
+pairing_api::HostStatusParameters::EnrollmentStatus PairingApiEnrollmentStatus(
+    HostPairingController::EnrollmentStatus enrollment_status) {
+  switch(enrollment_status) {
+    case HostPairingController::ENROLLMENT_STATUS_UNKNOWN:
+      return pairing_api::HostStatusParameters::ENROLLMENT_STATUS_UNKNOWN;
+    case HostPairingController::ENROLLMENT_STATUS_ENROLLING:
+      return pairing_api::HostStatusParameters::ENROLLMENT_STATUS_ENROLLING;
+    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;
+  }
+}
+
+}  // namespace
 
 BluetoothHostPairingController::BluetoothHostPairingController()
     : current_stage_(STAGE_NONE),
+      update_status_(UPDATE_STATUS_UNKNOWN),
+      enrollment_status_(ENROLLMENT_STATUS_UNKNOWN),
       device_(NULL),
       proto_decoder_(new ProtoDecoder(this)),
       ptr_factory_(this) {
 }
 
 BluetoothHostPairingController::~BluetoothHostPairingController() {
   if (adapter_.get())
     adapter_->RemoveObserver(this);
 }
 
 void BluetoothHostPairingController::ChangeStage(Stage new_stage) {
   if (current_stage_ == new_stage)
     return;
   VLOG(1) << "ChangeStage " << new_stage;
   current_stage_ = new_stage;
   FOR_EACH_OBSERVER(Observer, observers_, PairingStageChanged(new_stage));
 }
 
 void BluetoothHostPairingController::SendHostStatus() {
   pairing_api::HostStatus host_status;
 
   host_status.set_api_version(kPairingAPIVersion);
   if (!enrollment_domain_.empty())
     host_status.mutable_parameters()->set_domain(enrollment_domain_);
 
   // TODO(zork): Get these values from the UI. (http://crbug.com/405744)
   host_status.mutable_parameters()->set_connectivity(
       pairing_api::HostStatusParameters::CONNECTIVITY_CONNECTED);
   host_status.mutable_parameters()->set_update_status(
-      pairing_api::HostStatusParameters::UPDATE_STATUS_UPDATED);
+      PairingApiUpdateStatus(update_status_));
+  host_status.mutable_parameters()->set_enrollment_status(
+      PairingApiEnrollmentStatus(enrollment_status_));
 
   // TODO(zork): Get a list of other paired controllers.
   // (http://crbug.com/405757)
 
   int size = 0;
   scoped_refptr<net::IOBuffer> io_buffer(
       ProtoDecoder::SendHostStatus(host_status, &size));
 
   controller_socket_->Send(
       io_buffer, size,
@@ skipping 134 matching lines @@
   // TODO: Update Host. (http://crbug.com/405754)
   SendHostStatus();
 
   controller_socket_->Receive(
       kReceiveSize,
       base::Bind(&BluetoothHostPairingController::OnReceiveComplete,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnReceiveError,
                  ptr_factory_.GetWeakPtr()));
 
-  ChangeStage(STAGE_WAITING_FOR_CREDENTIALS);
+  ChangeStage(STAGE_UPDATING);
 }
 
 void BluetoothHostPairingController::OnSetDiscoverable(bool change_stage) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (change_stage) {
     DCHECK_EQ(current_stage_, STAGE_NONE);
     ChangeStage(STAGE_WAITING_FOR_CONTROLLER);
   }
 }
 
@@ skipping 52 matching lines @@
                     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;
-  }
-
   ChangeStage(STAGE_ENROLLING);
   FOR_EACH_OBSERVER(Observer, observers_,
                     EnrollHost(message.parameters().admin_access_token()));
 }
 
-void BluetoothHostPairingController::SetEnrollmentComplete(bool success) {
-  DCHECK_EQ(current_stage_, STAGE_ENROLLING);
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (success) {
-    ChangeStage(STAGE_PAIRING_DONE);
-    SendHostStatus();
-  } else {
-    AbortWithError(PAIRING_ERROR_PAIRING_OR_ENROLLMENT, kErrorEnrollmentFailed);
-  }
-}
-
 void BluetoothHostPairingController::OnCompleteSetupMessage(
     const pairing_api::CompleteSetup& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (current_stage_ != STAGE_PAIRING_DONE) {
     AbortWithError(PAIRING_ERROR_PAIRING_OR_ENROLLMENT, kErrorInvalidProtocol);
     return;
   }
 
   // TODO(zork): Handle adding another controller. (http://crbug.com/405757)
   ChangeStage(STAGE_FINISHED);
@@ skipping 48 matching lines @@
   DCHECK_EQ(current_stage_, STAGE_WAITING_FOR_CODE_CONFIRMATION);
   return confirmation_code_;
 }
 
 std::string BluetoothHostPairingController::GetEnrollmentDomain() {
   return enrollment_domain_;
 }
 
 void BluetoothHostPairingController::OnUpdateStatusChanged(
     UpdateStatus update_status) {
-  // TODO(zork): Handling updating stages (http://crbug.com/405754).
+  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_PAIRING_DONE);
+  } else if (enrollment_status == ENROLLMENT_STATUS_FAILURE) {
+      AbortWithError(PAIRING_ERROR_PAIRING_OR_ENROLLMENT,
+                     kErrorEnrollmentFailed);
+  }
+  SendHostStatus();
 }
 
 void BluetoothHostPairingController::RequestPinCode(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 void BluetoothHostPairingController::RequestPasskey(
     device::BluetoothDevice* device) {
@@ skipping 30 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothHostPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos