Removal of dependencies on PlatformDevice classes.

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 120 matching lines @@
        (f & DT_RIGHT) && base::i18n::StringContainsStrongRTLChars(text))) {
     f |= DT_RTLREADING;
   }
 
   return f;
 }
 
 // Changes the alpha of the given bitmap.
 // If |fade_to_right| is true then the rect fades from opaque to clear,
 // otherwise the rect fades from clear to opaque.
-void FadeBitmapRect(skia::BitmapPlatformDevice& bmp_device,
+void FadeBitmapRect(SkDevice& bmp_device,
                     const gfx::Rect& rect,
                     bool fade_to_right) {
   SkBitmap bmp = bmp_device.accessBitmap(true);
   DCHECK_EQ(SkBitmap::kARGB_8888_Config, bmp.config());
   SkAutoLockPixels lock(bmp);
   float total_width = static_cast<float>(rect.width());
 
   for (int x = rect.x(); x < rect.right(); x++) {
     float cur_width = static_cast<float>(fade_to_right ?
         rect.right() - x :  x - rect.x());
     // We want the fade effect to go from 0.2 to 1.0.
     float alpha_percent = ((cur_width / total_width) * 0.8f) + 0.2f;
 
     for (int y = rect.y(); y < rect.bottom(); y++) {
       SkColor color = bmp.getColor(x, y);
       SkAlpha alpha = static_cast<SkAlpha>(SkColorGetA(color) * alpha_percent);
       *bmp.getAddr32(x, y) = SkPreMultiplyColor(SkColorSetA(color, alpha));
     }
   }
 }
 
 // DrawText() doesn't support alpha channels. To create a transparent background
 // this function draws black on white. It then uses the intensity of black
 // to determine how much alpha to use. The text is drawn in |gfx_text_rect| and
 // clipped to |gfx_draw_rect|.
-void DrawTextAndClearBackground(skia::BitmapPlatformDevice& bmp_device,
+void DrawTextAndClearBackground(SkDevice& bmp_device,
                                 HFONT font,
                                 COLORREF text_color,
                                 const string16& text,
                                 int flags,
                                 const gfx::Rect& gfx_text_rect,
                                 const gfx::Rect& gfx_draw_rect) {
-  HDC hdc = bmp_device.BeginPlatformPaint();
+  HDC hdc = skia::BeginPlatformPaint(&bmp_device);
 
   // Clear the background by filling with white.
   HBRUSH fill_brush = static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));
   HANDLE old_brush = SelectObject(hdc, fill_brush);
   RECT draw_rect = gfx_draw_rect.ToRECT();
   FillRect(hdc, &draw_rect, fill_brush);
   SelectObject(hdc, old_brush);
 
   // Set black text with trasparent background.
   SetBkMode(hdc, TRANSPARENT);
@@ skipping 26 matching lines @@
       // using SkBitmap::getColor() won't work here.
       SkColor color = *bmp.getAddr32(x, y);
       // Calculate the alpha using the luminance. Since this is black text
       // on a white background the luminosity must be inverted.
       BYTE alpha = 0xFF - color_utils::GetLuminanceForColor(color);
       *bmp.getAddr32(x, y) = SkPreMultiplyColor(
           SkColorSetARGB(alpha, text_color_r, text_color_b, text_color_g));
     }
   }
 
-  bmp_device.EndPlatformPaint();
+  skia::EndPlatformPaint(&bmp_device);
 }
 
 // Draws the given text with a fade out gradient. |bmp_device| is a bitmap
 // that is used to temporary drawing. The text is drawn in |text_rect| and
 // clipped to |draw_rect|.
 void DrawTextGradientPart(HDC hdc,
-                          skia::BitmapPlatformDevice& bmp_device,
+                          SkDevice& bmp_device,
                           const string16& text,
                           const SkColor& color,
                           HFONT font,
                           const gfx::Rect& text_rect,
                           const gfx::Rect& draw_rect,
                           bool fade_to_right,
                           int flags) {
   DrawTextAndClearBackground(bmp_device, font, skia::SkColorToCOLORREF(color),
                              text, flags, text_rect, draw_rect);
   FadeBitmapRect(bmp_device, draw_rect, fade_to_right);
   BLENDFUNCTION blend = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
 
-  HDC bmp_hdc = bmp_device.BeginPlatformPaint();
+  HDC bmp_hdc = skia::BeginPlatformPaint(&bmp_device);
   AlphaBlend(hdc, draw_rect.x(), draw_rect.y(), draw_rect.width(),
              draw_rect.height(), bmp_hdc, draw_rect.x(), draw_rect.y(),
              draw_rect.width(), draw_rect.height(), blend);
-  bmp_device.EndPlatformPaint();
+  skia::EndPlatformPaint(&bmp_device);
 }
 
 enum PrimarySide {
   PrimaryOnLeft,
   PrimaryOnRight,
 };
 
 // Divides |rect| horizontally into a |primary| of width |primary_width| and a
 // |secondary| taking up the remainder.
 void DivideRect(const gfx::Rect& rect,
@@ skipping 84 matching lines @@
   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 = skia::BeginPlatformPaint(this);
   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();
+  skia::EndPlatformPaint(this);
 
   // 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(&getTopDevice(), 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 43 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!
-  text_canvas.getTopPlatformDevice().makeOpaque(0, 0, w + 2, h + 2);
+  skia::MakeOpaque(&text_canvas.getTopDevice(), 0, 0, w + 2, h + 2);
 
   uint32_t halo_premul = SkPreMultiplyColor(halo_color);
   SkBitmap& text_bitmap = const_cast<SkBitmap&>(
-      text_canvas.getTopPlatformDevice().accessBitmap(true));
+      text_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 98 matching lines @@
     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<skia::BitmapPlatformDevice> gradient_bitmap(
+  scoped_ptr<SkDevice> gradient_bitmap(
       skia::BitmapPlatformDevice::create(
           display_rect.width(), display_rect.height(), false, NULL));
   DCHECK(gradient_bitmap.get());
 
-  HDC hdc = beginPlatformPaint();
+  HDC hdc = skia::BeginPlatformPaint(this);
   if (is_truncating_head)
     DrawTextGradientPart(hdc, *gradient_bitmap, text, color,
                          font.GetNativeFont(), text_rect, head_part, is_rtl,
                          flags);
   if (is_truncating_tail)
     DrawTextGradientPart(hdc, *gradient_bitmap, text, color,
                          font.GetNativeFont(), text_rect, tail_part, !is_rtl,
                          flags);
-  endPlatformPaint();
+  skia::EndPlatformPaint(this);
 
   // Draw the solid part.
   save(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();
 }
 
 }  // namespace gfx