Replace StyleRange with BreakList; update RenderText, etc.

ui/gfx/render_text.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.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/text/utf16_indexing.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/text_constants.h"
 
+namespace gfx {
+
 namespace {
 
 // All chars are replaced by this char when the password style is set.
 // TODO(benrg): GTK uses the first of U+25CF, U+2022, U+2731, U+273A, '*'
 // that's available in the font (find_invisible_char() in gtkentry.c).
 const char16 kPasswordReplacementChar = '*';
 
-// Default color used for the cursor.
-const SkColor kDefaultCursorColor = SK_ColorBLACK;
-
-// Default color used for drawing selection text.
-const SkColor kDefaultSelectionColor = SK_ColorBLACK;
+// Default color used for the text and cursor.
+const SkColor kDefaultColor = SK_ColorBLACK;
 
 // Default color used for drawing selection background.
 const SkColor kDefaultSelectionBackgroundColor = SK_ColorGRAY;
 
+// Fraction of the text size to lower a strike through below the baseline.
+const SkScalar kStrikeThroughOffset = (-SK_Scalar1 * 6 / 21);
+// Fraction of the text size to lower an underline below the baseline.
+const SkScalar kUnderlineOffset = (SK_Scalar1 / 9);
+// Fraction of the text size to use for a strike through or under-line.
+const SkScalar kLineThickness = (SK_Scalar1 / 18);
+// Fraction of the text size to use for a top margin of a diagonal strike.
+const SkScalar kDiagonalStrikeMarginOffset = (SK_Scalar1 / 4);
+
+// Get the break at or preceeding |index|; |breaks| must not be empty.

[Alexei Svitkine (slow), 2013/01/23 16:52:54]

Please mention what units the |index| is. The way the comment currently reads
sounds like it just returns breaks->at(index).

[msw, 2013/01/25 09:10:02]

Replaced 'index' terminology with 'position' and mentions of ranged space in the
new BreakList.

+template <class T>
+typename std::vector<std::pair<size_t, T> >::iterator GetBreak(

[Alexei Svitkine (slow), 2013/01/23 16:52:54]

Can you make this templated on the vector too, to make it more readable?

Also, |breaks| should either be const or be the last param.

[msw, 2013/01/25 09:10:02]

Moot.

+    std::vector<std::pair<size_t, T> >* breaks,
+    size_t index) {
+  typename std::vector<std::pair<size_t, T> >::iterator i = breaks->end() - 1;
+  for (; i != breaks->begin() && i->first > index; --i);
+  return i;
+}
+
 #ifndef NDEBUG
-// Check StyleRanges invariant conditions: sorted and non-overlapping ranges.
-void CheckStyleRanges(const gfx::StyleRanges& style_ranges, size_t length) {
-  if (length == 0) {
-    DCHECK(style_ranges.empty()) << "Style ranges exist for empty text.";
-    return;
+// Check for ordered breaks [0->length) with no adjacent equivalent values.
+template <class T>
+void CheckBreaks(const std::vector<std::pair<size_t, T> >& breaks,
+                 size_t text_length) {
+  DCHECK_EQ(breaks[0].first, 0U) << "The first break must be at index 0.";
+  for (size_t i = 0; i < breaks.size() - 1; ++i) {
+    DCHECK_LT(breaks[i].first, breaks[i + 1].first) << "Break out of order.";
+    DCHECK_NE(breaks[i].second, breaks[i + 1].second) << "Redundant break.";
   }
-  for (gfx::StyleRanges::size_type i = 0; i < style_ranges.size() - 1; i++) {
-    const ui::Range& former = style_ranges[i].range;
-    const ui::Range& latter = style_ranges[i + 1].range;
-    DCHECK(!former.is_empty()) << "Empty range at " << i << ":" <<
-        former.ToString();
-    DCHECK(former.IsValid()) << "Invalid range at " << i << ":" <<
-        former.ToString();
-    DCHECK(!former.is_reversed()) << "Reversed range at " << i << ":" <<
-        former.ToString();
-    DCHECK(former.end() == latter.start()) << "Ranges gap/overlap/unsorted." <<
-        "former:" << former.ToString() << ", latter:" << latter.ToString();
-  }
-  const gfx::StyleRange& end_style = *style_ranges.rbegin();
-  DCHECK(!end_style.range.is_empty()) << "Empty range at end.";
-  DCHECK(end_style.range.IsValid()) << "Invalid range at end.";
-  DCHECK(!end_style.range.is_reversed()) << "Reversed range at end.";
-  DCHECK(end_style.range.end() == length) << "Style and text length mismatch.";
+  if (text_length > 0)
+    DCHECK_LT(breaks.back().first, text_length) << "Break beyond text length.";
 }
 #endif
 
-void ApplyStyleRangeImpl(gfx::StyleRanges* style_ranges,
-                         const gfx::StyleRange& style_range) {
-  const ui::Range& new_range = style_range.range;
-  // Follow StyleRanges invariant conditions: sorted and non-overlapping ranges.
-  gfx::StyleRanges::iterator i;
-  for (i = style_ranges->begin(); i != style_ranges->end();) {
-    if (i->range.end() < new_range.start()) {
-      i++;
-    } else if (i->range.start() == new_range.end()) {
-      break;
-    } else if (new_range.Contains(i->range)) {
-      i = style_ranges->erase(i);
-      if (i == style_ranges->end())
-        break;
-    } else if (i->range.start() < new_range.start() &&
-               i->range.end() > new_range.end()) {
-      // Split the current style into two styles.
-      gfx::StyleRange split_style = gfx::StyleRange(*i);
-      split_style.range.set_end(new_range.start());
-      i = style_ranges->insert(i, split_style) + 1;
-      i->range.set_start(new_range.end());
-      break;
-    } else if (i->range.start() < new_range.start()) {
-      i->range.set_end(new_range.start());
-      i++;
-    } else if (i->range.end() > new_range.end()) {
-      i->range.set_start(new_range.end());
-      break;
-    } else {
-      NOTREACHED();
-    }
+template <class T>
+void ResizeBreaks(std::vector<std::pair<size_t, T> >* breaks, size_t length) {

[Alexei Svitkine (slow), 2013/01/23 16:52:54]

Add a comment. Also, |breaks| should be last in params list, since you're
changing it.

[msw, 2013/01/25 09:10:02]

Moot.

+  if (length == 0) {
+    breaks->resize(1);
+  } else {
+    for (size_t i = 0; i < breaks->size(); ++i)
+      if (breaks->at(i).first >= length)
+        breaks->resize(i);
   }
-  // Add the new range in its sorted location.
-  style_ranges->insert(i, style_range);
+#ifndef NDEBUG
+  CheckBreaks(*breaks, length);
+#endif
 }
 
 // Converts |gfx::Font::FontStyle| flags to |SkTypeface::Style| flags.
 SkTypeface::Style ConvertFontStyleToSkiaTypefaceStyle(int font_style) {
   int skia_style = SkTypeface::kNormal;
-  if (font_style & gfx::Font::BOLD)
-    skia_style |= SkTypeface::kBold;
-  if (font_style & gfx::Font::ITALIC)
-    skia_style |= SkTypeface::kItalic;
+  skia_style |= (font_style & gfx::Font::BOLD) ? SkTypeface::kBold : 0;
+  skia_style |= (font_style & gfx::Font::ITALIC) ? SkTypeface::kItalic : 0;
   return static_cast<SkTypeface::Style>(skia_style);
 }
 
 // Given |font| and |display_width|, returns the width of the fade gradient.
-int CalculateFadeGradientWidth(const gfx::Font& font, int display_width) {
+int CalculateFadeGradientWidth(const Font& font, int display_width) {
   // Fade in/out about 2.5 characters of the beginning/end of the string.
   // The .5 here is helpful if one of the characters is a space.
   // Use a quarter of the display width if the display width is very short.
   const int average_character_width = font.GetAverageCharacterWidth();
   const double gradient_width = std::min(average_character_width * 2.5,
                                          display_width / 4.0);
   DCHECK_GE(gradient_width, 0.0);
   return static_cast<int>(floor(gradient_width + 0.5));
 }
 
 // Appends to |positions| and |colors| values corresponding to the fade over
 // |fade_rect| from color |c0| to color |c1|.
-void AddFadeEffect(const gfx::Rect& text_rect,
-                   const gfx::Rect& fade_rect,
+void AddFadeEffect(const Rect& text_rect,
+                   const Rect& fade_rect,
                    SkColor c0,
                    SkColor c1,
                    std::vector<SkScalar>* positions,
                    std::vector<SkColor>* colors) {
   const SkScalar left = static_cast<SkScalar>(fade_rect.x() - text_rect.x());
   const SkScalar width = static_cast<SkScalar>(fade_rect.width());
   const SkScalar p0 = left / text_rect.width();
   const SkScalar p1 = (left + width) / text_rect.width();
   // Prepend 0.0 to |positions|, as required by Skia.
   if (positions->empty() && p0 != 0.0) {
     positions->push_back(0.0);
     colors->push_back(c0);
   }
   positions->push_back(p0);
   colors->push_back(c0);
   positions->push_back(p1);
   colors->push_back(c1);
 }
 
 // Creates a SkShader to fade the text, with |left_part| specifying the left
 // fade effect, if any, and |right_part| specifying the right fade effect.
-skia::RefPtr<SkShader> CreateFadeShader(const gfx::Rect& text_rect,
-                                        const gfx::Rect& left_part,
-                                        const gfx::Rect& right_part,
+skia::RefPtr<SkShader> CreateFadeShader(const Rect& text_rect,
+                                        const Rect& left_part,
+                                        const Rect& right_part,
                                         SkColor color) {
   // Fade alpha of 51/255 corresponds to a fade of 0.2 of the original color.
   const SkColor fade_color = SkColorSetA(color, 51);
   std::vector<SkScalar> positions;
   std::vector<SkColor> colors;
 
   if (!left_part.IsEmpty())
     AddFadeEffect(text_rect, left_part, fade_color, color,
                   &positions, &colors);
   if (!right_part.IsEmpty())
@@ skipping 11 matching lines @@
   points[0].iset(text_rect.x(), text_rect.y());
   points[1].iset(text_rect.right(), text_rect.y());
 
   return skia::AdoptRef(
       SkGradientShader::CreateLinear(&points[0], &colors[0], &positions[0],
                                      colors.size(), SkShader::kClamp_TileMode));
 }
 
 }  // namespace
 
-namespace gfx {
-
 namespace internal {
 
 // Value of |underline_thickness_| that indicates that underline metrics have
 // not been set explicitly.
 const SkScalar kUnderlineMetricsNotSet = -1.0f;
 
 SkiaTextRenderer::SkiaTextRenderer(Canvas* canvas)
     : canvas_skia_(canvas->sk_canvas()),
       started_drawing_(false),
       underline_thickness_(kUnderlineMetricsNotSet),
@@ skipping 94 matching lines @@
       deferred_fade_shader_ = paint_.getShader();
       paint_.setShader(NULL);
       canvas_skia_->saveLayer(&bounds_, NULL);
     }
   }
 
   const size_t byte_length = glyph_count * sizeof(glyphs[0]);
   canvas_skia_->drawPosText(&glyphs[0], byte_length, &pos[0], paint_);
 }
 
-// Draw underline and strike through text decorations.
-// Based on |SkCanvas::DrawTextDecorations()| and constants from:
-//   third_party/skia/src/core/SkTextFormatParams.h
-void SkiaTextRenderer::DrawDecorations(int x, int y, int width,
-                                       const StyleRange& style) {
-  if (!style.underline && !style.strike && !style.diagonal_strike)
-    return;
+void SkiaTextRenderer::DrawDecorations(int x, int y, int width, bool underline,
+                                       bool strike, bool diagonal_strike) {
+  if (underline)
+    DrawUnderline(x, y, width);
+  if (strike)
+    DrawStrike(x, y, width);
+  if (diagonal_strike)
+    DrawDiagonalStrike(x, y, width);
+}
 
-  // Fraction of the text size to lower a strike through below the baseline.
-  const SkScalar kStrikeThroughOffset = (-SK_Scalar1 * 6 / 21);
-  // Fraction of the text size to lower an underline below the baseline.
-  const SkScalar kUnderlineOffset = (SK_Scalar1 / 9);
-  // Fraction of the text size to use for a strike through or under-line.
-  const SkScalar kLineThickness = (SK_Scalar1 / 18);
-  // Fraction of the text size to use for a top margin of a diagonal strike.
-  const SkScalar kDiagonalStrikeThroughMarginOffset = (SK_Scalar1 / 4);
+void SkiaTextRenderer::DrawUnderline(int x, int y, int width) {
+  SkRect r = SkRect::MakeLTRB(x, y + underline_position_, x + width,
+                              y + underline_position_ + underline_thickness_);
+  if (underline_thickness_ == kUnderlineMetricsNotSet) {
+    const SkScalar text_size = paint_.getTextSize();
+    r.fTop = SkScalarMulAdd(text_size, kUnderlineOffset, y);
+    r.fBottom = r.fTop + SkScalarMul(text_size, kLineThickness);
+  }
+  canvas_skia_->drawRect(r, paint_);
+}
 
-  SkScalar text_size = paint_.getTextSize();
-  SkScalar height = SkScalarMul(text_size, kLineThickness);
-  SkRect r;
+void SkiaTextRenderer::DrawStrike(int x, int y, int width) const {
+  const SkScalar text_size = paint_.getTextSize();
+  const SkScalar height = SkScalarMul(text_size, kLineThickness);
+  const SkScalar offset = SkScalarMulAdd(text_size, kStrikeThroughOffset, y);
+  const SkRect r = SkRect::MakeLTRB(x, offset, x + width, offset + height);
+  canvas_skia_->drawRect(r, paint_);
+}
 
-  r.fLeft = x;
-  r.fRight = x + width;
+void SkiaTextRenderer::DrawDiagonalStrike(int x, int y, int width) const {
+  const SkScalar text_size = paint_.getTextSize();
+  const SkScalar offset = SkScalarMul(text_size, kDiagonalStrikeMarginOffset);
 
-  if (style.underline) {
-    if (underline_thickness_ == kUnderlineMetricsNotSet) {
-      r.fTop = SkScalarMulAdd(text_size, kUnderlineOffset, y);
-      r.fBottom = r.fTop + height;
-    } else {
-      r.fTop = y + underline_position_;
-      r.fBottom = r.fTop + underline_thickness_;
-    }
-    canvas_skia_->drawRect(r, paint_);
-  }
-  if (style.strike) {
-    SkScalar offset = SkScalarMulAdd(text_size, kStrikeThroughOffset, y);
-    r.fTop = offset;
-    r.fBottom = offset + height;
-    canvas_skia_->drawRect(r, paint_);
-  }
-  if (style.diagonal_strike) {
-    SkScalar offset =
-        SkScalarMul(text_size, kDiagonalStrikeThroughMarginOffset);
-    SkPaint paint(paint_);
-    paint.setAntiAlias(true);
-    paint.setStyle(SkPaint::kFill_Style);
-    paint.setStrokeWidth(height * 2);
-    canvas_skia_->drawLine(
-        SkIntToScalar(x), SkIntToScalar(y),
-        SkIntToScalar(x + width), SkIntToScalar(y) - text_size + offset,
-        paint);
-  }
+  SkPaint paint(paint_);
+  paint.setAntiAlias(true);
+  paint.setStyle(SkPaint::kFill_Style);
+  paint.setStrokeWidth(SkScalarMul(text_size, kLineThickness) * 2);
+  canvas_skia_->drawLine(x, y, x + width, y - text_size + offset, paint);
 }
 
 }  // namespace internal
 
-
-StyleRange::StyleRange()
-    : foreground(SK_ColorBLACK),
-      font_style(gfx::Font::NORMAL),
-      strike(false),
-      diagonal_strike(false),
-      underline(false) {
-}
-
 RenderText::~RenderText() {
 }
 
 void RenderText::SetText(const string16& text) {
   DCHECK(!composition_range_.IsValid());
-  size_t old_text_length = text_.length();
+  const size_t old_length = text_.length();
   text_ = text;
 
-  // Update the style ranges as needed.
-  if (text_.empty()) {
-    style_ranges_.clear();
-  } else if (style_ranges_.empty()) {
-    ApplyDefaultStyle();
-  } else if (text_.length() > old_text_length) {
-    style_ranges_.back().range.set_end(text_.length());
-  } else if (text_.length() < old_text_length) {
-    StyleRanges::iterator i;
-    for (i = style_ranges_.begin(); i != style_ranges_.end(); i++) {
-      if (i->range.start() >= text_.length()) {
-        // Style ranges are sorted and non-overlapping, so all the subsequent
-        // style ranges should be out of text_.length() as well.
-        style_ranges_.erase(i, style_ranges_.end());
-        break;
-      }
-    }
-    // Since style ranges are sorted and non-overlapping, if there is a style
-    // range ends beyond text_.length, it must be the last one.
-    style_ranges_.back().range.set_end(text_.length());
+  // Adjust any ranged styles and colors to accomodate a new text size.

[Alexei Svitkine (slow), 2013/01/23 16:52:54]

Nit: "text size" -> "text length" in comment, to avoid confusion with font size.

[msw, 2013/01/25 09:10:02]

Done.

+  const size_t new_length = text_.length();
+  if (new_length < old_length) {
+    ResizeBreaks(&colors_, new_length);
+    for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
+      ResizeBreaks(&styles_[style], new_length);
   }
-#ifndef NDEBUG
-  CheckStyleRanges(style_ranges_, text_.length());
-#endif
   cached_bounds_and_offset_valid_ = false;
 
   // Reset selection model. SetText should always followed by SetSelectionModel
   // or SetCursorPosition in upper layer.
   SetSelectionModel(SelectionModel());
 
   // Invalidate the cached text direction if it depends on the text contents.
   if (directionality_mode_ == DIRECTIONALITY_FROM_TEXT)
     text_direction_ = base::i18n::UNKNOWN_DIRECTION;
 
@@ skipping 172 matching lines @@
 }
 
 void RenderText::SetCompositionRange(const ui::Range& composition_range) {
   CHECK(!composition_range.IsValid() ||
         ui::Range(0, text_.length()).Contains(composition_range));
   composition_range_.set_end(composition_range.end());
   composition_range_.set_start(composition_range.start());
   ResetLayout();
 }
 
-void RenderText::ApplyStyleRange(const StyleRange& style_range) {
-  const ui::Range& new_range = style_range.range;
-  if (!new_range.IsValid() || new_range.is_empty())
-    return;
-  CHECK(!new_range.is_reversed());
-  CHECK(ui::Range(0, text_.length()).Contains(new_range));
-  ApplyStyleRangeImpl(&style_ranges_, style_range);
-#ifndef NDEBUG
-  CheckStyleRanges(style_ranges_, text_.length());
-#endif
-  // TODO(xji): only invalidate if font or underline changes.
+void RenderText::SetColor(SkColor value) {
+  ApplyColor(value, ui::Range(0, text().length()));
+}
+
+void RenderText::ApplyColor(SkColor value, const ui::Range& range) {
+  ApplyBreaks(value, range, &colors_);
+
+#if defined(OS_WIN)
+  // TODO(msw): Windows applies colors and decorations in the layout process.
   cached_bounds_and_offset_valid_ = false;
   ResetLayout();
+#endif
 }
 
-void RenderText::ApplyDefaultStyle() {
-  style_ranges_.clear();
-  StyleRange style = StyleRange(default_style_);
-  style.range.set_end(text_.length());
-  style_ranges_.push_back(style);
-  cached_bounds_and_offset_valid_ = false;
-  ResetLayout();
+void RenderText::SetStyle(TextStyle style, bool value) {
+  ApplyStyle(style, value, ui::Range(0, text().length()));
+}
+
+void RenderText::ApplyStyle(TextStyle style,
+                            bool value,
+                            const ui::Range& range) {
+  ApplyBreaks(value, range, &styles_[style]);
+
+  // Only invalidate the layout on font changes; not for colors or decorations.
+  bool invalidate = (style == BOLD) || (style == UNDERLINE);
+#if defined(OS_WIN)
+  // TODO(msw): Windows applies colors and decorations in the layout process.
+  invalidate = true;
+#endif
+  if (invalidate) {
+    cached_bounds_and_offset_valid_ = false;
+    ResetLayout();
+  }
 }
 
 void RenderText::SetDirectionalityMode(DirectionalityMode mode) {
   if (mode == directionality_mode_)
     return;
 
   directionality_mode_ = mode;
   text_direction_ = base::i18n::UNKNOWN_DIRECTION;
   ResetLayout();
 }
@@ skipping 27 matching lines @@
 
 VisualCursorDirection RenderText::GetVisualDirectionOfLogicalEnd() {
   return GetTextDirection() == base::i18n::LEFT_TO_RIGHT ?
       CURSOR_RIGHT : CURSOR_LEFT;
 }
 
 void RenderText::Draw(Canvas* canvas) {
   EnsureLayout();
 
   if (clip_to_display_rect()) {
-    gfx::Rect clip_rect(display_rect());
+    Rect clip_rect(display_rect());
     clip_rect.Inset(ShadowValue::GetMargin(text_shadows_));
 
     canvas->Save();
     canvas->ClipRect(clip_rect);
   }
 
   if (!text().empty())
     DrawSelection(canvas);
 
   DrawCursor(canvas);
@@ skipping 80 matching lines @@
   text_shadows_ = shadows;
 }
 
 RenderText::RenderText()
     : horizontal_alignment_(base::i18n::IsRTL() ? ALIGN_RIGHT : ALIGN_LEFT),
       directionality_mode_(DIRECTIONALITY_FROM_TEXT),
       text_direction_(base::i18n::UNKNOWN_DIRECTION),
       cursor_enabled_(true),
       cursor_visible_(false),
       insert_mode_(true),
-      cursor_color_(kDefaultCursorColor),
-      selection_color_(kDefaultSelectionColor),
+      cursor_color_(kDefaultColor),
+      selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       selection_background_unfocused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(ui::Range::InvalidRange()),
       obscured_(false),
       fade_head_(false),
       fade_tail_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
       cached_bounds_and_offset_valid_(false) {
+  colors_.push_back(ColorBreak(0, kDefaultColor));
+  for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
+    styles_[style].push_back(StyleBreak(0, false));
 }
 
 const Vector2d& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
     BreakType break_type,
@@ skipping 18 matching lines @@
 void RenderText::SetSelectionModel(const SelectionModel& model) {
   DCHECK_LE(model.selection().GetMax(), text().length());
   selection_model_ = model;
   cached_bounds_and_offset_valid_ = false;
 }
 
 const string16& RenderText::GetLayoutText() const {
   return obscured() ? obscured_text_ : text();
 }
 
-void RenderText::ApplyCompositionAndSelectionStyles(
-    StyleRanges* style_ranges) {
-  // TODO(msw): This pattern ought to be reconsidered; what about composition
-  //            and selection overlaps, retain existing local style features?
-  // Apply a composition style override to a copy of the style ranges.
-  if (composition_range_.IsValid() && !composition_range_.is_empty()) {
-    StyleRange composition_style(default_style_);
-    composition_style.underline = true;
-    composition_style.range = composition_range_;
-    ApplyStyleRangeImpl(style_ranges, composition_style);
-  }
-  // Apply a selection style override to a copy of the style ranges.
+void RenderText::ApplyCompositionStyle(std::vector<StyleBreak>* underlines) {
+  // Apply an underline to the composition range in |underlines|.
+  if (composition_range_.IsValid() && !composition_range_.is_empty())
+    ApplyBreaks(true, composition_range_, underlines);
+}
+
+void RenderText::ApplySelectionColor(std::vector<ColorBreak>* colors) {
+  // Apply the selected text color to the selection range in |colors|.
   if (!selection().is_empty()) {
-    StyleRange selection_style(default_style_);
-    selection_style.foreground = selection_color_;
-    selection_style.range = ui::Range(selection().GetMin(),
-                                      selection().GetMax());
-    ApplyStyleRangeImpl(style_ranges, selection_style);
+    const ui::Range range(selection().GetMin(), selection().GetMax());
+    ApplyBreaks(selection_color_, range, colors);
   }
   // Apply replacement-mode style override to a copy of the style ranges.
   //
-  // TODO(xji): NEED TO FIX FOR WINDOWS ASAP. Windows call this function (to
-  // apply styles) in ItemizeLogicalText(). In order for the cursor's underline
-  // character to be drawn correctly, we will need to re-layout the text. It's
-  // not practical to do layout on every cursor blink. We need to fix Windows
-  // port to apply styles during drawing phase like Linux port does.
-  // http://crbug.com/110109
+  // TODO(xji|msw): RenderTextWin calls this function in ItemizeLogicalText(),
+  // but the character at the cursor changes color on every cursor blink in
+  // overtype mode. RenderTextWin should apply colors in DrawVisualText(), as
+  // done by RenderTextLinux; see http://crbug.com/110109
   if (!insert_mode_ && cursor_visible() && focused()) {
-    StyleRange replacement_mode_style(default_style_);
-    replacement_mode_style.foreground = selection_color_;
-    size_t cursor = cursor_position();
-    replacement_mode_style.range.set_start(cursor);
-    replacement_mode_style.range.set_end(
-        IndexOfAdjacentGrapheme(cursor, CURSOR_FORWARD));
-    ApplyStyleRangeImpl(style_ranges, replacement_mode_style);
+    const size_t cursor = cursor_position();
+    const size_t next = IndexOfAdjacentGrapheme(cursor, CURSOR_FORWARD);
+    ApplyBreaks(selection_color_, ui::Range(cursor, next), colors);
   }
 }
 
 Vector2d RenderText::GetTextOffset() {
   Vector2d offset = display_rect().OffsetFromOrigin();
   offset.Add(GetUpdatedDisplayOffset());
   offset.Add(GetAlignmentOffset());
   return offset;
 }
 
@@ skipping 42 matching lines @@
 
   bool fade_left = fade_head();
   bool fade_right = fade_tail();
   // Under RTL, |fade_right| == |fade_head|.
   // TODO(asvitkine): This is currently not based on GetTextDirection() because
   //                  RenderTextWin does not return a direction that's based on
   //                  the text content.
   if (horizontal_alignment() == ALIGN_RIGHT)
     std::swap(fade_left, fade_right);
 
-  gfx::Rect solid_part = display_rect();
-  gfx::Rect left_part;
-  gfx::Rect right_part;
+  Rect solid_part = display_rect();
+  Rect left_part;
+  Rect right_part;
   if (fade_left) {
     left_part = solid_part;
     left_part.Inset(0, 0, solid_part.width() - gradient_width, 0);
     solid_part.Inset(gradient_width, 0, 0, 0);
   }
   if (fade_right) {
     right_part = solid_part;
     right_part.Inset(solid_part.width() - gradient_width, 0, 0, 0);
     solid_part.Inset(0, 0, gradient_width, 0);
   }
 
-  gfx::Rect text_rect = display_rect();
+  Rect text_rect = display_rect();
   text_rect.Inset(GetAlignmentOffset().x(), 0, 0, 0);
 
-  const SkColor color = default_style().foreground;
-  skia::RefPtr<SkShader> shader =
-      CreateFadeShader(text_rect, left_part, right_part, color);
+  skia::RefPtr<SkShader> shader = CreateFadeShader(
+      text_rect, left_part, right_part, colors_.front().second);
   if (shader)
     renderer->SetShader(shader.get(), display_rect());
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
-  skia::RefPtr<SkDrawLooper> looper =
-      gfx::CreateShadowDrawLooper(text_shadows_);
+  skia::RefPtr<SkDrawLooper> looper = CreateShadowDrawLooper(text_shadows_);
   renderer->SetDrawLooper(looper.get());
 }
 
 // static
 bool RenderText::RangeContainsCaret(const ui::Range& range,
                                     size_t caret_pos,
                                     LogicalCursorDirection caret_affinity) {
   // NB: exploits unsigned wraparound (WG14/N1124 section 6.2.5 paragraph 9).
   size_t adjacent = (caret_affinity == CURSOR_BACKWARD) ?
       caret_pos - 1 : caret_pos + 1;
   return range.Contains(ui::Range(caret_pos, adjacent));
 }
 
+template <class T>
+void RenderText::ApplyBreaks(T value,
+                             const ui::Range& range,
+                             std::vector<std::pair<size_t, T> >* breaks) {
+  if (!range.IsValid() || (range.is_empty() && !text().empty()))
+    return;
+  DCHECK(!breaks->empty());
+  DCHECK(!range.is_reversed());
+  DCHECK(ui::Range(0, text_.length()).Contains(range));
+
+  // Erase any breaks in |range|, then add start and end breaks as needed.
+  typename std::vector<std::pair<size_t, T> >::iterator start =
+      GetBreak(breaks, range.start());
+  start += start->first < range.start() ? 1 : 0;
+  typename std::vector<std::pair<size_t, T> >::iterator end =
+      GetBreak(breaks, range.end());
+  T trailing_value = text().empty() ? value : end->second;
+  typename std::vector<std::pair<size_t, T> >::iterator i =
+      start == breaks->end() ? start : breaks->erase(start, end + 1);
+  if (range.start() == 0 || (i - 1)->second != value)
+    i = breaks->insert(i, std::pair<size_t, T>(range.start(), value)) + 1;
+  if (trailing_value != value && range.end() != text_.length())
+    breaks->insert(i, std::pair<size_t, T>(range.end(), trailing_value));
+
+#ifndef NDEBUG
+  CheckBreaks(*breaks, text_.length());
+#endif
+}
+
 void RenderText::MoveCursorTo(size_t position, bool select) {
   size_t cursor = std::min(position, text().length());
   if (IsCursorablePosition(cursor))
     SetSelectionModel(SelectionModel(
         ui::Range(select ? selection().start() : cursor, cursor),
         (cursor == 0) ? CURSOR_FORWARD : CURSOR_BACKWARD));
 }
 
 void RenderText::UpdateObscuredText() {
   if (!obscured_)
@@ skipping 40 matching lines @@
   } else if (display_offset_.x() != 0) {
     // Reduce the pan offset to show additional overflow text when the display
     // width increases.
     const int negate_rtl = horizontal_alignment_ == ALIGN_RIGHT ? -1 : 1;
     const int offset = negate_rtl * display_offset_.x();
     if (display_width > (content_width + offset)) {
       delta_x = negate_rtl * (display_width - (content_width + offset));
     }
   }
 
-  gfx::Vector2d delta_offset(delta_x, 0);
+  Vector2d delta_offset(delta_x, 0);
   display_offset_ += delta_offset;
   cursor_bounds_ += delta_offset;
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   const SkColor color = focused() ? selection_background_focused_color_ :
                                     selection_background_unfocused_color_;
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, color);
 }
 
 void RenderText::DrawCursor(Canvas* canvas) {
   // Paint cursor. Replace cursor is drawn as rectangle for now.
   // TODO(msw): Draw a better cursor with a better indication of association.
   if (cursor_enabled() && cursor_visible() && focused()) {
     const Rect& bounds = GetUpdatedCursorBounds();
     DCHECK(bounds.width());
     canvas->FillRect(bounds, cursor_color_);
   }
 }
 
 }  // namespace gfx