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 #ifndef CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_H_ | |
6 #define CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_H_ | |
7 | |
8 #include <string> | |
9 | |
10 #include "ash/launcher/launcher_delegate.h" | |
11 #include "ash/launcher/launcher_types.h" | |
12 #include "ash/shelf/shelf_types.h" | |
13 #include "base/memory/scoped_vector.h" | |
14 #include "chrome/browser/extensions/app_icon_loader.h" | |
15 #include "chrome/browser/extensions/extension_prefs.h" | |
16 | |
17 class LauncherItemControllerPerAppTest; | |
18 class LauncherItemController; | |
19 class Profile; | |
20 class ChromeLauncherAppMenuItem; | |
21 class ChromeLauncherControllerPerApp; | |
22 | |
23 namespace ash { | |
24 class LauncherModel; | |
25 } | |
26 | |
27 namespace aura { | |
28 class Window; | |
29 class RootWindow; | |
30 } | |
31 | |
32 namespace content { | |
33 class WebContents; | |
34 } | |
35 | |
36 namespace ui { | |
37 class BaseWindow; | |
38 } | |
39 | |
40 // A list of the elements which makes up a simple menu description. | |
41 typedef ScopedVector<ChromeLauncherAppMenuItem> ChromeLauncherAppMenuItems; | |
42 | |
43 // ChromeLauncherController manages the launcher items needed for content | |
44 // windows. Launcher items have a type, an optional app id, and a controller. | |
45 // ChromeLauncherController will furthermore create the particular | |
46 // implementation of interest - either sorting by application (new) or sorting | |
47 // by browser (old). | |
48 // * Tabbed browsers and browser app windows have BrowserLauncherItemController, | |
49 // owned by the BrowserView instance. | |
50 // * App shell windows have ShellWindowLauncherItemController, owned by | |
51 // ShellWindowLauncherController. | |
52 // * Shortcuts have no LauncherItemController. | |
53 class ChromeLauncherController | |
54 : public ash::LauncherDelegate, | |
55 public extensions::AppIconLoader::Delegate { | |
56 public: | |
57 // Indicates if a launcher item is incognito or not. | |
58 enum IncognitoState { | |
59 STATE_INCOGNITO, | |
60 STATE_NOT_INCOGNITO, | |
61 }; | |
62 | |
63 // Used to update the state of non plaform apps, as web contents change. | |
64 enum AppState { | |
65 APP_STATE_ACTIVE, | |
66 APP_STATE_WINDOW_ACTIVE, | |
67 APP_STATE_INACTIVE, | |
68 APP_STATE_REMOVED | |
69 }; | |
70 | |
71 // Mockable interface to get app ids from tabs. | |
72 class AppTabHelper { | |
73 public: | |
74 virtual ~AppTabHelper() {} | |
75 | |
76 // Returns the app id of the specified tab, or an empty string if there is | |
77 // no app. | |
78 virtual std::string GetAppID(content::WebContents* tab) = 0; | |
79 | |
80 // Returns true if |id| is valid. Used during restore to ignore no longer | |
81 // valid extensions. | |
82 virtual bool IsValidID(const std::string& id) = 0; | |
83 }; | |
84 | |
85 ChromeLauncherController() {} | |
86 virtual ~ChromeLauncherController(); | |
87 | |
88 // Initializes this ChromeLauncherController. | |
89 virtual void Init() = 0; | |
90 | |
91 // Returns the new per application interface of the given launcher. If it is | |
92 // a per browser (old) controller, it will return NULL; | |
93 // TODO(skuhne): Remove when we rip out the old launcher. | |
94 virtual ChromeLauncherControllerPerApp* GetPerAppInterface() = 0; | |
95 | |
96 // Creates an instance. | |
97 static ChromeLauncherController* CreateInstance(Profile* profile, | |
98 ash::LauncherModel* model); | |
99 | |
100 // Returns the single ChromeLauncherController instance. | |
101 static ChromeLauncherController* instance() { return instance_; } | |
102 | |
103 // Creates a new tabbed item on the launcher for |controller|. | |
104 virtual ash::LauncherID CreateTabbedLauncherItem( | |
105 LauncherItemController* controller, | |
106 IncognitoState is_incognito, | |
107 ash::LauncherItemStatus status) = 0; | |
108 | |
109 // Creates a new app item on the launcher for |controller|. | |
110 virtual ash::LauncherID CreateAppLauncherItem( | |
111 LauncherItemController* controller, | |
112 const std::string& app_id, | |
113 ash::LauncherItemStatus status) = 0; | |
114 | |
115 // Updates the running status of an item. | |
116 virtual void SetItemStatus(ash::LauncherID id, | |
117 ash::LauncherItemStatus status) = 0; | |
118 | |
119 // Updates the controller associated with id (which should be a shortcut). | |
120 // |controller| remains owned by caller. | |
121 virtual void SetItemController(ash::LauncherID id, | |
122 LauncherItemController* controller) = 0; | |
123 | |
124 // Closes or unpins the launcher item. | |
125 virtual void CloseLauncherItem(ash::LauncherID id) = 0; | |
126 | |
127 // Pins the specified id. Currently only supports platform apps. | |
128 virtual void Pin(ash::LauncherID id) = 0; | |
129 | |
130 // Unpins the specified id, closing if not running. | |
131 virtual void Unpin(ash::LauncherID id) = 0; | |
132 | |
133 // Returns true if the item identified by |id| is pinned. | |
134 virtual bool IsPinned(ash::LauncherID id) = 0; | |
135 | |
136 // Pins/unpins the specified id. | |
137 virtual void TogglePinned(ash::LauncherID id) = 0; | |
138 | |
139 // Returns true if the specified item can be pinned or unpinned. Only apps can | |
140 // be pinned. | |
141 virtual bool IsPinnable(ash::LauncherID id) const = 0; | |
142 | |
143 // If there is no launcher item in the launcher for application |app_id|, one | |
144 // gets created. The (existing or created) launcher items get then locked | |
145 // against a users un-pinning removal. | |
146 virtual void LockV1AppWithID(const std::string& app_id) = 0; | |
147 | |
148 // A previously locked launcher item of type |app_id| gets unlocked. If the | |
149 // lock count reaches 0 and the item is not pinned it will go away. | |
150 virtual void UnlockV1AppWithID(const std::string& app_id) = 0; | |
151 | |
152 // Requests that the launcher item controller specified by |id| open a new | |
153 // instance of the app. |event_flags| holds the flags of the event which | |
154 // triggered this command. | |
155 virtual void Launch(ash::LauncherID id, int event_flags) = 0; | |
156 | |
157 // Closes the specified item. | |
158 virtual void Close(ash::LauncherID id) = 0; | |
159 | |
160 // Returns true if the specified item is open. | |
161 virtual bool IsOpen(ash::LauncherID id) = 0; | |
162 | |
163 // Returns true if the specified item is for a platform app. | |
164 virtual bool IsPlatformApp(ash::LauncherID id) = 0; | |
165 | |
166 // Opens a new instance of the application identified by |app_id|. | |
167 // Used by the app-list, and by pinned-app launcher items. | |
168 virtual void LaunchApp(const std::string& app_id, int event_flags) = 0; | |
169 | |
170 // If |app_id| is running, reactivates the app's most recently active window, | |
171 // otherwise launches and activates the app. | |
172 // Used by the app-list, and by pinned-app launcher items. | |
173 virtual void ActivateApp(const std::string& app_id, int event_flags) = 0; | |
174 | |
175 // Returns the launch type of app for the specified id. | |
176 virtual extensions::ExtensionPrefs::LaunchType GetLaunchType( | |
177 ash::LauncherID id) = 0; | |
178 | |
179 // Returns the id of the app for the specified tab. | |
180 virtual std::string GetAppID(content::WebContents* tab) = 0; | |
181 | |
182 // Returns the launcherID of the first non-panel item whose app_id | |
183 // matches |app_id| or 0 if none match. | |
184 virtual ash::LauncherID GetLauncherIDForAppID(const std::string& app_id) = 0; | |
185 | |
186 // Returns the id of the app for the specified id (which must exist). | |
187 virtual std::string GetAppIDForLauncherID(ash::LauncherID id) = 0; | |
188 | |
189 // Set the image for a specific launcher item (e.g. when set by the app). | |
190 virtual void SetLauncherItemImage(ash::LauncherID launcher_id, | |
191 const gfx::ImageSkia& image) = 0; | |
192 | |
193 // Returns true if a pinned launcher item with given |app_id| could be found. | |
194 virtual bool IsAppPinned(const std::string& app_id) = 0; | |
195 | |
196 // Pins an app with |app_id| to launcher. If there is a running instance in | |
197 // launcher, the running instance is pinned. If there is no running instance, | |
198 // a new launcher item is created and pinned. | |
199 virtual void PinAppWithID(const std::string& app_id) = 0; | |
200 | |
201 // Updates the launche type of the app for the specified id to |launch_type|. | |
202 virtual void SetLaunchType( | |
203 ash::LauncherID id, | |
204 extensions::ExtensionPrefs::LaunchType launch_type) = 0; | |
205 | |
206 // Unpins any app items whose id is |app_id|. | |
207 virtual void UnpinAppsWithID(const std::string& app_id) = 0; | |
208 | |
209 // Returns true if the user is currently logged in as a guest. | |
210 virtual bool IsLoggedInAsGuest() = 0; | |
211 | |
212 // Invoked when user clicks on button in the launcher and there is no last | |
213 // used window (or CTRL is held with the click). | |
214 virtual void CreateNewWindow() = 0; | |
215 | |
216 // Invoked when the user clicks on button in the launcher to create a new | |
217 // incognito window. | |
218 virtual void CreateNewIncognitoWindow() = 0; | |
219 | |
220 // Checks whether the user is allowed to pin apps. Pinning may be disallowed | |
221 // by policy in case there is a pre-defined set of pinned apps. | |
222 virtual bool CanPin() const = 0; | |
223 | |
224 // Updates the pinned pref state. The pinned state consists of a list pref. | |
225 // Each item of the list is a dictionary. The key |kAppIDPath| gives the | |
226 // id of the app. | |
227 virtual void PersistPinnedState() = 0; | |
228 | |
229 virtual ash::LauncherModel* model() = 0; | |
230 | |
231 virtual Profile* profile() = 0; | |
232 | |
233 // Gets the shelf auto-hide behavior on |root_window|. | |
234 virtual ash::ShelfAutoHideBehavior GetShelfAutoHideBehavior( | |
235 aura::RootWindow* root_window) const = 0; | |
236 | |
237 // Returns |true| if the user is allowed to modify the shelf auto-hide | |
238 // behavior on |root_window|. | |
239 virtual bool CanUserModifyShelfAutoHideBehavior( | |
240 aura::RootWindow* root_window) const = 0; | |
241 | |
242 // Toggles the shelf auto-hide behavior on |root_window|. Does nothing if the | |
243 // user is not allowed to modify the auto-hide behavior. | |
244 virtual void ToggleShelfAutoHideBehavior(aura::RootWindow* root_window) = 0; | |
245 | |
246 // The tab no longer represents its previously identified application. | |
247 virtual void RemoveTabFromRunningApp(content::WebContents* tab, | |
248 const std::string& app_id) = 0; | |
249 | |
250 // Notify the controller that the state of an non platform app's tabs | |
251 // have changed, | |
252 virtual void UpdateAppState(content::WebContents* contents, | |
253 AppState app_state) = 0; | |
254 | |
255 // Limits application refocusing to urls that match |url| for |id|. | |
256 virtual void SetRefocusURLPatternForTest(ash::LauncherID id, | |
257 const GURL& url) = 0; | |
258 | |
259 // Returns the extension identified by |app_id|. | |
260 virtual const extensions::Extension* GetExtensionForAppID( | |
261 const std::string& app_id) const = 0; | |
262 | |
263 // Activates a |window|. If |allow_minimize| is true and the system allows | |
264 // it, the the window will get minimized instead. | |
265 virtual void ActivateWindowOrMinimizeIfActive(ui::BaseWindow* window, | |
266 bool allow_minimize) = 0; | |
267 // ash::LauncherDelegate overrides: | |
268 virtual void ItemSelected(const ash::LauncherItem& item, | |
269 const ui::Event& event) OVERRIDE = 0; | |
270 virtual string16 GetTitle(const ash::LauncherItem& item) OVERRIDE = 0; | |
271 virtual ui::MenuModel* CreateContextMenu( | |
272 const ash::LauncherItem& item, aura::RootWindow* root) OVERRIDE = 0; | |
273 virtual ash::LauncherMenuModel* CreateApplicationMenu( | |
274 const ash::LauncherItem& item, | |
275 int event_flags) OVERRIDE = 0; | |
276 virtual ash::LauncherID GetIDByWindow(aura::Window* window) OVERRIDE = 0; | |
277 virtual bool IsDraggable(const ash::LauncherItem& item) OVERRIDE = 0; | |
278 virtual bool ShouldShowTooltip(const ash::LauncherItem& item) OVERRIDE = 0; | |
279 virtual bool IsPerAppLauncher() OVERRIDE; | |
280 | |
281 // extensions::AppIconLoader overrides: | |
282 virtual void SetAppImage(const std::string& app_id, | |
283 const gfx::ImageSkia& image) OVERRIDE = 0; | |
284 | |
285 protected: | |
286 friend class LauncherItemControllerPerAppTest; | |
287 friend class LauncherPlatformAppBrowserTest; | |
288 friend class LauncherAppBrowserTest; | |
289 // TODO(skuhne): Remove these when the old launcher get removed. | |
290 friend class LauncherPlatformPerAppAppBrowserTest; | |
291 friend class LauncherPerAppAppBrowserTest; | |
292 | |
293 // Creates a new app shortcut item and controller on the launcher at |index|. | |
294 // Use kInsertItemAtEnd to add a shortcut as the last item. | |
295 virtual ash::LauncherID CreateAppShortcutLauncherItem( | |
296 const std::string& app_id, | |
297 int index) = 0; | |
298 | |
299 // Sets the AppTabHelper/AppIconLoader, taking ownership of the helper class. | |
300 // These are intended for testing. | |
301 virtual void SetAppTabHelperForTest(AppTabHelper* helper) = 0; | |
302 virtual void SetAppIconLoaderForTest(extensions::AppIconLoader* loader) = 0; | |
303 virtual const std::string& GetAppIdFromLauncherIdForTest( | |
304 ash::LauncherID id) = 0; | |
305 | |
306 private: | |
307 static ChromeLauncherController* instance_; | |
308 }; | |
309 | |
310 #endif // CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_H_ | |
OLD | NEW |