Allow CanvasSkia to bind to an existing SkCanvas.

ui/gfx/canvas_skia_win.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 <limits>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
@@ skipping 263 matching lines @@
       primary->Inset(remainder, 0, 0, 0);
       secondary->Inset(0, 0, primary_width, 0);
       break;
   }
 }
 
 }  // anonymous 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) {
   // Clamp the max amount of text we'll measure to 2K.  When the string is
   // actually drawn, it will be clipped to whatever size box is provided, and
   // the time to do that doesn't depend on the length being clipped off.
   const int kMaxStringLength = 2048 - 1;  // So the trailing \0 fits in 2K.
   string16 clamped_string(text.substr(0, kMaxStringLength));
@@ skipping 25 matching lines @@
   *width = r.right;
   *height = r.bottom;
 }
 
 void CanvasSkia::DrawStringInt(const string16& text,
                                HFONT font,
                                const SkColor& color,
                                int x, int y, int w, int h,
                                int flags) {
   SkRect fclip;
-  if (!getClipBounds(&fclip))
+  if (!canvas_->getClipBounds(&fclip))
     return;
   RECT text_bounds = { x, y, x + w, y + h };
   SkIRect clip;
   fclip.round(&clip);
   if (!clip.intersect(skia::RECTToSkIRect(text_bounds)))
     return;
 
   // Clamp the max amount of text we'll draw to 32K.  There seem to be bugs in
   // DrawText() if you e.g. ask it to character-break a no-whitespace string of
   // length > 43680 (for which it draws nothing), and since we clamped to 2K in
   // SizeStringInt() we're unlikely to be able to display this much anyway.
   const int kMaxStringLength = 32768 - 1;  // So the trailing \0 fits in 32K.
   string16 clamped_string(text.substr(0, kMaxStringLength));
 
   HDC dc;
   HFONT old_font;
   {
-    skia::ScopedPlatformPaint scoped_platform_paint(this);
+    skia::ScopedPlatformPaint scoped_platform_paint(canvas_);
     dc = scoped_platform_paint.GetPlatformSurface();
     SetBkMode(dc, TRANSPARENT);
     old_font = (HFONT)SelectObject(dc, font);
     COLORREF brush_color = RGB(SkColorGetR(color), SkColorGetG(color),
                                SkColorGetB(color));
     SetTextColor(dc, brush_color);
 
     int f = ComputeFormatFlags(flags, clamped_string);
     DoDrawText(dc, clamped_string, &text_bounds, f);
   }
 
   // Restore the old font. This way we don't have to worry if the caller
   // deletes the font and the DC lives longer.
   SelectObject(dc, old_font);
 
   // Windows will have cleared the alpha channel of the text we drew. Assume
   // we're drawing to an opaque surface, or at least the text rect area is
   // opaque.
-  skia::MakeOpaque(this, clip.fLeft, clip.fTop, clip.width(),
+  skia::MakeOpaque(canvas_, clip.fLeft, clip.fTop, clip.width(),
                    clip.height());
 }
 
 void CanvasSkia::DrawStringInt(const string16& text,
                                const gfx::Font& font,
                                const SkColor& color,
                                int x, int y, int w, int h,
                                int flags) {
   DrawStringInt(text, font.GetNativeFont(), color, x, y, w, h, flags);
 }
@@ skipping 44 matching lines @@
   text_canvas.DrawRectInt(0, 0, w + 2, h + 2, bkgnd_paint);
 
   // Draw the text into the temporary buffer. This will have correct
   // ClearType since the background color is the same as the halo color.
   text_canvas.DrawStringInt(text, font, text_color, 1, 1, w, h, flags);
 
   // Windows will have cleared the alpha channel for the pixels it drew. Make it
   // opaque. We have to do this first since pixelShouldGetHalo will check for
   // 0 to see if a pixel has been modified to transparent, and black text that
   // Windows draw will look transparent to it!
-  skia::MakeOpaque(&text_canvas, 0, 0, w + 2, h + 2);
+  skia::MakeOpaque(text_canvas.sk_canvas(), 0, 0, w + 2, h + 2);
 
   uint32_t halo_premul = SkPreMultiplyColor(halo_color);
   SkBitmap& text_bitmap = const_cast<SkBitmap&>(
-      skia::GetTopDevice(text_canvas)->accessBitmap(true));
+      skia::GetTopDevice(*text_canvas.sk_canvas())->accessBitmap(true));
   for (int cur_y = 0; cur_y < h + 2; cur_y++) {
     uint32_t* text_row = text_bitmap.getAddr32(0, cur_y);
     for (int cur_x = 0; cur_x < w + 2; cur_x++) {
       if (text_row[cur_x] == halo_premul) {
         // This pixel was not touched by the text routines. See if it borders
         // a touched pixel in any of the 4 directions (not diagonally).
         if (!pixelShouldGetHalo(text_bitmap, cur_x, cur_y, halo_premul))
           text_row[cur_x] = 0;  // Make transparent.
       } else {
         text_row[cur_x] |= 0xff << SK_A32_SHIFT;  // Make opaque.
@@ skipping 78 matching lines @@
     flags |= TEXT_ALIGN_LEFT;
 
   // Fade in/out about 2.5 characters of the beginning/end of the string.
   // The .5 here is helpful if one of the characters is a space.
   // Use a quarter of the display width if the string is very short.
   int gradient_width = Round(std::min(average_character_width * 2.5,
                                       display_rect.width() / 4.0));
 
   // Move the origin to |display_rect.origin()|. This simplifies all the
   // drawing so that both the source and destination can be (0,0).
-  save(kMatrix_SaveFlag);
+  canvas_->save(SkCanvas::kMatrix_SaveFlag);
   TranslateInt(display_rect.x(), display_rect.y());
 
   gfx::Rect solid_part(gfx::Point(), display_rect.size());
   gfx::Rect head_part;
   gfx::Rect tail_part;
   if (is_truncating_head)
     DivideRect(solid_part, is_rtl ? PrimaryOnRight : PrimaryOnLeft,
                gradient_width, &head_part, &solid_part);
   if (is_truncating_tail)
     DivideRect(solid_part, is_rtl ? PrimaryOnLeft : PrimaryOnRight,
                gradient_width, &tail_part, &solid_part);
 
   // Grow |display_rect| by |offset_x|.
   gfx::Rect text_rect(gfx::Point(), display_rect.size());
   if (!is_rtl)
     text_rect.set_x(text_rect.x() - offset_x);
   text_rect.set_width(text_rect.width() + offset_x);
 
   // Create a temporary bitmap to draw the gradient to.
   scoped_ptr<SkCanvas> gradient_canvas(skia::CreateBitmapCanvas(
       display_rect.width(), display_rect.height(), false));
 
   {
-    skia::ScopedPlatformPaint scoped_platform_paint(this);
+    skia::ScopedPlatformPaint scoped_platform_paint(canvas_);
     HDC hdc = scoped_platform_paint.GetPlatformSurface();
     if (is_truncating_head)
       DrawTextGradientPart(hdc, gradient_canvas.get(), text, color,
                            font.GetNativeFont(), text_rect, head_part, is_rtl,
                            flags);
     if (is_truncating_tail)
       DrawTextGradientPart(hdc, gradient_canvas.get(), text, color,
                            font.GetNativeFont(), text_rect, tail_part, !is_rtl,
                            flags);
   }
 
   // Draw the solid part.
-  save(kClip_SaveFlag);
+  canvas_->save(SkCanvas::kClip_SaveFlag);
   ClipRectInt(solid_part.x(), solid_part.y(),
               solid_part.width(), solid_part.height());
   DrawStringInt(text, font, color,
                 text_rect.x(), text_rect.y(),
                 text_rect.width(), text_rect.height(),
                 flags);
-  restore();
-  restore();
+  canvas_->restore();
+  canvas_->restore();
 }
 
 }  // namespace gfx