Move text_elider to gfx.

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/base/text/text_elider.h"
+#include "ui/gfx/text_elider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "base/i18n/rtl.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "third_party/icu/source/common/unicode/rbbi.h"
 #include "third_party/icu/source/common/unicode/uloc.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/text_utils.h"
 #include "url/gurl.h"
 
-namespace ui {
+namespace gfx {
 
 // U+2026 in utf8
 const char kEllipsis[] = "\xE2\x80\xA6";
 const char16 kEllipsisUTF16[] = { 0x2026, 0 };
 const char16 kForwardSlash = '/';
 
 namespace {
 
 // Helper class to split + elide text, while respecting UTF16 surrogate pairs.
 class StringSlicer {
@@ skipping 591 matching lines @@
       int lstr_len = rstr_len + ((max_len - 3) % 2);
       output->assign(input.substr(0, lstr_len) + ASCIIToUTF16("...") +
                      input.substr(input.length() - rstr_len));
       break;
     }
   }
 
   return true;
 }
 
-}  // namespace ui
-
 namespace {
 
 // Internal class used to track progress of a rectangular string elide
 // operation.  Exists so the top-level ElideRectangleString() function
 // can be broken into smaller methods sharing this state.
 class RectangleString {
  public:
   RectangleString(size_t max_rows, size_t max_cols,
                   bool strict, string16 *output)
       : max_rows_(max_rows),
@@ skipping 150 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 gfx::FontList& font_list,
                 int available_pixel_width,
                 int available_pixel_height,
-                ui::WordWrapBehavior wrap_behavior,
+                WordWrapBehavior wrap_behavior,
                 std::vector<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),
@@ skipping 47 matching lines @@
   // The height of each line of text.
   const int line_height_;
 
   // The number of pixels of available width in the rectangle.
   const int 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 ui::WordWrapBehavior wrap_behavior_;
+  const WordWrapBehavior wrap_behavior_;
 
   // The current running width.
   int current_width_;
 
   // The current running height.
   int current_height_;
 
   // The current line of text.
   string16 current_line_;
 
@@ skipping 35 matching lines @@
 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());
     if (lines_->back().empty() && !last_line_ended_in_lf_)
       lines_->pop_back();
   }
   if (last_line_ended_in_lf_)
     lines_->push_back(string16());
-  return (insufficient_width_ ? ui::INSUFFICIENT_SPACE_HORIZONTAL : 0) |
-         (insufficient_height_ ? ui::INSUFFICIENT_SPACE_VERTICAL : 0);
+  return (insufficient_width_ ? INSUFFICIENT_SPACE_HORIZONTAL : 0) |
+         (insufficient_height_ ? INSUFFICIENT_SPACE_VERTICAL : 0);
 }
 
 void RectangleText::AddLine(const string16& line) {
   const int line_width = gfx::GetStringWidth(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,
@@ skipping 24 matching lines @@
   NewLine();
 }
 
 int RectangleText::WrapWord(const string16& word) {
   // Word is so wide that it must be fragmented.
   string16 text = word;
   int lines_added = 0;
   bool first_fragment = true;
   while (!insufficient_height_ && !text.empty()) {
     string16 fragment =
-        ui::ElideText(text, font_list_, available_pixel_width_,
-                      ui::TRUNCATE_AT_END);
+        ElideText(text, font_list_, available_pixel_width_,
+                  TRUNCATE_AT_END);
     // At least one character has to be added at every line, even if the
     // available space is too small.
     if(fragment.empty())
       fragment = text.substr(0, 1);
     if (!first_fragment && NewLine())
       lines_added++;
     AddToCurrentLine(fragment);
     text = text.substr(fragment.length());
     first_fragment = false;
   }
   return lines_added;
 }
 
 int RectangleText::AddWordOverflow(const string16& word) {
   int lines_added = 0;
 
   // 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_ == ui::IGNORE_LONG_WORDS) {
+  if (wrap_behavior_ == IGNORE_LONG_WORDS) {
     current_line_ = word;
     current_width_ = available_pixel_width_;
-  } else if (wrap_behavior_ == ui::WRAP_LONG_WORDS) {
+  } else if (wrap_behavior_ == WRAP_LONG_WORDS) {
     lines_added += WrapWord(word);
   } else {
-    const ui::ElideBehavior elide_behavior =
-        (wrap_behavior_ == ui::ELIDE_LONG_WORDS ? ui::ELIDE_AT_END :
-                                                  ui::TRUNCATE_AT_END);
+    const ElideBehavior elide_behavior =
+        (wrap_behavior_ == ELIDE_LONG_WORDS ? ELIDE_AT_END : TRUNCATE_AT_END);
     const string16 elided_word =
-        ui::ElideText(word, font_list_, available_pixel_width_, elide_behavior);
+        ElideText(word, font_list_, available_pixel_width_, elide_behavior);
     AddToCurrentLine(elided_word);
     insufficient_width_ = true;
   }
 
   return lines_added;
 }
 
 int RectangleText::AddWord(const string16& word) {
   int lines_added = 0;
   string16 trimmed;
   TrimWhitespace(word, TRIM_TRAILING, &trimmed);
   const int trimmed_width = gfx::GetStringWidth(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_ == ui::IGNORE_LONG_WORDS ?
+    lines_added = AddWordOverflow(wrap_behavior_ == IGNORE_LONG_WORDS ?
                                   trimmed : word);
   }
   return lines_added;
 }
 
 void RectangleText::AddToCurrentLine(const string16& text) {
   AddToCurrentLineWithWidth(text, gfx::GetStringWidth(text, font_list_));
 }
 
 void RectangleText::AddToCurrentLineWithWidth(const string16& text,
@@ skipping 15 matching lines @@
   } else {
     insufficient_height_ = true;
   }
   current_height_ += line_height_;
   current_width_ = 0;
   return line_added;
 }
 
 }  // namespace
 
-namespace ui {
-
 bool ElideRectangleString(const string16& input, size_t max_rows,
                           size_t max_cols, bool strict, string16* output) {
   RectangleString rect(max_rows, max_cols, strict, output);
   rect.Init();
   rect.AddString(input);
   return rect.Finalize();
 }
 
 int ElideRectangleText(const string16& input,
                        const gfx::FontList& font_list,
@@ skipping 77 matching lines @@
       // Found a valid break point.
       index = char_iterator.getIndex();
     } else {
       // String has leading whitespace, return the elide string.
       return kElideString;
     }
   }
   return string.substr(0, index) + kElideString;
 }
 
-}  // namespace ui
+}  // namespace gfx