ChromeCanvas->gfx::Canvas

app/gfx/canvas_win.cc

 // Copyright (c) 2006-2008 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 "app/gfx/chrome_canvas.h"
+#include "app/gfx/canvas.h"
 
 #include <limits>
 
-#include "app/gfx/chrome_font.h"
+#include "app/gfx/font.h"
 #include "app/l10n_util.h"
 #include "base/gfx/rect.h"
 #include "third_party/skia/include/core/SkShader.h"
 
 namespace {
 
 // We make sure that LTR text we draw in an RTL context is modified
 // appropriately to make sure it maintains it LTR orientation.
 void DoDrawText(HDC hdc, const std::wstring& text,
                 RECT* text_bounds, int flags) {
   std::wstring localized_text;
   const wchar_t* string_ptr = text.c_str();
   int string_size = static_cast<int>(text.length());
   // Only adjust string directionality if both of the following are true:
   // 1. The current locale is RTL.
   // 2. The string itself has RTL directionality.
   if (flags & DT_RTLREADING) {
     if (l10n_util::AdjustStringForLocaleDirection(text, &localized_text)) {
       string_ptr = localized_text.c_str();
       string_size = static_cast<int>(localized_text.length());
     }
   }
 
   DrawText(hdc, string_ptr, string_size, text_bounds, flags);
 }
 
-// Compute the windows flags necessary to implement the provided text
-// ChromeCanvas flags.
+// Compute the windows flags necessary to implement the provided text Canvas
+// flags.
 int ComputeFormatFlags(int flags, const std::wstring& text) {
   int f = 0;
 
   // Setting the text alignment explicitly in case it hasn't already been set.
   // This will make sure that we don't align text to the left on RTL locales
   // just because no alignment flag was passed to DrawStringInt().
-  if (!(flags & (ChromeCanvas::TEXT_ALIGN_CENTER |
-                 ChromeCanvas::TEXT_ALIGN_RIGHT |
-                 ChromeCanvas::TEXT_ALIGN_LEFT))) {
+  if (!(flags & (gfx::Canvas::TEXT_ALIGN_CENTER |
+                 gfx::Canvas::TEXT_ALIGN_RIGHT |
+                 gfx::Canvas::TEXT_ALIGN_LEFT))) {
     flags |= l10n_util::DefaultCanvasTextAlignment();
   }
 
-  if (flags & ChromeCanvas::HIDE_PREFIX)
+  if (flags & gfx::Canvas::HIDE_PREFIX)
     f |= DT_HIDEPREFIX;
-  else if ((flags & ChromeCanvas::SHOW_PREFIX) == 0)
+  else if ((flags & gfx::Canvas::SHOW_PREFIX) == 0)
     f |= DT_NOPREFIX;
 
-  if (flags & ChromeCanvas::MULTI_LINE) {
+  if (flags & gfx::Canvas::MULTI_LINE) {
     f |= DT_WORDBREAK;
-    if (flags & ChromeCanvas::CHARACTER_BREAK)
+    if (flags & gfx::Canvas::CHARACTER_BREAK)
       f |= DT_EDITCONTROL;
   } else {
     f |= DT_SINGLELINE | DT_VCENTER;
-    if (!(flags & ChromeCanvas::NO_ELLIPSIS))
+    if (!(flags & gfx::Canvas::NO_ELLIPSIS))
       f |= DT_END_ELLIPSIS;
   }
 
   // vertical alignment
-  if (flags & ChromeCanvas::TEXT_VALIGN_TOP)
+  if (flags & gfx::Canvas::TEXT_VALIGN_TOP)
     f |= DT_TOP;
-  else if (flags & ChromeCanvas::TEXT_VALIGN_BOTTOM)
+  else if (flags & gfx::Canvas::TEXT_VALIGN_BOTTOM)
     f |= DT_BOTTOM;
   else
     f |= DT_VCENTER;
 
   // horizontal alignment
-  if (flags & ChromeCanvas::TEXT_ALIGN_CENTER)
+  if (flags & gfx::Canvas::TEXT_ALIGN_CENTER)
     f |= DT_CENTER;
-  else if (flags & ChromeCanvas::TEXT_ALIGN_RIGHT)
+  else if (flags & gfx::Canvas::TEXT_ALIGN_RIGHT)
     f |= DT_RIGHT;
   else
     f |= DT_LEFT;
 
   // In order to make sure RTL/BiDi strings are rendered correctly, we must
   // pass the flag DT_RTLREADING to DrawText (when the locale's language is
   // a right-to-left language) so that Windows does the right thing.
   //
   // In addition to correctly displaying text containing both RTL and LTR
   // elements (for example, a string containing a telephone number within a
@@ skipping 23 matching lines @@
       (f & DT_RIGHT)) {
     if (l10n_util::StringContainsStrongRTLChars(text)) {
       f |= DT_RTLREADING;
     }
   }
   return f;
 }
 
 }  // anonymous namespace
 
-ChromeCanvas::ChromeCanvas(int width, int height, bool is_opaque)
+namespace gfx {
+
+Canvas::Canvas(int width, int height, bool is_opaque)
     : skia::PlatformCanvasWin(width, height, is_opaque) {
 }
 
-ChromeCanvas::ChromeCanvas() : skia::PlatformCanvasWin() {
+Canvas::Canvas() : skia::PlatformCanvasWin() {
 }
 
-ChromeCanvas::~ChromeCanvas() {
+Canvas::~Canvas() {
 }
 
 // static
-void ChromeCanvas::SizeStringInt(const std::wstring& text,
-                                 const gfx::Font& font,
-                                 int *width, int *height, int flags) {
+void Canvas::SizeStringInt(const std::wstring& text,
+                           const gfx::Font& font,
+                           int *width, int *height, int flags) {
   HDC dc = GetDC(NULL);
   HFONT old_font = static_cast<HFONT>(SelectObject(dc, font.hfont()));
   RECT b;
   b.left = 0;
   b.top = 0;
   b.right = *width;
   if (b.right == 0 && !text.empty()) {
     // Width needs to be at least 1 or else DoDrawText will not resize it.
     b.right = 1;
   }
   b.bottom = *height;
   DoDrawText(dc, text, &b, ComputeFormatFlags(flags, text) | DT_CALCRECT);
 
   // 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);
   *width = b.right;
   *height = b.bottom;
 
   ReleaseDC(NULL, dc);
 }
 
-void ChromeCanvas::DrawStringInt(const std::wstring& text, HFONT font,
-                                 const SkColor& color, int x, int y, int w,
-                                 int h, int flags) {
+void Canvas::DrawStringInt(const std::wstring& text, HFONT font,
+                           const SkColor& color, int x, int y, int w, int h,
+                           int flags) {
   if (!IntersectsClipRectInt(x, y, w, h))
     return;
 
   RECT text_bounds = { x, y, x + w, y + h };
   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, text);
   DoDrawText(dc, text, &text_bounds, f);
   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(x, y, w, h);
 }
 
-void ChromeCanvas::DrawStringInt(const std::wstring& text,
-                                 const gfx::Font& font,
-                                 const SkColor& color,
-                                 int x, int y, int w, int h, int flags) {
+void Canvas::DrawStringInt(const std::wstring& text,
+                           const gfx::Font& font,
+                           const SkColor& color,
+                           int x, int y, int w, int h, int flags) {
   DrawStringInt(text, font.hfont(), color, x, y, w, h, flags);
 }
 
 // Checks each pixel immediately adjacent to the given pixel in the bitmap. If
 // any of them are not the halo color, returns true. This defines the halo of
 // pixels that will appear around the text. Note that we have to check each
 // pixel against both the halo color and transparent since DrawStringWithHalo
 // will modify the bitmap as it goes, and clears pixels shouldn't count as
 // changed.
 static bool pixelShouldGetHalo(const SkBitmap& bitmap, int x, int y,
@@ skipping 10 matching lines @@
       *bitmap.getAddr32(x, y - 1) != halo_color &&
       *bitmap.getAddr32(x, y - 1) != 0)
     return true;  // Touched pixel above.
   if (y < bitmap.height() - 1 &&
       *bitmap.getAddr32(x, y + 1) != halo_color &&
       *bitmap.getAddr32(x, y + 1) != 0)
     return true;  // Touched pixel below.
   return false;
 }
 
-void ChromeCanvas::DrawStringWithHalo(const std::wstring& text,
-                                      const gfx::Font& font,
-                                      const SkColor& text_color,
-                                      const SkColor& halo_color_in,
-                                      int x, int y, int w, int h,
-                                      int flags) {
+void Canvas::DrawStringWithHalo(const std::wstring& text,
+                                const gfx::Font& font,
+                                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.
-  ChromeCanvas text_canvas(w + 2, h + 2, true);
+  Canvas text_canvas(w + 2, h + 2, true);
   SkPaint bkgnd_paint;
   bkgnd_paint.setColor(halo_color);
   text_canvas.FillRectInt(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
@@ skipping 14 matching lines @@
           text_row[cur_x] = 0;  // Make transparent.
       } else {
         text_row[cur_x] |= 0xff << SK_A32_SHIFT;  // Make opaque.
       }
     }
   }
 
   // Draw the halo bitmap with blur.
   drawBitmap(text_bitmap, SkIntToScalar(x - 1), SkIntToScalar(y - 1));
 }
+
+}  // namespace gfx