Add the ability to show a demo app on OOBE if a machine is derelict.

chrome/browser/ui/webui/chromeos/login/network_screen_handler.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/ui/webui/chromeos/login/network_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/command_line.h"
 #include "base/memory/weak_ptr.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/pref_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/base/locale_util.h"
+#include "chrome/browser/chromeos/idle_detector.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/login/input_events_blocker.h"
+#include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/screens/core_oobe_actor.h"
 #include "chrome/browser/chromeos/system/input_device_settings.h"
 #include "chrome/browser/chromeos/system/timezone_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/browser/ui/webui/options/chromeos/cros_language_options_handler.h"
+#include "chrome/common/pref_names.h"
+#include "chromeos/chromeos_switches.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 const char kJsScreenPath[] = "login.NetworkScreen";
 
 // JS API callbacks names.
 const char kJsApiNetworkOnExit[] = "networkOnExit";
 const char kJsApiNetworkOnLanguageChanged[] = "networkOnLanguageChanged";
 const char kJsApiNetworkOnInputMethodChanged[] = "networkOnInputMethodChanged";
 const char kJsApiNetworkOnTimezoneChanged[] = "networkOnTimezoneChanged";
 
 const char kUSlayout[] = "xkb:us::eng";
 
+const int64 kDerelectDetectionTimeoutSeconds = 8 * 60 * 60; // 8 hours.
+const int64 kDerelectIdleTimeoutSeconds = 5 * 60; // 5 minutes.
+
 }  // namespace
 
 namespace chromeos {
 
 // NetworkScreenHandler, public: -----------------------------------------------
 
 NetworkScreenHandler::NetworkScreenHandler(CoreOobeActor* core_oobe_actor)
     : BaseScreenHandler(kJsScreenPath),
       screen_(NULL),
       core_oobe_actor_(core_oobe_actor),
       is_continue_enabled_(false),
+      is_derelict_(false),
       show_on_init_(false),
       weak_ptr_factory_(this) {
   DCHECK(core_oobe_actor_);
+  SetupTimeouts();
 }
 
 NetworkScreenHandler::~NetworkScreenHandler() {
   if (screen_)
     screen_->OnActorDestroyed(this);
 }
 
 // NetworkScreenHandler, NetworkScreenActor implementation: --------------------
 
 void NetworkScreenHandler::SetDelegate(NetworkScreenActor::Delegate* screen) {
   screen_ = screen;
 }
 
 void NetworkScreenHandler::PrepareToShow() {
 }
 
 void NetworkScreenHandler::Show() {
   if (!page_is_ready()) {
     show_on_init_ = true;
     return;
   }
 
   ShowScreen(OobeUI::kScreenOobeNetwork, NULL);
+  StartIdleDetection();
 }
 
 void NetworkScreenHandler::Hide() {
 }
 
 void NetworkScreenHandler::ShowError(const base::string16& message) {
   CallJS("showError", message);
 }
 
 void NetworkScreenHandler::ClearErrors() {
@@ skipping 63 matching lines @@
 void NetworkScreenHandler::RegisterMessages() {
   AddCallback(kJsApiNetworkOnExit, &NetworkScreenHandler::HandleOnExit);
   AddCallback(kJsApiNetworkOnLanguageChanged,
               &NetworkScreenHandler::HandleOnLanguageChanged);
   AddCallback(kJsApiNetworkOnInputMethodChanged,
               &NetworkScreenHandler::HandleOnInputMethodChanged);
   AddCallback(kJsApiNetworkOnTimezoneChanged,
               &NetworkScreenHandler::HandleOnTimezoneChanged);
 }
 
+
+// static
+void NetworkScreenHandler::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterBooleanPref(prefs::kDerelictMachine, false);
+}
+
 // NetworkScreenHandler, private: ----------------------------------------------
 
 void NetworkScreenHandler::HandleOnExit() {
+  detector_.reset();
   ClearErrors();
   if (screen_)
     screen_->OnContinuePressed();
 }
 
 struct NetworkScreenHandlerOnLanguageChangedCallbackData {
   explicit NetworkScreenHandlerOnLanguageChangedCallbackData(
       base::WeakPtr<NetworkScreenHandler>& handler)
       : handler_(handler) {}
 
@@ skipping 55 matching lines @@
 
   CrosSettings::Get()->SetString(kSystemTimezone, timezone_id);
 }
 
 void NetworkScreenHandler::OnSystemTimezoneChanged() {
   std::string current_timezone_id;
   CrosSettings::Get()->GetString(kSystemTimezone, &current_timezone_id);
   CallJS("setTimezone", current_timezone_id);
 }
 
+void NetworkScreenHandler::StartIdleDetection() {
+  if (!detector_.get()) {
+    detector_.reset(
+        new IdleDetector(base::Closure(),
+                         base::Bind(&NetworkScreenHandler::OnIdle,
+                                    weak_ptr_factory_.GetWeakPtr())));
+  }
+
+  detector_->Start(
+      is_derelict_ ? derelict_idle_timeout_ : derelict_detection_timeout_);
+}
+
+void NetworkScreenHandler::OnIdle() {
+  if (is_derelict_) {
+    LoginDisplayHost* host = LoginDisplayHostImpl::default_host();
+    host->StartDemoAppLaunch();
+  } else {
+    is_derelict_ = true;
+    PrefService* prefs = g_browser_process->local_state();
+    prefs->SetBoolean(prefs::kDerelictMachine, true);
+
+    StartIdleDetection();
+  }
+}
+
+void NetworkScreenHandler::SetupTimeouts() {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  DCHECK(command_line);
+
+  PrefService* prefs = g_browser_process->local_state();
+  DCHECK(prefs);
+  is_derelict_ = prefs->GetBoolean(prefs::kDerelictMachine);
+
+  int64 derelict_detection_timeout;
+  if (command_line->HasSwitch(switches::kDerelictDetectionTimeout)) {
+    if (!base::StringToInt64(
+        command_line->GetSwitchValueASCII(switches::kDerelictDetectionTimeout),
+        &derelict_detection_timeout))
+      derelict_detection_timeout = kDerelectDetectionTimeoutSeconds;

[xiyuan, 2014/02/11 04:47:45]

nit: Optimize a little bit to avoid duplicate code.

if (!command_line->HasSwitch(switches::kDerelictDetectionTimeout) ||
    !base::StringToInt64(...))
  derelict_detection_timeout = kDerelectDetectionTimeoutSeconds;

[rkc, 2014/02/11 19:44:50]

Fixed, here and below.
Done.

+  } else {
+    derelict_detection_timeout = kDerelectDetectionTimeoutSeconds;
+  }
+  derelict_detection_timeout_ =
+      base::TimeDelta::FromSeconds(derelict_detection_timeout);
+
+  int64 derelict_idle_timeout;
+  if (command_line->HasSwitch(switches::kDerelictIdleTimeout)) {
+    if (!base::StringToInt64(
+        command_line->GetSwitchValueASCII(switches::kDerelictIdleTimeout),
+        &derelict_idle_timeout))
+      derelict_idle_timeout = kDerelectIdleTimeoutSeconds;
+  } else {
+    derelict_idle_timeout = kDerelectIdleTimeoutSeconds;
+  }
+  derelict_idle_timeout_ = base::TimeDelta::FromSeconds(derelict_idle_timeout);
+}
+
 // static
 base::ListValue* NetworkScreenHandler::GetLanguageList() {
   const std::string app_locale = g_browser_process->GetApplicationLocale();
   input_method::InputMethodManager* manager =
       input_method::InputMethodManager::Get();
   // GetSupportedInputMethods() never returns NULL.
   scoped_ptr<input_method::InputMethodDescriptors> descriptors(
       manager->GetSupportedInputMethods());
   base::ListValue* languages_list =
       options::CrosLanguageOptionsHandler::GetUILanguageList(*descriptors);
@@ skipping 89 matching lines @@
     timezone_option->SetString("value", timezone_id);
     timezone_option->SetString("title", timezone_name);
     timezone_option->SetBoolean("selected", timezone_id == current_timezone_id);
     timezone_list->Append(timezone_option.release());
   }
 
   return timezone_list.release();
 }
 
 }  // namespace chromeos