diff --git a/.phpstorm.meta.php b/.phpstorm.meta.php
index aff292192bc..253a6382fd9 100644
--- a/.phpstorm.meta.php
+++ b/.phpstorm.meta.php
@@ -22,6 +22,7 @@
 			'admin.validation_counts'            => \AmpProject\AmpWP\Admin\ValidationCounts::class,
 			'amp_slug_customization_watcher'     => \AmpProject\AmpWP\AmpSlugCustomizationWatcher::class,
 			'background_task_deactivator'        => \AmpProject\AmpWP\BackgroundTask\BackgroundTaskDeactivator::class,
+			'block_uniqid_transformer'           => \AmpProject\AmpWP\BlockUniqidTransformer::class,
 			'cli.command_namespace'              => \AmpProject\AmpWP\CliCli\CommandNamespaceRegistration::class,
 			'cli.optimizer_command'              => \AmpProject\AmpWP\CliCli\OptimizerCommand::class,
 			'cli.transformer_command'            => \AmpProject\AmpWP\CliCli\TransformerCommand::class,
diff --git a/includes/options/class-amp-options-manager.php b/includes/options/class-amp-options-manager.php
index 857af7c4665..93ef7a5fca8 100644
--- a/includes/options/class-amp-options-manager.php
+++ b/includes/options/class-amp-options-manager.php
@@ -351,12 +351,6 @@ public static function validate_options( $new_options ) {
 			}
 		}
 
