1 // Copyright 2013 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_load_service.h" 6 7 #include "apps/app_load_service_factory.h" 8 #include "apps/app_restore_service.h" 9 #include "apps/launcher.h" 10 #include "chrome/browser/extensions/extension_service.h" 11 #include "chrome/browser/extensions/unpacked_installer.h" 12 #include "chrome/browser/profiles/profile.h" 13 #include "content/public/browser/notification_details.h" 14 #include "content/public/browser/notification_service.h" 15 #include "content/public/browser/notification_types.h" 16 #include "extensions/browser/app_window/app_window_registry.h" 17 #include "extensions/browser/extension_host.h" 18 #include "extensions/browser/extension_prefs.h" 19 #include "extensions/browser/extension_registry.h" 20 #include "extensions/browser/extension_system.h" 21 #include "extensions/browser/notification_types.h" 22 #include "extensions/common/extension.h" 23 24 using extensions::Extension; 25 using extensions::ExtensionPrefs; 26 using extensions::ExtensionSystem; 27 28 namespace apps { 29 30 AppLoadService::PostReloadAction::PostReloadAction() 31 : action_type(LAUNCH), 32 command_line(CommandLine::NO_PROGRAM) { 33 } 34 35 AppLoadService::AppLoadService(Profile* profile) 36 : profile_(profile) { 37 registrar_.Add(this, 38 extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING, 39 content::NotificationService::AllSources()); 40 extensions::ExtensionRegistry::Get(profile_)->AddObserver(this); 41 } 42 43 AppLoadService::~AppLoadService() { 44 extensions::ExtensionRegistry::Get(profile_)->RemoveObserver(this); 45 } 46 47 void AppLoadService::RestartApplication(const std::string& extension_id) { 48 post_reload_actions_[extension_id].action_type = RESTART; 49 ExtensionService* service = extensions::ExtensionSystem::Get(profile_)-> 50 extension_service(); 51 DCHECK(service); 52 service->ReloadExtension(extension_id); 53 } 54 55 void AppLoadService::RestartApplicationIfRunning( 56 const std::string& extension_id) { 57 if (apps::AppRestoreService::Get(profile_)->IsAppRestorable(extension_id)) 58 RestartApplication(extension_id); 59 } 60 61 bool AppLoadService::LoadAndLaunch(const base::FilePath& extension_path, 62 const CommandLine& command_line, 63 const base::FilePath& current_dir) { 64 ExtensionService* extension_service = 65 ExtensionSystem::Get(profile_)->extension_service(); 66 std::string extension_id; 67 if (!extensions::UnpackedInstaller::Create(extension_service)-> 68 LoadFromCommandLine(base::FilePath(extension_path), &extension_id)) { 69 return false; 70 } 71 72 // Schedule the app to be launched once loaded. 73 PostReloadAction& action = post_reload_actions_[extension_id]; 74 action.action_type = LAUNCH_WITH_COMMAND_LINE; 75 action.command_line = command_line; 76 action.current_dir = current_dir; 77 return true; 78 } 79 80 // static 81 AppLoadService* AppLoadService::Get(Profile* profile) { 82 return apps::AppLoadServiceFactory::GetForProfile(profile); 83 } 84 85 void AppLoadService::Observe(int type, 86 const content::NotificationSource& source, 87 const content::NotificationDetails& details) { 88 DCHECK_EQ(type, extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING); 89 extensions::ExtensionHost* host = 90 content::Details<extensions::ExtensionHost>(details).ptr(); 91 const Extension* extension = host->extension(); 92 // It is possible for an extension to be unloaded before it stops loading. 93 if (!extension) 94 return; 95 std::map<std::string, PostReloadAction>::iterator it = 96 post_reload_actions_.find(extension->id()); 97 if (it == post_reload_actions_.end()) 98 return; 99 100 switch (it->second.action_type) { 101 case LAUNCH: 102 LaunchPlatformApp(profile_, extension); 103 break; 104 case RESTART: 105 RestartPlatformApp(profile_, extension); 106 break; 107 case LAUNCH_WITH_COMMAND_LINE: 108 LaunchPlatformAppWithCommandLine( 109 profile_, extension, it->second.command_line, it->second.current_dir); 110 break; 111 default: 112 NOTREACHED(); 113 } 114 115 post_reload_actions_.erase(it); 116 } 117 118 void AppLoadService::OnExtensionUnloaded( 119 content::BrowserContext* browser_context, 120 const Extension* extension, 121 extensions::UnloadedExtensionInfo::Reason reason) { 122 if (!extension->is_platform_app()) 123 return; 124 125 extensions::ExtensionPrefs* extension_prefs = 126 extensions::ExtensionPrefs::Get(browser_context); 127 if (WasUnloadedForReload(extension->id(), reason) && 128 extension_prefs->IsActive(extension->id()) && 129 !HasPostReloadAction(extension->id())) { 130 post_reload_actions_[extension->id()].action_type = LAUNCH; 131 } 132 } 133 134 bool AppLoadService::WasUnloadedForReload( 135 const extensions::ExtensionId& extension_id, 136 const extensions::UnloadedExtensionInfo::Reason reason) { 137 if (reason == extensions::UnloadedExtensionInfo::REASON_DISABLE) { 138 ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_); 139 return (prefs->GetDisableReasons(extension_id) & 140 Extension::DISABLE_RELOAD) != 0; 141 } 142 return false; 143 } 144 145 bool AppLoadService::HasPostReloadAction(const std::string& extension_id) { 146 return post_reload_actions_.find(extension_id) != post_reload_actions_.end(); 147 } 148 149 } // namespace apps 150