Cache gfx::RenderText instances in views::Label.

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"
@@ skipping 384 matching lines @@
   paint->setSubpixelText(params.subpixel_positioning);
   paint->setAutohinted(params.autohinter);
   paint->setHinting(FontRenderParamsHintingToSkPaintHinting(params.hinting));
 }
 
 }  // namespace internal
 
 RenderText::~RenderText() {
 }
 
+// static
 RenderText* RenderText::CreateInstance() {
 #if defined(OS_MACOSX)
   static const bool use_native =
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableHarfBuzzRenderText);
   if (use_native)
     return new RenderTextMac;
 #endif  // defined(OS_MACOSX)
   return new RenderTextHarfBuzz;
 }
 
+// static
 RenderText* RenderText::CreateInstanceForEditing() {
   return new RenderTextHarfBuzz;
 }
 
 void RenderText::SetText(const base::string16& text) {
   DCHECK(!composition_range_.IsValid());
   if (text_ == text)
     return;
   text_ = text;
 
@@ skipping 70 matching lines @@
 
 void RenderText::SetMultiline(bool multiline) {
   if (multiline != multiline_) {
     multiline_ = multiline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
     OnTextAttributeChanged();
   }
 }
 
+void RenderText::SetReplaceNewlineCharsWithSymbols(bool replace) {
+  if (replace_newline_chars_with_symbols_ == replace)
+    return;
+  replace_newline_chars_with_symbols_ = replace;
+  cached_bounds_and_offset_valid_ = false;
+  OnTextAttributeChanged();
+}
+
 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) {
@@ skipping 396 matching lines @@
       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),
       text_elided_(false),
       min_line_height_(0),
       multiline_(false),
+      replace_newline_chars_with_symbols_(true),
       subpixel_rendering_suppressed_(false),
       clip_to_display_rect_(true),
       baseline_(kInvalidBaseline),
       cached_bounds_and_offset_valid_(false) {
 }
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
     BreakType break_type,
     VisualCursorDirection direction) {
@@ skipping 154 matching lines @@
 
 HorizontalAlignment RenderText::GetCurrentHorizontalAlignment() {
   if (horizontal_alignment_ != ALIGN_TO_HEAD)
     return horizontal_alignment_;
   return GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT ?
       ALIGN_RIGHT : ALIGN_LEFT;
 }
 
 Vector2d RenderText::GetAlignmentOffset(size_t line_number) {
   // TODO(ckocagil): Enable |lines_| usage on RenderTextMac.
-  if (multiline_)
+  if (MultilineSupported() && multiline_)
     DCHECK_LT(line_number, lines_.size());
   Vector2d offset;
   HorizontalAlignment horizontal_alignment = GetCurrentHorizontalAlignment();
   if (horizontal_alignment != ALIGN_LEFT) {
     const int width = multiline_ ?
         std::ceil(lines_[line_number].size.width()) +
         (cursor_enabled_ ? 1 : 0) :
         GetContentWidth();
     offset.set_x(display_rect().width() - width);
     // Put any extra margin pixel on the left to match legacy behavior.
@@ skipping 154 matching lines @@
       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);
     }
   }
   static const base::char16 kNewline[] = { '\n', 0 };
   static const base::char16 kNewlineSymbol[] = { 0x2424, 0 };
-  if (!multiline_)
+  if (!multiline_ && replace_newline_chars_with_symbols_)
     base::ReplaceChars(layout_text_, kNewline, kNewlineSymbol, &layout_text_);
 
   OnLayoutTextAttributeChanged(true);
 }
 
 base::string16 RenderText::Elide(const base::string16& text,
                                  float text_width,
                                  float available_width,
                                  ElideBehavior behavior) {
   if (available_width <= 0 || text.empty())
@@ skipping 182 matching lines @@
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   for (const Rect& s : GetSubstringBounds(selection()))
     canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx