Migrating UpdateScreen to ScreenContext

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/error_screens_histogram_helper.h"
 #include "chrome/browser/chromeos/login/screen_manager.h"
 #include "chrome/browser/chromeos/login/screens/base_screen_delegate.h"
 #include "chrome/browser/chromeos/login/screens/error_screen.h"
-#include "chrome/browser/chromeos/login/screens/update_screen_actor.h"
+#include "chrome/browser/chromeos/login/screens/update_view.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
+#include "chrome/grit/chromium_strings.h"
+#include "chrome/grit/generated_resources.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/network/network_state.h"
 #include "content/public/browser/browser_thread.h"
+#include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using pairing_chromeos::HostPairingController;
 
 namespace chromeos {
 
 namespace {
 
+// 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;
 const int kBeforeFinalizingProgress = 81;
 const int kProgressComplete = 100;
 
@@ skipping 45 matching lines @@
   return (found != instance_set.end());
 }
 
 // static
 UpdateScreen* UpdateScreen::Get(ScreenManager* manager) {
   return static_cast<UpdateScreen*>(
       manager->GetScreen(WizardController::kUpdateScreenName));
 }
 
 UpdateScreen::UpdateScreen(BaseScreenDelegate* base_screen_delegate,
-                           UpdateScreenActor* actor,
+                           UpdateView* view,
                            HostPairingController* remora_controller)
-    : BaseScreen(base_screen_delegate),
+    : UpdateModel(base_screen_delegate),
       state_(STATE_IDLE),
-      reboot_check_delay_(0),
+      reboot_check_delay_(kWaitForRebootTimeSec),
       is_checking_for_update_(true),
       is_downloading_update_(false),
-      is_ignore_update_deadlines_(false),
+      is_ignore_update_deadlines_(true),
       is_shown_(false),
       ignore_idle_status_(true),
-      actor_(actor),
+      view_(view),
       remora_controller_(remora_controller),
       is_first_detection_notification_(true),
       is_first_portal_notification_(true),
       histogram_helper_(new ErrorScreensHistogramHelper("Update")),
       weak_factory_(this) {
-  DCHECK(actor_);
-  if (actor_)
-    actor_->SetDelegate(this);
+  if (view_)
+    view_->Bind(*this);
+
   GetInstanceSet().insert(this);
 }
 
 UpdateScreen::~UpdateScreen() {
+  if (view_)
+    view_->Unbind();
+
   DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
   NetworkPortalDetector::Get()->RemoveObserver(this);
   GetInstanceSet().erase(this);
-  if (actor_)
-    actor_->SetDelegate(NULL);
 }
 
 void UpdateScreen::UpdateStatusChanged(
     const UpdateEngineClient::Status& status) {
-  if (!actor_)
-    return;
-
   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;
   }
 
   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);
+      GetContextEditor()
+          .SetInteger(kContextKeyProgress, kBeforeDownloadProgress)
+          .SetBoolean(kContextKeyShowEstimatedTimeLeft, 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;
-        actor_->SetProgressMessage(
-            UpdateScreenActor::PROGRESS_MESSAGE_UPDATE_AVAILABLE);
-        actor_->ShowProgressMessage(true);
-        actor_->ShowCurtain(false);
+        GetContextEditor()
+            .SetString(kContextKeyProgressMessage,
+                       l10n_util::GetStringUTF16(IDS_UPDATE_AVAILABLE))
+            .SetBoolean(kContextKeyShowProgressMessage, true)
+            .SetBoolean(kContextKeyShowCurtain, false);
       }
       break;
     case UpdateEngineClient::UPDATE_STATUS_DOWNLOADING:
       {
         MakeSureScreenIsShown();
         if (!is_downloading_update_) {
           // Because update engine doesn't send UPDATE_STATUS_UPDATE_AVAILABLE
           // we need to is update critical on first downloading notification.
           is_downloading_update_ = true;
           download_start_time_ = download_last_time_ = base::Time::Now();
           download_start_progress_ = status.download_progress;
           download_last_progress_ = status.download_progress;
           is_download_average_speed_computed_ = false;
           download_average_speed_ = 0.0;
           if (!HasCriticalUpdate()) {
             VLOG(1) << "Non-critical update available: " << status.new_version;
             ExitUpdate(REASON_UPDATE_NON_CRITICAL);
           } else {
             VLOG(1) << "Critical update available: " << status.new_version;
-            actor_->SetProgressMessage(
-                UpdateScreenActor::PROGRESS_MESSAGE_INSTALLING_UPDATE);
-            actor_->ShowProgressMessage(true);
-            actor_->ShowCurtain(false);
+            GetContextEditor()
+                .SetString(kContextKeyProgressMessage,
+                           l10n_util::GetStringUTF16(IDS_INSTALLING_UPDATE))
+                .SetBoolean(kContextKeyShowProgressMessage, true)
+                .SetBoolean(kContextKeyShowCurtain, false);
           }
         }
         UpdateDownloadingStats(status);
       }
       break;
     case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
       MakeSureScreenIsShown();
