Replace StyleRange with BreakList; update RenderText, etc.

ui/gfx/render_text_mac.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_mac.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 
 #include <cmath>
 #include <utility>
@@ skipping 140 matching lines @@
   ApplyTextShadows(&renderer);
 
   for (size_t i = 0; i < runs_.size(); ++i) {
     const TextRun& run = runs_[i];
     renderer.SetForegroundColor(run.foreground);
     renderer.SetTextSize(run.text_size);
     renderer.SetFontFamilyWithStyle(run.font_name, run.font_style);
     renderer.DrawPosText(&run.glyph_positions[0], &run.glyphs[0],
                          run.glyphs.size());
     renderer.DrawDecorations(run.origin.x(), run.origin.y(), run.width,
-                             run.style);
+                             run.underline, run.strike, run.diagonal_strike);
   }
 }
 
 RenderTextMac::TextRun::TextRun()
     : ct_run(NULL),
       origin(SkPoint::Make(0, 0)),
       width(0),
       font_style(Font::NORMAL),
       text_size(0),
-      foreground(SK_ColorBLACK) {
+      foreground(SK_ColorBLACK),
+      underline(false),
+      strike(false),
+      diagonal_strike(false) {
 }
 
 RenderTextMac::TextRun::~TextRun() {
 }
 
 void RenderTextMac::ApplyStyles(CFMutableAttributedStringRef attr_string,
                                 CTFontRef font) {
-  // Clear attributes and reserve space to hold the maximum number of entries,
-  // which is at most three per style range per the code below.
-  attributes_.reset(CFArrayCreateMutable(NULL, 3 * style_ranges().size(),
+  // Adjust the text colors to reflect the selection range.
+  ColorBreaks adjusted_colors(colors());
+  ApplySelectionColor(&adjusted_colors);
+
+  // Adjust the underline styling to reflect composition ranges.
+  const StyleBreaks* adjusted_styles[NUM_TEXT_STYLES];
+  for (size_t i = 0; i < NUM_TEXT_STYLES; ++i)
+    adjusted_styles[i] = &styles(static_cast<TextStyle>(i));
+  StyleBreaks adjusted_underlines(styles(UNDERLINE));
+  ApplyCompositionStyle(&adjusted_underlines);
+  adjusted_styles[UNDERLINE] = &adjusted_underlines;
+
+  // Track the current color and style with iterators; get the max style count.
+  ColorBreaks::const_iterator color = adjusted_colors.begin();
+  StyleBreaks::const_iterator style[NUM_TEXT_STYLES];
+  size_t max_style_count = adjusted_colors.size();
+  for (size_t i = 0; i < NUM_TEXT_STYLES; ++i) {
+    style[i] = adjusted_styles[i]->begin();
+    max_style_count += adjusted_styles[i]->size();
+  }
+  size_t style_end[NUM_TEXT_STYLES];
+
+  // Clear attributes and reserve space to hold the maximum number of entries.
+  attributes_.reset(CFArrayCreateMutable(NULL, max_style_count,
                                          &kCFTypeArrayCallBacks));
 
   // https://developer.apple.com/library/mac/#documentation/Carbon/Reference/CoreText_StringAttributes_Ref/Reference/reference.html
-  for (size_t i = 0; i < style_ranges().size(); ++i) {
-    const StyleRange& style = style_ranges()[i];
-    const CFRange range = CFRangeMake(style.range.start(),
-                                      style.range.length());
+  for (size_t i = 0, end = 0; i < text().length(); i = end) {
+    // Find the end of this ranged style.
+    const size_t color_end = TextIndexToLayoutIndex(
+        GetBreakEnd(adjusted_colors, color));
+    end = color_end;
+    for (size_t i = 0; i < NUM_TEXT_STYLES; ++i) {
+      style_end[i] = TextIndexToLayoutIndex(
+          GetBreakEnd(*adjusted_styles[i], style[i]));
+      end = std::min(end, style_end[i]);

[Alexei Svitkine (slow), 2013/01/22 19:41:03]

I find requiring this logic to RenderText subclasses suboptimal.

Can you make a function in the base RenderText class that computes a merged list
of style breaks instead? This way, the logic in the subclasses will remain
simple by iterating over this computed list...

[msw, 2013/01/22 22:27:24]

I agree, and have a TODO in the CL description for this:
TODO(followup): Make style iteration more convenient for Win/Linux/Mac impls. 
I don't see a great solution now; iterating over a combined list is a good idea,
but would need some thought (temp style ownership?, need separate iterators or
to repeatedly find each color/style break for each index?, etc.). Also
Win(+Mac?) code will soon only break for BOLD/ITALIC, and I hope to combine some
of the adornment drawing into render_text.cc if possible. I'd prefer to address
this in a followup CL, what do you think?

+    }
 
     // Note: CFAttributedStringSetAttribute() does not appear to retain the
     // values passed in, as can be verified via CFGetRetainCount(). To ensure
     // the attribute objects do not leak, they are saved to |attributes_|.
 
+    const CFRange range = CFRangeMake(i, end - i);
     base::mac::ScopedCFTypeRef<CGColorRef> foreground(
-        gfx::CGColorCreateFromSkColor(style.foreground));
+        gfx::CGColorCreateFromSkColor(color->second));
     CFAttributedStringSetAttribute(attr_string, range,
                                    kCTForegroundColorAttributeName,
                                    foreground);
     CFArrayAppendValue(attributes_, foreground);
 
-    if (style.underline) {
+    if (style[UNDERLINE]->second) {
       CTUnderlineStyle value = kCTUnderlineStyleSingle;
-      base::mac::ScopedCFTypeRef<CFNumberRef> underline(
+      base::mac::ScopedCFTypeRef<CFNumberRef> underline_value(
           CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
       CFAttributedStringSetAttribute(attr_string, range,
                                      kCTUnderlineStyleAttributeName,
-                                     underline);
-      CFArrayAppendValue(attributes_, underline);
+                                     underline_value);
+      CFArrayAppendValue(attributes_, underline_value);
     }
 
-    if (style.font_style & (Font::BOLD | Font::ITALIC)) {
-      int traits = 0;
-      if (style.font_style & Font::BOLD)
-        traits |= kCTFontBoldTrait;
-      if (style.font_style & Font::ITALIC)
-        traits |= kCTFontItalicTrait;
+    const int traits = (style[BOLD]->second ? kCTFontBoldTrait : 0) |
+                       (style[ITALIC]->second ? kCTFontItalicTrait : 0);
+    if (traits != 0) {
       base::mac::ScopedCFTypeRef<CTFontRef> styled_font(
           CTFontCreateCopyWithSymbolicTraits(font, 0.0, NULL, traits, traits));
       // TODO(asvitkine): Handle |styled_font| == NULL case better.
       if (styled_font) {
         CFAttributedStringSetAttribute(attr_string, range, kCTFontAttributeName,
                                        styled_font);
         CFArrayAppendValue(attributes_, styled_font);
       }
     }
+
+    // Advance the color and style iterators as needed.
+    color += color_end == end ? 1 : 0;
+    for (size_t i = 0; i < NUM_TEXT_STYLES; ++i)
+      style[i] += style_end[i] == end ? 1 : 0;
   }
 }
 
 void RenderTextMac::ComputeRuns() {
   DCHECK(line_);
 
   CFArrayRef ct_runs = CTLineGetGlyphRuns(line_);
   const CFIndex ct_runs_count = CFArrayGetCount(ct_runs);
 
   gfx::Vector2d text_offset = GetTextOffset();
@@ skipping 40 matching lines @@
       CTRunGetPositions(ct_run, empty_cf_range, &positions[0]);
       positions_ptr = &positions[0];
     }
     for (size_t glyph = 0; glyph < glyph_count; glyph++) {
       SkPoint* point = &run->glyph_positions[glyph];
       point->set(x + SkDoubleToScalar(positions_ptr[glyph].x),
                  y + SkDoubleToScalar(positions_ptr[glyph].y));
     }
 
     // TODO(asvitkine): Style boundaries are not necessarily per-run. Handle
-    //                  this better.
+    //                  this better. Also, support strike and diagonal_strike.
     CFDictionaryRef attributes = CTRunGetAttributes(ct_run);
     CTFontRef ct_font =
         base::mac::GetValueFromDictionary<CTFontRef>(attributes,
                                                      kCTFontAttributeName);
     base::mac::ScopedCFTypeRef<CFStringRef> font_name_ref(
         CTFontCopyFamilyName(ct_font));
     run->font_name = base::SysCFStringRefToUTF8(font_name_ref);
     run->text_size = CTFontGetSize(ct_font);
 
     CTFontSymbolicTraits traits = CTFontGetSymbolicTraits(ct_font);
     if (traits & kCTFontBoldTrait)
       run->font_style |= Font::BOLD;
     if (traits & kCTFontItalicTrait)
       run->font_style |= Font::ITALIC;
 
     const CGColorRef foreground =
         base::mac::GetValueFromDictionary<CGColorRef>(
             attributes, kCTForegroundColorAttributeName);
     if (foreground)
       run->foreground = gfx::CGColorRefToSkColor(foreground);
 
     const CFNumberRef underline =
         base::mac::GetValueFromDictionary<CFNumberRef>(
             attributes, kCTUnderlineStyleAttributeName);
     CTUnderlineStyle value = kCTUnderlineStyleNone;
     if (underline && CFNumberGetValue(underline, kCFNumberSInt32Type, &value))
-      run->style.underline = (value == kCTUnderlineStyleSingle);
+      run->underline = (value == kCTUnderlineStyleSingle);
 
     run_origin.offset(run_width, 0);
   }
   runs_valid_ = true;
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextMac;
 }
 
 }  // namespace gfx