GTK: Part 1 of removing GtkWidget->window to close up GSEALs.

chrome/browser/ui/gtk/browser_window_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/ui/gtk/browser_window_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include <dlfcn.h>
 #include <string>
@@ skipping 239 matching lines @@
 // of calling gtk_window_resize directly.  This is done to avoid a WM "feature"
 // where setting the window size to the monitor size causes the WM to set the
 // EWMH for full screen mode.
 void SetWindowSize(GtkWindow* window, const gfx::Size& size) {
   gfx::Size new_size = size;
 
   gint current_width = 0;
   gint current_height = 0;
   gtk_window_get_size(window, &current_width, &current_height);
   GdkRectangle size_with_decorations = {0};
-  if (GTK_WIDGET(window)->window) {
-    gdk_window_get_frame_extents(GTK_WIDGET(window)->window,
+  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window));
+  if (gdk_window) {
+    gdk_window_get_frame_extents(gdk_window,
                                  &size_with_decorations);
   }
 
   if (current_width == size_with_decorations.width &&
       current_height == size_with_decorations.height) {
     // Make sure the window doesn't match any monitor size.  We compare against
     // all monitors because we don't know which monitor the window is going to
     // open on (the WM decides that).
     GdkScreen* screen = gtk_window_get_screen(window);
     gint num_monitors = gdk_screen_get_n_monitors(screen);
@@ skipping 464 matching lines @@
   // the window is destroyed.
   global_menu_bar_->Disable();
   gtk_widget_destroy(window);
 }
 
 void BrowserWindowGtk::Activate() {
   gtk_window_present(window_);
 }
 
 void BrowserWindowGtk::Deactivate() {
-  gdk_window_lower(GTK_WIDGET(window_)->window);
+  gdk_window_lower(gtk_widget_get_window(GTK_WIDGET(window_)));
 }
 
 bool BrowserWindowGtk::IsActive() const {
   return is_active_;
 }
 
 void BrowserWindowGtk::FlashFrame() {
   // May not be respected by all window managers.
   gtk_window_set_urgency_hint(window_, TRUE);
 }
@@ skipping 497 matching lines @@
   // Update all the UI bits.
   UpdateTitleBar();
   MaybeShowBookmarkBar(false);
 }
 
 void BrowserWindowGtk::ActiveWindowChanged(GdkWindow* active_window) {
   // Do nothing if we're in the process of closing the browser window.
   if (!window_)
     return;
 
-  bool is_active = (GTK_WIDGET(window_)->window == active_window);
+  bool is_active = gtk_widget_get_window(GTK_WIDGET(window_)) == active_window;
   bool changed = (is_active != is_active_);
 
   if (is_active && changed) {
     // If there's an app modal dialog (e.g., JS alert), try to redirect
     // the user's attention to the window owning the dialog.
     if (AppModalDialogQueue::GetInstance()->HasActiveDialog()) {
       AppModalDialogQueue::GetInstance()->ActivateModalDialog();
       return;
     }
   }
@@ skipping 275 matching lines @@
   gtk_floating_container_add_floating(
       GTK_FLOATING_CONTAINER(render_area_floating_container_),
       findbar->widget());
 }
 
 void BrowserWindowGtk::ResetCustomFrameCursor() {
   if (!frame_cursor_)
     return;
 
   frame_cursor_ = NULL;
-  gdk_window_set_cursor(GTK_WIDGET(window_)->window, NULL);
+  gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)), NULL);
 }
 
 // static
 BrowserWindowGtk* BrowserWindowGtk::GetBrowserWindowForNativeWindow(
     gfx::NativeWindow window) {
   if (window) {
     return static_cast<BrowserWindowGtk*>(
         g_object_get_qdata(G_OBJECT(window), GetBrowserWindowQuarkKey()));
   }
 
@@ skipping 195 matching lines @@
     gtk_widget_show(bookmark_bar_->widget());
 
     g_signal_connect_after(bookmark_bar_->widget(), "expose-event",
                            G_CALLBACK(OnBookmarkBarExposeThunk), this);
     g_signal_connect(bookmark_bar_->widget(), "size-allocate",
                      G_CALLBACK(OnBookmarkBarSizeAllocateThunk), this);
   }
 
   // We have to realize the window before we try to apply a window shape mask.
   gtk_widget_realize(GTK_WIDGET(window_));
