DifferenceEngine.php

Go to the documentation of this file.

<?php
use MediaWiki\ChangeTags\ChangeTags;
use MediaWiki\CommentFormatter\CommentFormatter;
use MediaWiki\Content\Content;
use MediaWiki\Content\IContentHandlerFactory;
use MediaWiki\Context\ContextSource;
use MediaWiki\Context\IContextSource;
use MediaWiki\Debug\DeprecationHelper;
use MediaWiki\Diff\TextDiffer\ManifoldTextDiffer;
use MediaWiki\Exception\PermissionsError;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Html\Html;
use MediaWiki\Language\Language;
use MediaWiki\Linker\Linker;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Page\ParserOutputAccess;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\RecentChanges\ChangesList;
use MediaWiki\RecentChanges\RecentChange;
use MediaWiki\Revision\ArchivedRevisionLookup;
use MediaWiki\Revision\BadRevisionException;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Storage\NameTableAccessException;
use MediaWiki\Title\Title;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\User\UserEditTracker;
use MediaWiki\User\UserGroupManager;
use MediaWiki\User\UserGroupMembership;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserIdentityUtils;
use Wikimedia\Rdbms\IConnectionProvider;
 
class DifferenceEngine extends ContextSource {
 
    use DeprecationHelper;
 
    private const DIFF_VERSION = '1.41';
 
    protected $mOldid;
 
    protected $mNewid;
 
    private $mOldRevisionRecord;
 
    private $mNewRevisionRecord;
 
    protected $mOldPage;
 
    protected $mNewPage;
 
    private $mOldTags;
 
    private $mNewTags;
 
    private $mOldContent;
 
    private $mNewContent;
 
    protected $mDiffLang;
 
    private $mRevisionsIdsLoaded = false;
 
    protected $mRevisionsLoaded = false;
 
    protected $mTextLoaded = 0;
 
    protected $isContentOverridden = false;
 
    protected $mCacheHit = false;
 
    private $cacheHitKey = null;
 
    public $enableDebugComment = false;
 
    protected $mReducedLineNumbers = false;
 
    protected $mMarkPatrolledLink = null;
 
    protected $unhide = false;
 
    protected $mRefreshCache = false;
 
    protected $slotDiffRenderers = null;
 
    protected $isSlotDiffRenderer = false;
 
    private $slotDiffOptions = [];
 
    private $extraQueryParams = [];
 
    private $textDiffer;
 
    protected LinkRenderer $linkRenderer;
    private IContentHandlerFactory $contentHandlerFactory;
    private RevisionStore $revisionStore;
    private ArchivedRevisionLookup $archivedRevisionLookup;
    private HookRunner $hookRunner;
    private WikiPageFactory $wikiPageFactory;
    private UserOptionsLookup $userOptionsLookup;
    private CommentFormatter $commentFormatter;
    private IConnectionProvider $dbProvider;
    private UserGroupManager $userGroupManager;
    private UserEditTracker $userEditTracker;
    private UserIdentityUtils $userIdentityUtils;
 
    private $revisionLoadErrors = [];
 
    public function __construct( $context = null, $old = 0, $new = 0, $rcid = 0,
        $refreshCache = false, $unhide = false
    ) {
        if ( $context instanceof IContextSource ) {
            $this->setContext( $context );
        }
 
        wfDebug( "DifferenceEngine old '$old' new '$new' rcid '$rcid'" );
 
        $this->mOldid = $old;
        $this->mNewid = $new;
        $this->mRefreshCache = $refreshCache;
        $this->unhide = $unhide;
 
        $services = MediaWikiServices::getInstance();
        $this->linkRenderer = $services->getLinkRenderer();
        $this->contentHandlerFactory = $services->getContentHandlerFactory();
        $this->revisionStore = $services->getRevisionStore();
        $this->archivedRevisionLookup = $services->getArchivedRevisionLookup();
        $this->hookRunner = new HookRunner( $services->getHookContainer() );
        $this->wikiPageFactory = $services->getWikiPageFactory();
        $this->userOptionsLookup = $services->getUserOptionsLookup();
        $this->commentFormatter = $services->getCommentFormatter();
        $this->dbProvider = $services->getConnectionProvider();
        $this->userGroupManager = $services->getUserGroupManager();
        $this->userEditTracker = $services->getUserEditTracker();
        $this->userIdentityUtils = $services->getUserIdentityUtils();
    }
 
    protected function getSlotDiffRenderers() {
        if ( $this->isSlotDiffRenderer ) {
            throw new LogicException( __METHOD__ . ' called in slot diff renderer mode' );
        }
 
        if ( $this->slotDiffRenderers === null ) {
            if ( !$this->loadRevisionData() ) {
                return [];
            }
 
            $slotContents = $this->getSlotContents();
            $this->slotDiffRenderers = [];
            foreach ( $slotContents as $role => $contents ) {
                if ( $contents['new'] && $contents['old']
                    && $contents['new']->equals( $contents['old'] )
                ) {
                    // Do not produce a diff of identical content
                    continue;
                }
                if ( !$contents['new'] && !$contents['old'] ) {
                    // Nothing to diff (i.e both revisions are corrupted), just ignore
                    continue;
                }
                $handler = ( $contents['new'] ?: $contents['old'] )->getContentHandler();
                $this->slotDiffRenderers[$role] = $handler->getSlotDiffRenderer(
                    $this->getContext(),
                    $this->slotDiffOptions + [
                        'contentLanguage' => $this->getDiffLang()->getCode(),
                        'textDiffer' => $this->getTextDiffer()
                    ]
                );
            }
        }
 
        return $this->slotDiffRenderers;
    }
 
    public function markAsSlotDiffRenderer() {
        $this->isSlotDiffRenderer = true;
    }
 
    protected function getSlotContents() {
        if ( $this->isContentOverridden ) {
            return [
                SlotRecord::MAIN => [ 'old' => $this->mOldContent, 'new' => $this->mNewContent ]
            ];
        } elseif ( !$this->loadRevisionData() ) {
            return [];
        }
 
        $newSlots = $this->mNewRevisionRecord->getPrimarySlots()->getSlots();
        $oldSlots = $this->mOldRevisionRecord ?
            $this->mOldRevisionRecord->getPrimarySlots()->getSlots() :
            [];
        // The order here will determine the visual order of the diff. The current logic is
        // slots of the new revision first in natural order, then deleted ones. This is ad hoc
        // and should not be relied on - in the future we may want the ordering to depend
        // on the page type.
        $roles = array_keys( array_merge( $newSlots, $oldSlots ) );
 
        $slots = [];
        foreach ( $roles as $role ) {
            $slots[$role] = [
                'old' => $this->loadSingleSlot(
                    $oldSlots[$role] ?? null,
                    'old'
                ),
                'new' => $this->loadSingleSlot(
                    $newSlots[$role] ?? null,
                    'new'
                )
            ];
        }
        // move main slot to front
        if ( isset( $slots[SlotRecord::MAIN] ) ) {
            $slots = [ SlotRecord::MAIN => $slots[SlotRecord::MAIN] ] + $slots;
        }
        return $slots;
    }
 
    private function loadSingleSlot( ?SlotRecord $slot, string $which ) {
        if ( !$slot ) {
            return null;
        }
        try {
            return $slot->getContent();
        } catch ( BadRevisionException ) {
            $this->addRevisionLoadError( $which );
            return null;
        }
    }
 
    private function addRevisionLoadError( $which ) {
        $this->revisionLoadErrors[] = $this->msg( $which === 'new'
            ? 'difference-bad-new-revision' : 'difference-bad-old-revision'
        );
    }
 
    public function getRevisionLoadErrors() {
        return $this->revisionLoadErrors;
    }
 
    private function hasNewRevisionLoadError() {
        foreach ( $this->revisionLoadErrors as $error ) {
            if ( $error->getKey() === 'difference-bad-new-revision' ) {
                return true;
            }
        }
        return false;
    }
 
    public function getTitle() {
        // T202454 avoid errors when there is no title
        return parent::getTitle() ?: Title::makeTitle( NS_SPECIAL, 'BadTitle/DifferenceEngine' );
    }
 
    public function setReducedLineNumbers( $value = true ) {
        $this->mReducedLineNumbers = $value;
    }
 
    public function getDiffLang() {
        # Default language in which the diff text is written.
        $this->mDiffLang ??= $this->getDefaultLanguage();
        return $this->mDiffLang;
    }
 
