GTK: Closing in on being completely GSEALed.

chrome/browser/ui/gtk/tabs/tab_strip_gtk.cc

 // Copyright (c) 2012 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/tab_strip_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include <algorithm>
 
@@ skipping 1432 matching lines @@
     gfx::Rect state(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                     tab_height);
     tab_data_.at(i).ideal_bounds = state;
     tab_x = end_of_tab + GetTabHOffset(i + 1);
   }
 }
 
 void TabStripGtk::LayoutNewTabButton(double last_tab_right,
                                      double unselected_width) {
   GtkWidget* toplevel = gtk_widget_get_ancestor(widget(), GTK_TYPE_WINDOW);
-  bool is_maximized = toplevel &&
-      ((gdk_window_get_state(toplevel->window) & GDK_WINDOW_STATE_MAXIMIZED)
-          != 0);
+  bool is_maximized = false;
+  if (toplevel) {
+    GdkWindow* gdk_window = gtk_widget_get_window(toplevel);
+    is_maximized = (gdk_window_get_state(gdk_window) &
+                    GDK_WINDOW_STATE_MAXIMIZED) != 0;
+  }
 
   int y = is_maximized ? 0 : kNewTabButtonVOffset;
   int height = newtab_surface_bounds_.height() + kNewTabButtonVOffset - y;
 
   gfx::Rect bounds(0, y, newtab_surface_bounds_.width(), height);
   int delta = abs(Round(unselected_width) - TabGtk::GetStandardSize().width());
   if (delta > 1 && !needs_resize_layout_) {
     // We're shrinking tabs, so we need to anchor the New Tab button to the
     // right edge of the TabStrip's bounds, rather than the right edge of the
     // right-most Tab, otherwise it'll bounce when animating.
@@ skipping 277 matching lines @@
       drop_info_->drop_arrow = GetDropArrowImage(drop_info_->point_down);
     }
   }
 
   gtk_window_move(GTK_WINDOW(drop_info_->container),
                   drop_bounds.x(), drop_bounds.y());
   gtk_window_resize(GTK_WINDOW(drop_info_->container),
                     drop_bounds.width(), drop_bounds.height());
 }
 
-bool TabStripGtk::CompleteDrop(guchar* data, bool is_plain_text) {
+bool TabStripGtk::CompleteDrop(const guchar* data, bool is_plain_text) {
   if (!drop_info_.get())
     return false;
 
   const int drop_index = drop_info_->drop_index;
   const bool drop_before = drop_info_->drop_before;
 
   // Destroy the drop indicator.
   drop_info_.reset();
 
   // Cancel any pending tab transition.
   hover_tab_selector_.CancelTabTransition();
 
   GURL url;
   if (is_plain_text) {
     AutocompleteMatch match;
     model_->profile()->GetAutocompleteClassifier()->Classify(
-        UTF8ToUTF16(reinterpret_cast<char*>(data)), string16(), false, false,
-        &match, NULL);
+        UTF8ToUTF16(reinterpret_cast<const char*>(data)), string16(),
+        false, false, &match, NULL);
     url = match.destination_url;
   } else {
-    std::string url_string(reinterpret_cast<char*>(data));
+    std::string url_string(reinterpret_cast<const char*>(data));
     url = GURL(url_string.substr(0, url_string.find_first_of('\n')));
   }
   if (!url.is_valid())
     return false;
 
   browser::NavigateParams params(window()->browser(), url,
                                  content::PAGE_TRANSITION_LINK);
   params.tabstrip_index = drop_index;
 
   if (drop_before) {
@@ skipping 32 matching lines @@
 gboolean TabStripGtk::DropInfo::OnExposeEvent(GtkWidget* widget,
                                               GdkEventExpose* event) {
   TRACE_EVENT0("ui::gtk", "TabStripGtk::DropInfo::OnExposeEvent");
 
   if (ui::IsScreenComposited()) {
     SetContainerTransparency();
   } else {
     SetContainerShapeMask();
   }
 
-  cairo_t* cr = gdk_cairo_create(GDK_DRAWABLE(widget->window));
+  cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
   gdk_cairo_rectangle(cr, &event->area);
   cairo_clip(cr);
 
   drop_arrow->ToCairo()->SetSource(cr, widget, 0, 0);
   cairo_paint(cr);
 
   cairo_destroy(cr);
 
   return FALSE;
 }
 
 // Sets the color map of the container window to allow the window to be
 // transparent.
 void TabStripGtk::DropInfo::SetContainerColorMap() {
   GdkScreen* screen = gtk_widget_get_screen(container);
   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);
 }
 
 // Sets full transparency for the container window.  This is used if
 // compositing is available for the screen.
 void TabStripGtk::DropInfo::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.
 
   cairo_scale(cairo_context, static_cast<double>(drop_indicator_width),
               static_cast<double>(drop_indicator_height));
   cairo_set_source_rgba(cairo_context, 1.0f, 1.0f, 1.0f, 0.0f);
   cairo_set_operator(cairo_context, CAIRO_OPERATOR_SOURCE);
@@ skipping 17 matching lines @@
   // Blit the rendered bitmap into a pixmap.  Any pixel set in the pixmap will
   // be opaque in the container window.
   cairo_set_operator(cairo_context, CAIRO_OPERATOR_SOURCE);
   // We don't use CairoCachedSurface::SetSource() here because we're not
   // rendering on a display server.
   gdk_cairo_set_source_pixbuf(cairo_context, drop_arrow->ToGdkPixbuf(), 0, 0);
   cairo_paint(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);
 }
 
 void TabStripGtk::DropInfo::CreateContainer() {
   container = gtk_window_new(GTK_WINDOW_POPUP);
   SetContainerColorMap();
   gtk_widget_set_app_paintable(container, TRUE);
   g_signal_connect(container, "expose-event",
                    G_CALLBACK(OnExposeEventThunk), this);
   gtk_widget_add_events(container, GDK_STRUCTURE_MASK);
@@ skipping 246 matching lines @@
 gboolean TabStripGtk::OnDragDataReceived(GtkWidget* widget,
                                          GdkDragContext* context,
                                          gint x, gint y,
                                          GtkSelectionData* data,
                                          guint info, guint time) {
   bool success = false;
 
   if (info == ui::TEXT_URI_LIST ||
       info == ui::NETSCAPE_URL ||
       info == ui::TEXT_PLAIN) {
-    success = CompleteDrop(data->data, info == ui::TEXT_PLAIN);
+    success = CompleteDrop(gtk_selection_data_get_data(data),
+                           info == ui::TEXT_PLAIN);
   }
 
   gtk_drag_finish(context, success, FALSE, time);
   return TRUE;
 }
 
 void TabStripGtk::OnNewTabClicked(GtkWidget* widget) {
   GdkEvent* event = gtk_get_current_event();
   DCHECK_EQ(event->type, GDK_BUTTON_RELEASE);
   int mouse_button = event->button.button;
@@ skipping 76 matching lines @@
 }
 
 void TabStripGtk::SetNewTabButtonBackground() {
   SkColor color = theme_service_->GetColor(
       ThemeService::COLOR_BUTTON_BACKGROUND);
   SkBitmap* background = theme_service_->GetBitmapNamed(
       IDR_THEME_WINDOW_CONTROL_BACKGROUND);
   SkBitmap* mask = theme_service_->GetBitmapNamed(IDR_NEWTAB_BUTTON_MASK);
   newtab_button_->SetBackground(color, background, mask);
 }