-		if ( array_key_exists( Option::DISABLE_CSS_TRANSIENT_CACHING, $new_options ) && true === $new_options[ Option::DISABLE_CSS_TRANSIENT_CACHING ] ) {
-			$options[ Option::DISABLE_CSS_TRANSIENT_CACHING ] = true;
-		} else {
-			unset( $options[ Option::DISABLE_CSS_TRANSIENT_CACHING ] );
-		}
-
 		/**
 		 * Filter the options being updated, so services can handle the sanitization and validation of
 		 * their respective options.
diff --git a/includes/sanitizers/class-amp-block-uniqid-sanitizer.php b/includes/sanitizers/class-amp-block-uniqid-sanitizer.php
new file mode 100644
index 00000000000..9ce4692fbff
--- /dev/null
+++ b/includes/sanitizers/class-amp-block-uniqid-sanitizer.php
@@ -0,0 +1,204 @@
+<?php
+/**
+ * Class AMP_Block_Uniqid_Sanitizer.
+ *
+ * @package AMP
+ */
+
+use AmpProject\Dom\Element;
+use AmpProject\Html\Attribute;
+use AmpProject\Html\Tag;
+use AmpProject\Dom\Document;
+
+/**
+ * Work around use of uniqid() in blocks which breaks parsed CSS caching.
+ *
+ * @link https://github.com/ampproject/amp-wp/issues/6925
+ * @link https://github.com/WordPress/gutenberg/issues/38889
+ *
+ * @since 2.2.2
+ * @internal
+ */
+class AMP_Block_Uniqid_Sanitizer extends AMP_Base_Sanitizer {
+
+	/**
+	 * Prefixes of class names that should be transformed.
+	 *
+	 * @var string[]
+	 */
+	const KEY_PREFIXES = [
+		'wp-container-',
+		'wp-duotone-',
+		'wp-duotone-filter-',
+		'wp-elements-',
+	];
+
+	/**
+	 * Class name pattern.
+	 *
+	 * @var string
+	 */
+	private $key_pattern;
+
+	/**
+	 * The mapping between uniqid- and wp_unique_id-based class names.
+	 *
+	 * @var array
+	 */
+	private $key_mapping = [];
+
+	/**
+	 * @param Document $dom  DOM.
+	 * @param array    $args Args.
+	 */
+	public function __construct( $dom, $args = [] ) {
+		parent::__construct( $dom, $args );
+
+		$this->key_pattern = sprintf(
+			'/\b(?P<prefix>%s)(?P<uniqid>[0-9a-f]{13})\b/',
+			implode(
+				'|',
+				self::KEY_PREFIXES
+			)
+		);
+	}
+
+	/**
+	 * Sanitize.
+	 */
+	public function sanitize() {
+		$elements = $this->dom->xpath->query(
+			sprintf(
+				'//*[ %s ]',
+				implode(
+					' or ',
+					array_map(
+						static function ( $class_name_prefix ) {
+							return sprintf(
+								'contains( @class, "%s" )',
+								$class_name_prefix
+							);
+						},
+						self::KEY_PREFIXES
+					)
+				)
+			)
+		);
+
+		$replaced_count = 0;
+		foreach ( $elements as $element ) {
+			if ( $this->transform_element_with_class_attribute( $element ) ) {
+				$replaced_count++;
+			}
+		}
+
+		if ( $replaced_count > 0 ) {
+			$this->transform_styles();
+		}
+	}
+
+	/**
+	 * Transform element with class.
+	 *
+	 * @param Element $element Element.
+	 */
+	public function transform_element_with_class_attribute( Element $element ) {
+		$class_name = $element->getAttribute( Attribute::CLASS_ );
+
+		$count = 0;
+
+		$new_class_name = preg_replace_callback(
+			$this->key_pattern,
+			function ( $matches ) {
+				$old_key = $matches[0];
+
+				if ( ! isset( $this->key_mapping[ $old_key ] ) ) {
+					$this->key_mapping[ $old_key ] = self::unique_id( $matches['prefix'] );
+				}
+				$new_key = $this->key_mapping[ $old_key ];
+
+				if ( in_array( $matches['prefix'], [ 'wp-duotone-', 'wp-duotone-filter-' ], true ) ) {
+					$this->transform_duotone_filter( $old_key, $new_key );
+				}
+
+				return $new_key;
+			},
+			$class_name,
+			-1,
+			$count
+		);
+		if ( 0 === $count ) {
+			return false;
+		} else {
+			$element->setAttribute( Attribute::CLASS_, $new_class_name );
+			return true;
+		}
+	}
+
+	/**
+	 * Transform duotone filter by updating its ID.
+	 *
+	 * @param string $old_key Old identifier.
+	 * @param string $new_key New identifier.
+	 *
+	 * @return void
+	 */
+	public function transform_duotone_filter( $old_key, $new_key ) {
+		$svg_filter = $this->dom->getElementById( $old_key );
+		if ( $svg_filter instanceof Element && Tag::FILTER === $svg_filter->tagName ) {
+			$svg_filter->setAttribute( Attribute::ID, $new_key );
+		}
+	}
+
+	/**
+	 * Transform styles.
+	 */
+	public function transform_styles() {
+		$styles = $this->dom->xpath->query(
+			sprintf(
+				'//style[ %s ]',
+				implode(
+					' or ',
+					array_map(
+						static function ( $key_prefix ) {
+							return sprintf(
+								'contains( text(), "%s" )',
+								$key_prefix
+							);
+						},
+						self::KEY_PREFIXES
+					)
+				)
+			)
+		);
+
+		foreach ( $styles as $style ) {
+			$style->textContent = str_replace(
+				array_keys( $this->key_mapping ),
+				array_values( $this->key_mapping ),
+				$style->textContent
+			);
+		}
+	}
+
+	/**
+	 * Gets unique ID.
+	 *
+	 * This is a polyfill for WordPress <5.0.3.
+	 *
+	 * @see wp_unique_id()
+	 *
+	 * @param string $prefix Prefix for the returned ID.
+	 * @return string Unique ID.
+	 */
+	private static function unique_id( $prefix = '' ) {
+		if ( function_exists( 'wp_unique_id' ) ) {
+			return wp_unique_id( $prefix );
+		} else {
+			// @codeCoverageIgnoreStart
+			static $id_counter = 0;
+			return $prefix . (string) ++$id_counter;
+			// @codeCoverageIgnoreEnd
+		}
+	}
+}
diff --git a/src/AmpWpPlugin.php b/src/AmpWpPlugin.php
index 89e98c66f28..ee3a0a736f3 100644
--- a/src/AmpWpPlugin.php
+++ b/src/AmpWpPlugin.php
@@ -86,6 +86,7 @@ final class AmpWpPlugin extends ServiceBasedPlugin {
 		'admin.amp_themes'                   => Admin\AmpThemes::class,
 		'amp_slug_customization_watcher'     => AmpSlugCustomizationWatcher::class,
 		'background_task_deactivator'        => BackgroundTaskDeactivator::class,
+		'block_uniqid_transformer'           => BlockUniqidTransformer::class,
 		'cli.command_namespace'              => Cli\CommandNamespaceRegistration::class,
 		'cli.optimizer_command'              => Cli\OptimizerCommand::class,
 		'cli.transformer_command'            => Cli\TransformerCommand::class,
diff --git a/src/BackgroundTask/MonitorCssTransientCaching.php b/src/BackgroundTask/MonitorCssTransientCaching.php
index a2965aefe84..643a7658fca 100644
--- a/src/BackgroundTask/MonitorCssTransientCaching.php
+++ b/src/BackgroundTask/MonitorCssTransientCaching.php
@@ -8,6 +8,7 @@
 namespace AmpProject\AmpWP\BackgroundTask;
 
 use AMP_Options_Manager;
+use AmpProject\AmpWP\BlockUniqidTransformer;
 use AmpProject\AmpWP\Option;
 use DateTimeImmutable;
 use DateTimeInterface;
@@ -54,6 +55,32 @@ final class MonitorCssTransientCaching extends RecurringBackgroundTask {
 	 */
 	const DEFAULT_SAMPLING_RANGE = 14;
 
+	/**
+	 * @string
+	 */
+	const WP_VERSION = 'wp_version';
+
+	/**
+	 * @string
+	 */
+	const GUTENBERG_VERSION = 'gutenberg_version';
+
+	/**
+	 * @var BlockUniqidTransformer
+	 */
+	private $block_uniqid_transformer;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param BackgroundTaskDeactivator $background_task_deactivator Deactivator.
+	 * @param BlockUniqidTransformer    $block_uniqid_transformer    Transformer.
+	 */
+	public function __construct( BackgroundTaskDeactivator $background_task_deactivator, BlockUniqidTransformer $block_uniqid_transformer ) {
+		parent::__construct( $background_task_deactivator );
+		$this->block_uniqid_transformer = $block_uniqid_transformer;
+	}
+
 	/**
 	 * Register the service with the system.
 	 *
@@ -61,6 +88,7 @@ final class MonitorCssTransientCaching extends RecurringBackgroundTask {
 	 */
 	public function register() {
 		add_action( 'amp_plugin_update', [ $this, 'handle_plugin_update' ] );
+		add_filter( 'amp_options_updating', [ $this, 'sanitize_disabled_option' ], 10, 2 );
 		parent::register();
 	}
 
@@ -133,15 +161,60 @@ public function process( ...$args ) {
 	 *
 	 * @return bool Whether transient caching of stylesheets is disabled.
 	 */
-	private function is_css_transient_caching_disabled() {
-		return AMP_Options_Manager::get_option( Option::DISABLE_CSS_TRANSIENT_CACHING, false );
+	public function is_css_transient_caching_disabled() {
+		return (bool) AMP_Options_Manager::get_option( Option::DISABLE_CSS_TRANSIENT_CACHING, false );
+	}
+
+	/**
+	 * Enable transient caching of stylesheets.
+	 */
+	public function enable_css_transient_caching() {
+		AMP_Options_Manager::update_option( Option::DISABLE_CSS_TRANSIENT_CACHING, false );
 	}
 
 	/**
 	 * Disable transient caching of stylesheets.
 	 */
-	private function disable_css_transient_caching() {
-		AMP_Options_Manager::update_option( Option::DISABLE_CSS_TRANSIENT_CACHING, true );
+	public function disable_css_transient_caching() {
+		AMP_Options_Manager::update_option(
+			Option::DISABLE_CSS_TRANSIENT_CACHING,
+			[
+				self::WP_VERSION        => get_bloginfo( 'version' ),
+				self::GUTENBERG_VERSION => defined( 'GUTENBERG_VERSION' ) ? GUTENBERG_VERSION : null,
+			]
+		);
+	}
+
+	/**
+	 * Sanitize the option.
+	 *
+	 * @param array $options     Existing options.
+	 * @param array $new_options New options.
+	 * @return array Sanitized options.
+	 */
+	public function sanitize_disabled_option( $options, $new_options ) {
+		$value = null;
+
+		if ( array_key_exists( Option::DISABLE_CSS_TRANSIENT_CACHING, $new_options ) ) {
+			$unsanitized_value = $new_options[ Option::DISABLE_CSS_TRANSIENT_CACHING ];
+
+			if ( is_bool( $unsanitized_value ) ) {
+				$value = (bool) $unsanitized_value;
+			} elseif ( is_array( $unsanitized_value ) ) {
+				$value = [];
+				foreach ( wp_array_slice_assoc( $unsanitized_value, [ self::WP_VERSION, self::GUTENBERG_VERSION ] ) as $key => $version ) {
+					$value[ $key ] = preg_replace( '/[^a-z0-9_\-.]/', '', $version );
+				}
+			}
+		}
+
+		if ( empty( $value ) ) {
+			unset( $options[ Option::DISABLE_CSS_TRANSIENT_CACHING ] );
+		} else {
+			$options[ Option::DISABLE_CSS_TRANSIENT_CACHING ] = $value;
+		}
+
+		return $options;
 	}
 
 	/**
@@ -164,9 +237,39 @@ public function query_css_transient_count() {
 	 * @param string $old_version Old version.
 	 */
 	public function handle_plugin_update( $old_version ) {
-		// Reset the disabling of the CSS caching subsystem when updating from versions 1.5.0 or 1.5.1.
-		if ( version_compare( $old_version, '1.5.0', '>=' ) && version_compare( $old_version, '1.5.2', '<' ) ) {
-			AMP_Options_Manager::update_option( Option::DISABLE_CSS_TRANSIENT_CACHING, false );
+		// Note: We cannot use the is_css_transient_caching_disabled method because we need to get the underlying stored value.
+		$disabled = AMP_Options_Manager::get_option( Option::DISABLE_CSS_TRANSIENT_CACHING, false );
+		if ( empty( $disabled ) ) {
+			return;
+		}
+
+		// Obtain the version of WordPress and Gutenberg at which time the functionality was disabled, if available.
+		$wp_version        = isset( $disabled[ self::WP_VERSION ] ) ? $disabled[ self::WP_VERSION ] : null;
+		$gutenberg_version = isset( $disabled[ self::GUTENBERG_VERSION ] ) ? $disabled[ self::GUTENBERG_VERSION ] : null;
+
+		if (
+			// Reset the disabling of the CSS caching subsystem when updating from versions 1.5.0 or 1.5.1.
+			(
+				version_compare( $old_version, '1.5.0', '>=' )
+				&&
+				version_compare( $old_version, '1.5.2', '<' )
+			)
+			||
+			// Reset when it was disabled prior to the versions of WP/Gutenberg being captured,
+			// or if the captured versions were affected at the time of disabling.
+			(
+				version_compare( strtok( $old_version, '-' ), '2.2.2', '<' )
+				&&
+				(
+					! is_array( $disabled )
+					||
+					$this->block_uniqid_transformer->is_affected_gutenberg_version( $gutenberg_version )
+					||
+					$this->block_uniqid_transformer->is_affected_wordpress_version( $wp_version )
+				)
+			)
+		) {
+			$this->enable_css_transient_caching();
 		}
 	}
 
diff --git a/src/BlockUniqidTransformer.php b/src/BlockUniqidTransformer.php
new file mode 100644
index 00000000000..c547eed696a
--- /dev/null
+++ b/src/BlockUniqidTransformer.php
@@ -0,0 +1,132 @@
+<?php
+/**
+ * Class BlockUniqidTransformer.
+ *
+ * @package AmpProject\AmpWP
+ */
+
+namespace AmpProject\AmpWP;
+
+use AMP_Block_Uniqid_Sanitizer;
+use AmpProject\AmpWP\Infrastructure\Registerable;
+use AmpProject\AmpWP\Infrastructure\Service;
+
+/**
+ * Transform uniqid-based IDs into cacheable IDs based on wp_unique_id.
+ *
+ * Random strings based on `uniqid()` should not be used to generate CSS class
+ * names and used in inline styles so that parsed CSS transient caching is not
+ * automatically disabled.
+ *
+ * Instead, `wp_unique_id()` should be used so that the IDs in the class names
+ * are more predictable and the CSS transient caching works as expected.
+ *
+ * @link https://github.com/ampproject/amp-wp/pull/6925
+ * @link https://github.com/WordPress/gutenberg/issues/38889
+ *
+ * @package AmpProject\AmpWP
+ * @since 2.2.2
+ * @internal
+ */
+final class BlockUniqidTransformer implements Service, Registerable {
+
+	/**
+	 * Gutenberg version.
+	 *
+	 * @var string
+	 */
+	private $gutenberg_version = null;
+
+	/**
+	 * Construct.
+	 */
+	public function __construct() {
+		if ( defined( 'GUTENBERG_VERSION' ) ) {
+			$this->gutenberg_version = GUTENBERG_VERSION;
+		}
+	}
+
+	/**
+	 * Check whether the Gutenberg plugin is present and if its one of the affected versions.
+	 *
+	 * Elements was added in 10.7 via WordPress/gutenberg#31524
+	 * Layout was added in 11.2 via WordPress/gutenberg#33359
+	 * Duotone was added in 11.7 via WordPress/gutenberg#34667
+	 * `uniqid` has been replaced by `wp_unique_id` in 12.7 via WordPress/gutenberg#38891
+	 *
+	 * @param string|null $version Gutenberg version to check. If null, current version is used.
+	 * @return bool Whether affected Gutenberg version.
+	 */
+	public function is_affected_gutenberg_version( $version = null ) {
+		if ( empty( $version ) ) {
+			$version = $this->gutenberg_version;
+		}
+
+		if ( empty( $version ) ) {
+			return false;
+		}
+
+		return (
+			version_compare( $version, '10.7', '>=' )
+			&&
+			version_compare( $version, '12.7', '<' )
+		);
+	}
+
+	/**
+	 * Check whether WordPress version is affected by the `uniqid` issue.
+	 *
+	 * The affected WordPress version is 5.9. However, the duotone filter was first
+	 * introduced in WordPress 5.8 and it makes use of the `uniqid`, too.
+	 *
+	 * @todo Once the `uniqid` to `wp_unique_id` fix is backported to core, upper version boundary should be updated (it's set to 6.0 for now).
+	 *
+	 * @param string|null $version WordPress core version to check. If null, current version is used.
+	 * @return bool Whether affected WP version.
+	 */
+	public function is_affected_wordpress_version( $version = null ) {
+		if ( empty( $version ) ) {
+			$version = get_bloginfo( 'version' );
+		}
+		return (
+			version_compare( $version, '5.8', '>=' )
+			&&
+			version_compare( $version, '6.0', '<' )
+		);
+	}
+
+	/**
+	 * Check whether the transformer is necessary.
+	 *
+	 * @return bool Whether the conditional object is needed.
+	 */
+	public function is_necessary() {
+		return (
+			$this->is_affected_gutenberg_version()
+			||
+			$this->is_affected_wordpress_version()
+		);
+	}
+
+	/**
+	 * Register the service with the system.
+	 *
+	 * @return void
+	 */
+	public function register() {
+		if ( ! $this->is_necessary() ) {
+			return;
+		}
+
+		add_filter(
+			'amp_content_sanitizers',
+			static function ( $sanitizers ) {
+				$sanitizers = array_merge(
+					[ AMP_Block_Uniqid_Sanitizer::class => [] ],
+					$sanitizers
+				);
+				return $sanitizers;
+			}
+		);
+	}
+}
diff --git a/tests/php/src/BackgroundTask/MonitorCssTransientCachingTest.php b/tests/php/src/BackgroundTask/MonitorCssTransientCachingTest.php
index 98e3928447f..64531a49ab2 100644
--- a/tests/php/src/BackgroundTask/MonitorCssTransientCachingTest.php
+++ b/tests/php/src/BackgroundTask/MonitorCssTransientCachingTest.php
@@ -6,14 +6,18 @@
 namespace AmpProject\AmpWP\Tests\BackgroundTask;
 
 use AMP_Options_Manager;
-use AmpProject\AmpWP\BackgroundTask\BackgroundTaskDeactivator;
+use AMP_Style_Sanitizer;
 use AmpProject\AmpWP\BackgroundTask\MonitorCssTransientCaching;
 use AmpProject\AmpWP\Option;
-use AmpProject\AmpWP\Tests\TestCase;
+use AmpProject\AmpWP\Tests\DependencyInjectedTestCase;
+use AmpProject\AmpWP\Tests\Helpers\PrivateAccess;
+use AmpProject\Dom\Document;
 use DateTime;
 
 /** @coversDefaultClass \AmpProject\AmpWP\BackgroundTask\MonitorCssTransientCaching */
-class MonitorCssTransientCachingTest extends TestCase {
+class MonitorCssTransientCachingTest extends DependencyInjectedTestCase {
+
+	use PrivateAccess;
 
 	/**
 	 * Whether external object cache is being used.
@@ -22,6 +26,9 @@ class MonitorCssTransientCachingTest extends TestCase {
 	 */
 	private $was_wp_using_ext_object_cache;
 
+	/** @var string */
+	private $original_wp_version;
+
 	/**
 	 * Set up the tests by clearing the list of scheduled events.
 	 */
@@ -30,6 +37,7 @@ public function setUp() {
 		_set_cron_array( [] );
 		$this->was_wp_using_ext_object_cache = wp_using_ext_object_cache();
 		wp_using_ext_object_cache( false );
+		$this->original_wp_version = $GLOBALS['wp_version'];
 	}
 
 	/**
@@ -39,6 +47,33 @@ public function tearDown() {
 		parent::tearDown();
 		_set_cron_array( [] );
 		wp_using_ext_object_cache( $this->was_wp_using_ext_object_cache );
+		$GLOBALS['wp_version'] = $this->original_wp_version;
+	}
+
+	/**
+	 * @covers ::register()
+	 */
+	public function test_register() {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+		$monitor->register();
+		$this->assertEquals( 10, has_action( 'amp_plugin_update', [ $monitor, 'handle_plugin_update' ] ) );
+		$this->assertEquals( 10, has_filter( 'amp_options_updating', [ $monitor, 'sanitize_disabled_option' ] ) );
+	}
+
+	/**
+	 * @covers ::get_interval()
+	 */
+	public function test_get_interval() {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+		$this->assertIsString( $this->call_private_method( $monitor, 'get_interval' ) );
+	}
+
+	/**
+	 * @covers ::get_event_name()
+	 */
+	public function test_get_event_name() {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+		$this->assertIsString( $this->call_private_method( $monitor, 'get_event_name' ) );
 	}
 
 	/**
@@ -51,7 +86,7 @@ public function test_event_gets_scheduled_and_unscheduled() {
 		wp_set_current_user( self::factory()->user->create( [ 'role' => 'administrator' ] ) );
 		$this->assertFalse( wp_next_scheduled( MonitorCssTransientCaching::EVENT_NAME ) );
 
-		$monitor = new MonitorCssTransientCaching( new BackgroundTaskDeactivator() );
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
 		$monitor->schedule_event();
 
 		$timestamp = wp_next_scheduled( MonitorCssTransientCaching::EVENT_NAME );
@@ -66,10 +101,10 @@ public function test_event_gets_scheduled_and_unscheduled() {
 	 *
 	 * @covers ::process()
 	 */
-	public function test_event_can_be_processed() {
+	public function test_process_causes_time_series_to_be_stored() {
 		delete_option( MonitorCssTransientCaching::TIME_SERIES_OPTION_KEY );
 
-		$monitor = new MonitorCssTransientCaching( new BackgroundTaskDeactivator() );
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
 		$monitor->process();
 
 		$this->assertNotFalse( get_option( MonitorCssTransientCaching::TIME_SERIES_OPTION_KEY ) );
@@ -79,8 +114,14 @@ public function test_event_can_be_processed() {
 	 * Test whether transient caching is disabled once it hits the threshold.
 	 *
 	 * @covers ::process()
+	 * @covers ::get_time_series()
+	 * @covers ::get_sampling_range()
+	 * @covers ::persist_time_series()
+	 * @covers ::calculate_average()
+	 * @covers ::get_threshold()
+	 * @covers ::disable_css_transient_caching()
 	 */
-	public function test_transient_caching_is_disabled() {
+	public function test_process_disables_transient_caching_once_threshold_is_reached() {
 		delete_option( MonitorCssTransientCaching::TIME_SERIES_OPTION_KEY );
 		AMP_Options_Manager::update_option( Option::DISABLE_CSS_TRANSIENT_CACHING, false );
 
@@ -97,7 +138,7 @@ static function () {
 			}
 		);
 
-		$monitor = new MonitorCssTransientCaching( new BackgroundTaskDeactivator() );
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
 
 		// Moving average should be 0.
 		$monitor->process( new DateTime( '2000-01-01' ), 5 );
@@ -137,6 +178,266 @@ static function () {
 			],
 			get_option( MonitorCssTransientCaching::TIME_SERIES_OPTION_KEY )
 		);
-		$this->assertTrue( AMP_Options_Manager::get_option( Option::DISABLE_CSS_TRANSIENT_CACHING ) );
+
+		$expected = [
+			MonitorCssTransientCaching::WP_VERSION        => get_bloginfo( 'version' ),
+			MonitorCssTransientCaching::GUTENBERG_VERSION => defined( 'GUTENBERG_VERSION' ) ? GUTENBERG_VERSION : null,
+		];
+
+		$this->assertTrue( (bool) AMP_Options_Manager::get_option( Option::DISABLE_CSS_TRANSIENT_CACHING ) );
+		$this->assertEquals( $expected, AMP_Options_Manager::get_option( Option::DISABLE_CSS_TRANSIENT_CACHING ) );
+	}
+
+	/**
+	 * @covers ::enable_css_transient_caching()
+	 * @covers ::disable_css_transient_caching()
+	 * @covers ::is_css_transient_caching_disabled()
+	 */
+	public function test_enable_disable_is_css_transient_caching_disabled() {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+		$this->assertFalse( $monitor->is_css_transient_caching_disabled() );
+		$monitor->disable_css_transient_caching();
+		$this->assertTrue( $monitor->is_css_transient_caching_disabled() );
+		$monitor->enable_css_transient_caching();
+		$this->assertFalse( $monitor->is_css_transient_caching_disabled() );
+	}
+
+	/** @return array */
+	public function get_data_to_test_sanitize_disabled_option() {
+		return [
+			'true'               => [
+				true,
+				true,
+			],
+			'false'              => [
+				false,
+				null,
+			],
+			'number'             => [
+				123,
+				null,
+			],
+			'bad_array'          => [
+				[ 1, 2, 3 ],
+				null,
+			],
+			'partial_good_array' => [
+				[
+					MonitorCssTransientCaching::WP_VERSION => '123-\o/',
+					MonitorCssTransientCaching::GUTENBERG_VERSION => '45.21<script>//!@#$%^&*()`~',
+					'foo'                                  => 'bar',
+				],
+				[
+					MonitorCssTransientCaching::WP_VERSION => '123-o',
+					MonitorCssTransientCaching::GUTENBERG_VERSION => '45.21script',
+				],
+			],
+			'partial_all_good'   => [
+				[
+					MonitorCssTransientCaching::WP_VERSION => '1.2.3',
+				],
+				[
+					MonitorCssTransientCaching::WP_VERSION => '1.2.3',
+				],
+			],
+			'fully_all_good'     => [
+				[
+					MonitorCssTransientCaching::WP_VERSION => '1.2.3',
+					MonitorCssTransientCaching::GUTENBERG_VERSION => '4.5.6',
+				],
+				[
+					MonitorCssTransientCaching::WP_VERSION => '1.2.3',
+					MonitorCssTransientCaching::GUTENBERG_VERSION => '4.5.6',
+				],
+			],
+		];
+	}
+
+	/**
+	 * @covers ::sanitize_disabled_option()
+	 * @dataProvider get_data_to_test_sanitize_disabled_option
+	 * @param mixed $input
+	 * @param mixed $expected
+	 */
+	public function test_sanitize_disabled_option( $input, $expected ) {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+		$options = $monitor->sanitize_disabled_option(
+			[],
+			[
+				Option::DISABLE_CSS_TRANSIENT_CACHING => $input,
+			]
+		);
+
+		if ( array_key_exists( Option::DISABLE_CSS_TRANSIENT_CACHING, $options ) ) {
+			$actual = $options[ Option::DISABLE_CSS_TRANSIENT_CACHING ];
+		} else {
+			$actual = null;
+		}
+
+		$this->assertEquals( $expected, $actual );
+	}
+
+	/**
+	 * @covers ::query_css_transient_count()
+	 */
+	public function test_query_css_transient_count() {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+
+		$this->assertEquals( 0, $monitor->query_css_transient_count() );
+
+		$dom = new Document();
+		$dom->loadHTML(
+			'
+				<html>
+					<head><style>body { background:red }</style></head>
+					<body style="color:blue"></body>
+				</html>
+			'
+		);
+		$style_sanitizer = new AMP_Style_Sanitizer(
+			$dom,
+			[ 'use_document_element' => true ]
+		);
+		$style_sanitizer->sanitize();
+
+		$this->assertEquals( 2, $monitor->query_css_transient_count() );
+
+		$dom = new Document();
+		$dom->loadHTML(
+			'
+				<html>
+					<head><style>body { background:red }</style></head>
+					<body style="color:white"></body>
+				</html>
+			'
+		);
+		$style_sanitizer = new AMP_Style_Sanitizer(
+			$dom,
+			[ 'use_document_element' => true ]
+		);
+		$style_sanitizer->sanitize();
+
+		$this->assertEquals( 3, $monitor->query_css_transient_count() );
+	}
+
+	/** @return array */
+	public function get_data_to_test_handle_plugin_update() {
+		return [
+			'not_disabled'                                => [
+				function ( MonitorCssTransientCaching $monitor ) {
+					$monitor->enable_css_transient_caching();
+					$this->assertFalse( $monitor->is_css_transient_caching_disabled() );
+					$monitor->handle_plugin_update( '2.2.1' );
+				},
+				false,
+			],
+			'old_reset_condition_in_range'                => [
+				function ( MonitorCssTransientCaching $monitor ) {
+					AMP_Options_Manager::update_option( Option::DISABLE_CSS_TRANSIENT_CACHING, true );
+					$this->assertTrue( $monitor->is_css_transient_caching_disabled() );
+					$monitor->handle_plugin_update( '1.5.1' );
+				},
+				false,
+			],
+			'old_reset_condition_outside_range'           => [
+				function ( MonitorCssTransientCaching $monitor ) {
+					AMP_Options_Manager::update_option(
+						Option::DISABLE_CSS_TRANSIENT_CACHING,
+						[
+							MonitorCssTransientCaching::WP_VERSION => '999.9',
+							MonitorCssTransientCaching::GUTENBERG_VERSION => '999.9',
+						]
+					);
+					$this->assertTrue( $monitor->is_css_transient_caching_disabled() );
+					$monitor->handle_plugin_update( '1.5.2' ); // Should no-op.
+				},
+				true,
+			],
+			'uniqid_before_storing_meta'                  => [
+				function ( MonitorCssTransientCaching $monitor ) {
+					AMP_Options_Manager::update_option( Option::DISABLE_CSS_TRANSIENT_CACHING, true );
+					$this->assertTrue( $monitor->is_css_transient_caching_disabled() );
+					$monitor->handle_plugin_update( '2.2.1' );
+				},
+				false,
+			],
+			'uniqid_after_storing_meta'                   => [
+				function ( MonitorCssTransientCaching $monitor ) {
+					AMP_Options_Manager::update_option(
+						Option::DISABLE_CSS_TRANSIENT_CACHING,
+						[
+							MonitorCssTransientCaching::WP_VERSION => '999.0',
+							MonitorCssTransientCaching::GUTENBERG_VERSION => '999.9',
+						]
+					);
+					$this->assertTrue( $monitor->is_css_transient_caching_disabled() );
+					$monitor->handle_plugin_update( '2.2.2' ); // Should no-op.
+				},
+				true,
+			],
+			'uniqid_after_storing_meta_and_future_update' => [
+				function ( MonitorCssTransientCaching $monitor ) {
+					AMP_Options_Manager::update_option(
+						Option::DISABLE_CSS_TRANSIENT_CACHING,
+						[
+							MonitorCssTransientCaching::WP_VERSION => '5.9.0',
+							MonitorCssTransientCaching::GUTENBERG_VERSION => null,
+						]
+					);
+					$this->assertTrue( $monitor->is_css_transient_caching_disabled() );
+					$monitor->handle_plugin_update( '2.3.0' );
+				},
+				true,
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider get_data_to_test_handle_plugin_update
+	 * @covers ::handle_plugin_update()
+	 *
+	 * @param callable $set_up
+	 * @param bool     $expected_disabled
+	 */
+	public function test_handle_plugin_update( $set_up, $expected_disabled ) {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+		$set_up( $monitor );
+		$this->assertSame( $expected_disabled, $monitor->is_css_transient_caching_disabled() );
+	}
+
+	/**
+	 * @covers ::get_default_threshold()
+	 */
+	public function test_get_default_threshold() {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+		$this->assertIsFloat( $monitor->get_default_threshold() );
+	}
+
+	/**
+	 * @covers ::get_default_sampling_range()
+	 */
+	public function test_get_default_sampling_range() {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+		$this->assertIsInt( $monitor->get_default_sampling_range() );
+	}
+
+	/**
+	 * @covers ::get_time_series()
+	 * @covers ::persist_time_series()
+	 */
+	public function test_get_and_persist_time_series() {
+		$monitor = $this->injector->make( MonitorCssTransientCaching::class );
+
+		$this->assertEquals( [], $this->call_private_method( $monitor, 'get_time_series' ) );
+
+		$time_series = [
+			'20220101' => 10,
+			'20220102' => 20,
+			'20220103' => 30,
+		];
+
+		$this->call_private_method( $monitor, 'persist_time_series', [ $time_series ] );
+
+		$this->assertEquals( $time_series, $this->call_private_method( $monitor, 'get_time_series' ) );
 	}
 }
diff --git a/tests/php/src/BlockUniqidTransformerTest.php b/tests/php/src/BlockUniqidTransformerTest.php
new file mode 100644
index 00000000000..542ebfb533f
--- /dev/null
+++ b/tests/php/src/BlockUniqidTransformerTest.php
@@ -0,0 +1,170 @@
+<?php
+
+namespace AmpProject\AmpWP\Tests;
+
+use AMP_Block_Uniqid_Sanitizer;
+use AmpProject\AmpWP\BlockUniqidTransformer;
+use AmpProject\AmpWP\Infrastructure\Registerable;
+use AmpProject\AmpWP\Infrastructure\Service;
+use AmpProject\AmpWP\Tests\Helpers\MarkupComparison;
+use AmpProject\AmpWP\Tests\Helpers\PrivateAccess;
+
+/** @coversDefaultClass \AmpProject\AmpWP\BlockUniqidTransformer */
+final class BlockUniqidTransformerTest extends DependencyInjectedTestCase {
+
+	use MarkupComparison;
+	use PrivateAccess;
+
+	/** @var string */
+	private $original_wp_version;
+
+	/**
+	 * Set up.
+	 */
+	public function setUp() {
+		parent::setUp();
+		$this->original_wp_version = $GLOBALS['wp_version'];
+	}
+
+	/**
+	 * Tear down.
+	 */
+	public function tearDown() {
+		$GLOBALS['wp_version'] = $this->original_wp_version;
+		parent::tearDown();
+	}
+
+	public function test_it_can_be_initialized() {
+		$instance = $this->injector->make( BlockUniqidTransformer::class );
+		$this->assertSame(
+			defined( 'GUTENBERG_VERSION' ) ? GUTENBERG_VERSION : null,
+			$this->get_private_property( $instance, 'gutenberg_version' )
+		);
+		$this->assertInstanceOf( Registerable::class, $instance );
+		$this->assertInstanceOf( Service::class, $instance );
+	}
+
+	/**
+	 * @covers ::is_necessary()
+	 * @covers ::is_affected_gutenberg_version()
+	 * @covers ::is_affected_wordpress_version()
+	 */
+	public function test_is_necessary() {
+		$instance = $this->injector->make( BlockUniqidTransformer::class );
+
+		$gutenberg_data = $this->get_data_to_test_is_affected_gutenberg_version();
+		$wp_data        = $this->get_data_to_test_is_affected_wordpress_version();
+
+		foreach ( $wp_data as list( $wp_version, $wp_expected ) ) {
+			$GLOBALS['wp_version'] = $wp_version;
+			foreach ( $gutenberg_data as list( $gb_version, $gb_expected ) ) {
+				$this->set_private_property( $instance, 'gutenberg_version', $gb_version );
+
+				$this->assertSame(
+					$wp_expected || $gb_expected,
+					$instance->is_necessary(),
+					"Unexpected for WP $wp_version and Gutenberg $gb_version"
+				);
+			}
+		}
+	}
+
+	/** @return array */
+	public function get_data_to_test_is_affected_gutenberg_version() {
+		return [
+			'none' => [ null, false ],
+			'10.6' => [ '10.6', false ],
+			'10.7' => [ '10.7', true ],
+			'11.0' => [ '11.0', true ],
+			'12.0' => [ '12.0', true ],
+			'12.6' => [ '12.6', true ],
+			'12.7' => [ '12.7', false ],
+			'13.0' => [ '13.0', false ],
+		];
+	}
+
+	/**
+	 * @covers ::is_affected_gutenberg_version()
+	 * @dataProvider get_data_to_test_is_affected_gutenberg_version
+	 * @param string $gutenberg_version Gutenberg version.
+	 * @param bool   $is_affected       Is affected.
+	 */
+	public function test_is_affected_gutenberg_version( $gutenberg_version, $is_affected ) {
+		$instance = $this->injector->make( BlockUniqidTransformer::class );
+
+		// If Gutenberg is active for the tests, ignore the GUTENBERG_VERSION constant.
+		$this->set_private_property( $instance, 'gutenberg_version', null );
+
+		$this->assertSame( $is_affected, $instance->is_affected_gutenberg_version( $gutenberg_version ) );
+	}
+
+	/** @return array */
+	public function get_data_to_test_is_affected_wordpress_version() {
+		return [
+			'5.7.0' => [ '5.7.0', false ],
+			'5.8.0' => [ '5.8.0', true ],
+			'5.9.0' => [ '5.9.0', true ],
+			'5.9.1' => [ '5.9.1', true ],
+			'5.9.2' => [ '5.9.2', true ],
+			'6.0.0' => [ '6.0.0', false ],
+		];
+	}
+
+	/**
+	 * @covers ::is_affected_wordpress_version()
+	 * @dataProvider get_data_to_test_is_affected_wordpress_version
+	 * @param string $wp_version  WP version.
+	 * @param bool   $is_affected Is affected.
+	 */
+	public function test_is_affected_wordpress_version( $wp_version, $is_affected ) {
+		$instance = $this->injector->make( BlockUniqidTransformer::class );
+		$this->assertSame( $is_affected, $instance->is_affected_wordpress_version( $wp_version ) );
+	}
+
+	/** @return array */
+	public function get_data_to_test_register() {
+		return [
+			'necessary'   => [
+				'5.9.0',
+				true,
+			],
+			'unnecessary' => [
+				'6.0.0',
+				false,
+			],
+		];
+	}
+
+	/**
+	 * @covers ::register()
+	 * @dataProvider get_data_to_test_register
+	 * @param string $wp_version WP version.
+	 * @param bool   $expected   Expected.
+	 */
+	public function test_register( $wp_version, $expected ) {
+		remove_all_filters( 'amp_content_sanitizers' );
+
+		$this->assertArrayNotHasKey(
+			AMP_Block_Uniqid_Sanitizer::class,
+			amp_get_content_sanitizers()
+		);
+
+		$instance = $this->injector->make( BlockUniqidTransformer::class );
+		$this->set_private_property( $instance, 'gutenberg_version', null );
+		$GLOBALS['wp_version'] = $wp_version;
+
+		$instance->register();
+		$this->assertSame( $expected, $instance->is_necessary() );
+		if ( $expected ) {
+			$this->assertArrayHasKey(
+				AMP_Block_Uniqid_Sanitizer::class,
+				amp_get_content_sanitizers()
+			);
+		} else {
+			$this->assertArrayNotHasKey(
+				AMP_Block_Uniqid_Sanitizer::class,
+				amp_get_content_sanitizers()
+			);
+		}
+	}
+}
diff --git a/tests/php/test-amp-block-uniqid-sanitizer.php b/tests/php/test-amp-block-uniqid-sanitizer.php
new file mode 100644
index 00000000000..c54e5a2ebc3
--- /dev/null
+++ b/tests/php/test-amp-block-uniqid-sanitizer.php
@@ -0,0 +1,101 @@
+<?php
+/**
+ * Class AMP_Block_Uniqid_Sanitizer_Test
+ *
+ * @package AMP
+ */
+
+use AmpProject\AmpWP\Tests\Helpers\MarkupComparison;
+use AmpProject\AmpWP\Tests\TestCase;
+
+/**
+ * Test AMP_Block_Uniqid_Sanitizer
+ *
+ * @coversDefaultClass AMP_Block_Uniqid_Sanitizer
+ */
+class AMP_Block_Uniqid_Sanitizer_Test extends TestCase {
+
+	use MarkupComparison;
+
+	/** @return array */
+	public function get_block_data() {
+		return [
+			'transform_duotone_class_name'           => [
+				'content'  =>
+					'
+					<div class="wp-duotone-621e12fb51e3a wp-block-cover">This is a super cool class name: <code>wp-duotone-0123456789abc</code>!</div>
+					<style>.wp-duotone-621e12fb51e3a > .wp-block-cover__image-background, .wp-duotone-621e12fb51e3a > .wp-block-cover__video-background{filter:url(\'#wp-duotone-621e12fb51e3a\') !important;}</style>
+					<svg xmlns="http://www.w3.org/2000/svg"><defs><filter id="wp-duotone-621e12fb51e3a"></filter></defs></svg>
+					',
+				'expected' =>
+					'
+					<div class="wp-duotone-1 wp-block-cover">This is a super cool class name: <code>wp-duotone-0123456789abc</code>!</div>
+					<style>.wp-duotone-1 > .wp-block-cover__image-background, .wp-duotone-1 > .wp-block-cover__video-background{filter:url(\'#wp-duotone-1\') !important;}</style>
+					<svg xmlns="http://www.w3.org/2000/svg"><defs><filter id="wp-duotone-1"></filter></defs></svg>
+					',
+			],
+			'transform_legacy_duotone_class_name'    => [
+				'content'  =>
+					'
+					<figure class="wp-duotone-filter-622b62d997e58 wp-block-image size-large">This is a super cool class name: <code>wp-duotone-filter-622b62d997e58</code>!</figure>
+					<style>.wp-duotone-filter-622b62d997e58 img { filter: url( #wp-duotone-filter-622b62d997e58 ); }</style>
+					<svg xmlns="http://www.w3.org/2000/svg"><defs><filter id="wp-duotone-filter-622b62d997e58"></filter></defs></svg>
+					',
+				'expected' =>
+					'
+					<figure class="wp-duotone-filter-1 wp-block-image size-large">This is a super cool class name: <code>wp-duotone-filter-622b62d997e58</code>!</figure>
+					<style>.wp-duotone-filter-1 img { filter: url( #wp-duotone-filter-1 ); }</style>
+					<svg xmlns="http://www.w3.org/2000/svg"><defs><filter id="wp-duotone-filter-1"></filter></defs></svg>
+				',
+			],
+			'transform_container_class_name'         => [
+				'content'  => '<div class="wp-container-621e133aaf0e2 wp-block-group is-style-default has-black-background-color has-background" style="padding-top:20px;padding-right:20px;padding-bottom:20px;padding-left:20px">This is a super cool class name: <code>wp-container-0123456789abc</code>!</div>',
+				'expected' => '<div class="wp-container-1 wp-block-group is-style-default has-black-background-color has-background" style="padding-top:20px;padding-right:20px;padding-bottom:20px;padding-left:20px">This is a super cool class name: <code>wp-container-0123456789abc</code>!</div>',
+			],
+			'transform_elements_class_name'          => [
+				'content'  =>
+					'
+					<p class="wp-elements-622941a2ca7ee has-text-align-right has-link-color">This is a super cool class name: <code>wp-elements-622941a2ca7ee</code>!</p>
+					<style>.wp-elements-622941a2ca7ee a{color: var(--wp--preset--color--primary);}</style>
+					',
+				'expected' =>
+					'
+					<p class="wp-elements-1 has-text-align-right has-link-color">This is a super cool class name: <code>wp-elements-622941a2ca7ee</code>!</p>
+					<style>.wp-elements-1 a{color: var(--wp--preset--color--primary);}</style>
+					',
+			],
+			'ignore_class_names_without_hash'        => [
+				'content'  => '<div class="wp-duotone-test wp-block-cover">This is a super cool class name: <code>wp-duotone-0123456789abc</code>!</div>',
+				'expected' => '<div class="wp-duotone-test wp-block-cover">This is a super cool class name: <code>wp-duotone-0123456789abc</code>!</div>',
+			],
+			'ignore_already_transformed_class_names' => [
+				'content'  => '<div class="wp-duotone-1 wp-block-cover">This is a super cool class name: <code>wp-duotone-0123456789abc</code>!</div>',
+				'expected' => '<div class="wp-duotone-1 wp-block-cover">This is a super cool class name: <code>wp-duotone-0123456789abc</code>!</div>',
+			],
+		];
+	}
+
+	/**
+	 * @covers ::transform_class_names_in_content()
+	 * @covers ::transform_class_names_in_inline_styles()
+	 * @covers ::get_class_name_regexp_pattern()
+	 * @covers ::unique_id()
+	 *
+	 * @dataProvider get_block_data
+	 *
+	 * @param string $content
+	 * @param string $expected
+	 */
+	public function test_sanitize( $content, $expected ) {
+		$dom       = AMP_DOM_Utils::get_dom_from_content( $content );
+		$sanitizer = new AMP_Block_Uniqid_Sanitizer( $dom );
+
+		$sanitizer->sanitize();
+		$content = AMP_DOM_Utils::get_content_from_dom( $dom );
+
+		// Normalize auto-incrementing ID to allow tests to be run in isolation.
+		$content = preg_replace( '/-\d+\b/', '-1', $content );
+
+		$this->assertEqualMarkup( $expected, $content );
+	}
+}