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 #ifndef APPS_SHELL_WINDOW_H_ 6 #define APPS_SHELL_WINDOW_H_ 7 8 #include "base/memory/scoped_ptr.h" 9 #include "base/memory/weak_ptr.h" 10 #include "chrome/browser/extensions/extension_icon_image.h" 11 #include "chrome/browser/extensions/extension_keybinding_registry.h" 12 #include "chrome/browser/sessions/session_id.h" 13 #include "components/web_modal/web_contents_modal_dialog_manager_delegate.h" 14 #include "content/public/browser/notification_observer.h" 15 #include "content/public/browser/notification_registrar.h" 16 #include "content/public/browser/web_contents_delegate.h" 17 #include "content/public/browser/web_contents_observer.h" 18 #include "content/public/common/console_message_level.h" 19 #include "ui/base/ui_base_types.h" // WindowShowState 20 #include "ui/gfx/image/image.h" 21 #include "ui/gfx/rect.h" 22 23 class GURL; 24 class Profile; 25 class SkRegion; 26 27 namespace content { 28 class WebContents; 29 } 30 31 namespace extensions { 32 class Extension; 33 class PlatformAppBrowserTest; 34 class WindowController; 35 36 struct DraggableRegion; 37 } 38 39 namespace ui { 40 class BaseWindow; 41 } 42 43 namespace apps { 44 45 class NativeAppWindow; 46 47 // Manages the web contents for Shell Windows. The implementation for this 48 // class should create and maintain the WebContents for the window, and handle 49 // any message passing between the web contents and the extension system or 50 // native window. 51 class ShellWindowContents { 52 public: 53 ShellWindowContents() {} 54 virtual ~ShellWindowContents() {} 55 56 // Called to initialize the WebContents, before the app window is created. 57 virtual void Initialize(Profile* profile, const GURL& url) = 0; 58 59 // Called to load the contents, after the app window is created. 60 virtual void LoadContents(int32 creator_process_id) = 0; 61 62 // Called when the native window changes. 63 virtual void NativeWindowChanged(NativeAppWindow* native_app_window) = 0; 64 65 // Called when the native window closes. 66 virtual void NativeWindowClosed() = 0; 67 68 virtual content::WebContents* GetWebContents() const = 0; 69 70 private: 71 DISALLOW_COPY_AND_ASSIGN(ShellWindowContents); 72 }; 73 74 // ShellWindow is the type of window used by platform apps. Shell windows 75 // have a WebContents but none of the chrome of normal browser windows. 76 class ShellWindow : public content::NotificationObserver, 77 public content::WebContentsDelegate, 78 public content::WebContentsObserver, 79 public web_modal::WebContentsModalDialogManagerDelegate, 80 public extensions::ExtensionKeybindingRegistry::Delegate, 81 public extensions::IconImage::Observer { 82 public: 83 enum WindowType { 84 WINDOW_TYPE_DEFAULT = 1 << 0, // Default shell window. 85 WINDOW_TYPE_PANEL = 1 << 1, // OS controlled panel window (Ash only). 86 WINDOW_TYPE_V1_PANEL = 1 << 2, // For apps v1 support in Ash; deprecate 87 // with v1 apps. 88 }; 89 90 enum Frame { 91 FRAME_CHROME, // Chrome-style window frame. 92 FRAME_NONE, // Frameless window. 93 }; 94 95 enum FullscreenType { 96 // Not fullscreen. 97 FULLSCREEN_TYPE_NONE = 0, 98 99 // Fullscreen entered by the app.window api. 100 FULLSCREEN_TYPE_WINDOW_API = 1 << 0, 101 102 // Fullscreen entered by HTML requestFullscreen(). 103 FULLSCREEN_TYPE_HTML_API = 1 << 1, 104 105 // Fullscreen entered by the OS. ChromeOS uses this type of fullscreen to 106 // enter immersive fullscreen when the user hits the <F4> key. 107 FULLSCREEN_TYPE_OS = 1 << 2, 108 109 // Fullscreen mode that could not be exited by the user. ChromeOS uses 110 // this type of fullscreen to run an app in kiosk mode. 111 FULLSCREEN_TYPE_FORCED = 1 << 3, 112 }; 113 114 class SizeConstraints { 115 public: 116 // The value SizeConstraints uses to represent an unbounded width or height. 117 // This is an enum so that it can be declared inline here. 118 enum { kUnboundedSize = 0 }; 119 120 SizeConstraints(); 121 SizeConstraints(const gfx::Size& min_size, const gfx::Size& max_size); 122 ~SizeConstraints(); 123 124 // Returns the bounds with its size clamped to the min/max size. 125 gfx::Size ClampSize(gfx::Size size) const; 126 127 // When gfx::Size is used as a min/max size, a zero represents an unbounded 128 // component. This method checks whether either component is specified. 129 // Note we can't use gfx::Size::IsEmpty as it returns true if either width 130 // or height is zero. 131 bool HasMinimumSize() const; 132 bool HasMaximumSize() const; 133 134 // This returns true if all components are specified, and min and max are 135 // equal. 136 bool HasFixedSize() const; 137 138 gfx::Size GetMaximumSize() const; 139 gfx::Size GetMinimumSize() const; 140 141 void set_minimum_size(const gfx::Size& min_size); 142 void set_maximum_size(const gfx::Size& max_size); 143 144 private: 145 gfx::Size minimum_size_; 146 gfx::Size maximum_size_; 147 }; 148 149 struct CreateParams { 150 CreateParams(); 151 ~CreateParams(); 152 153 WindowType window_type; 154 Frame frame; 155 bool transparent_background; // Only supported on ash. 156 157 // Specify the initial content bounds of the window (excluding any window 158 // decorations). INT_MIN designates 'unspecified' for the position 159 // components, and 0 for the size components. When unspecified, they should 160 // be replaced with a default value. 161 gfx::Rect bounds; 162 163 gfx::Size minimum_size; 164 gfx::Size maximum_size; 165 166 std::string window_key; 167 168 // The process ID of the process that requested the create. 169 int32 creator_process_id; 170 171 // Initial state of the window. 172 ui::WindowShowState state; 173 174 // If true, don't show the window after creation. 175 bool hidden; 176 177 // If true, the window will be resizable by the user. Defaults to true. 178 bool resizable; 179 180 // If true, the window will be focused on creation. Defaults to true. 181 bool focused; 182 183 // If true, the window will stay on top of other windows that are not 184 // configured to be always on top. Defaults to false. 185 bool always_on_top; 186 }; 187 188 class Delegate { 189 public: 190 virtual ~Delegate(); 191 192 // General initialization. 193 virtual void InitWebContents(content::WebContents* web_contents) = 0; 194 virtual NativeAppWindow* CreateNativeAppWindow( 195 ShellWindow* window, 196 const CreateParams& params) = 0; 197 198 // Link handling. 199 virtual content::WebContents* OpenURLFromTab( 200 Profile* profile, 201 content::WebContents* source, 202 const content::OpenURLParams& params) = 0; 203 virtual void AddNewContents(Profile* profile, 204 content::WebContents* new_contents, 205 WindowOpenDisposition disposition, 206 const gfx::Rect& initial_pos, 207 bool user_gesture, 208 bool* was_blocked) = 0; 209 210 // Feature support. 211 virtual content::ColorChooser* ShowColorChooser( 212 content::WebContents* web_contents, 213 SkColor initial_color) = 0; 214 virtual void RunFileChooser(content::WebContents* tab, 215 const content::FileChooserParams& params) = 0; 216 virtual void RequestMediaAccessPermission( 217 content::WebContents* web_contents, 218 const content::MediaStreamRequest& request, 219 const content::MediaResponseCallback& callback, 220 const extensions::Extension* extension) = 0; 221 virtual int PreferredIconSize() = 0; 222 223 // Web contents modal dialog support. 224 virtual void SetWebContentsBlocked(content::WebContents* web_contents, 225 bool blocked) = 0; 226 virtual bool IsWebContentsVisible(content::WebContents* web_contents) = 0; 227 }; 228 229 // Convert draggable regions in raw format to SkRegion format. Caller is 230 // responsible for deleting the returned SkRegion instance. 231 static SkRegion* RawDraggableRegionsToSkRegion( 232 const std::vector<extensions::DraggableRegion>& regions); 233 234 // The constructor and Init methods are public for constructing a ShellWindow 235 // with a non-standard render interface (e.g. v1 apps using Ash Panels). 236 // Normally ShellWindow::Create should be used. 237 // The constructed shell window takes ownership of |delegate|. 238 ShellWindow(Profile* profile, 239 Delegate* delegate, 240 const extensions::Extension* extension); 241 242 // Initializes the render interface, web contents, and native window. 243 // |shell_window_contents| will become owned by ShellWindow. 244 void Init(const GURL& url, 245 ShellWindowContents* shell_window_contents, 246 const CreateParams& params); 247 248 249 const std::string& window_key() const { return window_key_; } 250 const SessionID& session_id() const { return session_id_; } 251 const extensions::Extension* extension() const { return extension_; } 252 const std::string& extension_id() const { return extension_id_; } 253 content::WebContents* web_contents() const; 254 WindowType window_type() const { return window_type_; } 255 bool window_type_is_panel() const { 256 return (window_type_ == WINDOW_TYPE_PANEL || 257 window_type_ == WINDOW_TYPE_V1_PANEL); 258 } 259 Profile* profile() const { return profile_; } 260 const gfx::Image& app_icon() const { return app_icon_; } 261 const GURL& app_icon_url() { return app_icon_url_; } 262 263 NativeAppWindow* GetBaseWindow(); 264 gfx::NativeWindow GetNativeWindow(); 265 266 // Returns the bounds that should be reported to the renderer. 267 gfx::Rect GetClientBounds() const; 268 269 // NativeAppWindows should call this to determine what the window's title 270 // is on startup and from within UpdateWindowTitle(). 271 string16 GetTitle() const; 272 273 // Call to notify ShellRegistry and delete the window. Subclasses should 274 // invoke this method instead of using "delete this". 275 void OnNativeClose(); 276 277 // Should be called by native implementations when the window size, position, 278 // or minimized/maximized state has changed. 279 void OnNativeWindowChanged(); 280 281 // Should be called by native implementations when the window is activated. 282 void OnNativeWindowActivated(); 283 284 // Specifies a url for the launcher icon. 285 void SetAppIconUrl(const GURL& icon_url); 286 287 // Set the window shape. Passing a NULL |region| sets the default shape. 288 void UpdateShape(scoped_ptr<SkRegion> region); 289 290 // Called from the render interface to modify the draggable regions. 291 void UpdateDraggableRegions( 292 const std::vector<extensions::DraggableRegion>& regions); 293 294 // Updates the app image to |image|. Called internally from the image loader 295 // callback. Also called externally for v1 apps using Ash Panels. 296 void UpdateAppIcon(const gfx::Image& image); 297 298 // Transitions window into fullscreen, maximized, minimized or restores based 299 // on chrome.app.window API. 300 void Fullscreen(); 301 void Maximize(); 302 void Minimize(); 303 void Restore(); 304 305 // Transitions to OS fullscreen. See FULLSCREEN_TYPE_OS for more details. 306 void OSFullscreen(); 307 308 // Transitions to forced fullscreen. See FULLSCREEN_TYPE_FORCED for more 309 // details. 310 void ForcedFullscreen(); 311 312 // Set the minimum and maximum size that this window is allowed to be. 313 void SetMinimumSize(const gfx::Size& min_size); 314 void SetMaximumSize(const gfx::Size& max_size); 315 316 enum ShowType { 317 SHOW_ACTIVE, 318 SHOW_INACTIVE 319 }; 320 321 // Shows the window if its contents have been painted; otherwise flags the 322 // window to be shown as soon as its contents are painted for the first time. 323 void Show(ShowType show_type); 324 325 // Hides the window. If the window was previously flagged to be shown on 326 // first paint, it will be unflagged. 327 void Hide(); 328 329 ShellWindowContents* shell_window_contents_for_test() { 330 return shell_window_contents_.get(); 331 } 332 333 // Get the size constraints. 334 const SizeConstraints& size_constraints() const { 335 return size_constraints_; 336 } 337 338 // Set whether the window should stay above other windows which are not 339 // configured to be always-on-top. 340 void SetAlwaysOnTop(bool always_on_top); 341 342 // Whether the always-on-top property has been set by the chrome.app.window 343 // API. Note that the actual value of this property in the native app window 344 // will be false in fullscreen mode. 345 bool IsAlwaysOnTop() const; 346 347 protected: 348 virtual ~ShellWindow(); 349 350 private: 351 // PlatformAppBrowserTest needs access to web_contents() 352 friend class extensions::PlatformAppBrowserTest; 353 354 // content::WebContentsDelegate implementation. 355 virtual void CloseContents(content::WebContents* contents) OVERRIDE; 356 virtual bool ShouldSuppressDialogs() OVERRIDE; 357 virtual content::ColorChooser* OpenColorChooser( 358 content::WebContents* web_contents, 359 SkColor color, 360 const std::vector<content::ColorSuggestion>& suggestions) OVERRIDE; 361 virtual void RunFileChooser( 362 content::WebContents* tab, 363 const content::FileChooserParams& params) OVERRIDE; 364 virtual bool IsPopupOrPanel( 365 const content::WebContents* source) const OVERRIDE; 366 virtual void MoveContents( 367 content::WebContents* source, const gfx::Rect& pos) OVERRIDE; 368 virtual void NavigationStateChanged(const content::WebContents* source, 369 unsigned changed_flags) OVERRIDE; 370 virtual void ToggleFullscreenModeForTab(content::WebContents* source, 371 bool enter_fullscreen) OVERRIDE; 372 virtual bool IsFullscreenForTabOrPending( 373 const content::WebContents* source) const OVERRIDE; 374 virtual void RequestMediaAccessPermission( 375 content::WebContents* web_contents, 376 const content::MediaStreamRequest& request, 377 const content::MediaResponseCallback& callback) OVERRIDE; 378 virtual content::WebContents* OpenURLFromTab( 379 content::WebContents* source, 380 const content::OpenURLParams& params) OVERRIDE; 381 virtual void AddNewContents(content::WebContents* source, 382 content::WebContents* new_contents, 383 WindowOpenDisposition disposition, 384 const gfx::Rect& initial_pos, 385 bool user_gesture, 386 bool* was_blocked) OVERRIDE; 387 virtual bool PreHandleKeyboardEvent( 388 content::WebContents* source, 389 const content::NativeWebKeyboardEvent& event, 390 bool* is_keyboard_shortcut) OVERRIDE; 391 virtual void HandleKeyboardEvent( 392 content::WebContents* source, 393 const content::NativeWebKeyboardEvent& event) OVERRIDE; 394 virtual void RequestToLockMouse(content::WebContents* web_contents, 395 bool user_gesture, 396 bool last_unlocked_by_target) OVERRIDE; 397 398 // content::WebContentsObserver implementation. 399 virtual void DidFirstVisuallyNonEmptyPaint(int32 page_id) OVERRIDE; 400 401 // content::NotificationObserver implementation. 402 virtual void Observe(int type, 403 const content::NotificationSource& source, 404 const content::NotificationDetails& details) OVERRIDE; 405 406 // web_modal::WebContentsModalDialogManagerDelegate implementation. 407 virtual void SetWebContentsBlocked(content::WebContents* web_contents, 408 bool blocked) OVERRIDE; 409 virtual bool IsWebContentsVisible( 410 content::WebContents* web_contents) OVERRIDE; 411 412 // Helper method to add a message to the renderer's DevTools console. 413 void AddMessageToDevToolsConsole(content::ConsoleMessageLevel level, 414 const std::string& message); 415 416 // Saves the window geometry/position/screen bounds. 417 void SaveWindowPosition(); 418 419 // Helper method to adjust the cached bounds so that we can make sure it can 420 // be visible on the screen. See http://crbug.com/145752 . 421 void AdjustBoundsToBeVisibleOnScreen( 422 const gfx::Rect& cached_bounds, 423 const gfx::Rect& cached_screen_bounds, 424 const gfx::Rect& current_screen_bounds, 425 const gfx::Size& minimum_size, 426 gfx::Rect* bounds) const; 427 428 // Loads the appropriate default or cached window bounds and constrains them 429 // based on screen size and minimum/maximum size. Returns a new CreateParams 430 // that should be used to create the window. 431 CreateParams LoadDefaultsAndConstrain(CreateParams params) const; 432 433 // Load the app's image, firing a load state change when loaded. 434 void UpdateExtensionAppIcon(); 435 436 // Called when size_constraints is changed. 437 void OnSizeConstraintsChanged(); 438 439 // Set the fullscreen state in the native app window. 440 void SetNativeWindowFullscreen(int fullscreen_types); 441 442 // extensions::ExtensionKeybindingRegistry::Delegate implementation. 443 virtual extensions::ActiveTabPermissionGranter* 444 GetActiveTabPermissionGranter() OVERRIDE; 445 446 // web_modal::WebContentsModalDialogManagerDelegate implementation. 447 virtual web_modal::WebContentsModalDialogHost* 448 GetWebContentsModalDialogHost() OVERRIDE; 449 450 // Callback from web_contents()->DownloadFavicon. 451 void DidDownloadFavicon(int id, 452 int http_status_code, 453 const GURL& image_url, 454 const std::vector<SkBitmap>& bitmaps, 455 const std::vector<gfx::Size>& original_bitmap_sizes); 456 457 // extensions::IconImage::Observer implementation. 458 virtual void OnExtensionIconImageChanged( 459 extensions::IconImage* image) OVERRIDE; 460 461 Profile* profile_; // weak pointer - owned by ProfileManager. 462 // weak pointer - owned by ExtensionService. 463 const extensions::Extension* extension_; 464 const std::string extension_id_; 465 466 // Identifier that is used when saving and restoring geometry for this 467 // window. 468 std::string window_key_; 469 470 const SessionID session_id_; 471 WindowType window_type_; 472 content::NotificationRegistrar registrar_; 473 474 // Icon shown in the task bar. 475 gfx::Image app_icon_; 476 477 // Icon URL to be used for setting the app icon. If not empty, app_icon_ will 478 // be fetched and set using this URL. 479 GURL app_icon_url_; 480 481 // An object to load the app's icon as an extension resource. 482 scoped_ptr<extensions::IconImage> app_icon_image_; 483 484 scoped_ptr<NativeAppWindow> native_app_window_; 485 scoped_ptr<ShellWindowContents> shell_window_contents_; 486 scoped_ptr<Delegate> delegate_; 487 488 base::WeakPtrFactory<ShellWindow> image_loader_ptr_factory_; 489 490 // Bit field of FullscreenType. 491 int fullscreen_types_; 492 493 // Size constraints on the window. 494 SizeConstraints size_constraints_; 495 496 // Show has been called, so the window should be shown once the first visually 497 // non-empty paint occurs. 498 bool show_on_first_paint_; 499 500 // The first visually non-empty paint has completed. 501 bool first_paint_complete_; 502 503 // Whether the delayed Show() call was for an active or inactive window. 504 ShowType delayed_show_type_; 505 506 // Cache the desired value of the always-on-top property. When windows enter 507 // fullscreen, this property will be automatically switched off for security 508 // reasons. It is reinstated when the window exits fullscreen. 509 bool cached_always_on_top_; 510 511 DISALLOW_COPY_AND_ASSIGN(ShellWindow); 512 }; 513 514 } // namespace apps 515 516 #endif // APPS_SHELL_WINDOW_H_ 517
