Fixes bug in views on gtk where we wouldn't necessarily paint...

views/widget/widget_gtk.cc

 // 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.
 
 #include "views/widget/widget_gtk.h"
 
 #include "app/drag_drop_types.h"
 #include "app/gfx/path.h"
 #include "app/os_exchange_data.h"
 #include "app/os_exchange_data_provider_gtk.h"
@@ skipping 460 matching lines @@
 
 void WidgetGtk::DidProcessEvent(GdkEvent* event) {
   if (root_view_->NeedsPainting(true))
     PaintNow(root_view_->GetScheduledPaintRect());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TODO(beng): organize into sections:
 
 void WidgetGtk::CreateGtkWidget(GtkWidget* parent, const gfx::Rect& bounds) {
+  // We turn off double buffering for two reasons:
+  // 1. We draw to a canvas then composite to the screen, which means we're
+  //    doing our own double buffering already.
+  // 2. GTKs double buffering clips to the dirty region. RootView occasionally
+  //    needs to expand the paint region (see RootView::OnPaint). This means
+  //    that if we use GTK's double buffering and we tried to expand the dirty
+  //    region, it wouldn't get painted.
   if (type_ == TYPE_CHILD) {
     window_contents_ = widget_ = gtk_fixed_new();
+    GTK_WIDGET_UNSET_FLAGS(widget_, GTK_DOUBLE_BUFFERED);
     gtk_fixed_set_has_window(GTK_FIXED(widget_), true);
     if (!parent && !null_parent_) {
       GtkWidget* popup = gtk_window_new(GTK_WINDOW_POPUP);
       null_parent_ = gtk_fixed_new();
       gtk_container_add(GTK_CONTAINER(popup), null_parent_);
       gtk_widget_realize(null_parent_);
     }
     gtk_container_add(GTK_CONTAINER(parent ? parent : null_parent_), widget_);
     SetViewForNative(widget_, this);
   } else {
     widget_ = gtk_window_new(
         type_ == TYPE_WINDOW ? GTK_WINDOW_TOPLEVEL : GTK_WINDOW_POPUP);
+    GTK_WIDGET_UNSET_FLAGS(widget_, GTK_DOUBLE_BUFFERED);
 
     if (!bounds.size().IsEmpty()) {
       // When we realize the window, the window manager is given a size. If we
       // don't specify a size before then GTK defaults to 200x200. Specify
       // a size now so that the window manager sees the requested size.
       GtkAllocation alloc = { 0, 0, bounds.width(), bounds.height() };
       gtk_widget_size_allocate(widget_, &alloc);
     }
     gtk_window_set_decorated(GTK_WINDOW(widget_), false);
     // We'll take care of positioning our window.
     gtk_window_set_position(GTK_WINDOW(widget_), GTK_WIN_POS_NONE);
     SetWindowForNative(widget_, static_cast<WindowGtk*>(this));
     SetViewForNative(widget_, this);
 
     window_contents_ = gtk_fixed_new();
+    GTK_WIDGET_UNSET_FLAGS(window_contents_, GTK_DOUBLE_BUFFERED);
     gtk_fixed_set_has_window(GTK_FIXED(window_contents_), true);
     gtk_container_add(GTK_CONTAINER(widget_), window_contents_);
     gtk_widget_show(window_contents_);
     SetViewForNative(window_contents_, this);
 
     if (transparent_)
       ConfigureWidgetForTransparentBackground();
   }
   // The widget needs to be realized before handlers like size-allocate can
   // function properly.
@@ skipping 509 matching lines @@
 void WidgetGtk::ConfigureWidgetForTransparentBackground() {
   DCHECK(widget_ && window_contents_ && widget_ != window_contents_);
 
   GdkColormap* rgba_colormap =
       gdk_screen_get_rgba_colormap(gdk_screen_get_default());
   if (!rgba_colormap) {
     transparent_ = false;
     return;
   }
   // To make the background transparent we need to install the RGBA colormap
-  // on both the window and fixed. In addition we need to turn off double
-  // buffering and make sure no decorations are drawn. The last bit is to make
-  // sure the widget doesn't attempt to draw a pixmap in it's background.
+  // on both the window and fixed. In addition we need to make sure no
+  // decorations are drawn. The last bit is to make sure the widget doesn't
+  // attempt to draw a pixmap in it's background.
   gtk_widget_set_colormap(widget_, rgba_colormap);
   gtk_widget_set_app_paintable(widget_, true);
-  GTK_WIDGET_UNSET_FLAGS(widget_, GTK_DOUBLE_BUFFERED);
   gtk_widget_realize(widget_);
   gdk_window_set_decorations(widget_->window,
                              static_cast<GdkWMDecoration>(0));
   // Widget must be realized before setting pixmap.
   gdk_window_set_back_pixmap(widget_->window, NULL, FALSE);
 
   gtk_widget_set_colormap(window_contents_, rgba_colormap);
   gtk_widget_set_app_paintable(window_contents_, true);
-  GTK_WIDGET_UNSET_FLAGS(window_contents_, GTK_DOUBLE_BUFFERED);
   gtk_widget_realize(window_contents_);
   // Widget must be realized before setting pixmap.
   gdk_window_set_back_pixmap(window_contents_->window, NULL, FALSE);
 }
 
 void WidgetGtk::HandleGrabBroke() {
   if (has_capture_) {
     if (is_mouse_down_)
       root_view_->ProcessMouseDragCanceled();
     is_mouse_down_ = false;
     has_capture_ = false;
   }
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
 Widget* Widget::CreateTransparentPopupWidget(bool delete_on_destroy) {
   WidgetGtk* popup = new WidgetGtk(WidgetGtk::TYPE_POPUP);
   popup->set_delete_on_destroy(delete_on_destroy);
   popup->MakeTransparent();
   return popup;
 }
 
 }  // namespace views