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),
       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());
 
   // 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(
@@ skipping 83 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) {
+  GdkWindow* our_window = gtk_widget_get_parent_window(view_.get());
+
+  if (our_window == window)
+    made_active_ = true;
+
+  // If the window was previously active, but isn't active anymore, shut it
+  // down.
+  if (is_fullscreen_ && our_window != window && 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 90 matching lines @@
     GdkDisplay* display = gtk_widget_get_display(parent_);
     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());
 
+    ui::ActiveWindowWatcherX::RemoveObserver(this);
+
     // Disconnect the destroy handler so that we don't try to shutdown twice.
     if (is_fullscreen_)
       g_signal_handler_disconnect(window, destroy_handler_id_);
 
     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
@@ skipping 55 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 {
   return popup_type_ != WebKit::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewGtk::DoSharedInit() {
   view_.Own(RenderWidgetHostViewGtkWidget::CreateNewWidget(this));
   im_context_.reset(new GtkIMContextWrapper(this));
   plugin_container_manager_.set_host_widget(view_.get());
   key_bindings_handler_.reset(new GtkKeyBindingsHandler(view_.get()));
 }
 
 void RenderWidgetHostViewGtk::DoPopupOrFullscreenInit(GtkWindow* window,
                                                       const gfx::Rect& bounds) {
   requested_size_.SetSize(std::min(bounds.width(), kMaxWindowWidth),
                           std::min(bounds.height(), kMaxWindowHeight));
   host_->WasResized();
 
+  ui::ActiveWindowWatcherX::AddObserver(this);
+
   // Don't set the size when we're going fullscreen. This can confuse the
   // window manager into thinking we're resizing a fullscreen window and
   // therefore not fullscreen anymore.
   if (!is_fullscreen_) {
     gtk_widget_set_size_request(
         view_.get(), requested_size_.width(), requested_size_.height());
 
     // Don't allow the window to be resized. This also forces the window to
     // shrink down to the size of its child contents.
     gtk_window_set_resizable(window, FALSE);
@@ skipping 502 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();
 }