ContentHandler.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Content;
 
use InvalidArgumentException;
use JsonException;
use LogicException;
use MediaWiki\Actions\Action;
use MediaWiki\CommentStore\CommentStore;
use MediaWiki\Content\Renderer\ContentParseParams;
use MediaWiki\Content\Transform\PreloadTransformParams;
use MediaWiki\Content\Transform\PreSaveTransformParams;
use MediaWiki\Context\IContextSource;
use MediaWiki\Context\RequestContext;
use MediaWiki\Deferred\DeferrableUpdate;
use MediaWiki\Diff\DifferenceEngine;
use MediaWiki\Diff\DifferenceEngineSlotDiffRenderer;
use MediaWiki\Diff\SlotDiffRenderer;
use MediaWiki\Diff\TextDiffer\ManifoldTextDiffer;
use MediaWiki\Diff\TextSlotDiffRenderer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\Language\ILanguageConverter;
use MediaWiki\Language\Language;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\ParserOutputAccess;
use MediaWiki\Page\WikiPage;
use MediaWiki\Parser\ParserCache;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Revision\SlotRenderingProvider;
use MediaWiki\Search\ParserOutputSearchDataExtractor;
use MediaWiki\Search\SearchEngine;
use MediaWiki\Search\SearchIndexField;
use MediaWiki\Title\Title;
use RuntimeException;
use StatusValue;
use UnexpectedValueException;
use Wikimedia\Assert\Assert;
use Wikimedia\Rdbms\IDBAccessObject;
use Wikimedia\ScopedCallback;
 
abstract class ContentHandler {
    use ProtectedHookAccessorTrait;
 
    public static function makeContent( $text, ?Title $title = null,
        $modelId = null, $format = null ) {
        if ( !$title && !$modelId ) {
            throw new InvalidArgumentException( "Must provide a Title object or a content model ID." );
        }
 
        return MediaWikiServices::getInstance()
            ->getContentHandlerFactory()
            ->getContentHandler( $modelId ?? $title->getContentModel() )
            ->unserializeContent( $text, $format );
    }
 
    public static function getLocalizedName( $name, ?Language $lang = null ) {
        // Messages: content-model-wikitext, content-model-text,
        // content-model-javascript, content-model-css
        // Lowercase the name as message keys need to be in lowercase, T358341
        $key = "content-model-" . strtolower( $name ?? '' );
 
        $msg = wfMessage( $key );
        if ( $lang ) {
            $msg->inLanguage( $lang );
        }
 
        return $msg->exists() ? $msg->plain() : $name;
    }
 
    // ------------------------------------------------------------------------
 
    protected $mModelID;
 
    protected $mSupportedFormats;
 
    public function __construct( $modelId, $formats ) {
        $this->mModelID = $modelId;
        $this->mSupportedFormats = $formats;
    }
 
    abstract public function serializeContent( Content $content, $format = null );
 
    public function serializeContentToJsonArray( Content $content ): array {
        $format = $this->getJsonFormat();
        $blob = $this->serializeContent( $content, $format );
        return [
            'format' => $format,
            'blob' => $blob,
        ];
    }
 
    public function exportTransform( $blob, $format = null ) {
        return $blob;
    }
 
    abstract public function unserializeContent( $blob, $format = null );
 
    public function deserializeContentFromJsonArray( array $json ): Content {
        try {
            return $this->unserializeContent( $json['blob'], $json['format'] );
        } catch ( ContentSerializationException $e ) {
            throw new JsonException( $e->getMessage() );
        }
    }
 
    public function importTransform( $blob, $format = null ) {
        return $blob;
    }
 
    abstract public function makeEmptyContent();
 
    public function makeRedirectContent( Title $destination, $text = '' ) {
        return null;
    }
 
    public function getModelID() {
        return $this->mModelID;
    }
 
    protected function checkModelID( $model_id ) {
        if ( $model_id !== $this->mModelID ) {
            throw new UnexpectedContentModelException( "Bad content model: " .
                "expected {$this->mModelID} " .
                "but got $model_id." );
        }
    }
 
    public function getSupportedFormats() {
        return $this->mSupportedFormats;
    }
 
    public function getDefaultFormat() {
        return $this->mSupportedFormats[0];
    }
 
    public function getJsonFormat(): string {
        return $this->getDefaultFormat();
    }
 