-      actor_->SetProgress(kBeforeVerifyingProgress);
-      actor_->SetProgressMessage(UpdateScreenActor::PROGRESS_MESSAGE_VERIFYING);
-      actor_->ShowProgressMessage(true);
+      GetContextEditor()
+          .SetInteger(kContextKeyProgress, kBeforeVerifyingProgress)
+          .SetString(kContextKeyProgressMessage,
+                     l10n_util::GetStringUTF16(IDS_UPDATE_VERIFYING))
+          .SetBoolean(kContextKeyShowProgressMessage, true);
       break;
     case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
       MakeSureScreenIsShown();
-      actor_->SetProgress(kBeforeFinalizingProgress);
-      actor_->SetProgressMessage(
-          UpdateScreenActor::PROGRESS_MESSAGE_FINALIZING);
-      actor_->ShowProgressMessage(true);
+      GetContextEditor()
+          .SetInteger(kContextKeyProgress, kBeforeFinalizingProgress)
+          .SetString(kContextKeyProgressMessage,
+                     l10n_util::GetStringUTF16(IDS_UPDATE_FINALIZING))
+          .SetBoolean(kContextKeyShowProgressMessage, true);
       break;
     case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
       MakeSureScreenIsShown();
-      actor_->SetProgress(kProgressComplete);
-      actor_->ShowEstimatedTimeLeft(false);
+      GetContextEditor()
+          .SetInteger(kContextKeyProgress, kProgressComplete)
+          .SetBoolean(kContextKeyShowEstimatedTimeLeft, false);
       if (HasCriticalUpdate()) {
-        actor_->ShowCurtain(false);
+        GetContextEditor().SetBoolean(kContextKeyShowCurtain, 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);
@@ skipping 73 matching lines @@
   if (!NetworkPortalDetector::Get()->IsEnabled()) {
     StartUpdateCheck();
     return;
   }
   state_ = STATE_FIRST_PORTAL_CHECK;
   is_first_detection_notification_ = true;
   is_first_portal_notification_ = true;
   NetworkPortalDetector::Get()->AddAndFireObserver(this);
 }
 