    protected function getDefaultLanguage() {
        return $this->getTitle()->getPageLanguage();
    }
 
    public function wasCacheHit() {
        return $this->mCacheHit;
    }
 
    public function getOldid() {
        $this->loadRevisionIds();
 
        return $this->mOldid;
    }
 
    public function getNewid() {
        $this->loadRevisionIds();
 
        return $this->mNewid;
    }
 
    public function getOldRevision() {
        return $this->mOldRevisionRecord ?: null;
    }
 
    public function getNewRevision() {
        return $this->mNewRevisionRecord;
    }
 
    public function deletedLink( $id ) {
        if ( $this->getAuthority()->isAllowed( 'deletedhistory' ) ) {
            $revRecord = $this->archivedRevisionLookup->getArchivedRevisionRecord( null, $id );
            if ( $revRecord ) {
                $title = Title::newFromPageIdentity( $revRecord->getPage() );
 
                return SpecialPage::getTitleFor( 'Undelete' )->getFullURL( [
                    'target' => $title->getPrefixedText(),
                    'timestamp' => $revRecord->getTimestamp()
                ] );
            }
        }
 
        return false;
    }
 
    public function deletedIdMarker( $id ) {
        $link = $this->deletedLink( $id );
        if ( $link ) {
            return "[$link $id]";
        } else {
            return (string)$id;
        }
    }
 
    private function showMissingRevision() {
        $out = $this->getOutput();
 
        $missing = [];
        if ( $this->mOldid && ( !$this->mOldRevisionRecord || !$this->mOldContent ) ) {
            $missing[] = $this->deletedIdMarker( $this->mOldid );
        }
        if ( !$this->mNewRevisionRecord || !$this->mNewContent ) {
            $missing[] = $this->deletedIdMarker( $this->mNewid );
        }
 
        $out->setPageTitleMsg( $this->msg( 'errorpagetitle' ) );
        $msg = $this->msg( 'difference-missing-revision' )
            ->params( $this->getLanguage()->listToText( $missing ) )
            ->numParams( count( $missing ) )
            ->parseAsBlock();
        $out->addHTML( $msg );
    }
 
    public function hasDeletedRevision() {
        $this->loadRevisionData();
        return (
                $this->mNewRevisionRecord &&
                $this->mNewRevisionRecord->isDeleted( RevisionRecord::DELETED_TEXT )
            ) ||
            (
                $this->mOldRevisionRecord &&
                $this->mOldRevisionRecord->isDeleted( RevisionRecord::DELETED_TEXT )
            );
    }
 
    public function getPermissionErrors( Authority $performer ) {
        wfDeprecated( __METHOD__, '1.44' );
        return $this->authorizeView( $performer )->toLegacyErrorArray();
    }
 
    public function authorizeView( Authority $performer ): PermissionStatus {
        $this->loadRevisionData();
        $permStatus = PermissionStatus::newEmpty();
        if ( $this->mNewPage ) {
            $performer->authorizeRead( 'read', $this->mNewPage, $permStatus );
        }
        if ( $this->mOldPage ) {
            $performer->authorizeRead( 'read', $this->mOldPage, $permStatus );
        }
        return $permStatus;
    }
 
