* Transition host to STAGE_UPDATING after pairing.

* Add enrollment status to proto
* Remove stages not handled by HostPairingController, and ControllerPairingController.
* UpdateScreen sends update status via remora_controller.
* EnrollmentScreen sends enrollment status via remora_controller.
* Remove auth_token_ from EnrollmentScreen.
* Rename to shark_controller and remora_controller in WizardController.
* Remove get_initial_status_ from BluetoothControllerPairingController.

Review URL: https://codereview.chromium.org/652743003

Cr-Commit-Position: refs/heads/master@{#299422}

chrome/browser/chromeos/login/enrollment/enrollment_screen.cc

@@ -78,12 +78,10 @@ void EnrollmentScreen::SetParameters(
     EnrollmentScreenActor::EnrollmentMode enrollment_mode,
     const std::string& management_domain,
     const std::string& user,
-    const std::string& auth_token,
     pairing_chromeos::ControllerPairingController* shark_controller,
     pairing_chromeos::HostPairingController* remora_controller) {
   enrollment_mode_ = enrollment_mode;
   user_ = user.empty() ? user : gaia::CanonicalizeEmail(user);
-  auth_token_ = auth_token;
   shark_controller_ = shark_controller;
   if (remora_controller_)
     remora_controller_->RemoveObserver(this);
@@ -103,14 +101,10 @@ void EnrollmentScreen::Show() {
     UMA(policy::kMetricEnrollmentAutoStarted);
     actor_->ShowEnrollmentSpinnerScreen();
     actor_->FetchOAuthToken();
-  } else if (auth_token_.empty()) {
+  } else {
     UMA(policy::kMetricEnrollmentTriggered);
     actor_->ResetAuth(base::Bind(&EnrollmentScreen::ShowSigninScreen,
                                  weak_ptr_factory_.GetWeakPtr()));
-  } else {
-    actor_->Show();
-    actor_->ShowEnrollmentSpinnerScreen();
-    OnOAuthTokenAvailable(auth_token_);
   }
 }
 
@@ -128,9 +122,7 @@ void EnrollmentScreen::PairingStageChanged(Stage new_stage) {
   if (new_stage == HostPairingController::STAGE_FINISHED) {
     remora_controller_->RemoveObserver(this);
     remora_controller_ = NULL;
-    // TODO(zork): Check that this is the best exit status. crbug.com/412798
-    get_screen_observer()->OnExit(
-        WizardController::ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED);
+    OnConfirmationClosed();
   }
 }
 
@@ -148,6 +140,10 @@ void EnrollmentScreen::EnrollHost(const std::string& auth_token) {
   actor_->Show();
   actor_->ShowEnrollmentSpinnerScreen();
   OnOAuthTokenAvailable(auth_token);
+  if (remora_controller_) {
+    remora_controller_->OnEnrollmentStatusChanged(
+        HostPairingController::ENROLLMENT_STATUS_ENROLLING);
+  }
 }
 
 void EnrollmentScreen::OnLoginDone(const std::string& user) {
@@ -326,8 +322,10 @@ void EnrollmentScreen::ReportEnrollmentStatus(policy::EnrollmentStatus status) {
                      status));
       UMA(is_auto_enrollment() ? policy::kMetricEnrollmentAutoOK
                                : policy::kMetricEnrollmentOK);
-      if (remora_controller_)
-        remora_controller_->SetEnrollmentComplete(true);
+      if (remora_controller_) {
+        remora_controller_->OnEnrollmentStatusChanged(
+            HostPairingController::ENROLLMENT_STATUS_SUCCESS);
+      }
       return;
     case policy::EnrollmentStatus::STATUS_REGISTRATION_FAILED:
     case policy::EnrollmentStatus::STATUS_POLICY_FETCH_FAILED:
@@ -420,8 +418,10 @@ void EnrollmentScreen::ReportEnrollmentStatus(policy::EnrollmentStatus status) {
       break;
   }
 
-  if (remora_controller_)
-    remora_controller_->SetEnrollmentComplete(false);
+  if (remora_controller_) {
+    remora_controller_->OnEnrollmentStatusChanged(
+        HostPairingController::ENROLLMENT_STATUS_FAILURE);
+  }
   enrollment_failed_once_ = true;
   if (elapsed_timer_)
     UMA_ENROLLMENT_TIME("Enterprise.EnrollmentTime.Failure", elapsed_timer_);

chrome/browser/chromeos/login/enrollment/enrollment_screen.h

@@ -47,7 +47,6 @@ class EnrollmentScreen
   static EnrollmentScreen* Get(ScreenManager* manager);
 
   // Setup how this screen will handle enrollment.
-  //   |auth_token| is an optional OAuth token to attempt to enroll with.
   //   |shark_controller| is an interface that is used to communicate with a
   //     remora device for remote enrollment.
   //   |remora_controller| is an interface that is used to communicate with a
@@ -56,7 +55,6 @@ class EnrollmentScreen
       EnrollmentScreenActor::EnrollmentMode enrollment_mode,
       const std::string& management_domain,
       const std::string& enrollment_user,
-      const std::string& auth_token,
       pairing_chromeos::ControllerPairingController* shark_controller,
       pairing_chromeos::HostPairingController* remora_controller);
 
