| OLD | NEW |
|---|
| (Empty) |
| 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/kiosk_mode/kiosk_mode_screensaver.h" | |
| 6 | |
| 7 #include "ash/screensaver/screensaver_view.h" | |
| 8 #include "base/bind.h" | |
| 9 #include "base/callback.h" | |
| 10 #include "base/lazy_instance.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "chrome/browser/browser_process.h" | |
| 13 #include "chrome/browser/chrome_notification_types.h" | |
| 14 #include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_settings.h" | |
| 15 #include "chrome/browser/chromeos/login/existing_user_controller.h" | |
| 16 #include "chrome/browser/chromeos/login/signin_specifics.h" | |
| 17 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h" | |
| 18 #include "chrome/browser/chromeos/policy/app_pack_updater.h" | |
| 19 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h" | |
| 20 #include "chrome/browser/chromeos/profiles/profile_helper.h" | |
| 21 #include "chrome/browser/extensions/extension_garbage_collector_chromeos.h" | |
| 22 #include "chrome/browser/extensions/extension_service.h" | |
| 23 #include "chrome/browser/extensions/sandboxed_unpacker.h" | |
| 24 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h" | |
| 25 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h" | |
| 26 #include "chromeos/login/auth/user_context.h" | |
| 27 #include "chromeos/login/login_state.h" | |
| 28 #include "chromeos/login/user_names.h" | |
| 29 #include "components/user_manager/user_type.h" | |
| 30 #include "content/public/browser/browser_thread.h" | |
| 31 #include "content/public/browser/notification_service.h" | |
| 32 #include "extensions/browser/extension_system.h" | |
| 33 #include "extensions/common/extension.h" | |
| 34 #include "extensions/common/file_util.h" | |
| 35 #include "ui/wm/core/user_activity_detector.h" | |
| 36 | |
| 37 using extensions::Extension; | |
| 38 using extensions::ExtensionGarbageCollectorChromeOS; | |
| 39 using extensions::SandboxedUnpacker; | |
| 40 | |
| 41 namespace chromeos { | |
| 42 | |
| 43 namespace { | |
| 44 | |
| 45 ExtensionService* GetDefaultExtensionService() { | |
| 46 Profile* default_profile = ProfileHelper::GetSigninProfile(); | |
| 47 if (!default_profile) | |
| 48 return NULL; | |
| 49 return extensions::ExtensionSystem::Get( | |
| 50 default_profile)->extension_service(); | |
| 51 } | |
| 52 | |
| 53 ExtensionGarbageCollectorChromeOS* GetDefaultExtensionGarbageCollector() { | |
| 54 Profile* default_profile = ProfileHelper::GetSigninProfile(); | |
| 55 if (!default_profile) | |
| 56 return NULL; | |
| 57 return ExtensionGarbageCollectorChromeOS::Get(default_profile); | |
| 58 } | |
| 59 | |
| 60 typedef base::Callback<void( | |
| 61 scoped_refptr<Extension>, | |
| 62 const base::FilePath&)> UnpackCallback; | |
| 63 | |
| 64 class ScreensaverUnpackerClient | |
| 65 : public extensions::SandboxedUnpackerClient { | |
| 66 public: | |
| 67 ScreensaverUnpackerClient(const base::FilePath& crx_path, | |
| 68 const UnpackCallback& unpacker_callback) | |
| 69 : crx_path_(crx_path), | |
| 70 unpack_callback_(unpacker_callback) {} | |
| 71 | |
| 72 virtual void OnUnpackSuccess(const base::FilePath& temp_dir, | |
| 73 const base::FilePath& extension_root, | |
| 74 const base::DictionaryValue* original_manifest, | |
| 75 const Extension* extension, | |
| 76 const SkBitmap& install_icon) override; | |
| 77 virtual void OnUnpackFailure(const base::string16& error) override; | |
| 78 | |
| 79 protected: | |
| 80 virtual ~ScreensaverUnpackerClient() {} | |
| 81 | |
| 82 private: | |
| 83 void LoadScreensaverExtension( | |
| 84 const base::FilePath& extension_base_path, | |
| 85 const base::FilePath& screensaver_extension_path); | |
| 86 | |
| 87 void NotifyAppPackOfDamagedFile(); | |
| 88 | |
| 89 base::FilePath crx_path_; | |
| 90 UnpackCallback unpack_callback_; | |
| 91 | |
| 92 DISALLOW_COPY_AND_ASSIGN(ScreensaverUnpackerClient); | |
| 93 }; | |
| 94 | |
| 95 void ScreensaverUnpackerClient::OnUnpackSuccess( | |
| 96 const base::FilePath& temp_dir, | |
| 97 const base::FilePath& extension_root, | |
| 98 const base::DictionaryValue* original_manifest, | |
| 99 const Extension* extension, | |
| 100 const SkBitmap& install_icon) { | |
| 101 content::BrowserThread::PostTask( | |
| 102 content::BrowserThread::FILE, | |
| 103 FROM_HERE, | |
| 104 base::Bind(&ScreensaverUnpackerClient::LoadScreensaverExtension, | |
| 105 this, | |
| 106 temp_dir, | |
| 107 extension_root)); | |
| 108 } | |
| 109 | |
| 110 void ScreensaverUnpackerClient::OnUnpackFailure(const base::string16& error) { | |
| 111 LOG(ERROR) << "Couldn't unpack screensaver extension. Error: " << error; | |
| 112 NotifyAppPackOfDamagedFile(); | |
| 113 } | |
| 114 | |
| 115 void ScreensaverUnpackerClient::LoadScreensaverExtension( | |
| 116 const base::FilePath& extension_base_path, | |
| 117 const base::FilePath& screensaver_extension_path) { | |
| 118 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE)); | |
| 119 | |
| 120 // TODO(rkc): This is a HACK, please remove this method from extension | |
| 121 // service once this code is deprecated. See crbug.com/280363 | |
| 122 ExtensionGarbageCollectorChromeOS* gc = GetDefaultExtensionGarbageCollector(); | |
| 123 if (gc) | |
| 124 gc->disable_garbage_collection(); | |
| 125 | |
| 126 std::string error; | |
| 127 scoped_refptr<Extension> screensaver_extension = | |
| 128 extensions::file_util::LoadExtension(screensaver_extension_path, | |
| 129 extensions::Manifest::COMPONENT, | |
| 130 Extension::NO_FLAGS, | |
| 131 &error); | |
| 132 if (!screensaver_extension.get()) { | |
| 133 LOG(ERROR) << "Could not load screensaver extension from: " | |
| 134 << screensaver_extension_path.value() << " due to: " << error; | |
| 135 NotifyAppPackOfDamagedFile(); | |
| 136 return; | |
| 137 } | |
| 138 | |
| 139 content::BrowserThread::PostTask( | |
| 140 content::BrowserThread::UI, | |
| 141 FROM_HERE, | |
| 142 base::Bind( | |
| 143 unpack_callback_, | |
| 144 screensaver_extension, | |
| 145 extension_base_path)); | |
| 146 } | |
| 147 | |
| 148 void ScreensaverUnpackerClient::NotifyAppPackOfDamagedFile() { | |
| 149 if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) { | |
| 150 content::BrowserThread::PostTask( | |
| 151 content::BrowserThread::UI, FROM_HERE, | |
| 152 base::Bind(&ScreensaverUnpackerClient::NotifyAppPackOfDamagedFile, | |
| 153 this)); | |
| 154 return; | |
| 155 } | |
| 156 | |
| 157 policy::BrowserPolicyConnectorChromeOS* connector = | |
| 158 g_browser_process->platform_part()->browser_policy_connector_chromeos(); | |
| 159 policy::AppPackUpdater* updater = connector->GetAppPackUpdater(); | |
| 160 if (updater) | |
| 161 updater->OnDamagedFileDetected(crx_path_); | |
| 162 } | |
| 163 | |
| 164 } // namespace | |
| 165 | |
| 166 KioskModeScreensaver::KioskModeScreensaver() | |
| 167 : weak_ptr_factory_(this) { | |
| 168 chromeos::KioskModeSettings* kiosk_mode_settings = | |
| 169 chromeos::KioskModeSettings::Get(); | |
| 170 | |
| 171 if (kiosk_mode_settings->is_initialized()) { | |
| 172 GetScreensaverCrxPath(); | |
| 173 } else { | |
| 174 kiosk_mode_settings->Initialize(base::Bind( | |
| 175 &KioskModeScreensaver::GetScreensaverCrxPath, | |
| 176 weak_ptr_factory_.GetWeakPtr())); | |
| 177 } | |
| 178 } | |
| 179 | |
| 180 KioskModeScreensaver::~KioskModeScreensaver() { | |
| 181 // If we are shutting down the system might already be gone and we shouldn't | |
| 182 // do anything (see crbug.com/288216). | |
| 183 if (!g_browser_process || g_browser_process->IsShuttingDown()) | |
| 184 return; | |
| 185 | |
| 186 // If the extension was unpacked. | |
| 187 if (!extension_base_path_.empty()) { | |
| 188 // TODO(rkc): This is a HACK, please remove this method from extension | |
| 189 // service once this code is deprecated. See crbug.com/280363 | |
| 190 ExtensionGarbageCollectorChromeOS* gc = | |
| 191 GetDefaultExtensionGarbageCollector(); | |
| 192 if (gc) | |
| 193 gc->enable_garbage_collection(); | |
| 194 | |
| 195 // Delete it. | |
| 196 content::BrowserThread::PostTask( | |
| 197 content::BrowserThread::FILE, | |
| 198 FROM_HERE, | |
| 199 base::Bind( | |
| 200 &extensions::file_util::DeleteFile, extension_base_path_, true)); | |
| 201 } | |
| 202 | |
| 203 // In case we're shutting down without ever triggering the active | |
| 204 // notification and/or logging in. | |
| 205 wm::UserActivityDetector* user_activity_detector = | |
| 206 wm::UserActivityDetector::Get(); | |
| 207 if (user_activity_detector && user_activity_detector->HasObserver(this)) | |
| 208 user_activity_detector->RemoveObserver(this); | |
| 209 } | |
| 210 | |
| 211 void KioskModeScreensaver::GetScreensaverCrxPath() { | |
| 212 chromeos::KioskModeSettings::Get()->GetScreensaverPath( | |
| 213 base::Bind(&KioskModeScreensaver::ScreensaverPathCallback, | |
| 214 weak_ptr_factory_.GetWeakPtr())); | |
| 215 } | |
| 216 | |
| 217 void KioskModeScreensaver::ScreensaverPathCallback( | |
| 218 const base::FilePath& screensaver_crx) { | |
| 219 if (screensaver_crx.empty()) | |
| 220 return; | |
| 221 | |
| 222 ExtensionService* extension_service = GetDefaultExtensionService(); | |
| 223 if (!extension_service) | |
| 224 return; | |
| 225 base::FilePath extensions_dir = extension_service->install_directory(); | |
| 226 scoped_refptr<SandboxedUnpacker> screensaver_unpacker( | |
| 227 new SandboxedUnpacker( | |
| 228 screensaver_crx, | |
| 229 extensions::Manifest::COMPONENT, | |
| 230 Extension::NO_FLAGS, | |
| 231 extensions_dir, | |
| 232 content::BrowserThread::GetMessageLoopProxyForThread( | |
| 233 content::BrowserThread::FILE).get(), | |
| 234 new ScreensaverUnpackerClient( | |
| 235 screensaver_crx, | |
| 236 base::Bind( | |
| 237 &KioskModeScreensaver::SetupScreensaver, | |
| 238 weak_ptr_factory_.GetWeakPtr())))); | |
| 239 | |
| 240 // Fire off the unpacker on the file thread; don't need it to return. | |
| 241 content::BrowserThread::PostTask( | |
| 242 content::BrowserThread::FILE, | |
| 243 FROM_HERE, | |
| 244 base::Bind( | |
| 245 &SandboxedUnpacker::Start, screensaver_unpacker.get())); | |
| 246 } | |
| 247 | |
| 248 void KioskModeScreensaver::SetupScreensaver( | |
| 249 scoped_refptr<Extension> extension, | |
| 250 const base::FilePath& extension_base_path) { | |
| 251 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 252 extension_base_path_ = extension_base_path; | |
| 253 | |
| 254 // If the user is already logged in, don't need to display the screensaver. | |
| 255 if (chromeos::LoginState::Get()->IsUserLoggedIn()) | |
| 256 return; | |
| 257 | |
| 258 wm::UserActivityDetector::Get()->AddObserver(this); | |
| 259 | |
| 260 ExtensionService* extension_service = GetDefaultExtensionService(); | |
| 261 // Add the extension to the extension service and display the screensaver. | |
| 262 if (extension_service) { | |
| 263 extension_service->AddExtension(extension.get()); | |
| 264 ash::ShowScreensaver( | |
| 265 extensions::AppLaunchInfo::GetFullLaunchURL(extension.get())); | |
| 266 } else { | |
| 267 LOG(ERROR) << "Couldn't get extension system. Unable to load screensaver!"; | |
| 268 ShutdownKioskModeScreensaver(); | |
| 269 } | |
| 270 } | |
| 271 | |
| 272 void KioskModeScreensaver::OnUserActivity(const ui::Event* event) { | |
| 273 // We don't want to handle further user notifications; we'll either login | |
| 274 // the user and close out or or at least close the screensaver. | |
| 275 wm::UserActivityDetector::Get()->RemoveObserver(this); | |
| 276 | |
| 277 // Find the retail mode login page. | |
| 278 if (LoginDisplayHostImpl::default_host()) { | |
| 279 LoginDisplayHostImpl* webui_host = | |
| 280 static_cast<LoginDisplayHostImpl*>( | |
| 281 LoginDisplayHostImpl::default_host()); | |
| 282 OobeUI* oobe_ui = webui_host->GetOobeUI(); | |
| 283 | |
| 284 // Show the login spinner. | |
| 285 if (oobe_ui) | |
| 286 oobe_ui->ShowRetailModeLoginSpinner(); | |
| 287 | |
| 288 // Close the screensaver, our login spinner is already showing. | |
| 289 ash::CloseScreensaver(); | |
| 290 | |
| 291 // Log us in. | |
| 292 ExistingUserController* controller = | |
| 293 ExistingUserController::current_controller(); | |
| 294 if (controller && !chromeos::LoginState::Get()->IsUserLoggedIn()) { | |
| 295 controller->Login(UserContext(user_manager::USER_TYPE_RETAIL_MODE, | |
| 296 chromeos::login::kRetailModeUserName), | |
| 297 SigninSpecifics()); | |
| 298 } | |
| 299 } else { | |
| 300 // No default host for the WebUiLoginDisplay means that we're already in the | |
| 301 // process of logging in - shut down screensaver and do nothing else. | |
| 302 ash::CloseScreensaver(); | |
| 303 } | |
| 304 | |
| 305 ShutdownKioskModeScreensaver(); | |
| 306 } | |
| 307 | |
| 308 static KioskModeScreensaver* g_kiosk_mode_screensaver = NULL; | |
| 309 | |
| 310 void InitializeKioskModeScreensaver() { | |
| 311 if (g_kiosk_mode_screensaver) { | |
| 312 LOG(WARNING) << "Screensaver was already initialized"; | |
| 313 return; | |
| 314 } | |
| 315 | |
| 316 g_kiosk_mode_screensaver = new KioskModeScreensaver(); | |
| 317 } | |
| 318 | |
| 319 void ShutdownKioskModeScreensaver() { | |
| 320 delete g_kiosk_mode_screensaver; | |
| 321 g_kiosk_mode_screensaver = NULL; | |
| 322 } | |
| 323 | |
| 324 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 608283003:
Remove retail mode. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master