apps/app_window.h

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