DNCI [RenderText] Added font size options in RenderText.

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 710 matching lines @@
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->set_truncate_length(5);
   for (size_t i = 0; i < arraysize(cases); i++) {
     render_text->SetText(WideToUTF16(cases[i].text));
     EXPECT_EQ(WideToUTF16(cases[i].text), render_text->text());
     EXPECT_EQ(WideToUTF16(cases[i].display_text), render_text->GetDisplayText())
         << "For case " << i << ": " << cases[i].text;
   }
 }
 
+TEST_F(RenderTextTest, FontSize) {
+  SCOPED_TRACE("FontSize");
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
+  const wchar_t* string = L"0gl1gl2gl3gl";
+  render_text->SetText(WideToUTF16(string));
+  const Size kCanvasSize(150, 55);
+  const int kTestSize = 10;
+
+  struct Tests {
+    int a_size;
+    int b_size;
+    int c_size;
+    BaselineStyle a_baseline;
+    bool b_bold;
+    SkColor c_color;
+  } const kTests[] = {
+      {18, 26, 0, NORMAL_BASELINE, false, SK_ColorBLACK},
+      {26, 18, 8, SUPERSCRIPT, true, SK_ColorLTGRAY},
+      {18, 26, 0, INFERIOR, false, SK_ColorRED},
+      {26, 18, 8, SUPERIOR, true, SK_ColorBLUE},
+  };
+
+  render_text->SetHorizontalAlignment(ALIGN_LEFT);
+  render_text->SetVerticalAlignment(VALIGN_TOP);
+  skia::RefPtr<SkSurface> surface = skia::AdoptRef(
+      SkSurface::NewRasterN32Premul(kCanvasSize.width(), kCanvasSize.height()));
+  scoped_ptr<Canvas> canvas(
+      Canvas::CreateCanvasWithoutScaling(surface->getCanvas(), 1.0f));
+  Rect bounds = Rect(kTestSize, kTestSize, kCanvasSize.width() - kTestSize * 2,
+                     kCanvasSize.height() - kTestSize * 2);
+  render_text->SetDisplayRect(bounds);
+  render_text->set_clip_to_display_rect(false);
+  const uint32* buffer =
+      static_cast<const uint32*>(surface->peekPixels(nullptr, nullptr));
+  ASSERT_NE(nullptr, buffer);
+  TestRectangleBuffer rect_buffer(string, buffer, kCanvasSize.width(),

[msw, 2015/03/30 21:14:35]

As in the vertical alignment CL, I hope that testing for the pixel content isn't
necessary. Can we just inspect the TextRunHarfBuzz values and the changes to the
height of GetStringSize[F], etc.?

+                                  kCanvasSize.height());
+  for (const auto& test : kTests) {
+    surface->getCanvas()->clear(SK_ColorWHITE);
+    render_text->ApplyFontSize(test.a_size, Range(0, 3));
+    render_text->ApplyFontSize(test.b_size, Range(3, 6));
+    render_text->ApplyFontSize(test.c_size, Range(6, 9));
+    render_text->ApplyBaselineStyle(test.a_baseline, Range(2, 3));
+    render_text->ApplyStyle(BOLD, test.b_bold, Range(4, 6));
+    render_text->ApplyColor(test.c_color, Range(7, 9));
+    const Size string_size = render_text->GetStringSize();
+    ASSERT_LE(string_size.width() + kTestSize * 2, kCanvasSize.width());
+    ASSERT_LE(string_size.height() + kTestSize * 2, kCanvasSize.height());
+    Rect expected_rect(kTestSize, kTestSize, string_size.width(),
+                       string_size.height());
+    render_text->Draw(canvas.get());
+    expected_rect.Inset(-1, -1);
+    rect_buffer.EnsureSolidBorder(SK_ColorWHITE, expected_rect);
+  }
+}
+
 TEST_F(RenderTextTest, TruncatedObscuredText) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->set_truncate_length(3);
   render_text->SetObscured(true);
   render_text->SetText(WideToUTF16(L"abcdef"));
   EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
   EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetDisplayText());
 }
 
 TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
@@ skipping 1990 matching lines @@
   const uint32* buffer =
       static_cast<const uint32*>(surface->peekPixels(nullptr, nullptr));
   ASSERT_NE(nullptr, buffer);
   TestRectangleBuffer rect_buffer(string, buffer, kCanvasSize.width(),
                                   kCanvasSize.height());
   ASSERT_LE(string_size.width() + kTestSize * 2, kCanvasSize.width());
   ASSERT_LE(string_size.height() + kTestSize * 2, kCanvasSize.height());
   for (const auto& test : kTests) {
     SCOPED_TRACE(base::StringPrintf("VerticalAlignement H %i, V %i",
                                     test.horizontal, test.vertical));
-
     surface->getCanvas()->clear(SK_ColorWHITE);
     render_text->SetHorizontalAlignment(test.horizontal);
     render_text->SetVerticalAlignment(test.vertical);
     EXPECT_EQ(test.x - kTestSize, render_text->GetAlignmentOffset(0).x());
     EXPECT_EQ(test.y - kTestSize, render_text->GetAlignmentOffset(0).y());
     Rect expected_rect(test.x, test.y, string_size.width(),
                        string_size.height());
     expected_rect.Inset(-1, -1);
     render_text->Draw(canvas.get());
     rect_buffer.EnsureSolidBorder(SK_ColorWHITE, expected_rect);
@@ skipping 217 matching lines @@
   string_size.set_width(string_size.width() / 2);
   render_text.SetDisplayRect(gfx::Rect(string_size));
   render_text.EnsureLayout();
   CFIndex glyph_count = CTLineGetGlyphCount(render_text.line_);
   EXPECT_GT(text.size(), static_cast<size_t>(glyph_count));
   EXPECT_NE(0, glyph_count);
 }
 #endif
 
 }  // namespace gfx