Article.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Page;
 
use LogicException;
use MediaWiki\Block\DatabaseBlock;
use MediaWiki\Block\DatabaseBlockStore;
use MediaWiki\Cache\HTMLFileCache;
use MediaWiki\CommentFormatter\CommentFormatter;
use MediaWiki\Context\IContextSource;
use MediaWiki\Context\RequestContext;
use MediaWiki\EditPage\EditPage;
use MediaWiki\Exception\PermissionsError;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\Html\Html;
use MediaWiki\JobQueue\JobQueueGroup;
use MediaWiki\JobQueue\Jobs\ParsoidCachePrewarmJob;
use MediaWiki\Language\Language;
use MediaWiki\Linker\Linker;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Logging\LogEventsList;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Output\OutputPage;
use MediaWiki\Parser\Parser;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\Permissions\RestrictionStore;
use MediaWiki\RecentChanges\RecentChange;
use MediaWiki\RecentChanges\RecentChangeLookup;
use MediaWiki\Revision\ArchivedRevisionLookup;
use MediaWiki\Revision\BadRevisionException;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Skin\Skin;
use MediaWiki\Status\Status;
use MediaWiki\Title\Title;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserNameUtils;
use Wikimedia\HtmlArmor\HtmlArmor;
use Wikimedia\IPUtils;
use Wikimedia\NonSerializable\NonSerializableTrait;
use Wikimedia\Rdbms\IConnectionProvider;
 
class Article implements Page {
    use ProtectedHookAccessorTrait;
    use NonSerializableTrait;
 
    protected $mContext;
 
    protected $mPage;
 
    public $mOldId;
 
    public $mRedirectedFrom = null;
 
    public $mRedirectUrl = false;
 
    private $fetchResult = null;
 
    public $mParserOutput = null;
 
    protected $viewIsRenderAction = false;
 
    protected LinkRenderer $linkRenderer;
    private RevisionStore $revisionStore;
    private UserNameUtils $userNameUtils;
    private UserOptionsLookup $userOptionsLookup;
    private CommentFormatter $commentFormatter;
    private WikiPageFactory $wikiPageFactory;
    private JobQueueGroup $jobQueueGroup;
    private ArchivedRevisionLookup $archivedRevisionLookup;
    private RecentChangeLookup $recentChangeLookup;
    protected IConnectionProvider $dbProvider;
    protected DatabaseBlockStore $blockStore;
    protected RestrictionStore $restrictionStore;
    private bool $usePostprocessCache;
 
    private $mRevisionRecord = null;
 
    public function __construct( Title $title, $oldId = null ) {
        $this->mOldId = $oldId;
        $this->mPage = $this->newPage( $title );
 
        $services = MediaWikiServices::getInstance();
        $this->linkRenderer = $services->getLinkRenderer();
        $this->revisionStore = $services->getRevisionStore();
        $this->userNameUtils = $services->getUserNameUtils();
        $this->userOptionsLookup = $services->getUserOptionsLookup();
        $this->commentFormatter = $services->getCommentFormatter();
        $this->wikiPageFactory = $services->getWikiPageFactory();
        $this->jobQueueGroup = $services->getJobQueueGroup();
        $this->archivedRevisionLookup = $services->getArchivedRevisionLookup();
        $this->recentChangeLookup = $services->getRecentChangeLookup();
        $this->dbProvider = $services->getConnectionProvider();
        $this->blockStore = $services->getDatabaseBlockStore();
        $this->restrictionStore = $services->getRestrictionStore();
        $this->usePostprocessCache = $services->getMainConfig()->get( MainConfigNames::UsePostprocCache );
    }
 
    protected function newPage( Title $title ) {
        return new WikiPage( $title );
    }
 
    public static function newFromID( $id ): ?static {
        $t = Title::newFromID( $id );
        return $t === null ? null : new static( $t );
    }
 
    public static function newFromTitle( $title, IContextSource $context ): static {
        if ( $title->getNamespace() === NS_MEDIA ) {
            // XXX: This should not be here, but where should it go?
            $title = Title::makeTitle( NS_FILE, $title->getDBkey() );
        }
 
        $page = null;
        ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
            // @phan-suppress-next-line PhanTypeMismatchArgument Type mismatch on pass-by-ref args
            ->onArticleFromTitle( $title, $page, $context );
 
        $page ??= match ( $title->getNamespace() ) {
            NS_FILE => new ImagePage( $title ),
            NS_CATEGORY => new CategoryPage( $title ),
            default => new Article( $title )
        };
        $page->setContext( $context );
 
        return $page;
    }
 
    public static function newFromWikiPage( WikiPage $page, IContextSource $context ) {
        $article = self::newFromTitle( $page->getTitle(), $context );
        $article->mPage = $page; // override to keep process cached vars
        return $article;
    }
 
    public function getRedirectedFrom() {
        return $this->mRedirectedFrom;
    }
 
    public function setRedirectedFrom( Title $from ) {
        $this->mRedirectedFrom = $from;
    }
 
    public function getTitle() {
        return $this->mPage->getTitle();
    }
 
    public function getPage() {
        return $this->mPage;
    }
 
    public function clear() {
        $this->mRedirectedFrom = null; # Title object if set
        $this->mRedirectUrl = false;
        $this->mRevisionRecord = null;
        $this->fetchResult = null;
 
        // TODO hard-deprecate direct access to public fields
 
        $this->mPage->clear();
    }
 
    public function getOldID() {
        if ( $this->mOldId === null ) {
            $this->mOldId = $this->getOldIDFromRequest();
        }
 
        return $this->mOldId;
    }
 
    public function getOldIDFromRequest() {
        $this->mRedirectUrl = false;
 
        $request = $this->getContext()->getRequest();
        $oldid = $request->getIntOrNull( 'oldid' );
 
        if ( $oldid === null ) {
            return 0;
        }
 
        if ( $oldid !== 0 ) {
            # Load the given revision and check whether the page is another one.
            # In that case, update this instance to reflect the change.
            if ( $oldid === $this->mPage->getLatest() ) {
                $this->mRevisionRecord = $this->mPage->getRevisionRecord();
            } else {
                $this->mRevisionRecord = $this->revisionStore->getRevisionById( $oldid );
                if ( $this->mRevisionRecord !== null ) {
                    $revPageId = $this->mRevisionRecord->getPageId();
                    // Revision title doesn't match the page title given?
                    if ( $this->mPage->getId() !== $revPageId ) {
                        $this->mPage = $this->wikiPageFactory->newFromID( $revPageId );
                    }
                }
            }
        }
 
        $oldRev = $this->mRevisionRecord;
        if ( $request->getRawVal( 'direction' ) === 'next' ) {
            $nextid = 0;
            if ( $oldRev ) {
                $nextRev = $this->revisionStore->getNextRevision( $oldRev );
                if ( $nextRev ) {
                    $nextid = $nextRev->getId();
                }
            }
            if ( $nextid ) {
                $oldid = $nextid;
                $this->mRevisionRecord = null;
            } else {
                $this->mRedirectUrl = $this->getTitle()->getFullURL( 'redirect=no' );
            }
        } elseif ( $request->getRawVal( 'direction' ) === 'prev' ) {
            $previd = 0;
            if ( $oldRev ) {
                $prevRev = $this->revisionStore->getPreviousRevision( $oldRev );
                if ( $prevRev ) {
                    $previd = $prevRev->getId();
                }
            }
            if ( $previd ) {
                $oldid = $previd;
                $this->mRevisionRecord = null;
            }
        }
 
        return $oldid;
    }
 
    public function fetchRevisionRecord() {
        if ( $this->fetchResult ) {
            return $this->mRevisionRecord;
        }
 
        $oldid = $this->getOldID();
 
        // $this->mRevisionRecord might already be fetched by getOldIDFromRequest()
        if ( !$this->mRevisionRecord ) {
            if ( !$oldid ) {
                $this->mRevisionRecord = $this->mPage->getRevisionRecord();
 
                if ( !$this->mRevisionRecord ) {
                    wfDebug( __METHOD__ . " failed to find page data for title " .
                        $this->getTitle()->getPrefixedText() );
 
                    // Output for this case is done by showMissingArticle().
                    $this->fetchResult = Status::newFatal( 'noarticletext' );
                    return null;
                }
            } else {
                $this->mRevisionRecord = $this->revisionStore->getRevisionById( $oldid );
 
                if ( !$this->mRevisionRecord ) {
                    wfDebug( __METHOD__ . " failed to load revision, rev_id $oldid" );
 
                    $this->fetchResult = Status::newFatal( $this->getMissingRevisionMsg( $oldid ) );
                    return null;
                }
            }
        }
 
        if ( !$this->mRevisionRecord->userCan( RevisionRecord::DELETED_TEXT, $this->getContext()->getAuthority() ) ) {
            wfDebug( __METHOD__ . " failed to retrieve content of revision " . $this->mRevisionRecord->getId() );
 
            // Output for this case is done by showDeletedRevisionHeader().
            // title used in wikilinks, should not contain whitespaces
            $this->fetchResult = new Status;
            $title = $this->getTitle()->getPrefixedDBkey();
 
            if ( $this->mRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) ) {
                $this->fetchResult->fatal( 'rev-suppressed-text' );
            } else {
                $this->fetchResult->fatal( 'rev-deleted-text-permission', $title );
            }
 
            return null;
        }
 