-void UpdateScreen::CancelUpdate() {
-  VLOG(1) << "Forced update cancel";
-  ExitUpdate(REASON_UPDATE_CANCELED);
+void UpdateScreen::PrepareToShow() {
+  if (!view_)
+    return;
+
+  view_->PrepareToShow();
 }
 
 void UpdateScreen::Show() {
   is_shown_ = true;
   histogram_helper_->OnScreenShow();
-  if (actor_) {
-    actor_->Show();
-    actor_->SetProgress(kBeforeUpdateCheckProgress);
+
+#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::Initialize(::login::ScreenContext* context) {
+  UpdateModel::Initialize(context);
+}
+
+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();
+#endif
+}
+
+void UpdateScreen::OnContextKeyUpdated(
+    const ::login::ScreenContext::KeyType& key) {
+  UpdateModel::OnContextKeyUpdated(key);
+}
+
+void UpdateScreen::OnConnectToNetworkRequested() {
+  if (state_ == STATE_ERROR) {
+    LOG(WARNING) << "Hiding error message since AP was reselected";
+    StartUpdateCheck();
   }
 }
 
-void UpdateScreen::Hide() {
-  if (actor_)
-    actor_->Hide();
-  is_shown_ = false;
-}
-
-std::string UpdateScreen::GetName() const {
-  return WizardController::kUpdateScreenName;
-}
-
-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:
       Finish(BaseScreenDelegate::UPDATE_NOUPDATE);
       break;
@@ skipping 31 matching lines @@
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 void UpdateScreen::OnWaitForRebootTimeElapsed() {
   LOG(ERROR) << "Unable to reboot - asking user for a manual reboot.";
   MakeSureScreenIsShown();
-  if (actor_)
-    actor_->ShowManualRebootInfo();
+  GetContextEditor().SetString(kContextKeyUpdateMessage,
+                               l10n_util::GetStringUTF16(IDS_UPDATE_COMPLETED));
 }
 
 void UpdateScreen::MakeSureScreenIsShown() {
   if (!is_shown_)
     get_base_screen_delegate()->ShowCurrentScreen();
 }
 
-void UpdateScreen::SetRebootCheckDelay(int seconds) {
-  if (seconds <= 0)
-    reboot_timer_.Stop();
-  DCHECK(!reboot_timer_.IsRunning());
-  reboot_check_delay_ = seconds;
-}
-
 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) {
-  if (!actor_)
-    return;
   base::Time download_current_time = base::Time::Now();
   if (download_current_time >= download_last_time_ + kMinTimeStep) {
     // Estimate downloading rate.
     double progress_delta =
         std::max(status.download_progress - download_last_progress_, 0.0);
     double time_delta =
         (download_current_time - download_last_time_).InSecondsF();
     double download_rate = status.new_size * progress_delta / time_delta;
 
     download_last_time_ = download_current_time;
@@ skipping 15 matching lines @@
           status.new_size *
           (status.download_progress - download_start_progress_) /
           time_delta;
     }
     double work_left = progress_left * status.new_size;
     double time_left = work_left / download_average_speed_;
     // |time_left| may be large enough or even +infinity. So we must
     // |bound possible estimations.
     time_left = std::min(time_left, kMaxTimeLeft);
 
-    actor_->ShowEstimatedTimeLeft(true);
-    actor_->SetEstimatedTimeLeft(
-        base::TimeDelta::FromSeconds(static_cast<int64>(time_left)));
+    GetContextEditor()
+        .SetBoolean(kContextKeyShowEstimatedTimeLeft, true)
+        .SetInteger(kContextKeyEstimatedTimeLeftSec,
+                    static_cast<int>(time_left));
   }
 
   int download_progress = static_cast<int>(
       status.download_progress * kDownloadProgressIncrement);
-  actor_->SetProgress(kBeforeDownloadProgress + download_progress);
+  GetContextEditor().SetInteger(kContextKeyProgress,
+                                kBeforeDownloadProgress + download_progress);
 }
 
 bool UpdateScreen::HasCriticalUpdate() {
   if (is_ignore_update_deadlines_)
     return true;
 
   std::string deadline;
   // Checking for update flag file causes us to do blocking IO on UI thread.
   // Temporarily allow it until we fix http://crosbug.com/11106
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   base::FilePath update_deadline_file_path(kUpdateDeadlineFile);
   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::OnActorDestroyed(UpdateScreenActor* actor) {
-  if (actor_ == actor)
-    actor_ = NULL;
-}
-
-void UpdateScreen::OnConnectToNetworkRequested() {
-  if (state_ == STATE_ERROR) {
-    LOG(WARNING) << "Hiding error message since AP was reselected";
-    StartUpdateCheck();
-  }
-}
-
 ErrorScreen* UpdateScreen::GetErrorScreen() {
   return get_base_screen_delegate()->GetErrorScreen();
 }
 
 void UpdateScreen::StartUpdateCheck() {
   NetworkPortalDetector::Get()->RemoveObserver(this);
   if (state_ == STATE_ERROR)
     HideErrorMessage();
   state_ = STATE_UPDATE;
   DBusThreadManager::Get()->GetUpdateEngineClient()->AddObserver(this);
@@ skipping 48 matching lines @@
 }
 
 void UpdateScreen::SetHostPairingControllerStatus(
     HostPairingController::UpdateStatus update_status) {
   if (remora_controller_) {
     remora_controller_->OnUpdateStatusChanged(update_status);
   }
 }
 
 }  // namespace chromeos