src/chrome/browser/ui/webui/chromeos/login/demo_mode_detector.cc

   1 // Copyright 2014 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/ui/webui/chromeos/login/demo_mode_detector.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/prefs/pref_registry_simple.h"
   9 #include "base/prefs/pref_service.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "chrome/browser/browser_process.h"
  12 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
  13 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
  14 #include "chrome/common/pref_names.h"
  15 #include "chromeos/chromeos_switches.h"
  16
  17 namespace {
  18   const int kDerelectDetectionTimeoutSeconds = 8 * 60 * 60;  // 8 hours.
  19   const int kDerelectIdleTimeoutSeconds = 5 * 60;            // 5 minutes.
  20   const int kOobeTimerUpdateIntervalSeconds = 5 * 60;        // 5 minutes.
  21 }  // namespace
  22
  23 namespace chromeos {
  24
  25 DemoModeDetector::DemoModeDetector()
  26     : demo_launched_(false),
  27       weak_ptr_factory_(this) {
  28   SetupTimeouts();
  29 }
  30
  31 DemoModeDetector::~DemoModeDetector() {
  32 }
  33
  34 // Public methods.
  35
  36 void DemoModeDetector::InitDetection() {
  37   if (IsDerelict())
  38     StartIdleDetection();
  39   else
  40     StartOobeTimer();
  41 }
  42
  43 void DemoModeDetector::StopDetection() {
  44   idle_detector_.reset();
  45 }
  46
  47 // static
  48 void DemoModeDetector::RegisterPrefs(PrefRegistrySimple* registry) {
  49   registry->RegisterInt64Pref(prefs::kTimeOnOobe, 0);
  50 }
  51
  52 // Private methods.
  53
  54 void DemoModeDetector::StartIdleDetection() {
  55   if (!idle_detector_.get()) {
  56     idle_detector_.reset(
  57         new IdleDetector(base::Closure(),
  58                          base::Bind(&DemoModeDetector::OnIdle,
  59                                     weak_ptr_factory_.GetWeakPtr())));
  60   }
  61   idle_detector_->Start(derelict_idle_timeout_);
  62 }
  63
  64 void DemoModeDetector::StartOobeTimer() {
  65   if (oobe_timer_.IsRunning())
  66     return;
  67   oobe_timer_.Start(FROM_HERE,
  68                     oobe_timer_update_interval_,
  69                     this,
  70                     &DemoModeDetector::OnOobeTimerUpdate);
  71 }
  72
  73 void DemoModeDetector::OnIdle() {
  74   if (demo_launched_)
  75     return;
  76   demo_launched_ = true;
  77   LoginDisplayHost* host = LoginDisplayHostImpl::default_host();
  78   host->StartDemoAppLaunch();
  79 }
  80
  81 void DemoModeDetector::OnOobeTimerUpdate() {
  82   time_on_oobe_ += oobe_timer_update_interval_;
  83
  84   PrefService* prefs = g_browser_process->local_state();
  85   prefs->SetInt64(prefs::kTimeOnOobe, time_on_oobe_.InSeconds());
  86
  87   if (IsDerelict()) {
  88     oobe_timer_.Stop();
  89     StartIdleDetection();
  90   }
  91 }
  92
  93 void DemoModeDetector::SetupTimeouts() {
  94   CommandLine* cmdline = CommandLine::ForCurrentProcess();
  95   DCHECK(cmdline);
  96
  97   PrefService* prefs = g_browser_process->local_state();
  98   time_on_oobe_ =
  99       base::TimeDelta::FromSeconds(prefs->GetInt64(prefs::kTimeOnOobe));
 100
 101   int derelict_detection_timeout;
 102   if (!cmdline->HasSwitch(switches::kDerelictDetectionTimeout) ||
 103       !base::StringToInt(
 104           cmdline->GetSwitchValueASCII(switches::kDerelictDetectionTimeout),
 105           &derelict_detection_timeout)) {
 106     derelict_detection_timeout = kDerelectDetectionTimeoutSeconds;
 107   }
 108   derelict_detection_timeout_ =
 109       base::TimeDelta::FromSeconds(derelict_detection_timeout);
 110
 111   int derelict_idle_timeout;
 112   if (!cmdline->HasSwitch(switches::kDerelictIdleTimeout) ||
 113       !base::StringToInt(
 114           cmdline->GetSwitchValueASCII(switches::kDerelictIdleTimeout),
 115           &derelict_idle_timeout)) {
 116     derelict_idle_timeout = kDerelectIdleTimeoutSeconds;
 117   }
 118   derelict_idle_timeout_ = base::TimeDelta::FromSeconds(derelict_idle_timeout);
 119
 120
 121   int oobe_timer_update_interval;
 122   if (!cmdline->HasSwitch(switches::kOobeTimerInterval) ||
 123       !base::StringToInt(
 124           cmdline->GetSwitchValueASCII(switches::kOobeTimerInterval),
 125           &oobe_timer_update_interval)) {
 126     oobe_timer_update_interval = kOobeTimerUpdateIntervalSeconds;
 127   }
 128   oobe_timer_update_interval_ =
 129       base::TimeDelta::FromSeconds(oobe_timer_update_interval);
 130
 131   // In case we'd be derelict before our timer is set to trigger, reduce
 132   // the interval so we check again when we're scheduled to go derelict.
 133   oobe_timer_update_interval_ =
 134       std::max(std::min(oobe_timer_update_interval_,
 135                         derelict_detection_timeout_ - time_on_oobe_),
 136                base::TimeDelta::FromSeconds(0));
 137 }
 138
 139 bool DemoModeDetector::IsDerelict() {
 140   return time_on_oobe_ >= derelict_detection_timeout_;
 141 }
 142
 143 }  // namespace chromeos