Enable subpixel positioning for UI

ui/gfx/render_text_unittest.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.h"
 
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/i18n/break_iterator.h"
@@ skipping 2138 matching lines @@
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(base::StringPrintf("Case %" PRIuS, i));
 
     base::string16 text = WideToUTF16(cases[i]);
     render_text.SetText(text);
     render_text.EnsureLayout();
     ASSERT_EQ(1U, render_text.runs_.size());
     internal::TextRunHarfBuzz* run = render_text.runs_[0];
 
     base::i18n::BreakIterator* iter = render_text.grapheme_iterator_.get();
-    Range first_grapheme_bounds = run->GetGraphemeBounds(iter, 0);
+    auto first_grapheme_bounds = run->GetGraphemeBounds(iter, 0);
     EXPECT_EQ(first_grapheme_bounds, run->GetGraphemeBounds(iter, 1));
-    Range second_grapheme_bounds = run->GetGraphemeBounds(iter, 2);
-    EXPECT_EQ(first_grapheme_bounds.end(), second_grapheme_bounds.start());
+    auto second_grapheme_bounds = run->GetGraphemeBounds(iter, 2);
+    EXPECT_EQ(first_grapheme_bounds.second, second_grapheme_bounds.first);
   }
 }
 
 // Test the partition of a multi-grapheme cluster into grapheme ranges.
 TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemePartition) {
   struct {
     uint32 glyph_to_char[2];
     Range bounds[4];
     bool is_rtl;
   } cases[] = {
@@ skipping 33 matching lines @@
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     std::copy(cases[i].glyph_to_char, cases[i].glyph_to_char + 2,
               run.glyph_to_char.begin());
     run.is_rtl = cases[i].is_rtl;
     for (int j = 0; j < 2; ++j)
       run.positions[j].set(j * 10, 0);
 
     for (size_t j = 0; j < 4; ++j) {
       SCOPED_TRACE(base::StringPrintf("Case %" PRIuS ", char %" PRIuS, i, j));
-      EXPECT_EQ(cases[i].bounds[j], run.GetGraphemeBounds(iter.get(), j));
+      EXPECT_EQ(cases[i].bounds[j],
+                internal::RoundRangeF(run.GetGraphemeBounds(iter.get(), j)));
     }
   }
 }
 
 TEST_F(RenderTextTest, HarfBuzz_RunDirection) {
   RenderTextHarfBuzz render_text;
   const base::string16 mixed =
       WideToUTF16(L"\x05D0\x05D1" L"1234" L"\x05D2\x05D3");
   render_text.SetText(mixed);
   render_text.EnsureLayout();
@@ skipping 71 matching lines @@
 TEST_F(RenderTextTest, HarfBuzz_EmptyRun) {
   internal::TextRunHarfBuzz run;
   const base::string16 kString = ASCIIToUTF16("abcdefgh");
   scoped_ptr<base::i18n::BreakIterator> iter(new base::i18n::BreakIterator(
       kString, base::i18n::BreakIterator::BREAK_CHARACTER));
   ASSERT_TRUE(iter->Init());
 
   run.range = Range(3, 8);
   run.glyph_count = 0;
   EXPECT_EQ(Range(0, 0), run.CharRangeToGlyphRange(Range(4, 5)));
-  EXPECT_EQ(Range(0, 0), run.GetGraphemeBounds(iter.get(), 4));
+  EXPECT_EQ(Range(0, 0),
+            internal::RoundRangeF(run.GetGraphemeBounds(iter.get(), 4)));
   Range chars;
   Range glyphs;
   run.GetClusterAt(4, &chars, &glyphs);
   EXPECT_EQ(Range(3, 8), chars);
   EXPECT_EQ(Range(0, 0), glyphs);
 }
 
 // Ensure a string fits in a display rect with a width equal to the string's.
 TEST_F(RenderTextTest, StringFitsOwnWidth) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
@@ skipping 47 matching lines @@
 
   render_text.SetFontList(font_list);
   // Korean character "han".
   render_text.SetText(WideToUTF16(L"\xd55c"));
   render_text.EnsureLayout();
   ASSERT_EQ(1U, render_text.runs_.size());
   EXPECT_EQ(0U, render_text.runs_[0]->CountMissingGlyphs());
 }
 #endif  // defined(OS_WIN)
 
+// Ensure that the width reported by RenderText is sufficient for drawing. Draws
+// to a canvas and checks whether any pixel beyond the width is colored.
+TEST_F(RenderTextTest, TextDoesntClip) {
+  const wchar_t* kTestStrings[] = { L"Save", L"Remove", L"TEST", L"W", L"WWW" };
+
+  skia::RefPtr<SkCanvas> sk_canvas =
+      skia::AdoptRef(SkCanvas::NewRasterN32(300, 50));
+  scoped_ptr<Canvas> canvas(
+      Canvas::CreateCanvasWithoutScaling(sk_canvas.get(), 1.0f));
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
+  render_text->SetDisplayRect(Rect(300, 50));
+  render_text->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+  render_text->SetColor(SK_ColorBLACK);
+
+  for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
+    sk_canvas->clear(SK_ColorWHITE);
+    render_text->SetText(WideToUTF16(kTestStrings[i]));
+    render_text->SetStyle(BOLD, true);
+    render_text->Draw(canvas.get());
+    int width = render_text->GetStringSize().width();
+    ASSERT_LT(width, 300);
+    const uint32* buffer = static_cast<const uint32*>(
+        sk_canvas->peekPixels(NULL, NULL));
+    ASSERT_NE(nullptr, buffer);
+    for (int y = 0; y < 50; ++y) {
+      EXPECT_EQ(SK_ColorWHITE, buffer[width + y * 300])
+          << "String: " << kTestStrings[i];
+    }
+  }
+}
+
 }  // namespace gfx