GTK: Closing in on being completely GSEALed.

chrome/browser/ui/gtk/tabs/dragged_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/ui/gtk/tabs/dragged_view_gtk.h"
 
 #include <gdk/gdk.h>
 
 #include <algorithm>
 
@@ skipping 125 matching lines @@
   attached_ = true;
   parent_window_width_ = window_width;
   normal_width_ = normal_width;
   mini_width_ = mini_width;
 
   int dragged_tab_width =
       drag_data_->GetSourceTabData()->mini_ ? mini_width : normal_width;
 
   Resize(dragged_tab_width);
 
-  if (ui::IsScreenComposited())
-    gdk_window_set_opacity(container_->window, kOpaqueAlpha);
+  if (ui::IsScreenComposited()) {
+    GdkWindow* gdk_window = gtk_widget_get_window(container_);
+    gdk_window_set_opacity(gdk_window, kOpaqueAlpha);
+  }
 }
 
 void DraggedViewGtk::Resize(int width) {
   attached_tab_size_.set_width(width);
   ResizeContainer();
 }
 
 void DraggedViewGtk::Detach() {
   attached_ = false;
   ResizeContainer();
 
-  if (ui::IsScreenComposited())
-    gdk_window_set_opacity(container_->window, kTransparentAlpha);
+  if (ui::IsScreenComposited()) {
+    GdkWindow* gdk_window = gtk_widget_get_window(container_);
+    gdk_window_set_opacity(gdk_window, kTransparentAlpha);
+  }
 }
 
 void DraggedViewGtk::Update() {
   gtk_widget_queue_draw(container_);
 }
 
 int DraggedViewGtk::GetWidthInTabStripFromTo(int from, int to) {
   DCHECK(from <= static_cast<int>(drag_data_->size()));
   DCHECK(to <= static_cast<int>(drag_data_->size()));
 
@@ skipping 29 matching lines @@
      width -= 16;
    }
    return width;
 }
 
 void DraggedViewGtk::AnimateToBounds(const gfx::Rect& bounds,
                                      const base::Closure& callback) {
   animation_callback_ = callback;
 
   gint x, y, width, height;
-  gdk_window_get_origin(container_->window, &x, &y);
-  gdk_window_get_geometry(container_->window, NULL, NULL,
+  GdkWindow* gdk_window = gtk_widget_get_window(container_);
+  gdk_window_get_origin(gdk_window, &x, &y);
+  gdk_window_get_geometry(gdk_window, NULL, NULL,
                           &width, &height, NULL);
 
   animation_start_bounds_ = gfx::Rect(x, y, width, height);
   animation_end_bounds_ = bounds;
 
   close_animation_.SetSlideDuration(kAnimateToBoundsDurationMs);
   close_animation_.SetTweenType(ui::Tween::EASE_OUT);
   if (!close_animation_.IsShowing()) {
     close_animation_.Reset();
     close_animation_.Show();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DraggedViewGtk, ui::AnimationDelegate implementation:
 
 void DraggedViewGtk::AnimationProgressed(const ui::Animation* animation) {
   int delta_x = (animation_end_bounds_.x() - animation_start_bounds_.x());
   int x = animation_start_bounds_.x() +
       static_cast<int>(delta_x * animation->GetCurrentValue());
   int y = animation_end_bounds_.y();
-  gdk_window_move(container_->window, x, y);
+  GdkWindow* gdk_window = gtk_widget_get_window(container_);
+  gdk_window_move(gdk_window, x, y);
 }
 
 void DraggedViewGtk::AnimationEnded(const ui::Animation* animation) {
   animation_callback_.Run();
 }
 
 void DraggedViewGtk::AnimationCanceled(const ui::Animation* animation) {
   AnimationEnded(animation);
 }
 
@@ skipping 62 matching lines @@
   GdkColormap* colormap = gdk_screen_get_rgba_colormap(screen);
 
   // If rgba is not available, use rgb instead.
   if (!colormap)
     colormap = gdk_screen_get_rgb_colormap(screen);
 
   gtk_widget_set_colormap(container_, colormap);
 }
 
 void DraggedViewGtk::SetContainerTransparency() {
-  cairo_t* cairo_context = gdk_cairo_create(container_->window);
+  cairo_t* cairo_context = gdk_cairo_create(gtk_widget_get_window(container_));
   if (!cairo_context)
     return;
 
   // Make the background of the dragged tab window fully transparent.  All of
   // the content of the window (child widgets) will be completely opaque.
   gfx::Size size = bounds().size();
   cairo_scale(cairo_context, static_cast<double>(size.width()),
               static_cast<double>(size.height()));
   cairo_set_source_rgba(cairo_context, 1.0f, 1.0f, 1.0f, 0.0f);
   cairo_set_operator(cairo_context, CAIRO_OPERATOR_SOURCE);
@@ skipping 38 matching lines @@
             kDragFrameBorderSize);
     cairo_rectangle(cairo_context,
                     0, tab_height,
                     size.width(), size.height() - tab_height);
     cairo_fill(cairo_context);
   }
 
   cairo_destroy(cairo_context);
 
   // Set the shape mask.
-  gdk_window_shape_combine_mask(container_->window, pixmap, 0, 0);
+  GdkWindow* gdk_window = gtk_widget_get_window(container_);
+  gdk_window_shape_combine_mask(gdk_window, pixmap, 0, 0);
   g_object_unref(pixmap);
 }
 
 gboolean DraggedViewGtk::OnExpose(GtkWidget* widget, GdkEventExpose* event) {
   TRACE_EVENT0("ui::gtk", "DraggedViewGtk::OnExpose");
 
   if (ui::IsScreenComposited())
     SetContainerTransparency();
   else
     SetContainerShapeMask();
 
   // Only used when not attached.
   int tab_height = static_cast<int>(
       kScalingFactor * renderers_[drag_data_->source_tab_index()]->height());
 
   GtkAllocation allocation;
   gtk_widget_get_allocation(widget, &allocation);
 
   // Draw the render area.
   BackingStore* backing_store = drag_data_->GetSourceWebContents()->
       GetRenderViewHost()->GetBackingStore(false);
   if (backing_store && !attached_) {
     // This leaves room for the border.
     static_cast<BackingStoreGtk*>(backing_store)->PaintToRect(
         gfx::Rect(kDragFrameBorderSize, tab_height,
                   allocation.width - kTwiceDragFrameBorderSize,
                   allocation.height - tab_height -
                   kDragFrameBorderSize),
-        GDK_DRAWABLE(widget->window));
+        GDK_DRAWABLE(gtk_widget_get_window(widget)));
   }
 
-  cairo_t* cr = gdk_cairo_create(GDK_DRAWABLE(widget->window));
+  cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
   // Draw the border.
   if (!attached_) {
     cairo_set_line_width(cr, kDragFrameBorderSize);
     cairo_set_source_rgb(cr, kDraggedTabBorderColor[0],
                              kDraggedTabBorderColor[1],
                              kDraggedTabBorderColor[2]);
     // |offset| is the distance from the edge of the image to the middle of
     // the border line.
     double offset = kDragFrameBorderSize / 2.0 - 0.5;
     double left_x = offset;
@@ skipping 42 matching lines @@
     if (!attached_) {
       paint_at = widget_width / kScalingFactor -
           GetWidthInTabStripFromTo(0, index + 1);
     }
   }
 
   cairo_set_source_surface(cr, surface, paint_at, 0);
   cairo_paint(cr);
   cairo_surface_destroy(surface);
 }