GTK: Port RenderWidgetHostViewGtk to latest GTK

content/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 "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 222 matching lines @@
     host_view->im_context_->OnFocusIn();
 
     return TRUE;
   }
 
   static gboolean OnFocusOut(GtkWidget* widget,
                              GdkEventFocus* focus,
                              RenderWidgetHostViewGtk* host_view) {
     // Whenever we lose focus, set the cursor back to that of our parent window,
     // which should be the default arrow.
-    gdk_window_set_cursor(widget->window, NULL);
+    gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
     // If we are showing a context menu, maintain the illusion that webkit has
     // focus.
     if (!host_view->is_showing_context_menu_) {
       host_view->GetRenderWidgetHost()->SetActive(false);
       host_view->GetRenderWidgetHost()->Blur();
     }
 
     // Prevents us from stealing input context focus in OnGrabNotify() handler.
     host_view->was_imcontext_focused_before_grab_ = false;
 
     // Disable the GtkIMContext object.
     host_view->im_context_->OnFocusOut();
 
     return TRUE;
   }
 
   // Called when we are shadowed or unshadowed by a keyboard grab (which will
   // occur for activatable popups, such as dropdown menus). Popup windows do not
   // take focus, so we never get a focus out or focus in event when they are
   // shown, and must rely on this signal instead.
   static void OnGrabNotify(GtkWidget* widget, gboolean was_grabbed,
                            RenderWidgetHostViewGtk* host_view) {
     if (was_grabbed) {
       if (host_view->was_imcontext_focused_before_grab_)
         host_view->im_context_->OnFocusIn();
     } else {
       host_view->was_imcontext_focused_before_grab_ =
           host_view->im_context_->is_focused();
       if (host_view->was_imcontext_focused_before_grab_) {
-        gdk_window_set_cursor(widget->window, NULL);
+        gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
         host_view->im_context_->OnFocusOut();
       }
     }
   }
 
   static gboolean OnButtonPressReleaseEvent(
       GtkWidget* widget,
       GdkEventButton* event,
       RenderWidgetHostViewGtk* host_view) {
 #if defined (OS_CHROMEOS)
@@ skipping 49 matching lines @@
     // from this widget to be relative to the top left of the widget.
     GtkWidget* event_widget = gtk_get_event_widget(
         reinterpret_cast<GdkEvent*>(event));
     if (event_widget != widget) {
       int x = 0;
       int y = 0;
       gtk_widget_get_pointer(widget, &x, &y);
       // If the mouse event happens outside our popup, force the popup to
       // close.  We do this so a hung renderer doesn't prevent us from
       // releasing the x pointer grab.
-      bool click_in_popup = x >= 0 && y >= 0 && x < widget->allocation.width &&
-          y < widget->allocation.height;
+      GtkAllocation allocation;
+      gtk_widget_get_allocation(widget, &allocation);
+      bool click_in_popup = x >= 0 && y >= 0 && x < allocation.width &&
+          y < allocation.height;
       // Only Shutdown on mouse downs. Mouse ups can occur outside the render
       // view if the user drags for DnD or while using the scrollbar on a select
       // dropdown. Don't shutdown if we are not a popup.
       if (event->type != GDK_BUTTON_RELEASE && host_view->IsPopup() &&
           !host_view->is_popup_first_mouse_release_ && !click_in_popup) {
         host_view->host_->Shutdown();
         return FALSE;
       }
       event->x = x;
       event->y = y;
@@ skipping 260 matching lines @@
     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,
+          gtk_widget_get_window(parent_),
           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);
+      gdk_keyboard_grab(gtk_widget_get_window(parent_), TRUE, GDK_CURRENT_TIME);
     }
   }
 }
 
 void RenderWidgetHostViewGtk::InitAsFullscreen(
     RenderWidgetHostView* /*reference_host_view*/) {
   DoSharedInit();
 
   is_fullscreen_ = true;
   GtkWindow* window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
@@ skipping 113 matching lines @@
 
 void RenderWidgetHostViewGtk::Hide() {
   gtk_widget_hide(view_.get());
 }
 
 bool RenderWidgetHostViewGtk::IsShowing() {
   return gtk_widget_get_visible(view_.get());
 }
 
 gfx::Rect RenderWidgetHostViewGtk::GetViewBounds() const {
-  GdkWindow* gdk_window = view_.get()->window;
+  GdkWindow* gdk_window = gtk_widget_get_window(view_.get());
   if (!gdk_window)
     return gfx::Rect(requested_size_);
   GdkRectangle window_rect;
   gdk_window_get_origin(gdk_window, &window_rect.x, &window_rect.y);
   return gfx::Rect(window_rect.x, window_rect.y,
                    requested_size_.width(), requested_size_.height());
 }
 
 void RenderWidgetHostViewGtk::UpdateCursor(const WebCursor& cursor) {
   // Optimize the common case, where the cursor hasn't changed.
@@ skipping 214 matching lines @@
   // 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) {
+  gint depth = gdk_visual_get_depth(gtk_widget_get_visual(view_.get()));
   return new BackingStoreGtk(host_, size,
                              ui::GetVisualFromGtkWidget(view_.get()),
-                             gtk_widget_get_visual(view_.get())->depth);
+                             depth);
 }
 
 void RenderWidgetHostViewGtk::SetBackground(const SkBitmap& background) {
   RenderWidgetHostView::SetBackground(background);
   host_->Send(new ViewMsg_SetBackground(host_->routing_id(), background));
 }
 
 void RenderWidgetHostViewGtk::ModifyEventForEdgeDragging(
     GtkWidget* widget, GdkEventMotion* event) {
   // If the widget is aligned with an edge of the monitor its on and the user
@@ skipping 11 matching lines @@
   if (event->state & GDK_BUTTON1_MASK) {
     if (drag_monitor_size.IsEmpty()) {
       // We can safely cache the monitor size for the duration of a drag.
       GdkScreen* screen = gtk_widget_get_screen(widget);
       int monitor =
           gdk_screen_get_monitor_at_point(screen, event->x_root, event->y_root);
       GdkRectangle geometry;
       gdk_screen_get_monitor_geometry(screen, monitor, &geometry);
       drag_monitor_size.SetSize(geometry.width, geometry.height);
     }
-
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(widget, &allocation);
     // Check X and Y independently, as the user could be dragging into a corner.
     if (event->x == 0 && event->x_root == 0) {
       new_dragged_at_horizontal_edge = dragged_at_horizontal_edge_ - 1;
-    } else if (widget->allocation.width - 1 == static_cast<gint>(event->x) &&
+    } else if (allocation.width - 1 == static_cast<gint>(event->x) &&
         drag_monitor_size.width() - 1 == static_cast<gint>(event->x_root)) {
       new_dragged_at_horizontal_edge = dragged_at_horizontal_edge_ + 1;
     }
 
     if (event->y == 0 && event->y_root == 0) {
       new_dragged_at_vertical_edge = dragged_at_vertical_edge_ - 1;
-    } else if (widget->allocation.height - 1 == static_cast<gint>(event->y) &&
+    } else if (allocation.height - 1 == static_cast<gint>(event->y) &&
         drag_monitor_size.height() - 1 == static_cast<gint>(event->y_root)) {
       new_dragged_at_vertical_edge = dragged_at_vertical_edge_ + 1;
     }
 
     event->x_root += new_dragged_at_horizontal_edge;
     event->x += new_dragged_at_horizontal_edge;
     event->y_root += new_dragged_at_vertical_edge;
     event->y += new_dragged_at_vertical_edge;
   } else {
     // Clear whenever we get a non-drag mouse move.
     drag_monitor_size.SetSize(0, 0);
   }
   dragged_at_horizontal_edge_ = new_dragged_at_horizontal_edge;
   dragged_at_vertical_edge_ = new_dragged_at_vertical_edge;
 }
 
 void RenderWidgetHostViewGtk::Paint(const gfx::Rect& damage_rect) {
   // If the GPU process is rendering directly into the View,
   // call the compositor directly.
   RenderWidgetHost* render_widget_host = GetRenderWidgetHost();
   if (render_widget_host->is_accelerated_compositing_active()) {
     host_->ScheduleComposite();
     return;
   }
 
-  GdkWindow* window = view_.get()->window;
+  GdkWindow* window = gtk_widget_get_window(view_.get());
   DCHECK(!about_to_validate_and_paint_);
 
   invalid_rect_ = damage_rect;
   about_to_validate_and_paint_ = true;
 
   // If the size of our canvas is (0,0), then we don't want to block here. We
   // are doing one of our first paints and probably have animations going on.
   bool force_create = !host_->empty();
   BackingStoreGtk* backing_store = static_cast<BackingStoreGtk*>(
       host_->GetBackingStore(force_create));
@@ skipping 70 matching lines @@
     if (window)
       gdk_window_clear(window);
     if (whiteout_start_time_.is_null())
       whiteout_start_time_ = base::TimeTicks::Now();
   }
 }
 
 void RenderWidgetHostViewGtk::ShowCurrentCursor() {
   // The widget may not have a window. If that's the case, abort mission. This
   // is the same issue as that explained above in Paint().
-  if (!view_.get()->window)
+  if (!gtk_widget_get_window(view_.get()))
     return;
 
   // TODO(port): WebKit bug https://bugs.webkit.org/show_bug.cgi?id=16388 is
   // that calling gdk_window_set_cursor repeatedly is expensive.  We should
   // avoid it here where possible.
   GdkCursor* gdk_cursor;
   if (current_cursor_.GetCursorType() == GDK_LAST_CURSOR) {
     // Use MOZ_CURSOR_SPINNING if we are showing the default cursor and
     // the page is loading.
     gdk_cursor = is_loading_ ? GetMozSpinningCursor() : NULL;
   } else {
     gdk_cursor = current_cursor_.GetNativeCursor();
   }
-  gdk_window_set_cursor(view_.get()->window, gdk_cursor);
+  gdk_window_set_cursor(gtk_widget_get_window(view_.get()), gdk_cursor);
 }
 
 void RenderWidgetHostViewGtk::CreatePluginContainer(
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.CreatePluginContainer(id);
 }
 
 void RenderWidgetHostViewGtk::DestroyPluginContainer(
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.DestroyPluginContainer(id);
@@ skipping 31 matching lines @@
 
 
 void RenderWidgetHostViewGtk::OnAcceleratedCompositingStateChange() {
   bool activated = host_->is_accelerated_compositing_active();
   GtkPreserveWindow* widget = reinterpret_cast<GtkPreserveWindow*>(view_.get());
 
   gtk_preserve_window_delegate_resize(widget, activated);
 }
 
 void RenderWidgetHostViewGtk::GetScreenInfo(WebKit::WebScreenInfo* results) {
-  GdkWindow* gdk_window = view_.get()->window;
+  GdkWindow* gdk_window = gtk_widget_get_window(view_.get());
   if (!gdk_window) {
     GdkDisplay* display = gdk_display_get_default();
     gdk_window = gdk_display_get_default_group(display);
   }
   if (!gdk_window)
     return;
   content::GetScreenInfoFromNativeWindow(gdk_window, results);
 }
 
 gfx::Rect RenderWidgetHostViewGtk::GetRootWindowBounds() {
   GtkWidget* toplevel = gtk_widget_get_toplevel(view_.get());
   if (!toplevel)
     return gfx::Rect();
 
   GdkRectangle frame_extents;
-  GdkWindow* gdk_window = toplevel->window;
+  GdkWindow* gdk_window = gtk_widget_get_window(toplevel);
   if (!gdk_window)
     return gfx::Rect();
 
   gdk_window_get_frame_extents(gdk_window, &frame_extents);
   return gfx::Rect(frame_extents.x, frame_extents.y,
                    frame_extents.width, frame_extents.height);
 }
 
 gfx::PluginWindowHandle RenderWidgetHostViewGtk::GetCompositingSurface() {
   if (compositing_surface_ == gfx::kNullPluginWindow) {
@@ skipping 118 matching lines @@
 gfx::Point RenderWidgetHostViewGtk::GetWidgetCenter() {
   if (widget_center_valid_)
     return widget_center_;
 
   GdkWindow* window = gtk_widget_get_window(view_.get());
   gint window_x = 0;
   gint window_y = 0;
   gdk_window_get_origin(window, &window_x, &window_y);
   gint window_w = 0;
   gint window_h = 0;
-  gdk_window_get_size(window, &window_w, &window_h);
-
+  window_w = gdk_window_get_width(window);

[Elliot Glaysher, 2011/11/28 18:35:42]

nit: we aren't using c here; it's ok to compress this to gint window_w =
gdk_window_get_width.

[robert.bradford, 2011/11/29 12:02:49]

Done and similarly for window_h too.

+  window_h = gdk_window_get_height(window);
   widget_center_.SetPoint(window_x + window_w / 2,
                           window_y + window_h / 2);
   widget_center_valid_ = true;
   return widget_center_;
 }
 
 void RenderWidgetHostViewGtk::ModifyEventMovementAndCoords(
     WebKit::WebMouseEvent* event) {
   // Movement is computed by taking the difference of the new cursor position
   // and the previous. Under mouse lock the cursor will be warped back to the
@@ skipping 21 matching lines @@
   }
 }
 
 // static
 void RenderWidgetHostView::GetDefaultScreenInfo(
     WebKit::WebScreenInfo* results) {
   GdkWindow* gdk_window =
       gdk_display_get_default_group(gdk_display_get_default());
   content::GetScreenInfoFromNativeWindow(gdk_window, results);
 }