Seperate freetype face and named instance indices (#39213)

In servo, each `LocalFontIdentifier` has an `fn index() -> u32`, which
returns the index of the font within the font file in case it is a font
collection (`.ttc` instead of `.ttf`). The way this index is obtained is
platform-dependent.

On systems using `fontconfig`, we get the index by querying `FC_INDEX`:


d2c78db981/components/fonts/platform/freetype/font_list.rs (L109-L112)

There is a sneaky bug here: In addition to the aforementioned face
index, the value for `FC_INDEX` contains the index of the named instance
of the face in the upper 16 bits. This behaviour is completely
undocumented, but FreeType uses the same format:
https://freetype.org/freetype2/docs/reference/ft2-face_creation.html#ft_open_face.

This wasn't a problem for the longest time, because the only consumer of
the `index` value coming from fontconfig was FreeType. However, sometime
after
29e618dcf7,
we started also passing it to`read-fonts` . `read-fonts` expects only
the face index, causing it to return errors as seen in
https://github.com/servo/servo/issues/39209.

The fix is to seperate the two indices when storing them in a
`LocalFontDescriptor` and pass only the lower 16 bits to `read-fonts`.
I'm unsure whether we should continue passing the named instance index
to FreeType since we don't actually support variable fonts, but I've
opted to keep the current behaviour for now.

Fixes: https://github.com/servo/servo/issues/39209

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

components/shared/fonts/font_identifier.rs

@@ -41,18 +41,26 @@ mod platform {
         /// The path to the font.
         pub path: Atom,
         /// The variation index within the font.
-        pub variation_index: i32,
+        pub face_index: u16,
+        /// The index of the named instance within the font.
+        ///
+        /// For non-variable fonts, this is ignored.
+        pub named_instance_index: u16,
     }
 
     impl LocalFontIdentifier {
         pub fn index(&self) -> u32 {
-            self.variation_index.try_into().unwrap()
+            self.face_index as u32
+        }
+
+        pub fn named_instance_index(&self) -> u32 {
+            self.named_instance_index as u32
         }
 
         pub fn native_font_handle(&self) -> NativeFontHandle {
             NativeFontHandle {
                 path: PathBuf::from(&*self.path),
-                index: self.variation_index as u32,
+                index: self.face_index as u32,
             }
         }
 
@@ -64,9 +72,20 @@ mod platform {
 
             Some(FontDataAndIndex {
                 data,
-                index: self.variation_index as u32,
+                index: self.face_index as u32,
             })
         }
+
+        /// Fontconfig and FreeType use a packed format to represent face and
+        /// named instance indexes in a single integer. The first 16 bits make
+        /// up the named instance index and the second 16 bits make up the
+        /// face index.
+        ///
+        /// See <https://freetype.org/freetype2/docs/reference/ft2-face_creation.html#ft_open_face>
+        /// for more information.
+        pub fn face_index_for_freetype(&self) -> u32 {
+            ((self.named_instance_index()) << 16) | self.index()
+        }
     }
 }