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 "apps/app_restore_service.h" 6 7#include "apps/app_lifetime_monitor_factory.h" 8#include "apps/app_restore_service_factory.h" 9#include "apps/launcher.h" 10#include "apps/saved_files_service.h" 11#include "apps/shell_window.h" 12#include "chrome/browser/chrome_notification_types.h" 13#include "chrome/browser/extensions/api/app_runtime/app_runtime_api.h" 14#include "chrome/browser/extensions/extension_host.h" 15#include "chrome/browser/extensions/extension_prefs.h" 16#include "chrome/browser/extensions/extension_service.h" 17#include "chrome/browser/extensions/extension_system.h" 18#include "chrome/browser/profiles/profile.h" 19#include "chrome/common/extensions/extension_set.h" 20#include "extensions/common/extension.h" 21 22#if defined(OS_WIN) 23#include "win8/util/win8_util.h" 24#endif 25 26using extensions::Extension; 27using extensions::ExtensionHost; 28using extensions::ExtensionPrefs; 29using extensions::ExtensionSystem; 30 31namespace apps { 32 33// static 34bool AppRestoreService::ShouldRestoreApps(bool is_browser_restart) { 35 bool should_restore_apps = is_browser_restart; 36#if defined(OS_CHROMEOS) 37 // Chromeos always restarts apps, even if it was a regular shutdown. 38 should_restore_apps = true; 39#elif defined(OS_WIN) 40 // Packaged apps are not supported in Metro mode, so don't try to start them. 41 if (win8::IsSingleWindowMetroMode()) 42 should_restore_apps = false; 43#endif 44 return should_restore_apps; 45} 46 47AppRestoreService::AppRestoreService(Profile* profile) 48 : profile_(profile) { 49 StartObservingAppLifetime(); 50} 51 52void AppRestoreService::HandleStartup(bool should_restore_apps) { 53 ExtensionService* extension_service = 54 ExtensionSystem::Get(profile_)->extension_service(); 55 const ExtensionSet* extensions = extension_service->extensions(); 56 ExtensionPrefs* extension_prefs = extension_service->extension_prefs(); 57 58 for (ExtensionSet::const_iterator it = extensions->begin(); 59 it != extensions->end(); ++it) { 60 const Extension* extension = it->get(); 61 if (extension_prefs->IsExtensionRunning(extension->id())) { 62 RecordAppStop(extension->id()); 63 // If we are not restoring apps (e.g., because it is a clean restart), and 64 // the app does not have retain permission, explicitly clear the retained 65 // entries queue. 66 if (should_restore_apps) { 67 RestoreApp(it->get()); 68 } else { 69 SavedFilesService::Get(profile_)->ClearQueueIfNoRetainPermission( 70 extension); 71 } 72 } 73 } 74} 75 76bool AppRestoreService::IsAppRestorable(const std::string& extension_id) { 77 return extensions::ExtensionPrefs::Get(profile_) ->IsExtensionRunning( 78 extension_id); 79} 80 81// static 82AppRestoreService* AppRestoreService::Get(Profile* profile) { 83 return apps::AppRestoreServiceFactory::GetForProfile(profile); 84} 85 86void AppRestoreService::OnAppStart(Profile* profile, 87 const std::string& app_id) { 88 RecordAppStart(app_id); 89} 90 91void AppRestoreService::OnAppActivated(Profile* profile, 92 const std::string& app_id) { 93 RecordAppActiveState(app_id, true); 94} 95 96void AppRestoreService::OnAppDeactivated(Profile* profile, 97 const std::string& app_id) { 98 RecordAppActiveState(app_id, false); 99} 100 101void AppRestoreService::OnAppStop(Profile* profile, const std::string& app_id) { 102 RecordAppStop(app_id); 103} 104 105void AppRestoreService::OnChromeTerminating() { 106 // We want to preserve the state when the app begins terminating, so stop 107 // listening to app lifetime events. 108 StopObservingAppLifetime(); 109} 110 111void AppRestoreService::Shutdown() { 112 StopObservingAppLifetime(); 113} 114 115void AppRestoreService::RecordAppStart(const std::string& extension_id) { 116 ExtensionPrefs* extension_prefs = 117 ExtensionSystem::Get(profile_)->extension_service()->extension_prefs(); 118 extension_prefs->SetExtensionRunning(extension_id, true); 119} 120 121void AppRestoreService::RecordAppStop(const std::string& extension_id) { 122 ExtensionPrefs* extension_prefs = 123 ExtensionSystem::Get(profile_)->extension_service()->extension_prefs(); 124 extension_prefs->SetExtensionRunning(extension_id, false); 125} 126 127void AppRestoreService::RecordAppActiveState(const std::string& id, 128 bool is_active) { 129 ExtensionService* extension_service = 130 ExtensionSystem::Get(profile_)->extension_service(); 131 ExtensionPrefs* extension_prefs = extension_service->extension_prefs(); 132 133 // If the extension isn't running then we will already have recorded whether 134 // it is active or not. 135 if (!extension_prefs->IsExtensionRunning(id)) 136 return; 137 138 extension_prefs->SetIsActive(id, is_active); 139} 140 141void AppRestoreService::RestoreApp(const Extension* extension) { 142 RestartPlatformApp(profile_, extension); 143} 144 145void AppRestoreService::StartObservingAppLifetime() { 146 AppLifetimeMonitor* app_lifetime_monitor = 147 AppLifetimeMonitorFactory::GetForProfile(profile_); 148 DCHECK(app_lifetime_monitor); 149 app_lifetime_monitor->AddObserver(this); 150} 151 152void AppRestoreService::StopObservingAppLifetime() { 153 AppLifetimeMonitor* app_lifetime_monitor = 154 AppLifetimeMonitorFactory::GetForProfile(profile_); 155 // This might be NULL in tests. 156 if (app_lifetime_monitor) 157 app_lifetime_monitor->RemoveObserver(this); 158} 159 160} // namespace apps 161