GTK: allow inspecting of extension popups.

chrome/browser/gtk/info_bubble_gtk.cc

 // Copyright (c) 2009 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/gtk/info_bubble_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include "app/l10n_util.h"
@@ skipping 31 matching lines @@
 const GdkColor kFrameColor = GDK_COLOR_RGB(0x63, 0x63, 0x63);
 
 }  // namespace
 
 // static
 InfoBubbleGtk* InfoBubbleGtk::Show(GtkWindow* toplevel_window,
                                    const gfx::Rect& rect,
                                    GtkWidget* content,
                                    ArrowLocationGtk arrow_location,
                                    bool match_system_theme,
+                                   bool grab_input,
                                    GtkThemeProvider* provider,
                                    InfoBubbleGtkDelegate* delegate) {
   InfoBubbleGtk* bubble = new InfoBubbleGtk(provider, match_system_theme);
-  bubble->Init(toplevel_window, rect, content, arrow_location);
+  bubble->Init(toplevel_window, rect, content, arrow_location, grab_input);
   bubble->set_delegate(delegate);
   return bubble;
 }
 
 InfoBubbleGtk::InfoBubbleGtk(GtkThemeProvider* provider,
                              bool match_system_theme)
     : delegate_(NULL),
       window_(NULL),
       theme_provider_(provider),
       accel_group_(gtk_accel_group_new()),
       toplevel_window_(NULL),
       mask_region_(NULL),
       preferred_arrow_location_(ARROW_LOCATION_TOP_LEFT),
       current_arrow_location_(ARROW_LOCATION_TOP_LEFT),
-      match_system_theme_(match_system_theme) {
+      match_system_theme_(match_system_theme),
+      grab_input_(true),
+      closed_by_escape_(false) {
 }
 
 InfoBubbleGtk::~InfoBubbleGtk() {
+  // Notify the delegate that we're about to close.  This gives the chance
+  // to save state / etc from the hosted widget before it's destroyed.
+  if (delegate_)
+    delegate_->InfoBubbleClosing(this, closed_by_escape_);
+
   g_object_unref(accel_group_);
   if (mask_region_) {
     gdk_region_destroy(mask_region_);
     mask_region_ = NULL;
   }
 
-  g_signal_handlers_disconnect_by_func(
-      toplevel_window_,
-      reinterpret_cast<gpointer>(HandleToplevelConfigureThunk),
-      this);
-  g_signal_handlers_disconnect_by_func(
-      toplevel_window_,
-      reinterpret_cast<gpointer>(HandleToplevelUnmapThunk),
-      this);
+  if (toplevel_window_) {
+    g_signal_handlers_disconnect_by_func(
+        toplevel_window_,
+        reinterpret_cast<gpointer>(HandleToplevelConfigureThunk),
+        this);
+    g_signal_handlers_disconnect_by_func(
+        toplevel_window_,
+        reinterpret_cast<gpointer>(HandleToplevelUnmapThunk),
+        this);
+  }
   toplevel_window_ = NULL;
 }
 
 void InfoBubbleGtk::Init(GtkWindow* toplevel_window,
                          const gfx::Rect& rect,
                          GtkWidget* content,
-                         ArrowLocationGtk arrow_location) {
+                         ArrowLocationGtk arrow_location,
+                         bool grab_input) {
   DCHECK(!window_);
   toplevel_window_ = toplevel_window;
   rect_ = rect;
   preferred_arrow_location_ = arrow_location;
 
-  window_ = gtk_window_new(GTK_WINDOW_POPUP);
+  grab_input_ = grab_input;
+  // Using a TOPLEVEL window may cause placement issues with certain WMs but it
+  // is necessary to be able to focus the window.
+  window_ = gtk_window_new(grab_input ? GTK_WINDOW_POPUP : GTK_WINDOW_TOPLEVEL);
+
   gtk_widget_set_app_paintable(window_, TRUE);
   // Resizing is handled by the program, not user.
   gtk_window_set_resizable(GTK_WINDOW(window_), FALSE);
 
   // Attach our accelerator group to the window with an escape accelerator.
   gtk_accel_group_connect(accel_group_, GDK_Escape,
       static_cast<GdkModifierType>(0), static_cast<GtkAccelFlags>(0),
       g_cclosure_new(G_CALLBACK(&HandleEscapeThunk), this, NULL));
   gtk_window_add_accel_group(GTK_WINDOW(window_), accel_group_);
 
@@ skipping 22 matching lines @@
                    G_CALLBACK(HandleSizeAllocateThunk), this);
   g_signal_connect(window_, "button-press-event",
                    G_CALLBACK(&HandleButtonPressThunk), this);
   g_signal_connect(window_, "destroy",
                    G_CALLBACK(&HandleDestroyThunk), this);
 
   g_signal_connect(toplevel_window, "configure-event",
                    G_CALLBACK(&HandleToplevelConfigureThunk), this);
   g_signal_connect(toplevel_window, "unmap-event",
                    G_CALLBACK(&HandleToplevelUnmapThunk), this);
+  // Set |toplevel_window_| to NULL if it gets destroyed.
+  g_signal_connect(toplevel_window, "destroy",
+                   G_CALLBACK(gtk_widget_destroyed), &toplevel_window_);
 
   gtk_widget_show_all(window_);
 
-  // We add a GTK (application-level) grab.  This means we will get all
-  // mouse events for our application, even if they were delivered on another
-  // window.  We don't need this to get button presses outside of the bubble's
-  // window so we'll know to close it (the pointer grab takes care of that), but
-  // it prevents other widgets from getting highlighted when the pointer moves
-  // over them.
-  //
-  // (Ideally we wouldn't add the window to a group and it would just get all
-  // the mouse events, but gtk_grab_add() doesn't appear to do anything in that
-  // case.  Adding it to the toplevel window's group first appears to block
-  // enter/leave events for that window and its subwindows, although other
-  // browser windows still receive them).
-  gtk_window_group_add_window(gtk_window_get_group(toplevel_window),
-                              GTK_WINDOW(window_));
-  gtk_grab_add(window_);
+  if (grab_input_) {
+    // We add a GTK (application-level) grab.  This means we will get all
+    // mouse events for our application, even if they were delivered on another
+    // window.  We don't need this to get button presses outside of the bubble's
+    // window so we'll know to close it (the pointer grab takes care of that),
+    // but it prevents other widgets from getting highlighted when the pointer
+    // moves over them.
+    //
+    // (Ideally we wouldn't add the window to a group and it would just get all
+    // the mouse events, but gtk_grab_add() doesn't appear to do anything in
+    // that case.  Adding it to the toplevel window's group first appears to
+    // block enter/leave events for that window and its subwindows, although
+    // other browser windows still receive them).
+    gtk_window_group_add_window(gtk_window_get_group(toplevel_window),
+                                GTK_WINDOW(window_));
+    gtk_grab_add(window_);
 
-  GrabPointerAndKeyboard();
+    GrabPointerAndKeyboard();
+  }
 
   registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
                  NotificationService::AllSources());
   theme_provider_->InitThemesFor(this);
 }
 
 // NOTE: This seems a bit overcomplicated, but it requires a bunch of careful
 // fudging to get the pixels rasterized exactly where we want them, the arrow to
 // have a 1 pixel point, etc.
 // TODO(deanm): Windows draws with Skia and uses some PNG images for the
