Debase our Uniscribe code. This moves FontUtils and all our Uniscribe code fr...

webkit/port/platform/graphics/UniscribeHelper_unittest.cpp

 // Copyright (c) 2006-2008 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 "base/gfx/uniscribe.h"
-#include "base/win_util.h"
+#include "config.h"
+#include "UniscribeHelper.h"
+
+#include "PlatformString.h"
 #include "testing/gtest/include/gtest/gtest.h"

[Erik does not do reviews, 2008/11/17 17:01:34]

Do you think it will be an issue to land gtest dependencies? I know we've got
others already, but I'm just curious whether we need to come up with a different
plan here.

[brettw, 2008/11/17 17:26:49]

I don't know about gtest. Eric Seidel has tried to get gtest upstream. I think
we'll just see how it goes.

 
 // This must be in the gfx namespace for the friend statements in uniscribe.h
 // to work.
-namespace gfx {
+namespace WebCore {
 
 namespace {
 
 class UniscribeTest : public testing::Test {
- public:
-  UniscribeTest() {
-  }
+public:
+    UniscribeTest()
+    {
+    }
 
-  // Returns an HFONT with the given name. The caller does not have to free
-  // this, it will be automatically freed at the end of the test. Returns NULL
-  // on failure. On success, the
-  HFONT MakeFont(const wchar_t* font_name, SCRIPT_CACHE** cache) {
-    LOGFONT lf;
-    memset(&lf, 0, sizeof(LOGFONT));
-    lf.lfHeight = 20;
-    wcscpy_s(lf.lfFaceName, font_name);
+    // Returns an HFONT with the given name. The caller does not have to free
+    // this, it will be automatically freed at the end of the test. Returns NULL
+    // on failure. On success, the
+    HFONT MakeFont(const wchar_t* fontName, SCRIPT_CACHE** cache)
+    {
+        LOGFONT lf;
+        memset(&lf, 0, sizeof(LOGFONT));
+        lf.lfHeight = 20;
+        wcscpy_s(lf.lfFaceName, fontName);
 
-    HFONT hfont = CreateFontIndirect(&lf);
-    if (!hfont)
-      return NULL;
+        HFONT hfont = CreateFontIndirect(&lf);
+        if (!hfont)
+            return NULL;
 
-    *cache = new SCRIPT_CACHE;
-    **cache = NULL;
-    created_fonts_.push_back(std::make_pair(hfont, *cache));
-    return hfont;
-  }
+        *cache = new SCRIPT_CACHE;
+        **cache = NULL;
+        m_createdFonts.append(std::make_pair(hfont, *cache));
+        return hfont;
+    }
 
- protected:
-  // Default font properties structure for tests to use.
-  SCRIPT_FONTPROPERTIES properties_;
+protected:
+    // Default font properties structure for tests to use.
+    SCRIPT_FONTPROPERTIES m_properties;
 
- private:
-  virtual void SetUp() {
-    memset(&properties_, 0, sizeof(SCRIPT_FONTPROPERTIES));
-    properties_.cBytes = sizeof(SCRIPT_FONTPROPERTIES);
-    properties_.wgBlank = ' ';
-    properties_.wgDefault = '?';  // Used when the character is not in the font.
-    properties_.wgInvalid = '#';  // Used for invalid characters.
-  }
+private:
+    virtual void SetUp()
+    {
+        memset(&m_properties, 0, sizeof(SCRIPT_FONTPROPERTIES));
+        m_properties.cBytes = sizeof(SCRIPT_FONTPROPERTIES);
+        m_properties.wgBlank = ' ';
+        m_properties.wgDefault = '?';  // Used when the char is not in the font.
+        m_properties.wgInvalid = '#';  // Used for invalid characters.
+    }
 
-  virtual void TearDown() {
-    // Free any allocated fonts.
-    for (size_t i = 0; i < created_fonts_.size(); i++) {
-      DeleteObject(created_fonts_[i].first);
-      ScriptFreeCache(created_fonts_[i].second);
-      delete created_fonts_[i].second;
+    virtual void TearDown()
+    {
+        // Free any allocated fonts.
+        for (size_t i = 0; i < m_createdFonts.size(); i++) {
+            DeleteObject(m_createdFonts[i].first);
+            ScriptFreeCache(m_createdFonts[i].second);
+            delete m_createdFonts[i].second;
+        }
+        m_createdFonts.clear();
     }
-    created_fonts_.clear();
-  }
 
-  // Tracks allocated fonts so we can delete them at the end of the test.
-  // The script cache pointer is heap allocated and must be freed.
-  std::vector< std::pair<HFONT, SCRIPT_CACHE*> > created_fonts_;
-
-  DISALLOW_EVIL_CONSTRUCTORS(UniscribeTest);
+    // Tracks allocated fonts so we can delete them at the end of the test.
+    // The script cache pointer is heap allocated and must be freed.
+    Vector< std::pair<HFONT, SCRIPT_CACHE*> > m_createdFonts;
 };
 
 }  // namespace
 
 // This test tests giving Uniscribe a very large buffer, which will cause a
 // failure.
-TEST_F(UniscribeTest, TooBig) {
-  // This test will only run on Windows XP. It seems Uniscribe does not have the
-  // internal limit on Windows 2000 that we rely on to cause this failure.
-  if (win_util::GetWinVersion() <= win_util::WINVERSION_2000)
-    return;
+TEST_F(UniscribeTest, TooBig)
+{
+    // Make a large string with an e with a zillion combining accents.
+    String input(L"e");
+    for (int i = 0; i < 100000; i++)
+        input.append(static_cast<UChar>(0x301));  // Combining acute accent.
 
-  // Make a large string with an e with a zillion combining accents.
-  std::wstring input(L"e");
-  for (int i = 0; i < 100000; i++)
-    input.push_back(0x301);  // Combining acute accent.
+    SCRIPT_CACHE* scriptCache;
+    HFONT hfont = MakeFont(L"Times New Roman", &scriptCache);
+    ASSERT_TRUE(hfont);
 
-  SCRIPT_CACHE* script_cache;
-  HFONT hfont = MakeFont(L"Times New Roman", &script_cache);
-  ASSERT_TRUE(hfont);
+    // Test a long string without the normal length protection we have. This
+    // will cause shaping to fail.
+    {
+        UniscribeHelper uniscribe(
+            input.characters(), static_cast<int>(input.length()),
+            false, hfont, scriptCache, &m_properties);
+        uniscribe.InitWithOptionalLengthProtection(false);
 
-  // Test a long string without the normal length protection we have. This will
-  // cause shaping to fail.
-  {
-    gfx::UniscribeState uniscribe(input.data(), static_cast<int>(input.size()),
-                                  false, hfont, script_cache, &properties_);
-    uniscribe.InitWithOptionalLengthProtection(false);
+        // There should be one shaping entry, with nothing in it.
+        ASSERT_EQ(1, uniscribe.m_shapes.size());
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_glyphs.size());
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_logs.size());
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_visattr.size());
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_advance.size());
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_offsets.size());
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_justify.size());
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcA);
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcB);
+        EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcC);
 
