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