Reduce the number of text reshaping in RenderText

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 <climits>
 
 #include "base/command_line.h"
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/trace_event/trace_event.h"
 #include "third_party/icu/source/common/unicode/rbbi.h"
 #include "third_party/icu/source/common/unicode/utf16.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/render_text_harfbuzz.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_util.h"
@@ skipping 411 matching lines @@
 
   // 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;
 
   obscured_reveal_index_ = -1;
-  UpdateLayoutText();
+  OnTextAttributeChanged();
 }
 
 void RenderText::SetHorizontalAlignment(HorizontalAlignment alignment) {
   if (horizontal_alignment_ != alignment) {
     horizontal_alignment_ = alignment;
     display_offset_ = Vector2d();
     cached_bounds_and_offset_valid_ = false;
   }
 }
 
 void RenderText::SetFontList(const FontList& font_list) {
   font_list_ = font_list;
   const int font_style = font_list.GetFontStyle();
   SetStyle(BOLD, (font_style & gfx::Font::BOLD) != 0);
   SetStyle(ITALIC, (font_style & gfx::Font::ITALIC) != 0);
   SetStyle(UNDERLINE, (font_style & gfx::Font::UNDERLINE) != 0);
   baseline_ = kInvalidBaseline;
   cached_bounds_and_offset_valid_ = false;
-  ResetLayout();
+  OnLayoutTextAttributeChanged(false);
 }
 
 void RenderText::SetCursorEnabled(bool cursor_enabled) {
   cursor_enabled_ = cursor_enabled;
   cached_bounds_and_offset_valid_ = false;
 }
 
 void RenderText::ToggleInsertMode() {
   insert_mode_ = !insert_mode_;
   cached_bounds_and_offset_valid_ = false;
 }
 
 void RenderText::SetObscured(bool obscured) {
   if (obscured != obscured_) {
     obscured_ = obscured;
     obscured_reveal_index_ = -1;
     cached_bounds_and_offset_valid_ = false;
-    UpdateLayoutText();
+    OnTextAttributeChanged();
   }
 }
 
 void RenderText::SetObscuredRevealIndex(int index) {
   if (obscured_reveal_index_ == index)
     return;
 
   obscured_reveal_index_ = index;
   cached_bounds_and_offset_valid_ = false;
-  UpdateLayoutText();
-}
-
-void RenderText::SetReplaceNewlineCharsWithSymbols(bool replace) {
-  replace_newline_chars_with_symbols_ = replace;
-  cached_bounds_and_offset_valid_ = false;
-  UpdateLayoutText();
+  OnTextAttributeChanged();
 }
 
 void RenderText::SetMultiline(bool multiline) {
   if (multiline != multiline_) {
     multiline_ = multiline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
+    OnDisplayTextAttributeChanged();
   }
 }
 
 void RenderText::SetMinLineHeight(int line_height) {
   if (min_line_height_ == line_height)
     return;
   min_line_height_ = line_height;
   cached_bounds_and_offset_valid_ = false;
   lines_.clear();
+  OnDisplayTextAttributeChanged();
 }
 
 void RenderText::SetElideBehavior(ElideBehavior elide_behavior) {
   // TODO(skanuj) : Add a test for triggering layout change.
   if (elide_behavior_ != elide_behavior) {
     elide_behavior_ = elide_behavior;
-    UpdateLayoutText();
+    OnDisplayTextAttributeChanged();
   }
 }
 
 void RenderText::SetDisplayRect(const Rect& r) {
   if (r != display_rect_) {
     display_rect_ = r;
     baseline_ = kInvalidBaseline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
-    if (elide_behavior_ != NO_ELIDE)
-      UpdateLayoutText();
+    if (elide_behavior_ != NO_ELIDE &&
+        elide_behavior_ != FADE_TAIL) {
+      OnDisplayTextAttributeChanged();
+    }
   }
 }
 
 void RenderText::SetCursorPosition(size_t position) {
   MoveCursorTo(position, false);
 }
 
 void RenderText::MoveCursor(BreakType break_type,
                             VisualCursorDirection direction,
                             bool select) {
@@ skipping 105 matching lines @@
 
 const Range& RenderText::GetCompositionRange() const {
   return composition_range_;
 }
 
 void RenderText::SetCompositionRange(const Range& composition_range) {
   CHECK(!composition_range.IsValid() ||
         Range(0, text_.length()).Contains(composition_range));
   composition_range_.set_end(composition_range.end());
   composition_range_.set_start(composition_range.start());
-  ResetLayout();
+  // TODO(oshima|msw): Altering composition underlines shouldn't
+  // require layout changes. It's currently necessary because
+  // RenderTextHarfBuzz paints text decorations by run, and
+  // RenderTextMac applies all styles during layout.
+  OnLayoutTextAttributeChanged(false);
 }
 
 void RenderText::SetColor(SkColor value) {
   colors_.SetValue(value);
 }
 
 void RenderText::ApplyColor(SkColor value, const Range& range) {
   colors_.ApplyValue(value, range);
 }
 
 void RenderText::SetStyle(TextStyle style, bool value) {
   styles_[style].SetValue(value);
 
   cached_bounds_and_offset_valid_ = false;
-  ResetLayout();
+  OnLayoutTextAttributeChanged(false);
 }
 
 void RenderText::ApplyStyle(TextStyle style, bool value, const Range& range) {
   // Do not change styles mid-grapheme to avoid breaking ligatures.
   const size_t start = IsValidCursorIndex(range.start()) ? range.start() :
       IndexOfAdjacentGrapheme(range.start(), CURSOR_BACKWARD);
   const size_t end = IsValidCursorIndex(range.end()) ? range.end() :
       IndexOfAdjacentGrapheme(range.end(), CURSOR_FORWARD);
   styles_[style].ApplyValue(value, Range(start, end));
 
   cached_bounds_and_offset_valid_ = false;
-  ResetLayout();
+  OnLayoutTextAttributeChanged(false);
 }
 
 bool RenderText::GetStyle(TextStyle style) const {
   return (styles_[style].breaks().size() == 1) &&
       styles_[style].breaks().front().second;
 }
 
 void RenderText::SetDirectionalityMode(DirectionalityMode mode) {
   if (mode == directionality_mode_)
     return;
 
   directionality_mode_ = mode;
   text_direction_ = base::i18n::UNKNOWN_DIRECTION;
   cached_bounds_and_offset_valid_ = false;
-  ResetLayout();
+  OnLayoutTextAttributeChanged(false);
 }
 
-base::i18n::TextDirection RenderText::GetTextDirection() {
-  if (text_direction_ == base::i18n::UNKNOWN_DIRECTION) {
-    switch (directionality_mode_) {
-      case DIRECTIONALITY_FROM_TEXT:
-        // Derive the direction from the display text, which differs from text()
-        // in the case of obscured (password) textfields.
-        text_direction_ =
-            base::i18n::GetFirstStrongCharacterDirection(GetLayoutText());
-        break;
-      case DIRECTIONALITY_FROM_UI:
-        text_direction_ = base::i18n::IsRTL() ? base::i18n::RIGHT_TO_LEFT :
-                                                base::i18n::LEFT_TO_RIGHT;
-        break;
-      case DIRECTIONALITY_FORCE_LTR:
-        text_direction_ = base::i18n::LEFT_TO_RIGHT;
-        break;
-      case DIRECTIONALITY_FORCE_RTL:
-        text_direction_ = base::i18n::RIGHT_TO_LEFT;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-
-  return text_direction_;
+base::i18n::TextDirection RenderText::GetDisplayTextDirection() {
+  return GetTextDirection(GetDisplayText());
 }
 
 VisualCursorDirection RenderText::GetVisualDirectionOfLogicalEnd() {
-  return GetTextDirection() == base::i18n::LEFT_TO_RIGHT ?
+  return GetDisplayTextDirection() == base::i18n::LEFT_TO_RIGHT ?
       CURSOR_RIGHT : CURSOR_LEFT;
 }
 
 SizeF RenderText::GetStringSizeF() {
   return GetStringSize();
 }
 
 float RenderText::GetContentWidthF() {
   const float string_size = GetStringSizeF().width();
   // The cursor is drawn one pixel beyond the int-enclosed text bounds.
@@ skipping 36 matching lines @@
 }
 
 void RenderText::DrawCursor(Canvas* canvas, const SelectionModel& position) {
   // Paint cursor. Replace cursor is drawn as rectangle for now.
   // TODO(msw): Draw a better cursor with a better indication of association.
   canvas->FillRect(GetCursorBounds(position, true), cursor_color_);
 }
 
 bool RenderText::IsValidLogicalIndex(size_t index) {
   // Check that the index is at a valid code point (not mid-surrgate-pair) and
-  // that it's not truncated from the layout text (its glyph may be shown).
+  // that it's not truncated from the display text (its glyph may be shown).
   //
   // Indices within truncated text are disallowed so users can easily interact
   // with the underlying truncated text using the ellipsis as a proxy. This lets
   // users select all text, select the truncated text, and transition from the
   // last rendered glyph to the end of the text without getting invisible cursor
   // positions nor needing unbounded arrow key presses to traverse the ellipsis.
   return index == 0 || index == text().length() ||
       (index < text().length() &&
        (truncate_length_ == 0 || index < truncate_length_) &&
        IsValidCodePointIndex(text(), index));
@@ skipping 10 matching lines @@
   DCHECK(IsValidLogicalIndex(caret_pos));
   // In overtype mode, ignore the affinity and always indicate that we will
   // overtype the next character.
   LogicalCursorDirection caret_affinity =
       insert_mode ? caret.caret_affinity() : CURSOR_FORWARD;
   int x = 0, width = 1;
   Size size = GetStringSize();
   if (caret_pos == (caret_affinity == CURSOR_BACKWARD ? 0 : text().length())) {
     // The caret is attached to the boundary. Always return a 1-dip width caret,
     // since there is nothing to overtype.
-    if ((GetTextDirection() == base::i18n::RIGHT_TO_LEFT) == (caret_pos == 0))
+    if ((GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT)
+        == (caret_pos == 0)) {
       x = size.width();
+    }
   } else {
     size_t grapheme_start = (caret_affinity == CURSOR_FORWARD) ?
         caret_pos : IndexOfAdjacentGrapheme(caret_pos, CURSOR_BACKWARD);
     Range xspan(GetGlyphBounds(grapheme_start));
     if (insert_mode) {
       x = (caret_affinity == CURSOR_BACKWARD) ? xspan.end() : xspan.start();
     } else {  // overtype mode
       x = xspan.GetMin();
       width = xspan.length();
     }
@@ skipping 91 matching lines @@
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(Range::InvalidRange()),
       colors_(kDefaultColor),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
       truncate_length_(0),
       elide_behavior_(NO_ELIDE),
-      replace_newline_chars_with_symbols_(true),
+      text_elided_(false),
       min_line_height_(0),
       multiline_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
       baseline_(kInvalidBaseline),
       cached_bounds_and_offset_valid_(false) {
 }
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
@@ skipping 15 matching lines @@
     return SelectionModel(text().length(), CURSOR_FORWARD);
   return SelectionModel(0, CURSOR_BACKWARD);
 }
 
 void RenderText::SetSelectionModel(const SelectionModel& model) {
   DCHECK_LE(model.selection().GetMax(), text().length());
   selection_model_ = model;
   cached_bounds_and_offset_valid_ = false;
 }
 
-const base::string16& RenderText::GetLayoutText() const {
-  return layout_text_;
+void RenderText::UpdateDisplayText(float text_width) {
+  // TODO(oshima): Consider support eliding for multi-line text.
+  // This requires max_line support first.
+  if (multiline_ ||
+      elide_behavior() == NO_ELIDE ||
+      elide_behavior() == FADE_TAIL ||
+      text_width < display_rect_.width() ||
+      layout_text_.empty()) {
+    text_elided_ = false;
+    display_text_.clear();
+    return;
+  }
+
+  // This doesn't trim styles so ellipsis may get rendered as a different
+  // style than the preceding text. See crbug.com/327850.
+  display_text_.assign(Elide(layout_text_,
+                             text_width,
+                             static_cast<float>(display_rect_.width()),
+                             elide_behavior_));
+
+  text_elided_ = display_text_ != layout_text_;
+  if (!text_elided_)
+    display_text_.clear();
 }
 
 const BreakList<size_t>& RenderText::GetLineBreaks() {
   if (line_breaks_.max() != 0)
     return line_breaks_;
 
-  const base::string16& layout_text = GetLayoutText();
+  const base::string16& layout_text = GetDisplayText();
   const size_t text_length = layout_text.length();
   line_breaks_.SetValue(0);
   line_breaks_.SetMax(text_length);
   base::i18n::BreakIterator iter(layout_text,
                                  base::i18n::BreakIterator::BREAK_LINE);
   const bool success = iter.Init();
   DCHECK(success);
   if (success) {
     do {
       line_breaks_.ApplyValue(iter.pos(), Range(iter.pos(), text_length));
@@ skipping 85 matching lines @@
       line_x += segment->x_range.length();
     }
   }
 
   return rects;
 }
 
 HorizontalAlignment RenderText::GetCurrentHorizontalAlignment() {
   if (horizontal_alignment_ != ALIGN_TO_HEAD)
     return horizontal_alignment_;
-  return GetTextDirection() == base::i18n::RIGHT_TO_LEFT ? ALIGN_RIGHT
-                                                         : ALIGN_LEFT;
+  return GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT ?
+      ALIGN_RIGHT : ALIGN_LEFT;
 }
 
 Vector2d RenderText::GetAlignmentOffset(size_t line_number) {
   // TODO(ckocagil): Enable |lines_| usage in other platforms.
 #if defined(OS_WIN)
   DCHECK_LT(line_number, lines_.size());
 #endif
   Vector2d offset;
   HorizontalAlignment horizontal_alignment = GetCurrentHorizontalAlignment();
   if (horizontal_alignment != ALIGN_LEFT) {
 #if defined(OS_WIN)
     const int width = std::ceil(lines_[line_number].size.width()) +
         (cursor_enabled_ ? 1 : 0);
 #else
     const int width = GetContentWidth();
 #endif
     offset.set_x(display_rect().width() - width);
     // Put any extra margin pixel on the left to match legacy behavior.
     if (horizontal_alignment == ALIGN_CENTER)
       offset.set_x((offset.x() + 1) / 2);
   }
 
   // Vertically center the text.
   if (multiline_) {
     const int text_height = lines_.back().preceding_heights +
         lines_.back().size.height();
     offset.set_y((display_rect_.height() - text_height) / 2);
   } else {
-    offset.set_y(GetBaseline() - GetLayoutTextBaseline());
+    offset.set_y(GetBaseline() - GetDisplayTextBaseline());
   }
 
   return offset;
 }
 
 void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
   const int width = display_rect().width();
   if (multiline() || elide_behavior_ != FADE_TAIL || GetContentWidth() <= width)
     return;
 
@@ skipping 24 matching lines @@
       text_rect, left_part, right_part, colors_.breaks().front().second);
   if (shader)
     renderer->SetShader(shader.get());
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
   skia::RefPtr<SkDrawLooper> looper = CreateShadowDrawLooper(shadows_);
   renderer->SetDrawLooper(looper.get());
 }
 
+base::i18n::TextDirection RenderText::GetTextDirection(
+    const base::string16& text) {
+  if (text_direction_ == base::i18n::UNKNOWN_DIRECTION) {
+    switch (directionality_mode_) {
+      case DIRECTIONALITY_FROM_TEXT:
+        // Derive the direction from the display text, which differs from text()
+        // in the case of obscured (password) textfields.
+        text_direction_ =
+            base::i18n::GetFirstStrongCharacterDirection(text);
+        break;
+      case DIRECTIONALITY_FROM_UI:
+        text_direction_ = base::i18n::IsRTL() ? base::i18n::RIGHT_TO_LEFT :
+                                                base::i18n::LEFT_TO_RIGHT;
+        break;
+      case DIRECTIONALITY_FORCE_LTR:
+        text_direction_ = base::i18n::LEFT_TO_RIGHT;
+        break;
+      case DIRECTIONALITY_FORCE_RTL:
+        text_direction_ = base::i18n::RIGHT_TO_LEFT;
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+  return text_direction_;
+}
+
 // static
 bool RenderText::RangeContainsCaret(const 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(Range(caret_pos, adjacent));
 }
 
 void RenderText::MoveCursorTo(size_t position, bool select) {
   size_t cursor = std::min(position, text().length());
   if (IsValidCursorIndex(cursor))
     SetSelectionModel(SelectionModel(
         Range(select ? selection().start() : cursor, cursor),
         (cursor == 0) ? CURSOR_FORWARD : CURSOR_BACKWARD));
 }
 
-void RenderText::UpdateLayoutText() {
+void RenderText::OnTextAttributeChanged() {
   layout_text_.clear();
+  display_text_.clear();
   line_breaks_.SetMax(0);
 
   if (obscured_) {
     size_t obscured_text_length =
         static_cast<size_t>(UTF16IndexToOffset(text_, 0, text_.length()));
     layout_text_.assign(obscured_text_length, kPasswordReplacementChar);
 
     if (obscured_reveal_index_ >= 0 &&
         obscured_reveal_index_ < static_cast<int>(text_.length())) {
       // Gets the index range in |text_| to be revealed.
@@ skipping 28 matching lines @@
       const size_t ellipsis_end = iter.getIndex();
       DCHECK_LE(ellipsis_start, ellipsis_end);
       layout_text_.assign(text.substr(0, ellipsis_start) + kEllipsisUTF16 +
                           text.substr(ellipsis_end));
     } else {
       iter.setIndex32(truncate_length_ - 1);
       layout_text_.assign(text.substr(0, iter.getIndex()) + kEllipsisUTF16);
     }
   }
 
-  if (elide_behavior_ != NO_ELIDE &&
-      elide_behavior_ != FADE_TAIL &&
-      !layout_text_.empty() &&
-      GetContentWidth() > display_rect_.width()) {
-    // This doesn't trim styles so ellipsis may get rendered as a different
-    // style than the preceding text. See crbug.com/327850.
-    layout_text_.assign(Elide(layout_text_,
-                              static_cast<float>(display_rect_.width()),
-                              elide_behavior_));
-  }
-
-  // Replace the newline character with a newline symbol in single line mode.
-  static const base::char16 kNewline[] = { '\n', 0 };
-  static const base::char16 kNewlineSymbol[] = { 0x2424, 0 };
-  if (!multiline_ && replace_newline_chars_with_symbols_)
-    base::ReplaceChars(layout_text_, kNewline, kNewlineSymbol, &layout_text_);
-
-  ResetLayout();
+  OnLayoutTextAttributeChanged(true);
 }
 
 base::string16 RenderText::Elide(const base::string16& text,
+                                 float text_width,
                                  float available_width,
                                  ElideBehavior behavior) {
   if (available_width <= 0 || text.empty())
     return base::string16();
   if (behavior == ELIDE_EMAIL)
     return ElideEmail(text, available_width);
+  if (text_width > 0 && text_width < available_width)
+    return text;
+
+  TRACE_EVENT0("ui", "RenderText::Elide");
 
   // Create a RenderText copy with attributes that affect the rendering width.
   scoped_ptr<RenderText> render_text = CreateInstanceOfSameType();
   render_text->SetFontList(font_list_);
   render_text->SetDirectionalityMode(directionality_mode_);
   render_text->SetCursorEnabled(cursor_enabled_);
   render_text->set_truncate_length(truncate_length_);
   render_text->styles_ = styles_;
   render_text->colors_ = colors_;
-  render_text->SetText(text);
-  if (render_text->GetContentWidthF() <= available_width)
+  if (text_width == 0) {
+    render_text->SetText(text);
+    text_width = render_text->GetContentWidthF();
+  }
+  if (text_width <= available_width)
     return text;
 
   const base::string16 ellipsis = base::string16(kEllipsisUTF16);
   const bool insert_ellipsis = (behavior != TRUNCATE);
   const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
   const bool elide_at_beginning = (behavior == ELIDE_HEAD);
+
+  if (insert_ellipsis) {
+    render_text->SetText(ellipsis);
+    const float ellipsis_width = render_text->GetContentWidthF();
+    if (ellipsis_width > available_width)
+      return base::string16();
+  }
+
   StringSlicer slicer(text, ellipsis, elide_in_middle, elide_at_beginning);
 
-  render_text->SetText(ellipsis);
-  const float ellipsis_width = render_text->GetContentWidthF();
-
-  if (insert_ellipsis && (ellipsis_width > available_width))
-    return base::string16();
-
   // Use binary search to compute the elided text.
   size_t lo = 0;
   size_t hi = text.length() - 1;
-  const base::i18n::TextDirection text_direction = GetTextDirection();
+  const base::i18n::TextDirection text_direction = GetTextDirection(text);
   for (size_t guess = (lo + hi) / 2; lo <= hi; guess = (lo + hi) / 2) {
     // Restore colors. They will be truncated to size by SetText.
     render_text->colors_ = colors_;
     base::string16 new_text =
         slicer.CutString(guess, insert_ellipsis && behavior != ELIDE_TAIL);
     render_text->SetText(new_text);
 
     // This has to be an additional step so that the ellipsis is rendered with
     // same style as trailing part of the text.
     if (insert_ellipsis && behavior == ELIDE_TAIL) {
@@ skipping 84 matching lines @@
     // Elide the domain so that it only takes half of the available width.
     // Should the username not need all the width available in its half, the
     // domain will occupy the leftover width.
     // If |desired_domain_width| is greater than |available_domain_width|: the
     // minimal username elision allowed by the specifications will not fit; thus
     // |desired_domain_width| must be <= |available_domain_width| at all cost.
     const float desired_domain_width =
         std::min<float>(available_domain_width,
             std::max<float>(available_width - full_username_width,
                             available_width / 2));
-    domain = Elide(domain, desired_domain_width, ELIDE_MIDDLE);
+    domain = Elide(domain, 0, desired_domain_width, ELIDE_MIDDLE);
     // Failing to elide the domain such that at least one character remains
     // (other than the ellipsis itself) remains: return a single ellipsis.
     if (domain.length() <= 1U)
       return base::string16(kEllipsisUTF16);
   }
 
   // Fit the username in the remaining width (at this point the elided username
   // is guaranteed to fit with at least one character remaining given all the
   // precautions taken earlier).
   available_width -= GetStringWidthF(domain, font_list());
-  username = Elide(username, available_width, ELIDE_TAIL);
+  username = Elide(username, 0, available_width, ELIDE_TAIL);
   return username + kAtSignUTF16 + domain;
 }
 
 void RenderText::UpdateCachedBoundsAndOffset() {
   if (cached_bounds_and_offset_valid_)
     return;
 
   // TODO(ckocagil): Add support for scrolling multiline text.
 
   int delta_x = 0;
@@ skipping 10 matching lines @@
     if (cursor_bounds_.right() > display_rect_.right())
       delta_x = display_rect_.right() - cursor_bounds_.right();
     else if (cursor_bounds_.x() < display_rect_.x())
       delta_x = display_rect_.x() - cursor_bounds_.x();
   }
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
-  const std::vector<Rect> sel = GetSubstringBounds(selection());
-  for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
-    canvas->FillRect(*i, selection_background_focused_color_);
+  for (const Rect& s : GetSubstringBounds(selection()))
+    canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx