Move a bunch of windows stuff from ui/base/win to ui/gfx/win

ui/gfx/render_text_linux.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/render_text_linux.h"
 
 #include <pango/pangocairo.h>
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkTypeface.h"
-#include "ui/base/text/utf16_indexing.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/font_render_params_linux.h"
 #include "ui/gfx/pango_util.h"
+#include "ui/gfx/utf16_indexing.h"
 
 namespace gfx {
 
 namespace {
 
 // Returns the preceding element in a GSList (O(n)).
 GSList* GSListPrevious(GSList* head, GSList* item) {
   GSList* prev = NULL;
   for (GSList* cur = head; cur != item; cur = cur->next) {
     DCHECK(cur);
@@ skipping 215 matching lines @@
     Rect rect(x, 0, width, height);
     rect.set_origin(ToViewPoint(rect.origin()));
     bounds.push_back(rect);
   }
   g_free(ranges);
   return bounds;
 }
 
 size_t RenderTextLinux::TextIndexToLayoutIndex(size_t index) const {
   DCHECK(layout_);
-  ptrdiff_t offset = ui::UTF16IndexToOffset(text(), 0, index);
+  ptrdiff_t offset = gfx::UTF16IndexToOffset(text(), 0, index);
   // Clamp layout indices to the length of the text actually used for layout.
   offset = std::min<size_t>(offset, g_utf8_strlen(layout_text_, -1));
   const char* layout_pointer = g_utf8_offset_to_pointer(layout_text_, offset);
   return (layout_pointer - layout_text_);
 }
 
 size_t RenderTextLinux::LayoutIndexToTextIndex(size_t index) const {
   DCHECK(layout_);
   const char* layout_pointer = layout_text_ + index;
   const long offset = g_utf8_pointer_to_offset(layout_text_, layout_pointer);
-  return ui::UTF16OffsetToIndex(text(), 0, offset);
+  return gfx::UTF16OffsetToIndex(text(), 0, offset);
 }
 
 bool RenderTextLinux::IsCursorablePosition(size_t position) {
   if (position == 0 && text().empty())
     return true;
   if (position >= text().length())
     return position == text().length();
-  if (!ui::IsValidCodePointIndex(text(), position))
+  if (!gfx::IsValidCodePointIndex(text(), position))
     return false;
 
   EnsureLayout();
-  ptrdiff_t offset = ui::UTF16IndexToOffset(text(), 0, position);
+  ptrdiff_t offset = gfx::UTF16IndexToOffset(text(), 0, position);
   // Check that the index corresponds with a valid text code point, that it is
   // marked as a legitimate cursor position by Pango, and that it is not
   // truncated from layout text (its glyph is shown on screen).
   return (offset < num_log_attrs_ && log_attrs_[offset].is_cursor_position &&
           offset < g_utf8_strlen(layout_text_, -1));
 }
 
 void RenderTextLinux::ResetLayout() {
   // set_cached_bounds_and_offset_valid(false) is done in RenderText for every
   // operation that triggers ResetLayout().
@@ skipping 215 matching lines @@
                                           int glyph_index) const {
   return LayoutIndexToTextIndex(run->item->offset +
                                 run->glyphs->log_clusters[glyph_index]);
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextLinux;
 }
 
 }  // namespace gfx