Modify ui::ElideRectangleText() to honor trailing newlines.

ui/base/text/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 the anonymous namespace.
 
 #include "ui/base/text/text_elider.h"
@@ skipping 775 matching lines @@
                 int available_pixel_height,
                 ui::WordWrapBehavior wrap_behavior,
                 std::vector<string16>* lines)
       : font_(font),
         line_height_(font.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),
         full_(false) {}
 
   // 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 string16& input);
 
   // Perform any deferred output processing.  Must be called after the last
   // AddString() call has occured.  Returns |true| if the text had to be
   // truncated to fit the available height.
   bool Finalize();
 
  private:
-  // Returns |true| if |text| is entirely composed of whitespace.
-  bool IsWhitespaceString(const string16& text) const;
-
   // Add a line to the rectangular region at the current position,
   // either by itself or by breaking it into words.
   void AddLine(const string16& line);
 
   // Wrap the specified word across multiple lines.
   int WrapWord(const string16& word);
 
   // Add a long word - wrapping, eliding or truncating per the wrap behavior.
   int AddWordOverflow(const string16& word);
 
@@ skipping 28 matching lines @@
 
   // The current running width.
   int current_width_;
 
   // The current running height.
   int current_height_;
 
   // The current line of text.
   string16 current_line_;
 
+  // Indicates whether the last line ended with \n.
+  bool last_line_ended_in_lf_;
+
   // The output vector of lines.
   std::vector<string16>* lines_;
 
   // Indicates whether there were too many lines for the available height.
   bool full_;
 
   DISALLOW_COPY_AND_ASSIGN(RectangleText);
 };
 
 void RectangleText::AddString(const string16& input) {
   base::i18n::BreakIterator lines(input,
                                   base::i18n::BreakIterator::BREAK_NEWLINE);
   if (lines.Init()) {
     while (!full_ && lines.Advance()) {
       string16 line = lines.GetString();
       // The BREAK_NEWLINE iterator will keep the trailing newline character,
       // except in the case of the last line, which may not have one.  Remove
       // the newline character, if it exists.
-      if (!line.empty() && line[line.length() - 1] == '\n')
+      last_line_ended_in_lf_ = !line.empty() && line[line.length() - 1] == '\n';
+      if (last_line_ended_in_lf_)
         line.resize(line.length() - 1);
       AddLine(line);
     }
   } else {
     NOTREACHED() << "BreakIterator (lines) init failed";
   }
 }
 
 bool RectangleText::Finalize() {
   // Remove trailing whitespace from the last line or remove the last line
   // completely, if it's just whitespace.
   if (!full_ && !lines_->empty()) {
     TrimWhitespace(lines_->back(), TRIM_TRAILING, &lines_->back());
-    if (lines_->back().empty())
+    if (lines_->back().empty() && !last_line_ended_in_lf_)
       lines_->pop_back();
   }
+  if (last_line_ended_in_lf_)
+    lines_->push_back(string16());
   return full_;
 }
 
-bool RectangleText::IsWhitespaceString(const string16& text) const {
-  return text.find_first_not_of(kWhitespaceUTF16) == string16::npos;
-}
-
 void RectangleText::AddLine(const string16& line) {
   const int line_width = font_.GetStringWidth(line);
   if (line_width < available_pixel_width_) {
     AddToCurrentLineWithWidth(line, line_width);
   } 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 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;
             TrimWhitespace(lines_->at(line), TRIM_TRAILING, &lines_->at(line));
           }
-          if (IsWhitespaceString(word)) {
+          if (ContainsOnlyWhitespace(word)) {
             // Skip the first space if the previous line was carried over.
             current_width_ = 0;
             current_line_.clear();
           }
         }
       }
     } else {
       NOTREACHED() << "BreakIterator (words) init failed";
     }
   }
@@ skipping 50 matching lines @@
   string16 trimmed;
   TrimWhitespace(word, TRIM_TRAILING, &trimmed);
   const int trimmed_width = font_.GetStringWidth(trimmed);
   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++;
     // Append the non-trimmed word, in case more words are added after.
     AddToCurrentLine(word);
   } else {
-    lines_added = AddWordOverflow(word);
+    lines_added = AddWordOverflow(wrap_behavior_ == ui::IGNORE_LONG_WORDS ?
+                                  trimmed : word);
   }
   return lines_added;
 }
 
 void RectangleText::AddToCurrentLine(const string16& text) {
   AddToCurrentLineWithWidth(text, font_.GetStringWidth(text));
 }
 
 void RectangleText::AddToCurrentLineWithWidth(const string16& text,
                                               int text_width) {
@@ skipping 103 matching lines @@
       index = char_iterator.getIndex();
     } else {
       // String has leading whitespace, return the elide string.
       return kElideString;
     }
   }
   return string.substr(0, index) + kElideString;
 }
 
 }  // namespace ui