Draw text via Skia in RenderTextLinux.

ui/gfx/render_text_linux.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/render_text_linux.h"
 
 #include <pango/pangocairo.h>
 #include <algorithm>
+#include <vector>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "ui/gfx/canvas_skia.h"
+#include "ui/gfx/font.h"
 #include "ui/gfx/pango_util.h"
 #include "unicode/uchar.h"
 #include "unicode/ustring.h"
 
 namespace {
 
 // TODO(xji): instead of converting each R or G or B from 8-bit to 16-bit,
 // it should also massage A in the conversion.
 int ConvertColorFrom8BitTo16Bit(int c) {
   return (c << 8) + c;
@@ skipping 230 matching lines @@
     pango_layout_line_ref(current_line_);
 
     pango_layout_get_log_attrs(layout_, &log_attrs_, &num_log_attrs_);
 
     layout_text_ = pango_layout_get_text(layout_);
     layout_text_len_ = strlen(layout_text_);
   }
 }
 
 void RenderTextLinux::DrawVisualText(Canvas* canvas) {
-  Rect bounds(display_rect());
+  DCHECK(layout_);
 
-  // Clip the canvas to the text display area.
-  SkCanvas* canvas_skia = canvas->GetSkCanvas();
+  Point offset(ToViewPoint(Point()));
+  // TODO(msw): Establish a vertical baseline for strings of mixed font heights.
+  size_t height = default_style().font.GetHeight();
 
-  skia::ScopedPlatformPaint scoped_platform_paint(canvas_skia);
-  cairo_t* cr = scoped_platform_paint.GetPlatformSurface();
-  cairo_save(cr);
-  cairo_rectangle(cr, bounds.x(), bounds.y(), bounds.width(), bounds.height());
-  cairo_clip(cr);
+  SkScalar x = SkIntToScalar(offset.x());
+  SkScalar y = SkIntToScalar(offset.y());
+  // Center the text vertically in the display area.
+  y += (display_rect().height() - height) / 2;
+  // Offset by the font size to account for Skia expecting y to be the bottom.
+  y += default_style().font.GetFontSize();

[xji, 2011/12/05 23:47:09]

The x/y initialization is the same for Win and Linux. Maybe they could be done
in base?

[Alexei Svitkine (slow), 2011/12/06 22:05:36]

I've added a helper function for this.

 
-  int text_width, text_height;
-  pango_layout_get_pixel_size(layout_, &text_width, &text_height);
-  Point offset(ToViewPoint(Point()));
-  // Vertically centered.
-  int text_y = offset.y() + ((bounds.height() - text_height) / 2);
-  // TODO(xji): need to use SkCanvas->drawPosText() for gpu acceleration.
-  cairo_move_to(cr, offset.x(), text_y);
-  pango_cairo_show_layout(cr, layout_);
+  std::vector<SkPoint> pos;
+  std::vector<uint16> glyphs;
 
-  cairo_restore(cr);
+  internal::SkiaTextRenderer renderer(canvas);
+  renderer.Init();
+

[xji, 2011/12/05 23:47:09]

you need to call ApplyCompositionAndSelectionStyle() before the loop so that
composition text is drawn with underline and selection's foregound color is
drawn correctly.

I think it should be the same for Windows, but seems
ApplyCompositionAndSelectionStyle() is not called in Windows, and the drawing
part is different in windows (seems that each style breaks text in different run
in windows).

[Alexei Svitkine (slow), 2011/12/06 22:05:36]

Done. On the Windows side, this needed to be done in
RenderTextWin::ItemizeLogicalText(), since runs/style ranges are merged at that
point. I've made that change, removing a TODO from there.

+  for (GSList* it = current_line_->runs; it; it = it->next) {
+    PangoLayoutRun* run = reinterpret_cast<PangoLayoutRun*>(it->data);
+    size_t run_start = Utf8IndexToUtf16Index(run->item->offset);
+
+    // Find the initial style for this run.
+    StyleRanges::const_iterator style = style_ranges().begin();
+    StyleRanges::const_iterator next = style + 1;
+    while (next < style_ranges().end() && next->range.start() <= run_start)

[msw, 2011/12/06 18:40:56]

This seems pretty inefficient, can we do better than O(N^2)?
StylesRanges should be in logical order with the text.
Is the loop that contains this code in logical or visual order?
Maybe just add a TODO as a heads up for a low-hanging perf opportunity. 

[Alexei Svitkine (slow), 2011/12/06 19:10:12]

I agree this is bad, I've added a TODO for now.

+      style = next++;
+
+    int glyph_count = run->glyphs->num_glyphs;
+    glyphs.resize(glyph_count);
+    pos.resize(glyph_count);
+
+    PangoFontDescription* native_font =
+        pango_font_describe(run->item->analysis.font);
+    renderer.SetFont(gfx::Font(native_font));
+    pango_font_description_free(native_font);
+
+    SkScalar glyph_x = x;
+    SkScalar start_x = x;
+    int start = 0;
+    for (int i = 0; i < glyph_count; ++i) {
+      const PangoGlyphInfo& glyph = run->glyphs->glyphs[i];
+      glyphs[i] = static_cast<uint16>(glyph.glyph);

[xji, 2011/12/05 23:47:09]

will cast from uint32 to uint16 cause problem?

[Alexei Svitkine (slow), 2011/12/06 19:10:12]

See my other comment.

+      pos[i].set(glyph_x + PANGO_PIXELS(glyph.geometry.x_offset),
+                 y + PANGO_PIXELS(glyph.geometry.y_offset));
+      glyph_x += PANGO_PIXELS(glyph.geometry.width);
+
+      // If this glyph is the last for the current style, draw the glyphs so far

[xji, 2011/12/05 23:47:09]

this glyph is *beyond* the current style.

[Alexei Svitkine (slow), 2011/12/06 19:10:12]

You're right, I've fixed the comment.

+      // and advance the style iterator.
+      size_t glyph_char_index = run->glyphs->log_clusters[i];
+      if (run_start + glyph_char_index >= style->range.end()) {

[xji, 2011/12/05 23:47:09]

glyph_char_index is *byte* index relative to run start.
need rename it to glyph_byte_index, and
do Utf8IndexToUtf16Index conversion. It should be:
if (Utf8IndexToUtf16Index(run->item->offset + glyph_byte_index) >=
style->range.end()) 

[Alexei Svitkine (slow), 2011/12/06 19:10:12]

Good catch! Rather than doing the conversion for every glyph, I've now made the
code pre-calculate the style ranges in terms of UTF8 indices, and am using these
now. Ideally, we could cache these precalculated ranges to avoid the extra work
in Draw()

+        renderer.SetForegroundColor(style->foreground);
+        renderer.DrawPosText(&pos[start], &glyphs[start], i - start);
+        if (style->strike || style->underline) {
+          renderer.DrawDecorations(start_x, y, glyph_x - start_x,
+                                   style->underline, style->strike);
+        }
+
+        ++style;
+        start = i;
+        start_x = glyph_x;
+      }
+    }
+
+    // Draw the remaining glyphs.
+    renderer.SetForegroundColor(style->foreground);
+    renderer.DrawPosText(&pos[start], &glyphs[start], glyph_count - start);
+    if (style->strike || style->underline) {
+       renderer.DrawDecorations(start_x, y, glyph_x - start_x,
+                                style->underline, style->strike);
+    }
+
+    x = glyph_x;

[xji, 2011/12/05 23:47:09]

Nice mechanism on drawing with styles.
But seems that it works for LTR run, but not on a RTL run that has 2 different
styles.

For a RTL run whose logical text is ABC, it display as CBA,
first glyph is 'C', assume run_start is 0,
at line 316, Utf8IndexToUtf16Index(run->item->offset + glyph_byte_index) is
calculating the char index using visual order, so the first glyph's index is 2.
But style->range.end() is in logical order.
For RTL run, maybe you need find the style using run's end (vs. line 291), and
change the style when glyph's index < style_range.start() (vs. 316). But I do
not know how to test it out (what RTL run can have 2 styles -- foregound,
strike, underline)?

[Alexei Svitkine (slow), 2011/12/06 22:05:36]

Good catch. I've updated the code to hopefully handle RTL correctly per your
comment - please take a look. I haven't yet tested it, though - I will try to do
that tomorrow.

+  }
 }
 
 size_t RenderTextLinux::IndexOfAdjacentGrapheme(size_t index, bool next) {
   if (index > text().length())
     return text().length();
   EnsureLayout();
   return Utf16IndexOfAdjacentGrapheme(Utf16IndexToUtf8Index(index), next);
 }
 
 GSList* RenderTextLinux::GetRunContainingPosition(size_t position) const {
@@ skipping 391 matching lines @@
 }
 
 void RenderTextLinux::GetSelectionBounds(std::vector<Rect>* bounds) {
   if (selection_visual_bounds_.empty())
     CalculateSubstringBounds(GetSelectionStart(), GetCursorPosition(),
                              &selection_visual_bounds_);
   *bounds = selection_visual_bounds_;
 }
 
 }  // namespace gfx