-    // There should be one shaping entry, with nothing in it.
-    ASSERT_EQ(1, uniscribe.shapes_->size());
-    EXPECT_EQ(0, uniscribe.shapes_[0].glyphs->size());
-    EXPECT_EQ(0, uniscribe.shapes_[0].logs->size());
-    EXPECT_EQ(0, uniscribe.shapes_[0].visattr->size());
-    EXPECT_EQ(0, uniscribe.shapes_[0].advance->size());
-    EXPECT_EQ(0, uniscribe.shapes_[0].offsets->size());
-    EXPECT_EQ(0, uniscribe.shapes_[0].justify->size());
-    EXPECT_EQ(0, uniscribe.shapes_[0].abc.abcA);
-    EXPECT_EQ(0, uniscribe.shapes_[0].abc.abcB);
-    EXPECT_EQ(0, uniscribe.shapes_[0].abc.abcC);
+        // The sizes of the other stuff should match the shaping entry.
+        EXPECT_EQ(1, uniscribe.m_runs.size());
+        EXPECT_EQ(1, uniscribe.m_screenOrder.size());
 
-    // The sizes of the other stuff should match the shaping entry.
-    EXPECT_EQ(1, uniscribe.runs_->size());
-    EXPECT_EQ(1, uniscribe.screen_order_->size());
+        // Check that the various querying functions handle the empty case
+        // properly.
+        EXPECT_EQ(0, uniscribe.Width());
+        EXPECT_EQ(0, uniscribe.FirstGlyphForCharacter(0));
+        EXPECT_EQ(0, uniscribe.FirstGlyphForCharacter(1000));
+        EXPECT_EQ(0, uniscribe.XToCharacter(0));
+        EXPECT_EQ(0, uniscribe.XToCharacter(1000));
+    }
 
-    // Check that the various querying functions handle the empty case properly.
-    EXPECT_EQ(0, uniscribe.Width());
-    EXPECT_EQ(0, uniscribe.FirstGlyphForCharacter(0));
-    EXPECT_EQ(0, uniscribe.FirstGlyphForCharacter(1000));
-    EXPECT_EQ(0, uniscribe.XToCharacter(0));
-    EXPECT_EQ(0, uniscribe.XToCharacter(1000));
-  }
+    // Now test the very large string and make sure it is handled properly by
+    // the length protection.
+    {
+        UniscribeHelper uniscribe(
+            input.characters(), static_cast<int>(input.length()),
+            false, hfont, scriptCache, &m_properties);
+        uniscribe.InitWithOptionalLengthProtection(true);
 
-  // Now test the very large string and make sure it is handled properly by the
-  // length protection.
-  {
-    gfx::UniscribeState uniscribe(input.data(), static_cast<int>(input.size()),
-                                  false, hfont, script_cache, &properties_);
-    uniscribe.InitWithOptionalLengthProtection(true);
+        // There should be 0 runs and shapes.
+        EXPECT_EQ(0, uniscribe.m_runs.size());
+        EXPECT_EQ(0, uniscribe.m_shapes.size());
+        EXPECT_EQ(0, uniscribe.m_screenOrder.size());
 
-    // There should be 0 runs and shapes.
-    EXPECT_EQ(0, uniscribe.runs_->size());
-    EXPECT_EQ(0, uniscribe.shapes_->size());
-    EXPECT_EQ(0, uniscribe.screen_order_->size());
-
-    EXPECT_EQ(0, uniscribe.Width());
-    EXPECT_EQ(0, uniscribe.FirstGlyphForCharacter(0));
-    EXPECT_EQ(0, uniscribe.FirstGlyphForCharacter(1000));
-    EXPECT_EQ(0, uniscribe.XToCharacter(0));
-    EXPECT_EQ(0, uniscribe.XToCharacter(1000));
-  }
+        EXPECT_EQ(0, uniscribe.Width());
+        EXPECT_EQ(0, uniscribe.FirstGlyphForCharacter(0));
+        EXPECT_EQ(0, uniscribe.FirstGlyphForCharacter(1000));
+        EXPECT_EQ(0, uniscribe.XToCharacter(0));
+        EXPECT_EQ(0, uniscribe.XToCharacter(1000));
+    }
 }
 
 }  // namespace gfx

[Erik does not do reviews, 2008/11/17 17:01:34]

update comment

-