Fold UpdateModel into UpdateScreen.

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"
@@ skipping 17 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using pairing_chromeos::HostPairingController;
 
 namespace chromeos {
 
 namespace {
 
+constexpr const char kUserActionCancelUpdateShortcut[] = "cancel-update";
+constexpr const char kContextKeyEstimatedTimeLeftSec[] = "time-left-sec";
+constexpr const char kContextKeyShowEstimatedTimeLeft[] = "show-time-left";
+constexpr const char kContextKeyUpdateMessage[] = "update-msg";
+constexpr const char kContextKeyShowCurtain[] = "show-curtain";
+constexpr const char kContextKeyShowProgressMessage[] = "show-progress-msg";
+constexpr const char kContextKeyProgress[] = "progress";
+constexpr const char kContextKeyProgressMessage[] = "progress-msg";
+constexpr const char kContextKeyCancelUpdateShortcutEnabled[] =
+    "cancel-update-enabled";
+
 // If reboot didn't happen, ask user to reboot device manually.
 const int kWaitForRebootTimeSec = 3;
 
 // 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;
 const int kBeforeDownloadProgress = 14;
 const int kBeforeVerifyingProgress = 74;
@@ skipping 55 matching lines @@
 
 // static
 UpdateScreen* UpdateScreen::Get(ScreenManager* manager) {
   return static_cast<UpdateScreen*>(
       manager->GetScreen(OobeScreen::SCREEN_OOBE_UPDATE));
 }
 
 UpdateScreen::UpdateScreen(BaseScreenDelegate* base_screen_delegate,
                            UpdateView* view,
                            HostPairingController* remora_controller)
-    : UpdateModel(base_screen_delegate),
-      state_(STATE_IDLE),
+    : BaseScreen(base_screen_delegate, OobeScreen::SCREEN_OOBE_UPDATE),
       reboot_check_delay_(kWaitForRebootTimeSec),
-      is_checking_for_update_(true),
-      is_downloading_update_(false),
-      is_ignore_update_deadlines_(false),
-      is_shown_(false),
-      ignore_idle_status_(true),
       view_(view),
       remora_controller_(remora_controller),
-      is_first_detection_notification_(true),
-      is_first_portal_notification_(true),
       histogram_helper_(new ErrorScreensHistogramHelper("Update")),
       weak_factory_(this) {
   if (view_)
-    view_->Bind(*this);
+    view_->Bind(this);
 
   GetInstanceSet().insert(this);
 }
 
 UpdateScreen::~UpdateScreen() {
   if (view_)
     view_->Unbind();
 
   DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
   network_portal_detector::GetInstance()->RemoveObserver(this);
   GetInstanceSet().erase(this);
 }
 
+void UpdateScreen::OnViewDestroyed(UpdateView* view) {
+  if (view_ == view)
+    view_ = nullptr;
+}
+
+void UpdateScreen::StartNetworkCheck() {
+  // If portal detector is enabled and portal detection before AU is
+  // allowed, initiate network state check. Otherwise, directly
+  // proceed to update.
+  if (!network_portal_detector::GetInstance()->IsEnabled()) {
+    StartUpdateCheck();
+    return;
+  }
+  state_ = State::STATE_FIRST_PORTAL_CHECK;
+  is_first_detection_notification_ = true;
+  is_first_portal_notification_ = true;
+  network_portal_detector::GetInstance()->AddAndFireObserver(this);
+}
+
+void UpdateScreen::SetIgnoreIdleStatus(bool ignore_idle_status) {
+  ignore_idle_status_ = ignore_idle_status;
+}
+
+void UpdateScreen::ExitUpdate(UpdateScreen::ExitReason reason) {
+  DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
+  network_portal_detector::GetInstance()->RemoveObserver(this);
+  SetHostPairingControllerStatus(HostPairingController::UPDATE_STATUS_UPDATED);
+
+  switch (reason) {
+    case REASON_UPDATE_CANCELED:
+      Finish(BaseScreenDelegate::UPDATE_NOUPDATE);
+      break;
+    case REASON_UPDATE_INIT_FAILED:
+      Finish(BaseScreenDelegate::UPDATE_ERROR_CHECKING_FOR_UPDATE);
+      break;
+    case REASON_UPDATE_NON_CRITICAL:
+    case REASON_UPDATE_ENDED: {
+      UpdateEngineClient* update_engine_client =
+          DBusThreadManager::Get()->GetUpdateEngineClient();
+      switch (update_engine_client->GetLastStatus().status) {
+        case UpdateEngineClient::UPDATE_STATUS_ATTEMPTING_ROLLBACK:
+          break;
+        case UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE:
+        case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
+        case UpdateEngineClient::UPDATE_STATUS_DOWNLOADING:
+        case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
+        case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
+          DCHECK(!HasCriticalUpdate());
+        // Noncritical update, just exit screen as if there is no update.
+        // no break
+        case UpdateEngineClient::UPDATE_STATUS_IDLE:
+          Finish(BaseScreenDelegate::UPDATE_NOUPDATE);
+          break;
+        case UpdateEngineClient::UPDATE_STATUS_ERROR:
+        case UpdateEngineClient::UPDATE_STATUS_REPORTING_ERROR_EVENT:
+          if (is_checking_for_update_) {
+            Finish(BaseScreenDelegate::UPDATE_ERROR_CHECKING_FOR_UPDATE);
+          } else if (HasCriticalUpdate()) {
+            Finish(BaseScreenDelegate::UPDATE_ERROR_UPDATING_CRITICAL_UPDATE);
+          } else {
+            Finish(BaseScreenDelegate::UPDATE_ERROR_UPDATING);
+          }
+          break;
+        default:
+          NOTREACHED();
+      }
+    } break;
+    default:
+      NOTREACHED();
+  }
+}
+
 void UpdateScreen::UpdateStatusChanged(
     const UpdateEngineClient::Status& status) {
   if (is_checking_for_update_ &&
       status.status > UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE) {
     is_checking_for_update_ = false;
   }
   if (ignore_idle_status_ && status.status >
       UpdateEngineClient::UPDATE_STATUS_IDLE) {
     ignore_idle_status_ = false;
   }
@@ skipping 125 matching lines @@
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(
             base::IgnoreResult(&NetworkPortalDetector::StartDetectionIfIdle),
             base::Unretained(network_portal_detector::GetInstance())));
     return;
   }
   is_first_detection_notification_ = false;
 
   NetworkPortalDetector::CaptivePortalStatus status = state.status;
-  if (state_ == STATE_ERROR) {
+  if (state_ == State::STATE_ERROR) {
     // In the case of online state hide error message and proceed to
     // the update stage. Otherwise, update error message content.
     if (status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE)
       StartUpdateCheck();
     else
       UpdateErrorMessage(network, status);
-  } else if (state_ == STATE_FIRST_PORTAL_CHECK) {
+  } else if (state_ == State::STATE_FIRST_PORTAL_CHECK) {
     // In the case of online state immediately proceed to the update
     // stage. Otherwise, prepare and show error message.
     if (status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE) {
       StartUpdateCheck();
     } else {
       UpdateErrorMessage(network, status);
 
       if (status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL)
         DelayErrorMessage();
       else
         ShowErrorMessage();
     }
   }
 }
 
-void UpdateScreen::StartNetworkCheck() {
-  // If portal detector is enabled and portal detection before AU is
-  // allowed, initiate network state check. Otherwise, directly
-  // proceed to update.
-  if (!network_portal_detector::GetInstance()->IsEnabled()) {
-    StartUpdateCheck();
-    return;
-  }
-  state_ = STATE_FIRST_PORTAL_CHECK;
-  is_first_detection_notification_ = true;
-  is_first_portal_notification_ = true;
-  network_portal_detector::GetInstance()->AddAndFireObserver(this);
+void UpdateScreen::CancelUpdate() {
+  VLOG(1) << "Forced update cancel";
+  ExitUpdate(REASON_UPDATE_CANCELED);
+}
+
+// TODO(jdufault): This should return a pointer. See crbug.com/672142.
+base::OneShotTimer& UpdateScreen::GetErrorMessageTimerForTesting() {
+  return error_message_timer_;
 }
 
 void UpdateScreen::Show() {
   is_shown_ = true;
   histogram_helper_->OnScreenShow();
 
 #if !defined(OFFICIAL_BUILD)
   GetContextEditor().SetBoolean(kContextKeyCancelUpdateShortcutEnabled, true);
 #endif
   GetContextEditor().SetInteger(kContextKeyProgress,
                                 kBeforeUpdateCheckProgress);
 
   if (view_)
     view_->Show();
 }
 
 void UpdateScreen::Hide() {
   if (view_)
     view_->Hide();
   is_shown_ = false;
 }
 
-void UpdateScreen::OnViewDestroyed(UpdateView* view) {
-  if (view_ == view)
-    view_ = nullptr;
-}
-
 void UpdateScreen::OnUserAction(const std::string& action_id) {
 #if !defined(OFFICIAL_BUILD)
   if (action_id == kUserActionCancelUpdateShortcut)
     CancelUpdate();
   else
 #endif
     BaseScreen::OnUserAction(action_id);
 }
 
-void UpdateScreen::OnContextKeyUpdated(
-    const ::login::ScreenContext::KeyType& key) {
-  UpdateModel::OnContextKeyUpdated(key);
-}
-
-void UpdateScreen::ExitUpdate(UpdateScreen::ExitReason reason) {
-  DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
-  network_portal_detector::GetInstance()->RemoveObserver(this);
-  SetHostPairingControllerStatus(HostPairingController::UPDATE_STATUS_UPDATED);
-
-
-  switch (reason) {
-    case REASON_UPDATE_CANCELED:
-      Finish(BaseScreenDelegate::UPDATE_NOUPDATE);
-      break;
-    case REASON_UPDATE_INIT_FAILED:
-      Finish(BaseScreenDelegate::UPDATE_ERROR_CHECKING_FOR_UPDATE);
-      break;
-    case REASON_UPDATE_NON_CRITICAL:
-    case REASON_UPDATE_ENDED:
-      {
-        UpdateEngineClient* update_engine_client =
-            DBusThreadManager::Get()->GetUpdateEngineClient();
-        switch (update_engine_client->GetLastStatus().status) {
-          case UpdateEngineClient::UPDATE_STATUS_ATTEMPTING_ROLLBACK:
-            break;
-          case UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE:
-          case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
-          case UpdateEngineClient::UPDATE_STATUS_DOWNLOADING:
-          case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
-          case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
-            DCHECK(!HasCriticalUpdate());
-            // Noncritical update, just exit screen as if there is no update.
-            // no break
-          case UpdateEngineClient::UPDATE_STATUS_IDLE:
-            Finish(BaseScreenDelegate::UPDATE_NOUPDATE);
-            break;
-          case UpdateEngineClient::UPDATE_STATUS_ERROR:
-          case UpdateEngineClient::UPDATE_STATUS_REPORTING_ERROR_EVENT:
-            if (is_checking_for_update_) {
-              Finish(BaseScreenDelegate::UPDATE_ERROR_CHECKING_FOR_UPDATE);
-            } else if (HasCriticalUpdate()) {
-              Finish(BaseScreenDelegate::UPDATE_ERROR_UPDATING_CRITICAL_UPDATE);
-            } else {
-              Finish(BaseScreenDelegate::UPDATE_ERROR_UPDATING);
-            }
-            break;
-          default:
-            NOTREACHED();
-        }
-      }
-      break;
-    default:
-      NOTREACHED();
-  }
-}
-
-void UpdateScreen::OnWaitForRebootTimeElapsed() {
-  LOG(ERROR) << "Unable to reboot - asking user for a manual reboot.";
-  MakeSureScreenIsShown();
-  GetContextEditor().SetString(kContextKeyUpdateMessage,
-                               l10n_util::GetStringUTF16(IDS_UPDATE_COMPLETED));
-}
-
-void UpdateScreen::MakeSureScreenIsShown() {
-  if (!is_shown_)
-    get_base_screen_delegate()->ShowCurrentScreen();
-}
-
-void UpdateScreen::SetIgnoreIdleStatus(bool ignore_idle_status) {
-  ignore_idle_status_ = ignore_idle_status;
-}
-
-void UpdateScreen::CancelUpdate() {
-  VLOG(1) << "Forced update cancel";
-  ExitUpdate(REASON_UPDATE_CANCELED);
-}
-
 void UpdateScreen::UpdateDownloadingStats(
     const UpdateEngineClient::Status& status) {
   base::Time download_current_time = base::Time::Now();
   if (download_current_time >=
       download_last_time_ +
           base::TimeDelta::FromSeconds(kMinTimeStepInSeconds)) {
     // Estimate downloading rate.
     double progress_delta =
         std::max(status.download_progress - download_last_progress_, 0.0);
     double time_delta =
@@ skipping 50 matching lines @@
   if (!base::ReadFileToString(update_deadline_file_path, &deadline) ||
       deadline.empty()) {
     return false;
   }
 
   // TODO(dpolukhin): Analyze file content. Now we can just assume that
   // if the file exists and not empty, there is critical update.
   return true;
 }
 
+void UpdateScreen::OnWaitForRebootTimeElapsed() {
+  LOG(ERROR) << "Unable to reboot - asking user for a manual reboot.";
+  MakeSureScreenIsShown();
+  GetContextEditor().SetString(kContextKeyUpdateMessage,
+                               l10n_util::GetStringUTF16(IDS_UPDATE_COMPLETED));
+}
+
+void UpdateScreen::MakeSureScreenIsShown() {
+  if (!is_shown_)
+    get_base_screen_delegate()->ShowCurrentScreen();
+}
+
+void UpdateScreen::SetHostPairingControllerStatus(
+    HostPairingController::UpdateStatus update_status) {
+  if (remora_controller_) {
+    remora_controller_->OnUpdateStatusChanged(update_status);
+  }
+}
+
 ErrorScreen* UpdateScreen::GetErrorScreen() {
   return get_base_screen_delegate()->GetErrorScreen();
 }
 
 void UpdateScreen::StartUpdateCheck() {
   error_message_timer_.Stop();
   GetErrorScreen()->HideCaptivePortal();
 
   network_portal_detector::GetInstance()->RemoveObserver(this);
   connect_request_subscription_.reset();
-  if (state_ == STATE_ERROR)
+  if (state_ == State::STATE_ERROR)
     HideErrorMessage();
-  state_ = STATE_UPDATE;
+  state_ = State::STATE_UPDATE;
   DBusThreadManager::Get()->GetUpdateEngineClient()->AddObserver(this);
   VLOG(1) << "Initiate update check";
   DBusThreadManager::Get()->GetUpdateEngineClient()->RequestUpdateCheck(
       base::Bind(StartUpdateCallback, this));
 }
 
 void UpdateScreen::ShowErrorMessage() {
   LOG(WARNING) << "UpdateScreen::ShowErrorMessage()";
 
   error_message_timer_.Stop();
 
-  state_ = STATE_ERROR;
+  state_ = State::STATE_ERROR;
   connect_request_subscription_ =
       GetErrorScreen()->RegisterConnectRequestCallback(base::Bind(
           &UpdateScreen::OnConnectRequested, base::Unretained(this)));
   GetErrorScreen()->SetUIState(NetworkError::UI_STATE_UPDATE);
   get_base_screen_delegate()->ShowErrorScreen();
   histogram_helper_->OnErrorShow(GetErrorScreen()->GetErrorState());
 }
 
 void UpdateScreen::HideErrorMessage() {
   LOG(WARNING) << "UpdateScreen::HideErrorMessage()";
@@ skipping 25 matching lines @@
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
       GetErrorScreen()->SetErrorState(NetworkError::ERROR_STATE_PROXY,
                                       std::string());
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
-void UpdateScreen::SetHostPairingControllerStatus(
-    HostPairingController::UpdateStatus update_status) {
-  if (remora_controller_) {
-    remora_controller_->OnUpdateStatusChanged(update_status);
-  }
-}
-
 void UpdateScreen::DelayErrorMessage() {
   if (error_message_timer_.IsRunning())
     return;
 
-  state_ = STATE_ERROR;
+  state_ = State::STATE_ERROR;
   error_message_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kDelayErrorMessageSec), this,
       &UpdateScreen::ShowErrorMessage);
 }
 
-base::OneShotTimer& UpdateScreen::GetErrorMessageTimerForTesting() {
-  return error_message_timer_;
-}
-
 void UpdateScreen::OnConnectRequested() {
-  if (state_ == STATE_ERROR) {
+  if (state_ == State::STATE_ERROR) {
     LOG(WARNING) << "Hiding error message since AP was reselected";
     StartUpdateCheck();
   }
 }
 
 }  // namespace chromeos