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/ui/ash/launcher/app_shortcut_launcher_item_controller.h" 6 7 #include "ash/shelf/shelf_model.h" 8 #include "ash/shell.h" 9 #include "ash/wm/window_util.h" 10 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item.h" 11 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item_tab.h" 12 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h" 13 #include "chrome/browser/ui/ash/launcher/launcher_application_menu_item_model.h" 14 #include "chrome/browser/ui/ash/launcher/launcher_context_menu.h" 15 #include "chrome/browser/ui/ash/launcher/launcher_item_controller.h" 16 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h" 17 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h" 18 #include "chrome/browser/ui/browser.h" 19 #include "chrome/browser/ui/browser_finder.h" 20 #include "chrome/browser/ui/browser_list.h" 21 #include "chrome/browser/ui/browser_window.h" 22 #include "chrome/browser/ui/host_desktop.h" 23 #include "chrome/browser/ui/tabs/tab_strip_model.h" 24 #include "chrome/browser/web_applications/web_app.h" 25 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h" 26 #include "content/public/browser/navigation_entry.h" 27 #include "content/public/browser/web_contents.h" 28 #include "extensions/browser/app_window/native_app_window.h" 29 #include "extensions/browser/extension_registry.h" 30 #include "extensions/browser/process_manager.h" 31 #include "ui/aura/window.h" 32 #include "ui/events/event.h" 33 #include "ui/wm/core/window_animations.h" 34 35 using extensions::Extension; 36 using extensions::ExtensionRegistry; 37 38 namespace { 39 40 // The time delta between clicks in which clicks to launch V2 apps are ignored. 41 const int kClickSuppressionInMS = 1000; 42 43 // Check if a browser can be used for activation. This addresses a special use 44 // case in the M31 multi profile mode where a user activates a V1 app which only 45 // exists yet on another users desktop, but he expects to get only his own app 46 // items and not the ones from other users through activation. 47 // TODO(skuhne): Remove this function and replace the call with 48 // launcher_controller()->IsBrowserFromActiveUser(browser) once this experiment 49 // goes away. 50 bool CanBrowserBeUsedForDirectActivation(Browser* browser, 51 ChromeLauncherController* launcher) { 52 if (chrome::MultiUserWindowManager::GetMultiProfileMode() == 53 chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_OFF) 54 return true; 55 return multi_user_util::IsProfileFromActiveUser(browser->profile()); 56 } 57 58 } // namespace 59 60 // Item controller for an app shortcut. Shortcuts track app and launcher ids, 61 // but do not have any associated windows (opening a shortcut will replace the 62 // item with the appropriate LauncherItemController type). 63 AppShortcutLauncherItemController::AppShortcutLauncherItemController( 64 const std::string& app_id, 65 ChromeLauncherController* controller) 66 : LauncherItemController(TYPE_SHORTCUT, app_id, controller), 67 chrome_launcher_controller_(controller) { 68 // To detect V1 applications we use their domain and match them against the 69 // used URL. This will also work with applications like Google Drive. 70 const Extension* extension = 71 launcher_controller()->GetExtensionForAppID(app_id); 72 // Some unit tests have no real extension. 73 if (extension) { 74 set_refocus_url(GURL( 75 extensions::AppLaunchInfo::GetLaunchWebURL(extension).spec() + "*")); 76 } 77 } 78 79 AppShortcutLauncherItemController::~AppShortcutLauncherItemController() { 80 } 81 82 bool AppShortcutLauncherItemController::IsOpen() const { 83 return !chrome_launcher_controller_-> 84 GetV1ApplicationsFromAppId(app_id()).empty(); 85 } 86 87 bool AppShortcutLauncherItemController::IsVisible() const { 88 // Return true if any browser window associated with the app is visible. 89 std::vector<content::WebContents*> content = 90 chrome_launcher_controller_->GetV1ApplicationsFromAppId(app_id()); 91 for (size_t i = 0; i < content.size(); i++) { 92 Browser* browser = chrome::FindBrowserWithWebContents(content[i]); 93 if (browser && browser->window()->GetNativeWindow()->IsVisible()) 94 return true; 95 } 96 return false; 97 } 98 99 void AppShortcutLauncherItemController::Launch(ash::LaunchSource source, 100 int event_flags) { 101 launcher_controller()->LaunchApp(app_id(), source, event_flags); 102 } 103 104 bool AppShortcutLauncherItemController::Activate(ash::LaunchSource source) { 105 content::WebContents* content = GetLRUApplication(); 106 if (!content) { 107 if (IsV2App()) { 108 // Ideally we come here only once. After that ShellLauncherItemController 109 // will take over when the shell window gets opened. However there are 110 // apps which take a lot of time for pre-processing (like the files app) 111 // before they open a window. Since there is currently no other way to 112 // detect if an app was started we suppress any further clicks within a 113 // special time out. 114 if (!AllowNextLaunchAttempt()) 115 return false; 116 } 117 Launch(source, ui::EF_NONE); 118 return true; 119 } 120 ActivateContent(content); 121 return false; 122 } 123 124 void AppShortcutLauncherItemController::Close() { 125 // Close all running 'programs' of this type. 126 std::vector<content::WebContents*> content = 127 launcher_controller()->GetV1ApplicationsFromAppId(app_id()); 128 for (size_t i = 0; i < content.size(); i++) { 129 Browser* browser = chrome::FindBrowserWithWebContents(content[i]); 130 if (!browser || !launcher_controller()->IsBrowserFromActiveUser(browser)) 131 continue; 132 TabStripModel* tab_strip = browser->tab_strip_model(); 133 int index = tab_strip->GetIndexOfWebContents(content[i]); 134 DCHECK(index != TabStripModel::kNoTab); 135 tab_strip->CloseWebContentsAt(index, TabStripModel::CLOSE_NONE); 136 } 137 } 138 139 ChromeLauncherAppMenuItems 140 AppShortcutLauncherItemController::GetApplicationList(int event_flags) { 141 ChromeLauncherAppMenuItems items; 142 // Add the application name to the menu. 143 items.push_back(new ChromeLauncherAppMenuItem(GetTitle(), NULL, false)); 144 145 std::vector<content::WebContents*> content_list = GetRunningApplications(); 146 147 for (size_t i = 0; i < content_list.size(); i++) { 148 content::WebContents* web_contents = content_list[i]; 149 // Get the icon. 150 gfx::Image app_icon = launcher_controller()->GetAppListIcon(web_contents); 151 base::string16 title = launcher_controller()->GetAppListTitle(web_contents); 152 items.push_back(new ChromeLauncherAppMenuItemTab( 153 title, &app_icon, web_contents, i == 0)); 154 } 155 return items.Pass(); 156 } 157 158 std::vector<content::WebContents*> 159 AppShortcutLauncherItemController::GetRunningApplications() { 160 std::vector<content::WebContents*> items; 161 162 URLPattern refocus_pattern(URLPattern::SCHEME_ALL); 163 refocus_pattern.SetMatchAllURLs(true); 164 165 if (!refocus_url_.is_empty()) { 166 refocus_pattern.SetMatchAllURLs(false); 167 refocus_pattern.Parse(refocus_url_.spec()); 168 } 169 170 const Extension* extension = 171 launcher_controller()->GetExtensionForAppID(app_id()); 172 173 // It is possible to come here While an extension gets loaded. 174 if (!extension) 175 return items; 176 177 const BrowserList* ash_browser_list = 178 BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH); 179 for (BrowserList::const_iterator it = ash_browser_list->begin(); 180 it != ash_browser_list->end(); ++it) { 181 Browser* browser = *it; 182 if (!launcher_controller()->IsBrowserFromActiveUser(browser)) 183 continue; 184 TabStripModel* tab_strip = browser->tab_strip_model(); 185 for (int index = 0; index < tab_strip->count(); index++) { 186 content::WebContents* web_contents = tab_strip->GetWebContentsAt(index); 187 if (WebContentMatchesApp( 188 extension, refocus_pattern, web_contents, browser)) 189 items.push_back(web_contents); 190 } 191 } 192 return items; 193 } 194 195 bool AppShortcutLauncherItemController::ItemSelected(const ui::Event& event) { 196 // In case of a keyboard event, we were called by a hotkey. In that case we 197 // activate the next item in line if an item of our list is already active. 198 if (event.type() == ui::ET_KEY_RELEASED) { 199 if (AdvanceToNextApp()) 200 return false; 201 } 202 return Activate(ash::LAUNCH_FROM_UNKNOWN); 203 } 204 205 base::string16 AppShortcutLauncherItemController::GetTitle() { 206 return GetAppTitle(); 207 } 208 209 ui::MenuModel* AppShortcutLauncherItemController::CreateContextMenu( 210 aura::Window* root_window) { 211 ash::ShelfItem item = 212 *(launcher_controller()->model()->ItemByID(shelf_id())); 213 return new LauncherContextMenu(launcher_controller(), &item, root_window); 214 } 215 216 ash::ShelfMenuModel* AppShortcutLauncherItemController::CreateApplicationMenu( 217 int event_flags) { 218 return new LauncherApplicationMenuItemModel(GetApplicationList(event_flags)); 219 } 220 221 bool AppShortcutLauncherItemController::IsDraggable() { 222 return true; 223 } 224 225 bool AppShortcutLauncherItemController::ShouldShowTooltip() { 226 return true; 227 } 228 229 content::WebContents* AppShortcutLauncherItemController::GetLRUApplication() { 230 URLPattern refocus_pattern(URLPattern::SCHEME_ALL); 231 refocus_pattern.SetMatchAllURLs(true); 232 233 if (!refocus_url_.is_empty()) { 234 refocus_pattern.SetMatchAllURLs(false); 235 refocus_pattern.Parse(refocus_url_.spec()); 236 } 237 238 const Extension* extension = 239 launcher_controller()->GetExtensionForAppID(app_id()); 240 241 // We may get here while the extension is loading (and NULL). 242 if (!extension) 243 return NULL; 244 245 const BrowserList* ash_browser_list = 246 BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH); 247 for (BrowserList::const_reverse_iterator 248 it = ash_browser_list->begin_last_active(); 249 it != ash_browser_list->end_last_active(); ++it) { 250 Browser* browser = *it; 251 if (!CanBrowserBeUsedForDirectActivation(browser, launcher_controller())) 252 continue; 253 TabStripModel* tab_strip = browser->tab_strip_model(); 254 // We start to enumerate from the active index. 255 int active_index = tab_strip->active_index(); 256 for (int index = 0; index < tab_strip->count(); index++) { 257 content::WebContents* web_contents = tab_strip->GetWebContentsAt( 258 (index + active_index) % tab_strip->count()); 259 if (WebContentMatchesApp( 260 extension, refocus_pattern, web_contents, browser)) 261 return web_contents; 262 } 263 } 264 // Coming here our application was not in the LRU list. This could have 265 // happened because it did never get activated yet. So check the browser list 266 // as well. 267 for (BrowserList::const_iterator it = ash_browser_list->begin(); 268 it != ash_browser_list->end(); ++it) { 269 Browser* browser = *it; 270 if (!CanBrowserBeUsedForDirectActivation(browser, launcher_controller())) 271 continue; 272 TabStripModel* tab_strip = browser->tab_strip_model(); 273 for (int index = 0; index < tab_strip->count(); index++) { 274 content::WebContents* web_contents = tab_strip->GetWebContentsAt(index); 275 if (WebContentMatchesApp( 276 extension, refocus_pattern, web_contents, browser)) 277 return web_contents; 278 } 279 } 280 return NULL; 281 } 282 283 bool AppShortcutLauncherItemController::WebContentMatchesApp( 284 const extensions::Extension* extension, 285 const URLPattern& refocus_pattern, 286 content::WebContents* web_contents, 287 Browser* browser) { 288 // If the browser is an app window and the app name matches the extension. 289 if (browser->is_app()) { 290 const extensions::Extension* browser_extension = 291 ExtensionRegistry::Get(browser->profile())->GetExtensionById( 292 web_app::GetExtensionIdFromApplicationName(browser->app_name()), 293 ExtensionRegistry::EVERYTHING); 294 return browser_extension == extension; 295 } 296 297 // There are three ways to identify the association of a URL with this 298 // extension: 299 // - The refocus pattern is matched (needed for apps like drive). 300 // - The extension's origin + extent gets matched. 301 // - The launcher controller knows that the tab got created for this app. 302 const GURL tab_url = web_contents->GetURL(); 303 return ((!refocus_pattern.match_all_urls() && 304 refocus_pattern.MatchesURL(tab_url)) || 305 (extension->OverlapsWithOrigin(tab_url) && 306 extension->web_extent().MatchesURL(tab_url)) || 307 launcher_controller()->IsWebContentHandledByApplication(web_contents, 308 app_id())); 309 } 310 311 void AppShortcutLauncherItemController::ActivateContent( 312 content::WebContents* content) { 313 Browser* browser = chrome::FindBrowserWithWebContents(content); 314 TabStripModel* tab_strip = browser->tab_strip_model(); 315 int index = tab_strip->GetIndexOfWebContents(content); 316 DCHECK_NE(TabStripModel::kNoTab, index); 317 318 int old_index = tab_strip->active_index(); 319 if (index != old_index) 320 tab_strip->ActivateTabAt(index, false); 321 launcher_controller()->ActivateWindowOrMinimizeIfActive( 322 browser->window(), 323 index == old_index && GetRunningApplications().size() == 1); 324 } 325 326 bool AppShortcutLauncherItemController::AdvanceToNextApp() { 327 std::vector<content::WebContents*> items = GetRunningApplications(); 328 if (items.size() >= 1) { 329 Browser* browser = chrome::FindBrowserWithWindow( 330 ash::wm::GetActiveWindow()); 331 if (browser) { 332 TabStripModel* tab_strip = browser->tab_strip_model(); 333 content::WebContents* active = tab_strip->GetWebContentsAt( 334 tab_strip->active_index()); 335 std::vector<content::WebContents*>::const_iterator i( 336 std::find(items.begin(), items.end(), active)); 337 if (i != items.end()) { 338 if (items.size() == 1) { 339 // If there is only a single item available, we animate it upon key 340 // action. 341 AnimateWindow(browser->window()->GetNativeWindow(), 342 wm::WINDOW_ANIMATION_TYPE_BOUNCE); 343 } else { 344 int index = (static_cast<int>(i - items.begin()) + 1) % items.size(); 345 ActivateContent(items[index]); 346 } 347 return true; 348 } 349 } 350 } 351 return false; 352 } 353 354 bool AppShortcutLauncherItemController::IsV2App() { 355 const Extension* extension = 356 launcher_controller()->GetExtensionForAppID(app_id()); 357 return extension && extension->is_platform_app(); 358 } 359 360 bool AppShortcutLauncherItemController::AllowNextLaunchAttempt() { 361 if (last_launch_attempt_.is_null() || 362 last_launch_attempt_ + base::TimeDelta::FromMilliseconds( 363 kClickSuppressionInMS) < base::Time::Now()) { 364 last_launch_attempt_ = base::Time::Now(); 365 return true; 366 } 367 return false; 368 } 369
