Rely on losing focus, not on becoming unfullscreened, to destroy a fullscreen window.

content/browser/renderer_host/render_widget_host_view_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 "content/browser/renderer_host/render_widget_host_view_gtk.h"
 
 // If this gets included after the gtk headers, then a bunch of compiler
 // errors happen because of a "#define Status int" in Xlib.h, which interacts
 // badly with net::URLRequestStatus::Status.
 #include "content/common/view_messages.h"
@@ skipping 25 matching lines @@
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/gtk/WebInputEventFactory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/x11/WebScreenInfoFactory.h"
 #include "ui/base/gtk/gtk_compat.h"
 #include "ui/base/text/text_elider.h"
+#include "ui/base/x/active_window_watcher_x.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #include "ui/gfx/gtk_preserve_window.h"
 #include "webkit/glue/webcursor_gtk_data.h"
 #include "webkit/plugins/npapi/webplugin.h"
 
 namespace {
 
 // Paint rects on Linux are bounded by the maximum size of a shared memory
 // region. By default that's 32MB, but many distros increase it significantly
@@ skipping 511 matching lines @@
     content::RenderWidgetHost* widget_host)
     : host_(RenderWidgetHostImpl::From(widget_host)),
       about_to_validate_and_paint_(false),
       is_hidden_(false),
       is_loading_(false),
       parent_(NULL),
       is_popup_first_mouse_release_(true),
       was_imcontext_focused_before_grab_(false),
       do_x_grab_(false),
       is_fullscreen_(false),
+      made_active_(false),

[Daniel Erat, 2012/06/13 19:18:43]

actually, having this variable contain false information unless this is a
fullscreen window makes me nervous.  any reason why you can't register as an
observer in DoSharedInit() and unregister in the d'tor (maybe with another
variable to make sure that you don't unregister unless init was actually
called)?

       destroy_handler_id_(0),
       dragged_at_horizontal_edge_(0),
       dragged_at_vertical_edge_(0),
       compositing_surface_(gfx::kNullPluginWindow),
       last_mouse_down_(NULL) {
   host_->SetView(this);
 }
 
 RenderWidgetHostViewGtk::~RenderWidgetHostViewGtk() {
   UnlockMouse();
@@ skipping 65 matching lines @@
 }
 
 void RenderWidgetHostViewGtk::InitAsFullscreen(
     RenderWidgetHostView* /*reference_host_view*/) {
   DoSharedInit();
 
   is_fullscreen_ = true;
   GtkWindow* window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
   gtk_window_set_decorated(window, FALSE);
   gtk_window_fullscreen(window);
-  g_signal_connect(GTK_WIDGET(window),
-                   "window-state-event",
-                   G_CALLBACK(&OnWindowStateEventThunk),
-                   this);
   destroy_handler_id_ = g_signal_connect(GTK_WIDGET(window),
                                          "destroy",
                                          G_CALLBACK(OnDestroyThunk),
                                          this);
   gtk_container_add(GTK_CONTAINER(window), view_.get());
 
+  ui::ActiveWindowWatcherX::AddObserver(this);
+
   // Try to move and resize the window to cover the screen in case the window
   // manager doesn't support _NET_WM_STATE_FULLSCREEN.
   GdkScreen* screen = gtk_window_get_screen(window);
   gfx::Rect bounds(
       0, 0, gdk_screen_get_width(screen), gdk_screen_get_height(screen));
   DoPopupOrFullscreenInit(window, bounds);
 }
 
 content::RenderWidgetHost*
 RenderWidgetHostViewGtk::GetRenderWidgetHost() const {
@@ skipping 77 matching lines @@
 void RenderWidgetHostViewGtk::Blur() {
   // TODO(estade): We should be clearing native focus as well, but I know of no
   // way to do that without focusing another widget.
   host_->Blur();
 }
 
 bool RenderWidgetHostViewGtk::HasFocus() const {
   return gtk_widget_is_focus(view_.get());
 }
 
+void RenderWidgetHostViewGtk::ActiveWindowChanged(GdkWindow *window) {
+  DCHECK(is_fullscreen_);
+  GdkWindow* our_window = gtk_widget_get_parent_window(view_.get());
+  // If the window was previously active, but isn't active anymore, shut it
+  // down.
+  if (our_window == window)
+    made_active_ = true;
+  else if (made_active_)
+    host_->Shutdown();
+}
+
 bool RenderWidgetHostViewGtk::IsSurfaceAvailableForCopy() const {
   return !!host_->GetBackingStore(false);
 }
 
 void RenderWidgetHostViewGtk::Show() {
   gtk_widget_show(view_.get());
 }
 
 void RenderWidgetHostViewGtk::Hide() {
   gtk_widget_hide(view_.get());
@@ skipping 91 matching lines @@
     gdk_display_pointer_ungrab(display, GDK_CURRENT_TIME);
     gdk_display_keyboard_ungrab(display, GDK_CURRENT_TIME);
   }
 
   // If this is a popup or fullscreen widget, then we need to destroy the window
   // that we created to hold it.
   if (IsPopup() || is_fullscreen_) {
     GtkWidget* window = gtk_widget_get_parent(view_.get());
 
     // Disconnect the destroy handler so that we don't try to shutdown twice.
-    if (is_fullscreen_)
+    if (is_fullscreen_) {
       g_signal_handler_disconnect(window, destroy_handler_id_);
+      ui::ActiveWindowWatcherX::RemoveObserver(this);
+    }
 
     gtk_widget_destroy(window);
   }
 
   // Remove |view_| from all containers now, so nothing else can hold a
   // reference to |view_|'s widget except possibly a gtk signal handler if
   // this code is currently executing within the context of a gtk signal
   // handler.  Note that |view_| is still alive after this call.  It will be
   // deallocated in the destructor.
   // See http://www.crbug.com/11847 for details.
@@ skipping 52 matching lines @@
 }
 
 GdkEventButton* RenderWidgetHostViewGtk::GetLastMouseDown() {
   return last_mouse_down_;
 }
 
 gfx::NativeView RenderWidgetHostViewGtk::BuildInputMethodsGtkMenu() {
   return im_context_->BuildInputMethodsGtkMenu();
 }
 
-gboolean RenderWidgetHostViewGtk::OnWindowStateEvent(
-    GtkWidget* widget,
-    GdkEventWindowState* event) {
-  if (is_fullscreen_) {
-    // If a fullscreen widget got unfullscreened (e.g. by the window manager),
-    // close it.
-    bool unfullscreened =
-        (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
-        !(event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN);
-    if (unfullscreened) {
-      host_->Shutdown();
-      return TRUE;
-    }
-  }
-
-  return FALSE;
-}
-
 void RenderWidgetHostViewGtk::OnDestroy(GtkWidget* widget) {
   DCHECK(is_fullscreen_);
   host_->Shutdown();
 }
 
 bool RenderWidgetHostViewGtk::NeedsInputGrab() {
   return popup_type_ == WebKit::WebPopupTypeSelect;
 }
 
 bool RenderWidgetHostViewGtk::IsPopup() const {
@@ skipping 528 matching lines @@
             parent,
             static_cast<content::AccessibilityNodeData::State>(0),
             this));
   }
   BrowserAccessibilityGtk* root =
       browser_accessibility_manager_->GetRoot()->ToBrowserAccessibilityGtk();
 
   atk_object_set_role(root->GetAtkObject(), ATK_ROLE_HTML_CONTAINER);
   return root->GetAtkObject();
 }