GTK: allow inspecting of extension popups.

chrome/browser/gtk/info_bubble_gtk.h

 // 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.
 
 // This is the GTK implementation of InfoBubbles.  InfoBubbles are like
 // dialogs, but they point to a given element on the screen.  You should call
 // InfoBubbleGtk::Show, which will create and display a bubble.  The object is
 // self deleting, when the bubble is closed, you will be notified via
 // InfoBubbleGtkDelegate::InfoBubbleClosing().  Then the widgets and the
 // underlying object will be destroyed.  You can also close and destroy the
@@ skipping 43 matching lines @@
   // so it can point to any edge of |rect|.  The bubble will host the |content|
   // widget.  Its arrow will be drawn at |arrow_location| if possible.  The
   // |delegate| will be notified when the bubble is closed.  The bubble will
   // perform an X grab of the pointer and keyboard, and will close itself if a
   // click is received outside of the bubble.
   static 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);
 
   // Close the bubble if it's open.  This will delete the widgets and object,
   // so you shouldn't hold a InfoBubbleGtk pointer after calling Close().
-  void Close() { CloseInternal(false); }
+  void Close();
 
   // NotificationObserver implementation.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // If the content contains widgets that can steal our pointer and keyboard
   // grabs (e.g. GtkComboBox), this method should be called after a widget
   // releases the grabs so we can reacquire them.  Note that this causes a race
   // condition; another client could grab them before we do (ideally, GDK would
   // transfer the grabs back to us when the widget releases them).  The window
   // is small, though, and the worst-case scenario for this seems to just be
   // that the content's widgets will appear inactive even after the user clicks
   // in them.
   void HandlePointerAndKeyboardUngrabbedByContent();
 
  private:
   enum FrameType {
     FRAME_MASK,
     FRAME_STROKE,
   };
 
   explicit InfoBubbleGtk(GtkThemeProvider* provider, bool match_system_theme);
   virtual ~InfoBubbleGtk();
 
   // Creates the InfoBubble.
   void Init(GtkWindow* toplevel_window,
             const gfx::Rect& rect,
             GtkWidget* content,
-            ArrowLocationGtk arrow_location);
+            ArrowLocationGtk arrow_location,
+            bool grab_input);
 
   // Make the points for our polygon frame, either for fill (the mask), or for
   // when we stroke the border.
   static std::vector<GdkPoint> MakeFramePolygonPoints(
       ArrowLocationGtk arrow_location,
       int width,
       int height,
       FrameType type);
 
   // Get the location where the arrow should be placed (which is a function of
@@ skipping 16 matching lines @@
   // |toplevel_window_|'s position as of its most-recent ConfigureNotify event
   // and |rect_|) and move it there.
   void MoveWindow();
 
   // Restack the bubble's window directly above |toplevel_window_|.
   void StackWindow();
 
   // Sets the delegate.
   void set_delegate(InfoBubbleGtkDelegate* delegate) { delegate_ = delegate; }
 
-  // Closes the window and notifies the delegate. |closed_by_escape| is true if
-  // the close is the result of pressing escape.
-  void CloseInternal(bool closed_by_escape);
-
   // Grab (in the X sense) the pointer and keyboard.  This is needed to make
   // sure that we have the input focus.
   void GrabPointerAndKeyboard();
 
   static gboolean HandleEscapeThunk(GtkAccelGroup* group,
                                     GObject* acceleratable,
                                     guint keyval,
                                     GdkModifierType modifier,
                                     gpointer user_data) {
     return reinterpret_cast<InfoBubbleGtk*>(user_data)->HandleEscape();
@@ skipping 78 matching lines @@
   // Where would we prefer for the arrow be drawn relative to the bubble, and
   // where is it currently drawn?
   ArrowLocationGtk preferred_arrow_location_;
   ArrowLocationGtk current_arrow_location_;
 
   // Whether the background should match the system theme, when the system theme
   // is being used. For example, the bookmark bubble does, but extension popups
   // do not.
   bool match_system_theme_;
 
+  // If true, the popup owns all X input for the duration of its existence.
+  // This will usually be true, the exception being when inspecting extension
+  // popups with dev tools.
+  bool grab_input_;
+
+  bool closed_by_escape_;
+
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(InfoBubbleGtk);
 };
 
 #endif  // CHROME_BROWSER_GTK_INFO_BUBBLE_GTK_H_