Error in popup on Link

ui/gfx/text_elider.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.
 //
 // This file implements utility functions for eliding and formatting UI text.
 //
 // Note that several of the functions declared in text_elider.h are implemented
 // in this file using helper classes in an unnamed namespace.
 
 #include "ui/gfx/text_elider.h"
@@ skipping 464 matching lines @@
       : font_list_(font_list),
         line_height_(font_list.GetHeight()),
         available_pixel_width_(available_pixel_width),
         available_pixel_height_(available_pixel_height),
         wrap_behavior_(wrap_behavior),
         current_width_(0),
         current_height_(0),
         last_line_ended_in_lf_(false),
         lines_(lines),
         insufficient_width_(false),
-        insufficient_height_(false) {}
+        insufficient_height_(false),
+        max_broken_pixel_width_(0) {}
 
   // Perform deferred initializions following creation.  Must be called
   // before any input can be added via AddString().
   void Init() { lines_->clear(); }
 
   // Add an input string, reformatting to fit the desired dimensions.
   // AddString() may be called multiple times to concatenate together
   // multiple strings into the region (the current caller doesn't do
   // this, however).
   void AddString(const base::string16& input);
 
   // Perform any deferred output processing.  Must be called after the last
   // AddString() call has occured. Returns a combination of
   // |ReformattingResultFlags| indicating whether the given width or height was
   // insufficient, leading to elision or truncation.
   int Finalize();
 
+  // Returns maximum width of those lines which were broken after some words to
+  // fit |available_pixel_width_|.
+  float GetMaxBrokenPixelWidth() const { return max_broken_pixel_width_; }

[Alexei Svitkine (slow), 2014/10/06 17:59:58]

Nit: This should just be max_broken_pixel_width() since its a trivial accessor.

[Roman Sorokin (ftl), 2014/10/07 09:21:53]

Done.

+
  private:
   // Add a line to the rectangular region at the current position,
   // either by itself or by breaking it into words.
   void AddLine(const base::string16& line);
 
   // Wrap the specified word across multiple lines.
   int WrapWord(const base::string16& word);
 
   // Add a long word - wrapping, eliding or truncating per the wrap behavior.
   int AddWordOverflow(const base::string16& word);
@@ skipping 42 matching lines @@
   // The output vector of lines.
   std::vector<base::string16>* lines_;
 
   // Indicates whether a word was so long that it had to be truncated or elided
   // to fit the available width.
   bool insufficient_width_;
 
   // Indicates whether there were too many lines for the available height.
   bool insufficient_height_;
 
+  // Maximum width of those lines which were broken after some words to
+  // fit |available_pixel_width_|.
+  float max_broken_pixel_width_;
+
   DISALLOW_COPY_AND_ASSIGN(RectangleText);
 };
 
 void RectangleText::AddString(const base::string16& input) {
   base::i18n::BreakIterator lines(input,
                                   base::i18n::BreakIterator::BREAK_NEWLINE);
   if (lines.Init()) {
     while (!insufficient_height_ && lines.Advance()) {
       base::string16 line = lines.GetString();
       // The BREAK_NEWLINE iterator will keep the trailing newline character,
@@ skipping 109 matching lines @@
 
 int RectangleText::AddWord(const base::string16& word) {
   int lines_added = 0;
   base::string16 trimmed;
   base::TrimWhitespace(word, base::TRIM_TRAILING, &trimmed);
   const float trimmed_width = GetStringWidthF(trimmed, font_list_);
   if (trimmed_width <= available_pixel_width_) {
     // Word can be made to fit, no need to fragment it.
     if ((current_width_ + trimmed_width > available_pixel_width_) && NewLine())
       lines_added++;
+    max_broken_pixel_width_ =
+        std::max(max_broken_pixel_width_, current_width_ + trimmed_width);
     // Append the non-trimmed word, in case more words are added after.
     AddToCurrentLine(word);
   } else {
     lines_added = AddWordOverflow(wrap_behavior_ == IGNORE_LONG_WORDS ?
                                   trimmed : word);
   }
   return lines_added;
 }
 
 void RectangleText::AddToCurrentLine(const base::string16& text) {
@@ skipping 33 matching lines @@
   rect.Init();
   rect.AddString(input);
   return rect.Finalize();
 }
 
 int ElideRectangleText(const base::string16& input,
                        const FontList& font_list,
                        float available_pixel_width,
                        int available_pixel_height,
                        WordWrapBehavior wrap_behavior,
-                       std::vector<base::string16>* lines) {
+                       std::vector<base::string16>* lines,
+                       float* max_broken_pixel_width) {
   RectangleText rect(font_list,
                      available_pixel_width,
                      available_pixel_height,
                      wrap_behavior,
                      lines);
   rect.Init();
   rect.AddString(input);
+  if (max_broken_pixel_width)
+    *max_broken_pixel_width = rect.GetMaxBrokenPixelWidth();
   return rect.Finalize();
 }
 
 base::string16 TruncateString(const base::string16& string,
                               size_t length,
                               BreakType break_type) {
   DCHECK(break_type == CHARACTER_BREAK || break_type == WORD_BREAK);
 
   if (string.size() <= length)
     // String fits, return it.
@@ skipping 50 matching lines @@
     index = char_iterator.getIndex();
   } else {
     // String has leading whitespace, return the elide string.
     return kElideString;
   }
 
   return string.substr(0, index) + kElideString;
 }
 
 }  // namespace gfx