    public function isSupportedFormat( $format ) {
        if ( !$format ) {
            return true; // this means "use the default"
        }
 
        return in_array( $format, $this->mSupportedFormats );
    }
 
    protected function checkFormat( $format ) {
        if ( !$this->isSupportedFormat( $format ) ) {
            throw new UnsupportedContentFormatException(
                "Format $format is not supported for content model "
                . $this->getModelID()
            );
        }
    }
 
    public function getActionOverrides() {
        return [];
    }
 
    public function createDifferenceEngine( IContextSource $context, $old = 0, $new = 0,
        $rcid = 0, // FIXME: Deprecated, no longer used
        $refreshCache = false, $unhide = false
    ) {
        $diffEngineClass = $this->getDiffEngineClass();
        $differenceEngine = new $diffEngineClass( $context, $old, $new, $rcid, $refreshCache, $unhide );
        $this->getHookRunner()->onGetDifferenceEngine(
            $context, $old, $new, $refreshCache, $unhide, $differenceEngine );
        return $differenceEngine;
    }
 
    final public function getSlotDiffRenderer( IContextSource $context, array $options = [] ) {
        $slotDiffRenderer = $this->getSlotDiffRendererWithOptions( $context, $options );
        if ( get_class( $slotDiffRenderer ) === TextSlotDiffRenderer::class ) {
            // To keep B/C, when SlotDiffRenderer is not overridden for a given content type
            // but DifferenceEngine is, use that instead.
            $differenceEngine = $this->createDifferenceEngine( $context );
            if ( get_class( $differenceEngine ) !== DifferenceEngine::class ) {
                // TODO turn this into a deprecation warning in a later release
                LoggerFactory::getInstance( 'diff' )->info(
                    'Falling back to DifferenceEngineSlotDiffRenderer', [
                        'modelID' => $this->getModelID(),
                        'DifferenceEngine' => get_class( $differenceEngine ),
                    ] );
                $slotDiffRenderer = new DifferenceEngineSlotDiffRenderer( $differenceEngine );
            }
        }
        $this->getHookRunner()->onGetSlotDiffRenderer( $this, $slotDiffRenderer, $context );
        return $slotDiffRenderer;
    }
 
    protected function getSlotDiffRendererInternal( IContextSource $context ) {
        return null;
    }
 
    protected function getSlotDiffRendererWithOptions( IContextSource $context, $options = [] ) {
        $internalRenderer = $this->getSlotDiffRendererInternal( $context );
        // `getSlotDiffRendererInternal` has been overridden by a class using the deprecated method.
        // Options will not work so exit early!
        if ( $internalRenderer !== null ) {
            wfDeprecated( 'ContentHandler::getSlotDiffRendererInternal', '1.35' );
            return $internalRenderer;
        }
        return $this->createTextSlotDiffRenderer( $options );
    }
 
    final protected function createTextSlotDiffRenderer( array $options = [] ): TextSlotDiffRenderer {
        $slotDiffRenderer = new TextSlotDiffRenderer();
 
        $services = MediaWikiServices::getInstance();
        $slotDiffRenderer->setStatsFactory( $services->getStatsFactory() );
        $slotDiffRenderer->setHookContainer( $services->getHookContainer() );
        $slotDiffRenderer->setContentModel( $this->getModelID() );
 
        if ( isset( $options['textDiffer'] ) ) {
            $textDiffer = $options['textDiffer'];
        } else {
            if ( isset( $options['contentLanguage'] ) ) {
                $language = $services->getLanguageFactory()->getLanguage( $options['contentLanguage'] );
            } else {
                $language = $services->getContentLanguage();
            }
            $config = $services->getMainConfig();
            $textDiffer = new ManifoldTextDiffer(
                RequestContext::getMain(),
                $language,
                $config->get( MainConfigNames::DiffEngine ),
                $config->get( MainConfigNames::ExternalDiffEngine ),
                $config->get( MainConfigNames::Wikidiff2Options )
            );
        }
        $format = $options['diff-type'] ?? 'table';
        if ( !$textDiffer->hasFormat( $format ) ) {
            // Maybe it would be better to throw an exception here, but at
            // present, the value comes straight from user input without
            // validation, so we have to fall back.
            $format = 'table';
        }
        $slotDiffRenderer->setFormat( $format );
        $slotDiffRenderer->setTextDiffer( $textDiffer );
        if ( $options['inline-toggle'] ?? false ) {
            $slotDiffRenderer->setInlineToggleEnabled();
        }
 
        return $slotDiffRenderer;
    }
 
    public function getPageLanguage( Title $title, ?Content $content = null ) {
        $services = MediaWikiServices::getInstance();
        $pageLang = $services->getContentLanguage();
 
        if ( $title->inNamespace( NS_MEDIAWIKI ) ) {
            // Parse mediawiki messages with correct target language
            [ /* $unused */, $lang ] = $services->getMessageCache()->figureMessage( $title->getText() );
            $pageLang = $services->getLanguageFactory()->getLanguage( $lang );
        }
 
        // Unused, T299369
        $userLang = null;
        $this->getHookRunner()->onPageContentLanguage( $title, $pageLang, $userLang );
 
        if ( !$pageLang instanceof Language ) {
            throw new UnexpectedValueException( 'onPageContentLanguage() hook provided an invalid $pageLang object.' );
        }
 
        return $pageLang;
    }
 
    public function getPageViewLanguage( Title $title, ?Content $content = null ) {
        $pageLang = $this->getPageLanguage( $title, $content );
 
        if ( $title->getNamespace() !== NS_MEDIAWIKI ) {
            // If the user chooses a variant, the content is actually
            // in a language whose code is the variant code.
            $variant = $this->getLanguageConverter( $pageLang )->getPreferredVariant();
            if ( $pageLang->getCode() !== $variant ) {
                $pageLang = MediaWikiServices::getInstance()->getLanguageFactory()
                    ->getLanguage( $variant );
            }
        }
 
        return $pageLang;
    }
 
    public function canBeUsedOn( Title $title ) {
        $ok = true;
 
        $this->getHookRunner()->onContentModelCanBeUsedOn( $this->getModelID(), $title, $ok );
 
        return $ok;
    }
 
    protected function getDiffEngineClass() {
        return DifferenceEngine::class;
    }
 
    public function merge3( Content $oldContent, Content $myContent, Content $yourContent ) {
        return false;
    }
 
    private function getLanguageConverter( $language ): ILanguageConverter {
        return MediaWikiServices::getInstance()->getLanguageConverterFactory()
            ->getLanguageConverter( $language );
    }
 
    private function getChangeType(
        ?Content $oldContent = null,
        ?Content $newContent = null,
        $flags = 0
    ) {
        $oldTarget = $oldContent !== null ? $oldContent->getRedirectTarget() : null;
        $newTarget = $newContent !== null ? $newContent->getRedirectTarget() : null;
 
        // We check for the type of change in the given edit, and return string key accordingly
 
        // Blanking of a page
        if ( $oldContent && $oldContent->getSize() > 0 &&
            $newContent && $newContent->getSize() === 0
        ) {
            return 'blank';
        }
 
        // Redirects
        if ( $newTarget ) {
            if ( !$oldTarget ) {
                // New redirect page (by creating new page or by changing content page)
                return 'new-redirect';
            } elseif ( !$newTarget->equals( $oldTarget ) ||
                $oldTarget->getFragment() !== $newTarget->getFragment()
            ) {
                // Redirect target changed
                return 'changed-redirect-target';
            }
        } elseif ( $oldTarget ) {
            // Changing an existing redirect into a non-redirect
            return 'removed-redirect';
        }
 
        // New page created
        if ( $flags & EDIT_NEW && $newContent ) {
            if ( $newContent->getSize() === 0 ) {
                // New blank page
                return 'newblank';
            } else {
                return 'newpage';
            }
        }
 
        // Removing more than 90% of the page
        if ( $oldContent && $newContent && $oldContent->getSize() > 10 * $newContent->getSize() ) {
            return 'replace';
        }
 
        // Content model changed
        if ( $oldContent && $newContent && $oldContent->getModel() !== $newContent->getModel() ) {
            return 'contentmodelchange';
        }
 
        return null;
    }
 