        $this->fetchResult = Status::newGood( $this->mRevisionRecord );
        return $this->mRevisionRecord;
    }
 
    public function isCurrent() {
        # If no oldid, this is the current version.
        if ( $this->getOldID() == 0 ) {
            return true;
        }
 
        return $this->mPage->exists() &&
            $this->mRevisionRecord &&
            $this->mRevisionRecord->isCurrent();
    }
 
    public function getRevIdFetched() {
        if ( $this->fetchResult && $this->fetchResult->isOK() ) {
            $rev = $this->fetchResult->getValue();
            return $rev->getId();
        } else {
            return $this->mPage->getLatest();
        }
    }
 
    public function view() {
        $context = $this->getContext();
        $useFileCache = $context->getConfig()->get( MainConfigNames::UseFileCache );
 
        # Get variables from query string
        # As side effect this will load the revision and update the title
        # in a revision ID is passed in the request, so this should remain
        # the first call of this method even if $oldid is used way below.
        $oldid = $this->getOldID();
 
        $authority = $context->getAuthority();
        # Another check in case getOldID() is altering the title
        $permissionStatus = PermissionStatus::newEmpty();
        if ( !$authority
            ->authorizeRead( 'read', $this->getTitle(), $permissionStatus )
        ) {
            wfDebug( __METHOD__ . ": denied on secondary read check" );
            throw new PermissionsError( 'read', $permissionStatus );
        }
 
        $outputPage = $context->getOutput();
        # getOldID() may as well want us to redirect somewhere else
        if ( $this->mRedirectUrl ) {
            $outputPage->redirect( $this->mRedirectUrl );
            wfDebug( __METHOD__ . ": redirecting due to oldid" );
 
            return;
        }
 
        # If we got diff in the query, we want to see a diff page instead of the article.
        if ( $context->getRequest()->getCheck( 'diff' ) ) {
            wfDebug( __METHOD__ . ": showing diff page" );
            $this->showDiffPage();
 
            return;
        }
 
        $this->showProtectionIndicator();
 
        # Set page title (may be overridden from ParserOutput if title conversion is enabled or DISPLAYTITLE is used)
        $outputPage->setPageTitle( Parser::formatPageTitle(
            str_replace( '_', ' ', $this->getTitle()->getNsText() ),
            ':',
            $this->getTitle()->getText(),
            $this->getTitle()->getPageLanguage()
        ) );
 
        $outputPage->setArticleFlag( true );
        # Allow frames by default
        $outputPage->getMetadata()->setPreventClickjacking( false );
 
        $parserOptions = $this->getParserOptions();
 
        $poOptions = [];
        # Allow extensions to vary parser options used for article rendering
        ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
            ->onArticleParserOptions( $this, $parserOptions );
        # Render printable version, use printable version cache
        if ( $outputPage->isPrintable() ) {
            $parserOptions->setIsPrintable( true );
            $poOptions['enableSectionEditLinks'] = false;
            $this->addMessageBoxStyles( $outputPage );
            $outputPage->prependHTML(
                Html::warningBox(
                    $outputPage->msg( 'printableversion-deprecated-warning' )->escaped()
                )
            );
        } elseif ( $this->viewIsRenderAction || !$this->isCurrent() ||
            !$authority->probablyCan( 'edit', $this->getTitle() )
        ) {
            $poOptions['enableSectionEditLinks'] = false;
        }
 
        # Try client and file cache
        if ( $oldid === 0 && $this->mPage->checkTouched() ) {
            # Try to stream the output from file cache
            if ( $useFileCache && $this->tryFileCache() ) {
                wfDebug( __METHOD__ . ": done file cache" );
                # tell wgOut that output is taken care of
                $outputPage->disable();
                $this->mPage->doViewUpdates( $authority, $oldid );
 
                return;
            }
        }
 
        $this->showRedirectedFromHeader();
        $this->showNamespaceHeader();
 
        if ( $this->viewIsRenderAction ) {
            $poOptions += [ 'absoluteURLs' => true ];
        }
        $poOptions += [ 'includeDebugInfo' => true ];
 
        try {
            $continue =
                $this->generateContentOutput( $authority, $parserOptions, $oldid, $outputPage, $poOptions );
        } catch ( BadRevisionException ) {
            $continue = false;
            $this->showViewError( wfMessage( 'badrevision' )->text() );
        }
 
        if ( !$continue ) {
            return;
        }
 
        # For the main page, overwrite the <title> element with the con-
        # tents of 'pagetitle-view-mainpage' instead of the default (if
        # that's not empty).
        # This message always exists because it is in the i18n files
        if ( $this->getTitle()->isMainPage() ) {
            $msg = $context->msg( 'pagetitle-view-mainpage' )->inContentLanguage();
            if ( !$msg->isDisabled() ) {
                $outputPage->setHTMLTitle( $msg->text() );
            }
        }
 
        // Enable 1-day CDN cache on this response
        //
        // To reduce impact of lost or delayed HTTP purges, the adaptive TTL will
        // raise the TTL for pages not recently edited, upto $wgCdnMaxAge.
        // This could use getTouched(), but that could be scary for major template edits.
        $outputPage->adaptCdnTTL( $this->mPage->getTimestamp(), 86_400 );
 
        $this->showViewFooter();
        $this->mPage->doViewUpdates( $authority, $oldid, $this->fetchRevisionRecord() );
 
        # Load the postEdit module if the user just saved this revision
        # See also EditPage::setPostEditCookie
        $request = $context->getRequest();
        $cookieKey = EditPage::POST_EDIT_COOKIE_KEY_PREFIX . $this->getRevIdFetched();
        $postEdit = $request->getCookie( $cookieKey );
        if ( $postEdit ) {
            # Clear the cookie. This also prevents caching of the response.
            $request->response()->clearCookie( $cookieKey );
            $outputPage->addJsConfigVars( 'wgPostEdit', $postEdit );
            $outputPage->addModules( 'mediawiki.action.view.postEdit' ); // FIXME: test this
            if ( $this->getContext()->getConfig()->get( MainConfigNames::EnableEditRecovery )
                && $this->userOptionsLookup->getOption( $this->getContext()->getUser(), 'editrecovery' )
            ) {
                $outputPage->addModules( 'mediawiki.editRecovery.postEdit' );
            }
        }
    }
 
    public function showProtectionIndicator(): void {
        $title = $this->getTitle();
        $context = $this->getContext();
        $outputPage = $context->getOutput();
 
        $protectionIndicatorsAreEnabled = $context->getConfig()
            ->get( MainConfigNames::EnableProtectionIndicators );
 
        if ( !$protectionIndicatorsAreEnabled || $title->isMainPage() ) {
            return;
        }
 
        $protection = $this->restrictionStore->getRestrictions( $title, 'edit' );
 
        $cascadeProtection = $this->restrictionStore->getCascadeProtectionSources( $title )[1];
 
        $isCascadeProtected = array_key_exists( 'edit', $cascadeProtection );
 
        if ( !$protection && !$isCascadeProtected ) {
            return;
        }
 
        if ( $isCascadeProtected ) {
            // Cascade-protected pages are protected at the sysop level. So it
            // should not matter if we take the protection level of the first
            // or last page that is being cascaded to the current page.
            $protectionLevel = $cascadeProtection['edit'][0];
        } else {
            $protectionLevel = $protection[0];
        }
 
        // Protection levels are stored in the database as plain text, but
        // they are expected to be valid protection levels. So we should be able to
        // safely use them. However phan thinks this could be a XSS problem so we
        // are being paranoid and escaping them once more.
        $protectionLevel = htmlspecialchars( $protectionLevel );
 
        $protectionExpiry = $this->restrictionStore->getRestrictionExpiry( $title, 'edit' );
        $formattedProtectionExpiry = $context->getLanguage()
            ->formatExpiry( $protectionExpiry ?? '' );
 
        $protectionMsg = 'protection-indicator-title';
        if ( $protectionExpiry === 'infinity' || !$protectionExpiry ) {
            $protectionMsg .= '-infinity';
        }
 
        // Potential values: 'protection-sysop', 'protection-autoconfirmed',
        // 'protection-sysop-cascade' etc.
        // If the wiki has more protection levels, the additional ids that get
        // added take the form 'protection-<protectionLevel>' and
        // 'protection-<protectionLevel>-cascade'.
        $protectionIndicatorId = 'protection-' . $protectionLevel;
        $protectionIndicatorId .= ( $isCascadeProtected ? '-cascade' : '' );
 
        // Messages 'protection-indicator-title', 'protection-indicator-title-infinity'
        $protectionMsg = $outputPage->msg( $protectionMsg, $protectionLevel, $formattedProtectionExpiry )->text();
 
        // Use a trick similar to the one used in Action::addHelpLink() to allow wikis
        // to customize where the help link points to.
        $protectionHelpLink = $outputPage->msg( $protectionIndicatorId . '-helppage' );
        if ( $protectionHelpLink->isDisabled() ) {
            $protectionHelpLink = 'https://mediawiki.org/wiki/Special:MyLanguage/Help:Protection';
        } else {
            $protectionHelpLink = $protectionHelpLink->text();
        }
 
        $outputPage->setIndicators( [
            $protectionIndicatorId => Html::rawElement( 'a', [
                'class' => 'mw-protection-indicator-icon--lock',
                'title' => $protectionMsg,
                'href' => $protectionHelpLink
            ],
            // Screen reader-only text describing the same thing as
            // was mentioned in the title attribute.
            Html::element( 'span', [], $protectionMsg ) )
        ] );
 
        $outputPage->addModuleStyles( 'mediawiki.protectionIndicators.styles' );
    }
 
    private function generateContentOutput(
        Authority $performer,
        ParserOptions $parserOptions,
        int $oldid,
        OutputPage $outputPage,
        array $textOptions
    ): bool {
        # Should the parser cache be used?
        $useParserCache = true;
        $pOutput = null;
        $parserOutputAccess = MediaWikiServices::getInstance()->getParserOutputAccess();
 
        // NOTE: $outputDone and $useParserCache may be changed by the hook
        $this->getHookRunner()->onArticleViewHeader( $this, $outputDone, $useParserCache );
        if ( $outputDone ) {
            if ( $outputDone instanceof ParserOutput ) {
                $pOutput = $outputDone;
            }
 
            if ( $pOutput ) {
                $this->doOutputMetaData( $pOutput, $outputPage );
            }
            return true;
        }
 
        // Early abort if the page doesn't exist
        if ( !$this->mPage->exists() ) {
            wfDebug( __METHOD__ . ": showing missing article" );
            $this->showMissingArticle();
            $this->mPage->doViewUpdates( $performer );
            return false; // skip all further output to OutputPage
        }
 
        // Augment the parser options
        $skin = $outputPage->getSkin();
        $skinOptions = $skin->getOptions();
        $textOptions += [
            // T371022, T410923
            'allowClone' => $this->getContext()->getConfig()->get( MainConfigNames::CloneArticleParserOutput ),
            'skin' => $skin,
            'injectTOC' => $skinOptions['toc'],
        ];
        foreach ( $textOptions as $key => $value ) {
            // allowClone will disappear and should not impact cache
            // userLang is a duplicate of userlang and should be reconciled with it
            if ( $key === 'allowClone' || $key === 'userLang' ) {
                continue;
            }
            if ( !in_array( $key, ParserOptions::$postprocOptions, true ) ) {
                wfDeprecated( __METHOD__ . " with unknown textOption $key", "1.46" );
            } else {
                $parserOptions->setOption( $key, $value );
            }
        }
        if ( $this->usePostprocessCache ) {
            $parserOptions->enablePostproc();
        }
 
        // Try the latest parser cache
        // NOTE: try latest-revision cache first to avoid loading revision.
        if ( $useParserCache && !$oldid ) {
            $pOutput = $parserOutputAccess->getCachedParserOutput(
                $this->getPage(),
                $parserOptions,
                null,
                [
                    // we already checked
                    ParserOutputAccess::OPT_NO_AUDIENCE_CHECK => true,
                ],
            );
 
            if ( $pOutput ) {
                if ( !$this->usePostprocessCache ) {
                    $pOutput = $this->postProcessOutput( $pOutput, $parserOptions, $textOptions, $skin );
                }
                $this->doOutputFromPostProcessedParserCache( $pOutput, $outputPage );
                $this->doOutputMetaData( $pOutput, $outputPage );
                return true;
            }
        }
 
        $rev = $this->fetchRevisionRecord();
        if ( !$this->fetchResult->isOK() ) {
            $this->showViewError( $this->fetchResult->getWikiText(
                false, false, $this->getContext()->getLanguage()
            ) );
            return true;
        }
 
        # Are we looking at an old revision
        if ( $oldid ) {
            $this->setOldSubtitle( $oldid );
 
            if ( !$this->showDeletedRevisionHeader() ) {
                wfDebug( __METHOD__ . ": cannot view deleted revision" );
                return false; // skip all further output to OutputPage
            }
 
            // Try the old revision parser cache
            // NOTE: Repeating cache check for old revision to avoid fetching $rev
            // before it's absolutely necessary.
            if ( $useParserCache ) {
                $pOutput = $parserOutputAccess->getCachedParserOutput(
                    $this->getPage(),
                    $parserOptions,
                    $rev,
                    [
                         // we already checked in fetchRevisionRecord
                        ParserOutputAccess::OPT_NO_AUDIENCE_CHECK => true,
                    ],
                );
 
                if ( $pOutput ) {
                    if ( !$this->usePostprocessCache ) {
                        $pOutput = $this->postProcessOutput( $pOutput, $parserOptions, $textOptions, $skin );
                    }
                    $this->doOutputFromPostProcessedParserCache( $pOutput, $outputPage );
                    $this->doOutputMetaData( $pOutput, $outputPage );
                    return true;
                }
            }
        }
 
        # Ensure that UI elements requiring revision ID have
        # the correct version information. (This may be overwritten after creation of ParserOutput)
        $outputPage->setRevisionId( $this->getRevIdFetched() );
        $outputPage->setRevisionIsCurrent( $rev->isCurrent() );
        # Preload timestamp to avoid a DB hit
        $outputPage->getMetadata()->setRevisionTimestamp( $rev->getTimestamp() );
 
        # Pages containing custom CSS or JavaScript get special treatment
        if ( $this->getTitle()->isSiteConfigPage() || $this->getTitle()->isUserConfigPage() ) {
            $dir = $this->getContext()->getLanguage()->getDir();
            $lang = $this->getContext()->getLanguage()->getHtmlCode();
 
            $outputPage->wrapWikiMsg(
                "<div id='mw-clearyourcache' lang='$lang' dir='$dir' class='mw-content-$dir'>\n$1\n</div>",
                'clearyourcache'
            );
            $outputPage->addModuleStyles( 'mediawiki.action.styles' );
        } elseif ( !$this->getHookRunner()->onArticleRevisionViewCustom(
            $rev,
            $this->getTitle(),
            $oldid,
            $outputPage )
        ) {
            // NOTE: sync with hooks called in DifferenceEngine::renderNewRevision()
            // Allow extensions do their own custom view for certain pages
            $this->doOutputMetaData( $pOutput, $outputPage );
            return true;
        }
 
        # Run the parse, protected by a pool counter
        wfDebug( __METHOD__ . ": doing uncached parse" );
 
        $opt = [];
 
        // we already checked the cache in case 2, don't check again; but if we're using postproc,
        // we still want to check if we have a main parser cache entry.
        if ( $this->usePostprocessCache ) {
            $opt[ ParserOutputAccess::OPT_NO_POSTPROC_CACHE ] = true;
        } else {
            $opt[ ParserOutputAccess::OPT_NO_CHECK_CACHE ] = true;
        }
 
        // we already checked in fetchRevisionRecord()
        $opt[ ParserOutputAccess::OPT_NO_AUDIENCE_CHECK ] = true;
 
        // enable stampede protection
        $opt[ ParserOutputAccess::OPT_POOL_COUNTER ]
            = ParserOutputAccess::POOL_COUNTER_ARTICLE_VIEW;
 
        // allow stale cached content to be served
        $opt[ ParserOutputAccess::OPT_POOL_COUNTER_FALLBACK ] = true;
 
        // Attempt to trigger WikiPage::triggerOpportunisticLinksUpdate
        // Ideally this should not be the responsibility of the ParserCache to control this.
        // See https://phabricator.wikimedia.org/T329842#8816557 for more context.
        $opt[ ParserOutputAccess::OPT_LINKS_UPDATE ] = true;
 
        if ( !$rev->getId() || !$useParserCache ) {
            // fake revision or uncacheable options
            $opt[ ParserOutputAccess::OPT_NO_CACHE ] = true;
        }
 
        $renderStatus = $parserOutputAccess->getParserOutput(
            $this->getPage(),
            $parserOptions,
            $rev,
            $opt
        );
 
        // T327164: If parsoid cache warming is enabled, we want to ensure that the page
        // the user is currently looking at has a cached parsoid rendering, in case they
        // open visual editor. The cache entry would typically be missing if it has expired
        // from the cache or it was invalidated by RefreshLinksJob. When "traditional"
        // parser output has been invalidated by RefreshLinksJob, we will render it on
        // the fly when a user requests the page, and thereby populate the cache again,
        // per the code above.
        // The code below is intended to do the same for parsoid output, but asynchronously
        // in a job, so the user does not have to wait.
        // Note that we get here if the traditional parser output was missing from the cache.
        // We do not check if the parsoid output is present in the cache, because that check
        // takes time. The assumption is that if we have traditional parser output
        // cached, we probably also have parsoid output cached.
        // So we leave it to ParsoidCachePrewarmJob to determine whether or not parsing is
        // needed.
        if ( $oldid === 0 || $oldid === $this->getPage()->getLatest() ) {
            $parsoidCacheWarmingEnabled = $this->getContext()->getConfig()
                ->get( MainConfigNames::ParsoidCacheConfig )['WarmParsoidParserCache'];
 
            if ( $parsoidCacheWarmingEnabled ) {
                $parsoidJobSpec = ParsoidCachePrewarmJob::newSpec(
                    $rev->getId(),
                    $this->getPage()->toPageRecord(),
                    [ 'causeAction' => 'view' ]
                );
                $this->jobQueueGroup->lazyPush( $parsoidJobSpec );
            }
        }
 
        $this->doOutputFromRenderStatus(
            $rev,
            $renderStatus,
            $outputPage,
            $parserOptions,
            $textOptions,
        );
 
        if ( !$renderStatus->isOK() ) {
            return true;
        }
 
        $pOutput = $renderStatus->getValue();
        $this->doOutputMetaData( $pOutput, $outputPage );
        return true;
    }
 
    private function doOutputMetaData( ?ParserOutput $pOutput, OutputPage $outputPage ) {
        # Adjust title for main page & pages with displaytitle
        if ( $pOutput ) {
            $this->adjustDisplayTitle( $pOutput );
 
            // It would be nice to automatically set this during the first call
            // to OutputPage::addParserOutputMetadata, but we can't because doing
            // so would break non-pageview actions where OutputPage::getContLangForJS
            // has different requirements.
            $pageLang = $pOutput->getLanguage();
            if ( $pageLang ) {
                $outputPage->setContentLangForJS( $pageLang );
            }
        }
 
        # Check for any __NOINDEX__ tags on the page using $pOutput
        $policy = $this->getRobotPolicy( 'view', $pOutput ?: null );
        $outputPage->getMetadata()->setIndexPolicy( $policy['index'] );
        $outputPage->setFollowPolicy( $policy['follow'] ); // FIXME: test this
 
        $this->mParserOutput = $pOutput;
    }
 
    private function postProcessOutput(
        ParserOutput $pOutput, ParserOptions $parserOptions, array $textOptions, Skin $skin
    ): ParserOutput {
        $skinOptions = $skin->getOptions();
        $textOptions += [
            // T371022, T410923
            'allowClone' => $this->getContext()->getConfig()->get( MainConfigNames::CloneArticleParserOutput ),
            'skin' => $skin,
            'injectTOC' => $skinOptions['toc'],
        ];
        $pipeline = MediaWikiServices::getInstance()->getDefaultOutputPipeline();
        $pOutput = $pipeline->run( $pOutput, $parserOptions, $textOptions );
        return $pOutput;
    }
 
    private function doOutputFromPostProcessedParserCache(
        ParserOutput $pOutput,
        OutputPage $outputPage,
    ) {
        # Ensure that UI elements requiring revision ID have
        # the correct version information.
        $oldid = $pOutput->getCacheRevisionId() ?? $this->getRevIdFetched();
        $outputPage->setRevisionId( $oldid );
        $outputPage->setRevisionIsCurrent( $oldid === $this->mPage->getLatest() );
 
        $outputPage->addPostProcessedParserOutput( $pOutput );
 
        # Preload timestamp to avoid a DB hit
        $cachedTimestamp = $pOutput->getRevisionTimestamp();
        if ( $cachedTimestamp !== null ) {
            $outputPage->getMetadata()->setRevisionTimestamp( $cachedTimestamp );
            $this->mPage->setTimestamp( $cachedTimestamp );
        }
    }
 
    private function doOutputFromRenderStatus(
        RevisionRecord $rev,
        Status $renderStatus,
        OutputPage $outputPage,
        ParserOptions $parserOptions,
        array $textOptions,
    ) {
        $context = $this->getContext();
        if ( !$renderStatus->isOK() ) {
            $this->showViewError( $renderStatus->getWikiText(
                false, 'view-pool-error', $context->getLanguage()
            ) );
            return;
        }
 
        $pOutput = $renderStatus->getValue();
 
        // Cache stale ParserOutput object with a short expiry
        if ( $renderStatus->hasMessage( 'view-pool-dirty-output' ) ) {
            $outputPage->lowerCdnMaxage( $context->getConfig()->get( MainConfigNames::CdnMaxageStale ) );
            $outputPage->setLastModified( $pOutput->getCacheTime() );
            $staleReason = $renderStatus->hasMessage( 'view-pool-contention' )
                ? $context->msg( 'view-pool-contention' )->escaped()
                : $context->msg( 'view-pool-timeout' )->escaped();
            $outputPage->addHTML( "<!-- parser cache is expired, " .
                "sending anyway due to $staleReason-->\n" );
 
            // Ensure OutputPage knowns the id from the dirty cache, but keep the current flag (T341013)
            $cachedId = $pOutput->getCacheRevisionId();
            if ( $cachedId !== null ) {
                $outputPage->setRevisionId( $cachedId );
                $outputPage->getMetadata()->setRevisionTimestamp( $pOutput->getRevisionTimestamp() );
            }
        }
 
        // TODO this will probably need to be conditional on cache access and/or hoisted one level above but for
        // now let's keep things in the same place and avoid editing StatusValues.
        if ( !$this->usePostprocessCache ) {
            $pOutput = $this->postProcessOutput( $pOutput, $parserOptions, $textOptions, $outputPage->getSkin() );
        }
 
        $outputPage->addPostProcessedParserOutput( $pOutput );
 
        if ( $this->getRevisionRedirectTarget( $rev ) ) {
            $outputPage->addSubtitle( "<span id=\"redirectsub\">" .
                $context->msg( 'redirectpagesub' )->parse() . "</span>" );
        }
    }
 
    private function getRevisionRedirectTarget( RevisionRecord $revision ) {
        // TODO: find a *good* place for the code that determines the redirect target for
        // a given revision!
        // NOTE: Use main slot content. Compare code in DerivedPageDataUpdater::revisionIsRedirect.
        $content = $revision->getContent( SlotRecord::MAIN );
        return $content ? $content->getRedirectTarget() : null;
    }
 
    public function adjustDisplayTitle( ParserOutput $pOutput ) {
        $out = $this->getContext()->getOutput();
 
        # Adjust the title if it was set by displaytitle, -{T|}- or language conversion
        $titleText = $pOutput->getTitleText();
        if ( $titleText !== '' ) {
            # XXX T36514 / T314399 / T306440: we should have a language here
            # and split the namespace
            $out->setPageTitle( $titleText );
            $out->setDisplayTitle( $titleText );
        }
    }
 
    protected function showDiffPage() {
        $context = $this->getContext();
        $outputPage = $context->getOutput();
        $outputPage->addBodyClasses( 'mw-article-diff' );
        $request = $context->getRequest();
        $diff = $request->getVal( 'diff' );
        $rcid = $request->getInt( 'rcid' );
        $purge = $request->getRawVal( 'action' ) === 'purge';
        $unhide = $request->getInt( 'unhide' ) === 1;
        $oldid = $this->getOldID();
 
        $rev = $this->fetchRevisionRecord();
 
        if ( !$rev ) {
            // T213621: $rev maybe null due to either lack of permission to view the
            // revision or actually not existing. So let's try loading it from the id
            $rev = $this->revisionStore->getRevisionById( $oldid );
            if ( $rev ) {
                // Revision exists but $user lacks permission to diff it.
                // Do nothing here.
                // The $rev will later be used to create standard diff elements however.
            } else {
                $outputPage->setPageTitleMsg( $context->msg( 'errorpagetitle' ) );
                $msg = $context->msg( 'difference-missing-revision' )
                    ->params( $oldid )
                    ->numParams( 1 )
                    ->parseAsBlock();
                $outputPage->addHTML( $msg );
                return;
            }
        }
 
        $services = MediaWikiServices::getInstance();
 
        $contentHandler = $services
            ->getContentHandlerFactory()
            ->getContentHandler(
                $rev->getMainContentModel()
            );
        $de = $contentHandler->createDifferenceEngine(
            $context,
            $oldid,
            $diff,
            $rcid,
            $purge,
            $unhide
        );
 
        $diffType = $request->getVal( 'diff-type' );
 
        if ( $diffType === null ) {
            $diffType = $this->userOptionsLookup
                ->getOption( $context->getUser(), 'diff-type' );
        } else {
            $de->setExtraQueryParams( [ 'diff-type' => $diffType ] );
        }
 
        $de->setSlotDiffOptions( [
            'diff-type' => $diffType,
            'expand-url' => $this->viewIsRenderAction,
            'inline-toggle' => true,
        ] );
        $de->showDiffPage( $this->isDiffOnlyView() );
 
        // Run view updates for the newer revision being diffed (and shown
        // below the diff if not diffOnly).
        [ , $new ] = $de->mapDiffPrevNext( $oldid, $diff );
        // New can be false, convert it to 0 - this conveniently means the latest revision
        $this->mPage->doViewUpdates( $context->getAuthority(), (int)$new );
 
        // Add link to help page; see T321569
        $context->getOutput()->addHelpLink( 'Help:Diff' );
    }
 
    protected function isDiffOnlyView(): bool {
        return $this->getContext()->getRequest()->getBool(
            'diffonly',
            $this->userOptionsLookup->getBoolOption( $this->getContext()->getUser(), 'diffonly' )
        );
    }
 
    public function getRobotPolicy( $action, ?ParserOutput $pOutput = null ) {
        $context = $this->getContext();
        $mainConfig = $context->getConfig();
        $articleRobotPolicies = $mainConfig->get( MainConfigNames::ArticleRobotPolicies );
        $namespaceRobotPolicies = $mainConfig->get( MainConfigNames::NamespaceRobotPolicies );
        $defaultRobotPolicy = $mainConfig->get( MainConfigNames::DefaultRobotPolicy );
        $title = $this->getTitle();
        $ns = $title->getNamespace();
 
        # Don't index user and user talk pages for blocked users (T13443)
        if ( $ns === NS_USER || $ns === NS_USER_TALK ) {
            $specificTarget = null;
            $vagueTarget = null;
            $titleText = $title->getText();
            if ( IPUtils::isValid( $titleText ) ) {
                $vagueTarget = $titleText;
            } else {
                $specificTarget = $title->getRootText();
            }
            $block = $this->blockStore->newFromTarget(
                $specificTarget, $vagueTarget, false, DatabaseBlockStore::AUTO_NONE );
            if ( $block instanceof DatabaseBlock ) {
                return [
                    'index' => 'noindex',
                    'follow' => 'nofollow'
                ];
            }
        }
 
        if ( $this->mPage->getId() === 0 || $this->getOldID() ) {
            # Non-articles (special pages etc), and old revisions
            return [
                'index' => 'noindex',
                'follow' => 'nofollow'
            ];
        } elseif ( $context->getOutput()->isPrintable() ) {
            # Discourage indexing of printable versions, but encourage following
            return [
                'index' => 'noindex',
                'follow' => 'follow'
            ];
        } elseif ( $context->getRequest()->getInt( 'curid' ) ) {
            # For ?curid=x urls, disallow indexing
            return [
                'index' => 'noindex',
                'follow' => 'follow'
            ];
        }
 
        # Otherwise, construct the policy based on the various config variables.
        $policy = self::formatRobotPolicy( $defaultRobotPolicy );
 
        if ( isset( $namespaceRobotPolicies[$ns] ) ) {
            # Honour customised robot policies for this namespace
            $policy = array_merge(
                $policy,
                self::formatRobotPolicy( $namespaceRobotPolicies[$ns] )
            );
        }
        if ( $title->canUseNoindex() && $pOutput && $pOutput->getIndexPolicy() ) {
            # __INDEX__ and __NOINDEX__ magic words, if allowed. Incorporates
            # a final check that we have really got the parser output.
            $policy['index'] = $pOutput->getIndexPolicy();
        }
 
        if ( isset( $articleRobotPolicies[$title->getPrefixedText()] ) ) {
            # (T16900) site config can override user-defined __INDEX__ or __NOINDEX__
            $policy = array_merge(
                $policy,
                self::formatRobotPolicy( $articleRobotPolicies[$title->getPrefixedText()] )
            );
        }
 
        return $policy;
    }
 
    public static function formatRobotPolicy( $policy ) {
        if ( is_array( $policy ) ) {
            return $policy;
        } elseif ( !$policy ) {
            return [];
        }
 
        $arr = [];
        foreach ( explode( ',', $policy ) as $var ) {
            $var = trim( $var );
            if ( $var === 'index' || $var === 'noindex' ) {
                $arr['index'] = $var;
            } elseif ( $var === 'follow' || $var === 'nofollow' ) {
                $arr['follow'] = $var;
            }
        }
 
        return $arr;
    }
 
    public function showRedirectedFromHeader() {
        $context = $this->getContext();
        $redirectSources = $context->getConfig()->get( MainConfigNames::RedirectSources );
        $outputPage = $context->getOutput();
        $request = $context->getRequest();
        $rdfrom = $request->getVal( 'rdfrom' );
 
        // Construct a URL for the current page view, but with the target title
        $query = $request->getQueryValues();
        unset( $query['rdfrom'] );
        unset( $query['title'] );
        if ( $this->getTitle()->isRedirect() ) {
            // Prevent double redirects
            $query['redirect'] = 'no';
        }
        $redirectTargetUrl = $this->getTitle()->getLinkURL( $query );
 
        if ( $this->mRedirectedFrom ) {
            // This is an internally redirected page view.
            // We'll need a backlink to the source page for navigation.
            if ( $this->getHookRunner()->onArticleViewRedirect( $this ) ) {
                $redir = $this->linkRenderer->makeKnownLink(
                    $this->mRedirectedFrom,
                    null,
                    [],
                    [ 'redirect' => 'no' ]
                );
 
                $outputPage->addSubtitle( "<span class=\"mw-redirectedfrom\">" .
                    $context->msg( 'redirectedfrom' )->rawParams( $redir )->parse()
                . "</span>" );
 
                // Add the script to update the displayed URL and
                // set the fragment if one was specified in the redirect
                $outputPage->addJsConfigVars( [
                    'wgInternalRedirectTargetUrl' => $redirectTargetUrl,
                ] );
                $outputPage->addModules( 'mediawiki.action.view.redirect' );
 
                // Add a <link rel="canonical"> tag
                $outputPage->setCanonicalUrl( $this->getTitle()->getCanonicalURL() );
 
                // Tell the output object that the user arrived at this article through a redirect
                $outputPage->setRedirectedFrom( $this->mRedirectedFrom );
 
                return true;
            }
        } elseif ( $rdfrom ) {
            // This is an externally redirected view, from some other wiki.
            // If it was reported from a trusted site, supply a backlink.
            if ( $redirectSources && preg_match( $redirectSources, $rdfrom ) ) {
                $redir = $this->linkRenderer->makeExternalLink( $rdfrom, $rdfrom, $this->getTitle() );
                $outputPage->addSubtitle( "<span class=\"mw-redirectedfrom\">" .
                    $context->msg( 'redirectedfrom' )->rawParams( $redir )->parse()
                . "</span>" );
 
                // Add the script to update the displayed URL
                $outputPage->addJsConfigVars( [
                    'wgInternalRedirectTargetUrl' => $redirectTargetUrl,
                ] );
                $outputPage->addModules( 'mediawiki.action.view.redirect' );
 
                return true;
            }
        }
 
        return false;
    }
 
    public function showNamespaceHeader() {
        if (
            !$this->getTitle()->isTalkPage() &&
            $this->getTitle()->exists() &&
            !$this->getContext()->msg( 'subjectpageheader' )->isDisabled()
        ) {
            $this->getContext()->getOutput()->wrapWikiMsg(
                "<div class=\"mw-subjectpageheader\">\n$1\n</div>",
                [ 'subjectpageheader' ]
            );
        }
 
        if (
            $this->getTitle()->isTalkPage() &&
            !$this->getContext()->msg( 'talkpageheader' )->isDisabled()
        ) {
            $this->getContext()->getOutput()->wrapWikiMsg(
                "<div class=\"mw-talkpageheader\">\n$1\n</div>",
                [ 'talkpageheader' ]
            );
        }
    }
 
    public function showViewFooter() {
        # check if we're displaying a [[User talk:x.x.x.x]] anonymous talk page
        if ( $this->getTitle()->getNamespace() === NS_USER_TALK
            && IPUtils::isValid( $this->getTitle()->getText() )
        ) {
            $this->getContext()->getOutput()->addWikiMsg( 'anontalkpagetext' );
        }
 
        // Show a footer allowing the user to patrol the shown revision or page if possible
        $patrolFooterShown = $this->showPatrolFooter();
 
        $this->getHookRunner()->onArticleViewFooter( $this, $patrolFooterShown );
    }
 
    public function showPatrolFooter() {
        $context = $this->getContext();
        $mainConfig = $context->getConfig();
        $useNPPatrol = $mainConfig->get( MainConfigNames::UseNPPatrol );
        $useRCPatrol = $mainConfig->get( MainConfigNames::UseRCPatrol );
        $useFilePatrol = $mainConfig->get( MainConfigNames::UseFilePatrol );
        $fileMigrationStage = $mainConfig->get( MainConfigNames::FileSchemaMigrationStage );
        // Allow hooks to decide whether to not output this at all
        if ( !$this->getHookRunner()->onArticleShowPatrolFooter( $this ) ) {
            return false;
        }
 
        $outputPage = $context->getOutput();
        $user = $context->getUser();
        $title = $this->getTitle();
        $rc = false;
 
        if ( !$context->getAuthority()->probablyCan( 'patrol', $title )
            || !( $useRCPatrol || $useNPPatrol
                || ( $useFilePatrol && $title->inNamespace( NS_FILE ) ) )
        ) {
            // Patrolling is disabled or the user isn't allowed to
            return false;
        }
 
        if ( $this->mRevisionRecord
            && !RecentChange::isInRCLifespan( $this->mRevisionRecord->getTimestamp(), 21600 )
        ) {
            // The current revision is already older than what could be in the RC table
            // 6h tolerance because the RC might not be cleaned out regularly
            return false;
        }
 
        // Check for cached results
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        $key = $cache->makeKey( 'unpatrollable-page', $title->getArticleID() );
        if ( $cache->get( $key ) ) {
            return false;
        }
 
        $dbr = $this->dbProvider->getReplicaDatabase();
        $oldestRevisionRow = $dbr->newSelectQueryBuilder()
            ->select( [ 'rev_id', 'rev_timestamp' ] )
            ->from( 'revision' )
            ->where( [ 'rev_page' => $title->getArticleID() ] )
            ->orderBy( [ 'rev_timestamp', 'rev_id' ] )
            ->caller( __METHOD__ )->fetchRow();
        $oldestRevisionTimestamp = $oldestRevisionRow ? $oldestRevisionRow->rev_timestamp : false;
 
        // New page patrol: Get the timestamp of the oldest revision which
        // the revision table holds for the given page. Then we look
        // whether it's within the RC lifespan and if it is, we try
        // to get the recentchanges row belonging to that entry.
        $recentPageCreation = false;
        if ( $oldestRevisionTimestamp
            && RecentChange::isInRCLifespan( $oldestRevisionTimestamp, 21600 )
        ) {
            // 6h tolerance because the RC might not be cleaned out regularly
            $recentPageCreation = true;
            $rc = $this->recentChangeLookup->getRecentChangeByConds(
                [
                    'rc_this_oldid' => intval( $oldestRevisionRow->rev_id ),
                    // Avoid selecting a categorization entry
                    'rc_source' => RecentChange::SRC_NEW,
                ],
                __METHOD__
            );
            if ( $rc ) {
                // Use generic patrol message for new pages
                $markPatrolledMsg = $context->msg( 'markaspatrolledtext' );
            }
        }
 
        // File patrol: Get the timestamp of the latest upload for this page,
        // check whether it is within the RC lifespan and if it is, we try
        // to get the recentchanges row belonging to that entry
        // (with rc_source = SRC_LOG, rc_log_type = upload).
        $recentFileUpload = false;
        if ( ( !$rc || $rc->getAttribute( 'rc_patrolled' ) ) && $useFilePatrol
            && $title->getNamespace() === NS_FILE ) {
            // Retrieve timestamp from the current file (latest upload)
            if ( $fileMigrationStage & SCHEMA_COMPAT_READ_OLD ) {
                $newestUploadTimestamp = $dbr->newSelectQueryBuilder()
                    ->select( 'img_timestamp' )
                    ->from( 'image' )
                    ->where( [ 'img_name' => $title->getDBkey() ] )
                    ->caller( __METHOD__ )->fetchField();
            } else {
                $newestUploadTimestamp = $dbr->newSelectQueryBuilder()
                    ->select( 'fr_timestamp' )
                    ->from( 'file' )
                    ->join( 'filerevision', null, 'file_latest = fr_id' )
                    ->where( [ 'file_name' => $title->getDBkey() ] )
                    ->caller( __METHOD__ )->fetchField();
            }
 
            if ( $newestUploadTimestamp
                && RecentChange::isInRCLifespan( $newestUploadTimestamp, 21600 )
            ) {
                // 6h tolerance because the RC might not be cleaned out regularly
                $recentFileUpload = true;
                $rc = $this->recentChangeLookup->getRecentChangeByConds(
                    [
                        'rc_source' => RecentChange::SRC_LOG,
                        'rc_log_type' => 'upload',
                        'rc_timestamp' => $newestUploadTimestamp,
                        'rc_namespace' => NS_FILE,
                        'rc_cur_id' => $title->getArticleID()
                    ],
                    __METHOD__
                );
                if ( $rc ) {
                    // Use patrol message specific to files
                    $markPatrolledMsg = $context->msg( 'markaspatrolledtext-file' );
                }
            }
        }
 
        if ( !$recentPageCreation && !$recentFileUpload ) {
            // Page creation and latest upload (for files) is too old to be in RC
 
            // We definitely can't patrol so cache the information
            // When a new file version is uploaded, the cache is cleared
            $cache->set( $key, '1' );
 
            return false;
        }
 
        if ( !$rc ) {
            // Don't cache: This can be hit if the page gets accessed very fast after
            // its creation / latest upload or in case we have high replica DB lag. In case
            // the revision is too old, we will already return above.
            return false;
        }
 
        if ( $rc->getAttribute( 'rc_patrolled' ) ) {
            // Patrolled RC entry around
 
            // Cache the information we gathered above in case we can't patrol
            // Don't cache in case we can patrol as this could change
            $cache->set( $key, '1' );
 
            return false;
        }
 
        if ( $rc->getPerformerIdentity()->equals( $user ) ) {
            // Don't show a patrol link for own creations/uploads. If the user could
            // patrol them, they already would be patrolled
            return false;
        }
 
        $outputPage->getMetadata()->setPreventClickjacking( true );
        $outputPage->addModules( 'mediawiki.misc-authed-curate' );
 
        $link = $this->linkRenderer->makeKnownLink(
            $title,
            new HtmlArmor( '<button class="cdx-button cdx-button--action-progressive">'
                // @phan-suppress-next-line PhanPossiblyUndeclaredVariable $markPatrolledMsg is always set
                . $markPatrolledMsg->escaped() . '</button>' ),
            [],
            [
                'action' => 'markpatrolled',
                'rcid' => $rc->getAttribute( 'rc_id' ),
            ]
        );
 
        $outputPage->addModuleStyles( 'mediawiki.action.styles' );
        $outputPage->addHTML( "<div class='patrollink' data-mw='interface'>$link</div>" );
 
        return true;
    }
 
    public static function purgePatrolFooterCache( $articleID ) {
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        $cache->delete( $cache->makeKey( 'unpatrollable-page', $articleID ) );
    }
 
    public function showMissingArticle() {
        $context = $this->getContext();
        $send404Code = $context->getConfig()->get( MainConfigNames::Send404Code );
 
        $outputPage = $context->getOutput();
        // Whether the page is a root user page of an existing user (but not a subpage)
        $validUserPage = false;
 
        $title = $this->getTitle();
 
        $services = MediaWikiServices::getInstance();
 
        $contextUser = $context->getUser();
 
        # Show info in user (talk) namespace. Does the user exist? Are they blocked?
        if ( $title->getNamespace() === NS_USER
            || $title->getNamespace() === NS_USER_TALK
        ) {
            $rootPart = $title->getRootText();
            $userFactory = $services->getUserFactory();
            $user = $userFactory->newFromNameOrIp( $rootPart );
 
            if ( $user && $user->isRegistered() && $user->isHidden() &&
                !$context->getAuthority()->isAllowed( 'hideuser' )
            ) {
                // T120883 if the user is hidden and the viewer cannot see hidden
                // users, pretend like it does not exist at all.
                $user = false;
            }
 
            if ( !( $user && $user->isRegistered() ) && !$this->userNameUtils->isIP( $rootPart ) ) {
                $this->addMessageBoxStyles( $outputPage );
                // User does not exist
                $outputPage->addHTML( Html::warningBox(
                    $context->msg( 'userpage-userdoesnotexist-view', wfEscapeWikiText( $rootPart ) )->parse(),
                    'mw-userpage-userdoesnotexist'
                ) );
 
                // Show renameuser log extract
                LogEventsList::showLogExtract(
                    $outputPage,
                    'renameuser',
                    Title::makeTitleSafe( NS_USER, $rootPart ),
                    '',
                    [
                        'lim' => 10,
                        'showIfEmpty' => false,
                        'msgKey' => [ 'renameuser-renamed-notice', $title->getBaseText() ]
                    ]
                );
            } else {
                $validUserPage = !$title->isSubpage();
 
                $blockLogBox = LogEventsList::getBlockLogWarningBox(
                    $this->blockStore,
                    $services->getNamespaceInfo(),
                    $this->getContext(),
                    $this->linkRenderer,
                    $user,
                    $title
                );
                if ( $blockLogBox !== null ) {
                    $outputPage->addHTML( $blockLogBox );
                }
            }
        }
 
        $this->getHookRunner()->onShowMissingArticle( $this );
 
        # Show delete and move logs if there were any such events.
        # The logging query can DOS the site when bots/crawlers cause 404 floods,
        # so be careful showing this. 404 pages must be cheap as they are hard to cache.
        $dbCache = MediaWikiServices::getInstance()->getMainObjectStash();
        $key = $dbCache->makeKey( 'page-recent-delete', md5( $title->getPrefixedText() ) );
        $isRegistered = $contextUser->isRegistered();
        $sessionExists = $context->getRequest()->getSession()->isPersistent();
 
        if ( $isRegistered || $dbCache->get( $key ) || $sessionExists ) {
            $logTypes = [ 'delete', 'move', 'protect', 'merge' ];
 
            $dbr = $this->dbProvider->getReplicaDatabase();
 
            $conds = [ $dbr->expr( 'log_action', '!=', 'revision' ) ];
            // Give extensions a chance to hide their (unrelated) log entries
            $this->getHookRunner()->onArticle__MissingArticleConditions( $conds, $logTypes );
            LogEventsList::showLogExtract(
                $outputPage,
                $logTypes,
                $title,
                '',
                [
                    'lim' => 10,
                    'conds' => $conds,
                    'showIfEmpty' => false,
                    'msgKey' => [ $isRegistered || $sessionExists
                        ? 'moveddeleted-notice'
                        : 'moveddeleted-notice-recent'
                    ]
                ]
            );
        }
 
        if ( !$this->mPage->hasViewableContent() && $send404Code && !$validUserPage ) {
            // If there's no backing content, send a 404 Not Found
            // for better machine handling of broken links.
            $context->getRequest()->response()->statusHeader( 404 );
        }
 
        // Also apply the robot policy for nonexisting pages (even if a 404 was used)
        $policy = $this->getRobotPolicy( 'view' );
        $outputPage->getMetadata()->setIndexPolicy( $policy['index'] );
        $outputPage->setFollowPolicy( $policy['follow'] );
 
        $hookResult = $this->getHookRunner()->onBeforeDisplayNoArticleText( $this );
 
        if ( !$hookResult ) {
            return;
        }
 
        # Show error message
        $oldid = $this->getOldID();
        if ( !$oldid && $title->getNamespace() === NS_MEDIAWIKI && $title->hasSourceText() ) {
            $text = $this->getTitle()->getDefaultMessageText() ?? '';
            $outputPage->addWikiTextAsContent( $text );
        } else {
            if ( $oldid ) {
                $text = $this->getMissingRevisionMsg( $oldid )->plain();
            } elseif ( $context->getAuthority()->probablyCan( 'edit', $title ) ) {
                $message = $isRegistered ? 'noarticletext' : 'noarticletextanon';
                $text = $context->msg( $message )->plain();
            } else {
                $text = $context->msg( 'noarticletext-nopermission' )->plain();
            }
 
            $dir = $context->getLanguage()->getDir();
            $lang = $context->getLanguage()->getHtmlCode();
            $outputPage->addWikiTextAsInterface( Html::openElement( 'div', [
                'class' => "noarticletext mw-content-$dir",
                'dir' => $dir,
                'lang' => $lang,
            ] ) . "\n$text\n</div>" );
        }
    }
 
    private function showViewError( string $errortext ) {
        $outputPage = $this->getContext()->getOutput();
        $outputPage->setPageTitleMsg( $this->getContext()->msg( 'errorpagetitle' ) );
        $outputPage->disableClientCache();
        $outputPage->setRobotPolicy( 'noindex,nofollow' );
        $outputPage->clearHTML();
        $this->addMessageBoxStyles( $outputPage );
        $outputPage->addHTML( Html::errorBox( $outputPage->parseAsContent( $errortext ) ) );
    }
 
    public function showDeletedRevisionHeader() {
        if ( !$this->mRevisionRecord->isDeleted( RevisionRecord::DELETED_TEXT ) ) {
            // Not deleted
            return true;
        }
        $outputPage = $this->getContext()->getOutput();
        // Used in wikilinks, should not contain whitespaces
        $titleText = $this->getTitle()->getPrefixedURL();
        $this->addMessageBoxStyles( $outputPage );
        // If the user is not allowed to see it...
        if ( !$this->mRevisionRecord->userCan(
            RevisionRecord::DELETED_TEXT,
            $this->getContext()->getAuthority()
        ) ) {
            $outputPage->addHTML(
                Html::warningBox(
                    $outputPage->msg( 'rev-deleted-text-permission', $titleText )->parse(),
                    'plainlinks'
                )
            );
 
            return false;
        // If the user needs to confirm that they want to see it...
        } elseif ( $this->getContext()->getRequest()->getInt( 'unhide' ) !== 1 ) {
            # Give explanation and add a link to view the revision...
            $oldid = intval( $this->getOldID() );
            $link = $this->getTitle()->getFullURL( "oldid={$oldid}&unhide=1" );
            $msg = $this->mRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) ?
                'rev-suppressed-text-unhide' : 'rev-deleted-text-unhide';
            $outputPage->addHTML(
                Html::warningBox(
                    $outputPage->msg( $msg, $link )->parse(),
                    'plainlinks'
                )
            );
 
            return false;
        // We are allowed to see...
        } else {
            $msg = $this->mRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED )
                ? [ 'rev-suppressed-text-view', $titleText ]
                : [ 'rev-deleted-text-view', $titleText ];
            $outputPage->addHTML(
                Html::warningBox(
                    $outputPage->msg( $msg[0], $msg[1] )->parse(),
                    'plainlinks'
                )
            );
 
            return true;
        }
    }
 
    private function addMessageBoxStyles( OutputPage $outputPage ) {
        $outputPage->addModuleStyles( [
            'mediawiki.codex.messagebox.styles',
        ] );
    }
 
    public function setOldSubtitle( $oldid = 0 ) {
        if ( !$this->getHookRunner()->onDisplayOldSubtitle( $this, $oldid ) ) {
            return;
        }
 
        $context = $this->getContext();
        $unhide = $context->getRequest()->getInt( 'unhide' ) === 1;
 
        # Cascade unhide param in links for easy deletion browsing
        $extraParams = [];
        if ( $unhide ) {
            $extraParams['unhide'] = 1;
        }
 
        if ( $this->mRevisionRecord && $this->mRevisionRecord->getId() === $oldid ) {
            $revisionRecord = $this->mRevisionRecord;
        } else {
            $revisionRecord = $this->revisionStore->getRevisionById( $oldid );
        }
        if ( !$revisionRecord ) {
            throw new LogicException( 'There should be a revision record at this point.' );
        }
 
        $timestamp = $revisionRecord->getTimestamp();
 
        $current = ( $oldid == $this->mPage->getLatest() );
        $language = $context->getLanguage();
        $user = $context->getUser();
 
        $td = $language->userTimeAndDate( $timestamp, $user );
        $tddate = $language->userDate( $timestamp, $user );
        $tdtime = $language->userTime( $timestamp, $user );
 
        # Show user links if allowed to see them. If hidden, then show them only if requested...
        $userlinks = Linker::revUserTools( $revisionRecord, !$unhide );
 
        $infomsg = $current && !$context->msg( 'revision-info-current' )->isDisabled()
            ? 'revision-info-current'
            : 'revision-info';
 
        $outputPage = $context->getOutput();
        $outputPage->addModuleStyles( [
            'mediawiki.action.styles',
            'mediawiki.interface.helpers.styles'
        ] );
 
        $revisionUser = $revisionRecord->getUser();
        $revisionInfo = "<div id=\"mw-{$infomsg}\">" .
            $context->msg( $infomsg, $td )
                ->rawParams( $userlinks )
                ->params(
                    $revisionRecord->getId(),
                    $tddate,
                    $tdtime,
                    $revisionUser ? $revisionUser->getName() : ''
                )
                ->rawParams( $this->commentFormatter->formatRevision(
                    $revisionRecord,
                    $user,
                    true,
                    !$unhide
                ) )
                ->parse() .
            "</div>";
 
        $lnk = $current
            ? $context->msg( 'currentrevisionlink' )->escaped()
            : $this->linkRenderer->makeKnownLink(
                $this->getTitle(),
                $context->msg( 'currentrevisionlink' )->text(),
                [],
                $extraParams
            );
        $curdiff = $current
            ? $context->msg( 'diff' )->escaped()
            : $this->linkRenderer->makeKnownLink(
                $this->getTitle(),
                $context->msg( 'diff' )->text(),
                [],
                [
                    'diff' => 'cur',
                    'oldid' => $oldid
                ] + $extraParams
            );
        $prevExist = (bool)$this->revisionStore->getPreviousRevision( $revisionRecord );
        $prevlink = $prevExist
            ? $this->linkRenderer->makeKnownLink(
                $this->getTitle(),
                $context->msg( 'previousrevision' )->text(),
                [],
                [
                    'direction' => 'prev',
                    'oldid' => $oldid
                ] + $extraParams
            )
            : $context->msg( 'previousrevision' )->escaped();
        $prevdiff = $prevExist
            ? $this->linkRenderer->makeKnownLink(
                $this->getTitle(),
                $context->msg( 'diff' )->text(),
                [],
                [
                    'diff' => 'prev',
                    'oldid' => $oldid
                ] + $extraParams
            )
            : $context->msg( 'diff' )->escaped();
        $nextlink = $current
            ? $context->msg( 'nextrevision' )->escaped()
            : $this->linkRenderer->makeKnownLink(
                $this->getTitle(),
                $context->msg( 'nextrevision' )->text(),
                [],
                [
                    'direction' => 'next',
                    'oldid' => $oldid
                ] + $extraParams
            );
        $nextdiff = $current
            ? $context->msg( 'diff' )->escaped()
            : $this->linkRenderer->makeKnownLink(
                $this->getTitle(),
                $context->msg( 'diff' )->text(),
                [],
                [
                    'diff' => 'next',
                    'oldid' => $oldid
                ] + $extraParams
            );
 
        $cdel = Linker::getRevDeleteLink(
            $context->getAuthority(),
            $revisionRecord,
            $this->getTitle()
        );
        if ( $cdel !== '' ) {
            $cdel .= ' ';
        }
 
        // the outer div is need for styling the revision info and nav in MobileFrontend
        $this->addMessageBoxStyles( $outputPage );
        $outputPage->addSubtitle(
            Html::warningBox(
                $revisionInfo .
                "<div id=\"mw-revision-nav\">" . $cdel .
                $context->msg( 'revision-nav' )->rawParams(
                    $prevdiff, $prevlink, $lnk, $curdiff, $nextlink, $nextdiff
                )->escaped() . "</div>",
                'mw-revision'
            )
        );
    }
 
    public static function getRedirectHeaderHtml( Language $lang, Title $target, $forceKnown = false ) {
        wfDeprecated( __METHOD__, '1.41' );
        $linkRenderer = MediaWikiServices::getInstance()->getLinkRenderer();
        return $linkRenderer->makeRedirectHeader( $lang, $target, $forceKnown );
    }
 
    public function addHelpLink( $to, $overrideBaseUrl = false ) {
        $out = $this->getContext()->getOutput();
        $msg = $out->msg( 'namespace-' . $this->getTitle()->getNamespace() . '-helppage' );
 
        if ( !$msg->isDisabled() ) {
            $title = Title::newFromText( $msg->plain() );
            if ( $title instanceof Title ) {
                $out->addHelpLink( $title->getLocalURL(), true );
            }
        } else {
            $out->addHelpLink( $to, $overrideBaseUrl );
        }
    }
 
    public function render() {
        $this->getContext()->getRequest()->response()->header( 'X-Robots-Tag: noindex' );
        $this->getContext()->getOutput()->setArticleBodyOnly( true );
        // We later set 'enableSectionEditLinks=false' based on this; also used by ImagePage
        $this->viewIsRenderAction = true;
        $this->view();
    }
 
    public function protect() {
        $form = new ProtectionForm( $this );
        $form->execute();
    }
 
    public function unprotect() {
        $this->protect();
    }
 
    /* Caching functions */
 
    protected function tryFileCache() {
        static $called = false;
 
        if ( $called ) {
            wfDebug( "Article::tryFileCache(): called twice!?" );
            return false;
        }
 
        $called = true;
        if ( $this->isFileCacheable() ) {
            $cache = new HTMLFileCache( $this->getTitle(), 'view' );
            if ( $cache->isCacheGood( $this->mPage->getTouched() ) ) {
                wfDebug( "Article::tryFileCache(): about to load file" );
                $cache->loadFromFileCache( $this->getContext() );
                return true;
            } else {
                wfDebug( "Article::tryFileCache(): starting buffer" );
                ob_start( $cache->saveToFileCache( ... ) );
            }
        } else {
            wfDebug( "Article::tryFileCache(): not cacheable" );
        }
 
        return false;
    }
 
    public function isFileCacheable( $mode = HTMLFileCache::MODE_NORMAL ) {
        $cacheable = false;
 
        if ( HTMLFileCache::useFileCache( $this->getContext(), $mode ) ) {
            $cacheable = $this->mPage->getId()
                && !$this->mRedirectedFrom && !$this->getTitle()->isRedirect();
            // Extension may have reason to disable file caching on some pages.
            if ( $cacheable ) {
                $cacheable = $this->getHookRunner()->onIsFileCacheable( $this ) ?? false;
            }
        }
 
        return $cacheable;
    }
 
    public function getParserOutput( $oldid = null, ?UserIdentity $user = null ) {
        if ( $user === null ) {
            $parserOptions = $this->getParserOptions();
        } else {
            $parserOptions = $this->mPage->makeParserOptions( $user );
            $parserOptions->setRenderReason( $this->getOldID() ? 'page_view_oldid' : 'page_view' );
        }
 
        return $this->mPage->getParserOutput( $parserOptions, $oldid );
    }
 
    public function getParserOptions() {
        $parserOptions = $this->mPage->makeParserOptions( $this->getContext() );
        $parserOptions->setRenderReason( $this->getOldID() ? 'page_view_oldid' : 'page_view' );
        return $parserOptions;
    }
 
    public function setContext( $context ) {
        $this->mContext = $context;
    }
 
    public function getContext(): IContextSource {
        if ( $this->mContext instanceof IContextSource ) {
            return $this->mContext;
        } else {
            wfDebug( __METHOD__ . " called and \$mContext is null. " .
                "Return RequestContext::getMain()" );
            return RequestContext::getMain();
        }
    }
 
    public function getActionOverrides() {
        return $this->mPage->getActionOverrides();
    }
 
    private function getMissingRevisionMsg( int $oldid ): Message {
        // T251066: Try loading the revision from the archive table.
        // Show link to view it if it exists and the user has permission to view it.
        // (Ignore the given title, if any; look it up from the revision instead.)
        $context = $this->getContext();
        $revRecord = $this->archivedRevisionLookup->getArchivedRevisionRecord( null, $oldid );
        if (
            $revRecord &&
            $revRecord->userCan(
                RevisionRecord::DELETED_TEXT,
                $context->getAuthority()
            ) &&
            $context->getAuthority()->isAllowedAny( 'deletedtext', 'undelete' )
        ) {
            return $context->msg(
                'missing-revision-permission',
                $oldid,
                $revRecord->getTimestamp(),
                Title::newFromPageIdentity( $revRecord->getPage() )->getPrefixedURL()
            );
        }
        return $context->msg( 'missing-revision', $oldid );
    }
}
 
class_alias( Article::class, 'Article' );