Optimize Complex Text Shaping and Caching

Source/platform/fonts/shaping/CachingWordShaperTest.cpp

+// Copyright (c) 2014 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 "config.h"
+
+#include "platform/fonts/FontCache.h"
+#include "platform/fonts/GlyphBuffer.h"
+#include "platform/fonts/shaping/CachingWordShapeIterator.h"
+#include <gtest/gtest.h>
+
+namespace blink {
+
+class CachingWordShaperTest : public ::testing::Test {
+protected:
+    void SetUp() override
+    {
+        fontDescription.setComputedSize(12.0);
+        fontDescription.setScript(USCRIPT_LATIN);
+        fontDescription.setGenericFamily(FontDescription::StandardFamily);
+
+        font = new Font(fontDescription);
+        font->update(nullptr);
+        font->setCanShapeWordByWordForTesting(true);

[drott, 2015/06/23 12:45:52]

Isn't there a small chance that the font found for the configured
FontDescription does have a space in it's kerning or ligatures tables,
potentially leading to inconsistent test results here? Could we instead assert
for the read and computed value of true here, instead of hard-setting it? Or
could we make sure we load a font known to not have spaces in the relevant
tables?

+        fallbackFonts = nullptr;
+        cache = new ShapeCache();
+    }
+
+    void TearDown() override
+    {
+        delete cache;
+        delete font;
+    }
+
+    FontCachePurgePreventer fontCachePurgePreventer;
+    FontDescription fontDescription;
+    Font* font;
+    ShapeCache* cache;
+    HashSet<const SimpleFontData*>* fallbackFonts;
+    unsigned startIndex = 0;
+    unsigned numGlyphs = 0;
+    hb_script_t script = HB_SCRIPT_INVALID;
+};
+
+TEST_F(CachingWordShaperTest, LatinLeftToRightByWord)
+{
+    TextRun textRun(reinterpret_cast<const LChar*>("ABC DEF."), 8);
+
+    RefPtr<ShapeResult> result;
+    CachingWordShapeIterator iterator(cache, textRun, font, fallbackFonts);
+    ASSERT_TRUE(iterator.next(&result));
+    ASSERT_TRUE(result->runInfoForTesting(0, startIndex, numGlyphs, script));
+    EXPECT_EQ(0u, startIndex);
+    EXPECT_EQ(3u, numGlyphs);
+    EXPECT_EQ(HB_SCRIPT_LATIN, script);
+
+    ASSERT_TRUE(iterator.next(&result));
+    ASSERT_TRUE(result->runInfoForTesting(0, startIndex, numGlyphs, script));
+    EXPECT_EQ(0u, startIndex);
+    EXPECT_EQ(1u, numGlyphs);
+    EXPECT_EQ(HB_SCRIPT_COMMON, script);
+
+    ASSERT_TRUE(iterator.next(&result));
+    ASSERT_TRUE(result->runInfoForTesting(0, startIndex, numGlyphs, script));
+    EXPECT_EQ(0u, startIndex);
+    EXPECT_EQ(4u, numGlyphs);
+    EXPECT_EQ(HB_SCRIPT_LATIN, script);
+
+    ASSERT_FALSE(iterator.next(&result));
+}
+
+TEST_F(CachingWordShaperTest, CommonAccentLeftToRightByWord)
+{
+    const UChar str[] = { 0x2F, 0x301, 0x2E, 0x20, 0x2E, 0x0 };

[drott, 2015/06/23 12:45:51]

I am not sure, do our source files allow UTF-8? Can we put the string spelled
out in a comment, just to make it easier to read what's expected? (Here and in
the cases below).

+    TextRun textRun(str, 5);
+
+    unsigned offset = 0;
+    RefPtr<ShapeResult> result;
+    CachingWordShapeIterator iterator(cache, textRun, font, fallbackFonts);
+    ASSERT_TRUE(iterator.next(&result));
+    ASSERT_TRUE(result->runInfoForTesting(0, startIndex, numGlyphs, script));
+    EXPECT_EQ(0u, offset + startIndex);
+    EXPECT_EQ(3u, numGlyphs);
+    EXPECT_EQ(HB_SCRIPT_COMMON, script);
+    offset += result->numCharacters();
+
+    ASSERT_TRUE(iterator.next(&result));
+    ASSERT_TRUE(result->runInfoForTesting(0, startIndex, numGlyphs, script));
+    EXPECT_EQ(3u, offset + startIndex);
+    EXPECT_EQ(1u, numGlyphs);
+    EXPECT_EQ(HB_SCRIPT_COMMON, script);
+    offset += result->numCharacters();
+
+    ASSERT_TRUE(iterator.next(&result));
+    ASSERT_TRUE(result->runInfoForTesting(0, startIndex, numGlyphs, script));
+    EXPECT_EQ(4u, offset + startIndex);
+    EXPECT_EQ(1u, numGlyphs);
+    EXPECT_EQ(HB_SCRIPT_COMMON, script);
+    offset += result->numCharacters();
+
+    ASSERT_EQ(5u, offset);
+    ASSERT_FALSE(iterator.next(&result));
+}
+
+// Tests that filling a glyph buffer for a specific range returns the same
+// results when shaping word by word as when shaping the full run in one go.
+TEST_F(CachingWordShaperTest, CommonAccentLeftToRightFillGlyphBuffer)
+{
+    const UChar str[] = { 0x2F, 0x301, 0x2E, 0x20, 0x2E, 0x0 };
+    TextRun textRun(str, 5);
+
+    CachingWordShaper shaper;
+    GlyphBuffer glyphBuffer;
+    shaper.fillGlyphBuffer(font, textRun, fallbackFonts, &glyphBuffer, 0, 3);
+
+    CachingWordShaper referenceShaper;
+    GlyphBuffer referenceGlyphBuffer;
+    font->setCanShapeWordByWordForTesting(false);
+    referenceShaper.fillGlyphBuffer(font, textRun, fallbackFonts,
+        &referenceGlyphBuffer, 0, 3);
+
+    ASSERT_EQ(referenceGlyphBuffer.glyphAt(0), glyphBuffer.glyphAt(0));
+    ASSERT_EQ(referenceGlyphBuffer.glyphAt(1), glyphBuffer.glyphAt(1));
+    ASSERT_EQ(referenceGlyphBuffer.glyphAt(2), glyphBuffer.glyphAt(2));
+}
+
+// Tests that filling a glyph buffer for a specific range returns the same
+// results when shaping word by word as when shaping the full run in one go.
+TEST_F(CachingWordShaperTest, CommonAccentRightToLeftFillGlyphBuffer)
+{
+    const UChar str[] = { 0x5A, 0x05B, 0x20, 0x5C, 0x301, 0x5E, 0x0 };
+    TextRun textRun(str, 6);
+    textRun.setDirection(RTL);
+
+    CachingWordShaper shaper;
+    GlyphBuffer glyphBuffer;
+    shaper.fillGlyphBuffer(font, textRun, fallbackFonts, &glyphBuffer, 1, 6);
+
+    CachingWordShaper referenceShaper;
+    GlyphBuffer referenceGlyphBuffer;
+    font->setCanShapeWordByWordForTesting(false);
+    referenceShaper.fillGlyphBuffer(font, textRun, fallbackFonts,
+        &referenceGlyphBuffer, 1, 6);
+
+    ASSERT_EQ(5u, referenceGlyphBuffer.size());
+    ASSERT_EQ(referenceGlyphBuffer.size(), glyphBuffer.size());
+
+    ASSERT_EQ(referenceGlyphBuffer.glyphAt(0), glyphBuffer.glyphAt(0));
+    ASSERT_EQ(referenceGlyphBuffer.glyphAt(1), glyphBuffer.glyphAt(1));
+    ASSERT_EQ(referenceGlyphBuffer.glyphAt(2), glyphBuffer.glyphAt(2));
+    ASSERT_EQ(referenceGlyphBuffer.glyphAt(3), glyphBuffer.glyphAt(3));
+    ASSERT_EQ(referenceGlyphBuffer.glyphAt(4), glyphBuffer.glyphAt(4));
+}
+
+} // namespace blink