    public function getAutosummary(
        ?Content $oldContent = null,
        ?Content $newContent = null,
        $flags = 0
    ) {
        $changeType = $this->getChangeType( $oldContent, $newContent, $flags );
 
        // There's no applicable auto-summary for our case, so our auto-summary is empty.
        if ( !$changeType ) {
            return '';
        }
 
        // Set the maximum auto-summary length to the general maximum summary length
        // T221617
        $summaryLimit = CommentStore::COMMENT_CHARACTER_LIMIT;
 
        // Decide what kind of auto-summary is needed.
        switch ( $changeType ) {
            case 'new-redirect':
                $newTarget = $newContent->getRedirectTarget();
                $truncatedtext = $newContent->getTextForSummary(
                    $summaryLimit
                    - strlen( wfMessage( 'autoredircomment' )->inContentLanguage()->text() )
                    - strlen( $newTarget->getFullText() )
                );
 
                return wfMessage( 'autoredircomment', $newTarget->getFullText() )
                    ->plaintextParams( $truncatedtext )->inContentLanguage()->text();
            case 'changed-redirect-target':
                $oldTarget = $oldContent->getRedirectTarget();
                $newTarget = $newContent->getRedirectTarget();
 
                $truncatedtext = $newContent->getTextForSummary(
                    $summaryLimit
                    - strlen( wfMessage( 'autosumm-changed-redirect-target' )
                        ->inContentLanguage()->text() )
                    - strlen( $oldTarget->getFullText() )
                    - strlen( $newTarget->getFullText() )
                );
 
                return wfMessage( 'autosumm-changed-redirect-target',
                        $oldTarget->getFullText(),
                        $newTarget->getFullText() )
                    ->rawParams( $truncatedtext )->inContentLanguage()->text();
            case 'removed-redirect':
                $oldTarget = $oldContent->getRedirectTarget();
                $truncatedtext = $newContent->getTextForSummary(
                    $summaryLimit
                    - strlen( wfMessage( 'autosumm-removed-redirect' )
                        ->inContentLanguage()->text() )
                    - strlen( $oldTarget->getFullText() ) );
 
                return wfMessage( 'autosumm-removed-redirect', $oldTarget->getFullText() )
                    ->rawParams( $truncatedtext )->inContentLanguage()->text();
            case 'newpage':
                // If they're making a new article, give its text, truncated, in the summary.
                $truncatedtext = $newContent->getTextForSummary(
                    $summaryLimit - strlen( wfMessage( 'autosumm-new' )->inContentLanguage()->text() ) );
 
                return wfMessage( 'autosumm-new' )->rawParams( $truncatedtext )
                    ->inContentLanguage()->text();
            case 'blank':
                return wfMessage( 'autosumm-blank' )->inContentLanguage()->text();
            case 'replace':
                $truncatedtext = $newContent->getTextForSummary(
                    $summaryLimit - strlen( wfMessage( 'autosumm-replace' )->inContentLanguage()->text() ) );
 
                return wfMessage( 'autosumm-replace' )->rawParams( $truncatedtext )
                    ->inContentLanguage()->text();
            case 'newblank':
                return wfMessage( 'autosumm-newblank' )->inContentLanguage()->text();
            default:
                return '';
        }
    }
 
    public function getChangeTag(
        ?Content $oldContent = null,
        ?Content $newContent = null,
        $flags = 0
    ) {
        $changeType = $this->getChangeType( $oldContent, $newContent, $flags );
 
        // There's no applicable tag for this change.
        if ( !$changeType ) {
            return null;
        }
 
        // Core tags use the same keys as ones returned from $this->getChangeType()
        // but prefixed with pseudo namespace 'mw-', so we add the prefix before checking
        // if this type of change should be tagged. List of tags for grep:
        // mw-blank, mw-new-redirect, mw-changed-redirect-target, mw-removed-redirect,
        // mw-replace, mw-contentmodelchange
        $tag = 'mw-' . $changeType;
 
        // Not all change types are tagged, so we check against the list of defined tags.
        if ( in_array( $tag, MediaWikiServices::getInstance()->getChangeTagsStore()->getSoftwareTags() ) ) {
            return $tag;
        }
 
        return null;
    }
 
