Move TrimWhitespace to the base namespace.

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 562 matching lines @@
     }
   } else {
     NOTREACHED() << "BreakIterator (lines) init failed";
   }
 }
 
 int RectangleText::Finalize() {
   // Remove trailing whitespace from the last line or remove the last line
   // completely, if it's just whitespace.
   if (!insufficient_height_ && !lines_->empty()) {
-    TrimWhitespace(lines_->back(), TRIM_TRAILING, &lines_->back());
+    base::TrimWhitespace(lines_->back(), base::TRIM_TRAILING, &lines_->back());
     if (lines_->back().empty() && !last_line_ended_in_lf_)
       lines_->pop_back();
   }
   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);
   } 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;
-            TrimWhitespace(lines_->at(line), TRIM_TRAILING, &lines_->at(line));
+            base::TrimWhitespace(lines_->at(line), base::TRIM_TRAILING,
+                                 &lines_->at(line));
           }
           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 48 matching lines @@
     AddToCurrentLine(elided_word);
     insufficient_width_ = true;
   }
 
   return lines_added;
 }
 
 int RectangleText::AddWord(const base::string16& word) {
   int lines_added = 0;
   base::string16 trimmed;
-  TrimWhitespace(word, TRIM_TRAILING, &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++;
     // 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);
@@ skipping 112 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