@@ -133,7 +131,6 @@ class EnrollmentScreen
   bool enrollment_failed_once_;
   bool remora_token_sent_;
   std::string user_;
-  std::string auth_token_;
   scoped_ptr<base::ElapsedTimer> elapsed_timer_;
   base::WeakPtrFactory<EnrollmentScreen> weak_ptr_factory_;
 

chrome/browser/chromeos/login/screens/controller_pairing_screen.cc

@@ -110,28 +110,9 @@ void ControllerPairingScreen::PairingStageChanged(Stage new_stage) {
       controller_->RemoveObserver(this);
       get_screen_observer()->OnExit(
           WizardController::CONTROLLER_PAIRING_FINISHED);
-      // TODO(achuith, zork): Move the rest of the stages to the proper
-      // location.
       desired_page = kPageEnrollmentIntroduction;
       break;
     }
-    case ControllerPairingController::STAGE_HOST_ENROLLMENT_IN_PROGRESS: {
-      desired_page = kPageHostEnrollment;
-      break;
-    }
-    case ControllerPairingController::STAGE_HOST_ENROLLMENT_ERROR: {
-      desired_page = kPageHostEnrollmentError;
-      break;
-    }
-    case ControllerPairingController::STAGE_PAIRING_DONE: {
-      desired_page = kPagePairingDone;
-      break;
-    }
-    case ControllerPairingController::STAGE_FINISHED: {
-      get_screen_observer()->OnExit(
-          WizardController::CONTROLLER_PAIRING_FINISHED);
-      break;
-    }
     default:
       NOTREACHED();
   }

chrome/browser/chromeos/login/screens/host_pairing_screen.cc

