GTK: Move tab_renderer_gtk.cc off of GetSurfaceNamed() and onto GetImageNamed().

chrome/browser/ui/gtk/tabs/tab_renderer_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/tab_renderer_gtk.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/utf_string_conversions.h"
@@ skipping 14 matching lines @@
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "grit/ui_resources.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/base/animation/throb_animation.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia_paint.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/gtk_util.h"
+#include "ui/gfx/image/image.h"
 #include "ui/gfx/image/cairo_cached_surface.h"
 #include "ui/gfx/pango_util.h"
 #include "ui/gfx/platform_font_pango.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "skia/ext/image_operations.h"
 
 #if !GTK_CHECK_VERSION(2, 22, 0)
 #define gtk_button_get_event_window(button) button->event_window
 #endif  // Gtk+ >= 2.22
 
@@ skipping 431 matching lines @@
     theme_id = IDR_THEME_TOOLBAR;
   } else {
     theme_id = data_.incognito ? IDR_THEME_TAB_BACKGROUND_INCOGNITO :
                IDR_THEME_TAB_BACKGROUND;
 
     if (!theme_service_->HasCustomImage(theme_id))
       offset_y = background_offset_y_;
   }
 
   // Paint the background behind the favicon.
-  gfx::CairoCachedSurface* tab_bg =
-      theme_service_->GetSurfaceNamed(theme_id, widget);
-  tab_bg->SetSource(cr, widget, -x(), -offset_y);
+  const gfx::Image* tab_bg = theme_service_->GetImageNamed(theme_id);
+  tab_bg->ToCairo()->SetSource(cr, widget, -x(), -offset_y);
   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
   cairo_rectangle(cr,
                   favicon_bounds_.x(), favicon_bounds_.y(),
                   favicon_bounds_.width(), favicon_bounds_.height());
   cairo_fill(cr);
 
   if (!IsActive()) {
     double throb_value = GetThrobValue();
     if (throb_value > 0) {
       cairo_push_group(cr);
-      gfx::CairoCachedSurface* active_bg = theme_service_->GetSurfaceNamed(
-          IDR_THEME_TOOLBAR, widget);
-      active_bg->SetSource(cr, widget, -x(), 0);
+      const gfx::Image* active_bg =
+          theme_service_->GetImageNamed(IDR_THEME_TOOLBAR);
+      active_bg->ToCairo()->SetSource(cr, widget, -x(), 0);
       cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
 
       cairo_rectangle(cr,
                       favicon_bounds_.x(), favicon_bounds_.y(),
                       favicon_bounds_.width(), favicon_bounds_.height());
       cairo_fill(cr);
 
       cairo_pop_group_to_source(cr);
       cairo_paint_with_alpha(cr, throb_value);
     }
@@ skipping 342 matching lines @@
 }
 
 void TabRendererGtk::PaintIcon(GtkWidget* widget, cairo_t* cr) {
   if (loading_animation_.animation_state() != ANIMATION_NONE) {
     PaintLoadingAnimation(widget, cr);
     return;
   }
 
   gfx::CairoCachedSurface* to_display = NULL;
   if (should_display_crashed_favicon_) {
-    to_display = theme_service_->GetSurfaceNamed(IDR_SAD_FAVICON, widget);
+    to_display = theme_service_->GetImageNamed(IDR_SAD_FAVICON)->ToCairo();
   } else if (!data_.favicon.isNull()) {
     if (data_.is_default_favicon && theme_service_->UsingNativeTheme()) {
       to_display = theme_service_->GetCairoIcon(
           GtkThemeService::NATIVE_FAVICON, widget);
     } else if (data_.cairo_favicon.valid()) {
       to_display = &data_.cairo_favicon;
     }
   }
 
   if (to_display) {
@@ skipping 17 matching lines @@
       PaintActiveTabBackground(widget, cr);
       cairo_pop_group_to_source(cr);
       cairo_paint_with_alpha(cr, throb_value);
     }
   }
 }
 
 void TabRendererGtk::DrawTabBackground(
     cairo_t* cr,
     GtkWidget* widget,
-    gfx::CairoCachedSurface* tab_bg,
+    const gfx::Image* tab_bg,
     int offset_x,
     int offset_y) {
-  tab_bg->SetSource(cr, widget, -offset_x, -offset_y);
+  tab_bg->ToCairo()->SetSource(cr, widget, -offset_x, -offset_y);
   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
 
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+
   // Draw left edge
-  gfx::CairoCachedSurface* tab_l_mask =
-      theme_service_->GetSurfaceNamed(IDR_TAB_ALPHA_LEFT, widget);
-  tab_l_mask->MaskSource(cr, widget, 0, 0);
+  gfx::Image& tab_l_mask = rb.GetNativeImageNamed(IDR_TAB_ALPHA_LEFT);
+  tab_l_mask.ToCairo()->MaskSource(cr, widget, 0, 0);
 
   // Draw center
   cairo_rectangle(cr,
                   tab_active_l_width_, kDropShadowOffset,
                   width() - (2 * tab_active_l_width_),
                   tab_inactive_l_height_);
   cairo_fill(cr);
 
   // Draw right edge
-  gfx::CairoCachedSurface* tab_r_mask =
-      theme_service_->GetSurfaceNamed(IDR_TAB_ALPHA_RIGHT, widget);
-  tab_r_mask->MaskSource(cr, widget, width() - tab_active_l_width_, 0);
+  gfx::Image& tab_r_mask = rb.GetNativeImageNamed(IDR_TAB_ALPHA_RIGHT);
+  tab_r_mask.ToCairo()->MaskSource(cr, widget,
+                                    width() - tab_active_l_width_, 0);
 }
 
 void TabRendererGtk::DrawTabShadow(
     cairo_t* cr,
     GtkWidget* widget,
     int left_idr,
     int center_idr,
     int right_idr) {
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  gfx::Image& active_image_l = rb.GetNativeImageNamed(left_idr);
+  gfx::Image& active_image_c = rb.GetNativeImageNamed(center_idr);
+  gfx::Image& active_image_r = rb.GetNativeImageNamed(right_idr);
+
   // Draw left drop shadow
-  gfx::CairoCachedSurface* active_image_l =
-      theme_service_->GetSurfaceNamed(left_idr, widget);
-  active_image_l->SetSource(cr, widget, 0, 0);
+  active_image_l.ToCairo()->SetSource(cr, widget, 0, 0);
   cairo_paint(cr);
 
   // Draw the center shadow
-  gfx::CairoCachedSurface* active_image_c =
-      theme_service_->GetSurfaceNamed(center_idr, widget);
-  active_image_c->SetSource(cr, widget, 0, 0);
+  active_image_c.ToCairo()->SetSource(cr, widget, 0, 0);
   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
   cairo_rectangle(cr, tab_active_l_width_, 0,
                   width() - (2 * tab_active_l_width_),
                   height());
   cairo_fill(cr);
 
   // Draw right drop shadow
-  gfx::CairoCachedSurface* active_image_r =
-      theme_service_->GetSurfaceNamed(right_idr, widget);
-  active_image_r->SetSource(cr, widget, width() - active_image_r->Width(), 0);
+  active_image_r.ToCairo()->SetSource(
+      cr, widget, width() - active_image_r.ToCairo()->Width(), 0);
   cairo_paint(cr);
 }
 
 void TabRendererGtk::PaintInactiveTabBackground(GtkWidget* widget,
-                                                     cairo_t* cr) {
+                                                cairo_t* cr) {
   int theme_id = data_.incognito ?
       IDR_THEME_TAB_BACKGROUND_INCOGNITO : IDR_THEME_TAB_BACKGROUND;
 
-  gfx::CairoCachedSurface* tab_bg =
-      theme_service_->GetSurfaceNamed(theme_id, widget);
+  const gfx::Image* tab_bg = theme_service_->GetImageNamed(theme_id);
 
   // If the theme is providing a custom background image, then its top edge
   // should be at the top of the tab. Otherwise, we assume that the background
   // image is a composited foreground + frame image.
   int offset_y = theme_service_->HasCustomImage(theme_id) ?
       0 : background_offset_y_;
 
   DrawTabBackground(cr, widget, tab_bg, background_offset_x_, offset_y);
 
   DrawTabShadow(cr, widget, IDR_TAB_INACTIVE_LEFT, IDR_TAB_INACTIVE_CENTER,
                 IDR_TAB_INACTIVE_RIGHT);
 }
 
 void TabRendererGtk::PaintActiveTabBackground(GtkWidget* widget,
                                               cairo_t* cr) {
-  gfx::CairoCachedSurface* tab_bg =
-      theme_service_->GetSurfaceNamed(IDR_THEME_TOOLBAR, widget);
+  const gfx::Image* tab_bg = theme_service_->GetImageNamed(IDR_THEME_TOOLBAR);
 
   DrawTabBackground(cr, widget, tab_bg, background_offset_x_, 0);
   DrawTabShadow(cr, widget, IDR_TAB_ACTIVE_LEFT, IDR_TAB_ACTIVE_CENTER,
                 IDR_TAB_ACTIVE_RIGHT);
 }
 
 void TabRendererGtk::PaintLoadingAnimation(GtkWidget* widget,
                                            cairo_t* cr) {
   int id = loading_animation_.animation_state() == ANIMATION_WAITING ?
            IDR_THROBBER_WAITING : IDR_THROBBER;
-  gfx::CairoCachedSurface* throbber =
-      theme_service_->GetSurfaceNamed(id, widget);
+  const gfx::Image* throbber = theme_service_->GetImageNamed(id);
 
-  const int image_size = throbber->Height();
+  const int image_size = throbber->ToCairo()->Height();
   const int image_offset = loading_animation_.animation_frame() * image_size;
   DCHECK(image_size == favicon_bounds_.height());
   DCHECK(image_size == favicon_bounds_.width());
 
-  throbber->SetSource(cr, widget, favicon_bounds_.x() - image_offset,
-                      favicon_bounds_.y());
+  throbber->ToCairo()->SetSource(cr, widget, favicon_bounds_.x() - image_offset,
+                                 favicon_bounds_.y());
   cairo_rectangle(cr, favicon_bounds_.x(), favicon_bounds_.y(),
                   image_size, image_size);
   cairo_fill(cr);
 }
 
 int TabRendererGtk::IconCapacity() const {
   if (height() < GetMinimumUnselectedSize().height())
     return 0;
   return (width() - kLeftPadding - kRightPadding) / gfx::kFaviconSize;
 }
