Add test for FontContext/FontGroup functionality

Unfortunately, this required quite a bit of changes to the non-test
code. That's because FontContext depends on a FontCacheThread, which in
turn depends on a CoreResourceThread and therefore lots of other data
structures.

It seemed like it would be very difficult to instantiate a FontContext
as it was, and even if we could it seems like overkill to have all these
data structures present for a relatively focused test.

Therefore, I created a FontSource trait which represents the interface
which FontContext uses to talk to FontCacheThread. FontCacheThread then
implements FontSource. Then, in the test, we can create a dummy
implementation of FontSource rather than using FontCacheThread.

This actually has the advantage that we can make our dummy
implementation behave in certain specific way which are useful for
testing, for example it can count the number of times
find_font_template() is called, which helps us verify that
caching/lazy-loading is working as intended.

components/gfx/tests/font_context.rs

@@ -0,0 +1,174 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+extern crate app_units;
+extern crate gfx;
+extern crate servo_arc;
+extern crate servo_atoms;
+extern crate style;
+extern crate webrender_api;
+
+use app_units::Au;
+use gfx::font::FontHandleMethods;
+use gfx::font_cache_thread::{FontTemplates, FontTemplateInfo};
+use gfx::font_context::{FontContext, FontContextHandle, FontSource};
+use gfx::font_template::FontTemplateDescriptor;
+use servo_arc::Arc;
+use servo_atoms::Atom;
+use std::cell::Cell;
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::prelude::*;
+use std::path::PathBuf;
+use std::rc::Rc;
+use style::properties::longhands::font_stretch::computed_value::T as FontStretch;
+use style::properties::longhands::font_style::computed_value::T as FontStyle;
+use style::properties::longhands::font_variant_caps::computed_value::T as FontVariantCaps;
+use style::properties::style_structs::Font as FontStyleStruct;
+use style::values::computed::font::{FamilyName, FamilyNameSyntax, FontFamily, FontFamilyList, FontSize};
+use style::values::computed::font::{FontWeight, SingleFontFamily};
+
+struct TestFontSource {
+    handle: FontContextHandle,
+    families: HashMap<Atom, FontTemplates>,
+    find_font_count: Rc<Cell<isize>>,
+}
+
+impl TestFontSource {
+    fn new() -> TestFontSource {
+        let mut csstest_ascii = FontTemplates::new();
+        Self::add_face(&mut csstest_ascii, "csstest-ascii");
+
+        let mut csstest_basic = FontTemplates::new();
+        Self::add_face(&mut csstest_basic, "csstest-basic-regular");
+
+        let mut families = HashMap::new();
+        families.insert(Atom::from("CSSTest ASCII"), csstest_ascii);
+        families.insert(Atom::from("CSSTest Basic"), csstest_basic);
+
+        TestFontSource {
+            handle: FontContextHandle::new(),
+            families,
+            find_font_count: Rc::new(Cell::new(0)),
+        }
+    }
+
+    fn add_face(family: &mut FontTemplates, name: &str) {
+        let mut path: PathBuf = [
+            env!("CARGO_MANIFEST_DIR"),
+            "tests",
+            "support",
+            "CSSTest",
+        ].iter().collect();
+        path.push(format!("{}.ttf", name));
+
+        let file = File::open(path).unwrap();
+
+        family.add_template(
+            Atom::from(name),
+            Some(file.bytes().map(|b| b.unwrap()).collect())
+        )
+    }
+}
+
+impl FontSource for TestFontSource {
+    fn get_font_instance(&mut self, _key: webrender_api::FontKey, _size: Au) -> webrender_api::FontInstanceKey {
+        webrender_api::FontInstanceKey(webrender_api::IdNamespace(0), 0)
+    }
+
+    fn find_font_template(
+        &mut self,
+        family: SingleFontFamily,
+        desc: FontTemplateDescriptor
+    ) -> Option<FontTemplateInfo> {
+        let handle = &self.handle;
+
+        self.find_font_count.set(self.find_font_count.get() + 1);
+        self.families
+            .get_mut(family.atom())
+            .and_then(|family| family.find_font_for_style(&desc, handle))
+            .map(|template| {
+                FontTemplateInfo {
+                    font_template: template,
+                    font_key: webrender_api::FontKey(webrender_api::IdNamespace(0), 0),
+                }
+            })
+    }
+
+    fn last_resort_font_template(&mut self, _desc: FontTemplateDescriptor) -> FontTemplateInfo {
+        unimplemented!();
+    }
+}
+
+fn style() -> FontStyleStruct {
+    let mut style = FontStyleStruct {
+        font_family: FontFamily::serif(),
+        font_style: FontStyle::Normal,
+        font_variant_caps: FontVariantCaps::Normal,
+        font_weight: FontWeight::normal(),
+        font_size: FontSize::medium(),
+        font_stretch: FontStretch::Normal,
+        hash: 0,
+    };
+    style.compute_font_hash();
+    style
+}
+
+fn font_family(names: Vec<&str>) -> FontFamily {
+    let names: Vec<SingleFontFamily> = names.into_iter().map(|name|
+        SingleFontFamily::FamilyName(FamilyName {
+            name: Atom::from(name),
+            syntax: FamilyNameSyntax::Quoted,
+        })
+    ).collect();
+
+    FontFamily(FontFamilyList::new(names.into_boxed_slice()))
+}
+
+#[test]
+fn test_font_group_is_cached_by_style() {
+    let source = TestFontSource::new();
+    let mut context = FontContext::new(source);
+
+    let style1 = style();
+
+    let mut style2 = style();
+    style2.set_font_style(FontStyle::Italic);
+
+    assert_eq!(
+        context.font_group(Arc::new(style1.clone())).as_ptr(),
+        context.font_group(Arc::new(style1.clone())).as_ptr(),
+        "the same font group should be returned for two styles with the same hash"
+    );
+
+    assert_ne!(
+        context.font_group(Arc::new(style1.clone())).as_ptr(),
+        context.font_group(Arc::new(style2.clone())).as_ptr(),
+        "different font groups should be returned for two styles with different hashes"
+    )
+}
+
+#[test]
+fn test_font_group_find_by_codepoint() {
+    let source = TestFontSource::new();
+    let count = source.find_font_count.clone();
+    let mut context = FontContext::new(source);
+
+    let mut style = style();
+    style.set_font_family(font_family(vec!("CSSTest ASCII", "CSSTest Basic")));
+
+    let group = context.font_group(Arc::new(style));
+
+    let font = group.borrow_mut().find_by_codepoint(&mut context, 'a').unwrap();
+    assert_eq!(font.borrow().handle.family_name(), "CSSTest ASCII");
+    assert_eq!(count.get(), 1, "only the first font in the list should have been loaded");
+
+    let font = group.borrow_mut().find_by_codepoint(&mut context, 'a').unwrap();
+    assert_eq!(font.borrow().handle.family_name(), "CSSTest ASCII");
+    assert_eq!(count.get(), 1, "we shouldn't load the same font a second time");
+
+    let font = group.borrow_mut().find_by_codepoint(&mut context, 'á').unwrap();
+    assert_eq!(font.borrow().handle.family_name(), "CSSTest Basic");
+    assert_eq!(count.get(), 2, "both fonts should now have been loaded");
+}

components/gfx/tests/support/CSSTest/LICENSE

@@ -0,0 +1,94 @@
+Copyright (c) 2003-2008 SIL International (http://www.sil.org/),
+with Reserved Font Names "Gentium" and "SIL".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 1 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that the font
+names of derivative works are changed. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

components/gfx/tests/support/CSSTest/README

@@ -0,0 +1,25 @@
+These fonts are a copy of the CSSTest fonts in web-platform-tests, so that we
+can use them for unit-testing our font code. Here is the README from
+web-platform-tests:
+
+-----
+
+These fonts were created to support the testing of the font features
+in CSS, and are required to run some of the tests for those features.
+
+The fonts are modified versions of Gentium Basic, licensed by SIL under
+the Open Font License which allows modifications as long as the terms
+of the license are met.
+
+The original fonts were used to create the family 'CSSTest Basic'. This
+family has four faces and can be used for testing bold / italics.
+A subsetted version of this font with only glyphs for basic ASCII
+characters is 'CSSTest ASCII'.  This was used to make the other
+variations.  Most of the modications are to the name table and character
+maps, for the most part glyphs were not modified.
+
+The fonts are available for download both individually and as a
+ZIP package below.
+
+The files test.html and test.xhtml test that the fonts have been
+correctly installed.