-  state_ = gdk_window_get_state(GTK_WIDGET(window_)->window);
+  state_ = gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(window_)));
   // Note that calling this the first time is necessary to get the
   // proper control layout.
   UpdateCustomFrame();
 
   // We have to call this after the first window is created, but after that only
   // when the theme changes.
   static bool default_icon_set = false;
   if (!default_icon_set) {
     gtk_util::SetDefaultWindowIcon(window_);
     default_icon_set = true;
@@ skipping 58 matching lines @@
     // The bottom two rects are mirror images of the top two rects.
     GdkRectangle bot_mid_rect = top_mid_rect;
     bot_mid_rect.y = height - 3;
     GdkRectangle bot_bot_rect = top_top_rect;
     bot_bot_rect.y = height - 1;
     GdkRegion* mask = gdk_region_rectangle(&top_top_rect);
     gdk_region_union_with_rect(mask, &top_mid_rect);
     gdk_region_union_with_rect(mask, &mid_rect);
     gdk_region_union_with_rect(mask, &bot_mid_rect);
     gdk_region_union_with_rect(mask, &bot_bot_rect);
-    gdk_window_shape_combine_region(GTK_WIDGET(window_)->window, mask, 0, 0);
+    gdk_window_shape_combine_region(gtk_widget_get_window(GTK_WIDGET(window_)),
+                                    mask, 0, 0);
     gdk_region_destroy(mask);
     gtk_alignment_set_padding(GTK_ALIGNMENT(window_container_), 1,
         kFrameBorderThickness, kFrameBorderThickness, kFrameBorderThickness);
   } else {
     // XFCE disables the system decorations if there's an xshape set.
     if (UseCustomFrame()) {
       // Disable rounded corners.  Simply passing in a NULL region doesn't
       // seem to work on KWin, so manually set the shape to the whole window.
       GdkRectangle rect = { 0, 0, width, height };
       GdkRegion* mask = gdk_region_rectangle(&rect);
-      gdk_window_shape_combine_region(GTK_WIDGET(window_)->window, mask, 0, 0);
+      gdk_window_shape_combine_region(
+          gtk_widget_get_window(GTK_WIDGET(window_)), mask, 0, 0);
       gdk_region_destroy(mask);
     } else {
-      gdk_window_shape_combine_region(GTK_WIDGET(window_)->window, NULL, 0, 0);
+      gdk_window_shape_combine_region(
+          gtk_widget_get_window(GTK_WIDGET(window_)), NULL, 0, 0);
     }
     gtk_alignment_set_padding(GTK_ALIGNMENT(window_container_), 0, 0, 0, 0);
   }
 }
 
 void BrowserWindowGtk::ConnectAccelerators() {
   accel_group_ = gtk_accel_group_new();
   gtk_window_add_accel_group(window_, accel_group_);
 
   AcceleratorsGtk* accelerators = AcceleratorsGtk::GetInstance();
@@ skipping 16 matching lines @@
 }
 
 gfx::Size BrowserWindowGtk::GetNonClientFrameSize() const {
   return gfx::Size(window_container_->allocation.width -
                    render_area_floating_container_->allocation.width,
                    window_container_->allocation.height -
                    render_area_floating_container_->allocation.height);
 }
 
 void BrowserWindowGtk::InvalidateWindow() {
-  gdk_window_invalidate_rect(GTK_WIDGET(window_)->window,
+  gdk_window_invalidate_rect(gtk_widget_get_window(GTK_WIDGET(window_)),
                              &GTK_WIDGET(window_)->allocation, TRUE);
 }
 
 void BrowserWindowGtk::SaveWindowPosition() {
   // Browser::SaveWindowPlacement is used for session restore.
   ui::WindowShowState show_state = ui::SHOW_STATE_NORMAL;
   if (IsMaximized())
     show_state = ui::SHOW_STATE_MAXIMIZED;
   else if (IsMinimized())
     show_state = ui::SHOW_STATE_MINIMIZED;
@@ skipping 134 matching lines @@
 
   // Prevents the default handler from handling this event.
   return TRUE;
 }
 
 gboolean BrowserWindowGtk::OnMouseMoveEvent(GtkWidget* widget,
                                             GdkEventMotion* event) {
   // This method is used to update the mouse cursor when over the edge of the
   // custom frame.  If the custom frame is off or we're over some other widget,
   // do nothing.
-  if (!UseCustomFrame() || event->window != widget->window) {
+  if (!UseCustomFrame() || event->window != gtk_widget_get_window(widget)) {
     // Reset the cursor.
     if (frame_cursor_) {
       frame_cursor_ = NULL;
-      gdk_window_set_cursor(GTK_WIDGET(window_)->window, NULL);
+      gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)), NULL);
     }
     return FALSE;
   }
 
   // Update the cursor if we're on the custom frame border.
   GdkWindowEdge edge;
   bool has_hit_edge = GetWindowEdge(static_cast<int>(event->x),
                                     static_cast<int>(event->y), &edge);
   GdkCursorType new_cursor = GDK_LAST_CURSOR;
   if (has_hit_edge)
     new_cursor = GdkWindowEdgeToGdkCursorType(edge);
 
   GdkCursorType last_cursor = GDK_LAST_CURSOR;
   if (frame_cursor_)
     last_cursor = frame_cursor_->type;
 
   if (last_cursor != new_cursor) {
     if (has_hit_edge) {
       frame_cursor_ = gfx::GetCursor(new_cursor);
     } else {
       frame_cursor_ = NULL;
     }
-    gdk_window_set_cursor(GTK_WIDGET(window_)->window, frame_cursor_);
+    gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)),
+                          frame_cursor_);
   }
   return FALSE;
 }
 
 gboolean BrowserWindowGtk::OnButtonPressEvent(GtkWidget* widget,
                                               GdkEventButton* event) {
   // Handle back/forward.
   if (event->type == GDK_BUTTON_PRESS) {
     if (event->button == 8) {
       browser_->GoBack(CURRENT_TAB);
       return TRUE;
     } else if (event->button == 9) {
       browser_->GoForward(CURRENT_TAB);
       return TRUE;
     }
   }
 
   // Handle left, middle and right clicks.  In particular, we care about clicks
   // in the custom frame border and clicks in the titlebar.
 
   // Make the button press coordinate relative to the browser window.
   int win_x, win_y;
-  gdk_window_get_origin(GTK_WIDGET(window_)->window, &win_x, &win_y);
+  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
+  gdk_window_get_origin(gdk_window, &win_x, &win_y);
 
   GdkWindowEdge edge;
   gfx::Point point(static_cast<int>(event->x_root - win_x),
                    static_cast<int>(event->y_root - win_y));
   bool has_hit_edge = GetWindowEdge(point.x(), point.y(), &edge);
 
   // Ignore clicks that are in/below the browser toolbar.
   GtkWidget* toolbar = toolbar_->widget();
   if (!gtk_widget_get_visible(toolbar)) {
     // If the toolbar is not showing, use the location of web contents as the
     // boundary of where to ignore clicks.
     toolbar = render_area_vbox_;
   }
   gint toolbar_y;
   gtk_widget_get_pointer(toolbar, NULL, &toolbar_y);
   bool has_hit_titlebar = !IsFullscreen() && (toolbar_y < 0)
                           && !has_hit_edge;
   if (event->button == 1) {
     if (GDK_BUTTON_PRESS == event->type) {
       guint32 last_click_time = last_click_time_;
       gfx::Point last_click_position = last_click_position_;
       last_click_time_ = event->time;
       last_click_position_ = gfx::Point(static_cast<int>(event->x),
                                         static_cast<int>(event->y));
 
       // Raise the window after a click on either the titlebar or the border to
       // match the behavior of most window managers, unless that behavior has
       // been suppressed.
       if ((has_hit_titlebar || has_hit_edge) && !suppress_window_raise_)
-        gdk_window_raise(GTK_WIDGET(window_)->window);
+        gdk_window_raise(gdk_window);
 
       if (has_hit_titlebar) {
         return HandleTitleBarLeftMousePress(
             event, last_click_time, last_click_position);
       } else if (has_hit_edge) {
         gtk_window_begin_resize_drag(window_, edge, event->button,
                                      static_cast<gint>(event->x_root),
                                      static_cast<gint>(event->y_root),
                                      event->time);
         return TRUE;
       }
     } else if (GDK_2BUTTON_PRESS == event->type) {
       if (has_hit_titlebar) {
         // Maximize/restore on double click.
         if (IsMaximized()) {
           UnMaximize();
         } else {
           gtk_window_maximize(window_);
         }
         return TRUE;
       }
     }
   } else if (event->button == 2) {
     if (has_hit_titlebar || has_hit_edge) {
-      gdk_window_lower(GTK_WIDGET(window_)->window);
+      gdk_window_lower(gdk_window);
     }
     return TRUE;
   } else if (event->button == 3) {
     if (has_hit_titlebar) {
       titlebar_->ShowContextMenu(event);
       return TRUE;
     }
   }
 
   return FALSE;  // Continue to propagate the event.
@@ skipping 57 matching lines @@
   return FALSE;
 }
 
 void BrowserWindowGtk::ShowSupportedWindowFeatures() {
   if (IsTabStripSupported())
     tabstrip_->Show();
 
   if (IsToolbarSupported()) {
     toolbar_->Show();
     gtk_widget_show(toolbar_border_);
-    gdk_window_lower(toolbar_border_->window);
+    gdk_window_lower(gtk_widget_get_window(toolbar_border_));
   }
 
   if (IsBookmarkBarSupported())
     MaybeShowBookmarkBar(false);
 }
 
 void BrowserWindowGtk::HideUnsupportedWindowFeatures() {
   if (!IsTabStripSupported())
     tabstrip_->Hide();
 
@@ skipping 82 matching lines @@
 
 bool BrowserWindowGtk::UseCustomFrame() {
   // We don't use the custom frame for app mode windows or app window popups.
   return use_custom_frame_pref_.GetValue() && !browser_->is_app();
 }
 
 bool BrowserWindowGtk::BoundsMatchMonitorSize() {
   // A screen can be composed of multiple monitors.
   GdkScreen* screen = gtk_window_get_screen(window_);
   gint monitor_num = gdk_screen_get_monitor_at_window(screen,
-      GTK_WIDGET(window_)->window);
+      gtk_widget_get_window(GTK_WIDGET(window_)));
 
   GdkRectangle monitor_size;
   gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor_size);
   return bounds_.size() == gfx::Size(monitor_size.width, monitor_size.height);
 }
 
 void BrowserWindowGtk::PlaceBookmarkBar(bool is_floating) {
   GtkWidget* target_parent = NULL;
   if (!is_floating) {
     // Place the bookmark bar at the end of |window_vbox_|; this happens after
@@ skipping 48 matching lines @@
           wm_type == ui::WM_OPENBOX ||
           wm_type == ui::WM_XFWM4);
 }
 
 // static
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   BrowserWindowGtk* browser_window_gtk = new BrowserWindowGtk(browser);
   browser_window_gtk->Init();
   return browser_window_gtk;
 }