Optimize Complex Text Shaping and Caching

Source/platform/fonts/shaping/CachingWordShaperTest.cpp

Index: Source/platform/fonts/shaping/CachingWordShaperTest.cpp
diff --git a/Source/platform/fonts/shaping/CachingWordShaperTest.cpp b/Source/platform/fonts/shaping/CachingWordShaperTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b94b84d7ba2a3587113471104c30983bb840723
--- /dev/null
+++ b/Source/platform/fonts/shaping/CachingWordShaperTest.cpp
@@ -0,0 +1,157 @@
+// 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/07/08 13:00:59]

Probably a rare case, but I feel like if the a case is hit, it would be pretty
hard to debug, that's why I bring it up again.

How about just the following instead:
ASSERT_TRUE(font->canShapeWordByWord()); // We need a font that is suitable for
word-based caching for testing.

If the acquired font here would have space-ligatures, it would cause test
failures in CommonAccentLeftToRightFillGlyphBuffer and
CommonAccentRightToLeftFillGlyphBuffer that are due to the fact that word-based
caching was forced-on even though the font doesn't support it. But the intention
of the tests is only to guarantee that non-caching and caching path produce the
same results under the assumption the font canShapeWordByWord(). 

+        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 };
+    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)
+{
+    // "/. ." with an accent mark over the first dot.
+    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)
+{
+    // "[] []" with an accent mark over the last square bracket.
+    const UChar str[] = { 0x5B, 0x5D, 0x20, 0x5B, 0x301, 0x5D, 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