Move text_elider to gfx.

ui/gfx/canvas_skia.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 "ui/gfx/canvas.h"
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "ui/base/text/text_elider.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/render_text.h"
 #include "ui/gfx/shadow_value.h"
+#include "ui/gfx/text_elider.h"
 #include "ui/gfx/text_utils.h"
 
 namespace gfx {
 
 namespace {
 
 // If necessary, wraps |text| with RTL/LTR directionality characters based on
 // |flags| and |text| content.
 // Returns true if the text will be rendered right-to-left.
 // TODO(msw): Nix this, now that RenderTextWin supports directionality directly.
@@ skipping 69 matching lines @@
 }
 
 // Elides |text| and adjusts |range| appropriately. If eliding causes |range|
 // to no longer point to the same character in |text|, |range| is made invalid.
 void ElideTextAndAdjustRange(const FontList& font_list,
                              int width,
                              base::string16* text,
                              gfx::Range* range) {
   const base::char16 start_char =
       (range->IsValid() ? text->at(range->start()) : 0);
-  *text = ui::ElideText(*text, font_list, width, ui::ELIDE_AT_END);
+  *text = gfx::ElideText(*text, font_list, width, gfx::ELIDE_AT_END);
   if (!range->IsValid())
     return;
   if (range->start() >= text->length() ||
       text->at(range->start()) != start_char) {
     *range = gfx::Range::InvalidRange();
   }
 }
 
 // Updates |render_text| from the specified parameters.
 void UpdateRenderText(const Rect& rect,
@@ skipping 59 matching lines @@
   DCHECK_GE(*height, 0);
 
   flags = AdjustPlatformSpecificFlags(text, flags);
 
   base::string16 adjusted_text = text;
 #if defined(OS_WIN)
   AdjustStringDirection(flags, &adjusted_text);
 #endif
 
   if ((flags & MULTI_LINE) && *width != 0) {
-    ui::WordWrapBehavior wrap_behavior = ui::TRUNCATE_LONG_WORDS;
+    gfx::WordWrapBehavior wrap_behavior = gfx::TRUNCATE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
-      wrap_behavior = ui::WRAP_LONG_WORDS;
+      wrap_behavior = gfx::WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
-      wrap_behavior = ui::ELIDE_LONG_WORDS;
+      wrap_behavior = gfx::ELIDE_LONG_WORDS;
 
     Rect rect(*width, INT_MAX);
     std::vector<base::string16> strings;
-    ui::ElideRectangleText(adjusted_text, font_list,
+    gfx::ElideRectangleText(adjusted_text, font_list,
                            rect.width(), rect.height(),
                            wrap_behavior, &strings);
     scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
     UpdateRenderText(rect, base::string16(), font_list, flags, 0,
                      render_text.get());
 
     int h = 0;
     int w = 0;
     for (size_t i = 0; i < strings.size(); ++i) {
       StripAcceleratorChars(flags, &strings[i]);
@@ skipping 46 matching lines @@
   base::string16 adjusted_text = text;
 
 #if defined(OS_WIN)
   AdjustStringDirection(flags, &adjusted_text);
 #endif
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetTextShadows(shadows);
 
   if (flags & MULTI_LINE) {
-    ui::WordWrapBehavior wrap_behavior = ui::IGNORE_LONG_WORDS;
+    gfx::WordWrapBehavior wrap_behavior = gfx::IGNORE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
-      wrap_behavior = ui::WRAP_LONG_WORDS;
+      wrap_behavior = gfx::WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
-      wrap_behavior = ui::ELIDE_LONG_WORDS;
+      wrap_behavior = gfx::ELIDE_LONG_WORDS;
 
     std::vector<base::string16> strings;
-    ui::ElideRectangleText(adjusted_text,
+    gfx::ElideRectangleText(adjusted_text,
                            font_list,
                            text_bounds.width(), text_bounds.height(),
                            wrap_behavior,
                            &strings);
 
     for (size_t i = 0; i < strings.size(); i++) {
       gfx::Range range = StripAcceleratorChars(flags, &strings[i]);
       UpdateRenderText(rect, strings[i], font_list, flags, color,
                        render_text.get());
       int line_padding = 0;
@@ skipping 184 matching lines @@
     size_t desired_characters_to_truncate_from_head,
     const Font& font,
     SkColor color,
     const Rect& display_rect) {
   DrawFadeTruncatingStringRect(text, truncate_mode,
                                desired_characters_to_truncate_from_head,
                                FontList(font), color, display_rect);
 }
 
 }  // namespace gfx