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

base/string_util.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 "base/string_util.h"
 
 #include "build/build_config.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ skipping 360 matching lines @@
   return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
 }
 #endif
 
 std::string CollapseWhitespaceASCII(const std::string& text,
                                     bool trim_sequences_with_line_breaks) {
   return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
 }
 
 bool ContainsOnlyWhitespaceASCII(const std::string& str) {
   for (std::string::const_iterator i(str.begin()); i != str.end(); ++i) {

[tfarina, 2012/05/15 02:49:52]

Can we simplify this as well?

[Alexei Svitkine (slow), 2012/05/15 03:04:23]

I considered it, but unfortunately kWhitespaceASCII is not the same set as
what's checked by IsAsciiWhitespace() and I didn't want to change any behaviour
here with this cleanup.

(I don't understand the implications of this change to judge whether it would be
correct to make it.)

     if (!IsAsciiWhitespace(*i))
       return false;
   }
   return true;
 }
 
 bool ContainsOnlyWhitespace(const string16& str) {
-  for (string16::const_iterator i(str.begin()); i != str.end(); ++i) {
-    if (!IsWhitespace(*i))
-      return false;
-  }
-  return true;
+  return str.find_first_not_of(kWhitespaceUTF16) == string16::npos;
 }
 
 template<typename STR>
 static bool ContainsOnlyCharsT(const STR& input, const STR& characters) {
   for (typename STR::const_iterator iter = input.begin();
        iter != input.end(); ++iter) {
     if (characters.find(*iter) == STR::npos)
       return false;
   }
   return true;
@@ skipping 642 matching lines @@
 }
 
 }  // namespace
 
 size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
   return lcpyT<char>(dst, src, dst_size);
 }
 size_t base::wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }