Additional checks/calls for cases when WebUI may be already gone but OOBE screen instance is not

chrome/browser/chromeos/login/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/update_screen.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 78 matching lines @@
 UpdateScreen::UpdateScreen(ScreenObserver* screen_observer,
                            UpdateScreenActor* actor)
     : WizardScreen(screen_observer),
       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) {
-  actor_->SetDelegate(this);
+  DCHECK(actor_);
+  if (actor_)
+    actor_->SetDelegate(this);
   GetInstanceSet().insert(this);
 }
 
 UpdateScreen::~UpdateScreen() {
   DBusThreadManager::Get()->GetUpdateEngineClient()->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) {
@@ skipping 94 matching lines @@
       base::Bind(StartUpdateCallback, this));
 }
 
 void UpdateScreen::CancelUpdate() {
   VLOG(1) << "Forced update cancel";
   ExitUpdate(REASON_UPDATE_CANCELED);
 }
 
 void UpdateScreen::Show() {
   is_shown_ = true;
-  actor_->Show();
-  actor_->SetProgress(kBeforeUpdateCheckProgress);
+  if (actor_) {
+    actor_->Show();
+    actor_->SetProgress(kBeforeUpdateCheckProgress);
+  }
 }
 
 void UpdateScreen::Hide() {
-  actor_->Hide();
+  if (actor_)
+    actor_->Hide();
   is_shown_ = false;
 }
 
 std::string UpdateScreen::GetName() const {
   return WizardController::kUpdateScreenName;
 }
 
 void UpdateScreen::PrepareToShow() {
-  actor_->PrepareToShow();
+  if (actor_)
+    actor_->PrepareToShow();
 }
 
 void UpdateScreen::ExitUpdate(UpdateScreen::ExitReason reason) {
   DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
 
   switch (reason) {
     case REASON_UPDATE_CANCELED:
       get_screen_observer()->OnExit(ScreenObserver::UPDATE_NOUPDATE);
       break;
     case REASON_UPDATE_INIT_FAILED:
@@ skipping 29 matching lines @@
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 void UpdateScreen::OnWaitForRebootTimeElapsed() {
   LOG(ERROR) << "Unable to reboot - asking user for a manual reboot.";
   MakeSureScreenIsShown();
-  actor_->ShowManualRebootInfo();
+  if (actor_)
+    actor_->ShowManualRebootInfo();
 }
 
 void UpdateScreen::MakeSureScreenIsShown() {
   if (!is_shown_)
     get_screen_observer()->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::UpdateDownloadingStats(
     const UpdateEngineClient::Status& status) {
+  if (!actor_)
+    return;
   base::Time download_current_time = base::Time::Now();
   if (download_current_time >= download_last_time_ + kMinTimeStep &&
       status.download_progress >=
       download_last_progress_ + kMinProgressStep) {
     // 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;
@@ skipping 52 matching lines @@
   // if the file exists and not empty, there is critical update.
   return true;
 }
 
 void UpdateScreen::OnActorDestroyed(UpdateScreenActor* actor) {
   if (actor_ == actor)
     actor_ = NULL;
 }
 
 }  // namespace chromeos