gtk: Improve fullscreen RenderWidgetHostViewGtk.

chrome/browser/renderer_host/render_widget_host_view_gtk.cc

 // Copyright (c) 2011 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/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 "chrome/common/render_messages.h"
@@ skipping 131 matching lines @@
   static gboolean ExposeEvent(GtkWidget* widget, GdkEventExpose* expose,
                               RenderWidgetHostViewGtk* host_view) {
     const gfx::Rect damage_rect(expose->area);
     host_view->Paint(damage_rect);
     return FALSE;
   }
 
   static gboolean KeyPressReleaseEvent(GtkWidget* widget, GdkEventKey* event,
                                        RenderWidgetHostViewGtk* host_view) {
     if (host_view->IsPopup() && host_view->NeedsInputGrab() &&
         GDK_Escape == event->keyval) {

[piman, 2011/02/10 02:28:45]

Does "Esc" still close the fullscreen window ? I would expect some code here to
deal with it - unless GTK handles it already but I'd be surprised.

[Daniel Erat, 2011/02/10 04:45:19]

Yes, it does.  I'd assumed that Flash was handling this.  Do you think that
Chrome should also be watching for it?  I'm not sure of the order in which Flash
vs. Chrome handles these events, but I'll do some experimenting tomorrow to see
if this code ever even gets reached in the fullscreen case or if Flash always
eats the event first.

       // Force popups to close on Esc just in case the renderer is hung.  This
       // allows us to release our keyboard grab.
       host_view->host_->Shutdown();
     } else {
       // Send key event to input method.
       host_view->im_context_->ProcessKeyEvent(event);
     }
 
     // We return TRUE because we did handle the event. If it turns out webkit
     // can't handle the event, we'll deal with it in
@@ skipping 319 matching lines @@
 }
 
 RenderWidgetHostViewGtk::RenderWidgetHostViewGtk(RenderWidgetHost* widget_host)
     : host_(widget_host),
       about_to_validate_and_paint_(false),
       is_hidden_(false),
       is_loading_(false),
       is_showing_context_menu_(false),
       overlay_color_(0),
       overlay_animation_(this),
-      parent_host_view_(NULL),
       parent_(NULL),
       is_popup_first_mouse_release_(true),
       was_focused_before_grab_(false),
       do_x_grab_(false),
+      is_fullscreen_(false),
       dragged_at_horizontal_edge_(0),
       dragged_at_vertical_edge_(0) {
   host_->set_view(this);
 }
 
 RenderWidgetHostViewGtk::~RenderWidgetHostViewGtk() {
   view_.Destroy();
 }
 
 void RenderWidgetHostViewGtk::InitAsChild() {
-  view_.Own(RenderWidgetHostViewGtkWidget::CreateNewWidget(this));
-  // |im_context_| must be created after creating |view_| widget.
-  im_context_.reset(new GtkIMContextWrapper(this));
-  // |key_bindings_handler_| must be created after creating |view_| widget.
-  key_bindings_handler_.reset(new GtkKeyBindingsHandler(view_.get()));
-  plugin_container_manager_.set_host_widget(view_.get());
-
-#if defined(OS_CHROMEOS)
-  tooltip_window_.reset(new views::TooltipWindowGtk(view_.get()));
-#endif  // defined(OS_CHROMEOS)
-
+  DoSharedInit();
   overlay_animation_.SetDuration(kFadeEffectDuration);
   overlay_animation_.SetSlideDuration(kFadeEffectDuration);
-
   gtk_widget_show(view_.get());
 }
 
 void RenderWidgetHostViewGtk::InitAsPopup(
     RenderWidgetHostView* parent_host_view, const gfx::Rect& pos) {
-  DoInitAsPopup(parent_host_view, GTK_WINDOW_POPUP, pos, false);
+  // If we aren't a popup, then |window| will be leaked.
+  DCHECK(IsPopup());
+
+  DoSharedInit();
+  parent_ = parent_host_view->GetNativeView();
+  GtkWindow* window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));
+  gtk_container_add(GTK_CONTAINER(window), view_.get());
+  DoPopupOrFullscreenInit(window, pos);
+
+  // The underlying X window needs to be created and mapped by the above code
+  // before we can grab the input devices.
+  if (NeedsInputGrab()) {
+    // Grab all input for the app. If a click lands outside the bounds of the
+    // popup, WebKit will notice and destroy us. Before doing this we need
+    // to ensure that the the popup is added to the browser's window group,
+    // to allow for the grabs to work correctly.
+    gtk_window_group_add_window(gtk_window_get_group(
+        GTK_WINDOW(gtk_widget_get_toplevel(parent_))), window);
+    gtk_grab_add(view_.get());
+
+    // We need for the application to do an X grab as well. However if the app
+    // already has an X grab (as in the case of extension popup), an app grab
+    // will suffice.
+    do_x_grab_ = !gdk_pointer_is_grabbed();
+
+    // Now grab all of X's input.
+    if (do_x_grab_) {
+      gdk_pointer_grab(
+          parent_->window,
+          TRUE,  // Only events outside of the window are reported with respect
+                 // to |parent_->window|.
+          static_cast<GdkEventMask>(GDK_BUTTON_PRESS_MASK |
+              GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK),
+          NULL,
+          NULL,
+          GDK_CURRENT_TIME);
+      // We grab keyboard events too so things like alt+tab are eaten.
+      gdk_keyboard_grab(parent_->window, TRUE, GDK_CURRENT_TIME);
+    }
+  }
 }
 
