Create windows for new app window bounds API

apps/app_window.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef APPS_APP_WINDOW_H_
 #define APPS_APP_WINDOW_H_
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/extensions/extension_icon_image.h"
@@ skipping 98 matching lines @@
 
     // Fullscreen entered by the OS. ChromeOS uses this type of fullscreen to
     // enter immersive fullscreen when the user hits the <F4> key.
     FULLSCREEN_TYPE_OS = 1 << 2,
 
     // Fullscreen mode that could not be exited by the user. ChromeOS uses
     // this type of fullscreen to run an app in kiosk mode.
     FULLSCREEN_TYPE_FORCED = 1 << 3,
   };
 
+  struct BoundsSpecification {
+    // INT_MIN represents an unspecified position component.
+    static const int kUnspecifiedPosition;
+
+    BoundsSpecification();
+    ~BoundsSpecification();
+
+    // INT_MIN designates 'unspecified' for the position components, and 0 for

[benwells, 2014/03/05 02:33:30]

Does INT_MIN mean 0 for size, or does 0 mean unspecified? This comment confuses
me.

[tmdiep, 2014/03/05 03:06:47]

I'll reword this comment.
INT_MIN means unspecified for position components.
0 means unspecified for size components.

+    // the size components. When unspecified, they should be replaced with a
+    // default value.
+    gfx::Rect bounds;
+
+    gfx::Size minimum_size;
+    gfx::Size maximum_size;
+
+    // Reset the bounds fields to their 'unspecified' values.

[tapted, 2014/03/05 03:14:03]

nit: mention that minimum/maximum size are unchanged.

+    void ResetBounds();
+  };
+
   struct CreateParams {
     CreateParams();
     ~CreateParams();
 
     WindowType window_type;
     Frame frame;
 
     bool has_frame_color;
     SkColor frame_color;
     bool transparent_background;  // Only supported on ash.
 
-    // Specify the initial content bounds of the window (excluding any window
-    // decorations). INT_MIN designates 'unspecified' for the position
-    // components, and 0 for the size components. When unspecified, they should
-    // be replaced with a default value.
-    gfx::Rect bounds;
+    // The initial content/inner bounds specification (excluding any window
+    // decorations).
+    BoundsSpecification content_spec;
 
-    gfx::Size minimum_size;
-    gfx::Size maximum_size;
+    // The initial window/outer bounds specification (including window
+    // decorations).
+    BoundsSpecification window_spec;
 
     std::string window_key;
 
     // The process ID of the process that requested the create.
     int32 creator_process_id;
 
     // Initial state of the window.
     ui::WindowShowState state;
 
     // If true, don't show the window after creation.
     bool hidden;
 
     // If true, the window will be resizable by the user. Defaults to true.
     bool resizable;
 
     // If true, the window will be focused on creation. Defaults to true.
     bool focused;
 
     // If true, the window will stay on top of other windows that are not
     // configured to be always on top. Defaults to false.
     bool always_on_top;
+
+    // The API enables developers to specify content or window bounds. This
+    // function combines them into a single, constrained window size. Note that
+    // until the frame insets are known, the returned value is just an estimate.

[benwells, 2014/03/05 02:33:30]

I don't understand the comment about frame insets. The are passed in, so why
would they be unknown?

[tmdiep, 2014/03/05 03:06:47]

We need the window created first to get the real frame insets. But some native
app window initialization passes in an initial size during window creation (e.g.
mac). So I just pass in empty frame insets to get an estimated initial size,
then set the bounds precisely later. All this happens when the window is still
hidden, so there is no jank.

I'll reword this comment.

+    gfx::Rect GetInitialWindowBounds(const gfx::Insets& frame_insets) const;
+
+    // The API enables developers to specify content or window size constraints.
+    // These functions combine them so that we can work with one set of
+    // constraints.
+    gfx::Size GetContentMinimumSize(const gfx::Insets& frame_insets) const;
+    gfx::Size GetContentMaximumSize(const gfx::Insets& frame_insets) const;
+    gfx::Size GetWindowMinimumSize(const gfx::Insets& frame_insets) const;
+    gfx::Size GetWindowMaximumSize(const gfx::Insets& frame_insets) const;
   };
 
   class Delegate {
    public:
     virtual ~Delegate();
 
     // General initialization.
     virtual void InitWebContents(content::WebContents* web_contents) = 0;
     virtual NativeAppWindow* CreateNativeAppWindow(
         AppWindow* window,
@@ skipping 113 matching lines @@
   void Minimize();
   void Restore();
 
   // Transitions to OS fullscreen. See FULLSCREEN_TYPE_OS for more details.
   void OSFullscreen();
 
   // Transitions to forced fullscreen. See FULLSCREEN_TYPE_FORCED for more
   // details.
   void ForcedFullscreen();
 
-  // Set the minimum and maximum size that this window is allowed to be.
-  void SetMinimumSize(const gfx::Size& min_size);
-  void SetMaximumSize(const gfx::Size& max_size);
+  // Set the minimum and maximum size of the content bounds.
+  void SetContentMinimumSize(const gfx::Size& min_size);
+  void SetContentMaximumSize(const gfx::Size& max_size);
 
   enum ShowType { SHOW_ACTIVE, SHOW_INACTIVE };
 
   // Shows the window if its contents have been painted; otherwise flags the
   // window to be shown as soon as its contents are painted for the first time.
   void Show(ShowType show_type);
 
   // Hides the window. If the window was previously flagged to be shown on
   // first paint, it will be unflagged.
   void Hide();
@@ skipping 84 matching lines @@
       OVERRIDE;
 
   // Helper method to add a message to the renderer's DevTools console.
   void AddMessageToDevToolsConsole(content::ConsoleMessageLevel level,
                                    const std::string& message);
 
   // Saves the window geometry/position/screen bounds.
   void SaveWindowPosition();
 
   // Helper method to adjust the cached bounds so that we can make sure it can
-  // be visible on the screen. See http://crbug.com/145752 .
+  // be visible on the screen. See http://crbug.com/145752.
   void AdjustBoundsToBeVisibleOnScreen(const gfx::Rect& cached_bounds,
                                        const gfx::Rect& cached_screen_bounds,
                                        const gfx::Rect& current_screen_bounds,
                                        const gfx::Size& minimum_size,
                                        gfx::Rect* bounds) const;
 
-  // Loads the appropriate default or cached window bounds and constrains them
-  // based on screen size and minimum/maximum size. Returns a new CreateParams
-  // that should be used to create the window.
-  CreateParams LoadDefaultsAndConstrain(CreateParams params) const;
+  // Loads the appropriate default or cached window bounds. Returns a new
+  // CreateParams that should be used to create the window.
+  CreateParams LoadDefaults(CreateParams params) const;
 
   // Load the app's image, firing a load state change when loaded.
   void UpdateExtensionAppIcon();
 
   // Called when size_constraints is changed.
   void OnSizeConstraintsChanged();
 
   // Set the fullscreen state in the native app window.
   void SetNativeWindowFullscreen();
 
@@ skipping 87 matching lines @@
   // reinstated when the window exits fullscreen and moves away from the
   // taskbar.
   bool cached_always_on_top_;
 
   DISALLOW_COPY_AND_ASSIGN(AppWindow);
 };
 
 }  // namespace apps
 
 #endif  // APPS_APP_WINDOW_H_