Use GetDisplayText() instead of text() for rendering text.

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 <algorithm>
 #include <cmath>
@@ skipping 15 matching lines @@
 
 scoped_ptr<RenderText> RenderTextMac::CreateInstanceOfSameType() const {
   return make_scoped_ptr(new RenderTextMac);
 }
 
 const base::string16& RenderTextMac::GetDisplayText() {
   return text_elided() ? display_text() : layout_text();
 }
 
 Size RenderTextMac::GetStringSize() {
-  EnsureLayout();
-  return Size(std::ceil(string_size_.width()), string_size_.height());
+  EnsureStringSize();
+  return Size(std::ceil(string_size_->width()), string_size_->height());
 }
 
 SizeF RenderTextMac::GetStringSizeF() {
-  EnsureLayout();
-  return string_size_;
+  EnsureStringSize();
+  return *string_size_;
 }
 
 SelectionModel RenderTextMac::FindCursorPosition(const Point& point) {
   // TODO(asvitkine): Implement this. http://crbug.com/131618
   return SelectionModel();
 }
 
 std::vector<RenderText::FontSpan> RenderTextMac::GetFontSpansForTesting() {
   EnsureLayout();
   if (!runs_valid_)
@@ skipping 34 matching lines @@
   return Range();
 }
 
 std::vector<Rect> RenderTextMac::GetSubstringBounds(const Range& range) {
   // TODO(asvitkine): Implement this. http://crbug.com/131618
   return std::vector<Rect>();
 }
 
 size_t RenderTextMac::TextIndexToDisplayIndex(size_t index) {
   // TODO(asvitkine): Implement this. http://crbug.com/131618
-  return index;
+  return std::min(index, GetDisplayText().size());

[tapted, 2015/03/05 06:32:49]

should this be `.size() - 1`?

[Jun Mukai, 2015/03/05 18:01:38]

This change isn't necessary, removed.

 }
 
 size_t RenderTextMac::DisplayIndexToTextIndex(size_t index) {
   // TODO(asvitkine): Implement this. http://crbug.com/131618
   return index;
 }
 
 bool RenderTextMac::IsValidCursorIndex(size_t index) {
   // TODO(asvitkine): Implement this. http://crbug.com/131618
   return IsValidLogicalIndex(index);
 }
 
 void RenderTextMac::OnLayoutTextAttributeChanged(bool text_changed) {
   DCHECK(!multiline()) << "RenderTextMac does not support multi line";
+  string_size_.reset();
   if (text_changed) {
     if (elide_behavior() != NO_ELIDE &&
         elide_behavior() != FADE_TAIL &&
         !layout_text().empty()) {
       UpdateDisplayText(GetContentWidth());
     } else {
       UpdateDisplayText(0);
     }
   }
   line_.reset();
   attributes_.reset();
   runs_.clear();
   runs_valid_ = false;
 }
 
 void RenderTextMac::OnDisplayTextAttributeChanged() {
   OnLayoutTextAttributeChanged(true);
 }
 
 void RenderTextMac::EnsureLayout() {
   if (line_.get())
     return;
   runs_.clear();
   runs_valid_ = false;
 
-  CTFontRef ct_font = base::mac::NSToCFCast(
-      font_list().GetPrimaryFont().GetNativeFont());
-
-  const void* keys[] = { kCTFontAttributeName };
-  const void* values[] = { ct_font };
-  base::ScopedCFTypeRef<CFDictionaryRef> attributes(
-      CFDictionaryCreate(NULL,
-                         keys,
-                         values,
-                         arraysize(keys),
-                         NULL,
-                         &kCFTypeDictionaryValueCallBacks));
-
-  base::ScopedCFTypeRef<CFStringRef> cf_text(
-      base::SysUTF16ToCFStringRef(text()));
-  base::ScopedCFTypeRef<CFAttributedStringRef> attr_text(
-      CFAttributedStringCreate(NULL, cf_text, attributes));
-  base::ScopedCFTypeRef<CFMutableAttributedStringRef> attr_text_mutable(
-      CFAttributedStringCreateMutableCopy(NULL, 0, attr_text));
-
-  // TODO(asvitkine|msw): Respect GetTextDirection(), which may not match the
-  // natural text direction. See kCTTypesetterOptionForcedEmbeddingLevel, etc.
-
-  ApplyStyles(attr_text_mutable, ct_font);
-  line_.reset(CTLineCreateWithAttributedString(attr_text_mutable));
-
-  CGFloat ascent = 0;
-  CGFloat descent = 0;
-  CGFloat leading = 0;
-  // TODO(asvitkine): Consider using CTLineGetBoundsWithOptions() on 10.8+.
-  double width = CTLineGetTypographicBounds(line_, &ascent, &descent, &leading);
-  // Ensure ascent and descent are not smaller than ones of the font list.
-  // Keep them tall enough to draw often-used characters.
-  // For example, if a text field contains a Japanese character, which is
-  // smaller than Latin ones, and then later a Latin one is inserted, this
-  // ensures that the text baseline does not shift.
-  CGFloat font_list_height = font_list().GetHeight();
-  CGFloat font_list_baseline = font_list().GetBaseline();
-  ascent = std::max(ascent, font_list_baseline);
-  descent = std::max(descent, font_list_height - font_list_baseline);
-  string_size_ =
-      SizeF(width, std::max(ascent + descent + leading,
-                            static_cast<CGFloat>(min_line_height())));
-  common_baseline_ = ascent;
+  EnsureStringSize();
+  EnsureLayoutInternal(GetDisplayText(), &line_, &attributes_);
 }
 
 void RenderTextMac::DrawVisualText(Canvas* canvas) {
   DCHECK(line_);
   if (!runs_valid_)
     ComputeRuns();
 
   internal::SkiaTextRenderer renderer(canvas);
   ApplyFadeEffects(&renderer);
   ApplyTextShadows(&renderer);
@@ skipping 20 matching lines @@
       text_size(0),
       foreground(SK_ColorBLACK),
       underline(false),
       strike(false),
       diagonal_strike(false) {
 }
 
 RenderTextMac::TextRun::~TextRun() {
 }
 
-void RenderTextMac::ApplyStyles(CFMutableAttributedStringRef attr_string,
-                                CTFontRef font) {
+void RenderTextMac::EnsureStringSize() {
+  if (string_size_)
+    return;
+
+  base::ScopedCFTypeRef<CTLineRef> line;
+  base::ScopedCFTypeRef<CFMutableArrayRef> attributes_owner;
+  EnsureLayoutInternal(layout_text(), &line, &attributes_owner);
+
+  CGFloat ascent = 0;
+  CGFloat descent = 0;
+  CGFloat leading = 0;
+  // TODO(asvitkine): Consider using CTLineGetBoundsWithOptions() on 10.8+.
+  double width = CTLineGetTypographicBounds(line, &ascent, &descent, &leading);
+  // Ensure ascent and descent are not smaller than ones of the font list.
+  // Keep them tall enough to draw often-used characters.
+  // For example, if a text field contains a Japanese character, which is
+  // smaller than Latin ones, and then later a Latin one is inserted, this
+  // ensures that the text baseline does not shift.
+  CGFloat font_list_height = font_list().GetHeight();
+  CGFloat font_list_baseline = font_list().GetBaseline();
+  ascent = std::max(ascent, font_list_baseline);
+  descent = std::max(descent, font_list_height - font_list_baseline);
+  string_size_.reset(new SizeF(
+      width, std::max(ascent + descent + leading,
+                      static_cast<CGFloat>(min_line_height()))));
+  common_baseline_ = ascent;
+}
+
+void RenderTextMac::EnsureLayoutInternal(
+    const base::string16& text,
+    base::ScopedCFTypeRef<CTLineRef>* line,
+    base::ScopedCFTypeRef<CFMutableArrayRef>* attributes_owner) {
+  CTFontRef ct_font = base::mac::NSToCFCast(
+      font_list().GetPrimaryFont().GetNativeFont());
+
+  const void* keys[] = { kCTFontAttributeName };
+  const void* values[] = { ct_font };
+  base::ScopedCFTypeRef<CFDictionaryRef> attributes(
+      CFDictionaryCreate(NULL,
+                         keys,
+                         values,
+                         arraysize(keys),
+                         NULL,
+                         &kCFTypeDictionaryValueCallBacks));
+
+  base::ScopedCFTypeRef<CFStringRef> cf_text(
+      base::SysUTF16ToCFStringRef(text));
+  base::ScopedCFTypeRef<CFAttributedStringRef> attr_text(
+      CFAttributedStringCreate(NULL, cf_text, attributes));
+  base::ScopedCFTypeRef<CFMutableAttributedStringRef> attr_text_mutable(
+      CFAttributedStringCreateMutableCopy(NULL, 0, attr_text));
+
+  // TODO(asvitkine|msw): Respect GetTextDirection(), which may not match the
+  // natural text direction. See kCTTypesetterOptionForcedEmbeddingLevel, etc.
+
+  ApplyStyles(attr_text_mutable, ct_font, attributes_owner);
+  line->reset(CTLineCreateWithAttributedString(attr_text_mutable));
+}
+
+void RenderTextMac::ApplyStyles(
+    CFMutableAttributedStringRef attr_string,
+    CTFontRef font,
+    base::ScopedCFTypeRef<CFMutableArrayRef>* attributes_owner) {
   // Temporarily apply composition underlines and selection colors.
   ApplyCompositionAndSelectionStyles();
 
   // 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_|.
   // Clear the attributes storage.
-  attributes_.reset(CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks));
+  attributes_owner->reset(
+      CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks));
 
   // https://developer.apple.com/library/mac/#documentation/Carbon/Reference/CoreText_StringAttributes_Ref/Reference/reference.html
   internal::StyleIterator style(colors(), styles());
-  const size_t layout_text_length = GetDisplayText().length();
+  const size_t layout_text_length = CFAttributedStringGetLength(attr_string);
   for (size_t i = 0, end = 0; i < layout_text_length; i = end) {
-    end = TextIndexToDisplayIndex(style.GetRange().end());
+    end = std::min(style.GetRange().end(), layout_text_length);
     const CFRange range = CFRangeMake(i, end - i);
     base::ScopedCFTypeRef<CGColorRef> foreground(
         CGColorCreateFromSkColor(style.color()));
     CFAttributedStringSetAttribute(attr_string, range,
         kCTForegroundColorAttributeName, foreground);
-    CFArrayAppendValue(attributes_, foreground);
+    CFArrayAppendValue(*attributes_owner, foreground);
 
     if (style.style(UNDERLINE)) {
       CTUnderlineStyle value = kCTUnderlineStyleSingle;
       base::ScopedCFTypeRef<CFNumberRef> underline_value(
           CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
       CFAttributedStringSetAttribute(attr_string, range,
                                      kCTUnderlineStyleAttributeName,
                                      underline_value);
-      CFArrayAppendValue(attributes_, underline_value);
+      CFArrayAppendValue(*attributes_owner, underline_value);
     }
 
     const int traits = (style.style(BOLD) ? kCTFontBoldTrait : 0) |
                        (style.style(ITALIC) ? kCTFontItalicTrait : 0);
     if (traits != 0) {
       base::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);
+        CFArrayAppendValue(*attributes_owner, styled_font);
       }
     }
 
     style.UpdatePosition(DisplayIndexToTextIndex(end));
   }
 
   // Undo the temporarily applied composition underlines and selection colors.
   UndoCompositionAndSelectionStyles();
 }
 
@@ skipping 84 matching lines @@
     CTUnderlineStyle value = kCTUnderlineStyleNone;
     if (underline && CFNumberGetValue(underline, kCFNumberSInt32Type, &value))
       run->underline = (value == kCTUnderlineStyleSingle);
 
     run_origin.offset(run_width, 0);
   }
   runs_valid_ = true;
 }
 
 }  // namespace gfx