DifferenceEngine.php

Go to the documentation of this file.

<?php
use MediaWiki\Content\IContentHandlerFactory;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Storage\NameTableAccessException;
use MediaWiki\User\UserOptionsLookup;
 
class DifferenceEngine extends ContextSource {
 
    use DeprecationHelper;
 
    private const DIFF_VERSION = '1.12';
 
    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;
 
    public $enableDebugComment = false;
 
    protected $mReducedLineNumbers = false;
 
    protected $mMarkPatrolledLink = null;
 
    protected $unhide = false;
 
    protected $mRefreshCache = false;
 
    protected $slotDiffRenderers = null;
 
    protected $isSlotDiffRenderer = false;
 
    private $slotDiffOptions = [];
 
    protected $linkRenderer;
 
    private $contentHandlerFactory;
 
    private $revisionStore;
 
    private $hookRunner;
 
    private $wikiPageFactory;
 
    private $userOptionsLookup;
 
    public function __construct( $context = null, $old = 0, $new = 0, $rcid = 0,
        $refreshCache = false, $unhide = false
    ) {
        $this->deprecatePublicProperty( 'mOldid', '1.32', __CLASS__ );
        $this->deprecatePublicProperty( 'mNewid', '1.32', __CLASS__ );
        $this->deprecatePublicProperty( 'mOldPage', '1.32', __CLASS__ );
        $this->deprecatePublicProperty( 'mNewPage', '1.32', __CLASS__ );
        $this->deprecatePublicProperty( 'mOldContent', '1.32', __CLASS__ );
        $this->deprecatePublicProperty( 'mNewContent', '1.32', __CLASS__ );
        $this->deprecatePublicProperty( 'mRevisionsLoaded', '1.32', __CLASS__ );
        $this->deprecatePublicProperty( 'mTextLoaded', '1.32', __CLASS__ );
        $this->deprecatePublicProperty( 'mCacheHit', '1.32', __CLASS__ );
 
        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->hookRunner = new HookRunner( $services->getHookContainer() );
        $this->wikiPageFactory = $services->getWikiPageFactory();
        $this->userOptionsLookup = $services->getUserOptionsLookup();
    }
 
    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 = array_map( function ( array $contents ) {
                $content = $contents['new'] ?: $contents['old'];
                return $content->getContentHandler()->getSlotDiffRenderer(
                    $this->getContext(),
                    $this->slotDiffOptions
                );
            }, $slotContents );
        }
 
        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' => isset( $oldSlots[$role] ) ? $oldSlots[$role]->getContent() : null,
                'new' => isset( $newSlots[$role] ) ? $newSlots[$role]->getContent() : null,
            ];
        }
        // move main slot to front
        if ( isset( $slots[SlotRecord::MAIN] ) ) {
            $slots = [ SlotRecord::MAIN => $slots[SlotRecord::MAIN] ] + $slots;
        }
        return $slots;
    }
 
    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() {
        if ( $this->mDiffLang === null ) {
            # Default language in which the diff text is written.
            $this->mDiffLang = $this->getTitle()->getPageLanguage();
        }
 
        return $this->mDiffLang;
    }
 
    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' ) ) {
            $dbr = wfGetDB( DB_REPLICA );
            $arQuery = $this->revisionStore->getArchiveQueryInfo();
            $row = $dbr->selectRow(
                $arQuery['tables'],
                array_merge( $arQuery['fields'], [ 'ar_namespace', 'ar_title' ] ),
                [ 'ar_rev_id' => $id ],
                __METHOD__,
                [],
                $arQuery['joins']
            );
            if ( $row ) {
                $revRecord = $this->revisionStore->newRevisionFromArchiveRow( $row );
                $title = Title::makeTitleSafe( $row->ar_namespace, $row->ar_title );
 
                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->setPageTitle( $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 ) {
        $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->toLegacyErrorArray();
    }
 
    public function hasSuppressedRevision() {
        return $this->hasDeletedRevision() && (
            ( $this->mOldRevisionRecord &&
                $this->mOldRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) ) ||
            ( $this->mNewRevisionRecord &&
                $this->mNewRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) )
        );
    }
 
    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->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();
        $permErrors = $this->getPermissionErrors( $this->getAuthority() );
        if ( $permErrors ) {
            throw new PermissionsError( 'read', $permErrors );
        }
 
        $rollback = '';
 
        $query = $this->slotDiffOptions;
        # 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 = [];
 
        # 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->setPageTitle( $this->msg( 'difference-title', $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->setPageTitle( $this->msg( 'difference-title', $this->mNewPage->getPrefixedText() ) );
                $samePage = true;
            } else {
                $out->setPageTitle( $this->msg( 'difference-title-multipage',
                    $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->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 ) {
                $prevlink = $this->linkRenderer->makeKnownLink(
                    $this->mOldPage,
                    $this->msg( 'previousdiff' )->text(),
                    [ 'id' => 'differences-prevlink' ],
                    [ 'diff' => 'prev', 'oldid' => $this->mOldid ] + $query
                );
            } 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 = Linker::revComment( $oldRevRecord, !$diffOnly, !$this->unhide );
 
            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 ) . '</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() ) {
            $nextlink = $this->linkRenderer->makeKnownLink(
                $this->mNewPage,
                $this->msg( 'nextdiff' )->text(),
                [ 'id' => 'differences-nextlink' ],
                [ 'diff' => 'next', 'oldid' => $this->mNewid ] + $query
            );
        } 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 ],
                $this->msg( 'parentheses' )->rawParams( $tool )->escaped()
            );
            $formattedRevisionTools[] = $element;
        }
 
        $newRevRecord = $this->mNewRevisionRecord;
 
        $newRevisionHeader = $this->getRevisionHeader( $newRevRecord, 'complete' ) .
            ' ' . implode( ' ', $formattedRevisionTools );
        $newChangeTags = ChangeTags::formatSummaryRow( $this->mNewTags, 'diff', $this->getContext() );
        $newRevComment = Linker::revComment( $newRevRecord, !$diffOnly, !$this->unhide );
 
        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</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 );
 
        # 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' ) );
        # 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' );
            }
            $this->showDiff( $oldHeader, $newHeader, $notice );
            if ( !$diffOnly ) {
                $this->renderNewRevision();
            }
        }
    }
 
    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 {
                $this->mMarkPatrolledLink = ' <span class="patrollink" 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()->setPreventClickjacking( true );
                if ( $this->getAuthority()->isAllowed( 'writeapi' ) ) {
                    $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;
            }
 
            $out->setRevisionId( $this->mNewid );
            $out->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 );
                }
 
                $parserOutput = $this->getParserOutput( $wikiPage, $this->mNewRevisionRecord );
 
                # WikiPage::getParserOutput() should not return false, but just in case
                if ( $parserOutput ) {
                    // Allow extensions to change parser output here
                    if ( $this->hookRunner->onDifferenceEngineRenderRevisionAddParserOutput(
                        $this, $out, $parserOutput, $wikiPage )
                    ) {
                        $out->addParserOutput( $parserOutput, [
                            'enableSectionEditLinks' => $this->mNewRevisionRecord->isCurrent()
                                && $this->getAuthority()->probablyCan(
                                    'edit',
                                    $this->mNewRevisionRecord->getPage()
                                ),
                            'absoluteURLs' => $this->slotDiffOptions['expand-url'] ?? false
                        ] );
                    }
                }
            }
        }
 
        // Allow extensions to optionally not show the final patrolled link
        if ( $this->hookRunner->onDifferenceEngineRenderRevisionShowFinalPatrolLink() ) {
            # Add redundant patrol link on bottom...
            $out->addHTML( $this->markPatrolledLink() );
        }
    }
 
    protected function getParserOutput( WikiPage $page, RevisionRecord $revRecord ) {
        if ( !$revRecord->getId() ) {
            // WikiPage::getParserOutput wants a revision ID. Passing 0 will incorrectly show
            // the current revision, so fail instead. If need be, WikiPage::getParserOutput
            // could be made to accept a RevisionRecord instead of the id.
            return false;
        }
 
        $parserOptions = $page->makeParserOptions( $this->getContext() );
        return $page->getParserOutput( $parserOptions, $revRecord->getId() );
    }
 
    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";
        }
 
        return $this->addHeader( $body, $otitle, $ntitle, $multi, $notice );
    }
 
    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 ) {
            // Check if subclass is still using the old way
            // for backwards-compatibility
            $key = $this->getDiffBodyCacheKey();
            if ( $key === null ) {
                $key = $cache->makeKey( ...$this->getDiffBodyCacheKeyParams() );
            }
 
            // Try cache
            if ( !$this->mRefreshCache ) {
                $difftext = $cache->get( $key );
                if ( is_string( $difftext ) ) {
                    $stats->updateCount( 'diff_cache.hit', 1 );
                    $difftext = $this->localiseDiff( $difftext );
                    $difftext .= "\n<!-- diff cache key $key -->\n";
 
                    return $difftext;
                }
            } // don't try to load but save the result
        }
        $this->mCacheHit = false;
 
        // 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 ) {
            $slotDiff = $slotDiffRenderer->getDiff( $slotContents[$role]['old'],
                $slotContents[$role]['new'] );
            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 ) ) {
            $stats->updateCount( 'diff_cache.uncacheable', 1 );
        } elseif ( $key !== false ) {
            $stats->updateCount( 'diff_cache.miss', 1 );
            $cache->set( $key, $difftext, 7 * 86400 );
        } else {
            $stats->updateCount( 'diff_cache.uncacheable', 1 );
        }
        // 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();
        $slotDiff = $diffRenderers[$role]->getDiff( $slotContents[$role]['old'],
            $slotContents[$role]['new'] );
        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 getDiffBodyCacheKey() {
        return null;
    }
 
    protected function getDiffBodyCacheKeyParams() {
        if ( !$this->mOldid || !$this->mNewid ) {
            throw new MWException( 'mOldid and mNewid must be set to get diff cache key.' );
        }
 
        $engine = $this->getEngine();
        $params = [
            'diff',
            $engine === 'php' ? false : $engine, // Back compat
            self::DIFF_VERSION,
            "old-{$this->mOldid}",
            "rev-{$this->mNewid}"
        ];
 
        if ( $engine === 'wikidiff2' ) {
            $params[] = phpversion( 'wikidiff2' );
        }
 
        if ( !$this->isSlotDiffRenderer ) {
            foreach ( $this->getSlotDiffRenderers() as $slotDiffRenderer ) {
                $params = array_merge( $params, $slotDiffRenderer->getExtraCacheKeys() );
            }
        }
 
        return $params;
    }
 
    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.
        $cacheString = $this->getDiffBodyCacheKey();
        if ( $cacheString ) {
            return [ $cacheString ];
        }
 
        $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 ) {
        $this->slotDiffOptions = $options;
    }
 
    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 Exception( 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 Exception( 'The slot diff renderer for text content should be a '
                . 'TextSlotDiffRenderer subclass' );
        }
        return $slotDiffRenderer->getTextDiff( $otext, $ntext ) . $this->getDebugString();
    }
 
    public static function getEngine() {
        $diffEngine = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::DiffEngine );
        $externalDiffEngine = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::ExternalDiffEngine );
 
        if ( $diffEngine === null ) {
            $engines = [ 'external', 'wikidiff2', 'php' ];
        } else {
            $engines = [ $diffEngine ];
        }
 
        $failureReason = null;
        foreach ( $engines as $engine ) {
            switch ( $engine ) {
                case 'external':
                    if ( is_string( $externalDiffEngine ) ) {
                        if ( is_executable( $externalDiffEngine ) ) {
                            return $externalDiffEngine;
                        }
                        $failureReason = 'ExternalDiffEngine config points to a non-executable';
                        if ( $diffEngine === null ) {
                            wfDebug( "$failureReason, ignoring" );
                        }
                    } else {
                        $failureReason = 'ExternalDiffEngine config is set to a non-string value';
                        if ( $diffEngine === null && $externalDiffEngine ) {
                            wfWarn( "$failureReason, ignoring" );
                        }
                    }
                    break;
 
                case 'wikidiff2':
                    if ( function_exists( 'wikidiff2_do_diff' ) ) {
                        return 'wikidiff2';
                    }
                    $failureReason = 'wikidiff2 is not available';
                    break;
 
                case 'php':
                    // Always available.
                    return 'php';
 
                default:
                    throw new DomainException( 'Invalid value for $wgDiffEngine: ' . $engine );
            }
        }
        throw new UnexpectedValueException( "Cannot use diff engine '$engine': $failureReason" );
    }
 
    protected function textDiff( $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 Exception( 'The slot diff renderer for text content should be a '
                . 'TextSlotDiffRenderer subclass' );
        }
        return $slotDiffRenderer->getTextDiff( $otext, $ntext ) . $this->getDebugString();
    }
 
    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 ) {
        $text = $this->localiseLineNumbers( $text );
        if ( $this->getEngine() === 'wikidiff2' &&
            version_compare( phpversion( 'wikidiff2' ), '1.5.1', '>=' )
        ) {
            $text = $this->addLocalisedTitleTooltips( $text );
        }
        return $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
        );
    }
 
    private function addLocalisedTitleTooltips( $text ) {
        return preg_replace_callback(
            '/class="mw-diff-movedpara-(left|right)"/',
            function ( array $matches ) {
                $key = $matches[1] === 'right' ?
                    'diff-paragraph-moved-toold' :
                    'diff-paragraph-moved-tonew';
                return $matches[0] . ' title="' . $this->msg( $key )->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 = $this->revisionStore->countRevisionsBetween(
            $this->mNewPage->getArticleID(),
            $oldRevRecord,
            $newRevRecord,
            1000
        );
        if ( $nEdits > 0 && $nEdits <= 1000 ) {
            $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() : '';
                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 $e ) {
                $numUsers = 0;
            }
 
            return self::intermediateEditsMsg( $nEdits, $numUsers, $limit );
        }
 
        return '';
    }
 
    public static function intermediateEditsMsg( $numEdits, $numUsers, $limit ) {
        if ( $numUsers === 0 ) {
            $msg = 'diff-multi-sameuser';
        } 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();
 
        $header = $this->linkRenderer->makeKnownLink( $title, $header->text(), [],
            [ 'oldid' => $rev->getId() ] );
 
        if ( $this->userCanEdit( $rev ) ) {
            $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->msg( 'parentheses' )->rawParams(
                $this->linkRenderer->makeKnownLink( $title, $msg, [], $editQuery ) )->escaped();
            $header .= ' ' . Html::rawElement(
                'span',
                [ 'class' => 'mw-diff-edit' ],
                $editLink
            );
            if ( $rev->isDeleted( RevisionRecord::DELETED_TEXT ) ) {
                $header = Html::rawElement(
                    'span',
                    [ 'class' => Linker::getRevisionDeletedClass( $rev ) ],
                    $header
                );
            }
        } else {
            $header = Html::rawElement( 'span', [ 'class' => 'history-deleted' ], $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',
                'diff-contentalign-' . $this->getDiffLang()->alignStart(),
                '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::newFromLinkTarget( $oldRevision->getPageAsLinkTarget() );
            // 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() );
        } else {
            $this->mOldPage = null;
            $this->mOldRevisionRecord = $this->mOldid = false;
        }
        $this->mNewRevisionRecord = $newRevision;
        $this->mNewid = $newRevision->getId();
        $this->mNewPage = Title::newFromLinkTarget( $newRevision->getPageAsLinkTarget() );
        $this->mNewContent = $newRevision->getContent( SlotRecord::MAIN,
            RevisionRecord::FOR_THIS_USER, $this->getAuthority() );
 
        $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;
 
        list( $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::newFromLinkTarget( $this->mNewRevisionRecord->getPageAsLinkTarget() ) :
            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::newFromLinkTarget(
                $this->mOldRevisionRecord->getPageAsLinkTarget()
            );
        } else {
            $this->mOldPage = null;
        }
 
        // Load tags information for both revisions
        $dbr = wfGetDB( DB_REPLICA );
        $changeTagDefStore = MediaWikiServices::getInstance()->getChangeTagDefStore();
        if ( $this->mOldid !== false ) {
            $tagIds = $dbr->selectFieldValues(
                'change_tag',
                'ct_tag_id',
                [ 'ct_rev_id' => $this->mOldid ],
                __METHOD__
            );
            $tags = [];
            foreach ( $tagIds as $tagId ) {
                try {
                    $tags[] = $changeTagDefStore->getName( (int)$tagId );
                } catch ( NameTableAccessException $exception ) {
                    continue;
                }
            }
            $this->mOldTags = implode( ',', $tags );
        } else {
            $this->mOldTags = false;
        }
 
        $tagIds = $dbr->selectFieldValues(
            'change_tag',
            'ct_tag_id',
            [ 'ct_rev_id' => $this->mNewid ],
            __METHOD__
        );
        $tags = [];
        foreach ( $tagIds as $tagId ) {
            try {
                $tags[] = $changeTagDefStore->getName( (int)$tagId );
            } catch ( NameTableAccessException $exception ) {
                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;
    }
 
}