Allow CanvasSkia to bind to an existing SkCanvas.

ui/gfx/canvas_skia_linux.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 "ui/gfx/canvas_skia.h"
 
 #include <algorithm>
 
 #include <cairo/cairo.h>
 #include <pango/pango.h>
@@ skipping 75 matching lines @@
       canvas_(canvas),
       cr_(NULL),
       layout_(NULL),
       text_x_(bounds.x()),
       text_y_(bounds.y()),
       text_width_(0),
       text_height_(0),
       text_direction_(base::i18n::GetFirstStrongCharacterDirection(text)) {
   DCHECK(!bounds_.IsEmpty());
 
-  cr_ = skia::BeginPlatformPaint(canvas_);
+  cr_ = skia::BeginPlatformPaint(canvas_->sk_canvas());
   layout_ = pango_cairo_create_layout(cr_);
 
   gfx::SetupPangoLayout(
       layout_, text, font, bounds_.width(), text_direction_, flags_);
 
   pango_layout_set_height(layout_, bounds_.height() * PANGO_SCALE);
 
   cairo_save(cr_);
 
   cairo_rectangle(cr_, clip.x(), clip.y(), clip.width(), clip.height());
   cairo_clip(cr_);
 
   pango_layout_get_pixel_size(layout_, &text_width_, &text_height_);
 
   if (flags_ & gfx::Canvas::TEXT_VALIGN_TOP) {
     // Cairo should draw from the top left corner already.
   } else if (flags_ & gfx::Canvas::TEXT_VALIGN_BOTTOM) {
     text_y_ += (bounds.height() - text_height_);
   } else {
     // Vertically centered.
     text_y_ += ((bounds.height() - text_height_) / 2);
   }
 }
 
 DrawStringContext::~DrawStringContext() {
   cairo_restore(cr_);
-  skia::EndPlatformPaint(canvas_);
+  skia::EndPlatformPaint(canvas_->sk_canvas());
   g_object_unref(layout_);
   // NOTE: BeginPlatformPaint returned its surface, we shouldn't destroy it.
 }
 
 void DrawStringContext::Draw(const SkColor& text_color) {
   double r = SkColorGetR(text_color) / 255.0,
          g = SkColorGetG(text_color) / 255.0,
          b = SkColorGetB(text_color) / 255.0,
          a = SkColorGetA(text_color) / 255.0;
 
@@ skipping 35 matching lines @@
   cairo_restore(cr_);
 }
 
 void DrawStringContext::DrawWithHalo(const SkColor& text_color,
                                      const SkColor& halo_color) {
   gfx::CanvasSkia text_canvas(bounds_.width() + 2, bounds_.height() + 2, false);
   text_canvas.FillRectInt(static_cast<SkColor>(0),
       0, 0, bounds_.width() + 2, bounds_.height() + 2);
 
   {
-    skia::ScopedPlatformPaint scoped_platform_paint(&text_canvas);
+    skia::ScopedPlatformPaint scoped_platform_paint(text_canvas.sk_canvas());
     cairo_t* text_cr = scoped_platform_paint.GetPlatformSurface();
 
     // TODO: The current approach (stroking the text path to generate the halo
     // and then filling it for the main text) won't work if |text_color| is
     // non-opaque.  If we need to do this at some later point,
     // http://lists.freedesktop.org/archives/cairo/2004-September/001829.html
     // suggests "do[ing] the stroke and fill with opaque paint onto an
     // intermediate surface, and then us[ing] cairo_show_surface to composite
     // that intermediate result with the desired compositing operator."
     cairo_set_source_rgba(text_cr,
@@ skipping 19 matching lines @@
                           SkColorGetG(text_color) / 255.0,
                           SkColorGetB(text_color) / 255.0,
                           SkColorGetA(text_color) / 255.0);
     cairo_fill(text_cr);
 
     if (font_.GetStyle() & gfx::Font::UNDERLINED)
       DrawUnderline(text_cr, 0.0);
   }
 
   const SkBitmap& text_bitmap = const_cast<SkBitmap&>(
-      skia::GetTopDevice(text_canvas)->accessBitmap(false));
+      skia::GetTopDevice(*text_canvas.sk_canvas())->accessBitmap(false));
   canvas_->DrawBitmapInt(text_bitmap, text_x_ - 1, text_y_ - 1);
 }
 
 void DrawStringContext::DrawUnderline(cairo_t* cr, double extra_edge_width) {
   gfx::PlatformFontPango* platform_font =
       static_cast<gfx::PlatformFontPango*>(font_.platform_font());
   const double underline_y =
       static_cast<double>(text_y_) + text_height_ +
       platform_font->underline_position();
   cairo_set_line_width(
       cr, platform_font->underline_thickness() + 2 * extra_edge_width);
   cairo_move_to(cr, text_x_ - extra_edge_width, underline_y);
   cairo_line_to(cr, text_x_ + text_width_ + extra_edge_width, underline_y);
   cairo_stroke(cr);
 }
 
 }  // namespace
 
 namespace gfx {
 
-CanvasSkia::CanvasSkia(int width, int height, bool is_opaque)
-    : skia::PlatformCanvas(width, height, is_opaque) {
-}
-
-CanvasSkia::CanvasSkia() : skia::PlatformCanvas() {
-}
-
-CanvasSkia::~CanvasSkia() {
-}
-
 // static
 void CanvasSkia::SizeStringInt(const string16& text,
                                const gfx::Font& font,
                                int* width, int* height,
                                int flags) {
   int org_width = *width;
   cairo_surface_t* surface =
       cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0);
   cairo_t* cr = cairo_create(surface);
   PangoLayout* layout = pango_cairo_create_layout(cr);
@@ skipping 71 matching lines @@
   context.Draw(color);
 }
 
 #if defined(TOOLKIT_USES_GTK)
 void CanvasSkia::DrawGdkPixbuf(GdkPixbuf* pixbuf, int x, int y) {
   if (!pixbuf) {
     NOTREACHED();
     return;
   }
 
-  skia::ScopedPlatformPaint scoped_platform_paint(this);
+  skia::ScopedPlatformPaint scoped_platform_paint(canvas_);
   cairo_t* cr = scoped_platform_paint.GetPlatformSurface();
   gdk_cairo_set_source_pixbuf(cr, pixbuf, x, y);
   cairo_paint(cr);
 }
 #endif  // defined(TOOLKIT_USES_GTK)
 
 ui::TextureID CanvasSkia::GetTextureID() {
   // TODO(wjmaclean)
   return 0;
 }
 
 }  // namespace gfx