-void RenderWidgetHostViewGtk::InitAsFullscreen(
-    RenderWidgetHostView* parent_host_view) {
-  DoInitAsPopup(parent_host_view, GTK_WINDOW_TOPLEVEL, gfx::Rect(), true);
+void RenderWidgetHostViewGtk::InitAsFullscreen() {
+  DoSharedInit();
+
+  is_fullscreen_ = true;
+  GtkWindow* window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
+  gtk_window_set_decorated(window, FALSE);
+  gtk_window_fullscreen(window);
+  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(
+      0, 0, gdk_screen_get_width(screen), gdk_screen_get_height(screen));
+  DoPopupOrFullscreenInit(window, bounds);
 }
 
 RenderWidgetHost* RenderWidgetHostViewGtk::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewGtk::DidBecomeSelected() {
   if (!is_hidden_)
     return;
 
@@ skipping 143 matching lines @@
   }
 }
 
 void RenderWidgetHostViewGtk::RenderViewGone(base::TerminationStatus status,
                                              int error_code) {
   Destroy();
   plugin_container_manager_.set_host_widget(NULL);
 }
 
 void RenderWidgetHostViewGtk::Destroy() {
-  if (IsPopup()) {
-    if (do_x_grab_) {
-      // Undo the X grab.
-      GdkDisplay* display = gtk_widget_get_display(parent_);
-      gdk_display_pointer_ungrab(display, GDK_CURRENT_TIME);
-      gdk_display_keyboard_ungrab(display, GDK_CURRENT_TIME);
-    }
+  if (do_x_grab_) {
+    // Undo the X grab.
+    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_)
     gtk_widget_destroy(gtk_widget_get_parent(view_.get()));
-  }
 
   // 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.
   gtk_widget_destroy(view_.get());
 
   // The RenderWidgetHost's destruction led here, so don't call it.
@@ skipping 38 matching lines @@
 #if !defined(TOOLKIT_VIEWS)
 void RenderWidgetHostViewGtk::AppendInputMethodsContextMenu(MenuGtk* menu) {
   im_context_->AppendInputMethodsContextMenu(menu);
 }
 #endif
 
 bool RenderWidgetHostViewGtk::NeedsInputGrab() {
   return popup_type_ == WebKit::WebPopupTypeSelect;
 }
 
-bool RenderWidgetHostViewGtk::IsPopup() {
+bool RenderWidgetHostViewGtk::IsPopup() const {
   return popup_type_ != WebKit::WebPopupTypeNone;
 }
 
+void RenderWidgetHostViewGtk::DoSharedInit() {
+  view_.Own(RenderWidgetHostViewGtkWidget::CreateNewWidget(this));
+  im_context_.reset(new GtkIMContextWrapper(this));
+  key_bindings_handler_.reset(new GtkKeyBindingsHandler(view_.get()));
+  plugin_container_manager_.set_host_widget(view_.get());
+#if defined(OS_CHROMEOS)
+  tooltip_window_.reset(new views::TooltipWindowGtk(view_.get()));
+#endif
+}
+
+void RenderWidgetHostViewGtk::DoPopupOrFullscreenInit(GtkWindow* window,
+                                                      const gfx::Rect& bounds) {
+  requested_size_ = bounds.size();
+  host_->WasResized();
+
+  gtk_widget_set_size_request(
+      view_.get(),
+      std::min(requested_size_.width(), kMaxWindowWidth),
+      std::min(requested_size_.height(), kMaxWindowHeight));
+
+  // 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);
+  gtk_window_set_default_size(window, -1, -1);
+  gtk_window_move(window, bounds.x(), bounds.y());
+
+  gtk_widget_show_all(GTK_WIDGET(window));
+}
+
 BackingStore* RenderWidgetHostViewGtk::AllocBackingStore(
     const gfx::Size& size) {
   return new BackingStoreX(host_, size,
                            ui::GetVisualFromGtkWidget(view_.get()),
                            gtk_widget_get_visual(view_.get())->depth);
 }
 
 void RenderWidgetHostViewGtk::SetBackground(const SkBitmap& background) {
   RenderWidgetHostView::SetBackground(background);
   host_->Send(new ViewMsg_SetBackground(host_->routing_id(), background));
@@ skipping 174 matching lines @@
     }
   } else {
     gdk_cursor = current_cursor_.GetNativeCursor();
   }
   gdk_window_set_cursor(view_.get()->window, gdk_cursor);
   // The window now owns the cursor.
   if (should_unref && gdk_cursor)
     gdk_cursor_unref(gdk_cursor);
 }
 
