skia::PlatformCanvas is being deprecated. Going forward we will use gfx::Canvas wherever we need ...

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 257 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 (!skia_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 = beginPlatformPaint();
+  HDC dc = BeginPlatformPaint();
   SetBkMode(dc, TRANSPARENT);
   HFONT 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);
-  endPlatformPaint();
+  EndPlatformPaint();
 
   // 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.
-  getTopPlatformDevice().makeOpaque(clip.fLeft, clip.fTop,
-                                    clip.width(), clip.height());
+  skia::MakeOpaque(clip, skia_canvas_.get());
 }
 
 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 30 matching lines @@
                                     const SkColor& text_color,
                                     const SkColor& halo_color_in,
                                     int x, int y, int w, int h,
                                     int flags) {
   // Some callers will have semitransparent halo colors, which we don't handle
   // (since the resulting image can have 1-bit transparency only).
   SkColor halo_color = halo_color_in | 0xFF000000;
 
   // Create a temporary buffer filled with the halo color. It must leave room
   // for the 1-pixel border around the text.
-  CanvasSkia text_canvas(w + 2, h + 2, true);
+  CanvasSkia text_canvas;
+  if (!text_canvas.Init(w + 2, h + 2, true))
+    return;
+
   SkPaint bkgnd_paint;
   bkgnd_paint.setColor(halo_color);
   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!
-  text_canvas.getTopPlatformDevice().makeOpaque(0, 0, w + 2, h + 2);
+  skia::MakeOpaque(SkIRect::MakeWH(w + 2, h + 2), text_canvas.skia_canvas());
 
   uint32_t halo_premul = SkPreMultiplyColor(halo_color);
   SkBitmap& text_bitmap = const_cast<SkBitmap&>(
-      text_canvas.getTopPlatformDevice().accessBitmap(true));
+      text_canvas.skia_canvas()->getTopDevice()->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);
+  skia_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,
@@ skipping 11 matching lines @@
   GetObject(font.GetNativeFont(), sizeof(font_info), &font_info);
   font_info.lfQuality = ANTIALIASED_QUALITY;
   base::win::ScopedHFONT gray_scale_font(CreateFontIndirect(&font_info));
 
   // Create a temporary bitmap to draw the gradient to.
   scoped_ptr<skia::BitmapPlatformDevice> gradient_bitmap(
       skia::BitmapPlatformDevice::create(
           display_rect.width(), display_rect.height(), false, NULL));
   DCHECK(gradient_bitmap.get());
 
-  HDC hdc = beginPlatformPaint();
+  HDC hdc = BeginPlatformPaint();
   if (is_truncating_head)
     DrawTextGradientPart(hdc, *gradient_bitmap, text, color, gray_scale_font,
                          text_rect, head_part, is_rtl, flags);
   if (is_truncating_tail)
     DrawTextGradientPart(hdc, *gradient_bitmap, text, color, gray_scale_font,
                          text_rect, tail_part, !is_rtl, flags);
-  endPlatformPaint();
+  EndPlatformPaint();
 
   // Draw the solid part.
-  save(kClip_SaveFlag);
+  skia_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();
+  skia_canvas_->restore();
+  skia_canvas_->restore();
+}
+
+void CanvasSkia::BlitToNativeContext(const Rect& src_rect,
+                                     const Point& dst_origin,
+                                     NativeDrawingContext dst_context) {
+  skia::BitmapPlatformDevice* device =
+      static_cast<skia::BitmapPlatformDevice*>(skia_canvas_->getTopDevice());
+  device->drawToHDC(dst_context, dst_origin.x(), dst_origin.y(),
+                    &src_rect.ToRECT());
 }
 
 }  // namespace gfx
+