@@ skipping 141 matching lines @@
   DCHECK_EQ(type.value, NotificationType::BROWSER_THEME_CHANGED);
   if (theme_provider_->UseGtkTheme() && match_system_theme_) {
     gtk_widget_modify_bg(window_, GTK_STATE_NORMAL, NULL);
   } else {
     // Set the background color, so we don't need to paint it manually.
     gtk_widget_modify_bg(window_, GTK_STATE_NORMAL, &kBackgroundColor);
   }
 }
 
 void InfoBubbleGtk::HandlePointerAndKeyboardUngrabbedByContent() {
-  GrabPointerAndKeyboard();
+  if (grab_input_)
+    GrabPointerAndKeyboard();
 }
 
-void InfoBubbleGtk::CloseInternal(bool closed_by_escape) {
-  // Notify the delegate that we're about to close.  This gives the chance
-  // to save state / etc from the hosted widget before it's destroyed.
-  if (delegate_)
-    delegate_->InfoBubbleClosing(this, closed_by_escape);
-
+void InfoBubbleGtk::Close() {
   // We don't need to ungrab the pointer or keyboard here; the X server will
   // automatically do that when we destroy our window.
-
   DCHECK(window_);
   gtk_widget_destroy(window_);
   // |this| has been deleted, see HandleDestroy.
 }
 
 void InfoBubbleGtk::GrabPointerAndKeyboard() {
   // Install X pointer and keyboard grabs to make sure that we have the focus
   // and get all mouse and keyboard events until we're closed.
   GdkGrabStatus pointer_grab_status =
       gdk_pointer_grab(window_->window,
@@ skipping 12 matching lines @@
       gdk_keyboard_grab(window_->window,
                         FALSE,  // owner_events
                         GDK_CURRENT_TIME);
   if (keyboard_grab_status != GDK_GRAB_SUCCESS) {
     DLOG(ERROR) << "Unable to grab keyboard (status="
                 << keyboard_grab_status << ")";
   }
 }
 
 gboolean InfoBubbleGtk::HandleEscape() {
-  CloseInternal(true);  // Close by escape.
+  closed_by_escape_ = true;
+  Close();
   return TRUE;
 }
 
 gboolean InfoBubbleGtk::HandleExpose() {
   GdkDrawable* drawable = GDK_DRAWABLE(window_->window);
   GdkGC* gc = gdk_gc_new(drawable);
   gdk_gc_set_rgb_fg_color(gc, &kFrameColor);
 
   // Stroke the frame border.
   std::vector<GdkPoint> points = MakeFramePolygonPoints(
@@ skipping 25 matching lines @@
       (mask_region_ && gdk_region_point_in(mask_region_, event->x, event->y))) {
     return FALSE;  // Propagate.
   }
 
   // Our content widget got a click.
   if (event->window != window_->window &&
       gdk_window_get_toplevel(event->window) == window_->window) {
     return FALSE;
   }
 
-  // Otherwise we had a click outside of our window, close ourself.
-  Close();
-  return TRUE;
+  if (grab_input_) {
+    // Otherwise we had a click outside of our window, close ourself.
+    Close();
+    return TRUE;
+  }
+
+  return FALSE;
 }
 
 gboolean InfoBubbleGtk::HandleDestroy() {
   // We are self deleting, we have a destroy signal setup to catch when we
   // destroy the widget manually, or the window was closed via X.  This will
   // delete the InfoBubbleGtk object.
   delete this;
   return FALSE;  // Propagate.
 }
 
 gboolean InfoBubbleGtk::HandleToplevelConfigure(GdkEventConfigure* event) {
   if (!UpdateArrowLocation(false))
     MoveWindow();
   StackWindow();
   return FALSE;
 }
 
 gboolean InfoBubbleGtk::HandleToplevelUnmap() {
   Close();
   return FALSE;
 }