@@ -61,10 +61,6 @@ std::string HostPairingScreen::GetName() const {
 void HostPairingScreen::PairingStageChanged(Stage new_stage) {
   std::string desired_page;
   switch (new_stage) {
-    case HostPairingController::STAGE_NONE:
-    case HostPairingController::STAGE_INITIALIZATION_ERROR: {
-      break;
-    }
     case HostPairingController::STAGE_WAITING_FOR_CONTROLLER:
     case HostPairingController::STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE: {
       desired_page = kPageWelcome;
@@ -76,36 +72,17 @@ void HostPairingScreen::PairingStageChanged(Stage new_stage) {
                          controller_->GetConfirmationCode());
       break;
     }
-    case HostPairingController::STAGE_UPDATING: {
-      desired_page = kPageUpdate;
-      context_.SetDouble(kContextKeyUpdateProgress, 0.0);
-      break;
-    }
-    case HostPairingController::STAGE_WAITING_FOR_CREDENTIALS: {
-      controller_->RemoveObserver(this);
-      get_screen_observer()->OnExit(
-          WizardController::HOST_PAIRING_FINISHED);
-      // TODO(achuith, zork): Remove the rest of the stages.
-      break;
-    }
-    case HostPairingController::STAGE_ENROLLING: {
-      desired_page = kPageEnrollment;
-      context_.SetString(kContextKeyEnrollmentDomain,
-                         controller_->GetEnrollmentDomain());
-      break;
-    }
-    case HostPairingController::STAGE_ENROLLMENT_ERROR: {
-      desired_page = kPageEnrollmentError;
-      break;
-    }
     case HostPairingController::STAGE_PAIRING_DONE: {
       desired_page = kPagePairingDone;
       break;
     }
-    case HostPairingController::STAGE_FINISHED: {
-      // This page is closed in EnrollHost.
+    case HostPairingController::STAGE_UPDATING: {
+      controller_->RemoveObserver(this);
+      get_screen_observer()->OnExit(WizardController::HOST_PAIRING_FINISHED);
       break;
     }
+    default:
+      break;
   }
   current_stage_ = new_stage;
   context_.SetString(kContextKeyDeviceName, controller_->GetDeviceName());

chrome/browser/chromeos/login/screens/mock_update_screen.cc

@@ -11,7 +11,7 @@ using ::testing::NotNull;
 
 MockUpdateScreen::MockUpdateScreen(ScreenObserver* screen_observer,
                                    UpdateScreenActor* actor)
-    : UpdateScreen(screen_observer, actor) {
+    : UpdateScreen(screen_observer, actor, NULL) {
 }
 
 MockUpdateScreen::~MockUpdateScreen() {

chrome/browser/chromeos/login/screens/update_screen.cc

@@ -22,6 +22,7 @@
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
+using pairing_chromeos::HostPairingController;
 
 namespace chromeos {
 
@@ -93,7 +94,8 @@ UpdateScreen* UpdateScreen::Get(ScreenManager* manager) {
 
 UpdateScreen::UpdateScreen(
     ScreenObserver* screen_observer,
-    UpdateScreenActor* actor)
+    UpdateScreenActor* actor,
+    HostPairingController* remora_controller)
     : WizardScreen(screen_observer),
       state_(STATE_IDLE),
       reboot_check_delay_(0),
@@ -103,6 +105,7 @@ UpdateScreen::UpdateScreen(
       is_shown_(false),
       ignore_idle_status_(true),
       actor_(actor),
+      remora_controller_(remora_controller),
       is_first_detection_notification_(true),
       is_first_portal_notification_(true),
       weak_factory_(this) {
@@ -138,6 +141,8 @@ void UpdateScreen::UpdateStatusChanged(
     case UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE:
       // Do nothing in these cases, we don't want to notify the user of the
       // check unless there is an update.
+      SetHostPairingControllerStatus(
+          HostPairingController::UPDATE_STATUS_UPDATING);
       break;
     case UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE:
       MakeSureScreenIsShown();
@@ -200,6 +205,8 @@ void UpdateScreen::UpdateStatusChanged(
       if (HasCriticalUpdate()) {
         actor_->ShowCurtain(false);
         VLOG(1) << "Initiate reboot after update";
+        SetHostPairingControllerStatus(
+            HostPairingController::UPDATE_STATUS_REBOOTING);
         DBusThreadManager::Get()->GetUpdateEngineClient()->RebootAfterUpdate();
         reboot_timer_.Start(FROM_HERE,
                             base::TimeDelta::FromSeconds(reboot_check_delay_),
@@ -321,6 +328,8 @@ void UpdateScreen::PrepareToShow() {
 void UpdateScreen::ExitUpdate(UpdateScreen::ExitReason reason) {
   DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
   NetworkPortalDetector::Get()->RemoveObserver(this);
+  SetHostPairingControllerStatus(HostPairingController::UPDATE_STATUS_UPDATED);
+
 
   switch (reason) {
     case REASON_UPDATE_CANCELED:
@@ -526,4 +535,11 @@ void UpdateScreen::UpdateErrorMessage(
   }
 }
 
+void UpdateScreen::SetHostPairingControllerStatus(
+    HostPairingController::UpdateStatus update_status) {
+  if (remora_controller_) {
+    remora_controller_->OnUpdateStatusChanged(update_status);
+  }
+}
+
 }  // namespace chromeos

chrome/browser/chromeos/login/screens/update_screen.h

@@ -17,6 +17,7 @@
 #include "chrome/browser/chromeos/login/screens/wizard_screen.h"
 #include "chromeos/dbus/update_engine_client.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
+#include "components/pairing/host_pairing_controller.h"
 
 namespace chromeos {
 
@@ -33,7 +34,9 @@ class UpdateScreen: public UpdateEngineClient::Observer,
                     public WizardScreen,
                     public NetworkPortalDetector::Observer {
  public:
-  UpdateScreen(ScreenObserver* screen_observer, UpdateScreenActor* actor);
+  UpdateScreen(ScreenObserver* screen_observer,
+               UpdateScreenActor* actor,
+               pairing_chromeos::HostPairingController* remora_controller);
   virtual ~UpdateScreen();
 
   static UpdateScreen* Get(ScreenManager* manager);
@@ -105,6 +108,10 @@ class UpdateScreen: public UpdateEngineClient::Observer,
   // Checks that screen is shown, shows if not.
   void MakeSureScreenIsShown();
 
+  // Send update status to host pairing controller.
+  void SetHostPairingControllerStatus(
+      pairing_chromeos::HostPairingController::UpdateStatus update_status);
+
   // Returns an instance of the error screen.
   ErrorScreen* GetErrorScreen();
 
@@ -145,6 +152,9 @@ class UpdateScreen: public UpdateEngineClient::Observer,
   // Keeps actor which is delegated with all showing operations.
   UpdateScreenActor* actor_;
 
+  // Used to track updates over Bluetooth.
+  pairing_chromeos::HostPairingController* remora_controller_;
+
   // Time of the first notification from the downloading stage.
   base::Time download_start_time_;
   double download_start_progress_;

chrome/browser/chromeos/login/wizard_controller.cc

@@ -293,7 +293,9 @@ WizardScreen* WizardController::CreateScreen(const std::string& screen_name) {
                                      oobe_display_->GetErrorScreenActor());
   } else if (screen_name == kUpdateScreenName) {
     chromeos::UpdateScreen* result =
-        new chromeos::UpdateScreen(this, oobe_display_->GetUpdateScreenActor());
+        new chromeos::UpdateScreen(this,
+                                   oobe_display_->GetUpdateScreenActor(),
+                                   remora_controller_.get());
     result->SetRebootCheckDelay(kWaitForRebootTimeSec);
     return result;
   } else if (screen_name == kUserImageScreenName) {
@@ -329,22 +331,22 @@ WizardScreen* WizardController::CreateScreen(const std::string& screen_name) {
     return new chromeos::AutoEnrollmentCheckScreen(
         this, oobe_display_->GetAutoEnrollmentCheckScreenActor());
   } else if (screen_name == kControllerPairingScreenName) {
-    if (!controller_pairing_controller_) {
-      controller_pairing_controller_.reset(
+    if (!shark_controller_) {
+      shark_controller_.reset(
           new pairing_chromeos::BluetoothControllerPairingController());
     }
     return new ControllerPairingScreen(
         this, oobe_display_->GetControllerPairingScreenActor(),
-        controller_pairing_controller_.get());
+        shark_controller_.get());
   } else if (screen_name == kHostPairingScreenName) {
-    if (!host_pairing_controller_) {
-      host_pairing_controller_.reset(
+    if (!remora_controller_) {
+      remora_controller_.reset(
           new pairing_chromeos::BluetoothHostPairingController());
-      host_pairing_controller_->StartPairing();
+      remora_controller_->StartPairing();
     }
     return new HostPairingScreen(this,
                                  oobe_display_->GetHostPairingScreenActor(),
-                                 host_pairing_controller_.get());
+                                 remora_controller_.get());
   }
   return NULL;
 }
@@ -436,9 +438,9 @@ void WizardController::ShowEnrollmentScreen() {
     mode = EnrollmentScreenActor::ENROLLMENT_MODE_FORCED;
   }
 
-  screen->SetParameters(mode, enrollment_domain, user, auth_token_,
-                        controller_pairing_controller_.get(),
-                        host_pairing_controller_.get());
+  screen->SetParameters(mode, enrollment_domain, user,
+                        shark_controller_.get(),
+                        remora_controller_.get());
   SetCurrentScreen(screen);
 }
 
@@ -581,10 +583,6 @@ void WizardController::OnUpdateCompleted() {
                             ->IsSharkRequisition();
   if (is_shark) {
     ShowControllerPairingScreen();
-  } else if (!auth_token_.empty()) {
-    // TODO(achuith): There is an issue with the auto enrollment check and
-    // remote enrollment. crbug.com/403147.
-    ShowEnrollmentScreen();
   } else {
     ShowAutoEnrollmentCheckScreen();
   }
@@ -1253,9 +1251,9 @@ void WizardController::MaybeStartListeningForSharkConnection() {
 }
 
 void WizardController::OnSharkConnected(
-    scoped_ptr<pairing_chromeos::HostPairingController> pairing_controller) {
+    scoped_ptr<pairing_chromeos::HostPairingController> remora_controller) {
   VLOG(1) << "OnSharkConnected";
-  host_pairing_controller_ = pairing_controller.Pass();
+  remora_controller_ = remora_controller.Pass();
   base::MessageLoop::current()->DeleteSoon(
       FROM_HERE, shark_connection_listener_.release());
   shark_controller_detected_ = true;

chrome/browser/chromeos/login/wizard_controller.h

@@ -326,7 +326,6 @@ class WizardController : public ScreenObserver, public ScreenManager {
 
   std::string username_;
   std::string password_;
-  std::string auth_token_;
 
   // True if running official BUILD.
   bool is_official_build_;
@@ -394,11 +393,10 @@ class WizardController : public ScreenObserver, public ScreenManager {
   scoped_ptr<TimeZoneProvider> timezone_provider_;
 
   // Pairing controller for shark devices.
-  scoped_ptr<pairing_chromeos::ControllerPairingController>
-      controller_pairing_controller_;
+  scoped_ptr<pairing_chromeos::ControllerPairingController> shark_controller_;
 
   // Pairing controller for remora devices.
-  scoped_ptr<pairing_chromeos::HostPairingController> host_pairing_controller_;
+  scoped_ptr<pairing_chromeos::HostPairingController> remora_controller_;
 
   // Maps screen ids to last time of their shows.
   base::hash_map<std::string, base::Time> screen_show_times_;

components/pairing/bluetooth_controller_pairing_controller.cc

@@ -23,7 +23,6 @@ namespace pairing_chromeos {
 
 BluetoothControllerPairingController::BluetoothControllerPairingController()
     : current_stage_(STAGE_NONE),
-      got_initial_status_(false),
       proto_decoder_(new ProtoDecoder(this)),
       ptr_factory_(this) {
 }
@@ -53,7 +52,6 @@ void BluetoothControllerPairingController::ChangeStage(Stage new_stage) {
 }
 
 void BluetoothControllerPairingController::Reset() {
-  got_initial_status_ = false;
   controller_device_id_.clear();
   discovery_session_.reset();
 
@@ -356,29 +354,40 @@ void BluetoothControllerPairingController::StartSession() {
 
 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));
-
-    SendBuffer(io_buffer, size);
-    ChangeStage(STAGE_PAIRING_DONE);
-  } else {
-    got_initial_status_ = true;
-
-    // TODO(zork): Check domain. (http://crbug.com/405761)
-    // TODO(achuith): Need STAGE_HOST_UPDATE_IN_PROGRESS here.
+  pairing_api::HostStatusParameters::UpdateStatus update_status =
+      message.parameters().update_status();
+  pairing_api::HostStatusParameters::EnrollmentStatus enrollment_status =
+      message.parameters().enrollment_status();
+  VLOG(1) << "OnHostStatusMessage, update_status=" << update_status;
+  // TODO(zork): Check domain. (http://crbug.com/405761)
+  if (enrollment_status ==
+      pairing_api::HostStatusParameters::ENROLLMENT_STATUS_SUCCESS) {
+    // TODO(achuith, zork): Need to ensure that controller has also successfully
+    // enrolled.
+    CompleteSetup();
+  } else if (update_status ==
+      pairing_api::HostStatusParameters::UPDATE_STATUS_UPDATING) {
+    ChangeStage(STAGE_HOST_UPDATE_IN_PROGRESS);
+  } else if (update_status ==
+      pairing_api::HostStatusParameters::UPDATE_STATUS_UPDATED) {
     ChangeStage(STAGE_WAITING_FOR_CREDENTIALS);
   }
 }
 
+void BluetoothControllerPairingController::CompleteSetup() {
+  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));
+
+  SendBuffer(io_buffer, size);
+  ChangeStage(STAGE_PAIRING_DONE);
+}
+
 void BluetoothControllerPairingController::OnConfigureHostMessage(
     const pairing_api::ConfigureHost& message) {
   NOTREACHED();

components/pairing/bluetooth_controller_pairing_controller.h

@@ -39,6 +39,7 @@ class BluetoothControllerPairingController
   void DeviceFound(device::BluetoothDevice* device);
   void DeviceLost(device::BluetoothDevice* device);
   void SendBuffer(scoped_refptr<net::IOBuffer> io_buffer, int size);
+  void CompleteSetup();
 
   void OnSetPowered();
   void OnGetAdapter(scoped_refptr<device::BluetoothAdapter> adapter);
@@ -108,7 +109,6 @@ class BluetoothControllerPairingController
   virtual void AuthorizePairing(device::BluetoothDevice* device) override;
 
   Stage current_stage_;
-  bool got_initial_status_;
   scoped_refptr<device::BluetoothAdapter> adapter_;
   scoped_ptr<device::BluetoothDiscoverySession> discovery_session_;
   scoped_refptr<device::BluetoothSocket> socket_;

components/pairing/bluetooth_host_pairing_controller.cc

@@ -14,14 +14,51 @@
 #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) {
@@ -51,7 +88,9 @@ void BluetoothHostPairingController::SendHostStatus() {
   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)
@@ -206,7 +245,7 @@ void BluetoothHostPairingController::OnAccept(
       base::Bind(&BluetoothHostPairingController::OnReceiveError,
                  ptr_factory_.GetWeakPtr()));
 
-  ChangeStage(STAGE_WAITING_FOR_CREDENTIALS);
+  ChangeStage(STAGE_UPDATING);
 }
 
 void BluetoothHostPairingController::OnSetDiscoverable(bool change_stage) {
@@ -279,27 +318,11 @@ void BluetoothHostPairingController::OnConfigureHostMessage(
 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());
@@ -368,7 +391,25 @@ std::string BluetoothHostPairingController::GetEnrollmentDomain() {
 
 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(

components/pairing/bluetooth_host_pairing_controller.h

@@ -70,7 +70,8 @@ class BluetoothHostPairingController
   virtual std::string GetConfirmationCode() override;
   virtual std::string GetEnrollmentDomain() override;
   virtual void OnUpdateStatusChanged(UpdateStatus update_status) override;
-  virtual void SetEnrollmentComplete(bool success) override;
+  virtual void OnEnrollmentStatusChanged(
+      EnrollmentStatus enrollment_status) override;
 
   // ProtoDecoder::Observer:
   virtual void OnHostStatusMessage(
@@ -104,6 +105,8 @@ class BluetoothHostPairingController
   std::string device_name_;
   std::string confirmation_code_;
   std::string enrollment_domain_;
+  UpdateStatus update_status_;
+  EnrollmentStatus enrollment_status_;
 
   scoped_refptr<device::BluetoothAdapter> adapter_;
   device::BluetoothDevice* device_;

components/pairing/fake_host_pairing_controller.cc

@@ -128,7 +128,8 @@ void FakeHostPairingController::OnUpdateStatusChanged(
     UpdateStatus update_status) {
 }
 
-void FakeHostPairingController::SetEnrollmentComplete(bool success) {
+void FakeHostPairingController::OnEnrollmentStatusChanged(
+    EnrollmentStatus enrollment_status) {
 }
 
 void FakeHostPairingController::PairingStageChanged(Stage new_stage) {

components/pairing/fake_host_pairing_controller.h

@@ -33,7 +33,11 @@ class FakeHostPairingController
   // Applies given |config| to flow.
   void ApplyConfig(const std::string& config);
 
-  // Overridden from HostPairingFlow:
+ private:
+  void ChangeStage(Stage new_stage);
+  void ChangeStageLater(Stage new_stage);
+
+  // HostPairingController:
   virtual void AddObserver(Observer* observer) override;
   virtual void RemoveObserver(Observer* observer) override;
   virtual Stage GetCurrentStage() override;
@@ -42,13 +46,10 @@ class FakeHostPairingController
   virtual std::string GetConfirmationCode() override;
   virtual std::string GetEnrollmentDomain() override;
   virtual void OnUpdateStatusChanged(UpdateStatus update_status) override;
-  virtual void SetEnrollmentComplete(bool success) override;
-
- private:
-  void ChangeStage(Stage new_stage);
-  void ChangeStageLater(Stage new_stage);
+  virtual void OnEnrollmentStatusChanged(
+      EnrollmentStatus enrollment_status) override;
 
-  // HostPairingFlow::Observer:
+  // HostPairingController::Observer:
   virtual void PairingStageChanged(Stage new_stage) override;
   virtual void ConfigureHost(bool accepted_eula,
                              const std::string& lang,

components/pairing/host_pairing_controller.h

@@ -34,6 +34,13 @@ class HostPairingController {
     UPDATE_STATUS_UPDATED,
   };
 
+  enum EnrollmentStatus {
+    ENROLLMENT_STATUS_UNKNOWN,
+    ENROLLMENT_STATUS_ENROLLING,
+    ENROLLMENT_STATUS_FAILURE,
+    ENROLLMENT_STATUS_SUCCESS,
+  };
+
   class Observer {
    public:
     Observer();
@@ -80,8 +87,10 @@ class HostPairingController {
   // Can be called on stage |STAGE_UPDATING|.
   virtual void OnUpdateStatusChanged(UpdateStatus update_status) = 0;
 
-  // Called when enrollment has completed.
-  virtual void SetEnrollmentComplete(bool success) = 0;
+  // Notify that enrollment status has changed.
+  // Can be called on stage |STAGE_WAITING_FOR_CREDENTIALS|.
+  virtual void OnEnrollmentStatusChanged(
+      EnrollmentStatus enrollment_status) = 0;
 
   virtual void AddObserver(Observer* observer) = 0;
   virtual void RemoveObserver(Observer* observer) = 0;

components/pairing/pairing_api.proto

@@ -26,10 +26,18 @@ message HostStatusParameters {
     UPDATE_STATUS_UPDATED = 3;
   }
 
+  enum EnrollmentStatus {
+    ENROLLMENT_STATUS_UNKNOWN = 0;
+    ENROLLMENT_STATUS_ENROLLING = 1;
+    ENROLLMENT_STATUS_FAILURE = 2;
+    ENROLLMENT_STATUS_SUCCESS = 3;
+  }
+
   optional string domain = 1;
   optional Connectivity connectivity = 2;
   optional UpdateStatus update_status = 3;
-  repeated string paired_controllers = 4;
+  optional EnrollmentStatus enrollment_status = 4;
+  repeated string paired_controllers = 5;
 }
 
 message HostStatus {