    public function getAutoDeleteReason( Title $title, &$hasHistory = false ) {
        if ( func_num_args() === 2 ) {
            wfDeprecated( __METHOD__ . ': $hasHistory parameter', '1.38' );
        }
        $dbr = MediaWikiServices::getInstance()->getConnectionProvider()->getReplicaDatabase();
        $revStore = MediaWikiServices::getInstance()->getRevisionStore();
 
        // Get the last revision
        $revRecord = $revStore->getRevisionByTitle( $title );
 
        if ( $revRecord === null ) {
            return false;
        }
 
        // Get the article's contents
        $content = $revRecord->getContent( SlotRecord::MAIN );
        $blank = false;
 
        // If the page is blank, use the text from the previous revision,
        if ( !$content || $content->isEmpty() ) {
            $prev = $revStore->getPreviousRevision( $revRecord );
 
            if ( $prev ) {
                $prevContent = $prev->getContent( SlotRecord::MAIN );
                if ( $prevContent && !$prevContent->isEmpty() ) {
                    $revRecord = $prev;
                    $content = $prevContent;
                    $blank = true;
                }
                // Else since the previous revision is also blank or revdelled
                // (the blank case only happen due to a move/import/protect dummy revision)
                // skip the "before blanking" logic and fall back to just `content was ""`
            }
        }
 
        $this->checkModelID( $revRecord->getSlot( SlotRecord::MAIN )->getModel() );
 
        // Find out if there was only one contributor
        // Only scan the last 20 revisions
        $queryBuilder = $revStore->newSelectQueryBuilder( $dbr )
            ->where( [
                'rev_page' => $title->getArticleID(),
                $dbr->bitAnd( 'rev_deleted', RevisionRecord::DELETED_USER ) . ' = 0'
            ] )
            ->limit( 20 );
        $res = $queryBuilder->caller( __METHOD__ )->fetchResultSet();
 
        if ( !$res->numRows() ) {
            // This page has no revisions, which is very weird
            return false;
        }
 
        $hasHistory = ( $res->numRows() > 1 );
        $row = $res->fetchObject();
 
        if ( $row ) { // $row is false if the only contributor is hidden
            $onlyAuthor = $row->rev_user_text;
            // Try to find a second contributor
            foreach ( $res as $row ) {
                if ( $row->rev_user_text != $onlyAuthor ) { // T24999
                    $onlyAuthor = false;
                    break;
                }
            }
        } else {
            $onlyAuthor = false;
        }
 
        // Generate the summary with a '$1' placeholder
        if ( $blank ) {
            $reason = wfMessage( 'exbeforeblank', '$1' )->inContentLanguage()->text();
        } else {
            if ( $onlyAuthor ) {
                $reason = wfMessage(
                    'excontentauthor',
                    '$1',
                    $onlyAuthor
                )->inContentLanguage()->text();
            } else {
                $reason = wfMessage( 'excontent', '$1' )->inContentLanguage()->text();
            }
        }
 
        if ( $reason == '-' ) {
            // Allow these UI messages to be blanked out cleanly
            return '';
        }
 
        // Max content length = max comment length - length of the comment (excl. $1)
        $maxLength = CommentStore::COMMENT_CHARACTER_LIMIT - ( strlen( $reason ) - 2 );
        $text = $content ? $content->getTextForSummary( $maxLength ) : '';
        if ( $blank && !$text ) {
            // Don't display "content before blanking was ''" as misleading
            // This can happen if the content before blanking was two unclosed square brackets, for example
            // Do display `content was ""` if the page was always blank, though
            return false;
        }
 
        // Now replace the '$1' placeholder
        $reason = str_replace( '$1', $text, $reason );
 
        return $reason;
    }
 
    public function getUndoContent(
        Content $currentContent,
        Content $undoContent,
        Content $undoAfterContent,
        $undoIsLatest = false
    ) {
        try {
            $this->checkModelID( $currentContent->getModel() );
            $this->checkModelID( $undoContent->getModel() );
            if ( !$undoIsLatest ) {
                // If we are undoing the most recent revision,
                // its ok to revert content model changes. However
                // if we are undoing a revision in the middle, then
                // doing that will be confusing.
                $this->checkModelID( $undoAfterContent->getModel() );
            }
        } catch ( UnexpectedContentModelException ) {
            // If the revisions have different content models
            // just return false
            return false;
        }
 
        if ( $currentContent->equals( $undoContent ) ) {
            // No use doing a merge if it's just a straight revert.
            return $undoAfterContent;
        }
 
        $undone_content = $this->merge3( $undoContent, $undoAfterContent, $currentContent );
 
        return $undone_content;
    }
 
