GTK: Move CairoCachedSurface from being owned by GtkThemeService to gfx::Image.

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"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/gtk/bookmarks/bookmark_utils_gtk.h"
-#include "chrome/browser/ui/gtk/cairo_cached_surface.h"
 #include "chrome/browser/ui/gtk/custom_button.h"
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
 #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/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
 
 namespace {
@@ skipping 430 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.
-  CairoCachedSurface* tab_bg =
+  gfx::CairoCachedSurface* tab_bg =
       theme_service_->GetSurfaceNamed(theme_id, widget);
-  tab_bg->SetSource(cr, -x(), -offset_y);
+  tab_bg->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);
-      CairoCachedSurface* active_bg = theme_service_->GetSurfaceNamed(
+      gfx::CairoCachedSurface* active_bg = theme_service_->GetSurfaceNamed(
           IDR_THEME_TOOLBAR, widget);
-      active_bg->SetSource(cr, -x(), 0);
+      active_bg->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 340 matching lines @@
                            base::i18n::IsRTL() ? gfx::Canvas::TEXT_ALIGN_RIGHT :
                            gfx::Canvas::TEXT_ALIGN_LEFT);
 }
 
 void TabRendererGtk::PaintIcon(GtkWidget* widget, cairo_t* cr) {
   if (loading_animation_.animation_state() != ANIMATION_NONE) {
     PaintLoadingAnimation(widget, cr);
     return;
   }
 
-  CairoCachedSurface* to_display = NULL;
+  gfx::CairoCachedSurface* to_display = NULL;
   if (should_display_crashed_favicon_) {
     to_display = theme_service_->GetSurfaceNamed(IDR_SAD_FAVICON, widget);
   } 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) {
     to_display->SetSource(cr,
+                          widget,
                           favicon_bounds_.x(),
                           favicon_bounds_.y() + favicon_hiding_offset_);
     cairo_paint(cr);
   }
 }
 
 void TabRendererGtk::PaintTabBackground(GtkWidget* widget, cairo_t* cr) {
   if (IsActive()) {
     PaintActiveTabBackground(widget, cr);
   } else {
     PaintInactiveTabBackground(widget, cr);
 
     double throb_value = GetThrobValue();
     if (throb_value > 0) {
       cairo_push_group(cr);
       PaintActiveTabBackground(widget, cr);
       cairo_pop_group_to_source(cr);
       cairo_paint_with_alpha(cr, throb_value);
     }
   }
 }
 
 void TabRendererGtk::DrawTabBackground(
     cairo_t* cr,
     GtkWidget* widget,
-    CairoCachedSurface* tab_bg,
+    gfx::CairoCachedSurface* tab_bg,
     int offset_x,
     int offset_y) {
-  tab_bg->SetSource(cr, -offset_x, -offset_y);
+  tab_bg->SetSource(cr, widget, -offset_x, -offset_y);
   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
 
   // Draw left edge
-  CairoCachedSurface* tab_l_mask =
+  gfx::CairoCachedSurface* tab_l_mask =
       theme_service_->GetSurfaceNamed(IDR_TAB_ALPHA_LEFT, widget);
-  tab_l_mask->MaskSource(cr, 0, 0);
+  tab_l_mask->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
-  CairoCachedSurface* tab_r_mask =
+  gfx::CairoCachedSurface* tab_r_mask =
       theme_service_->GetSurfaceNamed(IDR_TAB_ALPHA_RIGHT, widget);
-  tab_r_mask->MaskSource(cr, width() - tab_active_l_width_, 0);
+  tab_r_mask->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) {
   // Draw left drop shadow
-  CairoCachedSurface* active_image_l =
+  gfx::CairoCachedSurface* active_image_l =
       theme_service_->GetSurfaceNamed(left_idr, widget);
-  active_image_l->SetSource(cr, 0, 0);
+  active_image_l->SetSource(cr, widget, 0, 0);
   cairo_paint(cr);
 
   // Draw the center shadow
-  CairoCachedSurface* active_image_c =
+  gfx::CairoCachedSurface* active_image_c =
       theme_service_->GetSurfaceNamed(center_idr, widget);
-  active_image_c->SetSource(cr, 0, 0);
+  active_image_c->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
-  CairoCachedSurface* active_image_r =
+  gfx::CairoCachedSurface* active_image_r =
       theme_service_->GetSurfaceNamed(right_idr, widget);
-  active_image_r->SetSource(cr, width() - active_image_r->Width(), 0);
+  active_image_r->SetSource(cr, widget, width() - active_image_r->Width(), 0);
   cairo_paint(cr);
 }
 
 void TabRendererGtk::PaintInactiveTabBackground(GtkWidget* widget,
                                                      cairo_t* cr) {
   int theme_id = data_.incognito ?
       IDR_THEME_TAB_BACKGROUND_INCOGNITO : IDR_THEME_TAB_BACKGROUND;
 
-  CairoCachedSurface* tab_bg =
+  gfx::CairoCachedSurface* tab_bg =
       theme_service_->GetSurfaceNamed(theme_id, widget);
 
   // 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) {
-  CairoCachedSurface* tab_bg =
+                                              cairo_t* cr) {
+  gfx::CairoCachedSurface* tab_bg =
       theme_service_->GetSurfaceNamed(IDR_THEME_TOOLBAR, widget);
 
   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) {
+                                           cairo_t* cr) {
   int id = loading_animation_.animation_state() == ANIMATION_WAITING ?
            IDR_THROBBER_WAITING : IDR_THROBBER;
-  CairoCachedSurface* throbber = theme_service_->GetSurfaceNamed(id, widget);
+  gfx::CairoCachedSurface* throbber =
+      theme_service_->GetSurfaceNamed(id, widget);
 
   const int image_size = throbber->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, favicon_bounds_.x() - image_offset,
+  throbber->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 111 matching lines @@
 
   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;
 }