Home | History | Annotate | Download | only in screens 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/chromeos/login/screens/update_screen.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/bind.h"
     10 #include "base/command_line.h"
     11 #include "base/file_util.h"
     12 #include "base/logging.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "base/threading/thread_restrictions.h"
     15 #include "chrome/browser/chromeos/login/screens/error_screen.h"
     16 #include "chrome/browser/chromeos/login/screens/screen_observer.h"
     17 #include "chrome/browser/chromeos/login/screens/update_screen_actor.h"
     18 #include "chrome/browser/chromeos/login/startup_utils.h"
     19 #include "chrome/browser/chromeos/login/wizard_controller.h"
     20 #include "chromeos/chromeos_switches.h"
     21 #include "chromeos/dbus/dbus_thread_manager.h"
     22 #include "chromeos/network/network_state.h"
     23 #include "content/public/browser/browser_thread.h"
     24 
     25 using content::BrowserThread;
     26 
     27 namespace chromeos {
     28 
     29 namespace {
     30 
     31 // Progress bar stages. Each represents progress bar value
     32 // at the beginning of each stage.
     33 // TODO(nkostylev): Base stage progress values on approximate time.
     34 // TODO(nkostylev): Animate progress during each state.
     35 const int kBeforeUpdateCheckProgress = 7;
     36 const int kBeforeDownloadProgress = 14;
     37 const int kBeforeVerifyingProgress = 74;
     38 const int kBeforeFinalizingProgress = 81;
     39 const int kProgressComplete = 100;
     40 
     41 // Defines what part of update progress does download part takes.
     42 const int kDownloadProgressIncrement = 60;
     43 
     44 const char kUpdateDeadlineFile[] = "/tmp/update-check-response-deadline";
     45 
     46 // Minimum timestep between two consecutive measurements for the
     47 // download rate.
     48 const base::TimeDelta kMinTimeStep = base::TimeDelta::FromSeconds(1);
     49 
     50 // Smooth factor that is used for the average downloading speed
     51 // estimation.
     52 // avg_speed = smooth_factor * cur_speed + (1.0 - smooth_factor) * avg_speed.
     53 const double kDownloadSpeedSmoothFactor = 0.1;
     54 
     55 // Minumum allowed value for the average downloading speed.
     56 const double kDownloadAverageSpeedDropBound = 1e-8;
     57 
     58 // An upper bound for possible downloading time left estimations.
     59 const double kMaxTimeLeft = 24 * 60 * 60;
     60 
     61 // Invoked from call to RequestUpdateCheck upon completion of the DBus call.
     62 void StartUpdateCallback(UpdateScreen* screen,
     63                          UpdateEngineClient::UpdateCheckResult result) {
     64   VLOG(1) << "Callback from RequestUpdateCheck, result " << result;
     65   if (UpdateScreen::HasInstance(screen)) {
     66     if (result == UpdateEngineClient::UPDATE_RESULT_SUCCESS)
     67       screen->SetIgnoreIdleStatus(false);
     68     else
     69       screen->ExitUpdate(UpdateScreen::REASON_UPDATE_INIT_FAILED);
     70   }
     71 }
     72 
     73 // Returns true if blocking AU is enabled in command line.
     74 bool IsBlockingUpdateEnabledInCommandLine() {
     75   return !CommandLine::ForCurrentProcess()->HasSwitch(
     76       chromeos::switches::kDisableOOBEBlockingUpdate);
     77 }
     78 
     79 }  // anonymous namespace
     80 
     81 // static
     82 UpdateScreen::InstanceSet& UpdateScreen::GetInstanceSet() {
     83   CR_DEFINE_STATIC_LOCAL(std::set<UpdateScreen*>, instance_set, ());
     84   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));  // not threadsafe.
     85   return instance_set;
     86 }
     87 
     88 // static
     89 bool UpdateScreen::HasInstance(UpdateScreen* inst) {
     90   InstanceSet& instance_set = GetInstanceSet();
     91   InstanceSet::iterator found = instance_set.find(inst);
     92   return (found != instance_set.end());
     93 }
     94 
     95 UpdateScreen::UpdateScreen(
     96     ScreenObserver* screen_observer,
     97     UpdateScreenActor* actor)
     98     : WizardScreen(screen_observer),
     99       state_(STATE_IDLE),
    100       reboot_check_delay_(0),
    101       is_checking_for_update_(true),
    102       is_downloading_update_(false),
    103       is_ignore_update_deadlines_(false),
    104       is_shown_(false),
    105       ignore_idle_status_(true),
    106       actor_(actor),
    107       is_first_detection_notification_(true),
    108       is_first_portal_notification_(true),
    109       weak_factory_(this) {
    110   DCHECK(actor_);
    111   if (actor_)
    112     actor_->SetDelegate(this);
    113   GetInstanceSet().insert(this);
    114 }
    115 
    116 UpdateScreen::~UpdateScreen() {
    117   DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
    118   NetworkPortalDetector::Get()->RemoveObserver(this);
    119   GetInstanceSet().erase(this);
    120   if (actor_)
    121     actor_->SetDelegate(NULL);
    122 }
    123 
    124 void UpdateScreen::UpdateStatusChanged(
    125     const UpdateEngineClient::Status& status) {
    126   if (!actor_)
    127     return;
    128 
    129   if (is_checking_for_update_ &&
    130       status.status > UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE) {
    131     is_checking_for_update_ = false;
    132   }
    133   if (ignore_idle_status_ && status.status >
    134       UpdateEngineClient::UPDATE_STATUS_IDLE) {
    135     ignore_idle_status_ = false;
    136   }
    137 
    138   switch (status.status) {
    139     case UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE:
    140       // Do nothing in these cases, we don't want to notify the user of the
    141       // check unless there is an update.
    142       break;
    143     case UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE:
    144       MakeSureScreenIsShown();
    145       actor_->SetProgress(kBeforeDownloadProgress);
    146       actor_->ShowEstimatedTimeLeft(false);
    147       if (!HasCriticalUpdate()) {
    148         LOG(INFO) << "Noncritical update available: "
    149                   << status.new_version;
    150         ExitUpdate(REASON_UPDATE_NON_CRITICAL);
    151       } else {
    152         LOG(INFO) << "Critical update available: "
    153                   << status.new_version;
    154         actor_->SetProgressMessage(
    155             UpdateScreenActor::PROGRESS_MESSAGE_UPDATE_AVAILABLE);
    156         actor_->ShowProgressMessage(true);
    157         actor_->ShowCurtain(false);
    158       }
    159       break;
    160     case UpdateEngineClient::UPDATE_STATUS_DOWNLOADING:
    161       {
    162         MakeSureScreenIsShown();
    163         if (!is_downloading_update_) {
    164           // Because update engine doesn't send UPDATE_STATUS_UPDATE_AVAILABLE
    165           // we need to is update critical on first downloading notification.
    166           is_downloading_update_ = true;
    167           download_start_time_ = download_last_time_ = base::Time::Now();
    168           download_start_progress_ = status.download_progress;
    169           download_last_progress_ = status.download_progress;
    170           is_download_average_speed_computed_ = false;
    171           download_average_speed_ = 0.0;
    172           if (!HasCriticalUpdate()) {
    173             LOG(INFO) << "Non-critical update available: "
    174                       << status.new_version;
    175             ExitUpdate(REASON_UPDATE_NON_CRITICAL);
    176           } else {
    177             LOG(INFO) << "Critical update available: "
    178                       << status.new_version;
    179             actor_->SetProgressMessage(
    180                 UpdateScreenActor::PROGRESS_MESSAGE_INSTALLING_UPDATE);
    181             actor_->ShowProgressMessage(true);
    182             actor_->ShowCurtain(false);
    183           }
    184         }
    185         UpdateDownloadingStats(status);
    186       }
    187       break;
    188     case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
    189       MakeSureScreenIsShown();
    190       actor_->SetProgress(kBeforeVerifyingProgress);
    191       actor_->SetProgressMessage(UpdateScreenActor::PROGRESS_MESSAGE_VERIFYING);
    192       actor_->ShowProgressMessage(true);
    193       break;
    194     case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
    195       MakeSureScreenIsShown();
    196       actor_->SetProgress(kBeforeFinalizingProgress);
    197       actor_->SetProgressMessage(
    198           UpdateScreenActor::PROGRESS_MESSAGE_FINALIZING);
    199       actor_->ShowProgressMessage(true);
    200       break;
    201     case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
    202       MakeSureScreenIsShown();
    203       // Make sure that first OOBE stage won't be shown after reboot.
    204       StartupUtils::MarkOobeCompleted();
    205       actor_->SetProgress(kProgressComplete);
    206       actor_->ShowEstimatedTimeLeft(false);
    207       if (HasCriticalUpdate()) {
    208         actor_->ShowCurtain(false);
    209         VLOG(1) << "Initiate reboot after update";
    210         DBusThreadManager::Get()->GetUpdateEngineClient()->RebootAfterUpdate();
    211         reboot_timer_.Start(FROM_HERE,
    212                             base::TimeDelta::FromSeconds(reboot_check_delay_),
    213                             this,
    214                             &UpdateScreen::OnWaitForRebootTimeElapsed);
    215       } else {
    216         ExitUpdate(REASON_UPDATE_NON_CRITICAL);
    217       }
    218       break;
    219     case UpdateEngineClient::UPDATE_STATUS_IDLE:
    220       if (ignore_idle_status_) {
    221         // It is first IDLE status that is sent before we initiated the check.
    222         break;
    223       }
    224       // else no break
    225 
    226     case UpdateEngineClient::UPDATE_STATUS_ERROR:
    227     case UpdateEngineClient::UPDATE_STATUS_REPORTING_ERROR_EVENT:
    228       ExitUpdate(REASON_UPDATE_ENDED);
    229       break;
    230     default:
    231       NOTREACHED();
    232       break;
    233   }
    234 }
    235 
    236 void UpdateScreen::OnPortalDetectionCompleted(
    237     const NetworkState* network,
    238     const NetworkPortalDetector::CaptivePortalState& state) {
    239   LOG(WARNING) << "UpdateScreen::PortalDetectionCompleted(): "
    240                << "network=" << (network ? network->path() : "") << ", "
    241                << "state.status=" << state.status << ", "
    242                << "state.response_code=" << state.response_code;
    243 
    244   // Wait for the sane detection results.
    245   if (network &&
    246       state.status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN) {
    247     return;
    248   }
    249 
    250   // Restart portal detection for the first notification about offline state.
    251   if ((!network ||
    252        state.status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE) &&
    253       is_first_detection_notification_) {
    254     is_first_detection_notification_ = false;
    255     base::MessageLoop::current()->PostTask(
    256         FROM_HERE,
    257         base::Bind(
    258             base::IgnoreResult(&NetworkPortalDetector::StartDetectionIfIdle),
    259             base::Unretained(NetworkPortalDetector::Get())));
    260     return;
    261   }
    262   is_first_detection_notification_ = false;
    263 
    264   NetworkPortalDetector::CaptivePortalStatus status = state.status;
    265   if (state_ == STATE_ERROR) {
    266     // In the case of online state hide error message and proceed to
    267     // the update stage. Otherwise, update error message content.
    268     if (status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE)
    269       StartUpdateCheck();
    270     else
    271       UpdateErrorMessage(network, status);
    272   } else if (state_ == STATE_FIRST_PORTAL_CHECK) {
    273     // In the case of online state immediately proceed to the update
    274     // stage. Otherwise, prepare and show error message.
    275     if (status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE) {
    276       StartUpdateCheck();
    277     } else {
    278       UpdateErrorMessage(network, status);
    279       ShowErrorMessage();
    280     }
    281   }
    282 }
    283 
    284 void UpdateScreen::StartNetworkCheck() {
    285   // If portal detector is enabled and portal detection before AU is
    286   // allowed, initiate network state check. Otherwise, directly
    287   // proceed to update.
    288   if (!NetworkPortalDetector::Get()->IsEnabled() ||
    289       !IsBlockingUpdateEnabledInCommandLine()) {
    290     StartUpdateCheck();
    291     return;
    292   }
    293   state_ = STATE_FIRST_PORTAL_CHECK;
    294   is_first_detection_notification_ = true;
    295   is_first_portal_notification_ = true;
    296   NetworkPortalDetector::Get()->AddAndFireObserver(this);
    297 }
    298 
    299 void UpdateScreen::CancelUpdate() {
    300   VLOG(1) << "Forced update cancel";
    301   ExitUpdate(REASON_UPDATE_CANCELED);
    302 }
    303 
    304 void UpdateScreen::Show() {
    305   is_shown_ = true;
    306   if (actor_) {
    307     actor_->Show();
    308     actor_->SetProgress(kBeforeUpdateCheckProgress);
    309   }
    310 }
    311 
    312 void UpdateScreen::Hide() {
    313   if (actor_)
    314     actor_->Hide();
    315   is_shown_ = false;
    316 }
    317 
    318 std::string UpdateScreen::GetName() const {
    319   return WizardController::kUpdateScreenName;
    320 }
    321 
    322 void UpdateScreen::PrepareToShow() {
    323   if (actor_)
    324     actor_->PrepareToShow();
    325 }
    326 
    327 void UpdateScreen::ExitUpdate(UpdateScreen::ExitReason reason) {
    328   DBusThreadManager::Get()->GetUpdateEngineClient()->RemoveObserver(this);
    329   NetworkPortalDetector::Get()->RemoveObserver(this);
    330 
    331   switch (reason) {
    332     case REASON_UPDATE_CANCELED:
    333       get_screen_observer()->OnExit(ScreenObserver::UPDATE_NOUPDATE);
    334       break;
    335     case REASON_UPDATE_INIT_FAILED:
    336       get_screen_observer()->OnExit(
    337           ScreenObserver::UPDATE_ERROR_CHECKING_FOR_UPDATE);
    338       break;
    339     case REASON_UPDATE_NON_CRITICAL:
    340     case REASON_UPDATE_ENDED:
    341       {
    342         UpdateEngineClient* update_engine_client =
    343             DBusThreadManager::Get()->GetUpdateEngineClient();
    344         switch (update_engine_client->GetLastStatus().status) {
    345           case UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE:
    346           case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
    347           case UpdateEngineClient::UPDATE_STATUS_DOWNLOADING:
    348           case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
    349           case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
    350             DCHECK(!HasCriticalUpdate());
    351             // Noncritical update, just exit screen as if there is no update.
    352             // no break
    353           case UpdateEngineClient::UPDATE_STATUS_IDLE:
    354             get_screen_observer()->OnExit(ScreenObserver::UPDATE_NOUPDATE);
    355             break;
    356           case UpdateEngineClient::UPDATE_STATUS_ERROR:
    357           case UpdateEngineClient::UPDATE_STATUS_REPORTING_ERROR_EVENT:
    358             get_screen_observer()->OnExit(is_checking_for_update_ ?
    359                 ScreenObserver::UPDATE_ERROR_CHECKING_FOR_UPDATE :
    360                 ScreenObserver::UPDATE_ERROR_UPDATING);
    361             break;
    362           default:
    363             NOTREACHED();
    364         }
    365       }
    366       break;
    367     default:
    368       NOTREACHED();
    369   }
    370 }
    371 
    372 void UpdateScreen::OnWaitForRebootTimeElapsed() {
    373   LOG(ERROR) << "Unable to reboot - asking user for a manual reboot.";
    374   MakeSureScreenIsShown();
    375   if (actor_)
    376     actor_->ShowManualRebootInfo();
    377 }
    378 
    379 void UpdateScreen::MakeSureScreenIsShown() {
    380   if (!is_shown_)
    381     get_screen_observer()->ShowCurrentScreen();
    382 }
    383 
    384 void UpdateScreen::SetRebootCheckDelay(int seconds) {
    385   if (seconds <= 0)
    386     reboot_timer_.Stop();
    387   DCHECK(!reboot_timer_.IsRunning());
    388   reboot_check_delay_ = seconds;
    389 }
    390 
    391 void UpdateScreen::SetIgnoreIdleStatus(bool ignore_idle_status) {
    392   ignore_idle_status_ = ignore_idle_status;
    393 }
    394 
    395 void UpdateScreen::UpdateDownloadingStats(
    396     const UpdateEngineClient::Status& status) {
    397   if (!actor_)
    398     return;
    399   base::Time download_current_time = base::Time::Now();
    400   if (download_current_time >= download_last_time_ + kMinTimeStep) {
    401     // Estimate downloading rate.
    402     double progress_delta =
    403         std::max(status.download_progress - download_last_progress_, 0.0);
    404     double time_delta =
    405         (download_current_time - download_last_time_).InSecondsF();
    406     double download_rate = status.new_size * progress_delta / time_delta;
    407 
    408     download_last_time_ = download_current_time;
    409     download_last_progress_ = status.download_progress;
    410 
    411     // Estimate time left.
    412     double progress_left = std::max(1.0 - status.download_progress, 0.0);
    413     if (!is_download_average_speed_computed_) {
    414       download_average_speed_ = download_rate;
    415       is_download_average_speed_computed_ = true;
    416     }
    417     download_average_speed_ =
    418         kDownloadSpeedSmoothFactor * download_rate +
    419         (1.0 - kDownloadSpeedSmoothFactor) * download_average_speed_;
    420     if (download_average_speed_ < kDownloadAverageSpeedDropBound) {
    421       time_delta =
    422           (download_current_time - download_start_time_).InSecondsF();
    423       download_average_speed_ =
    424           status.new_size *
    425           (status.download_progress - download_start_progress_) /
    426           time_delta;
    427     }
    428     double work_left = progress_left * status.new_size;
    429     double time_left = work_left / download_average_speed_;
    430     // |time_left| may be large enough or even +infinity. So we must
    431     // |bound possible estimations.
    432     time_left = std::min(time_left, kMaxTimeLeft);
    433 
    434     actor_->ShowEstimatedTimeLeft(true);
    435     actor_->SetEstimatedTimeLeft(
    436         base::TimeDelta::FromSeconds(static_cast<int64>(time_left)));
    437   }
    438 
    439   int download_progress = static_cast<int>(
    440       status.download_progress * kDownloadProgressIncrement);
    441   actor_->SetProgress(kBeforeDownloadProgress + download_progress);
    442 }
    443 
    444 bool UpdateScreen::HasCriticalUpdate() {
    445   if (is_ignore_update_deadlines_)
    446     return true;
    447 
    448   std::string deadline;
    449   // Checking for update flag file causes us to do blocking IO on UI thread.
    450   // Temporarily allow it until we fix http://crosbug.com/11106
    451   base::ThreadRestrictions::ScopedAllowIO allow_io;
    452   base::FilePath update_deadline_file_path(kUpdateDeadlineFile);
    453   if (!base::ReadFileToString(update_deadline_file_path, &deadline) ||
    454       deadline.empty()) {
    455     return false;
    456   }
    457 
    458   // TODO(dpolukhin): Analyze file content. Now we can just assume that
    459   // if the file exists and not empty, there is critical update.
    460   return true;
    461 }
    462 
    463 void UpdateScreen::OnActorDestroyed(UpdateScreenActor* actor) {
    464   if (actor_ == actor)
    465     actor_ = NULL;
    466 }
    467 
    468 void UpdateScreen::OnConnectToNetworkRequested(
    469     const std::string& service_path) {
    470   if (state_ == STATE_ERROR) {
    471     LOG(WARNING) << "Hiding error message since AP was reselected";
    472     StartUpdateCheck();
    473   }
    474 }
    475 
    476 ErrorScreen* UpdateScreen::GetErrorScreen() {
    477   return get_screen_observer()->GetErrorScreen();
    478 }
    479 
    480 void UpdateScreen::StartUpdateCheck() {
    481   NetworkPortalDetector::Get()->RemoveObserver(this);
    482   if (state_ == STATE_ERROR)
    483     HideErrorMessage();
    484   state_ = STATE_UPDATE;
    485   DBusThreadManager::Get()->GetUpdateEngineClient()->AddObserver(this);
    486   VLOG(1) << "Initiate update check";
    487   DBusThreadManager::Get()->GetUpdateEngineClient()->RequestUpdateCheck(
    488       base::Bind(StartUpdateCallback, this));
    489 }
    490 
    491 void UpdateScreen::ShowErrorMessage() {
    492   LOG(WARNING) << "UpdateScreen::ShowErrorMessage()";
    493   state_ = STATE_ERROR;
    494   GetErrorScreen()->SetUIState(ErrorScreen::UI_STATE_UPDATE);
    495   get_screen_observer()->ShowErrorScreen();
    496 }
    497 
    498 void UpdateScreen::HideErrorMessage() {
    499   LOG(WARNING) << "UpdateScreen::HideErrorMessage()";
    500   get_screen_observer()->HideErrorScreen(this);
    501 }
    502 
    503 void UpdateScreen::UpdateErrorMessage(
    504     const NetworkState* network,
    505     const NetworkPortalDetector::CaptivePortalStatus status) {
    506   switch (status) {
    507     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE:
    508       NOTREACHED();
    509       break;
    510     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN:
    511     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE:
    512       GetErrorScreen()->SetErrorState(ErrorScreen::ERROR_STATE_OFFLINE,
    513                                       std::string());
    514       break;
    515     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL:
    516       DCHECK(network);
    517       GetErrorScreen()->SetErrorState(ErrorScreen::ERROR_STATE_PORTAL,
    518                                       network->name());
    519       if (is_first_portal_notification_) {
    520         is_first_portal_notification_ = false;
    521         GetErrorScreen()->FixCaptivePortal();
    522       }
    523       break;
    524     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
    525       GetErrorScreen()->SetErrorState(ErrorScreen::ERROR_STATE_PROXY,
    526                                       std::string());
    527       break;
    528     default:
    529       NOTREACHED();
    530       break;
    531   }
    532 }
    533 
    534 }  // namespace chromeos
    535