Create windows for new app window bounds API

chrome/browser/ui/gtk/apps/native_app_window_gtk.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/ui/gtk/apps/native_app_window_gtk.h"
 
 #include <gdk/gdkx.h>
 #include <vector>
 
 #include "base/message_loop/message_pump_gtk.h"
@@ skipping 43 matching lines @@
       atom_cache_(base::MessagePumpGtk::GetDefaultXDisplay(), kAtomsToCache),
       is_x_event_listened_(false) {
   Observe(web_contents());
 
   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
 
   gfx::NativeView native_view =
       web_contents()->GetView()->GetNativeView();
   gtk_container_add(GTK_CONTAINER(window_), native_view);
 
-  if (params.bounds.x() != INT_MIN && params.bounds.y() != INT_MIN)
-    gtk_window_move(window_, params.bounds.x(), params.bounds.y());
+  gfx::Insets frame_insets = GetFrameInsets();

[tmdiep, 2014/03/04 03:13:14]

The initial window bounds is broken on GTK because the window is initialized
asynchronously and the frame insets will be empty here. Since GTK will be
obsolete soon, I will leave it broken.

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

Is it more broken with your change? I'm wondering if windows which use IDs will
get progressively larger or smaller now as we're switched to remembering /
restoring window size.

If it is more broken we might want to log a bug / todo that we can jump on if
aura gets switched off for m35.

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

It's not significantly broken. Existing apps will behave the same as before, but
apps that use the new outer bounds will have initial size and constraints a bit
off (in the order of frame insets). I expect linux aura will get to stable
before this API gets to stable.

+  gfx::Rect initial_bounds = params.GetInitialWindowBounds(frame_insets);
+
+  if (initial_bounds.x() != INT_MIN && initial_bounds.y() != INT_MIN)

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

Isn't there a constant you should be using instead of INT_MIN?

+    gtk_window_move(window_, initial_bounds.x(), initial_bounds.y());
 
   // This is done to avoid a WM "feature" where setting the window size to
   // the monitor size causes the WM to set the EWMH for full screen mode.
-  int win_height = params.bounds.height();
+  int win_height = initial_bounds.height();
   if (frameless_ &&
-      gtk_window_util::BoundsMatchMonitorSize(window_, params.bounds)) {
+      gtk_window_util::BoundsMatchMonitorSize(window_, initial_bounds)) {
     win_height -= 1;
   }
-  gtk_window_set_default_size(window_, params.bounds.width(), win_height);
+  gtk_window_set_default_size(window_, initial_bounds.width(), win_height);
 
   resizable_ = params.resizable;
   if (!resizable_) {
     // If the window doesn't have a size request when we set resizable to
     // false, GTK will shrink the window to 1x1px.
     gtk_widget_set_size_request(GTK_WIDGET(window_),
-        params.bounds.width(), win_height);
+        initial_bounds.width(), win_height);
     gtk_window_set_resizable(window_, FALSE);
   }
 
   // make sure bounds_ and restored_bounds_ have correct values until we
   // get our first configure-event
-  bounds_ = restored_bounds_ = params.bounds;
+  bounds_ = restored_bounds_ = initial_bounds;
   gint x, y;
   gtk_window_get_position(window_, &x, &y);
   bounds_.set_origin(gfx::Point(x, y));
 
   // Hide titlebar when {frame: 'none'} specified on AppWindow..
   if (frameless_)
     gtk_window_set_decorated(window_, false);
 
   if (always_on_top_)
     gtk_window_set_keep_above(window_, TRUE);
 
-  size_constraints_.set_minimum_size(params.minimum_size);
-  size_constraints_.set_maximum_size(params.maximum_size);
-  UpdateWindowMinMaxSize();
+  size_constraints_.set_minimum_size(
+      params.GetContentMinimumSize(frame_insets));
+  size_constraints_.set_maximum_size(
+      params.GetContentMaximumSize(frame_insets));
+  UpdateContentMinMaxSize();
 
   // In some (older) versions of compiz, raising top-level windows when they
   // are partially off-screen causes them to get snapped back on screen, not
   // always even on the current virtual desktop.  If we are running under
   // compiz, suppress such raises, as they are not necessary in compiz anyway.
   if (ui::GuessWindowManager() == ui::WM_COMPIZ)
     suppress_window_raise_ = true;
 
   gtk_window_set_title(window_, extension()->name().c_str());
 
@@ skipping 360 matching lines @@
     if (!(state_ & GDK_WINDOW_STATE_MAXIMIZED)) {
       gtk_window_maximize(window_);
     } else {
       maximize_pending_ = false;
       if (!resizable_)
         gtk_window_set_resizable(window_, FALSE);
     }
   }
 }
 
-void NativeAppWindowGtk::UpdateWindowMinMaxSize() {
+void NativeAppWindowGtk::UpdateContentMinMaxSize() {
  GdkGeometry hints;
  int hints_mask = 0;
  if (size_constraints_.HasMinimumSize()) {
    gfx::Size min_size = size_constraints_.GetMinimumSize();
    hints.min_height = min_size.height();
    hints.min_width = min_size.width();
    hints_mask |= GDK_HINT_MIN_SIZE;
  }
  if (size_constraints_.HasMaximumSize()) {
    gfx::Size max_size = size_constraints_.GetMaximumSize();
@@ skipping 239 matching lines @@
 }
 
 void NativeAppWindowGtk::HideWithApp() {}
 void NativeAppWindowGtk::ShowWithApp() {}
 
 void NativeAppWindowGtk::UpdateShelfMenu() {
   // TODO(tmdiep): To be implemented for GTK.
   NOTIMPLEMENTED();
 }
 
-gfx::Size NativeAppWindowGtk::GetMinimumSize() const {
+gfx::Size NativeAppWindowGtk::GetContentMinimumSize() const {
  return size_constraints_.GetMinimumSize();
 }
 
-void NativeAppWindowGtk::SetMinimumSize(const gfx::Size& size) {
+void NativeAppWindowGtk::SetContentMinimumSize(const gfx::Size& size) {
  size_constraints_.set_minimum_size(size);
- UpdateWindowMinMaxSize();
+ UpdateContentMinMaxSize();
 }
 
-gfx::Size NativeAppWindowGtk::GetMaximumSize() const {
+gfx::Size NativeAppWindowGtk::GetContentMaximumSize() const {
  return size_constraints_.GetMaximumSize();
 }
 
-void NativeAppWindowGtk::SetMaximumSize(const gfx::Size& size) {
+void NativeAppWindowGtk::SetContentMaximumSize(const gfx::Size& size) {
  size_constraints_.set_maximum_size(size);
- UpdateWindowMinMaxSize();
+ UpdateContentMinMaxSize();
 }