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 459 matching lines @@
   RectangleText(const FontList& font_list,
                 float available_pixel_width,
                 int available_pixel_height,
                 WordWrapBehavior wrap_behavior,
                 std::vector<base::string16>* 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) {}
 
   // Perform deferred initializions following creation.  Must be called
   // before any input can be added via AddString().
   void Init() { lines_->clear(); }
 
@@ skipping 16 matching lines @@
 
   // 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);
 
   // Add a word to the rectangluar region at the current position.
   int AddWord(const base::string16& word);
 
-  // Append the specified |text| to the current output line, incrementing the
-  // running width by the specified amount. This is an optimization over
-  // |AddToCurrentLine()| when |text_width| is already known.
-  void AddToCurrentLineWithWidth(const base::string16& text, float text_width);
-
   // Append the specified |text| to the current output line.
   void AddToCurrentLine(const base::string16& text);
 
   // Set the current position to the beginning of the next line.
   bool NewLine();
 
   // The font list used for measuring text width.
   const FontList& font_list_;
 
   // The height of each line of text.
   const int line_height_;
 
   // The number of pixels of available width in the rectangle.
   const float available_pixel_width_;
 
   // The number of pixels of available height in the rectangle.
   const int available_pixel_height_;
 
   // The wrap behavior for words that are too long to fit on a single line.
   const WordWrapBehavior wrap_behavior_;
 
-  // The current running width.
-  float current_width_;
-
   // The current running height.
   int current_height_;
 
   // The current line of text.
   base::string16 current_line_;
 
   // Indicates whether the last line ended with \n.
   bool last_line_ended_in_lf_;
 
   // The output vector of lines.
@@ skipping 38 matching lines @@
   }
   if (last_line_ended_in_lf_)
     lines_->push_back(base::string16());
   return (insufficient_width_ ? INSUFFICIENT_SPACE_HORIZONTAL : 0) |
          (insufficient_height_ ? INSUFFICIENT_SPACE_VERTICAL : 0);
 }
 
 void RectangleText::AddLine(const base::string16& line) {
   const float line_width = GetStringWidthF(line, font_list_);
   if (line_width <= available_pixel_width_) {
-    AddToCurrentLineWithWidth(line, line_width);
+    AddToCurrentLine(line);
   } else {
     // Iterate over positions that are valid to break the line at. In general,
     // these are word boundaries but after any punctuation following the word.
     base::i18n::BreakIterator words(line,
                                     base::i18n::BreakIterator::BREAK_LINE);
     if (words.Init()) {
       while (words.Advance()) {
         const bool truncate = !current_line_.empty();
         const base::string16& word = words.GetString();
         const int lines_added = AddWord(word);
         if (lines_added) {
           if (truncate) {
             // Trim trailing whitespace from the line that was added.
             const int line = lines_->size() - lines_added;
             base::TrimWhitespace(lines_->at(line), base::TRIM_TRAILING,
                                  &lines_->at(line));
           }
           if (base::ContainsOnlyChars(word, base::kWhitespaceUTF16)) {
             // Skip the first space if the previous line was carried over.
-            current_width_ = 0;
             current_line_.clear();
           }
         }
       }
     } else {
       NOTREACHED() << "BreakIterator (words) init failed";
     }
   }
   // Account for naturally-occuring newlines.
   NewLine();
@@ skipping 25 matching lines @@
 
   // Unless this is the very first word, put it on a new line.
   if (!current_line_.empty()) {
     if (!NewLine())
       return 0;
     lines_added++;
   }
 
   if (wrap_behavior_ == IGNORE_LONG_WORDS) {
     current_line_ = word;
-    current_width_ = available_pixel_width_;
   } else if (wrap_behavior_ == WRAP_LONG_WORDS) {
     lines_added += WrapWord(word);
   } else {
     const ElideBehavior elide_behavior =
         (wrap_behavior_ == ELIDE_LONG_WORDS ? ELIDE_TAIL : TRUNCATE);
     const base::string16 elided_word =
         ElideText(word, font_list_, available_pixel_width_, elide_behavior);
     AddToCurrentLine(elided_word);
     insufficient_width_ = true;
   }
 
   return lines_added;
 }
 
 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())
+    base::string16 line_with_new_word(current_line_);
+    line_with_new_word.append(trimmed);
+    float new_width = GetStringWidthF(line_with_new_word, font_list_);
+    // We can't just add trimmed_width to current_width and compare it to
+    // available_pixel_width. Sometimes sum of widths of two strings is not
+    // equal to width of concatenation of these strings (see crbug.com/415213).
+    if ((new_width > available_pixel_width_) && NewLine())
       lines_added++;
     // 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) {
-  AddToCurrentLineWithWidth(text, GetStringWidthF(text, font_list_));
-}
-
-void RectangleText::AddToCurrentLineWithWidth(const base::string16& text,
-                                              float text_width) {
   if (current_height_ >= available_pixel_height_) {
     insufficient_height_ = true;
     return;
   }
   current_line_.append(text);
-  current_width_ += text_width;
 }
 
 bool RectangleText::NewLine() {
   bool line_added = false;
   if (current_height_ < available_pixel_height_) {
     lines_->push_back(current_line_);
     current_line_.clear();
     line_added = true;
   } else {
     insufficient_height_ = true;
   }
   current_height_ += line_height_;
-  current_width_ = 0;
   return line_added;
 }
 
 }  // namespace
 
 bool ElideRectangleString(const base::string16& input, size_t max_rows,
                           size_t max_cols, bool strict,
                           base::string16* output) {
   RectangleString rect(max_rows, max_cols, strict, output);
   rect.Init();
@@ skipping 77 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