-void RenderWidgetHostViewGtk::DoInitAsPopup(
-    RenderWidgetHostView* parent_host_view,
-    GtkWindowType window_type,
-    const gfx::Rect& pos,
-    bool is_fullscreen) {
-  // If we are not a popup, then popup will be leaked.
-  DCHECK(IsPopup());
-
-  parent_host_view_ = parent_host_view;
-  parent_ = parent_host_view->GetNativeView();
-  GtkWidget* popup = gtk_window_new(window_type);
-  gtk_window_set_decorated(GTK_WINDOW(popup), FALSE);
-  view_.Own(RenderWidgetHostViewGtkWidget::CreateNewWidget(this));
-  // |im_context_| must be created after creating |view_| widget.
-  im_context_.reset(new GtkIMContextWrapper(this));
-  // |key_bindings_handler_| must be created after creating |view_| widget.
-  key_bindings_handler_.reset(new GtkKeyBindingsHandler(view_.get()));
-  plugin_container_manager_.set_host_widget(view_.get());
-
-#if defined(OS_CHROMEOS)
-  tooltip_window_.reset(new views::TooltipWindowGtk(view_.get()));
-#endif  // defined(OS_CHROMEOS)
-
-  gtk_container_add(GTK_CONTAINER(popup), view_.get());
-
-  if (is_fullscreen) {
-    // Set the request size to the size of the screen.
-    // TODO(boliu): Make sure this works for multi-monitor set ups and move this
-    // to some utility function.
-    GdkScreen* screen = gtk_window_get_screen(GTK_WINDOW(popup));
-    requested_size_ = gfx::Size(
-        std::min(gdk_screen_get_width(screen), kMaxWindowWidth),
-        std::min(gdk_screen_get_height(screen), kMaxWindowHeight));
-  } else {
-    requested_size_ = gfx::Size(std::min(pos.width(), kMaxWindowWidth),
-                                std::min(pos.height(), kMaxWindowHeight));
-  }
-  host_->WasResized();
-
-  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(GTK_WINDOW(popup), FALSE);
-  gtk_window_set_default_size(GTK_WINDOW(popup), -1, -1);
-  gtk_window_move(GTK_WINDOW(popup), pos.x(), pos.y());
-  if (is_fullscreen) {
-    gtk_window_fullscreen(GTK_WINDOW(popup));
-  }
-
-  gtk_widget_show_all(popup);
-
-  // If we are not activatable, we don't want to grab keyboard input,
-  // and webkit will manage our destruction.
-  // For unknown reason, calling gtk_grab_add() before realizing the widget may
-  // cause an assertion failure. See http://crbug.com/51834. So we do it after
-  // showing the popup.
-  if (NeedsInputGrab()) {
-    // Grab all input for the app. If a click lands outside the bounds of the
-    // popup, WebKit will notice and destroy us. Before doing this we need
-    // to ensure that the the popup is added to the browser's window group,
-    // to allow for the grabs to work correctly.
-    gtk_window_group_add_window(gtk_window_get_group(
-        GTK_WINDOW(gtk_widget_get_toplevel(parent_))), GTK_WINDOW(popup));
-    gtk_grab_add(view_.get());
-
-    // We need for the application to do an X grab as well. However if the app
-    // already has an X grab (as in the case of extension popup), an app grab
-    // will suffice.
-    do_x_grab_ = !gdk_pointer_is_grabbed();
-
-    // Now grab all of X's input.
-    if (do_x_grab_) {
-      gdk_pointer_grab(
-          parent_->window,
-          TRUE,  // Only events outside of the window are reported with respect
-                 // to |parent_->window|.
-          static_cast<GdkEventMask>(GDK_BUTTON_PRESS_MASK |
-              GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK),
-          NULL,
-          NULL,
-          GDK_CURRENT_TIME);
-      // We grab keyboard events too so things like alt+tab are eaten.
-      gdk_keyboard_grab(parent_->window, TRUE, GDK_CURRENT_TIME);
-    }
-  }
-}
-
 void RenderWidgetHostViewGtk::CreatePluginContainer(
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.CreatePluginContainer(id);
 }
 
 void RenderWidgetHostViewGtk::DestroyPluginContainer(
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.DestroyPluginContainer(id);
 }
 
@@ skipping 63 matching lines @@
 }
 
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget),
                                          kRenderWidgetHostViewKey);
   return reinterpret_cast<RenderWidgetHostView*>(user_data);
 }