@@ skipping 94 matching lines @@
   return FALSE;
 }
 
 // static
 void TabRendererGtk::InitResources() {
   if (initialized_)
     return;
 
   // Grab the pixel sizes of our masking images.
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  SkBitmap* tab_active_l = rb.GetBitmapNamed(IDR_TAB_ACTIVE_LEFT);
-  tab_active_l_width_ = tab_active_l->width();
-  tab_active_l_height_ = tab_active_l->height();
+  GdkPixbuf* tab_active_l = rb.GetNativeImageNamed(IDR_TAB_ACTIVE_LEFT);

[Elliot Glaysher, 2011/12/05 22:52:16]

This makes sure that the image representation of these two resources is native
instead of SkBitmap. For now, IDR_TAB_CLOSE is only used as an SkBitmap.

+  tab_active_l_width_ = gdk_pixbuf_get_width(tab_active_l);
+  tab_active_l_height_ = gdk_pixbuf_get_height(tab_active_l);
 
-  SkBitmap* tab_inactive_l = rb.GetBitmapNamed(IDR_TAB_INACTIVE_LEFT);
-  tab_inactive_l_height_ = tab_inactive_l->height();
+  GdkPixbuf* tab_inactive_l = rb.GetNativeImageNamed(IDR_TAB_INACTIVE_LEFT);
+  tab_inactive_l_height_ = gdk_pixbuf_get_height(tab_inactive_l);
 
   close_button_width_ = rb.GetBitmapNamed(IDR_TAB_CLOSE)->width();
   close_button_height_ = rb.GetBitmapNamed(IDR_TAB_CLOSE)->height();
 
   const gfx::Font& base_font = rb.GetFont(ResourceBundle::BaseFont);
   title_font_ = new gfx::Font(base_font.GetFontName(), kFontPixelSize);
   title_font_height_ = title_font_->GetHeight();
 
   initialized_ = true;
 }