ui/gfx: Rename canvas_skia_skia to just canvas_skia.

ui/gfx/canvas_skia_skia.cc

Index: ui/gfx/canvas_skia_skia.cc
diff --git a/ui/gfx/canvas_skia_skia.cc b/ui/gfx/canvas_skia_skia.cc
deleted file mode 100644
index a7af081efbbb2451e646b81a3ceb27a8d333a9f3..0000000000000000000000000000000000000000
--- a/ui/gfx/canvas_skia_skia.cc
+++ /dev/null
@@ -1,422 +0,0 @@
-// Copyright (c) 2012 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.h"
-
-#include "base/i18n/rtl.h"
-#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "ui/base/range/range.h"
-#include "ui/base/text/text_elider.h"
-#include "ui/gfx/font.h"
-#include "ui/gfx/font_list.h"
-#include "ui/gfx/rect.h"
-#include "ui/gfx/render_text.h"
-#include "ui/gfx/skia_util.h"
-
-namespace {
-
-// Based on |flags| and |text| content, returns whether text should be
-// rendered right-to-left.
-bool IsTextRTL(int flags, const string16& text) {
-  if (flags & gfx::Canvas::FORCE_RTL_DIRECTIONALITY)
-    return true;
-  if (flags & gfx::Canvas::FORCE_LTR_DIRECTIONALITY)
-    return false;
-  return base::i18n::IsRTL() && base::i18n::StringContainsStrongRTLChars(text);
-}
-
-// 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 cleared pixels shouldn't count as
-// changed.
-bool PixelShouldGetHalo(const SkBitmap& bitmap,
-                        int x, int y,
-                        SkColor halo_color) {
-  if (x > 0 &&
-      *bitmap.getAddr32(x - 1, y) != halo_color &&
-      *bitmap.getAddr32(x - 1, y) != 0)
-    return true;  // Touched pixel to the left.
-  if (x < bitmap.width() - 1 &&
-      *bitmap.getAddr32(x + 1, y) != halo_color &&
-      *bitmap.getAddr32(x + 1, y) != 0)
-    return true;  // Touched pixel to the right.
-  if (y > 0 &&
-      *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;
-}
-
-// Apply vertical alignment per |flags|. Returns y-coordinate delta.
-int VAlignText(const gfx::Font& font,
-               int line_count,
-               int flags,
-               int available_height) {
-  const int text_size = font.GetFontSize();
-
-  if (flags & gfx::Canvas::TEXT_VALIGN_TOP)
-    return text_size;
-
-  if (flags & gfx::Canvas::TEXT_VALIGN_BOTTOM) {
-    // Note: The -1 was chosen empirically to match the existing GDI code.
-    int offset = available_height + text_size - font.GetHeight() - 1;
-    if (line_count > 1)
-      offset -= (line_count * text_size);
-    return offset;
-  }
-
-  // Default case: TEXT_VALIGN_MIDDLE.
-  // Note: The +1 below and the -2 further down were chosen empirically to match
-  // the alignment and rounding in the existing GDI code.
-  int double_offset = available_height + text_size + 1;
-  if (line_count > 1)
-    double_offset -= (line_count * text_size);
-  return double_offset / 2 - 2;
-}
-
-// Strips accelerator character prefixes in |text| if needed, based on |flags|.
-// Returns a range in |text| to underline or ui::Range::InvalidRange() if
-// underlining is not needed.
-ui::Range StripAcceleratorChars(int flags, string16* text) {
-  if (flags & (gfx::Canvas::SHOW_PREFIX | gfx::Canvas::HIDE_PREFIX)) {
-    int char_pos = -1;
-    int char_span = 0;
-    *text = gfx::RemoveAcceleratorChar(*text, '&', &char_pos, &char_span);
-    if ((flags & gfx::Canvas::SHOW_PREFIX) && char_pos != -1)
-      return ui::Range(char_pos, char_pos + char_span);
-  }
-  return ui::Range::InvalidRange();
-}
-
-// Elides |text| and adjusts |range| appropriately. If eliding causes |range|
-// to no longer point to the same character in |text|, |range| is made invalid.
-void ElideTextAndAdjustRange(const gfx::Font& font,
-                             int width,
-                             string16* text,
-                             ui::Range* range) {
-  const char16 start_char = (range->IsValid() ? text->at(range->start()) : 0);
-  *text = ui::ElideText(*text, font, width, ui::ELIDE_AT_END);
-  if (!range->IsValid())
-    return;
-  if (range->start() >= text->length() ||
-      text->at(range->start()) != start_char) {
-    *range = ui::Range::InvalidRange();
-  }
-}
-
-// Updates |render_text| from the specified parameters.
-void UpdateRenderText(const gfx::Rect& rect,
-                      const string16& text,
-                      const gfx::Font& font,
-                      int flags,
-                      SkColor color,
-                      gfx::RenderText* render_text) {
-  render_text->SetFontList(gfx::FontList(font));
-  render_text->SetText(text);
-  render_text->SetCursorEnabled(false);
-
-  gfx::Rect display_rect = rect;
-  display_rect.Offset(0, -font.GetFontSize());
-  display_rect.set_height(font.GetHeight());
-  render_text->SetDisplayRect(display_rect);
-
-  if (flags & gfx::Canvas::TEXT_ALIGN_RIGHT)
-    render_text->SetHorizontalAlignment(gfx::ALIGN_RIGHT);
-  else if (flags & gfx::Canvas::TEXT_ALIGN_CENTER)
-    render_text->SetHorizontalAlignment(gfx::ALIGN_CENTER);
-  else
-    render_text->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-
-  if (flags & gfx::Canvas::NO_SUBPIXEL_RENDERING)
-    render_text->set_background_is_transparent(true);
-
-  gfx::StyleRange style;
-  style.foreground = color;
-  style.font_style = font.GetStyle();
-  if (font.GetStyle() & gfx::Font::UNDERLINED)
-    style.underline = true;
-  render_text->set_default_style(style);
-  render_text->ApplyDefaultStyle();
-}
-
-// Adds an underline style to |render_text| over |range|.
-void ApplyUnderlineStyle(const ui::Range& range, gfx::RenderText* render_text) {
-  gfx::StyleRange style = render_text->default_style();
-  if (range.IsValid() && !style.underline) {
-    style.range = range;
-    style.underline = true;
-    render_text->ApplyStyleRange(style);
-  }
-}
-
-// Returns updated |flags| to match platform-specific expected behavior.
-int AdjustPlatformSpecificFlags(const string16& text, int flags) {
-#if defined(OS_LINUX)
-  // TODO(asvitkine): On Linux, NO_ELLIPSIS really means MULTI_LINE.
-  //                  http://crbug.com/107357
-  if (flags & gfx::Canvas::NO_ELLIPSIS)
-    flags |= gfx::Canvas::MULTI_LINE;
-
-  // TODO(asvitkine): ash/tooltips/tooltip_controller.cc adds \n's to the string
-  //                  without passing MULTI_LINE.
-  if (text.find('\n') != string16::npos)
-    flags |= gfx::Canvas::MULTI_LINE;
-#endif
-
-  return flags;
-}
-
-}  // anonymous namespace
-
-namespace gfx {
-
-// static
-void Canvas::SizeStringInt(const string16& text,
-                           const gfx::Font& font,
-                           int* width, int* height,
-                           int flags) {
-  DCHECK_GE(*width, 0);
-  DCHECK_GE(*height, 0);
-
-  flags = AdjustPlatformSpecificFlags(text, flags);
-  if ((flags & MULTI_LINE) && *width != 0) {
-    ui::WordWrapBehavior wrap_behavior = ui::TRUNCATE_LONG_WORDS;
-    if (flags & CHARACTER_BREAK)
-      wrap_behavior = ui::WRAP_LONG_WORDS;
-    else if (!(flags & NO_ELLIPSIS))
-      wrap_behavior = ui::ELIDE_LONG_WORDS;
-
-    gfx::Rect rect(*width, INT_MAX);
-    std::vector<string16> strings;
-    ui::ElideRectangleText(text, font, rect.width(), rect.height(),
-                           wrap_behavior, &strings);
-    scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
-    UpdateRenderText(rect, string16(), font, flags, 0, render_text.get());
-
-    int h = 0;
-    int w = 0;
-    for (size_t i = 0; i < strings.size(); ++i) {
-      StripAcceleratorChars(flags, &strings[i]);
-      render_text->SetText(strings[i]);
-      w = std::max(w, render_text->GetStringSize().width());
-      h += font.GetHeight();
-    }
-    *width = w;
-    *height = h;
-  } else {
-    // If the string is too long, the call by |RenderTextWin| to |ScriptShape()|
-    // will inexplicably fail with result E_INVALIDARG. Guard against this.
-    const size_t kMaxRenderTextLength = 5000;
-    if (text.length() >= kMaxRenderTextLength) {
-      *width = text.length() * font.GetAverageCharacterWidth();
-    } else {
-      scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
-      gfx::Rect rect(*width, *height);
-      string16 adjusted_text = text;
-      StripAcceleratorChars(flags, &adjusted_text);
-      UpdateRenderText(rect, adjusted_text, font, flags, 0, render_text.get());
-      *width = render_text->GetStringSize().width();
-    }
-    *height = font.GetHeight();
-  }
-}
-
-void Canvas::DrawStringInt(const string16& text,
-                           const gfx::Font& font,
-                           const SkColor& color,
-                           int x, int y, int w, int h,
-                           int flags) {
-  if (!IntersectsClipRectInt(x, y, w, h))
-    return;
-
-  flags = AdjustPlatformSpecificFlags(text, flags);
-
-  // TODO(asvitkine): On Windows, MULTI_LINE implies top alignment.
-  //                  http://crbug.com/107357
-  if (flags & MULTI_LINE) {
-    flags &= ~(TEXT_VALIGN_MIDDLE | TEXT_VALIGN_BOTTOM);
-    flags |= TEXT_VALIGN_TOP;
-  }
-
-  gfx::Rect rect(x, y, w, h);
-  canvas_->save(SkCanvas::kClip_SaveFlag);
-  ClipRect(rect);
-
-  string16 adjusted_text = text;
-
-#if defined(OS_WIN)
-  if (IsTextRTL(flags, adjusted_text))
-    base::i18n::AdjustStringForLocaleDirection(&adjusted_text);
-#endif
-
-  scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
-
-  if (flags & MULTI_LINE) {
-    ui::WordWrapBehavior wrap_behavior = ui::IGNORE_LONG_WORDS;
-    if (flags & CHARACTER_BREAK)
-      wrap_behavior = ui::WRAP_LONG_WORDS;
-    else if (!(flags & NO_ELLIPSIS))
-      wrap_behavior = ui::ELIDE_LONG_WORDS;
-
-    std::vector<string16> strings;
-    ui::ElideRectangleText(adjusted_text, font, w, h, wrap_behavior,
-                           &strings);
-
-    rect.Offset(0, VAlignText(font, strings.size(), flags, h));
-    for (size_t i = 0; i < strings.size(); i++) {
-      ui::Range range = StripAcceleratorChars(flags, &strings[i]);
-      UpdateRenderText(rect, strings[i], font, flags, color, render_text.get());
-      ApplyUnderlineStyle(range, render_text.get());
-      render_text->Draw(this);
-      rect.Offset(0, font.GetHeight());
-    }
-  } else {
-    ui::Range range = StripAcceleratorChars(flags, &adjusted_text);
-    bool elide_text = (flags & NO_ELLIPSIS) ? false : true;
-
-#if defined(OS_LINUX)
-    // On Linux, eliding really means fading the end of the string. But only
-    // for LTR text. RTL text is still elided (on the left) with "...".
-    if (elide_text) {
-      render_text->SetText(adjusted_text);
-      if (render_text->GetTextDirection() == base::i18n::LEFT_TO_RIGHT) {
-        render_text->set_fade_tail(true);
-        elide_text = false;
-      }
-    }
-#endif
-
-    if (elide_text)
-      ElideTextAndAdjustRange(font, w, &adjusted_text, &range);
-
-    rect.Offset(0, VAlignText(font, 1, flags, h));
-    UpdateRenderText(rect, adjusted_text, font, flags, color,
-                     render_text.get());
-    ApplyUnderlineStyle(range, render_text.get());
-    render_text->Draw(this);
-  }
-
-  canvas_->restore();
-}
-
-void Canvas::DrawStringWithHalo(const string16& 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 = SkColorSetA(halo_color_in, 0xFF);
-
-  // Create a temporary buffer filled with the halo color. It must leave room
-  // for the 1-pixel border around the text.
-  Size size(w + 2, h + 2);
-  Canvas text_canvas(size, true);
-  SkPaint bkgnd_paint;
-  bkgnd_paint.setColor(halo_color);
-  text_canvas.DrawRect(gfx::Rect(size), 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);
-
-  uint32_t halo_premul = SkPreMultiplyColor(halo_color);
-  SkBitmap& text_bitmap = const_cast<SkBitmap&>(
-      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.
-      }
-    }
-  }
-
-  // Draw the halo bitmap with blur.
-  DrawBitmapInt(text_bitmap, x - 1, y - 1);
-}
-
-// TODO(asvitkine): Remove the ifdef once all platforms use canvas_skia_skia.cc.
-#if defined(OS_WIN)
-void Canvas::DrawFadeTruncatingString(
-      const string16& text,
-      TruncateFadeMode truncate_mode,
-      size_t desired_characters_to_truncate_from_head,
-      const gfx::Font& font,
-      const SkColor& color,
-      const gfx::Rect& display_rect) {
-  int flags = NO_ELLIPSIS;
-
-  // If the whole string fits in the destination then just draw it directly.
-  if (GetStringWidth(text, font) <= display_rect.width()) {
-    DrawStringInt(text, font, color, display_rect.x(), display_rect.y(),
-                  display_rect.width(), display_rect.height(), flags);
-    return;
-  }
-
-  scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
-  string16 clipped_text = text;
-  const bool is_rtl = IsTextRTL(flags, text);
-  if (is_rtl)
-    base::i18n::AdjustStringForLocaleDirection(&clipped_text);
-
-  switch (truncate_mode) {
-    case TruncateFadeTail:
-      render_text->set_fade_tail(true);
-      if (is_rtl)
-        flags |= TEXT_ALIGN_RIGHT;
-      break;
-    case TruncateFadeHead:
-      render_text->set_fade_head(true);
-      if (!is_rtl)
-        flags |= TEXT_ALIGN_RIGHT;
-      break;
-    case TruncateFadeHeadAndTail:
-      DCHECK_GT(desired_characters_to_truncate_from_head, 0u);
-      // Due to the fade effect the first character is hard to see.
-      // We want to make sure that the first character starting at
-      // |desired_characters_to_truncate_from_head| is readable so we reduce
-      // the offset by a little bit.
-      desired_characters_to_truncate_from_head =
-          std::max<int>(0, desired_characters_to_truncate_from_head - 2);
-
-      if (desired_characters_to_truncate_from_head) {
-        // Make sure to clip the text at a UTF16 boundary.
-        U16_SET_CP_LIMIT(text.data(), 0,
-                         desired_characters_to_truncate_from_head,
-                         text.length());
-        clipped_text = text.substr(desired_characters_to_truncate_from_head);
-      }
-
-      render_text->set_fade_tail(true);
-      render_text->set_fade_head(true);
-      break;
-  }
-
-  gfx::Rect rect = display_rect;
-  rect.Offset(0, VAlignText(font, 1, flags, display_rect.height()));
-  UpdateRenderText(rect, clipped_text, font, flags, color, render_text.get());
-
-  canvas_->save(SkCanvas::kClip_SaveFlag);
-  ClipRect(display_rect);
-  render_text->Draw(this);
-  canvas_->restore();
-}
-#endif
-
-}  // namespace gfx