Fix update and enrollment flow

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

 // Copyright (c) 2012 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 "chrome/browser/chromeos/login/screens/update_screen.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/chromeos/login/screen_manager.h"
 #include "chrome/browser/chromeos/login/screens/error_screen.h"
 #include "chrome/browser/chromeos/login/screens/screen_observer.h"
 #include "chrome/browser/chromeos/login/screens/update_screen_actor.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/network/network_state.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
+using pairing_chromeos::HostPairingController;
 
 namespace chromeos {
 
 namespace {
 
 // Progress bar stages. Each represents progress bar value
 // at the beginning of each stage.
 // TODO(nkostylev): Base stage progress values on approximate time.
 // TODO(nkostylev): Animate progress during each state.
 const int kBeforeUpdateCheckProgress = 7;
@@ skipping 51 matching lines @@
 }
 
 // static
 UpdateScreen* UpdateScreen::Get(ScreenManager* manager) {
   return static_cast<UpdateScreen*>(
       manager->GetScreen(WizardController::kUpdateScreenName));
 }
 
 UpdateScreen::UpdateScreen(
     ScreenObserver* screen_observer,
-    UpdateScreenActor* actor)
+    UpdateScreenActor* actor,
+    HostPairingController* remora_controller)
     : WizardScreen(screen_observer),
       state_(STATE_IDLE),
       reboot_check_delay_(0),
       is_checking_for_update_(true),
       is_downloading_update_(false),
       is_ignore_update_deadlines_(false),
       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) {
   DCHECK(actor_);
   if (actor_)
     actor_->SetDelegate(this);
   GetInstanceSet().insert(this);
 }
 
 UpdateScreen::~UpdateScreen() {
@@ skipping 15 matching lines @@
   }
   if (ignore_idle_status_ && status.status >
       UpdateEngineClient::UPDATE_STATUS_IDLE) {
     ignore_idle_status_ = false;
   }
 
   switch (status.status) {
     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();
       actor_->SetProgress(kBeforeDownloadProgress);
       actor_->ShowEstimatedTimeLeft(false);
       if (!HasCriticalUpdate()) {
         VLOG(1) << "Noncritical update available: " << status.new_version;
         ExitUpdate(REASON_UPDATE_NON_CRITICAL);
       } else {
         VLOG(1) << "Critical update available: " << status.new_version;
@@ skipping 42 matching lines @@
           UpdateScreenActor::PROGRESS_MESSAGE_FINALIZING);
       actor_->ShowProgressMessage(true);
       break;
     case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
       MakeSureScreenIsShown();
       actor_->SetProgress(kProgressComplete);
       actor_->ShowEstimatedTimeLeft(false);
       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_),
                             this,
                             &UpdateScreen::OnWaitForRebootTimeElapsed);
       } else {
         ExitUpdate(REASON_UPDATE_NON_CRITICAL);
       }
       break;
     case UpdateEngineClient::UPDATE_STATUS_ATTEMPTING_ROLLBACK:
@@ skipping 101 matching lines @@
 }
 
 void UpdateScreen::PrepareToShow() {
   if (actor_)
     actor_->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:
       get_screen_observer()->OnExit(ScreenObserver::UPDATE_NOUPDATE);
       break;
     case REASON_UPDATE_INIT_FAILED:
       get_screen_observer()->OnExit(
           ScreenObserver::UPDATE_ERROR_CHECKING_FOR_UPDATE);
       break;
     case REASON_UPDATE_NON_CRITICAL:
@@ skipping 185 matching lines @@
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
       GetErrorScreen()->SetErrorState(ErrorScreen::ERROR_STATE_PROXY,
                                       std::string());
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
+void UpdateScreen::SetHostPairingControllerStatus(
+    HostPairingController::UpdateStatus update_status) {
+  if (remora_controller_) {
+    remora_controller_->OnUpdateStatusChanged(update_status);
+  }
+}
+
 }  // namespace chromeos