    public function isParserCacheSupported() {
        return false;
    }
 
    public function supportsSections() {
        return false;
    }
 
    public function supportsCategories() {
        return true;
    }
 
    public function supportsRedirects() {
        return false;
    }
 
    public function supportsDirectEditing() {
        return false;
    }
 
    public function supportsPreloadContent(): bool {
        return false;
    }
 
    public function generateHTMLOnEdit(): bool {
        return true;
    }
 
    public function supportsDirectApiEditing() {
        return $this->supportsDirectEditing();
    }
 
    public function getFieldsForSearchIndex( SearchEngine $engine ) {
        $fields = [];
        $fields['category'] = $engine->makeSearchFieldMapping(
            'category',
            SearchIndexField::INDEX_TYPE_TEXT
        );
        $fields['category']->setFlag( SearchIndexField::FLAG_CASEFOLD );
 
        $fields['external_link'] = $engine->makeSearchFieldMapping(
            'external_link',
            SearchIndexField::INDEX_TYPE_KEYWORD
        );
 
        $fields['outgoing_link'] = $engine->makeSearchFieldMapping(
            'outgoing_link',
            SearchIndexField::INDEX_TYPE_KEYWORD
        );
 
        $fields['template'] = $engine->makeSearchFieldMapping(
            'template',
            SearchIndexField::INDEX_TYPE_KEYWORD
        );
        $fields['template']->setFlag( SearchIndexField::FLAG_CASEFOLD );
 
        $fields['content_model'] = $engine->makeSearchFieldMapping(
            'content_model',
            SearchIndexField::INDEX_TYPE_KEYWORD
        );
 
        return $fields;
    }
 
    protected function addSearchField( &$fields, SearchEngine $engine, $name, $type ) {
        $fields[$name] = $engine->makeSearchFieldMapping( $name, $type );
        return $fields;
    }
 
    public function getDataForSearchIndex(
        WikiPage $page,
        ParserOutput $output,
        SearchEngine $engine,
        ?RevisionRecord $revision = null
    ) {
        $revision ??= $page->getRevisionRecord();
        if ( $revision === null ) {
            LoggerFactory::getInstance( 'search' )->warning(
                "Called getDataForSearchIndex on the page {page_id} for which the " .
                "latest revision cannot be loaded.",
                [ "page_id" => $page->getId() ]
            );
            return [];
        }
        Assert::invariant( $revision->getPageId() === $page->getId(),
            '$revision and $page must target the same page_id' );
 
        $fieldData = [];
        $content = $revision->getContent( SlotRecord::MAIN );
 
        if ( $content ) {
            $searchDataExtractor = new ParserOutputSearchDataExtractor();
 
            $fieldData['category'] = $searchDataExtractor->getCategories( $output );
            $fieldData['external_link'] = $searchDataExtractor->getExternalLinks( $output );
            $fieldData['outgoing_link'] = $searchDataExtractor->getOutgoingLinks( $output );
            $fieldData['template'] = $searchDataExtractor->getTemplates( $output );
 
            $text = $content->getTextForSearchIndex();
 
            $fieldData['text'] = $text;
            $fieldData['source_text'] = $text;
            $fieldData['text_bytes'] = $content->getSize();
            $fieldData['content_model'] = $content->getModel();
        }
 
        $this->getHookRunner()->onSearchDataForIndex( $fieldData, $this, $page, $output, $engine );
        $this->getHookRunner()->onSearchDataForIndex2( $fieldData, $this, $page, $output, $engine, $revision );
 
        return $fieldData;
    }
 
    public function getParserOutputForIndexing(
        WikiPage $page,
        ?ParserCache $cache = null,
        ?RevisionRecord $revision = null
    ) {
        // TODO: MCR: ContentHandler should be called per slot, not for the whole page.
        // See T190066.
        $parserOptions = $page->makeParserOptions( 'canonical' );
        $parserOptions->setRenderReason( 'ParserOutputForIndexing' );
        $parserOutputAccess = MediaWikiServices::getInstance()->getParserOutputAccess();
        return $parserOutputAccess->getParserOutput(
            $page,
            $parserOptions,
            $revision,
            [ ParserOutputAccess::OPT_NO_UPDATE_CACHE => true ],
        )->getValue();
    }
 
