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

ui/gfx/render_text_win.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_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "third_party/icu/source/common/unicode/uchar.h"
-#include "ui/base/text/utf16_indexing.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_fallback_win.h"
 #include "ui/gfx/font_smoothing_win.h"
 #include "ui/gfx/platform_font_win.h"
+#include "ui/gfx/utf16_indexing.h"
 
 namespace gfx {
 
 namespace {
 
 // The maximum length of text supported for Uniscribe layout and display.
 // This empirically chosen value should prevent major performance degradations.
 // TODO(msw): Support longer text, partial layout/painting, etc.
 const size_t kMaxUniscribeTextLength = 10000;
 
@@ skipping 374 matching lines @@
         bounds.pop_back();
       }
       bounds.push_back(rect);
     }
   }
   return bounds;
 }
 
 size_t RenderTextWin::TextIndexToLayoutIndex(size_t index) const {
   DCHECK_LE(index, text().length());
-  ptrdiff_t i = obscured() ? ui::UTF16IndexToOffset(text(), 0, index) : index;
+  ptrdiff_t i = obscured() ? gfx::UTF16IndexToOffset(text(), 0, index) : index;
   CHECK_GE(i, 0);
   // Clamp layout indices to the length of the text actually used for layout.
   return std::min<size_t>(GetLayoutText().length(), i);
 }
 
 size_t RenderTextWin::LayoutIndexToTextIndex(size_t index) const {
   if (!obscured())
     return index;
 
   DCHECK_LE(index, GetLayoutText().length());
-  const size_t text_index = ui::UTF16OffsetToIndex(text(), 0, index);
+  const size_t text_index = gfx::UTF16OffsetToIndex(text(), 0, index);
   DCHECK_LE(text_index, text().length());
   return text_index;
 }
 
 bool RenderTextWin::IsCursorablePosition(size_t position) {
   if (position == 0 || position == text().length())
     return true;
   EnsureLayout();
 
   // Check that the index is at a valid code point (not mid-surrgate-pair),
   // that it is not truncated from layout text (its glyph is shown on screen),
   // and that its glyph has distinct bounds (not mid-multi-character-grapheme).
   // An example of a multi-character-grapheme that is not a surrogate-pair is:
   // \x0915\x093f - (ki) - one of many Devanagari biconsonantal conjuncts.
-  return ui::IsValidCodePointIndex(text(), position) &&
+  return gfx::IsValidCodePointIndex(text(), position) &&
          position < LayoutIndexToTextIndex(GetLayoutText().length()) &&
          GetGlyphBounds(position) != GetGlyphBounds(position - 1);
 }
 
 void RenderTextWin::ResetLayout() {
   // Layout is performed lazily as needed for drawing/metrics.
   needs_layout_ = true;
 }
 
 void RenderTextWin::EnsureLayout() {
@@ skipping 139 matching lines @@
     run->script_analysis = script_item->a;
 
     // Find the next break and advance the iterators as needed.
     const size_t script_item_break = (script_item + 1)->iCharPos;
     run_break = std::min(script_item_break,
                          TextIndexToLayoutIndex(style.GetRange().end()));
 
     // Clamp run lengths to avoid exceeding the maximum supported glyph count.
     if ((run_break - run->range.start()) > max_run_length) {
       run_break = run->range.start() + max_run_length;
-      if (!ui::IsValidCodePointIndex(layout_text, run_break))
+      if (!gfx::IsValidCodePointIndex(layout_text, run_break))
         --run_break;
     }
 
     // Break runs between characters in different code blocks. This avoids using
     // fallback fonts for more characters than needed. http://crbug.com/278913
     if (run_break > run->range.start()) {
       const size_t run_start = run->range.start();
       const int32 run_length = static_cast<int32>(run_break - run_start);
       base::i18n::UTF16CharIterator iter(layout_text.c_str() + run_start,
                                          run_length);
       const UBlockCode first_block_code = ublock_getCode(iter.get());
       while (iter.Advance() && iter.array_pos() < run_length) {
         if (ublock_getCode(iter.get()) != first_block_code) {
           run_break = run_start + iter.array_pos();
           break;
         }
       }
     }
 
-    DCHECK(ui::IsValidCodePointIndex(layout_text, run_break));
+    DCHECK(gfx::IsValidCodePointIndex(layout_text, run_break));
 
     style.UpdatePosition(LayoutIndexToTextIndex(run_break));
     if (script_item_break == run_break)
       script_item++;
     run->range.set_end(run_break);
     runs_.push_back(run);
   }
 
   // Undo the temporarily applied composition underlines and selection colors.
   UndoCompositionAndSelectionStyles();
@@ skipping 289 matching lines @@
   size_t position = LayoutIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx