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 453 matching lines @@
 
 // Internal class used to track progress of a rectangular text elide
 // operation.  Exists so the top-level ElideRectangleText() function
 // can be broken into smaller methods sharing this state.
 class RectangleText {
  public:
   RectangleText(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_width)
       : 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_width_(max_width) {}
 
   // 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);
@@ skipping 59 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_;
 
+  float* max_width_;

[Alexei Svitkine (slow), 2014/10/02 16:59:37]

I suggest not making this a pointer, but rather a member of the class with a
getter. Then, in the wrapper function, assign it to the ptr passed into it via
the getter.

+
   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++;
+    if (max_width_)
+      *max_width_ = std::max(*max_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_width) {
   RectangleText rect(font_list,
                      available_pixel_width,
                      available_pixel_height,
                      wrap_behavior,
-                     lines);
+                     lines,
+                     max_width);
   rect.Init();
   rect.AddString(input);
   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);
 
@@ skipping 52 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