Replace StyleRange with BreakList; update RenderText, etc.

ui/gfx/render_text_linux.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 <pango/pangocairo.h>
 #include <algorithm>
 #include <string>
 #include <vector>
@@ skipping 307 matching lines @@
     current_line_ = pango_layout_get_line_readonly(layout_, 0);
     pango_layout_line_ref(current_line_);
 
     pango_layout_get_log_attrs(layout_, &log_attrs_, &num_log_attrs_);
   }
 }
 
 void RenderTextLinux::SetupPangoAttributes(PangoLayout* layout) {
   PangoAttrList* attrs = pango_attr_list_new();
 
-  int default_font_style = font_list().GetFontStyle();
-  for (StyleRanges::const_iterator i = style_ranges().begin();
-       i < style_ranges().end(); ++i) {
-    // In Pango, different fonts means different runs, and it breaks Arabic
-    // shaping across run boundaries. So, set font only when it is different
-    // from the default font.
-    // TODO(xji): We'll eventually need to split up StyleRange into components
-    // (ColorRange, FontRange, etc.) so that we can combine adjacent ranges
-    // with the same Fonts (to avoid unnecessarily splitting up runs).
-    if (i->font_style != default_font_style) {
-      FontList derived_font_list = font_list().DeriveFontList(i->font_style);
+  // 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);
+    const size_t bold_end = styles()[BOLD].GetRange(bold).end();
+    const size_t italic_end = styles()[ITALIC].GetRange(italic).end();
+    const size_t style_end = std::min(bold_end, italic_end);
+    if (style != font_list().GetFontStyle()) {
+      FontList derived_font_list = font_list().DeriveFontList(style);
       ScopedPangoFontDescription desc(pango_font_description_from_string(
           derived_font_list.GetFontDescriptionString().c_str()));
 
       PangoAttribute* pango_attr = pango_attr_font_desc_new(desc.get());
-      pango_attr->start_index = TextIndexToLayoutIndex(i->range.start());
-      pango_attr->end_index = TextIndexToLayoutIndex(i->range.end());
+      pango_attr->start_index =
+          TextIndexToLayoutIndex(std::max(bold->first, italic->first));
+      pango_attr->end_index = TextIndexToLayoutIndex(style_end);
       pango_attr_list_insert(attrs, pango_attr);
     }
+    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) {
   DCHECK(layout_);
 
   Vector2d offset(GetOffsetForDrawing());
   // Skia will draw glyphs with respect to the baseline.
   offset += Vector2d(0, PANGO_PIXELS(pango_layout_get_baseline(layout_)));
 
   SkScalar x = SkIntToScalar(offset.x());
   SkScalar y = SkIntToScalar(offset.y());
 
   std::vector<SkPoint> pos;
   std::vector<uint16> glyphs;
 
-  StyleRanges styles(style_ranges());
-  ApplyCompositionAndSelectionStyles(&styles);
-
-  // Pre-calculate UTF8 indices from UTF16 indices.
-  // TODO(asvitkine): Can we cache these?
-  std::vector<ui::Range> style_ranges_utf8;
-  style_ranges_utf8.reserve(styles.size());
-  size_t start_index = 0;
-  for (size_t i = 0; i < styles.size(); ++i) {
-    size_t end_index = TextIndexToLayoutIndex(styles[i].range.end());
-    style_ranges_utf8.push_back(ui::Range(start_index, end_index));
-    start_index = end_index;
-  }
-
   internal::SkiaTextRenderer renderer(canvas);
   ApplyFadeEffects(&renderer);
   ApplyTextShadows(&renderer);
 
   // TODO(derat): Use font-specific params: http://crbug.com/125235
   const gfx::FontRenderParams& render_params =
       gfx::GetDefaultFontRenderParams();
   const bool use_subpixel_rendering =
       render_params.subpixel_rendering !=
           gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE;
   renderer.SetFontSmoothingSettings(
       render_params.antialiasing,
       use_subpixel_rendering && !background_is_transparent());
 
+  // Temporarily apply composition underlines and selection colors.
+  ApplyCompositionAndSelectionStyles();
+
+  internal::StyleIterator style(colors(), styles());
   for (GSList* it = current_line_->runs; it; it = it->next) {
     PangoLayoutRun* run = reinterpret_cast<PangoLayoutRun*>(it->data);
     int glyph_count = run->glyphs->num_glyphs;
     if (glyph_count == 0)
       continue;
 
-    size_t run_start = run->item->offset;
-    size_t first_glyph_byte_index = run_start + run->glyphs->log_clusters[0];
-    size_t style_increment = IsForwardMotion(CURSOR_RIGHT, run->item) ? 1 : -1;
-
-    // Find the initial style for this run.
-    // TODO(asvitkine): Can we avoid looping here, e.g. by caching this per run?
-    int style = -1;
-    for (size_t i = 0; i < style_ranges_utf8.size(); ++i) {
-      if (IndexInRange(style_ranges_utf8[i], first_glyph_byte_index)) {
-        style = i;
-        break;
-      }
-    }
-    DCHECK_GE(style, 0);
-
     ScopedPangoFontDescription desc(
         pango_font_describe(run->item->analysis.font));
 
     const std::string family_name =
         pango_font_description_get_family(desc.get());
     renderer.SetTextSize(GetPangoFontSizeInPixels(desc.get()));
 
-    SkScalar glyph_x = x;
-    SkScalar start_x = x;
-    int start = 0;
-
     glyphs.resize(glyph_count);
     pos.resize(glyph_count);
 
-    for (int i = 0; i < glyph_count; ++i) {
-      const PangoGlyphInfo& glyph = run->glyphs->glyphs[i];
-      glyphs[i] = static_cast<uint16>(glyph.glyph);
-      // Use pango_units_to_double() rather than PANGO_PIXELS() here so that
-      // units won't get rounded to the pixel grid if we're using subpixel
-      // positioning.
-      pos[i].set(glyph_x + pango_units_to_double(glyph.geometry.x_offset),
-                 y + pango_units_to_double(glyph.geometry.y_offset));
+    // Track the glyph index and x-coordinate ranges for each styled range.

[Alexei Svitkine (slow), 2013/01/31 21:25:07]

I was looking for a comment explaining the differences between |glyph_start| and
|glyph_end| here, given the confusing code below that uses |glyph_end| to index
into |glyphs|.

I guess I'd prefer different names, e.g.:

glyph_end -> glyph_index (this is the current glyph being processed)
glyph_start -> style_start_glyph_index (corresponding to the start of the
current style)

[msw, 2013/02/01 00:08:08]

Done; I also renamed x_end to match; hopefully this is clearer.

+    int glyph_start = 0;
+    int glyph_end = 0;
+    SkScalar x_end = x;
 
-      // If this glyph is beyond the current style, draw the glyphs so far and
-      // advance to the next style.
-      size_t glyph_byte_index = run_start + run->glyphs->log_clusters[i];
-      DCHECK_GE(style, 0);
-      DCHECK_LT(style, static_cast<int>(styles.size()));
-      if (!IndexInRange(style_ranges_utf8[style], glyph_byte_index)) {
+    // Track the current style and its text index range.
+    style.UpdatePosition(GetGlyphTextIndex(run, glyph_start));
+    ui::Range style_range = style.GetRange();
+
+    do {
+      const PangoGlyphInfo& glyph = run->glyphs->glyphs[glyph_end];
+      glyphs[glyph_end] = static_cast<uint16>(glyph.glyph);
+      // Use pango_units_to_double() rather than PANGO_PIXELS() here, so units
+      // are not rounded to the pixel grid if subpixel positioning is enabled.
+      pos[glyph_end].set(x_end + pango_units_to_double(glyph.geometry.x_offset),
+                         y + pango_units_to_double(glyph.geometry.y_offset));
+      x_end += pango_units_to_double(glyph.geometry.width);
+
+      ++glyph_end;
+      const size_t glyph_text_index = (glyph_end == glyph_count) ?
+          style_range.end() : GetGlyphTextIndex(run, glyph_end);
+      if (!IndexInRange(style_range, glyph_text_index)) {
         // TODO(asvitkine): For cases like "fi", where "fi" is a single glyph
         //                  but can span multiple styles, Pango splits the
         //                  styles evenly over the glyph. We can do this too by
         //                  clipping and drawing the glyph several times.
-        renderer.SetForegroundColor(styles[style].foreground);
-        renderer.SetFontFamilyWithStyle(family_name, styles[style].font_style);
-        renderer.DrawPosText(&pos[start], &glyphs[start], i - start);
-        if (styles[style].underline)
+        renderer.SetForegroundColor(style.color());
+        const int font_style = (style.style(BOLD) ? Font::BOLD : 0) |
+                               (style.style(ITALIC) ? Font::ITALIC : 0);
+        renderer.SetFontFamilyWithStyle(family_name, font_style);
+        renderer.DrawPosText(&pos[glyph_start], &glyphs[glyph_start],
+                             glyph_end - glyph_start);
+        if (style.style(UNDERLINE))
           SetPangoUnderlineMetrics(desc.get(), &renderer);
-        renderer.DrawDecorations(start_x, y, glyph_x - start_x, styles[style]);
+        renderer.DrawDecorations(x, y, x_end - x,
+                                 style.style(UNDERLINE), style.style(STRIKE),
+                                 style.style(DIAGONAL_STRIKE));
+        style.UpdatePosition(glyph_text_index);
+        style_range = style.GetRange();
+        glyph_start = glyph_end;
+        x = x_end;
+      }
+    } while (glyph_end < glyph_count);
+  }
 
-        start = i;
-        start_x = glyph_x;
-        // Loop to find the next style, in case the glyph spans multiple styles.
-        do {
-          style += style_increment;
-        } while (style >= 0 && style < static_cast<int>(styles.size()) &&
-                 !IndexInRange(style_ranges_utf8[style], glyph_byte_index));
-      }
-
-      glyph_x += pango_units_to_double(glyph.geometry.width);
-    }
-
-    // Draw the remaining glyphs.
-    renderer.SetForegroundColor(styles[style].foreground);
-    renderer.SetFontFamilyWithStyle(family_name, styles[style].font_style);
-    renderer.DrawPosText(&pos[start], &glyphs[start], glyph_count - start);
-    if (styles[style].underline)
-      SetPangoUnderlineMetrics(desc.get(), &renderer);
-    renderer.DrawDecorations(start_x, y, glyph_x - start_x, styles[style]);
-    x = glyph_x;
-  }
+  // Undo the temporarily applied composition underlines and selection colors.
+  UndoCompositionAndSelectionStyles();
 }
 
 GSList* RenderTextLinux::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;
     ui::Range item_range(item->offset, item->offset + item->length);
@@ skipping 45 matching lines @@
   g_free(ranges);
   return bounds;
 }
 
 std::vector<Rect> RenderTextLinux::GetSelectionBounds() {
   if (selection_visual_bounds_.empty())
     selection_visual_bounds_ = CalculateSubstringBounds(selection());
   return selection_visual_bounds_;
 }
 
+size_t RenderTextLinux::GetGlyphTextIndex(PangoLayoutRun* run,
+                                          int glyph_index) const {
+  return LayoutIndexToTextIndex(run->item->offset +
+                                run->glyphs->log_clusters[glyph_index]);
+}
+
 RenderText* RenderText::CreateInstance() {
   return new RenderTextLinux;
 }
 
 }  // namespace gfx