Clamp RenderTextWin layout length to 10,000 code points.

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/icu/public/common/unicode/rbbi.h"
 #include "third_party/icu/public/common/unicode/utf16.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
+#include "ui/base/text/text_elider.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 {
 
@@ skipping 292 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;
-  UpdateObscuredText();
+  UpdateLayoutText();
   ResetLayout();
 }
 
 void RenderText::SetHorizontalAlignment(HorizontalAlignment alignment) {
   if (horizontal_alignment_ != alignment) {
     horizontal_alignment_ = alignment;
     display_offset_ = Vector2d();
     cached_bounds_and_offset_valid_ = false;
   }
 }
@@ skipping 34 matching lines @@
 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;
-    UpdateObscuredText();
+    UpdateLayoutText();
     ResetLayout();
   }
 }
 
 void RenderText::SetObscuredRevealIndex(int index) {
   if (obscured_reveal_index_ == index)
     return;
 
   obscured_reveal_index_ = index;
   cached_bounds_and_offset_valid_ = false;
-  UpdateObscuredText();
+  UpdateLayoutText();
   ResetLayout();
 }
 
 void RenderText::SetDisplayRect(const Rect& r) {
   display_rect_ = r;
   cached_bounds_and_offset_valid_ = false;
 }
 
 void RenderText::SetCursorPosition(size_t position) {
   MoveCursorTo(position, false);
@@ skipping 298 matching lines @@
   }
   return Rect(ToViewPoint(Point(x, 0)), Size(width, size.height()));
 }
 
 const Rect& RenderText::GetUpdatedCursorBounds() {
   UpdateCachedBoundsAndOffset();
   return cursor_bounds_;
 }
 
 size_t RenderText::IndexOfAdjacentGrapheme(size_t index,
-    LogicalCursorDirection direction) {
+                                           LogicalCursorDirection direction) {
   if (index > text().length())
     return text().length();
 
   EnsureLayout();
 
   if (direction == CURSOR_FORWARD) {
     while (index < text().length()) {
       index++;
       if (IsCursorablePosition(index))
         return index;
@@ skipping 33 matching lines @@
       selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       selection_background_unfocused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(ui::Range::InvalidRange()),
       colors_(kDefaultColor),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
+      truncate_length_(0),
       fade_head_(false),
       fade_tail_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
       cached_bounds_and_offset_valid_(false) {
 }
 
 const Vector2d& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
@@ skipping 20 matching lines @@
   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 obscured() ? obscured_text_ : text();
+  return layout_text_.empty() ? text_ : layout_text_;
 }
 
 void RenderText::ApplyCompositionAndSelectionStyles() {
   // Save the underline and color breaks to undo the temporary styles later.
   DCHECK(!composition_and_selection_styles_applied_);
   saved_colors_ = colors_;
   saved_underlines_ = styles_[UNDERLINE];
 
   // Apply an underline to the composition range in |underlines|.
   if (composition_range_.IsValid() && !composition_range_.is_empty())
@@ skipping 109 matching lines @@
 }
 
 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_)
-    return;
+void RenderText::UpdateLayoutText() {
+  layout_text_.clear();
 
-  const size_t obscured_text_length =
-      static_cast<size_t>(ui::UTF16IndexToOffset(text_, 0, text_.length()));
-  obscured_text_.assign(obscured_text_length, kPasswordReplacementChar);
+  if (obscured_) {
+    size_t obscured_text_length =
+        static_cast<size_t>(ui::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.
-    size_t start = obscured_reveal_index_;
-    U16_SET_CP_START(text_.data(), 0, start);
-    size_t end = start;
-    UChar32 unused_char;
-    U16_NEXT(text_.data(), end, text_.length(), unused_char);
+    if (obscured_reveal_index_ >= 0 &&
+        obscured_reveal_index_ < static_cast<int>(text_.length())) {
+      // Gets the index range in |text_| to be revealed.
+      size_t start = obscured_reveal_index_;
+      U16_SET_CP_START(text_.data(), 0, start);
+      size_t end = start;
+      UChar32 unused_char;
+      U16_NEXT(text_.data(), end, text_.length(), unused_char);
 
-    // Gets the index in |obscured_text_| to be replaced.
-    const size_t cp_start =
-        static_cast<size_t>(ui::UTF16IndexToOffset(text_, 0, start));
-    obscured_text_.replace(cp_start, 1, text_.substr(start, end - start));
+      // Gets the index in |layout_text_| to be replaced.
+      const size_t cp_start =
+          static_cast<size_t>(ui::UTF16IndexToOffset(text_, 0, start));
+      if (layout_text_.length() > cp_start)
+        layout_text_.replace(cp_start, 1, text_.substr(start, end - start));
+    }
+  }
+
+  const base::string16& text = obscured_ ? layout_text_ : text_;
+  if (truncate_length_ > 0 && truncate_length_ < text.length()) {
+    // Truncate the text at a valid character break and append an ellipsis.
+    icu::StringCharacterIterator iter(text.c_str());
+    iter.setIndex32(truncate_length_ - 1);
+    layout_text_.assign(text.substr(0, iter.getIndex()) + ui::kEllipsisUTF16);
   }
 }
 
 void RenderText::UpdateCachedBoundsAndOffset() {
   if (cached_bounds_and_offset_valid_)
     return;
 
   // First, set the valid flag true to calculate the current cursor bounds using
   // the stale |display_offset_|. Applying |delta_offset| at the end of this
   // function will set |cursor_bounds_| and |display_offset_| to correct values.
@@ skipping 40 matching lines @@
 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);
 }
 
 }  // namespace gfx