GTK implementation of remembering platform app window geometry.

chrome/browser/ui/gtk/extensions/shell_window_gtk.cc

 // Copyright (c) 2012 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/extensions/shell_window_gtk.h"
 
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/gtk/gtk_window_util.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/extensions/draggable_region.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "ui/base/x/active_window_watcher_x.h"
 #include "ui/gfx/rect.h"
 
+namespace {
+
+// The timeout in milliseconds before we'll get the true window position with
+// gtk_window_get_position() after the last GTK configure-event signal.
+const int kDebounceTimeoutMilliseconds = 100;
+
+} // namespace
+
 ShellWindowGtk::ShellWindowGtk(ShellWindow* shell_window,
                                const ShellWindow::CreateParams& params)
     : shell_window_(shell_window),
       state_(GDK_WINDOW_STATE_WITHDRAWN),
       is_active_(!ui::ActiveWindowWatcherX::WMSupportsActivation()),
       content_thinks_its_fullscreen_(false),
       frameless_(params.frame == ShellWindow::CreateParams::FRAME_NONE) {
   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() >= 0 && params.bounds.y() >= 0)
+    gtk_window_move(window_, params.bounds.x(), params.bounds.y());
+
   gtk_window_set_default_size(
       window_, params.bounds.width(), params.bounds.height());
 
+  // make sure bounds_ and restored_bounds_ have correct values until we
+  // get our first configure-event
+  bounds_ = restored_bounds_ = params.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 ShellWindow.
   if (frameless_)
     gtk_window_set_decorated(window_, false);
 
   int min_width = params.minimum_size.width();
   int min_height = params.minimum_size.height();
   int max_width = params.maximum_size.width();
   int max_height = params.maximum_size.height();
   GdkGeometry hints;
   int hints_mask = 0;
@@ skipping 77 matching lines @@
 void ShellWindowGtk::Show() {
   gtk_window_present(window_);
 }
 
 void ShellWindowGtk::ShowInactive() {
   gtk_window_set_focus_on_map(window_, false);
   gtk_widget_show(GTK_WIDGET(window_));
 }
 
 void ShellWindowGtk::Close() {
+  shell_window_->SaveWindowPosition();
+
+  // Cancel any pending callback from the window configure debounce timer.
+  window_configure_debounce_timer_.Stop();
+
   GtkWidget* window = GTK_WIDGET(window_);
   // To help catch bugs in any event handlers that might get fired during the
   // destruction, set window_ to NULL before any handlers will run.
   window_ = NULL;
 
   // OnNativeClose does a delete this so no other members should
   // be accessed after. gtk_widget_destroy is safe (and must
   // be last).
   shell_window_->OnNativeClose();
   gtk_widget_destroy(window);
@@ skipping 51 matching lines @@
                                                  GdkEvent* event) {
   Close();
 
   // Return true to prevent the GTK window from being destroyed.  Close will
   // destroy it for us.
   return TRUE;
 }
 
 gboolean ShellWindowGtk::OnConfigure(GtkWidget* widget,
                                      GdkEventConfigure* event) {
-  // TODO(mihaip): Do we need an explicit gtk_window_get_position call like in
-  // in BrowserWindowGtk::OnConfigure?
+  // We update |bounds_| but not |restored_bounds_| here.  The latter needs
+  // to be updated conditionally when the window is non-maximized and non-
+  // fullscreen, but whether those state updates have been processed yet is
+  // window-manager specific.  We update |restored_bounds_| in the debounced
+  // handler below, after the window state has been updated.
   bounds_.SetRect(event->x, event->y, event->width, event->height);
-  if (!IsMaximized())
-    restored_bounds_ = bounds_;
+
+  // The GdkEventConfigure* we get here doesn't have quite the right
+  // coordinates though (they're relative to the drawable window area, rather
+  // than any window manager decorations, if enabled), so we need to call
+  // gtk_window_get_position() to get the right values. (Otherwise session
+  // restore, if enabled, will restore windows to incorrect positions.) That's
+  // a round trip to the X server though, so we set a debounce timer and only
+  // call it (in OnDebouncedBoundsChanged() below) after we haven't seen a
+  // reconfigure event in a short while.
+  // We don't use Reset() because the timer may not yet be running.
+  // (In that case Stop() is a no-op.)
+  window_configure_debounce_timer_.Stop();
+  window_configure_debounce_timer_.Start(FROM_HERE,
+      base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds), this,
+      &ShellWindowGtk::OnDebouncedBoundsChanged);
 
   return FALSE;
 }
 
+void ShellWindowGtk::OnDebouncedBoundsChanged() {
+  gtk_window_util::UpdateWindowPosition(this, &bounds_, &restored_bounds_);
+  shell_window_->SaveWindowPosition();
+}
+
 gboolean ShellWindowGtk::OnWindowState(GtkWidget* sender,
                                        GdkEventWindowState* event) {
   state_ = event->new_window_state;
 
   if (content_thinks_its_fullscreen_ &&
       !(state_ & GDK_WINDOW_STATE_FULLSCREEN)) {
     content_thinks_its_fullscreen_ = false;
     content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
     if (rvh)
       rvh->ExitFullscreen();
@@ skipping 80 matching lines @@
   }
 
   draggable_region_ = draggable_region;
 }
 
 // static
 NativeShellWindow* NativeShellWindow::Create(
     ShellWindow* shell_window, const ShellWindow::CreateParams& params) {
   return new ShellWindowGtk(shell_window, params);
 }