ozone: Allow building for ozone without depending on pango

ui/gfx/render_text_pango.cc

 // 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/render_text_linux.h"
+#include "ui/gfx/render_text_pango.h"
 
 #include <pango/pangocairo.h>
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/canvas.h"
@@ skipping 44 matching lines @@
   renderer->SetUnderlineMetrics(PANGO_PIXELS(thickness),
                                 PANGO_PIXELS(position));
 }
 
 }  // namespace
 
 // TODO(xji): index saved in upper layer is utf16 index. Pango uses utf8 index.
 // Since caret_pos is used internally, we could save utf8 index for caret_pos
 // to avoid conversion.
 
-RenderTextLinux::RenderTextLinux()
+RenderTextPango::RenderTextPango()
     : layout_(NULL),
       current_line_(NULL),
       log_attrs_(NULL),
       num_log_attrs_(0),
       layout_text_(NULL) {
 }
 
-RenderTextLinux::~RenderTextLinux() {
+RenderTextPango::~RenderTextPango() {
   ResetLayout();
 }
 
-Size RenderTextLinux::GetStringSize() {
+Size RenderTextPango::GetStringSize() {
   EnsureLayout();
   int width = 0, height = 0;
   pango_layout_get_pixel_size(layout_, &width, &height);
   // Keep a consistent height between this particular string's PangoLayout and
   // potentially larger text supported by the FontList.
   // For example, if a text field contains a Japanese character, which is
   // smaller than Latin ones, and then later a Latin one is inserted, this
   // ensures that the text baseline does not shift.
   return Size(width, std::max(height, font_list().GetHeight()));
 }
 
-SelectionModel RenderTextLinux::FindCursorPosition(const Point& point) {
+SelectionModel RenderTextPango::FindCursorPosition(const Point& point) {
   EnsureLayout();
 
   if (text().empty())
     return SelectionModel(0, CURSOR_FORWARD);
 
   Point p(ToTextPoint(point));
 
   // When the point is outside of text, return HOME/END position.
   if (p.x() < 0)
     return EdgeSelectionModel(CURSOR_LEFT);
   if (p.x() > GetStringSize().width())
     return EdgeSelectionModel(CURSOR_RIGHT);
 
   int caret_pos = 0, trailing = 0;
   pango_layout_xy_to_index(layout_, p.x() * PANGO_SCALE, p.y() * PANGO_SCALE,
                            &caret_pos, &trailing);
 
   DCHECK_GE(trailing, 0);
   if (trailing > 0) {
     caret_pos = g_utf8_offset_to_pointer(layout_text_ + caret_pos,
                                          trailing) - layout_text_;
     DCHECK_LE(static_cast<size_t>(caret_pos), strlen(layout_text_));
   }
 
   return SelectionModel(LayoutIndexToTextIndex(caret_pos),
                         (trailing > 0) ? CURSOR_BACKWARD : CURSOR_FORWARD);
 }
 
-std::vector<RenderText::FontSpan> RenderTextLinux::GetFontSpansForTesting() {
+std::vector<RenderText::FontSpan> RenderTextPango::GetFontSpansForTesting() {
   EnsureLayout();
 
   std::vector<RenderText::FontSpan> spans;
   for (GSList* it = current_line_->runs; it; it = it->next) {
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(it->data)->item;
     const int start = LayoutIndexToTextIndex(item->offset);
     const int end = LayoutIndexToTextIndex(item->offset + item->length);
     const Range range(start, end);
 
     ScopedPangoFontDescription desc(pango_font_describe(item->analysis.font));
     spans.push_back(RenderText::FontSpan(Font(desc.get()), range));
   }
 
   return spans;
 }
 
-int RenderTextLinux::GetLayoutTextBaseline() {
+int RenderTextPango::GetLayoutTextBaseline() {
   EnsureLayout();
   return PANGO_PIXELS(pango_layout_get_baseline(layout_));
 }
 
-SelectionModel RenderTextLinux::AdjacentCharSelectionModel(
+SelectionModel RenderTextPango::AdjacentCharSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
   GSList* run = GetRunContainingCaret(selection);
   if (!run) {
     // The cursor is not in any run: we're at the visual and logical edge.
     SelectionModel edge = EdgeSelectionModel(direction);
     if (edge.caret_pos() == selection.caret_pos())
       return edge;
     else
       run = (direction == CURSOR_RIGHT) ?
@@ skipping 19 matching lines @@
     run = (direction == CURSOR_RIGHT) ?
         run->next : GSListPrevious(current_line_->runs, run);
     if (!run)
       return EdgeSelectionModel(direction);
   }
   PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
   return IsForwardMotion(direction, item) ?
       FirstSelectionModelInsideRun(item) : LastSelectionModelInsideRun(item);
 }
 
-SelectionModel RenderTextLinux::AdjacentWordSelectionModel(
+SelectionModel RenderTextPango::AdjacentWordSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
   if (obscured())
     return EdgeSelectionModel(direction);
 
   base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
   if (!success)
     return selection;
 
   SelectionModel cur(selection);
   for (;;) {
     cur = AdjacentCharSelectionModel(cur, direction);
     GSList* run = GetRunContainingCaret(cur);
     if (!run)
       break;
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
     size_t cursor = cur.caret_pos();
     if (IsForwardMotion(direction, item) ?
         iter.IsEndOfWord(cursor) : iter.IsStartOfWord(cursor))
       break;
   }
 
   return cur;
 }
 
-Range RenderTextLinux::GetGlyphBounds(size_t index) {
+Range RenderTextPango::GetGlyphBounds(size_t index) {
   PangoRectangle pos;
   pango_layout_index_to_pos(layout_, TextIndexToLayoutIndex(index), &pos);
   // TODO(derat): Support fractional ranges for subpixel positioning?
   return Range(PANGO_PIXELS(pos.x), PANGO_PIXELS(pos.x + pos.width));
 }
 
-std::vector<Rect> RenderTextLinux::GetSubstringBounds(const Range& range) {
+std::vector<Rect> RenderTextPango::GetSubstringBounds(const Range& range) {
   DCHECK_LE(range.GetMax(), text().length());
   if (range.is_empty())
     return std::vector<Rect>();
 
   EnsureLayout();
   int* ranges = NULL;
   int n_ranges = 0;
   pango_layout_line_get_x_ranges(current_line_,
                                  TextIndexToLayoutIndex(range.GetMin()),
                                  TextIndexToLayoutIndex(range.GetMax()),
                                  &ranges,
                                  &n_ranges);
 
   const int height = GetStringSize().height();
 
   std::vector<Rect> bounds;
   for (int i = 0; i < n_ranges; ++i) {
     // TODO(derat): Support fractional bounds for subpixel positioning?
     int x = PANGO_PIXELS(ranges[2 * i]);
     int width = PANGO_PIXELS(ranges[2 * i + 1]) - x;
     Rect rect(x, 0, width, height);
     rect.set_origin(ToViewPoint(rect.origin()));
     bounds.push_back(rect);
   }
   g_free(ranges);
   return bounds;
 }
 
-size_t RenderTextLinux::TextIndexToLayoutIndex(size_t index) const {
+size_t RenderTextPango::TextIndexToLayoutIndex(size_t index) const {
   DCHECK(layout_);
   ptrdiff_t offset = gfx::UTF16IndexToOffset(text(), 0, index);
   // Clamp layout indices to the length of the text actually used for layout.
   offset = std::min<size_t>(offset, g_utf8_strlen(layout_text_, -1));
   const char* layout_pointer = g_utf8_offset_to_pointer(layout_text_, offset);
   return (layout_pointer - layout_text_);
 }
 
-size_t RenderTextLinux::LayoutIndexToTextIndex(size_t index) const {
+size_t RenderTextPango::LayoutIndexToTextIndex(size_t index) const {
   DCHECK(layout_);
   const char* layout_pointer = layout_text_ + index;
   const long offset = g_utf8_pointer_to_offset(layout_text_, layout_pointer);
   return gfx::UTF16OffsetToIndex(text(), 0, offset);
 }
 
-bool RenderTextLinux::IsCursorablePosition(size_t position) {
+bool RenderTextPango::IsCursorablePosition(size_t position) {
   if (position == 0 && text().empty())
     return true;
   if (position >= text().length())
     return position == text().length();
   if (!gfx::IsValidCodePointIndex(text(), position))
     return false;
 
   EnsureLayout();
   ptrdiff_t offset = gfx::UTF16IndexToOffset(text(), 0, position);
   // Check that the index corresponds with a valid text code point, that it is
   // marked as a legitimate cursor position by Pango, and that it is not
   // truncated from layout text (its glyph is shown on screen).
   return (offset < num_log_attrs_ && log_attrs_[offset].is_cursor_position &&
           offset < g_utf8_strlen(layout_text_, -1));
 }
 
-void RenderTextLinux::ResetLayout() {
+void RenderTextPango::ResetLayout() {
   // set_cached_bounds_and_offset_valid(false) is done in RenderText for every
   // operation that triggers ResetLayout().
   if (layout_) {
     // TODO(msw): Keep |layout_| across text changes, etc.; it can be re-used.
     g_object_unref(layout_);
     layout_ = NULL;
   }
   if (current_line_) {
     pango_layout_line_unref(current_line_);
     current_line_ = NULL;
   }
   if (log_attrs_) {
     g_free(log_attrs_);
     log_attrs_ = NULL;
     num_log_attrs_ = 0;
   }
   layout_text_ = NULL;
 }
 
-void RenderTextLinux::EnsureLayout() {
+void RenderTextPango::EnsureLayout() {
   if (layout_ == NULL) {
     cairo_surface_t* surface =
         cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0);
     CHECK_EQ(CAIRO_STATUS_SUCCESS, cairo_surface_status(surface));
     cairo_t* cr = cairo_create(surface);
     CHECK_EQ(CAIRO_STATUS_SUCCESS, cairo_status(cr));
 
     layout_ = pango_cairo_create_layout(cr);
     CHECK_NE(static_cast<PangoLayout*>(NULL), layout_);
     cairo_destroy(cr);
@@ skipping 18 matching lines @@
     SetupPangoAttributes(layout_);
 
     current_line_ = pango_layout_get_line_readonly(layout_, 0);
     CHECK_NE(static_cast<PangoLayoutLine*>(NULL), current_line_);
     pango_layout_line_ref(current_line_);
 
     pango_layout_get_log_attrs(layout_, &log_attrs_, &num_log_attrs_);
   }
 }
 
-void RenderTextLinux::SetupPangoAttributes(PangoLayout* layout) {
+void RenderTextPango::SetupPangoAttributes(PangoLayout* layout) {
   PangoAttrList* attrs = pango_attr_list_new();
 
   // Splitting text runs to accommodate styling can break Arabic glyph shaping.
   // Only split text runs as needed for bold and italic font styles changes.
   BreakList<bool>::const_iterator bold = styles()[BOLD].breaks().begin();
   BreakList<bool>::const_iterator italic = styles()[ITALIC].breaks().begin();
   while (bold != styles()[BOLD].breaks().end() &&
          italic != styles()[ITALIC].breaks().end()) {
     const int style = (bold->second ? Font::BOLD : 0) |
                       (italic->second ? Font::ITALIC : 0);
@@ skipping 14 matching lines @@
     bold += bold_end == style_end ? 1 : 0;
     italic += italic_end == style_end ? 1 : 0;
   }
   DCHECK(bold == styles()[BOLD].breaks().end());
   DCHECK(italic == styles()[ITALIC].breaks().end());
 
   pango_layout_set_attributes(layout, attrs);
   pango_attr_list_unref(attrs);
 }
 
-void RenderTextLinux::DrawVisualText(Canvas* canvas) {
+void RenderTextPango::DrawVisualText(Canvas* canvas) {
   DCHECK(layout_);
 
   // Skia will draw glyphs with respect to the baseline.
   Vector2d offset(GetLineOffset(0) + Vector2d(0, GetLayoutTextBaseline()));
 
   SkScalar x = SkIntToScalar(offset.x());
   SkScalar y = SkIntToScalar(offset.y());
 
   std::vector<SkPoint> pos;
   std::vector<uint16> glyphs;
@@ skipping 78 matching lines @@
         style_start_glyph_index = glyph_index;
         style_start_x = x;
       }
     } while (glyph_index < glyph_count);
   }
 
   // Undo the temporarily applied composition underlines and selection colors.
   UndoCompositionAndSelectionStyles();
 }
 
-GSList* RenderTextLinux::GetRunContainingCaret(
+GSList* RenderTextPango::GetRunContainingCaret(
     const SelectionModel& caret) const {
   size_t position = TextIndexToLayoutIndex(caret.caret_pos());
   LogicalCursorDirection affinity = caret.caret_affinity();
   GSList* run = current_line_->runs;
   while (run) {
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
     Range item_range(item->offset, item->offset + item->length);
     if (RangeContainsCaret(item_range, position, affinity))
       return run;
     run = run->next;
   }
   return NULL;
 }
 
-SelectionModel RenderTextLinux::FirstSelectionModelInsideRun(
+SelectionModel RenderTextPango::FirstSelectionModelInsideRun(
     const PangoItem* item) {
   size_t caret = IndexOfAdjacentGrapheme(
       LayoutIndexToTextIndex(item->offset), CURSOR_FORWARD);
   return SelectionModel(caret, CURSOR_BACKWARD);
 }
 
-SelectionModel RenderTextLinux::LastSelectionModelInsideRun(
+SelectionModel RenderTextPango::LastSelectionModelInsideRun(
     const PangoItem* item) {
   size_t caret = IndexOfAdjacentGrapheme(
       LayoutIndexToTextIndex(item->offset + item->length), CURSOR_BACKWARD);
   return SelectionModel(caret, CURSOR_FORWARD);
 }
 
-size_t RenderTextLinux::GetGlyphTextIndex(PangoLayoutRun* run,
+size_t RenderTextPango::GetGlyphTextIndex(PangoLayoutRun* run,
                                           int glyph_index) const {
   return LayoutIndexToTextIndex(run->item->offset +
                                 run->glyphs->log_clusters[glyph_index]);
 }
 
 RenderText* RenderText::CreateInstance() {
-  return new RenderTextLinux;
+  return new RenderTextPango;
 }
 
 }  // namespace gfx