    protected function latestRevision( WikiPage $page ): RevisionRecord {
        $revRecord = $page->getRevisionRecord();
        if ( $revRecord == null ) {
            // If the content represents a brand new page it's possible
            // we need to fetch it from the primary.
            $page->loadPageData( IDBAccessObject::READ_LATEST );
            $revRecord = $page->getRevisionRecord();
            if ( $revRecord == null ) {
                $text = $page->getTitle()->getPrefixedText();
                throw new RuntimeException(
                    "No revision could be loaded for page: $text" );
            }
        }
 
        return $revRecord;
    }
 
    public function getSecondaryDataUpdates(
        Title $title,
        Content $content,
        $role,
        SlotRenderingProvider $slotOutput
    ) {
        return [];
    }
 
    public function getDeletionUpdates( Title $title, $role ) {
        return [];
    }
 
    public function preSaveTransform(
        Content $content,
        PreSaveTransformParams $pstParams
    ): Content {
        return $content;
    }
 
    public function preloadTransform(
        Content $content,
        PreloadTransformParams $pltParams
    ): Content {
        return $content;
    }
 
    public function validateSave(
        Content $content,
        ValidationParams $validationParams
    ) {
        if ( $content->isValid() ) {
            return StatusValue::newGood();
        } else {
            return StatusValue::newFatal( "invalid-content-data" );
        }
    }
 
    public function getParserOutput(
        Content $content,
        ContentParseParams $cpoParams
    ) {
        $services = MediaWikiServices::getInstance();
        $title = $services->getTitleFactory()->newFromPageReference( $cpoParams->getPage() );
        $parserOptions = $cpoParams->getParserOptions();
 
        if ( $parserOptions->getIsPreview() ) {
            $scopedCallback = $parserOptions->setupFakeRevision(
                $title,
                $content,
                $parserOptions->getUserIdentity(),
                $cpoParams->getRevId() ?: 0
            );
        }
 
        $hookRunner = new HookRunner( $services->getHookContainer() );
 
        $po = new ParserOutput();
 
        // Initialize to the page language
        $po->setLanguage( $title->getPageLanguage() );
 
        // Necessary use of a reference, because the fillParserOutput() call below also uses
        // pass-by-reference and may reassign $po (5c9322ae06384a8845962ba7e3c499731110e7f0).
        $parserOptions->registerWatcher( [ &$po, 'recordOption' ] );
        if ( $hookRunner->onContentGetParserOutput(
            // FIXME $cpoParams->getRevId() may be null here?
            // @phan-suppress-next-line PhanTypeMismatchArgumentNullable
            $content, $title, $cpoParams->getRevId(), $parserOptions, $cpoParams->getGenerateHtml(), $po )
        ) {
            // Save and restore the old value, just in case something is reusing
            // the ParserOptions object in some weird way.
            $oldRedir = $parserOptions->getRedirectTarget();
            $parserOptions->setRedirectTarget( $content->getRedirectTarget() );
 
            $po->resetParseStartTime();
            $this->fillParserOutput(
                $content,
                $cpoParams,
                $po
            );
            $po->recordTimeProfile();
 
            MediaWikiServices::getInstance()->get( '_ParserObserver' )->notifyParse(
                $title,
                $cpoParams->getRevId(),
                $parserOptions,
                $content,
                $po
            );
            $parserOptions->setRedirectTarget( $oldRedir );
        }
 
        $hookRunner->onContentAlterParserOutput( $content, $title, $po );
        $parserOptions->registerWatcher( null );
        if ( isset( $scopedCallback ) ) {
            ScopedCallback::consume( $scopedCallback );
        }
 
        return $po;
    }
 
    public function fillParserOutputInternal(
        Content $content,
        ContentParseParams $cpoParams,
        ParserOutput &$output
    ) {
        $this->fillParserOutput( $content, $cpoParams, $output );
    }
 
    protected function fillParserOutput(
        Content $content,
        ContentParseParams $cpoParams,
        ParserOutput &$output
    ) {
        // Subclasses must override fillParserOutput() to directly don't fail.
        throw new LogicException( 'Subclasses of ContentHandler must override fillParserOutput!' );
    }
 
}
 
class_alias( ContentHandler::class, 'ContentHandler' );