GTK: Remove UseSurface() calls in browser toolbar.

chrome/browser/ui/gtk/browser_toolbar_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/browser_toolbar_gtk.h"
 
 #include <X11/XF86keysym.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
@@ skipping 34 matching lines @@
 #include "content/browser/user_metrics.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/accelerators/accelerator_gtk.h"
 #include "ui/base/dragdrop/gtk_dnd_util.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/gtk_util.h"
 #include "ui/gfx/image/cairo_cached_surface.h"
 #include "ui/gfx/skbitmap_operations.h"
 
 namespace {
 
 // Padding on left and right of the left toolbar buttons (back, forward, reload,
 // etc.).
 const int kToolbarLeftAreaPadding = 4;
@@ skipping 432 matching lines @@
   gfx::Rect left(allocation.x - kShadowThickness,
                  allocation.y - kShadowThickness,
                  kCornerWidth,
                  allocation.height + kShadowThickness);
 
   if (window_->ShouldDrawContentDropShadow()) {
     // Leave room to draw rounded corners.
     area = area.Subtract(right).Subtract(left);
   }
 
-  gfx::CairoCachedSurface* background = theme_service_->GetSurfaceNamed(
-      IDR_THEME_TOOLBAR, widget);
-  background->SetSource(cr, widget, tabstrip_origin.x(), tabstrip_origin.y());
+  const gfx::Image* background =
+      theme_service_->GetImageNamed(IDR_THEME_TOOLBAR);
+  background->ToCairo()->SetSource(
+      cr, widget, tabstrip_origin.x(), tabstrip_origin.y());
   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
   cairo_rectangle(cr, area.x(), area.y(), area.width(), area.height());
   cairo_fill(cr);
 
   if (!window_->ShouldDrawContentDropShadow()) {
     // The rest of this function is for rounded corners. Our work is done here.
     cairo_destroy(cr);
     return FALSE;
   }
 
   bool draw_left_corner = left.Intersects(gfx::Rect(e->area));
   bool draw_right_corner = right.Intersects(gfx::Rect(e->area));
 
   if (draw_left_corner || draw_right_corner) {
     // Create a mask which is composed of the left and/or right corners.
     cairo_surface_t* target = cairo_surface_create_similar(
         cairo_get_target(cr),
         CAIRO_CONTENT_COLOR_ALPHA,
         allocation.x + allocation.width,
         allocation.y + allocation.height);
     cairo_t* copy_cr = cairo_create(target);
 
+    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+
     cairo_set_operator(copy_cr, CAIRO_OPERATOR_SOURCE);
     if (draw_left_corner) {
-      gfx::CairoCachedSurface* left_corner = theme_service_->GetSurfaceNamed(
-          IDR_CONTENT_TOP_LEFT_CORNER_MASK, widget);
-      left_corner->SetSource(copy_cr, widget, left.x(), left.y());
+      rb.GetNativeImageNamed(IDR_CONTENT_TOP_LEFT_CORNER_MASK).ToCairo()->
+          SetSource(copy_cr, widget, left.x(), left.y());
       cairo_paint(copy_cr);
     }
     if (draw_right_corner) {
-      gfx::CairoCachedSurface* right_corner = theme_service_->GetSurfaceNamed(
-          IDR_CONTENT_TOP_RIGHT_CORNER_MASK, widget);
-      right_corner->SetSource(copy_cr, widget, right.x(), right.y());
+      rb.GetNativeImageNamed(IDR_CONTENT_TOP_RIGHT_CORNER_MASK).ToCairo()->
+          SetSource(copy_cr, widget, right.x(), right.y());
       // We fill a path rather than just painting because we don't want to
       // overwrite the left corner.
       cairo_rectangle(copy_cr, right.x(), right.y(),
                       right.width(), right.height());
       cairo_fill(copy_cr);
     }
 
     // Draw the background. CAIRO_OPERATOR_IN uses the existing pixel data as
     // an alpha mask.
-    background->SetSource(copy_cr, widget,
-                          tabstrip_origin.x(), tabstrip_origin.y());
+    background->ToCairo()->SetSource(copy_cr, widget,
+                                     tabstrip_origin.x(), tabstrip_origin.y());
     cairo_set_operator(copy_cr, CAIRO_OPERATOR_IN);
     cairo_pattern_set_extend(cairo_get_source(copy_cr), CAIRO_EXTEND_REPEAT);
     cairo_paint(copy_cr);
     cairo_destroy(copy_cr);
 
     // Copy the temporary surface to the screen.
     cairo_set_source_surface(cr, target, 0, 0);
     cairo_paint(cr);
     cairo_surface_destroy(target);
   }
@@ skipping 106 matching lines @@
   const SkBitmap* badge = theme_service_->GetBitmapNamed(resource_id);
   gfx::CanvasSkiaPaint canvas(expose, false);
   int x_offset = base::i18n::IsRTL() ? 0 : allocation.width - badge->width();
   int y_offset = 0;
   canvas.DrawBitmapInt(*badge,
                        allocation.x + x_offset,
                        allocation.y + y_offset);
 
   return FALSE;
 }