From 52ef0d62e98d98dbeac09379a6e1e47c75a26c1f Mon Sep 17 00:00:00 2001
From: hellofromtonya <tonya.mork@automattic.com>
Date: Tue, 17 Jan 2023 16:00:30 -0600
Subject: [PATCH] Rename and deprecate WP_Web_Fonts

---
 lib/compat/wordpress-6.2/script-loader.php    |   2 +-
 lib/experimental/fonts-api/class-wp-fonts.php | 744 ++++++++++++++++++
 .../{ => deprecations}/class-wp-web-fonts.php |  49 +-
 .../class-wp-webfonts-provider.php            |   2 +-
 lib/experimental/fonts-api/fonts-api.php      |  10 +-
 lib/load.php                                  |   2 +-
 phpunit/fonts-api/wp-fonts-testcase.php       |  34 +-
 phpunit/fonts-api/wp-fonts-tests-dataset.php  |   8 +-
 .../fonts-api/wpDeregisterFontFamily-test.php |   4 +-
 phpunit/fonts-api/wpEnqueueFonts-test.php     |  10 +-
 phpunit/fonts-api/wpFonts-test.php            |   4 +-
 .../{wpWebfonts => wpFonts}/add-test.php      |  14 +-
 .../addFontFamily-test.php                    |  14 +-
 .../addVariation-test.php                     |  70 +-
 .../{wpWebfonts => wpFonts}/dequeue-test.php  |  36 +-
 .../{wpWebfonts => wpFonts}/doItem-test.php   |  78 +-
 .../{wpWebfonts => wpFonts}/doItems-test.php  |  44 +-
 .../{wpWebfonts => wpFonts}/enqueue-test.php  |  24 +-
 .../getEnqueued-test.php                      |  24 +-
 .../getProviders-test.php                     |  20 +-
 .../getRegistered-test.php                    |  24 +-
 .../{wpWebfonts => wpFonts}/query-test.php    |  44 +-
 .../registerProvider-test.php                 |  26 +-
 .../{wpWebfonts => wpFonts}/remove-test.php   |  20 +-
 .../removeFontFamily-test.php                 |  46 +-
 .../removeVariation-test.php                  | 102 +--
 phpunit/fonts-api/wpPrintFonts-test.php       |   6 +-
 phpunit/fonts-api/wpRegisterFonts-test.php    |   4 +-
 28 files changed, 1084 insertions(+), 381 deletions(-)
 create mode 100644 lib/experimental/fonts-api/class-wp-fonts.php
 rename lib/experimental/fonts-api/{ => deprecations}/class-wp-web-fonts.php (96%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/add-test.php (60%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/addFontFamily-test.php (75%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/addVariation-test.php (63%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/dequeue-test.php (54%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/doItem-test.php (75%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/doItems-test.php (79%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/enqueue-test.php (57%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/getEnqueued-test.php (63%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/getProviders-test.php (65%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/getRegistered-test.php (75%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/query-test.php (67%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/registerProvider-test.php (64%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/remove-test.php (78%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/removeFontFamily-test.php (51%)
 rename phpunit/fonts-api/{wpWebfonts => wpFonts}/removeVariation-test.php (57%)

diff --git a/lib/compat/wordpress-6.2/script-loader.php b/lib/compat/wordpress-6.2/script-loader.php
index 4e4ae3ef418a9b..6ad6b2b9ec78bd 100644
--- a/lib/compat/wordpress-6.2/script-loader.php
+++ b/lib/compat/wordpress-6.2/script-loader.php
@@ -131,7 +131,7 @@ function gutenberg_resolve_assets_override() {
 	 * Generate font @font-face styles for the site editor iframe.
 	 * Use the registered font families for printing.
 	 */
-	if ( class_exists( 'WP_Web_Fonts' ) ) {
+	if ( class_exists( 'WP_Fonts' ) ) {
 		$wp_fonts   = wp_fonts();
 		$registered = $wp_fonts->get_registered_font_families();
 		if ( ! empty( $registered ) ) {
diff --git a/lib/experimental/fonts-api/class-wp-fonts.php b/lib/experimental/fonts-api/class-wp-fonts.php
new file mode 100644
index 00000000000000..6a06de8f4c86a5
--- /dev/null
+++ b/lib/experimental/fonts-api/class-wp-fonts.php
@@ -0,0 +1,744 @@
+<?php
+/**
+ * WP Fonts API class.
+ *
+ * @package    WordPress
+ * @subpackage Fonts API
+ * @since      X.X.X
+ */
+
+if ( class_exists( 'WP_Fonts' ) ) {
+	return;
+}
+
+/**
+ * Class WP_Web_Fonts
+ *
+ * @since X.X.X
+ */
+class WP_Fonts extends WP_Webfonts {
+
+	/**
+	 * An array of registered providers.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var array
+	 */
+	private $providers = array();
+
+	/**
+	 * The flipped $to_do array of font handles.
+	 *
+	 * Used for a faster lookup of the font handles.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var string[]
+	 */
+	private $to_do_keyed_handles;
+
+	/**
+	 * Provider instance store, keyed by provider ID.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var array
+	 */
+	private $provider_instances = array();
+
+	/**
+	 * Variation property defaults.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var array
+	 */
+	private $variation_property_defaults = array(
+		'provider'     => 'local',
+		'font-family'  => '',
+		'font-style'   => 'normal',
+		'font-weight'  => '400',
+		'font-display' => 'fallback',
+	);
+
+	/**
+	 * Constructor.
+	 *
+	 * @since X.X.X
+	 */
+	public function __construct() {
+		/**
+		 * Filters the font variation's property defaults.
+		 *
+		 * @since X.X.X
+		 *
+		 * @param array $defaults {
+		 *     An array of required font properties and defaults.
+		 *
+		 *     @type string $provider     The provider ID. Default 'local'.
+		 *     @type string $font-family  The font-family property. Default empty string.
+		 *     @type string $font-style   The font-style property. Default 'normal'.
+		 *     @type string $font-weight  The font-weight property. Default '400'.
+		 *     @type string $font-display The font-display property. Default 'fallback'.
+		 * }
+		 */
+		$this->variation_property_defaults = apply_filters( 'wp_font_variation_defaults', $this->variation_property_defaults );
+
+		/**
+		 * Fires when the WP_Fonts instance is initialized.
+		 *
+		 * @since X.X.X
+		 *
+		 * @param WP_Fonts $wp_fonts WP_Fonts instance (passed by reference).
+		 */
+		do_action_ref_array( 'wp_default_fonts', array( &$this ) );
+	}
+
+	/**
+	 * Get the list of registered providers.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return array $providers {
+	 *     An associative array of registered providers, keyed by their unique ID.
+	 *
+	 *     @type string $provider_id => array {
+	 *         An associate array of provider's class name and fonts.
+	 *
+	 *         @type string $class   Fully qualified name of the provider's class.
+	 *         @type string[] $fonts An array of enqueued font handles for this provider.
+	 *     }
+	 * }
+	 */
+	public function get_providers() {
+		return $this->providers;
+	}
+
+	/**
+	 * Register a provider.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $provider_id The provider's unique ID.
+	 * @param string $class       The provider class name.
+	 * @return bool True if successfully registered, else false.
+	 */
+	public function register_provider( $provider_id, $class ) {
+		if ( empty( $provider_id ) || empty( $class ) || ! class_exists( $class ) ) {
+			return false;
+		}
+
+		$this->providers[ $provider_id ] = array(
+			'class' => $class,
+			'fonts' => array(),
+		);
+		return true;
+	}
+
+	/**
+	 * Get the list of all registered font family handles.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string[]
+	 */
+	public function get_registered_font_families() {
+		$font_families = array();
+		foreach ( $this->registered as $handle => $obj ) {
+			if ( $obj->extra['is_font_family'] ) {
+				$font_families[] = $handle;
+			}
+		}
+		return $font_families;
+	}
+
+	/**
+	 * Get the list of all registered font families and their variations.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string[]
+	 */
+	public function get_registered() {
+		return array_keys( $this->registered );
+	}
+
+	/**
+	 * Get the list of enqueued font families and their variations.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return array[]
+	 */
+	public function get_enqueued() {
+		return $this->queue;
+	}
+
+	/**
+	 * Registers a font family.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family Font family name to register.
+	 * @return string|null Font family handle when registration successes. Null on failure.
+	 */
+	public function add_font_family( $font_family ) {
+		$font_family_handle = WP_Fonts_Utils::convert_font_family_into_handle( $font_family );
+		if ( ! $font_family_handle ) {
+			return null;
+		}
+
+		if ( isset( $this->registered[ $font_family_handle ] ) ) {
+			return $font_family_handle;
+		}
+
+		$registered = $this->add( $font_family_handle, false );
+		if ( ! $registered ) {
+			return null;
+		}
+
+		$this->add_data( $font_family_handle, 'font-properties', array( 'font-family' => $font_family ) );
+		$this->add_data( $font_family_handle, 'is_font_family', true );
+
+		return $font_family_handle;
+	}
+
+	/**
+	 * Removes a font family and all registered variations.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family to remove.
+	 */
+	public function remove_font_family( $font_family_handle ) {
+		if ( ! isset( $this->registered[ $font_family_handle ] ) ) {
+			return;
+		}
+
+		$variations = $this->registered[ $font_family_handle ]->deps;
+
+		foreach ( $variations as $variation ) {
+			$this->remove( $variation );
+		}
+
+		$this->remove( $font_family_handle );
+	}
+
+	/**
+	 * Add a variation to an existing family or register family if none exists.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param array  $variation          An array of variation properties to add.
+	 * @param string $variation_handle   Optional. The variation's handle. When none is provided, the
+	 *                                   handle will be dynamically generated.
+	 *                                   Default empty string.
+	 * @return string|null Variation handle on success. Else null.
+	 */
+	public function add_variation( $font_family_handle, array $variation, $variation_handle = '' ) {
+		if ( ! WP_Fonts_Utils::is_defined( $font_family_handle ) ) {
+			trigger_error( 'Font family handle must be a non-empty string.' );
+			return null;
+		}
+
+		// When there is a variation handle, check it.
+		if ( '' !== $variation_handle && ! WP_Fonts_Utils::is_defined( $variation_handle ) ) {
+			trigger_error( 'Variant handle must be a non-empty string.' );
+			return null;
+		}
+
+		// Register the font family when it does not yet exist.
+		if ( ! isset( $this->registered[ $font_family_handle ] ) ) {
+			if ( ! $this->add_font_family( $font_family_handle ) ) {
+				return null;
+			}
+		}
+
+		$variation = $this->validate_variation( $variation );
+
+		// Variation validation failed.
+		if ( ! $variation ) {
+			return null;
+		}
+
+		// When there's no variation handle, attempt to create one.
+		if ( '' === $variation_handle ) {
+			$variation_handle = WP_Fonts_Utils::convert_variation_into_handle( $font_family_handle, $variation );
+			if ( is_null( $variation_handle ) ) {
+				return null;
+			}
+		}
+
+		// Bail out if the variant is already registered.
+		if ( $this->is_variation_registered( $font_family_handle, $variation_handle ) ) {
+			return $variation_handle;
+		}
+
+		$variation_src = array_key_exists( 'src', $variation ) ? $variation['src'] : false;
+		$result        = $this->add( $variation_handle, $variation_src );
+
+		// Bail out if the registration failed.
+		if ( ! $result ) {
+			return null;
+		}
+
+		$this->add_data( $variation_handle, 'font-properties', $variation );
+		$this->add_data( $variation_handle, 'is_font_family', false );
+
+		// Add the font variation as a dependency to the registered font family.
+		$this->add_dependency( $font_family_handle, $variation_handle );
+
+		$this->providers[ $variation['provider'] ]['fonts'][] = $variation_handle;
+
+		return $variation_handle;
+	}
+
+	/**
+	 * Removes a variation.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family for this variation.
+	 * @param string $variation_handle   The variation's handle to remove.
+	 */
+	public function remove_variation( $font_family_handle, $variation_handle ) {
+		if ( isset( $this->registered[ $variation_handle ] ) ) {
+			$this->remove( $variation_handle );
+		}
+
+		if ( ! $this->is_variation_registered( $font_family_handle, $variation_handle ) ) {
+			return;
+		}
+
+		// Remove the variation as a dependency from its font family.
+		$this->registered[ $font_family_handle ]->deps = array_values(
+			array_diff(
+				$this->registered[ $font_family_handle ]->deps,
+				array( $variation_handle )
+			)
+		);
+	}
+
+	/**
+	 * Checks if the variation is registered.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param string $variation_handle   Variation's handle.
+	 * @return bool True when registered to the given font family. Else false.
+	 */
+	private function is_variation_registered( $font_family_handle, $variation_handle ) {
+		if ( ! isset( $this->registered[ $font_family_handle ] ) ) {
+			return false;
+		}
+
+		return in_array( $variation_handle, $this->registered[ $font_family_handle ]->deps, true );
+	}
+
+	/**
+	 * Adds a variation as a dependency to the given font family.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param string $variation_handle   The variation's handle.
+	 */
+	private function add_dependency( $font_family_handle, $variation_handle ) {
+		$this->registered[ $font_family_handle ]->deps[] = $variation_handle;
+	}
+
+	/**
+	 * Validates and sanitizes a variation.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $variation  Variation properties to add.
+	 * @return false|array Validated variation on success. Else, false.
+	 */
+	private function validate_variation( $variation ) {
+		$variation = wp_parse_args( $variation, $this->variation_property_defaults );
+
+		// Check the font-family.
+		if ( empty( $variation['font-family'] ) || ! is_string( $variation['font-family'] ) ) {
+			trigger_error( 'Webfont font-family must be a non-empty string.' );
+			return false;
+		}
+
+		// Local fonts need a "src".
+		if ( 'local' === $variation['provider'] ) {
+			// Make sure that local fonts have 'src' defined.
+			if ( empty( $variation['src'] ) || ( ! is_string( $variation['src'] ) && ! is_array( $variation['src'] ) ) ) {
+				trigger_error( 'Webfont src must be a non-empty string or an array of strings.' );
+				return false;
+			}
+		} elseif ( ! isset( $this->providers[ $variation['provider'] ] ) ) {
+			trigger_error( sprintf( 'The provider "%s" is not registered', $variation['provider'] ) );
+			return false;
+		} elseif ( ! class_exists( $this->providers[ $variation['provider'] ]['class'] ) ) {
+			trigger_error( sprintf( 'The provider class "%s" does not exist', $variation['provider'] ) );
+			return false;
+		}
+
+		// Validate the 'src' property.
+		if ( ! empty( $variation['src'] ) ) {
+			foreach ( (array) $variation['src'] as $src ) {
+				if ( empty( $src ) || ! is_string( $src ) ) {
+					trigger_error( 'Each font src must be a non-empty string.' );
+					return false;
+				}
+			}
+		}
+
+		// Check the font-weight.
+		if ( ! is_string( $variation['font-weight'] ) && ! is_int( $variation['font-weight'] ) ) {
+			trigger_error( 'Webfont font-weight must be a properly formatted string or integer.' );
+			return false;
+		}
+
+		// Check the font-display.
+		if ( ! in_array( $variation['font-display'], array( 'auto', 'block', 'fallback', 'swap', 'optional' ), true ) ) {
+			$variation['font-display'] = 'fallback';
+		}
+
+		$valid_props = array(
+			'ascent-override',
+			'descent-override',
+			'font-display',
+			'font-family',
+			'font-stretch',
+			'font-style',
+			'font-weight',
+			'font-variant',
+			'font-feature-settings',
+			'font-variation-settings',
+			'line-gap-override',
+			'size-adjust',
+			'src',
+			'unicode-range',
+
+			// Exceptions.
+			'provider',
+		);
+
+		foreach ( $variation as $prop => $value ) {
+			if ( ! in_array( $prop, $valid_props, true ) ) {
+				unset( $variation[ $prop ] );
+			}
+		}
+
+		return $variation;
+	}
+
+	/**
+	 * Processes the items and dependencies.
+	 *
+	 * Processes the items passed to it or the queue, and their dependencies.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string|string[]|bool $handles Optional. Items to be processed: queue (false),
+	 *                                      single item (string), or multiple items (array of strings).
+	 *                                      Default false.
+	 * @param int|false            $group   Optional. Group level: level (int), no group (false).
+	 *
+	 * @return array|string[] Array of font handles that have been processed.
+	 *                        An empty array if none were processed.
+	 */
+	public function do_items( $handles = false, $group = false ) {
+		$handles = $this->prepare_handles_for_printing( $handles );
+
+		if ( empty( $handles ) ) {
+			return $this->done;
+		}
+
+		$this->all_deps( $handles );
+		if ( empty( $this->to_do ) ) {
+			return $this->done;
+		}
+
+		$this->to_do_keyed_handles = array_flip( $this->to_do );
+
+		foreach ( $this->get_providers() as $provider_id => $provider ) {
+			// Alert and skip if the provider class does not exist.
+			if ( ! class_exists( $provider['class'] ) ) {
+				/* translators: %s is the provider name. */
+				trigger_error(
+					sprintf(
+						'Class "%s" not found for "%s" font provider',
+						$provider['class'],
+						$provider_id
+					)
+				);
+				continue;
+			}
+
+			$this->do_item( $provider_id, $group );
+		}
+
+		$this->process_font_families_after_printing( $handles );
+
+		return $this->done;
+	}
+
+	/**
+	 * Prepares the given handles for printing.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string|string[]|bool $handles Optional. Handles to prepare.
+	 *                                      Default false.
+	 * @return array Array of handles.
+	 */
+	private function prepare_handles_for_printing( $handles = false ) {
+		if ( false !== $handles ) {
+			$handles = $this->validate_handles( $handles );
+			// Bail out when invalid.
+			if ( empty( $handles ) ) {
+				return array();
+			}
+		}
+
+		// Use the enqueued queue.
+		if ( empty( $handles ) ) {
+			if ( empty( $this->queue ) ) {
+				return array();
+			}
+			$handles = $this->queue;
+		}
+
+		return $handles;
+	}
+
+	/**
+	 * Validates handle(s) to ensure each is a non-empty string.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string|string[] $handles Handles to prepare.
+	 * @return string[]|null Array of handles on success. Else null.
+	 */
+	private function validate_handles( $handles ) {
+		// Validate each element is a non-empty string handle.
+		$handles = array_filter( (array) $handles, array( WP_Fonts_Utils::class, 'is_defined' ) );
+
+		if ( empty( $handles ) ) {
+			trigger_error( 'Handles must be a non-empty string or array of non-empty strings' );
+			return null;
+		}
+
+		return $handles;
+	}
+
+	/**
+	 * Invokes each provider to process and print its styles.
+	 *
+	 * @since X.X.X
+	 *
+	 * @see WP_Dependencies::do_item()
+	 *
+	 * @param string    $provider_id The provider to process.
+	 * @param int|false $group       Not used.
+	 * @return bool
+	 */
+	public function do_item( $provider_id, $group = false ) { // phpcs:ignore VariableAnalysis.CodeAnalysis.VariableAnalysis.UnusedVariable
+		// Bail out if the provider is not registered.
+		if ( ! isset( $this->providers[ $provider_id ] ) ) {
+			return false;
+		}
+
+		$font_handles = $this->get_enqueued_fonts_for_provider( $provider_id );
+		if ( empty( $font_handles ) ) {
+			return false;
+		}
+
+		$properties_by_font = $this->get_font_properties_for_provider( $font_handles );
+		if ( empty( $properties_by_font ) ) {
+			return false;
+		}
+
+		// Invoke provider to print its styles.
+		$provider = $this->get_provider_instance( $provider_id );
+		$provider->set_fonts( $properties_by_font );
+		$provider->print_styles();
+
+		// Clean up.
+		$this->update_queues_for_printed_fonts( $font_handles );
+
+		return true;
+	}
+
+	/**
+	 * Retrieves a list of enqueued font variations for a provider.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $provider_id The provider to process.
+	 * @return array[] Webfonts organized by providers.
+	 */
+	private function get_enqueued_fonts_for_provider( $provider_id ) {
+		$providers = $this->get_providers();
+
+		if ( empty( $providers[ $provider_id ] ) ) {
+			return array();
+		}
+
+		return array_intersect(
+			$providers[ $provider_id ]['fonts'],
+			$this->to_do
+		);
+	}
+
+	/**
+	 * Gets a list of font properties for each of the given font handles.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_handles Font handles to get properties.
+	 * @return array A list of fonts with each font's properties.
+	 */
+	private function get_font_properties_for_provider( array $font_handles ) {
+		$font_properties = array();
+
+		foreach ( $font_handles as $font_handle ) {
+			$properties = $this->get_data( $font_handle, 'font-properties' );
+			if ( ! $properties ) {
+				continue;
+			}
+			$font_properties[ $font_handle ] = $properties;
+		}
+
+		return $font_properties;
+	}
+
+	/**
+	 * Gets the instance of the provider from the WP_Webfonts::$provider_instance store.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $provider_id The provider to get.
+	 * @return object Instance of the provider.
+	 */
+	private function get_provider_instance( $provider_id ) {
+		if ( ! isset( $this->provider_instances[ $provider_id ] ) ) {
+			$this->provider_instances[ $provider_id ] = new $this->providers[ $provider_id ]['class']();
+		}
+		return $this->provider_instances[ $provider_id ];
+	}
+
+	/**
+	 * Update queues for the given printed fonts.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_handles Font handles to get properties.
+	 */
+	private function update_queues_for_printed_fonts( array $font_handles ) {
+		foreach ( $font_handles as $font_handle ) {
+			$this->set_as_done( $font_handle );
+			$this->remove_from_to_do_queues( $font_handle );
+		}
+	}
+
+	/**
+	 * Processes the font families after printing the variations.
+	 *
+	 * For each queued font family:
+	 *
+	 * a. if any of their variations were printed, the font family is added to the `done` list.
+	 * b. removes each from the to_do queues.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $handles Handles to process.
+	 */
+	private function process_font_families_after_printing( array $handles ) {
+		foreach ( $handles as $handle ) {
+			if (
+				! $this->get_data( $handle, 'is_font_family' ) ||
+				! isset( $this->to_do_keyed_handles[ $handle ] )
+			) {
+				continue;
+			}
+			$font_family = $this->registered[ $handle ];
+
+			// Add the font family to `done` list if any of its variations were printed.
+			if ( ! empty( $font_family->deps ) ) {
+				$processed = array_intersect( $font_family->deps, $this->done );
+				if ( ! empty( $processed ) ) {
+					$this->set_as_done( $handle );
+				}
+			}
+
+			$this->remove_from_to_do_queues( $handle );
+		}
+	}
+
+	/**
+	 * Removes the handle from the `to_do` and `to_do_keyed_handles` lists.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $handle Handle to remove.
+	 */
+	private function remove_from_to_do_queues( $handle ) {
+		unset(
+			$this->to_do[ $this->to_do_keyed_handles[ $handle ] ],
+			$this->to_do_keyed_handles[ $handle ]
+		);
+	}
+
+	/**
+	 * Sets the given handle to done by adding it to the `done` list.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $handle Handle to set as done.
+	 */
+	private function set_as_done( $handle ) {
+		if ( ! is_array( $this->done ) ) {
+			$this->done = array();
+		}
+		$this->done[] = $handle;
+	}
+
+	/**
+	 * Converts the font family and its variations into theme.json structural format.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle Font family to convert.
+	 * @return array Webfonts in theme.json structural format.
+	 */
+	public function to_theme_json( $font_family_handle ) {
+		if ( ! isset( $this->registered[ $font_family_handle ] ) ) {
+			return array();
+		}
+
+		$font_family_name  = $this->registered[ $font_family_handle ]->extra['font-properties']['font-family'];
+		$theme_json_format = array(
+			'fontFamily' => str_contains( $font_family_name, ' ' ) ? "'{$font_family_name}'" : $font_family_name,
+			'name'       => $font_family_name,
+			'slug'       => $font_family_handle,
+			'fontFace'   => array(),
+		);
+
+		foreach ( $this->registered[ $font_family_handle ]->deps as $variation_handle ) {
+			if ( ! isset( $this->registered[ $variation_handle ] ) ) {
+				continue;
+			}
+
+			$variation_obj        = $this->registered[ $variation_handle ];
+			$variation_properties = array( 'origin' => 'gutenberg_wp_fonts_api' );
+			foreach ( $variation_obj->extra['font-properties'] as $property_name => $property_value ) {
+				$property_in_camelcase                          = lcfirst( str_replace( '-', '', ucwords( $property_name, '-' ) ) );
+				$variation_properties[ $property_in_camelcase ] = $property_value;
+			}
+			$theme_json_format['fontFace'][ $variation_obj->handle ] = $variation_properties;
+		}
+
+		return $theme_json_format;
+	}
+}
diff --git a/lib/experimental/fonts-api/class-wp-web-fonts.php b/lib/experimental/fonts-api/deprecations/class-wp-web-fonts.php
similarity index 96%
rename from lib/experimental/fonts-api/class-wp-web-fonts.php
rename to lib/experimental/fonts-api/deprecations/class-wp-web-fonts.php
index 83b0e29476b770..bdf06bb317e3a9 100644
--- a/lib/experimental/fonts-api/class-wp-web-fonts.php
+++ b/lib/experimental/fonts-api/deprecations/class-wp-web-fonts.php
@@ -14,60 +14,19 @@
 /**
  * Class WP_Web_Fonts
  *
- * @since X.X.X
+ * @since GB 14.9.1
+ * @deprecated GB 15.1 Use WP_Fonts instead.
  */
 class WP_Web_Fonts extends WP_Webfonts {
 
-	/**
-	 * An array of registered providers.
-	 *
-	 * @since X.X.X
-	 *
-	 * @var array
-	 */
-	private $providers = array();
-
-	/**
-	 * The flipped $to_do array of web font handles.
-	 *
-	 * Used for a faster lookup of the web font handles.
-	 *
-	 * @since X.X.X
-	 *
-	 * @var string[]
-	 */
-	private $to_do_keyed_handles;
-
-	/**
-	 * Provider instance store, keyed by provider ID.
-	 *
-	 * @since X.X.X
-	 *
-	 * @var array
-	 */
-	private $provider_instances = array();
-
-	/**
-	 * Variation property defaults.
-	 *
-	 * @since X.X.X
-	 *
-	 * @var array
-	 */
-	private $variation_property_defaults = array(
-		'provider'     => 'local',
-		'font-family'  => '',
-		'font-style'   => 'normal',
-		'font-weight'  => '400',
-		'font-display' => 'fallback',
-	);
-
 	/**
 	 * Constructor.
 	 *
 	 * @since X.X.X
 	 */
 	public function __construct() {
+		_deprecated_function( __METHOD__, 'GB 15.1', 'WP_Fonts' );
+
 		/**
 		 * Filters the web font variation's property defaults.
 		 *
diff --git a/lib/experimental/fonts-api/deprecations/class-wp-webfonts-provider.php b/lib/experimental/fonts-api/deprecations/class-wp-webfonts-provider.php
index b09c5496e6543f..5b7f5ece335b11 100644
--- a/lib/experimental/fonts-api/deprecations/class-wp-webfonts-provider.php
+++ b/lib/experimental/fonts-api/deprecations/class-wp-webfonts-provider.php
@@ -61,6 +61,6 @@ public function set_webfonts( array $fonts ) {
 	 */
 	public function set_fonts( array $fonts ) {
 		parent::set_fonts( $fonts );
-		$this->webfonts = $this->fonts;;
+		$this->webfonts = $this->fonts;
 	}
 }
diff --git a/lib/experimental/fonts-api/fonts-api.php b/lib/experimental/fonts-api/fonts-api.php
index 78307ba418406c..49b45392d3306a 100644
--- a/lib/experimental/fonts-api/fonts-api.php
+++ b/lib/experimental/fonts-api/fonts-api.php
@@ -13,15 +13,15 @@
 	 *
 	 * @since X.X.X
 	 *
-	 * @global WP_Web_Fonts $wp_fonts
+	 * @global WP_Fonts $wp_fonts
 	 *
-	 * @return WP_Web_Fonts WP_Web_Fonts instance.
+	 * @return WP_Fonts WP_Fonts instance.
 	 */
 	function wp_fonts() {
 		global $wp_fonts;
 
-		if ( ! ( $wp_fonts instanceof WP_Web_Fonts ) ) {
-			$wp_fonts = new WP_Web_Fonts();
+		if ( ! ( $wp_fonts instanceof WP_Fonts ) ) {
+			$wp_fonts = new WP_Fonts();
 			$wp_fonts->register_provider( 'local', 'WP_Fonts_Provider_Local' );
 		}
 
@@ -191,7 +191,7 @@ function wp_print_fonts( $handles = false ) {
 
 		_wp_scripts_maybe_doing_it_wrong( __FUNCTION__ );
 
-		if ( ! ( $wp_fonts instanceof WP_Web_Fonts ) ) {
+		if ( ! ( $wp_fonts instanceof WP_Fonts ) ) {
 			if ( ! $handles ) {
 				return array(); // No need to instantiate if nothing is there.
 			}
diff --git a/lib/load.php b/lib/load.php
index e8d09183fee7a6..3ef152e6416e7f 100644
--- a/lib/load.php
+++ b/lib/load.php
@@ -104,7 +104,7 @@ function gutenberg_is_experiment_enabled( $name ) {
 require __DIR__ . '/experimental/fonts-api/deprecations/class-wp-webfonts.php';
 require __DIR__ . '/experimental/fonts-api/class-wp-fonts-utils.php';
 require __DIR__ . '/experimental/fonts-api/register-fonts-from-theme-json.php';
-require __DIR__ . '/experimental/fonts-api/class-wp-web-fonts.php';
+require __DIR__ . '/experimental/fonts-api/class-wp-fonts.php';
 require __DIR__ . '/experimental/fonts-api/class-wp-fonts-provider-local.php';
 require __DIR__ . '/experimental/fonts-api/fonts-api.php';
 
diff --git a/phpunit/fonts-api/wp-fonts-testcase.php b/phpunit/fonts-api/wp-fonts-testcase.php
index 266325c422e991..e76a81590f9544 100644
--- a/phpunit/fonts-api/wp-fonts-testcase.php
+++ b/phpunit/fonts-api/wp-fonts-testcase.php
@@ -15,9 +15,9 @@ abstract class WP_Fonts_TestCase extends WP_UnitTestCase {
 	use WP_Fonts_Tests_Datasets;
 
 	/**
-	 * Original WP_Web_Fonts instance, before the tests.
+	 * Original WP_Fonts instance, before the tests.
 	 *
-	 * @var WP_Web_Fonts
+	 * @var WP_Fonts
 	 */
 	private $old_wp_fonts;
 
@@ -56,7 +56,7 @@ public function tear_down() {
 	}
 
 	protected function set_up_mock( $method ) {
-		$mock = $this->setup_object_mock( $method, WP_Web_Fonts::class );
+		$mock = $this->setup_object_mock( $method, WP_Fonts::class );
 
 		// Set the global.
 		$GLOBALS['wp_fonts'] = $mock;
@@ -81,7 +81,7 @@ protected function get_registered() {
 	}
 
 	protected function get_variations( $font_family, $wp_fonts = null ) {
-		if ( ! ( $wp_fonts instanceof WP_Web_Fonts ) ) {
+		if ( ! ( $wp_fonts instanceof WP_Fonts ) ) {
 			$wp_fonts = wp_fonts();
 		}
 
@@ -96,7 +96,7 @@ protected function get_queued_before_register( $wp_fonts = null ) {
 		return $this->get_property_value( 'queued_before_register', WP_Dependencies::class, $wp_fonts );
 	}
 
-	protected function get_reflection_property( $property_name, $class = 'WP_Web_Fonts' ) {
+	protected function get_reflection_property( $property_name, $class = 'WP_Fonts' ) {
 		$property = new ReflectionProperty( $class, $property_name );
 		$property->setAccessible( true );
 
@@ -135,7 +135,7 @@ protected function get_property_key( $class, $property_name ) {
 	 * @return ReflectionMethod Instance of the method, ie to invoke it in the test.
 	 */
 	protected function get_reflection_method( $method_name ) {
-		$method = new ReflectionMethod( WP_Web_Fonts::class, $method_name );
+		$method = new ReflectionMethod( WP_Fonts::class, $method_name );
 		$method->setAccessible( true );
 
 		return $method;
@@ -144,11 +144,11 @@ protected function get_reflection_method( $method_name ) {
 	/**
 	 * Sets up multiple font family and variation mocks.
 	 *
-	 * @param array        $inputs   Array of array( font-family => variations ) to setup.
-	 * @param WP_Web_Fonts $wp_fonts Instance of WP_Web_Fonts.
+	 * @param array    $inputs   Array of array( font-family => variations ) to setup.
+	 * @param WP_Fonts $wp_fonts Instance of WP_Fonts.
 	 * @return stdClass[] Array of registered mocks.
 	 */
-	protected function setup_registration_mocks( array $inputs, WP_Web_Fonts $wp_fonts ) {
+	protected function setup_registration_mocks( array $inputs, WP_Fonts $wp_fonts ) {
 		$mocks = array();
 
 		$build_mock = function ( $font_family, $is_font_family = false ) use ( &$mocks, $wp_fonts ) {
@@ -187,12 +187,12 @@ protected function setup_registration_mocks( array $inputs, WP_Web_Fonts $wp_fon
 	/**
 	 * Register one or more font-family and its variations to set up a test.
 	 *
-	 * @param string            $font_family Font family to test.
-	 * @param array             $variations  Variations.
-	 * @param WP_Web_Fonts|null $wp_fonts    Optional. Instance of the WP_Web_Fonts.
+	 * @param string        $font_family Font family to test.
+	 * @param array         $variations  Variations.
+	 * @param WP_Fonts|null $wp_fonts    Optional. Instance of the WP_Fonts.
 	 */
 	protected function setup_register( $font_family, $variations, $wp_fonts = null ) {
-		if ( ! ( $wp_fonts instanceof WP_Web_Fonts ) ) {
+		if ( ! ( $wp_fonts instanceof WP_Fonts ) ) {
 			$wp_fonts = wp_fonts();
 		}
 
@@ -207,18 +207,18 @@ protected function setup_register( $font_family, $variations, $wp_fonts = null )
 	}
 
 	/**
-	 * Sets up the WP_Web_Fonts::$provider property.
+	 * Sets up the WP_Fonts::$provider property.
 	 *
-	 * @param WP_Web_Fonts $wp_fonts     Instance of WP_Web_Fonts.
+	 * @param WP_Fonts     $wp_fonts     Instance of WP_Fonts.
 	 * @param string|array $provider     Provider ID when string. Else provider definition with 'id' and 'class' keys.
 	 * @param array        $font_handles Optional. Font handles for this provider.
 	 */
-	protected function setup_provider_property_mock( WP_Web_Fonts $wp_fonts, $provider, array $font_handles = array() ) {
+	protected function setup_provider_property_mock( WP_Fonts $wp_fonts, $provider, array $font_handles = array() ) {
 		if ( is_string( $provider ) ) {
 			$provider = $this->get_provider_definitions( $provider );
 		}
 
-		$property  = $this->setup_property( WP_Web_Fonts::class, 'providers' );
+		$property  = $this->setup_property( WP_Fonts::class, 'providers' );
 		$providers = $property->getValue( $wp_fonts );
 
 		if ( ! isset( $providers[ $provider['id'] ] ) ) {
diff --git a/phpunit/fonts-api/wp-fonts-tests-dataset.php b/phpunit/fonts-api/wp-fonts-tests-dataset.php
index 54a57c13daeeef..4640526c07138a 100644
--- a/phpunit/fonts-api/wp-fonts-tests-dataset.php
+++ b/phpunit/fonts-api/wp-fonts-tests-dataset.php
@@ -324,7 +324,7 @@ public function data_invalid_variation() {
 				),
 			),
 			'src: array of an empty string'   => array(
-				'expected'           => 'Each webfont src must be a non-empty string.',
+				'expected'           => 'Each font src must be a non-empty string.',
 				'font_family_handle' => 'lato',
 				'variation'          => array(
 					'provider'    => 'local',
@@ -334,7 +334,7 @@ public function data_invalid_variation() {
 				),
 			),
 			'src: array of a non-string'      => array(
-				'expected'           => 'Each webfont src must be a non-empty string.',
+				'expected'           => 'Each font src must be a non-empty string.',
 				'font_family_handle' => 'lato',
 				'variation'          => array(
 					'provider'    => 'local',
@@ -344,7 +344,7 @@ public function data_invalid_variation() {
 				),
 			),
 			'src: array with an empty string' => array(
-				'expected'           => 'Each webfont src must be a non-empty string.',
+				'expected'           => 'Each font src must be a non-empty string.',
 				'font_family_handle' => 'lato',
 				'variation'          => array(
 					'provider'    => 'local',
@@ -358,7 +358,7 @@ public function data_invalid_variation() {
 				),
 			),
 			'src: array with a non-string'    => array(
-				'expected'           => 'Each webfont src must be a non-empty string.',
+				'expected'           => 'Each font src must be a non-empty string.',
 				'font_family_handle' => 'lato',
 				'variation'          => array(
 					'provider'    => 'local',
diff --git a/phpunit/fonts-api/wpDeregisterFontFamily-test.php b/phpunit/fonts-api/wpDeregisterFontFamily-test.php
index c55151e496977b..6ef73879f20320 100644
--- a/phpunit/fonts-api/wpDeregisterFontFamily-test.php
+++ b/phpunit/fonts-api/wpDeregisterFontFamily-test.php
@@ -12,12 +12,12 @@
  * @group fontsapi
  * @group remove_fonts
  * @covers ::wp_deregister_font_family
- * @covers WP_Web_Fonts::remove_font_family
+ * @covers WP_Fonts::remove_font_family
  */
 class Tests_Webfonts_WpDeregisterFontFamily extends WP_Fonts_TestCase {
 
 	/**
-	 * Unit test for registering a font-family that mocks WP_Web_Fonts.
+	 * Unit test for registering a font-family that mocks WP_Fonts.
 	 *
 	 * @dataProvider data_font_family_handles
 	 *
diff --git a/phpunit/fonts-api/wpEnqueueFonts-test.php b/phpunit/fonts-api/wpEnqueueFonts-test.php
index 57d37eb3945a03..43c1fd63a76104 100644
--- a/phpunit/fonts-api/wpEnqueueFonts-test.php
+++ b/phpunit/fonts-api/wpEnqueueFonts-test.php
@@ -11,17 +11,17 @@
 /**
  * @group  fontsapi
  * @covers ::wp_enqueue_fonts
- * @covers WP_Web_Fonts::enqueue
+ * @covers WP_Fonts::enqueue
  */
 class Tests_Fonts_WpEnqueueFonts extends WP_Fonts_TestCase {
 
 	/**
-	 * Unit test for registering a font-family that mocks WP_Web_Fonts.
+	 * Unit test for registering a font-family that mocks WP_Fonts.
 	 *
 	 * @dataProvider data_should_enqueue
 	 *
 	 * @param string[] $font_families    Font families to test.
-	 * @param string[] $expected_handles Expected handles passed to WP_Web_Fonts::enqueue().
+	 * @param string[] $expected_handles Expected handles passed to WP_Fonts::enqueue().
 	 */
 	public function test_unit_should_enqueue( $font_families, $expected_handles ) {
 		$mock = $this->set_up_mock( 'enqueue' );
@@ -40,7 +40,7 @@ public function test_unit_should_enqueue( $font_families, $expected_handles ) {
 	 * @dataProvider data_should_enqueue
 	 *
 	 * @param string[] $font_families    Font families to test.
-	 * @param string[] $expected_handles Expected handles passed to WP_Web_Fonts::enqueue().
+	 * @param string[] $expected_handles Expected handles passed to WP_Fonts::enqueue().
 	 */
 	public function test_should_enqueue_after_registration( $font_families, $expected_handles ) {
 		// Register the font-families.
@@ -60,7 +60,7 @@ public function test_should_enqueue_after_registration( $font_families, $expecte
 	 * @dataProvider data_should_enqueue
 	 *
 	 * @param string[] $font_families    Font families to test.
-	 * @param string[] $expected_handles Expected handles passed to WP_Web_Fonts::enqueue().
+	 * @param string[] $expected_handles Expected handles passed to WP_Fonts::enqueue().
 	 */
 	public function test_should_enqueue_before_registration( $font_families, $expected_handles ) {
 		wp_enqueue_fonts( $font_families );
diff --git a/phpunit/fonts-api/wpFonts-test.php b/phpunit/fonts-api/wpFonts-test.php
index f11bc803a7cc50..9a50dcb0fafc30 100644
--- a/phpunit/fonts-api/wpFonts-test.php
+++ b/phpunit/fonts-api/wpFonts-test.php
@@ -15,14 +15,14 @@
 class Tests_Fonts_WpFonts extends WP_Fonts_TestCase {
 
 	public function test_returns_instance() {
-		$this->assertInstanceOf( WP_Web_Fonts::class, wp_fonts() );
+		$this->assertInstanceOf( WP_Fonts::class, wp_fonts() );
 	}
 
 	public function test_global_set() {
 		global $wp_fonts;
 		$this->assertNull( $wp_fonts );
 		$instance = wp_fonts();
-		$this->assertInstanceOf( WP_Web_Fonts::class, $wp_fonts );
+		$this->assertInstanceOf( WP_Fonts::class, $wp_fonts );
 		$this->assertSame( $instance, $wp_fonts );
 	}
 
diff --git a/phpunit/fonts-api/wpWebfonts/add-test.php b/phpunit/fonts-api/wpFonts/add-test.php
similarity index 60%
rename from phpunit/fonts-api/wpWebfonts/add-test.php
rename to phpunit/fonts-api/wpFonts/add-test.php
index 32147d6fd4a91a..8d88b6834d0cf6 100644
--- a/phpunit/fonts-api/wpWebfonts/add-test.php
+++ b/phpunit/fonts-api/wpFonts/add-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::add() tests.
+ * WP_Fonts::add() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -10,9 +10,9 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::add
+ * @covers WP_Fonts::add
  */
-class Tests_Webfonts_WpWebfonts_Add extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_Add extends WP_Fonts_TestCase {
 
 	/**
 	 * @dataProvider data_handles
@@ -20,11 +20,11 @@ class Tests_Webfonts_WpWebfonts_Add extends WP_Fonts_TestCase {
 	 * @param string $handle Handle to register.
 	 */
 	public function test_add( $handle ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 
-		$this->assertTrue( $wp_webfonts->add( $handle, false ), 'Registering a handle should return true' );
-		$this->assertCount( 1, $wp_webfonts->registered );
-		$this->assertArrayHasKey( $handle, $wp_webfonts->registered, 'Font family handle should be in the registry after registration' );
+		$this->assertTrue( $wp_fonts->add( $handle, false ), 'Registering a handle should return true' );
+		$this->assertCount( 1, $wp_fonts->registered );
+		$this->assertArrayHasKey( $handle, $wp_fonts->registered, 'Font family handle should be in the registry after registration' );
 
 	}
 
diff --git a/phpunit/fonts-api/wpWebfonts/addFontFamily-test.php b/phpunit/fonts-api/wpFonts/addFontFamily-test.php
similarity index 75%
rename from phpunit/fonts-api/wpWebfonts/addFontFamily-test.php
rename to phpunit/fonts-api/wpFonts/addFontFamily-test.php
index 385e451acb0e64..85676b47c35e5e 100644
--- a/phpunit/fonts-api/wpWebfonts/addFontFamily-test.php
+++ b/phpunit/fonts-api/wpFonts/addFontFamily-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::add_font_family() tests.
+ * WP_Fonts::add_font_family() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -10,9 +10,9 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::add_font_family
+ * @covers WP_Fonts::add_font_family
  */
-class Tests_Webfonts_WpWebfonts_AddFontFamily extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_AddFontFamily extends WP_Fonts_TestCase {
 
 	/**
 	 * @dataProvider data_handles
@@ -21,12 +21,12 @@ class Tests_Webfonts_WpWebfonts_AddFontFamily extends WP_Fonts_TestCase {
 	 * @param string $expected    Expected handle.
 	 */
 	public function test_should_register( $font_family, $expected ) {
-		$wp_webfonts        = new WP_Web_Fonts();
-		$font_family_handle = $wp_webfonts->add_font_family( $font_family );
+		$wp_fonts           = new WP_Fonts();
+		$font_family_handle = $wp_fonts->add_font_family( $font_family );
 
 		$this->assertSame( $expected, $font_family_handle, 'Registering a font-family should return its handle' );
-		$this->assertCount( 1, $wp_webfonts->registered );
-		$this->assertArrayHasKey( $font_family_handle, $wp_webfonts->registered, 'Font family handle should be in the registry after registration' );
+		$this->assertCount( 1, $wp_fonts->registered );
+		$this->assertArrayHasKey( $font_family_handle, $wp_fonts->registered, 'Font family handle should be in the registry after registration' );
 
 	}
 
diff --git a/phpunit/fonts-api/wpWebfonts/addVariation-test.php b/phpunit/fonts-api/wpFonts/addVariation-test.php
similarity index 63%
rename from phpunit/fonts-api/wpWebfonts/addVariation-test.php
rename to phpunit/fonts-api/wpFonts/addVariation-test.php
index dd8d985a43660c..0f86c07ab0eaa8 100644
--- a/phpunit/fonts-api/wpWebfonts/addVariation-test.php
+++ b/phpunit/fonts-api/wpFonts/addVariation-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::add_variation() tests.
+ * WP_Fonts::add_variation() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -10,9 +10,9 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::add_variation
+ * @covers WP_Fonts::add_variation
  */
-class Tests_Webfonts_WpWebfonts_AddVariation extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_AddVariation extends WP_Fonts_TestCase {
 
 	/**
 	 * @dataProvider data_valid_variation
@@ -23,13 +23,13 @@ class Tests_Webfonts_WpWebfonts_AddVariation extends WP_Fonts_TestCase {
 	 * @param string      $variation_handle   Optional. The variation's handle.
 	 */
 	public function test_should_register_variation_when_font_family_is_registered( $expected, $font_family_handle, array $variation, $variation_handle = '' ) {
-		$wp_webfonts = new WP_Web_Fonts();
-		$wp_webfonts->add( $font_family_handle, false );
+		$wp_fonts = new WP_Fonts();
+		$wp_fonts->add( $font_family_handle, false );
 
-		$variation_handle = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		$variation_handle = $wp_fonts->add_variation( $font_family_handle, $variation, $variation_handle );
 		$this->assertSame( $expected, $variation_handle, 'Registering a variation should return its handle' );
-		$this->assertArrayHasKey( $variation_handle, $wp_webfonts->registered, 'Variation handle should be in the registry after registration' );
-		$this->assertSame( array( $expected ), $this->get_variations( $font_family_handle, $wp_webfonts ), 'Variation should be registered to font family' );
+		$this->assertArrayHasKey( $variation_handle, $wp_fonts->registered, 'Variation handle should be in the registry after registration' );
+		$this->assertSame( array( $expected ), $this->get_variations( $font_family_handle, $wp_fonts ), 'Variation should be registered to font family' );
 	}
 
 	/**
@@ -41,14 +41,14 @@ public function test_should_register_variation_when_font_family_is_registered( $
 	 * @param string      $variation_handle   Optional. The variation's handle.
 	 */
 	public function test_should_not_reregister_font_family( $expected, $font_family_handle, array $variation, $variation_handle = '' ) {
-		$wp_webfonts = new WP_Web_Fonts();
-		$wp_webfonts->add( $font_family_handle, false );
+		$wp_fonts = new WP_Fonts();
+		$wp_fonts->add( $font_family_handle, false );
 
-		$variation_handle = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		$variation_handle = $wp_fonts->add_variation( $font_family_handle, $variation, $variation_handle );
 
 		// Font family should appear only once in the registered queue.
 		$expected = array( $font_family_handle, $variation_handle );
-		$this->assertSame( $expected, array_keys( $wp_webfonts->registered ), 'Font family should not be re-registered after registering a variation' );
+		$this->assertSame( $expected, array_keys( $wp_fonts->registered ), 'Font family should not be re-registered after registering a variation' );
 	}
 
 	/**
@@ -60,20 +60,20 @@ public function test_should_not_reregister_font_family( $expected, $font_family_
 	 * @param string      $variation_handle   Optional. The variation's handle.
 	 */
 	public function test_should_not_reregister_variation( $expected, $font_family_handle, array $variation, $variation_handle = '' ) {
-		$wp_webfonts = new WP_Web_Fonts();
-		$wp_webfonts->add( $font_family_handle, false );
+		$wp_fonts = new WP_Fonts();
+		$wp_fonts->add( $font_family_handle, false );
 
 		// Set up the test.
-		$variation_handle = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		$variation_handle = $wp_fonts->add_variation( $font_family_handle, $variation, $variation_handle );
 
 		// Run the test.
-		$variant_handle_on_reregister = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		$variant_handle_on_reregister = $wp_fonts->add_variation( $font_family_handle, $variation, $variation_handle );
 		$this->assertSame( $expected, $variant_handle_on_reregister, 'Variation should be registered to font family' );
 		$this->assertSame( $variation_handle, $variant_handle_on_reregister, 'Variation should return the previously registered variant handle' );
-		$this->assertSame( array( $variation_handle ), $this->get_variations( $font_family_handle, $wp_webfonts ), 'Variation should only be registered once' );
+		$this->assertSame( array( $variation_handle ), $this->get_variations( $font_family_handle, $wp_fonts ), 'Variation should only be registered once' );
 
-		$this->assertCount( 2, $wp_webfonts->registered );
-		$this->assertArrayHasKey( $variation_handle, $wp_webfonts->registered, 'Variation handle should be in the registry after registration' );
+		$this->assertCount( 2, $wp_fonts->registered );
+		$this->assertArrayHasKey( $variation_handle, $wp_fonts->registered, 'Variation handle should be in the registry after registration' );
 	}
 
 	/**
@@ -85,16 +85,16 @@ public function test_should_not_reregister_variation( $expected, $font_family_ha
 	 * @param string      $variation_handle   Optional. The variation's handle.
 	 */
 	public function test_should_register_font_family_and_variation( $expected, $font_family_handle, array $variation, $variation_handle = '' ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 
-		$variation_handle = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		$variation_handle = $wp_fonts->add_variation( $font_family_handle, $variation, $variation_handle );
 		$this->assertSame( $expected, $variation_handle, 'Variation should return its registered handle' );
 
 		// Extra checks to ensure both are registered.
-		$this->assertCount( 2, $wp_webfonts->registered );
-		$this->assertArrayHasKey( $font_family_handle, $wp_webfonts->registered, 'Font family handle should be in the registry after registration' );
-		$this->assertArrayHasKey( $variation_handle, $wp_webfonts->registered, 'Variation handle should be in the registry after registration' );
-		$this->assertSame( array( $variation_handle ), $this->get_variations( $font_family_handle, $wp_webfonts ), 'Variation should be registered to the font family' );
+		$this->assertCount( 2, $wp_fonts->registered );
+		$this->assertArrayHasKey( $font_family_handle, $wp_fonts->registered, 'Font family handle should be in the registry after registration' );
+		$this->assertArrayHasKey( $variation_handle, $wp_fonts->registered, 'Variation handle should be in the registry after registration' );
+		$this->assertSame( array( $variation_handle ), $this->get_variations( $font_family_handle, $wp_fonts ), 'Variation should be registered to the font family' );
 	}
 
 	/**
@@ -107,11 +107,11 @@ public function test_should_not_register_font_family_or_variant( $font_family_ha
 		$this->expectNotice();
 		$this->expectNoticeMessage( 'Font family handle must be a non-empty string.' );
 
-		$wp_webfonts = new WP_Web_Fonts();
-		$wp_webfonts->add_variation( $font_family_handle, $variation );
+		$wp_fonts = new WP_Fonts();
+		$wp_fonts->add_variation( $font_family_handle, $variation );
 
-		$this->assertEmpty( $wp_webfonts->registered, 'Registered queue should be empty' );
-		$this->assertEmpty( $this->get_variations( $font_family_handle, $wp_webfonts ), 'Variation should not be registered to the font family' );
+		$this->assertEmpty( $wp_fonts->registered, 'Registered queue should be empty' );
+		$this->assertEmpty( $this->get_variations( $font_family_handle, $wp_fonts ), 'Variation should not be registered to the font family' );
 	}
 
 	/**
@@ -126,8 +126,8 @@ public function test_should_not_register_variation_when_font_family_not_defined(
 		$this->expectNotice();
 		$this->expectNoticeMessage( $expected_message );
 
-		$wp_webfonts = new WP_Web_Fonts();
-		$this->assertNull( $wp_webfonts->add_variation( $font_family_handle, $variation ) );
+		$wp_fonts = new WP_Fonts();
+		$this->assertNull( $wp_fonts->add_variation( $font_family_handle, $variation ) );
 	}
 
 	/**
@@ -140,10 +140,10 @@ public function test_should_register_font_family_when_variant_fails_to_register(
 		$this->expectNotice();
 		$this->expectNoticeMessage( 'Variant handle could not be determined as font-weight and/or font-style are require' );
 
-		$wp_webfonts = new WP_Web_Fonts();
-		$wp_webfonts->add_variation( $font_family_handle, $variation );
+		$wp_fonts = new WP_Fonts();
+		$wp_fonts->add_variation( $font_family_handle, $variation );
 
-		$this->assertCount( 1, $wp_webfonts->registered );
-		$this->assertArrayHasKey( $font_family_handle, $wp_webfonts->registered );
+		$this->assertCount( 1, $wp_fonts->registered );
+		$this->assertArrayHasKey( $font_family_handle, $wp_fonts->registered );
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/dequeue-test.php b/phpunit/fonts-api/wpFonts/dequeue-test.php
similarity index 54%
rename from phpunit/fonts-api/wpWebfonts/dequeue-test.php
rename to phpunit/fonts-api/wpFonts/dequeue-test.php
index 2e7af2d722b17b..e6ea2223657baa 100644
--- a/phpunit/fonts-api/wpWebfonts/dequeue-test.php
+++ b/phpunit/fonts-api/wpFonts/dequeue-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::dequeue() tests.
+ * WP_Fonts::dequeue() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -10,9 +10,9 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::dequeue
+ * @covers WP_Fonts::dequeue
  */
-class Tests_Webfonts_WpWebfonts_Dequeue extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_Dequeue extends WP_Fonts_TestCase {
 
 	/**
 	 * @dataProvider data_enqueue
@@ -21,11 +21,11 @@ class Tests_Webfonts_WpWebfonts_Dequeue extends WP_Fonts_TestCase {
 	 * @param string|string[] $handles Handles to test.
 	 */
 	public function test_should_do_nothing_when_handles_not_queued( $handles ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 
-		$wp_webfonts->dequeue( $handles );
-		$this->assertEmpty( $this->get_queued_before_register( $wp_webfonts ), 'Prequeue should be empty' );
-		$this->assertEmpty( $wp_webfonts->queue, 'Queue should be empty' );
+		$wp_fonts->dequeue( $handles );
+		$this->assertEmpty( $this->get_queued_before_register( $wp_fonts ), 'Prequeue should be empty' );
+		$this->assertEmpty( $wp_fonts->queue, 'Queue should be empty' );
 	}
 
 	/**
@@ -37,20 +37,20 @@ public function test_should_do_nothing_when_handles_not_queued( $handles ) {
 	 * @param string|string[] $handles Handles to test.
 	 */
 	public function test_should_dequeue_from_queue( $handles ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 
 		// Register and enqueue.
 		foreach ( $this->get_data_registry() as $handle => $variations ) {
-			$this->setup_register( $handle, $variations, $wp_webfonts );
+			$this->setup_register( $handle, $variations, $wp_fonts );
 		}
-		$wp_webfonts->enqueue( $handles );
+		$wp_fonts->enqueue( $handles );
 
 		// To make sure the handles are in the queue before dequeuing.
-		$this->assertNotEmpty( $wp_webfonts->queue, 'Queue not be empty before dequeueing' );
+		$this->assertNotEmpty( $wp_fonts->queue, 'Queue not be empty before dequeueing' );
 
 		// Run the test.
-		$wp_webfonts->dequeue( $handles );
-		$this->assertEmpty( $wp_webfonts->queue, 'Queue should be empty after dequeueing' );
+		$wp_fonts->dequeue( $handles );
+		$this->assertEmpty( $wp_fonts->queue, 'Queue should be empty after dequeueing' );
 	}
 
 	/**
@@ -62,11 +62,11 @@ public function test_should_dequeue_from_queue( $handles ) {
 	 * @param string|string[] $handles Handles to test.
 	 */
 	public function test_should_dequeue_from_prequeue( $handles ) {
-		$wp_webfonts = new WP_Web_Fonts();
-		$wp_webfonts->enqueue( $handles );
-		$this->assertNotEmpty( $this->get_queued_before_register( $wp_webfonts ), 'Prequeue not be empty before dequeueing' );
+		$wp_fonts = new WP_Fonts();
+		$wp_fonts->enqueue( $handles );
+		$this->assertNotEmpty( $this->get_queued_before_register( $wp_fonts ), 'Prequeue not be empty before dequeueing' );
 
-		$wp_webfonts->dequeue( $handles );
-		$this->assertEmpty( $this->get_queued_before_register( $wp_webfonts ), 'Prequeue should be empty after dequeueing' );
+		$wp_fonts->dequeue( $handles );
+		$this->assertEmpty( $this->get_queued_before_register( $wp_fonts ), 'Prequeue should be empty after dequeueing' );
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/doItem-test.php b/phpunit/fonts-api/wpFonts/doItem-test.php
similarity index 75%
rename from phpunit/fonts-api/wpWebfonts/doItem-test.php
rename to phpunit/fonts-api/wpFonts/doItem-test.php
index 85805a337c49da..602c8d74e1bae1 100644
--- a/phpunit/fonts-api/wpWebfonts/doItem-test.php
+++ b/phpunit/fonts-api/wpFonts/doItem-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::do_item() tests.
+ * WP_Fonts::do_item() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -11,18 +11,18 @@
 /**
  * @group  fontsapi
  * @group  printfonts
- * @covers WP_Web_Fonts::do_item
+ * @covers WP_Fonts::do_item
  */
-class Tests_Webfonts_WpWebfonts_DoItem extends WP_Fonts_TestCase {
-	private $wp_webfonts;
+class Tests_Fonts_WpFonts_DoItem extends WP_Fonts_TestCase {
+	private $wp_fonts;
 
 	public function set_up() {
 		parent::set_up();
-		$this->wp_webfonts = new WP_Web_Fonts;
+		$this->wp_fonts = new WP_Fonts;
 	}
 
 	public function test_should_return_false_when_provider_not_registered() {
-		$this->assertFalse( $this->wp_webfonts->do_item( 'provider_not_registered' ) );
+		$this->assertFalse( $this->wp_fonts->do_item( 'provider_not_registered' ) );
 	}
 
 	/**
@@ -31,8 +31,8 @@ public function test_should_return_false_when_provider_not_registered() {
 	 * @param array $provider Provider to mock.
 	 */
 	public function test_should_return_false_when_no_fonts_enqueued_for_provider( array $provider ) {
-		$this->setup_provider_property_mock( $this->wp_webfonts, $provider );
-		$this->assertFalse( $this->wp_webfonts->do_item( $provider['id'] ) );
+		$this->setup_provider_property_mock( $this->wp_fonts, $provider );
+		$this->assertFalse( $this->wp_fonts->do_item( $provider['id'] ) );
 	}
 
 	/**
@@ -50,7 +50,7 @@ public function data_provider_definitions() {
 	}
 
 	/**
-	 * Test the test set up to ensure the `Tests_Webfonts_WpWebfonts_DoItem_::setup_provider_property_mock()`
+	 * Test the test set up to ensure the `Tests_Fonts_WpFonts_DoItem_::setup_provider_property_mock()`
 	 * method works as expected.
 	 */
 	public function test_mocking_providers_property() {
@@ -62,34 +62,34 @@ public function test_mocking_providers_property() {
 			),
 		);
 
-		$this->setup_provider_property_mock( $this->wp_webfonts, $this->get_provider_definitions( 'mock' ), $font_handles );
-		$actual = $this->property['WP_Web_Fonts::$providers']->getValue( $this->wp_webfonts );
+		$this->setup_provider_property_mock( $this->wp_fonts, $this->get_provider_definitions( 'mock' ), $font_handles );
+		$actual = $this->property['WP_Fonts::$providers']->getValue( $this->wp_fonts );
 		$this->assertSame( $expected, $actual );
 	}
 
 	/**
-	 * Test the private method WP_Web_Fonts::get_enqueued_fonts_for_provider().
+	 * Test the private method WP_Fonts::get_enqueued_fonts_for_provider().
 	 *
 	 * Why? This test validates the right fonts are returned for use within
-	 * WP_Web_Fonts::do_item().
+	 * WP_Fonts::do_item().
 	 *
 	 * @dataProvider data_get_enqueued_fonts_for_provider
 	 *
 	 * @param array $font_handles Array of handles for the provider.
-	 * @param array $to_do        Handles to set for the WP_Web_Fonts::$to_do property.
+	 * @param array $to_do        Handles to set for the WP_Fonts::$to_do property.
 	 * @param array $expected     Expected result.
 	 */
 	public function test_get_enqueued_fonts_for_provider( $font_handles, $to_do, $expected ) {
 		// Set up the `to_do` property.
-		$this->wp_webfonts->to_do = $to_do;
+		$this->wp_fonts->to_do = $to_do;
 
 		// Open the method's visibility for testing.
 		$get_enqueued_fonts_for_provider = $this->get_reflection_method( 'get_enqueued_fonts_for_provider' );
 
-		// Mock the WP_Web_Fonts::$property to set up the test.
-		$this->setup_provider_property_mock( $this->wp_webfonts, $this->get_provider_definitions( 'mock' ), $font_handles );
+		// Mock the WP_Fonts::$property to set up the test.
+		$this->setup_provider_property_mock( $this->wp_fonts, $this->get_provider_definitions( 'mock' ), $font_handles );
 
-		$actual = $get_enqueued_fonts_for_provider->invoke( $this->wp_webfonts, 'mock' );
+		$actual = $get_enqueued_fonts_for_provider->invoke( $this->wp_fonts, 'mock' );
 		$this->assertSameSets( $expected, $actual );
 	}
 
@@ -124,10 +124,10 @@ public function data_get_enqueued_fonts_for_provider() {
 	}
 
 	/**
-	 * Test the private method WP_Web_Fonts::get_font_properties_for_provider().
+	 * Test the private method WP_Fonts::get_font_properties_for_provider().
 	 *
 	 * Why? This test validates the right font properties are returned for use within
-	 * WP_Web_Fonts::do_item().
+	 * WP_Fonts::do_item().
 	 *
 	 * @dataProvider data_get_font_properties_for_provider
 	 *
@@ -139,14 +139,14 @@ public function test_get_font_properties_for_provider( $font_handles, $expected
 		$fonts = $this->get_registered_fonts();
 		// Set all variations to 'mock' provider.
 
-		// Mock the WP_Web_Fonts::$property to set up the test.
-		$this->setup_provider_property_mock( $this->wp_webfonts, $this->get_provider_definitions( 'mock' ), $font_handles );
-		$this->setup_registration_mocks( $fonts, $this->wp_webfonts );
+		// Mock the WP_Fonts::$property to set up the test.
+		$this->setup_provider_property_mock( $this->wp_fonts, $this->get_provider_definitions( 'mock' ), $font_handles );
+		$this->setup_registration_mocks( $fonts, $this->wp_fonts );
 
 		// Open the method's visibility for testing.
 		$method = $this->get_reflection_method( 'get_font_properties_for_provider' );
 
-		$actual = $method->invoke( $this->wp_webfonts, $font_handles );
+		$actual = $method->invoke( $this->wp_fonts, $font_handles );
 		$this->assertSame( $expected, $actual );
 	}
 
@@ -193,13 +193,13 @@ public function test_should_trigger_provider_when_mocked( array $provider, array
 		$provider_mock->expects( $this->once() )->method( 'set_fonts' )->with( $this->identicalTo( $expected['set_fonts'] ) );
 		$provider_mock->expects( $this->once() )->method( 'print_styles' );
 
-		// Set up the WP_Web_Fonts::$provider_instances property.
+		// Set up the WP_Fonts::$provider_instances property.
 		$provider_instances = $this->get_reflection_property( 'provider_instances' );
-		$provider_instances->setValue( $this->wp_webfonts, array( $provider['id'] => $provider_mock ) );
+		$provider_instances->setValue( $this->wp_fonts, array( $provider['id'] => $provider_mock ) );
 
 		// Test the method successfully processes the provider.
 		$this->expectOutputString( '' );
-		$this->assertTrue( $this->wp_webfonts->do_item( $provider['id'] ), 'WP_Web_Fonts::do_item() should return true' );
+		$this->assertTrue( $this->wp_fonts->do_item( $provider['id'] ), 'WP_Fonts::do_item() should return true' );
 	}
 
 	/**
@@ -216,7 +216,7 @@ public function test_should_print( array $provider, array $fonts, array $expecte
 
 		// Test the method successfully processes the provider.
 		$this->expectOutputString( $expected['printed_output'] );
-		$this->assertTrue( $this->wp_webfonts->do_item( $provider['id'] ), 'WP_Web_Fonts::do_item() should return true' );
+		$this->assertTrue( $this->wp_fonts->do_item( $provider['id'] ), 'WP_Fonts::do_item() should return true' );
 	}
 
 	/**
@@ -234,7 +234,7 @@ public function data_print_enqueued_fonts() {
 				'provider' => $this->get_provider_definitions( 'mock' ),
 				'fonts'    => $mock,
 				'expected' => array(
-					'set_fonts'   => array_merge( $mock['font1'], $mock['font2'], $mock['font3'] ),
+					'set_fonts'      => array_merge( $mock['font1'], $mock['font2'], $mock['font3'] ),
 					'printed_output' => sprintf(
 						'<mock id="wp-fonts-mock" attr="some-attr">%s; %s; %s; %s; %s; %s</mock>\n',
 						$font_faces['font1-300-normal'],
@@ -250,7 +250,7 @@ public function data_print_enqueued_fonts() {
 				'provider' => $this->get_provider_definitions( 'local' ),
 				'fonts'    => $local,
 				'expected' => array(
-					'set_fonts'   => array_merge( $local['merriweather'], $local['Source Serif Pro'] ),
+					'set_fonts'      => array_merge( $local['merriweather'], $local['Source Serif Pro'] ),
 					'printed_output' => sprintf(
 						"<style id='wp-fonts-local' type='text/css'>\n%s%s%s\n</style>\n",
 						$font_faces['merriweather-200-900-normal'],
@@ -270,14 +270,14 @@ public function data_print_enqueued_fonts() {
 	 * @param array $provider    Define provider.
 	 * @param array $fonts       Fonts to register and enqueue.
 	 * @param array $expected    Not used.
-	 * @param array $to_do_queue Value to set in the WP_Web_Fonts::$to_do queue.
+	 * @param array $to_do_queue Value to set in the WP_Fonts::$to_do queue.
 	 */
 	public function test_should_not_print_when_to_do_queue_empty( array $provider, array $fonts, $expected, $to_do_queue ) {
 		$this->setup_print_deps( $provider, $fonts, $to_do_queue );
 
 		// Test the method successfully processes the provider.
 		$this->expectOutputString( '' );
-		$this->assertFalse( $this->wp_webfonts->do_item( $provider['id'] ), 'WP_Web_Fonts::do_item() should return false' );
+		$this->assertFalse( $this->wp_fonts->do_item( $provider['id'] ), 'WP_Fonts::do_item() should return false' );
 	}
 
 	/**
@@ -316,21 +316,21 @@ public function data_not_print_enqueued_fonts() {
 	 *
 	 * @param array      $provider    Provider id and class.
 	 * @param array      $fonts       Fonts to register and enqueue.
-	 * @param array|null $to_do_queue Set the WP_Web_Fonts:$to_do queue.
+	 * @param array|null $to_do_queue Set the WP_Fonts:$to_do queue.
 	 */
 	private function setup_print_deps( $provider, $fonts, $to_do_queue = null ) {
 		// Set up the fonts for WP_Dependencies:get_data().
-		$mocks   = $this->setup_registration_mocks( $fonts, $this->wp_webfonts );
+		$mocks   = $this->setup_registration_mocks( $fonts, $this->wp_fonts );
 		$handles = array_keys( $mocks );
-		$this->setup_provider_property_mock( $this->wp_webfonts, $provider, $handles );
+		$this->setup_provider_property_mock( $this->wp_fonts, $provider, $handles );
 
-		// Set up the `WP_Web_Fonts::$to_do` and `WP_Web_Fonts::$to_do_keyed_handles` properties.
+		// Set up the `WP_Fonts::$to_do` and `WP_Fonts::$to_do_keyed_handles` properties.
 		if ( null === $to_do_queue ) {
 			$to_do_queue = $handles;
 		}
 
-		$this->wp_webfonts->to_do = $to_do_queue;
-		$to_do_keyed_handles      = $this->get_reflection_property( 'to_do_keyed_handles' );
-		$to_do_keyed_handles->setValue( $this->wp_webfonts, array_flip( $to_do_queue ) );
+		$this->wp_fonts->to_do = $to_do_queue;
+		$to_do_keyed_handles   = $this->get_reflection_property( 'to_do_keyed_handles' );
+		$to_do_keyed_handles->setValue( $this->wp_fonts, array_flip( $to_do_queue ) );
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/doItems-test.php b/phpunit/fonts-api/wpFonts/doItems-test.php
similarity index 79%
rename from phpunit/fonts-api/wpWebfonts/doItems-test.php
rename to phpunit/fonts-api/wpFonts/doItems-test.php
index 20a03c5d814fdf..20314f957014d9 100644
--- a/phpunit/fonts-api/wpWebfonts/doItems-test.php
+++ b/phpunit/fonts-api/wpFonts/doItems-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::do_items() tests.
+ * WP_Fonts::do_items() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -12,23 +12,23 @@
 /**
  * @group  fontsapi
  * @group  printfonts
- * @covers WP_Web_Fonts::do_items
+ * @covers WP_Fonts::do_items
  */
-class Tests_Webfonts_WpWebfonts_DoItems extends WP_Fonts_TestCase {
-	private $wp_webfonts;
+class Tests_Fonts_WpFonts_DoItems extends WP_Fonts_TestCase {
+	private $wp_fonts;
 
 	public function set_up() {
 		parent::set_up();
-		$this->wp_webfonts = new WP_Web_Fonts;
+		$this->wp_fonts = new WP_Fonts;
 	}
 
 	public function test_should_not_process_when_no_providers_registered() {
 		$this->setup_deps( array( 'enqueued' => 'font1' ) );
 
-		$done = $this->wp_webfonts->do_items();
+		$done = $this->wp_fonts->do_items();
 
-		$this->assertSame( array(), $done, 'WP_Web_Fonts::do_items() should return an empty array' );
-		$this->assertSame( array(), $this->wp_webfonts->to_do, 'WP_Web_Fonts::$to_do should be an empty array' );
+		$this->assertSame( array(), $done, 'WP_Fonts::do_items() should return an empty array' );
+		$this->assertSame( array(), $this->wp_fonts->to_do, 'WP_Fonts::$to_do should be an empty array' );
 	}
 
 	/**
@@ -40,7 +40,7 @@ public function test_should_throw_notice_when_invalid_handles( $handles ) {
 		$this->expectNotice();
 		$this->expectNoticeMessage( 'Handles must be a non-empty string or array of non-empty strings' );
 
-		$this->wp_webfonts->do_items( $handles );
+		$this->wp_fonts->do_items( $handles );
 	}
 
 	/**
@@ -60,7 +60,7 @@ public function data_invalid_handles() {
 
 	public function test_should_throw_notice_when_provider_class_not_found() {
 		$this->expectNotice();
-		$this->expectNoticeMessage( 'Class "Provider_Does_Not_Exist" not found for "doesnotexist" web font provider' );
+		$this->expectNoticeMessage( 'Class "Provider_Does_Not_Exist" not found for "doesnotexist" font provider' );
 
 		$setup = array(
 			'provider'         => array(
@@ -86,7 +86,7 @@ public function test_should_throw_notice_when_provider_class_not_found() {
 		);
 		$this->setup_deps( $setup );
 
-		$this->wp_webfonts->do_items();
+		$this->wp_fonts->do_items();
 	}
 
 	/**
@@ -100,7 +100,7 @@ public function test_should_print_mocked_enqueued( $setup, $expected_done, $expe
 		$this->setup_deps( $setup );
 
 		$this->expectOutputString( $expected_output );
-		$actual_done = $this->wp_webfonts->do_items();
+		$actual_done = $this->wp_fonts->do_items();
 		$this->assertSameSets( $expected_done, $actual_done, 'Printed handles should match' );
 	}
 
@@ -118,7 +118,7 @@ public function test_should_print_enqueued( $setup, $expected_done, $expected_ou
 		$this->setup_integrated_deps( $setup );
 
 		$this->expectOutputString( $expected_output, 'Printed @font-face styles should match' );
-		$actual_done = $this->wp_webfonts->do_items();
+		$actual_done = $this->wp_fonts->do_items();
 		$this->assertSameSets( $expected_done, $actual_done, 'Printed handles should match' );
 	}
 
@@ -134,12 +134,12 @@ public function test_should_print_enqueued( $setup, $expected_done, $expected_ou
 	 */
 	public function test_should_print_handles_when_not_enqueued( $setup, $expected_done, $expected_output ) {
 		$this->setup_integrated_deps( $setup, false );
-		// Do not enqueue. Instead, pass the handles to WP_Web_Fonts::do_items().
+		// Do not enqueue. Instead, pass the handles to WP_Fonts::do_items().
 		$handles = $setup['enqueued'];
-		$this->assertEmpty( $this->wp_webfonts->queue, 'No fonts should be enqueued' );
+		$this->assertEmpty( $this->wp_fonts->queue, 'No fonts should be enqueued' );
 
 		$this->expectOutputString( $expected_output );
-		$actual_done = $this->wp_webfonts->do_items( $handles );
+		$actual_done = $this->wp_fonts->do_items( $handles );
 		$this->assertSameSets( $expected_done, $actual_done, 'Printed handles should match' );
 	}
 
@@ -161,17 +161,17 @@ private function setup_deps( array $setup ) {
 
 		if ( ! empty( $setup['provider'] ) ) {
 			foreach ( $setup['provider'] as $provider_id => $provider ) {
-				$this->setup_provider_property_mock( $this->wp_webfonts, $provider, $setup['provider_handles'][ $provider_id ] );
+				$this->setup_provider_property_mock( $this->wp_fonts, $provider, $setup['provider_handles'][ $provider_id ] );
 			}
 		}
 
 		if ( ! empty( $setup['registered'] ) ) {
-			$this->setup_registration_mocks( $setup['registered'], $this->wp_webfonts );
+			$this->setup_registration_mocks( $setup['registered'], $this->wp_fonts );
 		}
 
 		if ( ! empty( $setup['enqueued'] ) ) {
 			$queue = $this->get_reflection_property( 'queue' );
-			$queue->setValue( $this->wp_webfonts, $setup['enqueued'] );
+			$queue->setValue( $this->wp_fonts, $setup['enqueued'] );
 		}
 	}
 
@@ -183,14 +183,14 @@ private function setup_deps( array $setup ) {
 	 */
 	private function setup_integrated_deps( array $setup, $enqueue = true ) {
 		foreach ( $setup['provider'] as $provider ) {
-			$this->wp_webfonts->register_provider( $provider['id'], $provider['class'] );
+			$this->wp_fonts->register_provider( $provider['id'], $provider['class'] );
 		}
 		foreach ( $setup['registered'] as $handle => $variations ) {
-			$this->setup_register( $handle, $variations, $this->wp_webfonts );
+			$this->setup_register( $handle, $variations, $this->wp_fonts );
 		}
 
 		if ( $enqueue ) {
-			$this->wp_webfonts->enqueue( $setup['enqueued'] );
+			$this->wp_fonts->enqueue( $setup['enqueued'] );
 		}
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/enqueue-test.php b/phpunit/fonts-api/wpFonts/enqueue-test.php
similarity index 57%
rename from phpunit/fonts-api/wpWebfonts/enqueue-test.php
rename to phpunit/fonts-api/wpFonts/enqueue-test.php
index dcfa67b3b85742..34380febfef5df 100644
--- a/phpunit/fonts-api/wpWebfonts/enqueue-test.php
+++ b/phpunit/fonts-api/wpFonts/enqueue-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::enqueue() tests.
+ * WP_Fonts::enqueue() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -10,9 +10,9 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::enqueue
+ * @covers WP_Fonts::enqueue
  */
-class Tests_Webfonts_WpWebfonts_Enqueue extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_Enqueue extends WP_Fonts_TestCase {
 
 	/**
 	 * @dataProvider data_enqueue
@@ -23,11 +23,11 @@ class Tests_Webfonts_WpWebfonts_Enqueue extends WP_Fonts_TestCase {
 	 * @param array           $expected Expected "queued_before_register" queue.
 	 */
 	public function test_should_prequeue_when_not_registered( $handles, $not_used, $expected ) {
-		$wp_webfonts = new WP_Web_Fonts();
-		$wp_webfonts->enqueue( $handles );
+		$wp_fonts = new WP_Fonts();
+		$wp_fonts->enqueue( $handles );
 
-		$this->assertSame( $expected, $this->get_queued_before_register( $wp_webfonts ), 'Handles should be added to before registered queue' );
-		$this->assertEmpty( $wp_webfonts->queue, 'Handles should not be added to the enqueue queue when not registered' );
+		$this->assertSame( $expected, $this->get_queued_before_register( $wp_fonts ), 'Handles should be added to before registered queue' );
+		$this->assertEmpty( $wp_fonts->queue, 'Handles should not be added to the enqueue queue when not registered' );
 	}
 
 	/**
@@ -40,14 +40,14 @@ public function test_should_prequeue_when_not_registered( $handles, $not_used, $
 	 * @param array           $expected Expected queue.
 	 */
 	public function test_should_enqueue_when_registered( $handles, array $expected ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 		foreach ( $this->get_data_registry() as $font_family => $variations ) {
-			$this->setup_register( $font_family, $variations, $wp_webfonts );
+			$this->setup_register( $font_family, $variations, $wp_fonts );
 		}
 
-		$wp_webfonts->enqueue( $handles );
+		$wp_fonts->enqueue( $handles );
 
-		$this->assertEmpty( $this->get_queued_before_register( $wp_webfonts ), '"queued_before_register" queue should be empty' );
-		$this->assertSame( $expected, $wp_webfonts->queue, 'Queue should contain the given handles' );
+		$this->assertEmpty( $this->get_queued_before_register( $wp_fonts ), '"queued_before_register" queue should be empty' );
+		$this->assertSame( $expected, $wp_fonts->queue, 'Queue should contain the given handles' );
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/getEnqueued-test.php b/phpunit/fonts-api/wpFonts/getEnqueued-test.php
similarity index 63%
rename from phpunit/fonts-api/wpWebfonts/getEnqueued-test.php
rename to phpunit/fonts-api/wpFonts/getEnqueued-test.php
index e6d32249f9f47a..68a509f3c35ccb 100644
--- a/phpunit/fonts-api/wpWebfonts/getEnqueued-test.php
+++ b/phpunit/fonts-api/wpFonts/getEnqueued-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::get_enqueued() tests.
+ * WP_Fonts::get_enqueued() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -10,13 +10,13 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::get_enqueued
+ * @covers WP_Fonts::get_enqueued
  */
-class Tests_Webfonts_WpWebfonts_GetEnqueued extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_GetEnqueued extends WP_Fonts_TestCase {
 
 	public function test_should_return_empty_when_non_enqueued() {
-		$wp_webfonts = new WP_Web_Fonts();
-		$this->assertEmpty( $wp_webfonts->get_enqueued() );
+		$wp_fonts = new WP_Fonts();
+		$this->assertEmpty( $wp_fonts->get_enqueued() );
 	}
 
 	/**
@@ -28,10 +28,10 @@ public function test_should_return_empty_when_non_enqueued() {
 	 * @param array           $expected    Expected queue.
 	 */
 	public function test_should_return_queue_when_property_has_font_families( $not_used, array $expected ) {
-		$wp_webfonts        = new WP_Web_Fonts();
-		$wp_webfonts->queue = $expected;
+		$wp_fonts        = new WP_Fonts();
+		$wp_fonts->queue = $expected;
 
-		$this->assertSame( $expected, $wp_webfonts->get_enqueued() );
+		$this->assertSame( $expected, $wp_fonts->get_enqueued() );
 	}
 
 	/**
@@ -44,14 +44,14 @@ public function test_should_return_queue_when_property_has_font_families( $not_u
 	 * @param array           $expected    Expected queue.
 	 */
 	public function test_should_return_queue_when_font_families_registered_and_enqueued( $font_family, array $expected ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 
 		// Register and enqueue.
 		foreach ( $this->get_data_registry() as $handle => $variations ) {
-			$this->setup_register( $handle, $variations, $wp_webfonts );
+			$this->setup_register( $handle, $variations, $wp_fonts );
 		}
-		$wp_webfonts->enqueue( $font_family );
+		$wp_fonts->enqueue( $font_family );
 
-		$this->assertSame( $expected, $wp_webfonts->get_enqueued() );
+		$this->assertSame( $expected, $wp_fonts->get_enqueued() );
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/getProviders-test.php b/phpunit/fonts-api/wpFonts/getProviders-test.php
similarity index 65%
rename from phpunit/fonts-api/wpWebfonts/getProviders-test.php
rename to phpunit/fonts-api/wpFonts/getProviders-test.php
index 879bab4113df59..ed73921a31aea4 100644
--- a/phpunit/fonts-api/wpWebfonts/getProviders-test.php
+++ b/phpunit/fonts-api/wpFonts/getProviders-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::get_providers() tests.
+ * WP_Fonts::get_providers() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -11,22 +11,22 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::get_providers
+ * @covers WP_Fonts::get_providers
  */
-class Tests_Webfonts_WpWebfonts_GetProviders extends WP_Fonts_TestCase {
-	private $wp_webfonts;
+class Tests_Fonts_WpFonts_GetProviders extends WP_Fonts_TestCase {
+	private $wp_fonts;
 	private $providers_property;
 
 	public function set_up() {
 		parent::set_up();
-		$this->wp_webfonts = new WP_Web_Fonts();
+		$this->wp_fonts = new WP_Fonts();
 
-		$this->providers_property = new ReflectionProperty( WP_Web_Fonts::class, 'providers' );
+		$this->providers_property = new ReflectionProperty( WP_Fonts::class, 'providers' );
 		$this->providers_property->setAccessible( true );
 	}
 
 	public function test_should_be_empty() {
-		$actual = $this->wp_webfonts->get_providers();
+		$actual = $this->wp_fonts->get_providers();
 		$this->assertIsArray( $actual, 'Should return an empty array' );
 		$this->assertEmpty( $actual, 'Should return an empty array when no providers are registered' );
 	}
@@ -39,11 +39,11 @@ public function test_should_be_empty() {
 	 */
 	public function test_get_providers( array $providers, array $expected ) {
 		$this->setup_providers( $providers );
-		$this->assertSame( $expected, $this->wp_webfonts->get_providers() );
+		$this->assertSame( $expected, $this->wp_fonts->get_providers() );
 	}
 
 	/**
-	 * Sets up the given providers and stores them in the `WP_Web_Fonts::providers` property.
+	 * Sets up the given providers and stores them in the `WP_Fonts::providers` property.
 	 *
 	 * @param array $providers Array of providers to set up.
 	 */
@@ -57,6 +57,6 @@ private function setup_providers( array $providers ) {
 			);
 		}
 
-		$this->providers_property->setValue( $this->wp_webfonts, $data );
+		$this->providers_property->setValue( $this->wp_fonts, $data );
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/getRegistered-test.php b/phpunit/fonts-api/wpFonts/getRegistered-test.php
similarity index 75%
rename from phpunit/fonts-api/wpWebfonts/getRegistered-test.php
rename to phpunit/fonts-api/wpFonts/getRegistered-test.php
index efad00748dc49a..365a97733f3cfa 100644
--- a/phpunit/fonts-api/wpWebfonts/getRegistered-test.php
+++ b/phpunit/fonts-api/wpFonts/getRegistered-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::get_registered() tests.
+ * WP_Fonts::get_registered() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -11,13 +11,13 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::get_registered
+ * @covers WP_Fonts::get_registered
  */
-class Tests_Webfonts_WpWebfonts_GetRegistered extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_GetRegistered extends WP_Fonts_TestCase {
 
 	public function test_should_return_empty_when_none_registered() {
-		$wp_webfonts = new WP_Web_Fonts();
-		$this->assertEmpty( $wp_webfonts->get_registered() );
+		$wp_fonts = new WP_Fonts();
+		$this->assertEmpty( $wp_fonts->get_registered() );
 	}
 
 	/**
@@ -28,11 +28,11 @@ public function test_should_return_empty_when_none_registered() {
 	 * @param array $inputs Font family(ies) and variations to register.
 	 */
 	public function test_should_return_queue_when_mocking_registered_property( array $inputs ) {
-		$wp_webfonts = new WP_Web_Fonts();
-		$mocks       = $this->setup_registration_mocks( $inputs, $wp_webfonts );
-		$expected    = array_keys( $mocks );
+		$wp_fonts = new WP_Fonts();
+		$mocks    = $this->setup_registration_mocks( $inputs, $wp_fonts );
+		$expected = array_keys( $mocks );
 
-		$this->assertSame( $expected, $wp_webfonts->get_registered() );
+		$this->assertSame( $expected, $wp_fonts->get_registered() );
 	}
 
 	/**
@@ -78,13 +78,13 @@ public function data_get_registered() {
 	 * @param array  $expected    Expected results.
 	 */
 	public function test_should_return_queue_when_items_are_registered( $font_family, array $inputs, array $expected ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 
 		// Register before testing.
 		foreach ( $inputs as $handle => $variations ) {
-			$this->setup_register( $handle, $variations, $wp_webfonts );
+			$this->setup_register( $handle, $variations, $wp_fonts );
 		}
 
-		$this->assertSame( $expected, $wp_webfonts->get_registered() );
+		$this->assertSame( $expected, $wp_fonts->get_registered() );
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/query-test.php b/phpunit/fonts-api/wpFonts/query-test.php
similarity index 67%
rename from phpunit/fonts-api/wpWebfonts/query-test.php
rename to phpunit/fonts-api/wpFonts/query-test.php
index faae2af93e32b8..c64d88cf9fa867 100644
--- a/phpunit/fonts-api/wpWebfonts/query-test.php
+++ b/phpunit/fonts-api/wpFonts/query-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::query() tests.
+ * WP_Fonts::query() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -10,15 +10,15 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::query
+ * @covers WP_Fonts::query
  */
-class Tests_Webfonts_WpWebfonts_Query extends WP_Fonts_TestCase {
-	private $wp_webfonts;
+class Tests_Fonts_WpFonts_Query extends WP_Fonts_TestCase {
+	private $wp_fonts;
 
 	public function set_up() {
 		parent::set_up();
 
-		$this->wp_webfonts = new WP_Web_Fonts();
+		$this->wp_fonts = new WP_Fonts();
 	}
 
 	/**
@@ -28,7 +28,7 @@ public function set_up() {
 	 * @param string $query_handle Handle to test.
 	 */
 	public function test_should_fail_when_handles_not_registered( $query_handle ) {
-		$this->assertFalse( $this->wp_webfonts->query( $query_handle, 'registered' ) );
+		$this->assertFalse( $this->wp_fonts->query( $query_handle, 'registered' ) );
 	}
 
 	/**
@@ -38,7 +38,7 @@ public function test_should_fail_when_handles_not_registered( $query_handle ) {
 	 * @param string $query_handle Handle to test.
 	 */
 	public function test_should_fail_when_handles_not_registered_or_enqueued( $query_handle ) {
-		$this->assertFalse( $this->wp_webfonts->query( $query_handle, 'queue' ) );
+		$this->assertFalse( $this->wp_fonts->query( $query_handle, 'queue' ) );
 	}
 
 	/**
@@ -49,7 +49,7 @@ public function test_should_fail_when_handles_not_registered_or_enqueued( $query
 	public function test_registered_query_should_succeed_when_registered( $query_handle ) {
 		$this->setup_registry();
 
-		$actual = $this->wp_webfonts->query( $query_handle, 'registered' );
+		$actual = $this->wp_fonts->query( $query_handle, 'registered' );
 		$this->assertInstanceOf( '_WP_Dependency', $actual, 'Query should return an instance of _WP_Dependency' );
 		$this->assertSame( $query_handle, $actual->handle, 'Query object handle should match the given handle to query' );
 	}
@@ -61,9 +61,9 @@ public function test_registered_query_should_succeed_when_registered( $query_han
 	 */
 	public function test_enqueued_query_should_succeed_when_registered_and_enqueued( $query_handle ) {
 		$this->setup_registry();
-		$this->wp_webfonts->enqueue( $query_handle );
+		$this->wp_fonts->enqueue( $query_handle );
 
-		$this->assertTrue( $this->wp_webfonts->query( $query_handle, 'enqueued' ) );
+		$this->assertTrue( $this->wp_fonts->query( $query_handle, 'enqueued' ) );
 	}
 
 	/**
@@ -72,9 +72,9 @@ public function test_enqueued_query_should_succeed_when_registered_and_enqueued(
 	 * @param string $query_handle Handle to test.
 	 */
 	public function test_enqueued_query_should_fail_when_not_registered_but_enqueued( $query_handle ) {
-		$this->wp_webfonts->enqueue( $query_handle );
+		$this->wp_fonts->enqueue( $query_handle );
 
-		$this->assertFalse( $this->wp_webfonts->query( $query_handle, 'enqueued' ) );
+		$this->assertFalse( $this->wp_fonts->query( $query_handle, 'enqueued' ) );
 	}
 
 	/**
@@ -104,13 +104,13 @@ public function data_valid_query() {
 	}
 
 	public function test_done_query_should_fail_when_no_variations() {
-		$this->wp_webfonts->register_provider( 'local', WP_Fonts_Provider_Local::class );
+		$this->wp_fonts->register_provider( 'local', WP_Fonts_Provider_Local::class );
 		$this->setup_registry();
-		$this->wp_webfonts->enqueue( 'lato' );
+		$this->wp_fonts->enqueue( 'lato' );
 
-		$this->wp_webfonts->do_items( 'lato' );
+		$this->wp_fonts->do_items( 'lato' );
 
-		$this->assertFalse( $this->wp_webfonts->query( 'lato', 'done' ) );
+		$this->assertFalse( $this->wp_fonts->query( 'lato', 'done' ) );
 	}
 
 	/**
@@ -119,16 +119,16 @@ public function test_done_query_should_fail_when_no_variations() {
 	 * @param string $query_handle Handle to test.
 	 */
 	public function test_done_query_should_succeed_when_registered_and_enqueued( $query_handle ) {
-		$this->wp_webfonts->register_provider( 'local', WP_Fonts_Provider_Local::class );
+		$this->wp_fonts->register_provider( 'local', WP_Fonts_Provider_Local::class );
 		$this->setup_registry();
-		$this->wp_webfonts->enqueue( $query_handle );
+		$this->wp_fonts->enqueue( $query_handle );
 
-		// Process the web fonts while ignoring all the printed output.
+		// Process the fonts while ignoring all the printed output.
 		$this->expectOutputRegex( '`.`' );
-		$this->wp_webfonts->do_items( $query_handle );
+		$this->wp_fonts->do_items( $query_handle );
 		$this->getActualOutput();
 
-		$this->assertTrue( $this->wp_webfonts->query( $query_handle, 'done' ) );
+		$this->assertTrue( $this->wp_fonts->query( $query_handle, 'done' ) );
 	}
 
 	/**
@@ -145,7 +145,7 @@ public function data_done_query() {
 
 	private function setup_registry() {
 		foreach ( $this->get_registered_local_fonts() as $handle => $variations ) {
-			$this->setup_register( $handle, $variations, $this->wp_webfonts );
+			$this->setup_register( $handle, $variations, $this->wp_fonts );
 		}
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/registerProvider-test.php b/phpunit/fonts-api/wpFonts/registerProvider-test.php
similarity index 64%
rename from phpunit/fonts-api/wpWebfonts/registerProvider-test.php
rename to phpunit/fonts-api/wpFonts/registerProvider-test.php
index f33273fef03622..e4c9454c19ca1c 100644
--- a/phpunit/fonts-api/wpWebfonts/registerProvider-test.php
+++ b/phpunit/fonts-api/wpFonts/registerProvider-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::register_provider() tests.
+ * WP_Fonts::register_provider() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -11,9 +11,9 @@
 
 /**
  * @group  fontsapi
- * @covers WP_Web_Fonts::register_provider
+ * @covers WP_Fonts::register_provider
  */
-class Tests_Webfonts_WpWebfonts_RegisterProvider extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_RegisterProvider extends WP_Fonts_TestCase {
 
 	/**
 	 * @dataProvider data_register_providers
@@ -23,9 +23,9 @@ class Tests_Webfonts_WpWebfonts_RegisterProvider extends WP_Fonts_TestCase {
 	 * @param array  $expected    Expected providers queue.
 	 */
 	public function test_should_register_provider( $provider_id, $class, $expected ) {
-		$wp_webfonts = new WP_Web_Fonts();
-		$this->assertTrue( $wp_webfonts->register_provider( $provider_id, $class ), 'WP_Web_Fonts::register_provider() should return true' );
-		$this->assertSame( $expected, $wp_webfonts->get_providers(), 'Provider "' . $provider_id . '" should be registered in providers queue' );
+		$wp_fonts = new WP_Fonts();
+		$this->assertTrue( $wp_fonts->register_provider( $provider_id, $class ), 'WP_Fonts::register_provider() should return true' );
+		$this->assertSame( $expected, $wp_fonts->get_providers(), 'Provider "' . $provider_id . '" should be registered in providers queue' );
 	}
 
 	/**
@@ -59,10 +59,10 @@ public function data_register_providers() {
 	}
 
 	public function test_should_register_mutliple_providers() {
-		$wp_webfonts = new WP_Web_Fonts();
-		$providers   = $this->get_provider_definitions();
+		$wp_fonts  = new WP_Fonts();
+		$providers = $this->get_provider_definitions();
 		foreach ( $providers as $provider ) {
-			$this->assertTrue( $wp_webfonts->register_provider( $provider['id'], $provider['class'] ), 'WP_Web_Fonts::register_provider() should return true for provider ' . $provider['id'] );
+			$this->assertTrue( $wp_fonts->register_provider( $provider['id'], $provider['class'] ), 'WP_Fonts::register_provider() should return true for provider ' . $provider['id'] );
 		}
 
 		$expected = array(
@@ -76,7 +76,7 @@ public function test_should_register_mutliple_providers() {
 			),
 		);
 
-		$this->assertSame( $expected, $wp_webfonts->get_providers(), 'Both local and mock providers should be registered' );
+		$this->assertSame( $expected, $wp_fonts->get_providers(), 'Both local and mock providers should be registered' );
 	}
 
 	/**
@@ -86,10 +86,10 @@ public function test_should_register_mutliple_providers() {
 	 * @param string $class       Provider class name.
 	 */
 	public function test_should_not_register( $provider_id, $class ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 
-		$this->assertFalse( $wp_webfonts->register_provider( $provider_id, $class ), 'WP_Web_Fonts::register_provider() should return false' );
-		$this->assertArrayNotHasKey( $provider_id, $wp_webfonts->get_providers(), 'Both local and mock providers should be registered' );
+		$this->assertFalse( $wp_fonts->register_provider( $provider_id, $class ), 'WP_Fonts::register_provider() should return false' );
+		$this->assertArrayNotHasKey( $provider_id, $wp_fonts->get_providers(), 'Both local and mock providers should be registered' );
 	}
 
 	/**
diff --git a/phpunit/fonts-api/wpWebfonts/remove-test.php b/phpunit/fonts-api/wpFonts/remove-test.php
similarity index 78%
rename from phpunit/fonts-api/wpWebfonts/remove-test.php
rename to phpunit/fonts-api/wpFonts/remove-test.php
index 21eecb6a03ce2c..6da419a988e853 100644
--- a/phpunit/fonts-api/wpWebfonts/remove-test.php
+++ b/phpunit/fonts-api/wpFonts/remove-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::remove() tests.
+ * WP_Fonts::remove() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -11,16 +11,16 @@
 /**
  * @group  fontsapi
  * @group  remove_fonts
- * @covers WP_Web_Fonts::remove
+ * @covers WP_Fonts::remove
  */
-class Tests_Webfonts_WpWebfonts_Remove extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_Remove extends WP_Fonts_TestCase {
 
 	public function test_should_not_remove_when_none_registered() {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 
-		$wp_webfonts->remove( array( 'handle-1', 'handle2' ) );
+		$wp_fonts->remove( array( 'handle-1', 'handle2' ) );
 
-		$this->assertEmpty( $wp_webfonts->registered );
+		$this->assertEmpty( $wp_fonts->registered );
 	}
 
 	/**
@@ -30,12 +30,12 @@ public function test_should_not_remove_when_none_registered() {
 	 * @param array $expected Expected handles are running test.
 	 */
 	public function test_should_remove_when_registered( array $handles, array $expected ) {
-		$wp_webfonts             = new WP_Web_Fonts();
-		$wp_webfonts->registered = $this->generate_registered_queue();
+		$wp_fonts             = new WP_Fonts();
+		$wp_fonts->registered = $this->generate_registered_queue();
 
-		$wp_webfonts->remove( $handles );
+		$wp_fonts->remove( $handles );
 
-		$this->assertSameSets( $expected, array_keys( $wp_webfonts->registered ), 'Registered queue should match after removing handles' );
+		$this->assertSameSets( $expected, array_keys( $wp_fonts->registered ), 'Registered queue should match after removing handles' );
 	}
 
 	/**
diff --git a/phpunit/fonts-api/wpWebfonts/removeFontFamily-test.php b/phpunit/fonts-api/wpFonts/removeFontFamily-test.php
similarity index 51%
rename from phpunit/fonts-api/wpWebfonts/removeFontFamily-test.php
rename to phpunit/fonts-api/wpFonts/removeFontFamily-test.php
index e04955bf650e52..b04882e04acdde 100644
--- a/phpunit/fonts-api/wpWebfonts/removeFontFamily-test.php
+++ b/phpunit/fonts-api/wpFonts/removeFontFamily-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::remove_font_family() tests.
+ * WP_Fonts::remove_font_family() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -11,9 +11,9 @@
 /**
  * @group fontsapi
  * @group remove_fonts
- * @covers WP_Web_Fonts::remove_font_family
+ * @covers WP_Fonts::remove_font_family
  */
-class Tests_Webfonts_WpWebfonts_RemoveFontFamily extends WP_Fonts_TestCase {
+class Tests_Fonts_WpFonts_RemoveFontFamily extends WP_Fonts_TestCase {
 
 	/**
 	 * @dataProvider data_one_to_many_font_families_and_zero_to_many_variations
@@ -24,16 +24,16 @@ class Tests_Webfonts_WpWebfonts_RemoveFontFamily extends WP_Fonts_TestCase {
 	 * @param array  $expected           Array of expected handles.
 	 */
 	public function test_should_dequeue_when_mocks_registered( $font_family, array $inputs, array $registered_handles, array $expected ) {
-		$wp_webfonts = new WP_Web_Fonts();
-		$this->setup_registration_mocks( $inputs, $wp_webfonts );
+		$wp_fonts = new WP_Fonts();
+		$this->setup_registration_mocks( $inputs, $wp_fonts );
 		// Test the before state, just to make sure.
-		$this->assertArrayHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should contain the font family before remove' );
-		$this->assertSame( $registered_handles, array_keys( $wp_webfonts->registered ), 'Font family and variations should be registered before remove' );
+		$this->assertArrayHasKey( $font_family, $wp_fonts->registered, 'Registered queue should contain the font family before remove' );
+		$this->assertSame( $registered_handles, array_keys( $wp_fonts->registered ), 'Font family and variations should be registered before remove' );
 
-		$wp_webfonts->remove_font_family( $font_family );
+		$wp_fonts->remove_font_family( $font_family );
 
-		$this->assertArrayNotHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should not contain the font family' );
-		$this->assertSame( $expected, array_keys( $wp_webfonts->registered ), 'Registered queue should match after removing font family' );
+		$this->assertArrayNotHasKey( $font_family, $wp_fonts->registered, 'Registered queue should not contain the font family' );
+		$this->assertSame( $expected, array_keys( $wp_fonts->registered ), 'Registered queue should match after removing font family' );
 	}
 
 	/**
@@ -45,14 +45,14 @@ public function test_should_dequeue_when_mocks_registered( $font_family, array $
 	 * @param array  $expected           Array of expected handles.
 	 */
 	public function test_should_bail_out_when_not_registered( $font_family, array $inputs, array $registered_handles, array $expected ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 		unset( $inputs[ $font_family ] );
-		$this->setup_registration_mocks( $inputs, $wp_webfonts );
+		$this->setup_registration_mocks( $inputs, $wp_fonts );
 
-		$wp_webfonts->remove_font_family( $font_family );
+		$wp_fonts->remove_font_family( $font_family );
 
-		$this->assertArrayNotHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should not contain the font family' );
-		$this->assertSame( $expected, array_keys( $wp_webfonts->registered ), 'Registered queue should match after removing font family' );
+		$this->assertArrayNotHasKey( $font_family, $wp_fonts->registered, 'Registered queue should not contain the font family' );
+		$this->assertSame( $expected, array_keys( $wp_fonts->registered ), 'Registered queue should match after removing font family' );
 	}
 
 	/**
@@ -66,24 +66,24 @@ public function test_should_bail_out_when_not_registered( $font_family, array $i
 	 * @param array  $expected           Array of expected handles.
 	 */
 	public function test_should_deregister_when_registered( $font_family, array $inputs, array $registered_handles, array $expected ) {
-		$wp_webfonts = new WP_Web_Fonts();
+		$wp_fonts = new WP_Fonts();
 		// Register all font families and their variations.
 		foreach ( $inputs as $input_font_family => $variations ) {
-			$handle = $wp_webfonts->add_font_family( $input_font_family );
+			$handle = $wp_fonts->add_font_family( $input_font_family );
 			foreach ( $variations as $variation_handle => $variation ) {
 				if ( ! is_string( $variation_handle ) ) {
 					$variation_handle = '';
 				}
-				$wp_webfonts->add_variation( $handle, $variation, $variation_handle );
+				$wp_fonts->add_variation( $handle, $variation, $variation_handle );
 			}
 		}
 		// Test the before state, just to make sure.
-		$this->assertArrayHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should contain the font family before remove' );
-		$this->assertSame( $registered_handles, array_keys( $wp_webfonts->registered ), 'Font family and variations should be registered before remove' );
+		$this->assertArrayHasKey( $font_family, $wp_fonts->registered, 'Registered queue should contain the font family before remove' );
+		$this->assertSame( $registered_handles, array_keys( $wp_fonts->registered ), 'Font family and variations should be registered before remove' );
 
-		$wp_webfonts->remove_font_family( $font_family );
+		$wp_fonts->remove_font_family( $font_family );
 
-		$this->assertArrayNotHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should not contain the font family' );
-		$this->assertSame( $expected, array_keys( $wp_webfonts->registered ), 'Registered queue should match after removing font family' );
+		$this->assertArrayNotHasKey( $font_family, $wp_fonts->registered, 'Registered queue should not contain the font family' );
+		$this->assertSame( $expected, array_keys( $wp_fonts->registered ), 'Registered queue should match after removing font family' );
 	}
 }
diff --git a/phpunit/fonts-api/wpWebfonts/removeVariation-test.php b/phpunit/fonts-api/wpFonts/removeVariation-test.php
similarity index 57%
rename from phpunit/fonts-api/wpWebfonts/removeVariation-test.php
rename to phpunit/fonts-api/wpFonts/removeVariation-test.php
index 067ce6ce3f224c..71e898a4ba45af 100644
--- a/phpunit/fonts-api/wpWebfonts/removeVariation-test.php
+++ b/phpunit/fonts-api/wpFonts/removeVariation-test.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * WP_Web_Fonts::remove_variation() tests.
+ * WP_Fonts::remove_variation() tests.
  *
  * @package    WordPress
  * @subpackage Fonts API
@@ -11,34 +11,34 @@
 /**
  * @group  fontsapi
  * @group  remove_fonts
- * @covers WP_Web_Fonts::remove_variation
+ * @covers WP_Fonts::remove_variation
  */
-class Tests_Webfonts_WpWebfonts_RemoveVariation extends WP_Fonts_TestCase {
-	private $wp_webfonts;
+class Tests_Fonts_WpFonts_RemoveVariation extends WP_Fonts_TestCase {
+	private $wp_fonts;
 	private $fonts_to_register = array();
 
 	public function set_up() {
 		parent::set_up();
-		$this->wp_webfonts       = new WP_Web_Fonts();
+		$this->wp_fonts          = new WP_Fonts();
 		$this->fonts_to_register = $this->get_registered_local_fonts();
 	}
 
 	/**
 	 * Sets up the unit test by mocking the WP_Dependencies object using stdClass and
-	 * registering each font family directly to the WP_Web_Fonts::$registered property
+	 * registering each font family directly to the WP_Fonts::$registered property
 	 * and its variations to the mocked $deps property.
 	 */
 	private function setup_unit_test() {
-		$this->setup_registration_mocks( $this->fonts_to_register, $this->wp_webfonts );
+		$this->setup_registration_mocks( $this->fonts_to_register, $this->wp_fonts );
 	}
 
 	/**
 	 * Sets up the integration test by properly registering each font family and its variations
-	 * by using the WP_Web_Fonts::add() and WP_Web_Fonts::add_variation() methods.
+	 * by using the WP_Fonts::add() and WP_Fonts::add_variation() methods.
 	 */
 	private function setup_integration_test() {
 		foreach ( $this->fonts_to_register as $font_family_handle => $variations ) {
-			$this->setup_register( $font_family_handle, $variations, $this->wp_webfonts );
+			$this->setup_register( $font_family_handle, $variations, $this->wp_fonts );
 		}
 	}
 
@@ -53,8 +53,8 @@ private function setup_integration_test() {
 	public function test_mocked_setup( $font_family_handle, $variation_handle ) {
 		$this->setup_unit_test();
 
-		$this->assertArrayHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be in the registered queue before remval' );
-		$this->assertContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should be in its font family deps before removal' );
+		$this->assertArrayHasKey( $variation_handle, $this->wp_fonts->registered, 'Variation should be in the registered queue before remval' );
+		$this->assertContains( $variation_handle, $this->wp_fonts->registered[ $font_family_handle ]->deps, 'Variation should be in its font family deps before removal' );
 	}
 
 	/**
@@ -70,13 +70,13 @@ public function test_unit_should_do_nothing_when_variation_and_font_family_not_r
 		// Set up the test.
 		unset( $this->fonts_to_register[ $font_family ] );
 		$this->setup_unit_test();
-		$registered_queue = $this->wp_webfonts->registered;
+		$registered_queue = $this->wp_fonts->registered;
 
 		// Run the tests.
-		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
-		$this->assertArrayNotHasKey( $font_family_handle, $this->wp_webfonts->registered, 'Font family should not be registered' );
-		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
-		$this->assertSame( $registered_queue, $this->wp_webfonts->registered, 'Registered queue should not have changed' );
+		$this->wp_fonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $font_family_handle, $this->wp_fonts->registered, 'Font family should not be registered' );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_fonts->registered, 'Variant should not be registered' );
+		$this->assertSame( $registered_queue, $this->wp_fonts->registered, 'Registered queue should not have changed' );
 	}
 
 	/**
@@ -92,13 +92,13 @@ public function test_should_do_nothing_when_variation_and_font_family_not_regist
 		// Set up the test.
 		unset( $this->fonts_to_register[ $font_family ] );
 		$this->setup_integration_test();
-		$registered_queue = $this->wp_webfonts->get_registered();
+		$registered_queue = $this->wp_fonts->get_registered();
 
 		// Run the tests.
-		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
-		$this->assertArrayNotHasKey( $font_family_handle, $this->wp_webfonts->registered, 'Font family should not be registered' );
-		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
-		$this->assertSameSets( $registered_queue, $this->wp_webfonts->get_registered(), 'Registered queue should not have changed' );
+		$this->wp_fonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $font_family_handle, $this->wp_fonts->registered, 'Font family should not be registered' );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_fonts->registered, 'Variant should not be registered' );
+		$this->assertSameSets( $registered_queue, $this->wp_fonts->get_registered(), 'Registered queue should not have changed' );
 	}
 
 	/**
@@ -136,10 +136,10 @@ public function test_unit_should_only_remove_from_font_family_deps_when_variatio
 		$this->setup_remove_variation_from_registered( $variation_handle );
 
 		// Run the tests.
-		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
-		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
-		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
-		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+		$this->wp_fonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_fonts->registered, 'Variant should not be registered' );
+		$this->assertNotContains( $variation_handle, $this->wp_fonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
 	}
 
 	/**
@@ -157,10 +157,10 @@ public function test_should_only_remove_from_font_family_deps_when_variation_not
 		$this->setup_remove_variation_from_registered( $variation_handle );
 
 		// Run the tests.
-		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
-		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
-		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
-		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+		$this->wp_fonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_fonts->registered, 'Variant should not be registered' );
+		$this->assertNotContains( $variation_handle, $this->wp_fonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
 	}
 
 	/**
@@ -177,12 +177,12 @@ public function test_unit_should_remove_variation_from_registered_queue_though_f
 		$this->setup_unit_test();
 		$this->setup_remove_from_font_family_deps( $font_family_handle, $variation_handle );
 
-		$this->assertArrayNotHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should not be in its font family deps before removal' );
+		$this->assertArrayNotHasKey( $variation_handle, array_flip( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Variation should not be in its font family deps before removal' );
 
-		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->wp_fonts->remove_variation( $font_family_handle, $variation_handle );
 
-		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
-		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+		$this->assertNotContains( $variation_handle, $this->wp_fonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
 	}
 
 	/**
@@ -199,12 +199,12 @@ public function test_should_remove_variation_from_registered_queue_though_font_f
 		$this->setup_integration_test();
 		$this->setup_remove_from_font_family_deps( $font_family_handle, $variation_handle );
 
-		$this->assertArrayNotHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should not be in its font family deps before removal' );
+		$this->assertArrayNotHasKey( $variation_handle, array_flip( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Variation should not be in its font family deps before removal' );
 
-		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->wp_fonts->remove_variation( $font_family_handle, $variation_handle );
 
-		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
-		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+		$this->assertNotContains( $variation_handle, $this->wp_fonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
 	}
 
 	/**
@@ -220,13 +220,13 @@ public function test_unit_should_remove_variation_from_queue_and_font_family_dep
 		// Set up the test.
 		$this->setup_unit_test();
 
-		$this->assertArrayHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should be in its font family deps before removal' );
+		$this->assertArrayHasKey( $variation_handle, array_flip( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Variation should be in its font family deps before removal' );
 
-		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->wp_fonts->remove_variation( $font_family_handle, $variation_handle );
 
-		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be not be in registered queue' );
-		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
-		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_fonts->registered, 'Variation should be not be in registered queue' );
+		$this->assertNotContains( $variation_handle, $this->wp_fonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
 	}
 
 	/**
@@ -242,13 +242,13 @@ public function test_should_remove_variation_from_queue_and_font_family_deps( $f
 		// Set up the test.
 		$this->setup_integration_test();
 
-		$this->assertArrayHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should be in its font family deps before removal' );
+		$this->assertArrayHasKey( $variation_handle, array_flip( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Variation should be in its font family deps before removal' );
 
-		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->wp_fonts->remove_variation( $font_family_handle, $variation_handle );
 
-		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be not be in registered queue' );
-		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
-		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_fonts->registered, 'Variation should be not be in registered queue' );
+		$this->assertNotContains( $variation_handle, $this->wp_fonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_fonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
 	}
 
 	/**
@@ -258,21 +258,21 @@ public function test_should_remove_variation_from_queue_and_font_family_deps( $f
 	 * @param string $variation_handle   The variation handle to remove.
 	 */
 	private function setup_remove_from_font_family_deps( $font_family_handle, $variation_handle ) {
-		foreach ( $this->wp_webfonts->registered[ $font_family_handle ]->deps as $index => $vhandle ) {
+		foreach ( $this->wp_fonts->registered[ $font_family_handle ]->deps as $index => $vhandle ) {
 			if ( $variation_handle !== $vhandle ) {
 				continue;
 			}
-			unset( $this->wp_webfonts->registered[ $font_family_handle ]->deps[ $index ] );
+			unset( $this->wp_fonts->registered[ $font_family_handle ]->deps[ $index ] );
 			break;
 		}
 	}
 
 	/**
-	 * Removes the variation from the WP_Web_Fonts::$registered queue.
+	 * Removes the variation from the WP_Fonts::$registered queue.
 	 *
 	 * @param string $variation_handle The variation handle to remove.
 	 */
 	private function setup_remove_variation_from_registered( $variation_handle ) {
-		unset( $this->wp_webfonts->registered[ $variation_handle ] );
+		unset( $this->wp_fonts->registered[ $variation_handle ] );
 	}
 }
diff --git a/phpunit/fonts-api/wpPrintFonts-test.php b/phpunit/fonts-api/wpPrintFonts-test.php
index a263e1b781357b..932af8e990b31f 100644
--- a/phpunit/fonts-api/wpPrintFonts-test.php
+++ b/phpunit/fonts-api/wpPrintFonts-test.php
@@ -108,9 +108,9 @@ public function test_should_print_handles_when_not_enqueued( $setup, $expected_d
 	/**
 	 * Sets up the dependencies for integration test.
 	 *
-	 * @param array        $setup       Dependencies to set up.
-	 * @param WP_Web_Fonts $wp_fonts Instance of WP_Web_Fonts.
-	 * @param bool         $enqueue     Whether to enqueue. Default true.
+	 * @param array    $setup    Dependencies to set up.
+	 * @param WP_Fonts $wp_fonts Instance of WP_Fonts.
+	 * @param bool     $enqueue  Whether to enqueue. Default true.
 	 */
 	private function setup_integrated_deps( array $setup, $wp_fonts, $enqueue = true ) {
 		foreach ( $setup['provider'] as $provider ) {
diff --git a/phpunit/fonts-api/wpRegisterFonts-test.php b/phpunit/fonts-api/wpRegisterFonts-test.php
index f51ffa7caddfd6..47fa896fd79d72 100644
--- a/phpunit/fonts-api/wpRegisterFonts-test.php
+++ b/phpunit/fonts-api/wpRegisterFonts-test.php
@@ -11,8 +11,8 @@
 /**
  * @group  fontsapi
  * @covers ::wp_register_fonts
- * @covers WP_Web_Fonts::add
- * @covers WP_Web_Fonts::add_variation
+ * @covers WP_Fonts::add
+ * @covers WP_Fonts::add_variation
  */
 class Tests_Fonts_WpRegisterFonts extends WP_Fonts_TestCase {