    public function hasSuppressedRevision() {
        return $this->hasDeletedRevision() && (
            ( $this->mOldRevisionRecord &&
                $this->mOldRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) ) ||
            ( $this->mNewRevisionRecord &&
                $this->mNewRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) )
        );
    }
 
    private function getUserEditCount( $user ): string {
        $editCount = $this->userEditTracker->getUserEditCount( $user );
        if ( $editCount === null ) {
            return '';
        }
 
        return Html::rawElement( 'div', [
            'class' => 'mw-diff-usereditcount',
        ],
            $this->msg(
                'diff-user-edits',
                $this->getLanguage()->formatNum( $editCount )
            )->parse()
        );
    }
 
    private function getUserRoles( UserIdentity $user ) {
        if ( !$this->userIdentityUtils->isNamed( $user ) ) {
            return '';
        }
        $userGroups = $this->userGroupManager->getUserGroups( $user );
        $userGroupLinks = [];
        foreach ( $userGroups as $group ) {
            $userGroupLinks[] = UserGroupMembership::getLinkHTML( $group, $this->getContext() );
        }
        return Html::rawElement( 'div', [
            'class' => 'mw-diff-userroles',
        ], $this->getLanguage()->commaList( $userGroupLinks ) );
    }
 
    private function getUserMetaData( ?UserIdentity $user ) {
        if ( !$user ) {
            return '';
        }
        return Html::rawElement( 'div', [
            'class' => 'mw-diff-usermetadata',
        ], $this->getUserRoles( $user ) . $this->getUserEditCount( $user ) );
    }
 
    public function isUserAllowedToSeeRevisions( Authority $performer ) {
        $this->loadRevisionData();
 
        if ( $this->mOldRevisionRecord && !$this->mOldRevisionRecord->userCan(
            RevisionRecord::DELETED_TEXT,
            $performer
        ) ) {
            return false;
        }
 
        // $this->mNewRev will only be falsy if a loading error occurred
        // (in which case the user is allowed to see).
        return !$this->mNewRevisionRecord || $this->mNewRevisionRecord->userCan(
            RevisionRecord::DELETED_TEXT,
            $performer
        );
    }
 
    public function shouldBeHiddenFromUser( Authority $performer ) {
        return $this->hasDeletedRevision() && ( !$this->unhide ||
            !$this->isUserAllowedToSeeRevisions( $performer ) );
    }
 
    public function showDiffPage( $diffOnly = false ) {
        # Allow frames except in certain special cases
        $out = $this->getOutput();
        $out->getMetadata()->setPreventClickjacking( false );
        $out->setRobotPolicy( 'noindex,nofollow' );
 
        // Allow extensions to add any extra output here
        $this->hookRunner->onDifferenceEngineShowDiffPage( $out );
 
        if ( !$this->loadRevisionData() ) {
            if ( $this->hookRunner->onDifferenceEngineShowDiffPageMaybeShowMissingRevision( $this ) ) {
                $this->showMissingRevision();
            }
            return;
        }
 
        $user = $this->getUser();
        $permStatus = $this->authorizeView( $this->getAuthority() );
        if ( !$permStatus->isGood() ) {
            throw new PermissionsError( 'read', $permStatus );
        }
 
        $rollback = '';
 
        $query = $this->extraQueryParams;
        # Carry over 'diffonly' param via navigation links
        if ( $diffOnly != MediaWikiServices::getInstance()
            ->getUserOptionsLookup()->getBoolOption( $user, 'diffonly' )
        ) {
            $query['diffonly'] = $diffOnly;
        }
        # Cascade unhide param in links for easy deletion browsing
        if ( $this->unhide ) {
            $query['unhide'] = 1;
        }
 
        # Check if one of the revisions is deleted/suppressed
        $deleted = $this->hasDeletedRevision();
        $suppressed = $this->hasSuppressedRevision();
        $allowed = $this->isUserAllowedToSeeRevisions( $this->getAuthority() );
 
        $revisionTools = [];
        $breadCrumbs = '';
 
        # mOldRevisionRecord is false if the difference engine is called with a "vague" query for
        # a diff between a version V and its previous version V' AND the version V
        # is the first version of that article. In that case, V' does not exist.
        if ( $this->mOldRevisionRecord === false ) {
            if ( $this->mNewPage ) {
                $out->setPageTitleMsg(
                    $this->msg( 'difference-title' )->plaintextParams( $this->mNewPage->getPrefixedText() )
                );
            }
            $samePage = true;
            $oldHeader = '';
            // Allow extensions to change the $oldHeader variable
            $this->hookRunner->onDifferenceEngineOldHeaderNoOldRev( $oldHeader );
        } else {
            $this->hookRunner->onDifferenceEngineViewHeader( $this );
 
            if ( !$this->mOldPage || !$this->mNewPage ) {
                // XXX say something to the user?
                $samePage = false;
            } elseif ( $this->mNewPage->equals( $this->mOldPage ) ) {
                $out->setPageTitleMsg(
                    $this->msg( 'difference-title' )->plaintextParams( $this->mNewPage->getPrefixedText() )
                );
                $samePage = true;
            } else {
                $out->setPageTitleMsg( $this->msg( 'difference-title-multipage' )->plaintextParams(
                    $this->mOldPage->getPrefixedText(), $this->mNewPage->getPrefixedText() ) );
                $out->addSubtitle( $this->msg( 'difference-multipage' ) );
                $samePage = false;
            }
 
            if ( $samePage && $this->mNewPage &&
                $this->getAuthority()->probablyCan( 'edit', $this->mNewPage )
            ) {
                if ( $this->mNewRevisionRecord->isCurrent() &&
                    $this->getAuthority()->probablyCan( 'rollback', $this->mNewPage )
                ) {
                    $rollbackLink = Linker::generateRollback(
                        $this->mNewRevisionRecord,
                        $this->getContext(),
                        [ 'noBrackets' ]
                    );
                    if ( $rollbackLink ) {
                        $out->getMetadata()->setPreventClickjacking( true );
                        $rollback = "\u{00A0}\u{00A0}\u{00A0}" . $rollbackLink;
                    }
                }
 
                if ( $this->userCanEdit( $this->mOldRevisionRecord ) &&
                    $this->userCanEdit( $this->mNewRevisionRecord )
                ) {
                    $undoLink = $this->linkRenderer->makeKnownLink(
                        $this->mNewPage,
                        $this->msg( 'editundo' )->text(),
                        [ 'title' => Linker::titleAttrib( 'undo' ) ],
                        [
                            'action' => 'edit',
                            'undoafter' => $this->mOldid,
                            'undo' => $this->mNewid
                        ]
                    );
                    $revisionTools['mw-diff-undo'] = $undoLink;
                }
            }
            # Make "previous revision link"
            $hasPrevious = $samePage && $this->mOldPage &&
                $this->revisionStore->getPreviousRevision( $this->mOldRevisionRecord );
            if ( $hasPrevious ) {
                $prevlinkQuery = [ 'diff' => 'prev', 'oldid' => $this->mOldid ] + $query;
                $prevlink = $this->linkRenderer->makeKnownLink(
                    $this->mOldPage,
                    $this->msg( 'previousdiff' )->text(),
                    [ 'id' => 'differences-prevlink' ],
                    $prevlinkQuery
                );
                $breadCrumbs .= $this->linkRenderer->makeKnownLink(
                    $this->mOldPage,
                    $this->msg( 'previousdiff' )->text(),
                    [
                        'class' => 'mw-diff-revision-history-link-previous'
                    ],
                    $prevlinkQuery
                );
            } else {
                $prevlink = "\u{00A0}";
            }
 
            if ( $this->mOldRevisionRecord->isMinor() ) {
                $oldminor = ChangesList::flag( 'minor' );
            } else {
                $oldminor = '';
            }
 
            $oldRevRecord = $this->mOldRevisionRecord;
 
            $ldel = $this->revisionDeleteLink( $oldRevRecord );
            $oldRevisionHeader = $this->getRevisionHeader( $oldRevRecord, 'complete' );
            $oldChangeTags = ChangeTags::formatSummaryRow( $this->mOldTags, 'diff', $this->getContext() );
            $oldRevComment = $this->commentFormatter
                ->formatRevision(
                    $oldRevRecord, $user, !$diffOnly, !$this->unhide,  false
                );
 
            if ( $oldRevComment === '' ) {
                $defaultComment = $this->msg( 'changeslist-nocomment' )->escaped();
                $oldRevComment = "<span class=\"comment mw-comment-none\">$defaultComment</span>";
            }
 
            $oldHeader = '<div id="mw-diff-otitle1"><strong>' . $oldRevisionHeader . '</strong></div>' .
                '<div id="mw-diff-otitle2">' .
                Linker::revUserTools( $oldRevRecord, !$this->unhide ) .
                $this->getUserMetaData( $oldRevRecord->getUser() ) .
                '</div>' .
                '<div id="mw-diff-otitle3">' . $oldminor . $oldRevComment . $ldel . '</div>' .
                '<div id="mw-diff-otitle5">' . $oldChangeTags[0] . '</div>' .
                '<div id="mw-diff-otitle4">' . $prevlink . '</div>';
 
            // Allow extensions to change the $oldHeader variable
            $this->hookRunner->onDifferenceEngineOldHeader(
                $this, $oldHeader, $prevlink, $oldminor, $diffOnly, $ldel, $this->unhide );
        }
 
        $out->addJsConfigVars( [
            'wgDiffOldId' => $this->mOldid,
            'wgDiffNewId' => $this->mNewid,
        ] );
 
        # Make "next revision link"
        # Skip next link on the top revision
        if ( $samePage && $this->mNewPage && !$this->mNewRevisionRecord->isCurrent() ) {
            $nextlinkQuery = [ 'diff' => 'next', 'oldid' => $this->mNewid ] + $query;
            $nextlink = $this->linkRenderer->makeKnownLink(
                $this->mNewPage,
                $this->msg( 'nextdiff' )->text(),
                [ 'id' => 'differences-nextlink' ],
                $nextlinkQuery
            );
            $breadCrumbs .= $this->linkRenderer->makeKnownLink(
                $this->mNewPage,
                $this->msg( 'nextdiff' )->text(),
                [
                    'class' => 'mw-diff-revision-history-link-next'
                ],
                $nextlinkQuery
            );
        } else {
            $nextlink = "\u{00A0}";
        }
 
        if ( $this->mNewRevisionRecord->isMinor() ) {
            $newminor = ChangesList::flag( 'minor' );
        } else {
            $newminor = '';
        }
 
        # Handle RevisionDelete links...
        $rdel = $this->revisionDeleteLink( $this->mNewRevisionRecord );
 
        # Allow extensions to define their own revision tools
        $this->hookRunner->onDiffTools(
            $this->mNewRevisionRecord,
            $revisionTools,
            $this->mOldRevisionRecord ?: null,
            $user
        );
 
        $formattedRevisionTools = [];
        // Put each one in parentheses (poor man's button)
        foreach ( $revisionTools as $key => $tool ) {
            $toolClass = is_string( $key ) ? $key : 'mw-diff-tool';
            $element = Html::rawElement(
                'span',
                [ 'class' => $toolClass ],
                $tool
            );
            $formattedRevisionTools[] = $element;
        }
 
        $newRevRecord = $this->mNewRevisionRecord;
 
        $newRevisionHeader = $this->getRevisionHeader( $newRevRecord, 'complete' ) .
            ' ' . implode( ' ', $formattedRevisionTools );
        $newChangeTags = ChangeTags::formatSummaryRow( $this->mNewTags, 'diff', $this->getContext() );
        $newRevComment = $this->commentFormatter->formatRevision(
            $newRevRecord, $user, !$diffOnly, !$this->unhide,  false
        );
 
        if ( $newRevComment === '' ) {
            $defaultComment = $this->msg( 'changeslist-nocomment' )->escaped();
            $newRevComment = "<span class=\"comment mw-comment-none\">$defaultComment</span>";
        }
 
        $newHeader = '<div id="mw-diff-ntitle1"><strong>' . $newRevisionHeader . '</strong></div>' .
            '<div id="mw-diff-ntitle2">' . Linker::revUserTools( $newRevRecord, !$this->unhide ) .
            $rollback .
            $this->getUserMetaData( $newRevRecord->getUser() ) .
            '</div>' .
            '<div id="mw-diff-ntitle3">' . $newminor . $newRevComment . $rdel . '</div>' .
            '<div id="mw-diff-ntitle5">' . $newChangeTags[0] . '</div>' .
            '<div id="mw-diff-ntitle4">' . $nextlink . $this->markPatrolledLink() . '</div>';
 
        // Allow extensions to change the $newHeader variable
        $this->hookRunner->onDifferenceEngineNewHeader( $this, $newHeader,
            $formattedRevisionTools, $nextlink, $rollback, $newminor, $diffOnly,
            $rdel, $this->unhide );
 
        $out->addHTML(
            Html::rawElement( 'div', [
                'class' => 'mw-diff-revision-history-links'
            ], $breadCrumbs )
        );
        $addMessageBoxStyles = false;
        # If the diff cannot be shown due to a deleted revision, then output
        # the diff header and links to unhide (if available)...
        if ( $this->shouldBeHiddenFromUser( $this->getAuthority() ) ) {
            $this->showDiffStyle();
            $multi = $this->getMultiNotice();
            $out->addHTML( $this->addHeader( '', $oldHeader, $newHeader, $multi ) );
            if ( !$allowed ) {
                # Give explanation for why revision is not visible
                $msg = [ $suppressed ? 'rev-suppressed-no-diff' : 'rev-deleted-no-diff' ];
            } else {
                # Give explanation and add a link to view the diff...
                $query = $this->getRequest()->appendQueryValue( 'unhide', '1' );
                $msg = [
                    $suppressed ? 'rev-suppressed-unhide-diff' : 'rev-deleted-unhide-diff',
                    $this->getTitle()->getFullURL( $query )
                ];
            }
            $out->addHTML( Html::warningBox( $this->msg( ...$msg )->parse(), 'plainlinks' ) );
            $addMessageBoxStyles = true;
        # Otherwise, output a regular diff...
        } else {
            # Add deletion notice if the user is viewing deleted content
            $notice = '';
            if ( $deleted ) {
                $msg = $suppressed ? 'rev-suppressed-diff-view' : 'rev-deleted-diff-view';
                $notice = Html::warningBox( $this->msg( $msg )->parse(), 'plainlinks' );
                $addMessageBoxStyles = true;
            }
 
            # Add an error if the content can't be loaded
            $this->getSlotContents();
            foreach ( $this->getRevisionLoadErrors() as $msg ) {
                $notice .= Html::warningBox( $msg->parse() );
                $addMessageBoxStyles = true;
            }
 
            // Check if inline switcher will be needed
            if ( $this->getTextDiffer()->hasFormat( 'inline' ) ) {
                $out->enableOOUI();
            }
 
            $this->showTablePrefixes();
            $this->showDiff( $oldHeader, $newHeader, $notice );
            if ( !$diffOnly ) {
                $this->renderNewRevision();
            }
 
            // Allow extensions to optionally not show the final patrolled link
            if ( $this->hookRunner->onDifferenceEngineRenderRevisionShowFinalPatrolLink() ) {
                # Add redundant patrol link on bottom...
                $out->addHTML( $this->markPatrolledLink() );
            }
        }
        if ( $addMessageBoxStyles ) {
            $out->addModuleStyles( 'mediawiki.codex.messagebox.styles' );
        }
    }
 
    private function showTablePrefixes() {
        $parts = [];
        foreach ( $this->getSlotDiffRenderers() as $slotDiffRenderer ) {
            $parts += $slotDiffRenderer->getTablePrefix( $this->getContext(), $this->mNewPage );
        }
        ksort( $parts );
        if ( count( array_filter( $parts ) ) > 0 ) {
            $language = $this->getLanguage();
            $attrs = [
                'class' => 'mw-diff-table-prefix',
                'dir' => $language->getDir(),
                'lang' => $language->getCode(),
            ];
            $this->getOutput()->addHTML(
                Html::rawElement( 'div', $attrs, implode( '', $parts ) ) );
        }
    }
 
    public function markPatrolledLink() {
        if ( $this->mMarkPatrolledLink === null ) {
            $linkInfo = $this->getMarkPatrolledLinkInfo();
            // If false, there is no patrol link needed/allowed
            if ( !$linkInfo || !$this->mNewPage ) {
                $this->mMarkPatrolledLink = '';
            } else {
                $patrolLinkClass = 'patrollink';
                $this->mMarkPatrolledLink = ' <span class="' . $patrolLinkClass . '" data-mw="interface">[' .
                    $this->linkRenderer->makeKnownLink(
                        $this->mNewPage,
                        $this->msg( 'markaspatrolleddiff' )->text(),
                        [],
                        [
                            'action' => 'markpatrolled',
                            'rcid' => $linkInfo['rcid'],
                        ]
                    ) . ']</span>';
                // Allow extensions to change the markpatrolled link
                $this->hookRunner->onDifferenceEngineMarkPatrolledLink( $this,
                    $this->mMarkPatrolledLink, $linkInfo['rcid'] );
            }
        }
        return $this->mMarkPatrolledLink;
    }
 
    protected function getMarkPatrolledLinkInfo() {
        $user = $this->getUser();
        $config = $this->getConfig();
 
        // Prepare a change patrol link, if applicable
        if (
            // Is patrolling enabled and the user allowed to?
            $config->get( MainConfigNames::UseRCPatrol ) &&
            $this->mNewPage &&
            $this->getAuthority()->probablyCan( 'patrol', $this->mNewPage ) &&
            // Only do this if the revision isn't more than 6 hours older
            // than the Max RC age (6h because the RC might not be cleaned out regularly)
            RecentChange::isInRCLifespan( $this->mNewRevisionRecord->getTimestamp(), 21600 )
        ) {
            // Look for an unpatrolled change corresponding to this diff
            $change = RecentChange::newFromConds(
                [
                    'rc_this_oldid' => $this->mNewid,
                    'rc_patrolled' => RecentChange::PRC_UNPATROLLED
                ],
                __METHOD__
            );
 
            if ( $change && !$change->getPerformerIdentity()->equals( $user ) ) {
                $rcid = $change->getAttribute( 'rc_id' );
            } else {
                // None found or the page has been created by the current user.
                // If the user could patrol this it already would be patrolled
                $rcid = 0;
            }
 
            // Allow extensions to possibly change the rcid here
            // For example the rcid might be set to zero due to the user
            // being the same as the performer of the change but an extension
            // might still want to show it under certain conditions
            $this->hookRunner->onDifferenceEngineMarkPatrolledRCID( $rcid, $this, $change, $user );
 
            // Build the link
            if ( $rcid ) {
                $this->getOutput()->getMetadata()->setPreventClickjacking( true );
                $this->getOutput()->addModules( 'mediawiki.misc-authed-curate' );
 
                return [ 'rcid' => $rcid ];
            }
        }
 
        // No mark as patrolled link applicable
        return false;
    }
 
    private function revisionDeleteLink( RevisionRecord $revRecord ) {
        $link = Linker::getRevDeleteLink(
            $this->getAuthority(),
            $revRecord,
            $revRecord->getPageAsLinkTarget()
        );
        if ( $link !== '' ) {
            $link = "\u{00A0}\u{00A0}\u{00A0}" . $link . ' ';
        }
 
        return $link;
    }
 
    public function renderNewRevision() {
        if ( $this->isContentOverridden ) {
            // The code below only works with a RevisionRecord object. We could construct a
            // fake RevisionRecord (here or in setContent), but since this does not seem
            // needed at the moment, we'll just fail for now.
            throw new LogicException(
                __METHOD__
                . ' is not supported after calling setContent(). Use setRevisions() instead.'
            );
        }
 
        $out = $this->getOutput();
        $revHeader = $this->getRevisionHeader( $this->mNewRevisionRecord );
        # Add "current version as of X" title
        $out->addHTML( "<hr class='diff-hr' id='mw-oldid' />
        <h2 class='diff-currentversion-title'>{$revHeader}</h2>\n" );
        # Page content may be handled by a hooked call instead...
        if ( $this->hookRunner->onArticleContentOnDiff( $this, $out ) ) {
            $this->loadNewText();
            if ( !$this->mNewPage ) {
                // New revision is unsaved; bail out.
                // TODO in theory rendering the new revision is a meaningful thing to do
                // even if it's unsaved, but a lot of untangling is required to do it safely.
                return;
            }
            if ( $this->hasNewRevisionLoadError() ) {
                // There was an error loading the new revision
                return;
            }
 
            $out->setRevisionId( $this->mNewid );
            $out->setRevisionIsCurrent( $this->mNewRevisionRecord->isCurrent() );
            $out->getMetadata()->setRevisionTimestamp( $this->mNewRevisionRecord->getTimestamp() );
            $out->setArticleFlag( true );
 
            if ( !$this->hookRunner->onArticleRevisionViewCustom(
                $this->mNewRevisionRecord, $this->mNewPage, $this->mOldid, $out )
            ) {
                // Handled by extension
                // NOTE: sync with hooks called in Article::view()
            } else {
                // Normal page
                if ( $this->getTitle()->equals( $this->mNewPage ) ) {
                    // If the Title stored in the context is the same as the one
                    // of the new revision, we can use its associated WikiPage
                    // object.
                    $wikiPage = $this->getWikiPage();
                } else {
                    // Otherwise we need to create our own WikiPage object
                    $wikiPage = $this->wikiPageFactory->newFromTitle( $this->mNewPage );
                }
 
                $parserOptions = $wikiPage->makeParserOptions( $this->getContext() );
                $parserOptions->setRenderReason( 'diff-page' );
 
                $parserOutputAccess = MediaWikiServices::getInstance()->getParserOutputAccess();
                $status = $parserOutputAccess->getParserOutput(
                    $wikiPage,
                    $parserOptions,
                    $this->mNewRevisionRecord,
                    // we already checked
                    ParserOutputAccess::OPT_NO_AUDIENCE_CHECK |
                    // Update cascading protection
                    ParserOutputAccess::OPT_LINKS_UPDATE
                );
                if ( $status->isOK() ) {
                    $parserOutput = $status->getValue();
                    // Allow extensions to change parser output here
                    if ( $this->hookRunner->onDifferenceEngineRenderRevisionAddParserOutput(
                        $this, $out, $parserOutput, $wikiPage )
                    ) {
                        $out->addParserOutput( $parserOutput, $parserOptions, [
                            'enableSectionEditLinks' => $this->mNewRevisionRecord->isCurrent()
                                && $this->getAuthority()->probablyCan(
                                    'edit',
                                    $this->mNewRevisionRecord->getPage()
                                ),
                            'absoluteURLs' => $this->slotDiffOptions['expand-url'] ?? false
                        ] );
                    }
                } else {
                    $out->addModuleStyles( 'mediawiki.codex.messagebox.styles' );
                    foreach ( $status->getMessages() as $msg ) {
                        $out->addHTML( Html::errorBox(
                            $this->msg( $msg )->parse()
                        ) );
                    }
                }
            }
        }
    }
 
    public function showDiff( $otitle, $ntitle, $notice = '' ) {
        // Allow extensions to affect the output here
        $this->hookRunner->onDifferenceEngineShowDiff( $this );
 
        $diff = $this->getDiff( $otitle, $ntitle, $notice );
        if ( $diff === false ) {
            $this->showMissingRevision();
            return false;
        }
 
        $this->showDiffStyle();
        if ( $this->slotDiffOptions['expand-url'] ?? false ) {
            $diff = Linker::expandLocalLinks( $diff );
        }
        $this->getOutput()->addHTML( $diff );
        return true;
    }
 
    public function showDiffStyle() {
        if ( !$this->isSlotDiffRenderer ) {
            $this->getOutput()->addModules( 'mediawiki.diff' );
            $this->getOutput()->addModuleStyles( [
                'mediawiki.interface.helpers.styles',
                'mediawiki.diff.styles'
            ] );
            foreach ( $this->getSlotDiffRenderers() as $slotDiffRenderer ) {
                $slotDiffRenderer->addModules( $this->getOutput() );
            }
        }
    }
 
    public function getDiff( $otitle, $ntitle, $notice = '' ) {
        $body = $this->getDiffBody();
        if ( $body === false ) {
            return false;
        }
 
        $multi = $this->getMultiNotice();
        // Display a message when the diff is empty
        if ( $body === '' ) {
            $notice .= '<div class="mw-diff-empty">' .
                $this->msg( 'diff-empty' )->parse() .
                "</div>\n";
        }
 
        if ( $this->cacheHitKey !== null ) {
            $body .= "\n<!-- diff cache key " . htmlspecialchars( $this->cacheHitKey ) . " -->\n";
        }
 
        return $this->addHeader( $body, $otitle, $ntitle, $multi, $notice );
    }
 
    private function incrementStats( string $cacheStatus ): void {
        $stats = MediaWikiServices::getInstance()->getStatsFactory();
        $stats->getCounter( 'diff_cache_total' )
            ->setLabel( 'status', $cacheStatus )
            ->copyToStatsdAt( 'diff_cache.' . $cacheStatus )
            ->increment();
    }
 
    public function getDiffBody() {
        $this->mCacheHit = true;
        // Check if the diff should be hidden from this user
        if ( !$this->isContentOverridden ) {
            if ( !$this->loadRevisionData() ) {
                return false;
            } elseif ( $this->mOldRevisionRecord &&
                !$this->mOldRevisionRecord->userCan(
                    RevisionRecord::DELETED_TEXT,
                    $this->getAuthority()
                )
            ) {
                return false;
            } elseif ( $this->mNewRevisionRecord &&
                !$this->mNewRevisionRecord->userCan(
                    RevisionRecord::DELETED_TEXT,
                    $this->getAuthority()
                ) ) {
                return false;
            }
            // Short-circuit
            if ( $this->mOldRevisionRecord === false || (
                $this->mOldRevisionRecord &&
                $this->mNewRevisionRecord &&
                $this->mOldRevisionRecord->getId() &&
                $this->mOldRevisionRecord->getId() == $this->mNewRevisionRecord->getId()
            ) ) {
                if ( $this->hookRunner->onDifferenceEngineShowEmptyOldContent( $this ) ) {
                    return '';
                }
            }
        }
 
        // Cacheable?
        $key = false;
        $services = MediaWikiServices::getInstance();
        $cache = $services->getMainWANObjectCache();
        $stats = $services->getStatsdDataFactory();
        if ( $this->mOldid && $this->mNewid ) {
            $key = $cache->makeKey( ...$this->getDiffBodyCacheKeyParams() );
 
            // Try cache
            if ( !$this->mRefreshCache ) {
                $difftext = $cache->get( $key );
                if ( is_string( $difftext ) ) {
                    $this->incrementStats( 'hit' );
                    $difftext = $this->localiseDiff( $difftext );
                    $this->cacheHitKey = $key;
                    return $difftext;
                }
            } // don't try to load but save the result
        }
        $this->mCacheHit = false;
        $this->cacheHitKey = null;
 
        // Loadtext is permission safe, this just clears out the diff
        if ( !$this->loadText() ) {
            return false;
        }
 
        $difftext = '';
        // We've checked for revdelete at the beginning of this method; it's OK to ignore
        // read permissions here.
        $slotContents = $this->getSlotContents();
        foreach ( $this->getSlotDiffRenderers() as $role => $slotDiffRenderer ) {
            try {
                $slotDiff = $slotDiffRenderer->getDiff( $slotContents[$role]['old'],
                    $slotContents[$role]['new'] );
            } catch ( IncompatibleDiffTypesException $e ) {
                $slotDiff = $this->getSlotError( $e->getMessageObject()->parse() );
            }
            if ( $slotDiff && $role !== SlotRecord::MAIN ) {
                // FIXME: ask SlotRoleHandler::getSlotNameMessage
                $slotTitle = $role;
                $difftext .= $this->getSlotHeader( $slotTitle );
            }
            $difftext .= $slotDiff;
        }
 
        // Save to cache for 7 days
        if ( !$this->hookRunner->onAbortDiffCache( $this ) ) {
            $this->incrementStats( 'uncacheable' );
        } elseif ( $key !== false ) {
            $this->incrementStats( 'miss' );
            $cache->set( $key, $difftext, 7 * 86400 );
        } else {
            $this->incrementStats( 'uncacheable' );
        }
        // localise line numbers and title attribute text
        $difftext = $this->localiseDiff( $difftext );
 
        return $difftext;
    }
 
    public function getDiffBodyForRole( $role ) {
        $diffRenderers = $this->getSlotDiffRenderers();
        if ( !isset( $diffRenderers[$role] ) ) {
            return false;
        }
 
        $slotContents = $this->getSlotContents();
        try {
            $slotDiff = $diffRenderers[$role]->getDiff( $slotContents[$role]['old'],
                $slotContents[$role]['new'] );
        } catch ( IncompatibleDiffTypesException $e ) {
            $slotDiff = $this->getSlotError( $e->getMessageObject()->parse() );
        }
        if ( $slotDiff === '' ) {
            return false;
        }
 
        if ( $role !== SlotRecord::MAIN ) {
            // TODO use human-readable role name at least
            $slotTitle = $role;
            $slotDiff = $this->getSlotHeader( $slotTitle ) . $slotDiff;
        }
 
        return $this->localiseDiff( $slotDiff );
    }
 
    protected function getSlotHeader( $headerText ) {
        // The old revision is missing on oldid=<first>&diff=prev; only 2 columns in that case.
        $columnCount = $this->mOldRevisionRecord ? 4 : 2;
        $userLang = $this->getLanguage()->getHtmlCode();
        return Html::rawElement( 'tr', [ 'class' => 'mw-diff-slot-header', 'lang' => $userLang ],
            Html::element( 'th', [ 'colspan' => $columnCount ], $headerText ) );
    }
 
    protected function getSlotError( $errorText ) {
        // The old revision is missing on oldid=<first>&diff=prev; only 2 columns in that case.
        $columnCount = $this->mOldRevisionRecord ? 4 : 2;
        $userLang = $this->getLanguage()->getHtmlCode();
        return Html::rawElement( 'tr', [ 'class' => 'mw-diff-slot-error', 'lang' => $userLang ],
            Html::rawElement( 'td', [ 'colspan' => $columnCount ], $errorText ) );
    }
 
    protected function getDiffBodyCacheKeyParams() {
        if ( !$this->mOldid || !$this->mNewid ) {
            throw new BadMethodCallException( 'mOldid and mNewid must be set to get diff cache key.' );
        }
 
        $params = [
            'diff',
            self::DIFF_VERSION,
            "old-{$this->mOldid}",
            "rev-{$this->mNewid}"
        ];
 
        $extraKeys = [];
        if ( !$this->isSlotDiffRenderer ) {
            foreach ( $this->getSlotDiffRenderers() as $slotDiffRenderer ) {
                $extraKeys = array_merge( $extraKeys, $slotDiffRenderer->getExtraCacheKeys() );
            }
        }
        ksort( $extraKeys );
        return array_merge( $params, array_values( $extraKeys ) );
    }
 
    public function getExtraCacheKeys() {
        // This method is called when the DifferenceEngine is used for a slot diff. We only care
        // about special things, not the revision IDs, which are added to the cache key by the
        // page-level DifferenceEngine, and which might not have a valid value for this object.
        $this->mOldid = 123456789;
        $this->mNewid = 987654321;
 
        // This will repeat a bunch of unnecessary key fields for each slot. Not nice but harmless.
        $params = $this->getDiffBodyCacheKeyParams();
 
        // Try to get rid of the standard keys to keep the cache key human-readable:
        // call the getDiffBodyCacheKeyParams implementation of the base class, and if
        // the child class includes the same keys, drop them.
        // Uses an obscure PHP feature where static calls to non-static methods are allowed
        // as long as we are already in a non-static method of the same class, and the call context
        // ($this) will be inherited.
        // phpcs:ignore Squiz.Classes.SelfMemberReference.NotUsed
        $standardParams = DifferenceEngine::getDiffBodyCacheKeyParams();
        if ( array_slice( $params, 0, count( $standardParams ) ) === $standardParams ) {
            $params = array_slice( $params, count( $standardParams ) );
        }
 
        return $params;
    }
 
    public function setSlotDiffOptions( $options ) {
        $validatedOptions = [];
        if ( isset( $options['diff-type'] )
            && $this->getTextDiffer()->hasFormat( $options['diff-type'] )
        ) {
            $validatedOptions['diff-type'] = $options['diff-type'];
        }
        if ( !empty( $options['expand-url'] ) ) {
            $validatedOptions['expand-url'] = true;
        }
        if ( !empty( $options['inline-toggle'] ) ) {
            $validatedOptions['inline-toggle'] = true;
        }
        $this->slotDiffOptions = $validatedOptions;
    }
 
    public function setExtraQueryParams( $params ) {
        $this->extraQueryParams = $params;
    }
 
    public function generateContentDiffBody( Content $old, Content $new ) {
        $slotDiffRenderer = $new->getContentHandler()->getSlotDiffRenderer( $this->getContext() );
        if (
            $slotDiffRenderer instanceof DifferenceEngineSlotDiffRenderer
            && $this->isSlotDiffRenderer
        ) {
            // Oops, we are just about to enter an infinite loop (the slot-level DifferenceEngine
            // called a DifferenceEngineSlotDiffRenderer that wraps the same DifferenceEngine class).
            // This will happen when a content model has no custom slot diff renderer, it does have
            // a custom difference engine, but that does not override this method.
            throw new LogicException( get_class( $this ) . ': could not maintain backwards compatibility. '
                . 'Please use a SlotDiffRenderer.' );
        }
        return $slotDiffRenderer->getDiff( $old, $new ) . $this->getDebugString();
    }
 
    public function generateTextDiffBody( $otext, $ntext ) {
        $slotDiffRenderer = $this->contentHandlerFactory
            ->getContentHandler( CONTENT_MODEL_TEXT )
            ->getSlotDiffRenderer( $this->getContext() );
        if ( !( $slotDiffRenderer instanceof TextSlotDiffRenderer ) ) {
            // Someone used the GetSlotDiffRenderer hook to replace the renderer.
            // This is too unlikely to happen to bother handling properly.
            throw new LogicException( 'The slot diff renderer for text content should be a '
                . 'TextSlotDiffRenderer subclass' );
        }
        return $slotDiffRenderer->getTextDiff( $otext, $ntext ) . $this->getDebugString();
    }
 
    public static function getEngine() {
        $differenceEngine = new self;
        $engine = $differenceEngine->getTextDiffer()->getEngineForFormat( 'table' );
        if ( $engine === 'external' ) {
            return MediaWikiServices::getInstance()->getMainConfig()
                ->get( MainConfigNames::ExternalDiffEngine );
        } else {
            return $engine;
        }
    }
 
    protected function debug( $generator = "internal" ) {
        if ( !$this->enableDebugComment ) {
            return '';
        }
        $data = [ $generator ];
        if ( $this->getConfig()->get( MainConfigNames::ShowHostnames ) ) {
            $data[] = wfHostname();
        }
        $data[] = wfTimestamp( TS_DB );
 
        return "<!-- diff generator: " .
            implode( " ", array_map( "htmlspecialchars", $data ) ) .
            " -->\n";
    }
 
    private function getDebugString() {
        $engine = self::getEngine();
        if ( $engine === 'wikidiff2' ) {
            return $this->debug( 'wikidiff2' );
        } elseif ( $engine === 'php' ) {
            return $this->debug( 'native PHP' );
        } else {
            return $this->debug( "external $engine" );
        }
    }
 
    private function localiseDiff( $text ) {
        return $this->getTextDiffer()->localize( $this->getTextDiffFormat(), $text );
    }
 
    public function localiseLineNumbers( $text ) {
        return preg_replace_callback( '/<!--LINE (\d+)-->/',
            function ( array $matches ) {
                if ( $matches[1] === '1' && $this->mReducedLineNumbers ) {
                    return '';
                }
                return $this->msg( 'lineno' )->numParams( $matches[1] )->escaped();
            }, $text );
    }
 
    public function getMultiNotice() {
        // The notice only make sense if we are diffing two saved revisions of the same page.
        if (
            !$this->mOldRevisionRecord || !$this->mNewRevisionRecord
            || !$this->mOldPage || !$this->mNewPage
            || !$this->mOldPage->equals( $this->mNewPage )
            || $this->mOldRevisionRecord->getId() === null
            || $this->mNewRevisionRecord->getId() === null
            // (T237709) Deleted revs might have different page IDs
            || $this->mNewPage->getArticleID() !== $this->mOldRevisionRecord->getPageId()
            || $this->mNewPage->getArticleID() !== $this->mNewRevisionRecord->getPageId()
        ) {
            return '';
        }
 
        if ( $this->mOldRevisionRecord->getTimestamp() > $this->mNewRevisionRecord->getTimestamp() ) {
            $oldRevRecord = $this->mNewRevisionRecord; // flip
            $newRevRecord = $this->mOldRevisionRecord; // flip
        } else { // normal case
            $oldRevRecord = $this->mOldRevisionRecord;
            $newRevRecord = $this->mNewRevisionRecord;
        }
 
        // Don't show the notice if too many rows must be scanned
        // @todo show some special message for that case
        $nEdits = 0;
        $revisionIdList = $this->revisionStore->getRevisionIdsBetween(
            $this->mNewPage->getArticleID(),
            $oldRevRecord,
            $newRevRecord,
            1000
        );
        // only count revisions that are visible
        if ( count( $revisionIdList ) > 0 ) {
            foreach ( $revisionIdList as $revisionId ) {
                $revision = $this->revisionStore->getRevisionById( $revisionId );
                if ( $revision->getUser( RevisionRecord::FOR_THIS_USER, $this->getAuthority() ) ) {
                    $nEdits++;
                }
            }
        }
        if ( $nEdits > 0 && $nEdits <= 1000 ) {
            // Use an invalid username to get the wiki's default gender (as fallback)
            $newRevUserForGender = '[HIDDEN]';
            $limit = 100; // use diff-multi-manyusers if too many users
            try {
                $users = $this->revisionStore->getAuthorsBetween(
                    $this->mNewPage->getArticleID(),
                    $oldRevRecord,
                    $newRevRecord,
                    null,
                    $limit
                );
                $numUsers = count( $users );
 
                $newRevUser = $newRevRecord->getUser( RevisionRecord::RAW );
                $newRevUserText = $newRevUser ? $newRevUser->getName() : '';
                $newRevUserSafe = $newRevRecord->getUser(
                    RevisionRecord::FOR_THIS_USER,
                    $this->getAuthority()
                );
                $newRevUserForGender = $newRevUserSafe ? $newRevUserSafe->getName() : '[HIDDEN]';
                if ( $numUsers == 1 && $users[0]->getName() == $newRevUserText ) {
                    $numUsers = 0; // special case to say "by the same user" instead of "by one other user"
                }
            } catch ( InvalidArgumentException ) {
                $numUsers = 0;
            }
 
            return self::intermediateEditsMsg( $nEdits, $numUsers, $limit, $newRevUserForGender );
        }
 
        return '';
    }
 
    public static function intermediateEditsMsg( $numEdits, $numUsers, $limit, $lastUser = '[HIDDEN]' ) {
        if ( $numUsers === 0 ) {
            $msg = 'diff-multi-sameuser';
            return wfMessage( $msg )
                ->numParams( $numEdits, $numUsers )
                ->params( $lastUser )
                ->parse();
        } elseif ( $numUsers > $limit ) {
            $msg = 'diff-multi-manyusers';
            $numUsers = $limit;
        } else {
            $msg = 'diff-multi-otherusers';
        }
 
        return wfMessage( $msg )->numParams( $numEdits, $numUsers )->parse();
    }
 
    private function userCanEdit( RevisionRecord $revRecord ) {
        if ( !$revRecord->userCan( RevisionRecord::DELETED_TEXT, $this->getAuthority() ) ) {
            return false;
        }
 
        return true;
    }
 
    public function getRevisionHeader( RevisionRecord $rev, $complete = '' ) {
        $lang = $this->getLanguage();
        $user = $this->getUser();
        $revtimestamp = $rev->getTimestamp();
        $timestamp = $lang->userTimeAndDate( $revtimestamp, $user );
        $dateofrev = $lang->userDate( $revtimestamp, $user );
        $timeofrev = $lang->userTime( $revtimestamp, $user );
 
        $header = $this->msg(
            $rev->isCurrent() ? 'currentrev-asof' : 'revisionasof',
            $timestamp,
            $dateofrev,
            $timeofrev
        );
 
        if ( $complete !== 'complete' ) {
            return $header->escaped();
        }
 
        $title = $rev->getPageAsLinkTarget();
 
        if ( $this->userCanEdit( $rev ) ) {
            $header = $this->linkRenderer->makeKnownLink(
                $title,
                $header->text(),
                [],
                [ 'oldid' => $rev->getId() ]
            );
            $editQuery = [ 'action' => 'edit' ];
            if ( !$rev->isCurrent() ) {
                $editQuery['oldid'] = $rev->getId();
            }
 
            $key = $this->getAuthority()->probablyCan( 'edit', $rev->getPage() ) ? 'editold' : 'viewsourceold';
            $msg = $this->msg( $key )->text();
            $editLink = $this->linkRenderer->makeKnownLink( $title, $msg, [], $editQuery );
            $header .= ' ' . Html::rawElement(
                'span',
                [ 'class' => 'mw-diff-edit' ],
                $editLink
            );
        } else {
            $header = $header->escaped();
        }
 
        // Machine readable information
        $header .= Html::element( 'span',
            [
                'class' => 'mw-diff-timestamp',
                'data-timestamp' => wfTimestamp( TS_ISO_8601, $revtimestamp ),
            ], ''
        );
 
        if ( $rev->isDeleted( RevisionRecord::DELETED_TEXT ) ) {
            return Html::rawElement(
                'span',
                [ 'class' => Linker::getRevisionDeletedClass( $rev ) ],
                $header
            );
        }
 
        return $header;
    }
 
    public function addHeader( $diff, $otitle, $ntitle, $multi = '', $notice = '' ) {
        // shared.css sets diff in interface language/dir, but the actual content
        // is often in a different language, mostly the page content language/dir
        $header = Html::openElement( 'table', [
            'class' => [
                'diff',
                // The following classes are used here:
                // * diff-type-table
                // * diff-type-inline
                'diff-type-' . $this->getTextDiffFormat(),
                // The following classes are used here:
                // * diff-contentalign-left
                // * diff-contentalign-right
                'diff-contentalign-' . $this->getDiffLang()->alignStart(),
                // The following classes are used here:
                // * diff-editfont-monospace
                // * diff-editfont-sans-serif
                // * diff-editfont-serif
                'diff-editfont-' . $this->userOptionsLookup->getOption(
                    $this->getUser(),
                    'editfont'
                )
            ],
            'data-mw' => 'interface',
        ] );
        $userLang = htmlspecialchars( $this->getLanguage()->getHtmlCode() );
 
        if ( !$diff && !$otitle ) {
            $header .= "
            <tr class=\"diff-title\" lang=\"{$userLang}\">
            <td class=\"diff-ntitle\">{$ntitle}</td>
            </tr>";
            $multiColspan = 1;
        } else {
            if ( $diff ) { // Safari/Chrome show broken output if cols not used
                $header .= "
                <col class=\"diff-marker\" />
                <col class=\"diff-content\" />
                <col class=\"diff-marker\" />
                <col class=\"diff-content\" />";
                $colspan = 2;
                $multiColspan = 4;
            } else {
                $colspan = 1;
                $multiColspan = 2;
            }
            if ( $otitle || $ntitle ) {
                // FIXME Hardcoding values from TableDiffFormatter.
                $deletedClass = 'diff-side-deleted';
                $addedClass = 'diff-side-added';
                $header .= "
                <tr class=\"diff-title\" lang=\"{$userLang}\">
                <td colspan=\"$colspan\" class=\"diff-otitle {$deletedClass}\">{$otitle}</td>
                <td colspan=\"$colspan\" class=\"diff-ntitle {$addedClass}\">{$ntitle}</td>
                </tr>";
            }
        }
 
        if ( $multi != '' ) {
            $header .= "<tr><td colspan=\"{$multiColspan}\" " .
                "class=\"diff-multi\" lang=\"{$userLang}\">{$multi}</td></tr>";
        }
        if ( $notice != '' ) {
            $header .= "<tr><td colspan=\"{$multiColspan}\" " .
                "class=\"diff-notice\" lang=\"{$userLang}\">{$notice}</td></tr>";
        }
 
        return $header . $diff . "</table>";
    }
 
    public function setContent( Content $oldContent, Content $newContent ) {
        $this->mOldContent = $oldContent;
        $this->mNewContent = $newContent;
 
        $this->mTextLoaded = 2;
        $this->mRevisionsLoaded = true;
        $this->isContentOverridden = true;
        $this->slotDiffRenderers = null;
    }
 
    public function setRevisions(
        ?RevisionRecord $oldRevision, RevisionRecord $newRevision
    ) {
        if ( $oldRevision ) {
            $this->mOldRevisionRecord = $oldRevision;
            $this->mOldid = $oldRevision->getId();
            $this->mOldPage = Title::newFromPageIdentity( $oldRevision->getPage() );
            // This method is meant for edit diffs and such so there is no reason to provide a
            // revision that's not readable to the user, but check it just in case.
            $this->mOldContent = $oldRevision->getContent( SlotRecord::MAIN,
                RevisionRecord::FOR_THIS_USER, $this->getAuthority() );
            if ( !$this->mOldContent ) {
                $this->addRevisionLoadError( 'old' );
            }
        } else {
            $this->mOldPage = null;
            $this->mOldRevisionRecord = $this->mOldid = false;
        }
        $this->mNewRevisionRecord = $newRevision;
        $this->mNewid = $newRevision->getId();
        $this->mNewPage = Title::newFromPageIdentity( $newRevision->getPage() );
        $this->mNewContent = $newRevision->getContent( SlotRecord::MAIN,
            RevisionRecord::FOR_THIS_USER, $this->getAuthority() );
        if ( !$this->mNewContent ) {
            $this->addRevisionLoadError( 'new' );
        }
 
        $this->mRevisionsIdsLoaded = $this->mRevisionsLoaded = true;
        $this->mTextLoaded = $oldRevision ? 2 : 1;
        $this->isContentOverridden = false;
        $this->slotDiffRenderers = null;
    }
 
    public function setTextLanguage( Language $lang ) {
        $this->mDiffLang = $lang;
    }
 
    public function mapDiffPrevNext( $old, $new ) {
        if ( $new === 'prev' ) {
            // Show diff between revision $old and the previous one. Get previous one from DB.
            $newid = intval( $old );
            $oldid = false;
            $newRev = $this->revisionStore->getRevisionById( $newid );
            if ( $newRev ) {
                $oldRev = $this->revisionStore->getPreviousRevision( $newRev );
                if ( $oldRev ) {
                    $oldid = $oldRev->getId();
                }
            }
        } elseif ( $new === 'next' ) {
            // Show diff between revision $old and the next one. Get next one from DB.
            $oldid = intval( $old );
            $newid = false;
            $oldRev = $this->revisionStore->getRevisionById( $oldid );
            if ( $oldRev ) {
                $newRev = $this->revisionStore->getNextRevision( $oldRev );
                if ( $newRev ) {
                    $newid = $newRev->getId();
                }
            }
        } else {
            $oldid = intval( $old );
            $newid = intval( $new );
        }
 
        // @phan-suppress-next-line PhanTypeMismatchReturn getId does not return null here
        return [ $oldid, $newid ];
    }
 
    private function loadRevisionIds() {
        if ( $this->mRevisionsIdsLoaded ) {
            return;
        }
 
        $this->mRevisionsIdsLoaded = true;
 
        $old = $this->mOldid;
        $new = $this->mNewid;
 
        [ $this->mOldid, $this->mNewid ] = self::mapDiffPrevNext( $old, $new );
        if ( $new === 'next' && $this->mNewid === false ) {
            # if no result, NewId points to the newest old revision. The only newer
            # revision is cur, which is "0".
            $this->mNewid = 0;
        }
 
        $this->hookRunner->onNewDifferenceEngine(
            // @phan-suppress-next-line PhanTypeMismatchArgumentNullable False positive
            $this->getTitle(), $this->mOldid, $this->mNewid, $old, $new );
    }
 
    public function loadRevisionData() {
        if ( $this->mRevisionsLoaded ) {
            return $this->isContentOverridden ||
            ( $this->mOldRevisionRecord !== null && $this->mNewRevisionRecord !== null );
        }
 
        // Whether it succeeds or fails, we don't want to try again
        $this->mRevisionsLoaded = true;
 
        $this->loadRevisionIds();
 
        // Load the new RevisionRecord object
        if ( $this->mNewid ) {
            $this->mNewRevisionRecord = $this->revisionStore->getRevisionById( $this->mNewid );
        } else {
            $this->mNewRevisionRecord = $this->revisionStore->getRevisionByTitle( $this->getTitle() );
        }
 
        if ( !$this->mNewRevisionRecord instanceof RevisionRecord ) {
            return false;
        }
 
        // Update the new revision ID in case it was 0 (makes life easier doing UI stuff)
        $this->mNewid = $this->mNewRevisionRecord->getId();
        $this->mNewPage = $this->mNewid ?
            Title::newFromPageIdentity( $this->mNewRevisionRecord->getPage() ) :
            null;
 
        // Load the old RevisionRecord object
        $this->mOldRevisionRecord = false;
        if ( $this->mOldid ) {
            $this->mOldRevisionRecord = $this->revisionStore->getRevisionById( $this->mOldid );
        } elseif ( $this->mOldid === 0 ) {
            $revRecord = $this->revisionStore->getPreviousRevision( $this->mNewRevisionRecord );
            // No previous revision; mark to show as first-version only.
            $this->mOldid = $revRecord ? $revRecord->getId() : false;
            $this->mOldRevisionRecord = $revRecord ?? false;
        } /* elseif ( $this->mOldid === false ) leave mOldRevisionRecord false; */
 
        if ( $this->mOldRevisionRecord === null ) {
            return false;
        }
 
        if ( $this->mOldRevisionRecord && $this->mOldRevisionRecord->getId() ) {
            $this->mOldPage = Title::newFromPageIdentity( $this->mOldRevisionRecord->getPage() );
        } else {
            $this->mOldPage = null;
        }
 
        // Load tags information for both revisions
        $dbr = $this->dbProvider->getReplicaDatabase();
        $changeTagDefStore = MediaWikiServices::getInstance()->getChangeTagDefStore();
        if ( $this->mOldid !== false ) {
            $tagIds = $dbr->newSelectQueryBuilder()
                ->select( 'ct_tag_id' )
                ->from( 'change_tag' )
                ->where( [ 'ct_rev_id' => $this->mOldid ] )
                ->caller( __METHOD__ )->fetchFieldValues();
            $tags = [];
            foreach ( $tagIds as $tagId ) {
                try {
                    $tags[] = $changeTagDefStore->getName( (int)$tagId );
                } catch ( NameTableAccessException ) {
                    continue;
                }
            }
            $this->mOldTags = implode( ',', $tags );
        } else {
            $this->mOldTags = false;
        }
 
        $tagIds = $dbr->newSelectQueryBuilder()
            ->select( 'ct_tag_id' )
            ->from( 'change_tag' )
            ->where( [ 'ct_rev_id' => $this->mNewid ] )
            ->caller( __METHOD__ )->fetchFieldValues();
        $tags = [];
        foreach ( $tagIds as $tagId ) {
            try {
                $tags[] = $changeTagDefStore->getName( (int)$tagId );
            } catch ( NameTableAccessException ) {
                continue;
            }
        }
        $this->mNewTags = implode( ',', $tags );
 
        return true;
    }
 
    public function loadText() {
        if ( $this->mTextLoaded == 2 ) {
            return $this->loadRevisionData() &&
                ( $this->mOldRevisionRecord === false || $this->mOldContent )
                && $this->mNewContent;
        }
 
        // Whether it succeeds or fails, we don't want to try again
        $this->mTextLoaded = 2;
 
        if ( !$this->loadRevisionData() ) {
            return false;
        }
 
        if ( $this->mOldRevisionRecord ) {
            $this->mOldContent = $this->mOldRevisionRecord->getContent(
                SlotRecord::MAIN,
                RevisionRecord::FOR_THIS_USER,
                $this->getAuthority()
            );
            if ( $this->mOldContent === null ) {
                return false;
            }
        }
 
        $this->mNewContent = $this->mNewRevisionRecord->getContent(
            SlotRecord::MAIN,
            RevisionRecord::FOR_THIS_USER,
            $this->getAuthority()
        );
        $this->hookRunner->onDifferenceEngineLoadTextAfterNewContentIsLoaded( $this );
        if ( $this->mNewContent === null ) {
            return false;
        }
 
        return true;
    }
 
    public function loadNewText() {
        if ( $this->mTextLoaded >= 1 ) {
            return $this->loadRevisionData();
        }
 
        $this->mTextLoaded = 1;
 
        if ( !$this->loadRevisionData() ) {
            return false;
        }
 
        $this->mNewContent = $this->mNewRevisionRecord->getContent(
            SlotRecord::MAIN,
            RevisionRecord::FOR_THIS_USER,
            $this->getAuthority()
        );
 
        $this->hookRunner->onDifferenceEngineAfterLoadNewText( $this );
 
        return true;
    }
 
    protected function getTextDiffer() {
        if ( $this->textDiffer === null ) {
            $this->textDiffer = new ManifoldTextDiffer(
                $this->getContext(),
                $this->getDiffLang(),
                $this->getConfig()->get( MainConfigNames::DiffEngine ),
                $this->getConfig()->get( MainConfigNames::ExternalDiffEngine ),
                $this->getConfig()->get( MainConfigNames::Wikidiff2Options )
            );
        }
        return $this->textDiffer;
    }
 
    public function getSupportedFormats() {
        return $this->getTextDiffer()->getFormats();
    }
 
    public function getTextDiffFormat() {
        return $this->slotDiffOptions['diff-type'] ?? 'table';
    }
 
}