WikiPage.php

Go to the documentation of this file.

<?php
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Content\ContentHandlerFactory;
use MediaWiki\Content\IContentHandlerFactory;
use MediaWiki\DAO\WikiAwareEntityTrait;
use MediaWiki\Debug\DeprecatablePropertyArray;
use MediaWiki\Edit\PreparedEdit;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\ParserOutputAccess;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionRenderer;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Revision\SlotRoleRegistry;
use MediaWiki\Storage\DerivedPageDataUpdater;
use MediaWiki\Storage\EditResult;
use MediaWiki\Storage\EditResultCache;
use MediaWiki\Storage\PageUpdater;
use MediaWiki\Storage\RevisionSlotsUpdate;
use MediaWiki\User\UserIdentity;
use Wikimedia\Assert\Assert;
use Wikimedia\Assert\PreconditionException;
use Wikimedia\IPUtils;
use Wikimedia\NonSerializable\NonSerializableTrait;
use Wikimedia\Rdbms\FakeResultWrapper;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\LoadBalancer;
 
class WikiPage implements Page, IDBAccessObject, PageIdentity {
    use NonSerializableTrait;
    use ProtectedHookAccessorTrait;
    use WikiAwareEntityTrait;
 
    // Constants for $mDataLoadedFrom and related
 
    public $mTitle = null;
 
    public $mDataLoaded = false;
 
    public $mIsRedirect = false;
 
    public $mLatest = false;
 
    public $mPreparedEdit = false;
 
    protected $mId = null;
 
    protected $mDataLoadedFrom = self::READ_NONE;
 
    protected $mRedirectTarget = null;
 
    private $mLastRevision = null;
 
    protected $mTimestamp = '';
 
    protected $mTouched = '19700101000000';
 
    protected $mLinksUpdated = '19700101000000';
 
    private $derivedDataUpdater = null;
 
    public function __construct( PageIdentity $pageIdentity ) {
        $pageIdentity->assertWiki( PageIdentity::LOCAL );
 
        // TODO: remove the need for casting to Title.
        $title = Title::castFromPageIdentity( $pageIdentity );
        if ( !$title->canExist() ) {
            // TODO: In order to allow WikiPage to implement ProperPageIdentity,
            //       throw here to prevent construction of a WikiPage that doesn't
            //       represent a proper page.
            wfDeprecatedMsg(
                "WikiPage constructed on a Title that cannot exist as a page: $title",
                '1.36'
            );
        }
 
        $this->mTitle = $title;
    }
 
    public function __clone() {
        $this->mTitle = clone $this->mTitle;
    }
 
    public static function factory( PageIdentity $pageIdentity ) {
        return MediaWikiServices::getInstance()->getWikiPageFactory()->newFromTitle( $pageIdentity );
    }
 
    public static function newFromID( $id, $from = 'fromdb' ) {
        return MediaWikiServices::getInstance()->getWikiPageFactory()->newFromID( $id, $from );
    }
 
    public static function newFromRow( $row, $from = 'fromdb' ) {
        return MediaWikiServices::getInstance()->getWikiPageFactory()->newFromRow( $row, $from );
    }
 
    public static function convertSelectType( $type ) {
        switch ( $type ) {
            case 'fromdb':
                return self::READ_NORMAL;
            case 'fromdbmaster':
                return self::READ_LATEST;
            case 'forupdate':
                return self::READ_LOCKING;
            default:
                // It may already be an integer or whatever else
                return $type;
        }
    }
 
    private function getRevisionStore() {
        return MediaWikiServices::getInstance()->getRevisionStore();
    }
 
    private function getRevisionRenderer() {
        return MediaWikiServices::getInstance()->getRevisionRenderer();
    }
 
    private function getSlotRoleRegistry() {
        return MediaWikiServices::getInstance()->getSlotRoleRegistry();
    }
 
    private function getContentHandlerFactory(): IContentHandlerFactory {
        return MediaWikiServices::getInstance()->getContentHandlerFactory();
    }
 
    private function getParserCache() {
        return MediaWikiServices::getInstance()->getParserCache();
    }
 
    private function getDBLoadBalancer() {
        return MediaWikiServices::getInstance()->getDBLoadBalancer();
    }
 
    public function getActionOverrides() {
        return $this->getContentHandler()->getActionOverrides();
    }
 
    public function getContentHandler() {
        return $this->getContentHandlerFactory()
            ->getContentHandler( $this->getContentModel() );
    }
 
    public function getTitle() {
        return $this->mTitle;
    }
 
    public function clear() {
        $this->mDataLoaded = false;
        $this->mDataLoadedFrom = self::READ_NONE;
 
        $this->clearCacheFields();
    }
 
    protected function clearCacheFields() {
        $this->mId = null;
        $this->mRedirectTarget = null; // Title object if set
        $this->mLastRevision = null; // Latest revision
        $this->mTouched = '19700101000000';
        $this->mLinksUpdated = '19700101000000';
        $this->mTimestamp = '';
        $this->mIsRedirect = false;
        $this->mLatest = false;
        // T59026: do not clear $this->derivedDataUpdater since getDerivedDataUpdater() already
        // checks the requested rev ID and content against the cached one. For most
        // content types, the output should not change during the lifetime of this cache.
        // Clearing it can cause extra parses on edit for no reason.
    }
 
    public function clearPreparedEdit() {
        $this->mPreparedEdit = false;
    }
 
    public static function getQueryInfo() {
        global $wgPageLanguageUseDB;
 
        $ret = [
            'tables' => [ 'page' ],
            'fields' => [
                'page_id',
                'page_namespace',
                'page_title',
                'page_restrictions',
                'page_is_redirect',
                'page_is_new',
                'page_random',
                'page_touched',
                'page_links_updated',
                'page_latest',
                'page_len',
                'page_content_model',
            ],
            'joins' => [],
        ];
 
        if ( $wgPageLanguageUseDB ) {
            $ret['fields'][] = 'page_lang';
        }
 
        return $ret;
    }
 
    protected function pageData( $dbr, $conditions, $options = [] ) {
        $pageQuery = self::getQueryInfo();
 
        $this->getHookRunner()->onArticlePageDataBefore(
            $this, $pageQuery['fields'], $pageQuery['tables'], $pageQuery['joins'] );
 
        $row = $dbr->selectRow(
            $pageQuery['tables'],
            $pageQuery['fields'],
            $conditions,
            __METHOD__,
            $options,
            $pageQuery['joins']
        );
 
        $this->getHookRunner()->onArticlePageDataAfter( $this, $row );
 
        return $row;
    }
 
    public function pageDataFromTitle( $dbr, $title, $options = [] ) {
        if ( !$title->canExist() ) {
            return false;
        }
 
        return $this->pageData( $dbr, [
            'page_namespace' => $title->getNamespace(),
            'page_title' => $title->getDBkey() ], $options );
    }
 
    public function pageDataFromId( $dbr, $id, $options = [] ) {
        return $this->pageData( $dbr, [ 'page_id' => $id ], $options );
    }
 
    public function loadPageData( $from = 'fromdb' ) {
        if ( !$this->mTitle->canExist() ) {
            // NOTE: If and when WikiPage implements PageIdentity but not yet ProperPageIdentity,
            //       throw here to prevent usage of a WikiPage that doesn't
            //       represent a proper page.
            // NOTE: The constructor will already have triggered a warning, but seeing how
            //       bad instances of WikiPage are used will be helpful.
            wfDeprecatedMsg(
                "Accessing WikiPage that cannot exist as a page: {$this->mTitle}. ",
                '1.36'
            );
        }
 
        $from = self::convertSelectType( $from );
        if ( is_int( $from ) && $from <= $this->mDataLoadedFrom ) {
            // We already have the data from the correct location, no need to load it twice.
            return;
        }
 
        if ( is_int( $from ) ) {
            list( $index, $opts ) = DBAccessObjectUtils::getDBOptions( $from );
            $loadBalancer = $this->getDBLoadBalancer();
            $db = $loadBalancer->getConnection( $index );
            $data = $this->pageDataFromTitle( $db, $this->mTitle, $opts );
 
            if ( !$data
                && $index == DB_REPLICA
                && $loadBalancer->getServerCount() > 1
                && $loadBalancer->hasOrMadeRecentMasterChanges()
            ) {
                $from = self::READ_LATEST;
                list( $index, $opts ) = DBAccessObjectUtils::getDBOptions( $from );
                $db = $loadBalancer->getConnection( $index );
                $data = $this->pageDataFromTitle( $db, $this->mTitle, $opts );
            }
        } else {
            // No idea from where the caller got this data, assume replica DB.
            $data = $from;
            $from = self::READ_NORMAL;
        }
 
        $this->loadFromRow( $data, $from );
    }
 
    public function wasLoadedFrom( $from ) {
        $from = self::convertSelectType( $from );
 
        if ( !is_int( $from ) ) {
            // No idea from where the caller got this data, assume replica DB.
            $from = self::READ_NORMAL;
        }
 
        if ( $from <= $this->mDataLoadedFrom ) {
            return true;
        }
 
        return false;
    }
 
    public function loadFromRow( $data, $from ) {
        $lc = MediaWikiServices::getInstance()->getLinkCache();
        $lc->clearLink( $this->mTitle );
 
        if ( $data ) {
            $lc->addGoodLinkObjFromRow( $this->mTitle, $data );
 
            $this->mTitle->loadFromRow( $data );
 
            // Old-fashioned restrictions
            $this->mTitle->loadRestrictions( $data->page_restrictions );
 
            $this->mId = intval( $data->page_id );
            $this->mTouched = MWTimestamp::convert( TS_MW, $data->page_touched );
            $this->mLinksUpdated = $data->page_links_updated === null
                ? null
                : MWTimestamp::convert( TS_MW, $data->page_links_updated );
            $this->mIsRedirect = intval( $data->page_is_redirect );
            $this->mLatest = intval( $data->page_latest );
            // T39225: $latest may no longer match the cached latest RevisionRecord object.
            // Double-check the ID of any cached latest RevisionRecord object for consistency.
            if ( $this->mLastRevision && $this->mLastRevision->getId() != $this->mLatest ) {
                $this->mLastRevision = null;
                $this->mTimestamp = '';
            }
        } else {
            $lc->addBadLinkObj( $this->mTitle );
 
            $this->mTitle->loadFromRow( false );
 
            $this->clearCacheFields();
 
            $this->mId = 0;
        }
 
        $this->mDataLoaded = true;
        $this->mDataLoadedFrom = self::convertSelectType( $from );
    }
 
    private function assertProperPage() {
        Assert::precondition(
            $this->mTitle->canExist(),
            'This WikiPage instance does not represent a proper page!'
        );
    }
 
    public function getId( $wikiId = self::LOCAL ): int {
        $this->assertWiki( $wikiId );
        $this->assertProperPage();
 
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return $this->mId;
    }
 
    public function exists(): bool {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return $this->mId > 0;
    }
 
    public function hasViewableContent() {
        return $this->mTitle->isKnown();
    }
 
    public function isRedirect() {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
 
        return (bool)$this->mIsRedirect;
    }
 
    public function getContentModel() {
        if ( $this->exists() ) {
            $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
 
            return $cache->getWithSetCallback(
                $cache->makeKey( 'page-content-model', $this->getLatest() ),
                $cache::TTL_MONTH,
                function () {
                    $rev = $this->getRevisionRecord();
                    if ( $rev ) {
                        // Look at the revision's actual content model
                        $slot = $rev->getSlot(
                            SlotRecord::MAIN,
                            RevisionRecord::RAW
                        );
                        return $slot->getModel();
                    } else {
                        LoggerFactory::getInstance( 'wikipage' )->warning(
                            'Page exists but has no (visible) revisions!',
                            [
                                'page-title' => $this->mTitle->getPrefixedDBkey(),
                                'page-id' => $this->getId(),
                            ]
                        );
                        return $this->mTitle->getContentModel();
                    }
                },
                [ 'pcTTL' => $cache::TTL_PROC_LONG ]
            );
        }
 
        // use the default model for this page
        return $this->mTitle->getContentModel();
    }
 
    public function checkTouched() {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return ( $this->mId && !$this->mIsRedirect );
    }
 
    public function getTouched() {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return $this->mTouched;
    }
 
    public function getLinksTimestamp() {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return $this->mLinksUpdated;
    }
 
    public function getLatest() {
        if ( !$this->mDataLoaded ) {
            $this->loadPageData();
        }
        return (int)$this->mLatest;
    }
 
    public function getOldestRevision() {
        wfDeprecated( __METHOD__, '1.35' );
        $rev = $this->getRevisionStore()->getFirstRevision( $this->getTitle() );
        return $rev ? new Revision( $rev ) : null;
    }
 
    protected function loadLastEdit() {
        if ( $this->mLastRevision !== null ) {
            return; // already loaded
        }
 
        if ( !$this->mTitle->canExist() ) {
            // NOTE: If and when WikiPage implements PageIdentity but not yet ProperPageIdentity,
            //       throw here to prevent usage of a WikiPage that doesn't
            //       represent a proper page.
            // NOTE: The constructor will already have triggered a warning, but seeing how
            //       bad instances of WikiPage are used will be helpful.
            wfDeprecatedMsg(
                "Accessing WikiPage that cannot exist as a page: {$this->mTitle}. ",
                '1.36'
            );
        }
 
        $latest = $this->getLatest();
        if ( !$latest ) {
            return; // page doesn't exist or is missing page_latest info
        }
 
        if ( $this->mDataLoadedFrom == self::READ_LOCKING ) {
            // T39225: if session S1 loads the page row FOR UPDATE, the result always
            // includes the latest changes committed. This is true even within REPEATABLE-READ
            // transactions, where S1 normally only sees changes committed before the first S1
            // SELECT. Thus we need S1 to also gets the revision row FOR UPDATE; otherwise, it
            // may not find it since a page row UPDATE and revision row INSERT by S2 may have
            // happened after the first S1 SELECT.
            // https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html#isolevel_repeatable-read
            $revision = $this->getRevisionStore()
                ->getRevisionByPageId( $this->getId(), $latest, RevisionStore::READ_LOCKING );
        } elseif ( $this->mDataLoadedFrom == self::READ_LATEST ) {
            // Bug T93976: if page_latest was loaded from the master, fetch the
            // revision from there as well, as it may not exist yet on a replica DB.
            // Also, this keeps the queries in the same REPEATABLE-READ snapshot.
            $revision = $this->getRevisionStore()
                ->getRevisionByPageId( $this->getId(), $latest, RevisionStore::READ_LATEST );
        } else {
            $revision = $this->getRevisionStore()->getKnownCurrentRevision( $this->getTitle(), $latest );
        }
 
        if ( $revision ) { // sanity
            $this->setLastEdit( $revision );
        }
    }
 
    private function setLastEdit( RevisionRecord $revRecord ) {
        $this->mLastRevision = $revRecord;
        $this->mTimestamp = $revRecord->getTimestamp();
    }
 
    public function getRevision() {
        wfDeprecated( __METHOD__, '1.35' );
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            return new Revision( $this->mLastRevision );
        }
        return null;
    }
 
    public function getRevisionRecord() {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            return $this->mLastRevision;
        }
        return null;
    }
 
    public function getContent( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            return $this->mLastRevision->getContent( SlotRecord::MAIN, $audience, $performer );
        }
        return null;
    }
 
    public function getTimestamp() {
        // Check if the field has been filled by WikiPage::setTimestamp()
        if ( !$this->mTimestamp ) {
            $this->loadLastEdit();
        }
 
        return MWTimestamp::convert( TS_MW, $this->mTimestamp );
    }
 
    public function setTimestamp( $ts ) {
        $this->mTimestamp = MWTimestamp::convert( TS_MW, $ts );
    }
 
    public function getUser( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            $revUser = $this->mLastRevision->getUser( $audience, $performer );
            return $revUser ? $revUser->getId() : 0;
        } else {
            return -1;
        }
    }
 
    public function getCreator( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $revRecord = $this->getRevisionStore()->getFirstRevision( $this->getTitle() );
        if ( $revRecord ) {
            return $revRecord->getUser( $audience, $performer );
        } else {
            return null;
        }
    }
 
    public function getUserText( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            $revUser = $this->mLastRevision->getUser( $audience, $performer );
            return $revUser ? $revUser->getName() : '';
        } else {
            return '';
        }
    }
 
    public function getComment( $audience = RevisionRecord::FOR_PUBLIC, Authority $performer = null ) {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            $revComment = $this->mLastRevision->getComment( $audience, $performer );
            return $revComment ? $revComment->text : '';
        } else {
            return '';
        }
    }
 
    public function getMinorEdit() {
        $this->loadLastEdit();
        if ( $this->mLastRevision ) {
            return $this->mLastRevision->isMinor();
        } else {
            return false;
        }
    }
 
    public function isCountable( $editInfo = false ) {
        global $wgArticleCountMethod;
 
        // NOTE: Keep in sync with DerivedPageDataUpdater::isCountable.
 
        if ( !$this->mTitle->isContentPage() ) {
            return false;
        }
 
        if ( $editInfo ) {
            // NOTE: only the main slot can make a page a redirect
            $content = $editInfo->pstContent;
        } else {
            $content = $this->getContent();
        }
 
        if ( !$content || $content->isRedirect() ) {
            return false;
        }
 
        $hasLinks = null;
 
        if ( $wgArticleCountMethod === 'link' ) {
            // nasty special case to avoid re-parsing to detect links
 
            if ( $editInfo ) {
                // ParserOutput::getLinks() is a 2D array of page links, so
                // to be really correct we would need to recurse in the array
                // but the main array should only have items in it if there are
                // links.
                $hasLinks = (bool)count( $editInfo->output->getLinks() );
            } else {
                // NOTE: keep in sync with RevisionRenderer::getLinkCount
                // NOTE: keep in sync with DerivedPageDataUpdater::isCountable
                $hasLinks = (bool)wfGetDB( DB_REPLICA )->selectField( 'pagelinks', '1',
                    [ 'pl_from' => $this->getId() ], __METHOD__ );
            }
        }
 
        // TODO: MCR: determine $hasLinks for each slot, and use that info
        // with that slot's Content's isCountable method. That requires per-
        // slot ParserOutput in the ParserCache, or per-slot info in the
        // pagelinks table.
        return $content->isCountable( $hasLinks );
    }
 
    public function getRedirectTarget() {
        if ( !$this->mTitle->isRedirect() ) {
            return null;
        }
 
        if ( $this->mRedirectTarget !== null ) {
            return $this->mRedirectTarget;
        }
 
        // Query the redirect table
        $dbr = wfGetDB( DB_REPLICA );
        $row = $dbr->selectRow( 'redirect',
            [ 'rd_namespace', 'rd_title', 'rd_fragment', 'rd_interwiki' ],
            [ 'rd_from' => $this->getId() ],
            __METHOD__
        );
 
        // rd_fragment and rd_interwiki were added later, populate them if empty
        if ( $row && $row->rd_fragment !== null && $row->rd_interwiki !== null ) {
            // (T203942) We can't redirect to Media namespace because it's virtual.
            // We don't want to modify Title objects farther down the
            // line. So, let's fix this here by changing to File namespace.
            if ( $row->rd_namespace == NS_MEDIA ) {
                $namespace = NS_FILE;
            } else {
                $namespace = $row->rd_namespace;
            }
            $this->mRedirectTarget = Title::makeTitle(
                $namespace, $row->rd_title,
                $row->rd_fragment, $row->rd_interwiki
            );
            return $this->mRedirectTarget;
        }
 
        // This page doesn't have an entry in the redirect table
        $this->mRedirectTarget = $this->insertRedirect();
        return $this->mRedirectTarget;
    }
 
    public function insertRedirect() {
        $content = $this->getContent();
        $retval = $content ? $content->getUltimateRedirectTarget() : null;
        if ( !$retval ) {
            return null;
        }
 
        // Update the DB post-send if the page has not cached since now
        $latest = $this->getLatest();
        DeferredUpdates::addCallableUpdate(
            function () use ( $retval, $latest ) {
                $this->insertRedirectEntry( $retval, $latest );
            },
            DeferredUpdates::POSTSEND,
            wfGetDB( DB_MASTER )
        );
 
        return $retval;
    }
 
    public function insertRedirectEntry( Title $rt, $oldLatest = null ) {
        $dbw = wfGetDB( DB_MASTER );
        $dbw->startAtomic( __METHOD__ );
 
        if ( !$oldLatest || $oldLatest == $this->lockAndGetLatest() ) {
            $contLang = MediaWikiServices::getInstance()->getContentLanguage();
            $truncatedFragment = $contLang->truncateForDatabase( $rt->getFragment(), 255 );
            $dbw->upsert(
                'redirect',
                [
                    'rd_from' => $this->getId(),
                    'rd_namespace' => $rt->getNamespace(),
                    'rd_title' => $rt->getDBkey(),
                    'rd_fragment' => $truncatedFragment,
                    'rd_interwiki' => $rt->getInterwiki(),
                ],
                'rd_from',
                [
                    'rd_namespace' => $rt->getNamespace(),
                    'rd_title' => $rt->getDBkey(),
                    'rd_fragment' => $truncatedFragment,
                    'rd_interwiki' => $rt->getInterwiki(),
                ],
                __METHOD__
            );
            $success = true;
        } else {
            $success = false;
        }
 
        $dbw->endAtomic( __METHOD__ );
 
        return $success;
    }
 
    public function followRedirect() {
        return $this->getRedirectURL( $this->getRedirectTarget() );
    }
 
    public function getRedirectURL( $rt ) {
        if ( !$rt ) {
            return false;
        }
 
        if ( $rt->isExternal() ) {
            if ( $rt->isLocal() ) {
                // Offsite wikis need an HTTP redirect.
                // This can be hard to reverse and may produce loops,
                // so they may be disabled in the site configuration.
                $source = $this->mTitle->getFullURL( 'redirect=no' );
                return $rt->getFullURL( [ 'rdfrom' => $source ] );
            } else {
                // External pages without "local" bit set are not valid
                // redirect targets
                return false;
            }
        }
 
        if ( $rt->isSpecialPage() ) {
            // Gotta handle redirects to special pages differently:
            // Fill the HTTP response "Location" header and ignore the rest of the page we're on.
            // Some pages are not valid targets.
            if ( $rt->isValidRedirectTarget() ) {
                return $rt->getFullURL();
            } else {
                return false;
            }
        }
 
        return $rt;
    }
 
    public function getContributors() {
        // @todo: This is expensive; cache this info somewhere.
 
        $dbr = wfGetDB( DB_REPLICA );
 
        $actorMigration = ActorMigration::newMigration();
        $actorQuery = $actorMigration->getJoin( 'rev_user' );
 
        $tables = array_merge( [ 'revision' ], $actorQuery['tables'], [ 'user' ] );
 
        $revactor_actor = $actorQuery['fields']['rev_actor'];
        $fields = [
            'user_id' => $actorQuery['fields']['rev_user'],
            'user_name' => $actorQuery['fields']['rev_user_text'],
            'actor_id' => "MIN($revactor_actor)",
            'user_real_name' => 'MIN(user_real_name)',
            'timestamp' => 'MAX(rev_timestamp)',
        ];
 
        $conds = [ 'rev_page' => $this->getId() ];
 
        // The user who made the top revision gets credited as "this page was last edited by
        // John, based on contributions by Tom, Dick and Harry", so don't include them twice.
        $user = $this->getUser()
            ? User::newFromId( $this->getUser() )
            : User::newFromName( $this->getUserText(), false );
        $conds[] = 'NOT(' . $actorMigration->getWhere( $dbr, 'rev_user', $user )['conds'] . ')';
 
        // Username hidden?
        $conds[] = "{$dbr->bitAnd( 'rev_deleted', RevisionRecord::DELETED_USER )} = 0";
 
        $jconds = [
            'user' => [ 'LEFT JOIN', $actorQuery['fields']['rev_user'] . ' = user_id' ],
        ] + $actorQuery['joins'];
 
        $options = [
            'GROUP BY' => [ $fields['user_id'], $fields['user_name'] ],
            'ORDER BY' => 'timestamp DESC',
        ];
 
        $res = $dbr->select( $tables, $fields, $conds, __METHOD__, $options, $jconds );
        return new UserArrayFromResult( $res );
    }
 
    public function shouldCheckParserCache( ParserOptions $parserOptions, $oldId ) {
        // NOTE: Keep in sync with ParserOutputAccess::shouldUseCache().
        // TODO: Once ParserOutputAccess is stable, deprecated this method.
        return $this->exists()
            && ( $oldId === null || $oldId === 0 || $oldId === $this->getLatest() )
            && $this->getContentHandler()->isParserCacheSupported();
    }
 
    public function getParserOutput(
        ParserOptions $parserOptions, $oldid = null, $noCache = false
    ) {
        if ( $oldid ) {
            $revision = $this->getRevisionStore()->getRevisionByTitle( $this->getTitle(), $oldid );
 
            if ( !$revision ) {
                return false;
            }
        } else {
            $revision = $this->getRevisionRecord();
        }
 
        $options = $noCache ? ParserOutputAccess::OPT_NO_CACHE : 0;
 
        $status = MediaWikiServices::getInstance()->getParserOutputAccess()->getParserOutput(
            $this, $parserOptions, $revision, $options
        );
        return $status->isOK() ? $status->getValue() : false; // convert null to false
    }
 
    public function doViewUpdates( User $user, $oldid = 0 ) {
        if ( wfReadOnly() ) {
            return;
        }
 
        // Update newtalk / watchlist notification status;
        // Avoid outage if the master is not reachable by using a deferred updated
        DeferredUpdates::addCallableUpdate(
            function () use ( $user, $oldid ) {
                $this->getHookRunner()->onPageViewUpdates( $this, $user );
 
                $user->clearNotification( $this->mTitle, $oldid );
            },
            DeferredUpdates::PRESEND
        );
    }
 
    public function doPurge() {
        if ( !$this->getHookRunner()->onArticlePurge( $this ) ) {
            return false;
        }
 
        $this->mTitle->invalidateCache();
 
        // Clear file cache and send purge after above page_touched update was committed
        $hcu = MediaWikiServices::getInstance()->getHtmlCacheUpdater();
        $hcu->purgeTitleUrls( $this->mTitle, $hcu::PURGE_PRESEND );
 
        if ( $this->mTitle->getNamespace() === NS_MEDIAWIKI ) {
            MediaWikiServices::getInstance()->getMessageCache()
                ->updateMessageOverride( $this->mTitle, $this->getContent() );
        }
 
        return true;
    }
 
    public function insertOn( $dbw, $pageId = null ) {
        $this->assertProperPage();
 
        $pageIdForInsert = $pageId ? [ 'page_id' => $pageId ] : [];
        $dbw->insert(
            'page',
            [
                'page_namespace'    => $this->mTitle->getNamespace(),
                'page_title'        => $this->mTitle->getDBkey(),
                'page_restrictions' => '',
                'page_is_redirect'  => 0, // Will set this shortly...
                'page_is_new'       => 1,
                'page_random'       => wfRandom(),
                'page_touched'      => $dbw->timestamp(),
                'page_latest'       => 0, // Fill this in shortly...
                'page_len'          => 0, // Fill this in shortly...
            ] + $pageIdForInsert,
            __METHOD__,
            [ 'IGNORE' ]
        );
 
        if ( $dbw->affectedRows() > 0 ) {
            $newid = $pageId ? (int)$pageId : $dbw->insertId();
            $this->mId = $newid;
            $this->mTitle->resetArticleID( $newid );
 
            return $newid;
        } else {
            return false; // nothing changed
        }
    }
 
    public function updateRevisionOn( $dbw, $revision, $lastRevision = null,
        $lastRevIsRedirect = null
    ) {
        // TODO: move into PageUpdater or PageStore
        // NOTE: when doing that, make sure cached fields get reset in doEditContent,
        // and in the compat stub!
 
        // Assertion to try to catch T92046
        if ( (int)$revision->getId() === 0 ) {
            throw new InvalidArgumentException(
                __METHOD__ . ': Revision has ID ' . var_export( $revision->getId(), 1 )
            );
        }
 
        if ( $revision instanceof Revision ) {
            wfDeprecated( __METHOD__ . ' with a Revision object', '1.35' );
            $revision = $revision->getRevisionRecord();
        }
 
        $content = $revision->getContent( SlotRecord::MAIN );
        $len = $content ? $content->getSize() : 0;
        $rt = $content ? $content->getUltimateRedirectTarget() : null;
 
        $conditions = [ 'page_id' => $this->getId() ];
 
        if ( $lastRevision !== null ) {
            // An extra check against threads stepping on each other
            $conditions['page_latest'] = $lastRevision;
        }
 
        $revId = $revision->getId();
        Assert::parameter( $revId > 0, '$revision->getId()', 'must be > 0' );
 
        $model = $revision->getSlot( SlotRecord::MAIN, RevisionRecord::RAW )->getModel();
 
        $row = [ /* SET */
            'page_latest'        => $revId,
            'page_touched'       => $dbw->timestamp( $revision->getTimestamp() ),
            'page_is_new'        => ( $lastRevision === 0 ) ? 1 : 0,
            'page_is_redirect'   => $rt !== null ? 1 : 0,
            'page_len'           => $len,
            'page_content_model' => $model,
        ];
 
        $dbw->update( 'page',
            $row,
            $conditions,
            __METHOD__ );
 
        $result = $dbw->affectedRows() > 0;
        if ( $result ) {
            $this->updateRedirectOn( $dbw, $rt, $lastRevIsRedirect );
            $this->setLastEdit( $revision );
            $this->mLatest = $revision->getId();
            $this->mIsRedirect = (bool)$rt;
            // Update the LinkCache.
            $linkCache = MediaWikiServices::getInstance()->getLinkCache();
            $linkCache->addGoodLinkObj(
                $this->getId(),
                $this->mTitle,
                $len,
                $this->mIsRedirect,
                $this->mLatest,
                $model
            );
        }
 
        return $result;
    }
 
    public function updateRedirectOn( $dbw, $redirectTitle, $lastRevIsRedirect = null ) {
        // Always update redirects (target link might have changed)
        // Update/Insert if we don't know if the last revision was a redirect or not
        // Delete if changing from redirect to non-redirect
        $isRedirect = $redirectTitle !== null;
 
        if ( !$isRedirect && $lastRevIsRedirect === false ) {
            return true;
        }
 
        if ( $isRedirect ) {
            $success = $this->insertRedirectEntry( $redirectTitle );
        } else {
            // This is not a redirect, remove row from redirect table
            $where = [ 'rd_from' => $this->getId() ];
            $dbw->delete( 'redirect', $where, __METHOD__ );
            $success = true;
        }
 
        if ( $this->getTitle()->getNamespace() === NS_FILE ) {
            MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo()
                ->invalidateImageRedirect( $this->getTitle() );
        }
 
        return $success;
    }
 
    public function updateIfNewerOn( $dbw, $revision ) {
        wfDeprecated( __METHOD__, '1.24' );
 
        $revisionRecord = $revision->getRevisionRecord();
 
        $row = $dbw->selectRow(
            [ 'revision', 'page' ],
            [ 'rev_id', 'rev_timestamp', 'page_is_redirect' ],
            [
                'page_id' => $this->getId(),
                'page_latest=rev_id'
            ],
            __METHOD__
        );
 
        if ( $row ) {
            $rowTimestamp = MWTimestamp::convert( TS_MW, $row->rev_timestamp );
            if ( $rowTimestamp >= $revisionRecord->getTimestamp() ) {
                return false;
            }
            $prev = $row->rev_id;
            $lastRevIsRedirect = (bool)$row->page_is_redirect;
        } else {
            // No or missing previous revision; mark the page as new
            $prev = 0;
            $lastRevIsRedirect = null;
        }
 
        $ret = $this->updateRevisionOn(
            $dbw,
            $revisionRecord,
            $prev,
            $lastRevIsRedirect
        );
 
        return $ret;
    }
 
    public static function hasDifferencesOutsideMainSlot( $a, $b ) {
        if ( $a instanceof Revision ) {
            wfDeprecated( __METHOD__ . ' with Revision objects', '1.35' );
            $a = $a->getRevisionRecord();
        }
        if ( $b instanceof Revision ) {
            wfDeprecated( __METHOD__ . ' with Revision objects', '1.35' );
            $b = $b->getRevisionRecord();
        }
        $aSlots = $a->getSlots();
        $bSlots = $b->getSlots();
        $changedRoles = $aSlots->getRolesWithDifferentContent( $bSlots );
 
        return ( $changedRoles !== [ SlotRecord::MAIN ] && $changedRoles !== [] );
    }
 
    public function getUndoContent( Revision $undo, Revision $undoafter ) {
        wfDeprecated( __METHOD__, '1.35' );
        // TODO: MCR: replace this with a method that returns a RevisionSlotsUpdate
 
        if ( self::hasDifferencesOutsideMainSlot(
            $undo->getRevisionRecord(),
            $undoafter->getRevisionRecord()
        ) ) {
            // Cannot yet undo edits that involve anything other the main slot.
            return false;
        }
 
        $handler = $undo->getContentHandler();
 
        // TODO remove use of Revision objects by deprecating this method entirely
        $revRecord = $this->getRevisionRecord();
        $revision = $revRecord ? new Revision( $revRecord ) : null;
        return $handler->getUndoContent( $revision, $undo, $undoafter );
    }
 
    public function supportsSections() {
        return $this->getContentHandler()->supportsSections();
    }
 
    public function replaceSectionContent(
        $sectionId, Content $sectionContent, $sectionTitle = '', $edittime = null
    ) {
        $baseRevId = null;
        if ( $edittime && $sectionId !== 'new' ) {
            $lb = $this->getDBLoadBalancer();
            $rev = $this->getRevisionStore()->getRevisionByTimestamp( $this->mTitle, $edittime );
            // Try the master if this thread may have just added it.
            // This could be abstracted into a Revision method, but we don't want
            // to encourage loading of revisions by timestamp.
            if ( !$rev
                && $lb->getServerCount() > 1
                && $lb->hasOrMadeRecentMasterChanges()
            ) {
                $rev = $this->getRevisionStore()->getRevisionByTimestamp(
                    $this->mTitle, $edittime, RevisionStore::READ_LATEST );
            }
            if ( $rev ) {
                $baseRevId = $rev->getId();
            }
        }
 
        return $this->replaceSectionAtRev( $sectionId, $sectionContent, $sectionTitle, $baseRevId );
    }
 
    public function replaceSectionAtRev( $sectionId, Content $sectionContent,
        $sectionTitle = '', $baseRevId = null
    ) {
        if ( strval( $sectionId ) === '' ) {
            // Whole-page edit; let the whole text through
            $newContent = $sectionContent;
        } else {
            if ( !$this->supportsSections() ) {
                throw new MWException( "sections not supported for content model " .
                    $this->getContentHandler()->getModelID() );
            }
 
            // T32711: always use current version when adding a new section
            if ( $baseRevId === null || $sectionId === 'new' ) {
                $oldContent = $this->getContent();
            } else {
                $revRecord = $this->getRevisionStore()->getRevisionById( $baseRevId );
                if ( !$revRecord ) {
                    wfDebug( __METHOD__ . " asked for bogus section (page: " .
                        $this->getId() . "; section: $sectionId)" );
                    return null;
                }
 
                $oldContent = $revRecord->getContent( SlotRecord::MAIN );
            }
 
            if ( !$oldContent ) {
                wfDebug( __METHOD__ . ": no page text" );
                return null;
            }
 
            $newContent = $oldContent->replaceSection( $sectionId, $sectionContent, $sectionTitle );
        }
 
        return $newContent;
    }
 
    public function checkFlags( $flags ) {
        if ( !( $flags & EDIT_NEW ) && !( $flags & EDIT_UPDATE ) ) {
            if ( $this->exists() ) {
                $flags |= EDIT_UPDATE;
            } else {
                $flags |= EDIT_NEW;
            }
        }
 
        return $flags;
    }
 
    private function newDerivedDataUpdater() {
        global $wgRCWatchCategoryMembership, $wgArticleCountMethod;
 
        $services = MediaWikiServices::getInstance();
        $editResultCache = new EditResultCache(
            $services->getMainObjectStash(),
            $services->getDBLoadBalancer(),
            new ServiceOptions(
                EditResultCache::CONSTRUCTOR_OPTIONS,
                $services->getMainConfig()
            )
        );
 
        $derivedDataUpdater = new DerivedPageDataUpdater(
            $this, // NOTE: eventually, PageUpdater should not know about WikiPage
            $this->getRevisionStore(),
            $this->getRevisionRenderer(),
            $this->getSlotRoleRegistry(),
            $this->getParserCache(),
            JobQueueGroup::singleton(),
            $services->getMessageCache(),
            $services->getContentLanguage(),
            $services->getDBLoadBalancerFactory(),
            $this->getContentHandlerFactory(),
            $this->getHookContainer(),
            $editResultCache
        );
 
        $derivedDataUpdater->setLogger( LoggerFactory::getInstance( 'SaveParse' ) );
        $derivedDataUpdater->setRcWatchCategoryMembership( $wgRCWatchCategoryMembership );
        $derivedDataUpdater->setArticleCountMethod( $wgArticleCountMethod );
 
        return $derivedDataUpdater;
    }
 
    private function getDerivedDataUpdater(
        User $forUser = null,
        RevisionRecord $forRevision = null,
        RevisionSlotsUpdate $forUpdate = null,
        $forEdit = false
    ) {
        if ( !$forRevision && !$forUpdate ) {
            // NOTE: can't re-use an existing derivedDataUpdater if we don't know what the caller is
            // going to use it with.
            $this->derivedDataUpdater = null;
        }
 
        if ( $this->derivedDataUpdater && !$this->derivedDataUpdater->isContentPrepared() ) {
            // NOTE: can't re-use an existing derivedDataUpdater if other code that has a reference
            // to it did not yet initialize it, because we don't know what data it will be
            // initialized with.
            $this->derivedDataUpdater = null;
        }
 
        // XXX: It would be nice to have an LRU cache instead of trying to re-use a single instance.
        // However, there is no good way to construct a cache key. We'd need to check against all
        // cached instances.
 
        if ( $this->derivedDataUpdater
            && !$this->derivedDataUpdater->isReusableFor(
                $forUser,
                $forRevision,
                $forUpdate,
                $forEdit ? $this->getLatest() : null
            )
        ) {
            $this->derivedDataUpdater = null;
        }
 
        if ( !$this->derivedDataUpdater ) {
            $this->derivedDataUpdater = $this->newDerivedDataUpdater();
        }
 
        return $this->derivedDataUpdater;
    }
 
    public function newPageUpdater( User $user, RevisionSlotsUpdate $forUpdate = null ) {
        $this->assertProperPage();
 
        $config = MediaWikiServices::getInstance()->getMainConfig();
 
        $pageUpdater = new PageUpdater(
            $user,
            $this, // NOTE: eventually, PageUpdater should not know about WikiPage
            $this->getDerivedDataUpdater( $user, null, $forUpdate, true ),
            $this->getDBLoadBalancer(),
            $this->getRevisionStore(),
            $this->getSlotRoleRegistry(),
            $this->getContentHandlerFactory(),
            $this->getHookContainer(),
            new ServiceOptions(
                PageUpdater::CONSTRUCTOR_OPTIONS,
                $config
            ),
            ChangeTags::getSoftwareTags()
        );
 
        $pageUpdater->setUsePageCreationLog( $config->get( 'PageCreationLog' ) );
        $pageUpdater->setAjaxEditStash( $config->get( 'AjaxEditStash' ) );
        $pageUpdater->setUseAutomaticEditSummaries(
            $config->get( 'UseAutomaticEditSummaries' )
        );
 
        return $pageUpdater;
    }
 
    public function doEditContent(
        Content $content, $summary, $flags = 0, $originalRevId = false,
        Authority $performer = null, $serialFormat = null, $tags = [], $undidRevId = 0
    ) {
        global $wgUser;
 
        if ( !$performer ) {
            $performer = $wgUser;
        }
 
        return $this->doUserEditContent(
            $content, $performer, $summary, $flags, $originalRevId, $tags, $undidRevId
        );
    }
 
    public function doUserEditContent(
        Content $content,
        Authority $performer,
        $summary,
        $flags = 0,
        $originalRevId = false,
        $tags = [],
        $undidRevId = 0
    ) {
        global $wgUseNPPatrol, $wgUseRCPatrol;
 
        if ( !( $summary instanceof CommentStoreComment ) ) {
            $summary = CommentStoreComment::newUnsavedComment( trim( $summary ) );
        }
 
        // TODO: this check is here for backwards-compatibility with 1.31 behavior.
        // Checking the minoredit right should be done in the same place the 'bot' right is
        // checked for the EDIT_FORCE_BOT flag, which is currently in EditPage::attemptSave.
        if ( ( $flags & EDIT_MINOR ) && !$performer->isAllowed( 'minoredit' ) ) {
            $flags &= ~EDIT_MINOR;
        }
 
        $slotsUpdate = new RevisionSlotsUpdate();
        $slotsUpdate->modifyContent( SlotRecord::MAIN, $content );
 
        // NOTE: while doUserEditContent() executes, callbacks to getDerivedDataUpdater and
        // prepareContentForEdit will generally use the DerivedPageDataUpdater that is also
        // used by this PageUpdater. However, there is no guarantee for this.
        $user = MediaWikiServices::getInstance()->getUserFactory()->newFromAuthority( $performer );
        $updater = $this->newPageUpdater( $user, $slotsUpdate );
        $updater->setContent( SlotRecord::MAIN, $content );
 
        $revisionStore = $this->getRevisionStore();
        $originalRevision = $originalRevId ? $revisionStore->getRevisionById( $originalRevId ) : null;
        if ( $originalRevision && $undidRevId !== 0 ) {
            // Mark it as a revert if it's an undo
            $oldestRevertedRev = $revisionStore->getNextRevision( $originalRevision );
            if ( $oldestRevertedRev ) {
                $updater->markAsRevert(
                    EditResult::REVERT_UNDO,
                    $oldestRevertedRev->getId(),
                    $undidRevId
                );
            } else {
                // We can't find the oldest reverted revision for some reason
                $updater->markAsRevert( EditResult::REVERT_UNDO, $undidRevId );
            }
        } elseif ( $undidRevId !== 0 ) {
            // It's an undo, but the original revision is not specified, fall back to just
            // marking it as an undo with one revision undone.
            $updater->markAsRevert( EditResult::REVERT_UNDO, $undidRevId );
            // Try finding the original revision ID by assuming it's the one before the edit
            // that is being undone. If the bet fails, $originalRevision is ignored anyway, so
            // no damage is done.
            $undidRevision = $revisionStore->getRevisionById( $undidRevId );
            if ( $undidRevision ) {
                $originalRevision = $revisionStore->getPreviousRevision( $undidRevision );
            }
        }
 
        // Make sure original revision's content is the same as the new content and save the
        // original revision ID.
        if ( $originalRevision &&
            $originalRevision->getContent( SlotRecord::MAIN )->equals( $content )
        ) {
            $updater->setOriginalRevisionId( $originalRevision->getId() );
        }
 
        $needsPatrol = $wgUseRCPatrol || ( $wgUseNPPatrol && !$this->exists() );
 
        // TODO: this logic should not be in the storage layer, it's here for compatibility
        // with 1.31 behavior. Applying the 'autopatrol' right should be done in the same
        // place the 'bot' right is handled, which is currently in EditPage::attemptSave.
 
        if ( $needsPatrol && $performer->authorizeWrite( 'autopatrol', $this->getTitle() ) ) {
            $updater->setRcPatrolStatus( RecentChange::PRC_AUTOPATROLLED );
        }
 
        $updater->addTags( $tags );
 
        $revRec = $updater->saveRevision(
            $summary,
            $flags
        );
 
        // $revRec will be null if the edit failed, or if no new revision was created because
        // the content did not change.
        if ( $revRec ) {
            // update cached fields
            // TODO: this is currently redundant to what is done in updateRevisionOn.
            // But updateRevisionOn() should move into PageStore, and then this will be needed.
            $this->setLastEdit( $revRec );
            $this->mLatest = $revRec->getId();
        }
 
        return $updater->getStatus();
    }
 
    public function makeParserOptions( $context ) {
        $options = ParserOptions::newCanonical( $context );
 
        if ( $this->getTitle()->isConversionTable() ) {
            // @todo ConversionTable should become a separate content model, so
            // we don't need special cases like this one.
            $options->disableContentConversion();
        }
 
        return $options;
    }
 
    public function prepareContentForEdit(
        Content $content,
        $revision = null,
        User $user = null,
        $serialFormat = null,
        $useCache = true
    ) {
        global $wgUser;
 
        if ( !$user ) {
            $user = $wgUser;
        }
 
        if ( $revision !== null ) {
            if ( $revision instanceof Revision ) {
                wfDeprecated( __METHOD__ . ' with a Revision object', '1.35' );
                $revision = $revision->getRevisionRecord();
            } elseif ( !( $revision instanceof RevisionRecord ) ) {
                throw new InvalidArgumentException(
                    __METHOD__ . ': invalid $revision argument type ' . gettype( $revision ) );
            }
        }
 
        $slots = RevisionSlotsUpdate::newFromContent( [ SlotRecord::MAIN => $content ] );
        $updater = $this->getDerivedDataUpdater( $user, $revision, $slots );
 
        if ( !$updater->isUpdatePrepared() ) {
            $updater->prepareContent( $user, $slots, $useCache );
 
            if ( $revision ) {
                $updater->prepareUpdate(
                    $revision,
                    [
                        'causeAction' => 'prepare-edit',
                        'causeAgent' => $user->getName(),
                    ]
                );
            }
        }
 
        return $updater->getPreparedEdit();
    }
 
    public function doEditUpdates( $revisionRecord, User $user, array $options = [] ) {
        if ( $revisionRecord instanceof Revision ) {
            wfDeprecated( __METHOD__ . ' with a Revision object', '1.35' );
            $revisionRecord = $revisionRecord->getRevisionRecord();
        }
        if ( isset( $options['oldrevision'] ) && $options['oldrevision'] instanceof Revision ) {
            wfDeprecated(
                __METHOD__ . ' with the `oldrevision` option being a ' .
                'Revision object',
                '1.35'
            );
            $options['oldrevision'] = $options['oldrevision']->getRevisionRecord();
        }
 
        $options += [
            'causeAction' => 'edit-page',
            'causeAgent' => $user->getName(),
        ];
 
        $updater = $this->getDerivedDataUpdater( $user, $revisionRecord );
 
        $updater->prepareUpdate( $revisionRecord, $options );
 
        $updater->doUpdates();
    }
 
    public function updateParserCache( array $options = [] ) {
        $revision = $this->getRevisionRecord();
        if ( !$revision || !$revision->getId() ) {
            LoggerFactory::getInstance( 'wikipage' )->info(
                __METHOD__ . 'called with ' . ( $revision ? 'unsaved' : 'no' ) . ' revision'
            );
            return;
        }
        $user = User::newFromIdentity( $revision->getUser( RevisionRecord::RAW ) );
 
        $updater = $this->getDerivedDataUpdater( $user, $revision );
        $updater->prepareUpdate( $revision, $options );
        $updater->doParserCacheUpdate();
    }
 
    public function doSecondaryDataUpdates( array $options = [] ) {
        $options['recursive'] = $options['recursive'] ?? true;
        $revision = $this->getRevisionRecord();
        if ( !$revision || !$revision->getId() ) {
            LoggerFactory::getInstance( 'wikipage' )->info(
                __METHOD__ . 'called with ' . ( $revision ? 'unsaved' : 'no' ) . ' revision'
            );
            return;
        }
        $user = User::newFromIdentity( $revision->getUser( RevisionRecord::RAW ) );
 
        $updater = $this->getDerivedDataUpdater( $user, $revision );
        $updater->prepareUpdate( $revision, $options );
        $updater->doSecondaryDataUpdates( $options );
    }
 
    public function doUpdateRestrictions( array $limit, array $expiry,
        &$cascade, $reason, User $user, $tags = null
    ) {
        global $wgCascadingRestrictionLevels;
 
        $this->assertProperPage();
 
        if ( wfReadOnly() ) {
            return Status::newFatal( wfMessage( 'readonlytext', wfReadOnlyReason() ) );
        }
 
        $this->loadPageData( 'fromdbmaster' );
        $this->mTitle->loadRestrictions( null, Title::READ_LATEST );
        $restrictionTypes = $this->mTitle->getRestrictionTypes();
        $id = $this->getId();
 
        if ( !$cascade ) {
            $cascade = false;
        }
 
        // Take this opportunity to purge out expired restrictions
        Title::purgeExpiredRestrictions();
 
        // @todo: Same limitations as described in ProtectionForm.php (line 37);
        // we expect a single selection, but the schema allows otherwise.
        $isProtected = false;
        $protect = false;
        $changed = false;
 
        $dbw = wfGetDB( DB_MASTER );
 
        foreach ( $restrictionTypes as $action ) {
            if ( !isset( $expiry[$action] ) || $expiry[$action] === $dbw->getInfinity() ) {
                $expiry[$action] = 'infinity';
            }
            if ( !isset( $limit[$action] ) ) {
                $limit[$action] = '';
            } elseif ( $limit[$action] != '' ) {
                $protect = true;
            }
 
            // Get current restrictions on $action
            $current = implode( '', $this->mTitle->getRestrictions( $action ) );
            if ( $current != '' ) {
                $isProtected = true;
            }
 
            if ( $limit[$action] != $current ) {
                $changed = true;
            } elseif ( $limit[$action] != '' ) {
                // Only check expiry change if the action is actually being
                // protected, since expiry does nothing on an not-protected
                // action.
                if ( $this->mTitle->getRestrictionExpiry( $action ) != $expiry[$action] ) {
                    $changed = true;
                }
            }
        }
 
        if ( !$changed && $protect && $this->mTitle->areRestrictionsCascading() != $cascade ) {
            $changed = true;
        }
 
        // If nothing has changed, do nothing
        if ( !$changed ) {
            return Status::newGood();
        }
 
        if ( !$protect ) { // No protection at all means unprotection
            $revCommentMsg = 'unprotectedarticle-comment';
            $logAction = 'unprotect';
        } elseif ( $isProtected ) {
            $revCommentMsg = 'modifiedarticleprotection-comment';
            $logAction = 'modify';
        } else {
            $revCommentMsg = 'protectedarticle-comment';
            $logAction = 'protect';
        }
 
        $logRelationsValues = [];
        $logRelationsField = null;
        $logParamsDetails = [];
 
        // Null revision (used for change tag insertion)
        $nullRevision = null;
 
        if ( $id ) { // Protection of existing page
            if ( !$this->getHookRunner()->onArticleProtect( $this, $user, $limit, $reason ) ) {
                return Status::newGood();
            }
 
            // Only certain restrictions can cascade...
            $editrestriction = isset( $limit['edit'] )
                ? [ $limit['edit'] ]
                : $this->mTitle->getRestrictions( 'edit' );
            foreach ( array_keys( $editrestriction, 'sysop' ) as $key ) {
                $editrestriction[$key] = 'editprotected'; // backwards compatibility
            }
            foreach ( array_keys( $editrestriction, 'autoconfirmed' ) as $key ) {
                $editrestriction[$key] = 'editsemiprotected'; // backwards compatibility
            }
 
            $cascadingRestrictionLevels = $wgCascadingRestrictionLevels;
            foreach ( array_keys( $cascadingRestrictionLevels, 'sysop' ) as $key ) {
                $cascadingRestrictionLevels[$key] = 'editprotected'; // backwards compatibility
            }
            foreach ( array_keys( $cascadingRestrictionLevels, 'autoconfirmed' ) as $key ) {
                $cascadingRestrictionLevels[$key] = 'editsemiprotected'; // backwards compatibility
            }
 
            // The schema allows multiple restrictions
            if ( !array_intersect( $editrestriction, $cascadingRestrictionLevels ) ) {
                $cascade = false;
            }
 
            // insert null revision to identify the page protection change as edit summary
            $latest = $this->getLatest();
            $nullRevisionRecord = $this->insertNullProtectionRevision(
                $revCommentMsg,
                $limit,
                $expiry,
                $cascade,
                $reason,
                $user
            );
 
            if ( $nullRevisionRecord === null ) {
                return Status::newFatal( 'no-null-revision', $this->mTitle->getPrefixedText() );
            }
 
            $logRelationsField = 'pr_id';
 
            // T214035: Avoid deadlock on MySQL.
            // Do a DELETE by primary key (pr_id) for any existing protection rows.
            // On MySQL and derivatives, unconditionally deleting by page ID (pr_page) would.
            // place a gap lock if there are no matching rows. This can deadlock when another
            // thread modifies protection settings for page IDs in the same gap.
            $existingProtectionIds = $dbw->selectFieldValues(
                'page_restrictions',
                'pr_id',
                [
                    'pr_page' => $id,
                    'pr_type' => array_map( 'strval', array_keys( $limit ) )
                ],
                __METHOD__
            );
 
            if ( $existingProtectionIds ) {
                $dbw->delete(
                    'page_restrictions',
                    [ 'pr_id' => $existingProtectionIds ],
                    __METHOD__
                );
            }
 
            // Update restrictions table
            foreach ( $limit as $action => $restrictions ) {
                if ( $restrictions != '' ) {
                    $cascadeValue = ( $cascade && $action == 'edit' ) ? 1 : 0;
                    $dbw->insert(
                        'page_restrictions',
                        [
                            'pr_page' => $id,
                            'pr_type' => $action,
                            'pr_level' => $restrictions,
                            'pr_cascade' => $cascadeValue,
                            'pr_expiry' => $dbw->encodeExpiry( $expiry[$action] )
                        ],
                        __METHOD__
                    );
                    $logRelationsValues[] = $dbw->insertId();
                    $logParamsDetails[] = [
                        'type' => $action,
                        'level' => $restrictions,
                        'expiry' => $expiry[$action],
                        'cascade' => (bool)$cascadeValue,
                    ];
                }
            }
 
            // Clear out legacy restriction fields
            $dbw->update(
                'page',
                [ 'page_restrictions' => '' ],
                [ 'page_id' => $id ],
                __METHOD__
            );
 
            $this->getHookRunner()->onRevisionFromEditComplete(
                $this, $nullRevisionRecord, $latest, $user, $tags );
 
            // Hook is hard deprecated since 1.35
            if ( $this->getHookContainer()->isRegistered( 'NewRevisionFromEditComplete' ) ) {
                // Only create the Revision object if neeed
                $nullRevision = new Revision( $nullRevisionRecord );
                $this->getHookRunner()->onNewRevisionFromEditComplete(
                    $this, $nullRevision, $latest, $user, $tags );
            }
 
            $this->getHookRunner()->onArticleProtectComplete( $this, $user, $limit, $reason );
        } else { // Protection of non-existing page (also known as "title protection")
            // Cascade protection is meaningless in this case
            $cascade = false;
 
            if ( $limit['create'] != '' ) {
                $commentFields = CommentStore::getStore()->insert( $dbw, 'pt_reason', $reason );
                $dbw->replace( 'protected_titles',
                    [ [ 'pt_namespace', 'pt_title' ] ],
                    [
                        'pt_namespace' => $this->mTitle->getNamespace(),
                        'pt_title' => $this->mTitle->getDBkey(),
                        'pt_create_perm' => $limit['create'],
                        'pt_timestamp' => $dbw->timestamp(),
                        'pt_expiry' => $dbw->encodeExpiry( $expiry['create'] ),
                        'pt_user' => $user->getId(),
                    ] + $commentFields, __METHOD__
                );
                $logParamsDetails[] = [
                    'type' => 'create',
                    'level' => $limit['create'],
                    'expiry' => $expiry['create'],
                ];
            } else {
                $dbw->delete( 'protected_titles',
                    [
                        'pt_namespace' => $this->mTitle->getNamespace(),
                        'pt_title' => $this->mTitle->getDBkey()
                    ], __METHOD__
                );
            }
        }
 
        $this->mTitle->flushRestrictions();
        InfoAction::invalidateCache( $this->mTitle );
 
        if ( $logAction == 'unprotect' ) {
            $params = [];
        } else {
            $protectDescriptionLog = $this->protectDescriptionLog( $limit, $expiry );
            $params = [
                '4::description' => $protectDescriptionLog, // parameter for IRC
                '5:bool:cascade' => $cascade,
                'details' => $logParamsDetails, // parameter for localize and api
            ];
        }
 
        // Update the protection log
        $logEntry = new ManualLogEntry( 'protect', $logAction );
        $logEntry->setTarget( $this->mTitle );
        $logEntry->setComment( $reason );
        $logEntry->setPerformer( $user );
        $logEntry->setParameters( $params );
        if ( $nullRevision !== null ) {
            $logEntry->setAssociatedRevId( $nullRevision->getId() );
        }
        $logEntry->addTags( $tags );
        if ( $logRelationsField !== null && count( $logRelationsValues ) ) {
            $logEntry->setRelations( [ $logRelationsField => $logRelationsValues ] );
        }
        $logId = $logEntry->insert();
        $logEntry->publish( $logId );
 
        return Status::newGood( $logId );
    }
 
    public function insertNullProtectionRevision(
        string $revCommentMsg,
        array $limit,
        array $expiry,
        bool $cascade,
        string $reason,
        UserIdentity $user
    ) : ?RevisionRecord {
        $dbw = wfGetDB( DB_MASTER );
 
        // Prepare a null revision to be added to the history
        $editComment = wfMessage(
            $revCommentMsg,
            $this->mTitle->getPrefixedText(),
            $user->getName()
        )->inContentLanguage()->text();
        if ( $reason ) {
            $editComment .= wfMessage( 'colon-separator' )->inContentLanguage()->text() . $reason;
        }
        $protectDescription = $this->protectDescription( $limit, $expiry );
        if ( $protectDescription ) {
            $editComment .= wfMessage( 'word-separator' )->inContentLanguage()->text();
            $editComment .= wfMessage( 'parentheses' )->params( $protectDescription )
                ->inContentLanguage()->text();
        }
        if ( $cascade ) {
            $editComment .= wfMessage( 'word-separator' )->inContentLanguage()->text();
            $editComment .= wfMessage( 'brackets' )->params(
                wfMessage( 'protect-summary-cascade' )->inContentLanguage()->text()
            )->inContentLanguage()->text();
        }
 
        $revStore = $this->getRevisionStore();
        $comment = CommentStoreComment::newUnsavedComment( $editComment );
        $nullRevRecord = $revStore->newNullRevision(
            $dbw,
            $this->getTitle(),
            $comment,
            true,
            $user
        );
 
        if ( $nullRevRecord ) {
            $inserted = $revStore->insertRevisionOn( $nullRevRecord, $dbw );
 
            // Update page record and touch page
            $oldLatest = $inserted->getParentId();
 
            $this->updateRevisionOn( $dbw, $inserted, $oldLatest );
 
            return $inserted;
        } else {
            return null;
        }
    }
 
    protected function formatExpiry( $expiry ) {
        if ( $expiry != 'infinity' ) {
            $contLang = MediaWikiServices::getInstance()->getContentLanguage();
            return wfMessage(
                'protect-expiring',
                $contLang->timeanddate( $expiry, false, false ),
                $contLang->date( $expiry, false, false ),
                $contLang->time( $expiry, false, false )
            )->inContentLanguage()->text();
        } else {
            return wfMessage( 'protect-expiry-indefinite' )
                ->inContentLanguage()->text();
        }
    }
 
    public function protectDescription( array $limit, array $expiry ) {
        $protectDescription = '';
 
        foreach ( array_filter( $limit ) as $action => $restrictions ) {
            # $action is one of $wgRestrictionTypes = [ 'create', 'edit', 'move', 'upload' ].
            # All possible message keys are listed here for easier grepping:
            # * restriction-create
            # * restriction-edit
            # * restriction-move
            # * restriction-upload
            $actionText = wfMessage( 'restriction-' . $action )->inContentLanguage()->text();
            # $restrictions is one of $wgRestrictionLevels = [ '', 'autoconfirmed', 'sysop' ],
            # with '' filtered out. All possible message keys are listed below:
            # * protect-level-autoconfirmed
            # * protect-level-sysop
            $restrictionsText = wfMessage( 'protect-level-' . $restrictions )
                ->inContentLanguage()->text();
 
            $expiryText = $this->formatExpiry( $expiry[$action] );
 
            if ( $protectDescription !== '' ) {
                $protectDescription .= wfMessage( 'word-separator' )->inContentLanguage()->text();
            }
            $protectDescription .= wfMessage( 'protect-summary-desc' )
                ->params( $actionText, $restrictionsText, $expiryText )
                ->inContentLanguage()->text();
        }
 
        return $protectDescription;
    }
 
    public function protectDescriptionLog( array $limit, array $expiry ) {
        $protectDescriptionLog = '';
 
        $dirMark = MediaWikiServices::getInstance()->getContentLanguage()->getDirMark();
        foreach ( array_filter( $limit ) as $action => $restrictions ) {
            $expiryText = $this->formatExpiry( $expiry[$action] );
            $protectDescriptionLog .=
                $dirMark .
                "[$action=$restrictions] ($expiryText)";
        }
 
        return trim( $protectDescriptionLog );
    }
 
    public function isBatchedDelete( $safetyMargin = 0 ) {
        global $wgDeleteRevisionsBatchSize;
 
        $dbr = wfGetDB( DB_REPLICA );
        $revCount = $this->getRevisionStore()->countRevisionsByPageId( $dbr, $this->getId() );
        $revCount += $safetyMargin;
 
        return $revCount >= $wgDeleteRevisionsBatchSize;
    }
 
    public function doDeleteArticleReal(
        $reason, User $deleter, $suppress = false, $u1 = null, &$error = '', $u2 = null,
        $tags = [], $logsubtype = 'delete', $immediate = false
    ) {
        wfDebug( __METHOD__ );
        $this->assertProperPage();
 
        $status = Status::newGood();
 
        if ( !$this->getHookRunner()->onArticleDelete(
            $this, $deleter, $reason, $error, $status, $suppress )
        ) {
            if ( $status->isOK() ) {
                // Hook aborted but didn't set a fatal status
                $status->fatal( 'delete-hook-aborted' );
            }
            return $status;
        }
 
        return $this->doDeleteArticleBatched( $reason, $suppress, $deleter, $tags,
            $logsubtype, $immediate );
    }
 
    public function doDeleteArticleBatched(
        $reason, $suppress, User $deleter, $tags,
        $logsubtype, $immediate = false, $webRequestId = null
    ) {
        wfDebug( __METHOD__ );
 
        $status = Status::newGood();
 
        $dbw = wfGetDB( DB_MASTER );
        $dbw->startAtomic( __METHOD__ );
 
        $this->loadPageData( self::READ_LATEST );
        $id = $this->getId();
        // T98706: lock the page from various other updates but avoid using
        // WikiPage::READ_LOCKING as that will carry over the FOR UPDATE to
        // the revisions queries (which also JOIN on user). Only lock the page
        // row and CAS check on page_latest to see if the trx snapshot matches.
        $lockedLatest = $this->lockAndGetLatest();
        if ( $id == 0 || $this->getLatest() != $lockedLatest ) {
            $dbw->endAtomic( __METHOD__ );
            // Page not there or trx snapshot is stale
            $status->error( 'cannotdelete',
                wfEscapeWikiText( $this->getTitle()->getPrefixedText() ) );
            return $status;
        }
 
        // At this point we are now committed to returning an OK
        // status unless some DB query error or other exception comes up.
        // This way callers don't have to call rollback() if $status is bad
        // unless they actually try to catch exceptions (which is rare).
 
        // we need to remember the old content so we can use it to generate all deletion updates.
        $revisionRecord = $this->getRevisionRecord();
        try {
            $content = $this->getContent( RevisionRecord::RAW );
        } catch ( Exception $ex ) {
            wfLogWarning( __METHOD__ . ': failed to load content during deletion! '
                . $ex->getMessage() );
 
            $content = null;
        }
 
        // Archive revisions.  In immediate mode, archive all revisions.  Otherwise, archive
        // one batch of revisions and defer archival of any others to the job queue.
        $explictTrxLogged = false;
        while ( true ) {
            $done = $this->archiveRevisions( $dbw, $id, $suppress );
            if ( $done || !$immediate ) {
                break;
            }
            $dbw->endAtomic( __METHOD__ );
            if ( $dbw->explicitTrxActive() ) {
                // Explict transactions may never happen here in practice.  Log to be sure.
                if ( !$explictTrxLogged ) {
                    $explictTrxLogged = true;
                    LoggerFactory::getInstance( 'wfDebug' )->debug(
                        'explicit transaction active in ' . __METHOD__ . ' while deleting {title}', [
                        'title' => $this->getTitle()->getText(),
                    ] );
                }
                continue;
            }
            if ( $dbw->trxLevel() ) {
                $dbw->commit( __METHOD__ );
            }
            $lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
            $lbFactory->waitForReplication();
            $dbw->startAtomic( __METHOD__ );
        }
 
        // If done archiving, also delete the article.
        if ( !$done ) {
            $dbw->endAtomic( __METHOD__ );
 
            $jobParams = [
                'namespace' => $this->getTitle()->getNamespace(),
                'title' => $this->getTitle()->getDBkey(),
                'wikiPageId' => $id,
                'requestId' => $webRequestId ?? WebRequest::getRequestId(),
                'reason' => $reason,
                'suppress' => $suppress,
                'userId' => $deleter->getId(),
                'tags' => json_encode( $tags ),
                'logsubtype' => $logsubtype,
            ];
 
            $job = new DeletePageJob( $jobParams );
            JobQueueGroup::singleton()->push( $job );
 
            $status->warning( 'delete-scheduled',
                wfEscapeWikiText( $this->getTitle()->getPrefixedText() ) );
        } else {
            // Get archivedRevisionCount by db query, because there's no better alternative.
            // Jobs cannot pass a count of archived revisions to the next job, because additional
            // deletion operations can be started while the first is running.  Jobs from each
            // gracefully interleave, but would not know about each other's count.  Deduplication
            // in the job queue to avoid simultaneous deletion operations would add overhead.
            // Number of archived revisions cannot be known beforehand, because edits can be made
            // while deletion operations are being processed, changing the number of archivals.
            $archivedRevisionCount = (int)$dbw->selectField(
                'archive', 'COUNT(*)',
                [
                    'ar_namespace' => $this->getTitle()->getNamespace(),
                    'ar_title' => $this->getTitle()->getDBkey(),
                    'ar_page_id' => $id
                ], __METHOD__
            );
 
            // Clone the title and wikiPage, so we have the information we need when
            // we log and run the ArticleDeleteComplete hook.
            $logTitle = clone $this->mTitle;
            $wikiPageBeforeDelete = clone $this;
 
            // Now that it's safely backed up, delete it
            $dbw->delete( 'page', [ 'page_id' => $id ], __METHOD__ );
 
            // Log the deletion, if the page was suppressed, put it in the suppression log instead
            $logtype = $suppress ? 'suppress' : 'delete';
 
            $logEntry = new ManualLogEntry( $logtype, $logsubtype );
            $logEntry->setPerformer( $deleter );
            $logEntry->setTarget( $logTitle );
            $logEntry->setComment( $reason );
            $logEntry->addTags( $tags );
            $logid = $logEntry->insert();
 
            $dbw->onTransactionPreCommitOrIdle(
                static function () use ( $logEntry, $logid ) {
                    // T58776: avoid deadlocks (especially from FileDeleteForm)
                    $logEntry->publish( $logid );
                },
                __METHOD__
            );
 
            $dbw->endAtomic( __METHOD__ );
 
            $this->doDeleteUpdates(
                $id,
                $content,
                $revisionRecord,
                $deleter
            );
 
            $this->getHookRunner()->onArticleDeleteComplete(
                $wikiPageBeforeDelete,
                $deleter,
                $reason,
                $id,
                $content,
                $logEntry,
                $archivedRevisionCount
            );
            $status->value = $logid;
 
            // Show log excerpt on 404 pages rather than just a link
            $dbCache = ObjectCache::getInstance( 'db-replicated' );
            $key = $dbCache->makeKey( 'page-recent-delete', md5( $logTitle->getPrefixedText() ) );
            $dbCache->set( $key, 1, $dbCache::TTL_DAY );
        }
 
        return $status;
    }
 
    protected function archiveRevisions( $dbw, $id, $suppress ) {
        global $wgDeleteRevisionsBatchSize;
 
        // Given the lock above, we can be confident in the title and page ID values
        $namespace = $this->getTitle()->getNamespace();
        $dbKey = $this->getTitle()->getDBkey();
 
        $commentStore = CommentStore::getStore();
        $actorMigration = ActorMigration::newMigration();
 
        $revQuery = $this->getRevisionStore()->getQueryInfo();
        $bitfield = false;
 
        // Bitfields to further suppress the content
        if ( $suppress ) {
            $bitfield = RevisionRecord::SUPPRESSED_ALL;
            $revQuery['fields'] = array_diff( $revQuery['fields'], [ 'rev_deleted' ] );
        }
 
        // For now, shunt the revision data into the archive table.
        // Text is *not* removed from the text table; bulk storage
        // is left intact to avoid breaking block-compression or
        // immutable storage schemes.
        // In the future, we may keep revisions and mark them with
        // the rev_deleted field, which is reserved for this purpose.
 
        // Lock rows in `revision` and its temp tables, but not any others.
        // Note array_intersect() preserves keys from the first arg, and we're
        // assuming $revQuery has `revision` primary and isn't using subtables
        // for anything we care about.
        $dbw->lockForUpdate(
            array_intersect(
                $revQuery['tables'],
                [ 'revision', 'revision_comment_temp', 'revision_actor_temp' ]
            ),
            [ 'rev_page' => $id ],
            __METHOD__,
            [],
            $revQuery['joins']
        );
 
        // Get as many of the page revisions as we are allowed to.  The +1 lets us recognize the
        // unusual case where there were exactly $wgDeleteRevisionBatchSize revisions remaining.
        $res = $dbw->select(
            $revQuery['tables'],
            $revQuery['fields'],
            [ 'rev_page' => $id ],
            __METHOD__,
            [ 'ORDER BY' => 'rev_timestamp ASC, rev_id ASC', 'LIMIT' => $wgDeleteRevisionsBatchSize + 1 ],
            $revQuery['joins']
        );
 
        // Build their equivalent archive rows
        $rowsInsert = [];
        $revids = [];
 
        $ipRevIds = [];
 
        $done = true;
        foreach ( $res as $row ) {
            if ( count( $revids ) >= $wgDeleteRevisionsBatchSize ) {
                $done = false;
                break;
            }
 
            $comment = $commentStore->getComment( 'rev_comment', $row );
            $user = User::newFromAnyId( $row->rev_user, $row->rev_user_text, $row->rev_actor );
            $rowInsert = [
                    'ar_namespace'  => $namespace,
                    'ar_title'      => $dbKey,
                    'ar_timestamp'  => $row->rev_timestamp,
                    'ar_minor_edit' => $row->rev_minor_edit,
                    'ar_rev_id'     => $row->rev_id,
                    'ar_parent_id'  => $row->rev_parent_id,
                    'ar_len'        => $row->rev_len,
                    'ar_page_id'    => $id,
                    'ar_deleted'    => $suppress ? $bitfield : $row->rev_deleted,
                    'ar_sha1'       => $row->rev_sha1,
                ] + $commentStore->insert( $dbw, 'ar_comment', $comment )
                + $actorMigration->getInsertValues( $dbw, 'ar_user', $user );
 
            $rowsInsert[] = $rowInsert;
            $revids[] = $row->rev_id;
 
            // Keep track of IP edits, so that the corresponding rows can
            // be deleted in the ip_changes table.
            if ( (int)$row->rev_user === 0 && IPUtils::isValid( $row->rev_user_text ) ) {
                $ipRevIds[] = $row->rev_id;
            }
        }
 
        // This conditional is just a sanity check
        if ( count( $revids ) > 0 ) {
            // Copy them into the archive table
            $dbw->insert( 'archive', $rowsInsert, __METHOD__ );
 
            $dbw->delete( 'revision', [ 'rev_id' => $revids ], __METHOD__ );
            $dbw->delete( 'revision_comment_temp', [ 'revcomment_rev' => $revids ], __METHOD__ );
            $dbw->delete( 'revision_actor_temp', [ 'revactor_rev' => $revids ], __METHOD__ );
 
            // Also delete records from ip_changes as applicable.
            if ( count( $ipRevIds ) > 0 ) {
                $dbw->delete( 'ip_changes', [ 'ipc_rev_id' => $ipRevIds ], __METHOD__ );
            }
        }
 
        return $done;
    }
 
    public function lockAndGetLatest() {
        return (int)wfGetDB( DB_MASTER )->selectField(
            'page',
            'page_latest',
            [
                'page_id' => $this->getId(),
                // Typically page_id is enough, but some code might try to do
                // updates assuming the title is the same, so verify that
                'page_namespace' => $this->getTitle()->getNamespace(),
                'page_title' => $this->getTitle()->getDBkey()
            ],
            __METHOD__,
            [ 'FOR UPDATE' ]
        );
    }
 
    public function doDeleteUpdates(
        $id, Content $content = null, $revRecord = null, User $user = null
    ) {
        if ( $revRecord && $revRecord instanceof Revision ) {
            wfDeprecated( __METHOD__ . ' with a Revision object', '1.35' );
            $revRecord = $revRecord->getRevisionRecord();
        }
 
        if ( $id !== $this->getId() ) {
            throw new InvalidArgumentException( 'Mismatching page ID' );
        }
 
        try {
            $countable = $this->isCountable();
        } catch ( Exception $ex ) {
            // fallback for deleting broken pages for which we cannot load the content for
            // some reason. Note that doDeleteArticleReal() already logged this problem.
            $countable = false;
        }
 
        // Update site status
        DeferredUpdates::addUpdate( SiteStatsUpdate::factory(
            [ 'edits' => 1, 'articles' => -$countable, 'pages' => -1 ]
        ) );
 
        // Delete pagelinks, update secondary indexes, etc
        $updates = $this->getDeletionUpdates( $revRecord ?: $content );
        foreach ( $updates as $update ) {
            DeferredUpdates::addUpdate( $update );
        }
 
        $causeAgent = $user ? $user->getName() : 'unknown';
        // Reparse any pages transcluding this page
        LinksUpdate::queueRecursiveJobsForTable(
            $this->mTitle, 'templatelinks', 'delete-page', $causeAgent );
        // Reparse any pages including this image
        if ( $this->mTitle->getNamespace() === NS_FILE ) {
            LinksUpdate::queueRecursiveJobsForTable(
                $this->mTitle, 'imagelinks', 'delete-page', $causeAgent );
        }
 
        // Clear caches
        self::onArticleDelete( $this->mTitle );
 
        ResourceLoaderWikiModule::invalidateModuleCache(
            $this->mTitle,
            $revRecord,
            null,
            WikiMap::getCurrentWikiDbDomain()->getId()
        );
 
        // Reset this object and the Title object
        $this->loadFromRow( false, self::READ_LATEST );
 
        // Search engine
        DeferredUpdates::addUpdate( new SearchUpdate( $id, $this->mTitle ) );
    }
 
    public function doRollback(
        $fromP, $summary, $token, $bot, &$resultDetails, Authority $performer, $tags = null
    ) {
        $this->assertProperPage();
 
        $resultDetails = null;
 
        // Check permissions
        $permissionStatus = PermissionStatus::newEmpty();
        $performer->authorizeWrite( 'edit', $this->getTitle(), $permissionStatus );
        $performer->authorizeWrite( 'rollback', $this->getTitle(), $permissionStatus );
 
        $user = MediaWikiServices::getInstance()->getUserFactory()->newFromAuthority( $performer );
        if ( !$user->matchEditToken( $token, 'rollback' ) ) {
            $permissionStatus->fatal( 'sessionfailure' );
        }
 
        if ( $user->pingLimiter( 'rollback' ) || $user->pingLimiter() ) {
            $permissionStatus->fatal( 'actionthrottledtext' );
        }
 
        // If there were errors, bail out now
        if ( !$permissionStatus->isGood() ) {
            return $permissionStatus->toLegacyErrorArray();
        }
 
        return $this->commitRollback( $fromP, $summary, $bot, $resultDetails, $performer, $tags );
    }
 
    public function commitRollback( $fromP, $summary, $bot,
        &$resultDetails, Authority $performer, $tags = null
    ) {
        global $wgUseRCPatrol, $wgDisableAnonTalk;
 
        $dbw = wfGetDB( DB_MASTER );
 
        if ( wfReadOnly() ) {
            return [ [ 'readonlytext' ] ];
        }
 
        // Begin revision creation cycle by creating a PageUpdater.
        // If the page is changed concurrently after grabParentRevision(), the rollback will fail.
        $user = MediaWikiServices::getInstance()->getUserFactory()->newFromAuthority( $performer );
        $updater = $this->newPageUpdater( $user );
        $current = $updater->grabParentRevision();
 
        if ( $current === null ) {
            // Something wrong... no page?
            return [ [ 'notanarticle' ] ];
        }
 
        $currentEditorForPublic = $current->getUser( RevisionRecord::FOR_PUBLIC );
        $legacyCurrentCallback = static function () use ( $current ) {
            // Only created when needed
            return new Revision( $current );
        };
        $from = str_replace( '_', ' ', $fromP );
 
        // User name given should match up with the top revision.
        // If the revision's user is not visible, then $from should be empty.
        if ( $from !== ( $currentEditorForPublic ? $currentEditorForPublic->getName() : '' ) ) {
            $resultDetails = new DeprecatablePropertyArray(
                [
                    'current' => $legacyCurrentCallback,
                    'current-revision-record' => $current,
                ],
                [ 'current' => '1.35' ],
                __METHOD__
            );
            return [ [ 'alreadyrolled',
                htmlspecialchars( $this->mTitle->getPrefixedText() ),
                htmlspecialchars( $fromP ),
                htmlspecialchars( $currentEditorForPublic ? $currentEditorForPublic->getName() : '' )
            ] ];
        }
 
        // Get the last edit not by this person...
        // Note: these may not be public values
        $actorWhere = ActorMigration::newMigration()->getWhere(
            $dbw,
            'rev_user',
            $current->getUser( RevisionRecord::RAW )
        );
 
        $s = $dbw->selectRow(
            [ 'revision' ] + $actorWhere['tables'],
            [ 'rev_id', 'rev_timestamp', 'rev_deleted' ],
            [
                'rev_page' => $current->getPageId(),
                'NOT(' . $actorWhere['conds'] . ')',
            ],
            __METHOD__,
            [
                'USE INDEX' => [ 'revision' => 'page_timestamp' ],
                'ORDER BY' => [ 'rev_timestamp DESC', 'rev_id DESC' ]
            ],
            $actorWhere['joins']
        );
        if ( $s === false ) {
            // No one else ever edited this page
            return [ [ 'cantrollback' ] ];
        } elseif ( $s->rev_deleted & RevisionRecord::DELETED_TEXT
            || $s->rev_deleted & RevisionRecord::DELETED_USER
        ) {
            // Only admins can see this text
            return [ [ 'notvisiblerev' ] ];
        }
 
        // Generate the edit summary if necessary
        $target = $this->getRevisionStore()->getRevisionById(
            $s->rev_id,
            RevisionStore::READ_LATEST
        );
        if ( empty( $summary ) ) {
            if ( !$currentEditorForPublic ) { // no public user name
                $summary = wfMessage( 'revertpage-nouser' );
            } elseif ( $wgDisableAnonTalk && $current->getUser() === 0 ) {
                $summary = wfMessage( 'revertpage-anon' );
            } else {
                $summary = wfMessage( 'revertpage' );
            }
        }
        $targetEditorForPublic = $target->getUser( RevisionRecord::FOR_PUBLIC );
 
        // Allow the custom summary to use the same args as the default message
        $contLang = MediaWikiServices::getInstance()->getContentLanguage();
        $args = [
            $targetEditorForPublic ? $targetEditorForPublic->getName() : null,
            $currentEditorForPublic ? $currentEditorForPublic->getName() : null,
            $s->rev_id,
            $contLang->timeanddate( MWTimestamp::convert( TS_MW, $s->rev_timestamp ) ),
            $current->getId(),
            $contLang->timeanddate( $current->getTimestamp() )
        ];
        if ( $summary instanceof Message ) {
            $summary = $summary->params( $args )->inContentLanguage()->text();
        } else {
            $summary = wfMsgReplaceArgs( $summary, $args );
        }
 
        // Trim spaces on user supplied text
        $summary = trim( $summary );
 
        // Save
        $flags = EDIT_UPDATE | EDIT_INTERNAL;
 
        if ( $performer->isAllowed( 'minoredit' ) ) {
            $flags |= EDIT_MINOR;
        }
 
        if ( $bot && ( $performer->isAllowedAny( 'markbotedits', 'bot' ) ) ) {
            $flags |= EDIT_FORCE_BOT;
        }
 
        // TODO: MCR: also log model changes in other slots, in case that becomes possible!
        $currentContent = $current->getContent( SlotRecord::MAIN );
        $targetContent = $target->getContent( SlotRecord::MAIN );
        $changingContentModel = $targetContent->getModel() !== $currentContent->getModel();
 
        // Build rollback revision:
        // Restore old content
        // TODO: MCR: test this once we can store multiple slots
        foreach ( $target->getSlots()->getSlots() as $slot ) {
            $updater->inheritSlot( $slot );
        }
 
        // Remove extra slots
        // TODO: MCR: test this once we can store multiple slots
        foreach ( $current->getSlotRoles() as $role ) {
            if ( !$target->hasSlot( $role ) ) {
                $updater->removeSlot( $role );
            }
        }
 
        $updater->setOriginalRevisionId( $target->getId() );
        $oldestRevertedRevision = $this->getRevisionStore()->getNextRevision(
            $target,
            RevisionStore::READ_LATEST
        );
        if ( $oldestRevertedRevision !== null ) {
            $updater->markAsRevert(
                EditResult::REVERT_ROLLBACK,
                $oldestRevertedRevision->getId(),
                $current->getId()
            );
        }
 
        // TODO: this logic should not be in the storage layer, it's here for compatibility
        // with 1.31 behavior. Applying the 'autopatrol' right should be done in the same
        // place the 'bot' right is handled, which is currently in EditPage::attemptSave.
 
        if ( $wgUseRCPatrol && $performer->authorizeWrite( 'autopatrol', $this->getTitle() ) ) {
            $updater->setRcPatrolStatus( RecentChange::PRC_AUTOPATROLLED );
        }
 
        // Actually store the rollback
        $rev = $updater->saveRevision(
            CommentStoreComment::newUnsavedComment( $summary ),
            $flags
        );
 
        // Set patrolling and bot flag on the edits, which gets rollbacked.
        // This is done even on edit failure to have patrolling in that case (T64157).
        $set = [];
        if ( $bot && $performer->isAllowed( 'markbotedits' ) ) {
            // Mark all reverted edits as bot
            $set['rc_bot'] = 1;
        }
 
        if ( $wgUseRCPatrol ) {
            // Mark all reverted edits as patrolled
            $set['rc_patrolled'] = RecentChange::PRC_AUTOPATROLLED;
        }
 
        if ( count( $set ) ) {
            $actorWhere = ActorMigration::newMigration()->getWhere(
                $dbw,
                'rc_user',
                $current->getUser( RevisionRecord::RAW ),
                false
            );
            $dbw->update( 'recentchanges', $set,
                [ /* WHERE */
                    'rc_cur_id' => $current->getPageId(),
                    'rc_timestamp > ' . $dbw->addQuotes( $s->rev_timestamp ),
                    $actorWhere['conds'], // No tables/joins are needed for rc_user
                ],
                __METHOD__
            );
        }
 
        if ( !$updater->wasSuccessful() ) {
            return $updater->getStatus()->getErrorsArray();
        }
 
        // Report if the edit was not created because it did not change the content.
        if ( $updater->isUnchanged() ) {
            $resultDetails = new DeprecatablePropertyArray(
                [
                    'current' => $legacyCurrentCallback,
                    'current-revision-record' => $current,
                ],
                [ 'current' => '1.35' ],
                __METHOD__
            );
            return [ [ 'alreadyrolled',
                htmlspecialchars( $this->mTitle->getPrefixedText() ),
                htmlspecialchars( $fromP ),
                htmlspecialchars( $currentEditorForPublic ? $currentEditorForPublic->getName() : '' )
            ] ];
        }
 
        if ( $changingContentModel ) {
            // If the content model changed during the rollback,
            // make sure it gets logged to Special:Log/contentmodel
            $log = new ManualLogEntry( 'contentmodel', 'change' );
            $log->setPerformer( $performer->getPerformer() );
            $log->setTarget( $this->mTitle );
            $log->setComment( $summary );
            $log->setParameters( [
                '4::oldmodel' => $currentContent->getModel(),
                '5::newmodel' => $targetContent->getModel(),
            ] );
 
            $logId = $log->insert( $dbw );
            $log->publish( $logId );
        }
 
        $revId = $rev->getId();
 
        // Hook is hard deprecated since 1.35
        if ( $this->getHookContainer()->isRegistered( 'ArticleRollbackComplete' ) ) {
            // Only create the Revision objects if needed
            $legacyCurrent = new Revision( $current );
            $legacyTarget = new Revision( $target );
            $this->getHookRunner()->onArticleRollbackComplete( $this, $user,
                $legacyTarget, $legacyCurrent );
        }
 
        $this->getHookRunner()->onRollbackComplete( $this, $user, $target, $current );
 
        $legacyTargetCallback = static function () use ( $target ) {
            // Only create the Revision object if needed
            return new Revision( $target );
        };
 
        $tags = array_merge(
            $tags ?: [],
            $updater->getEditResult()->getRevertTags()
        );
 
        $resultDetails = new DeprecatablePropertyArray(
            [
                'summary' => $summary,
                'current' => $legacyCurrentCallback,
                'current-revision-record' => $current,
                'target' => $legacyTargetCallback,
                'target-revision-record' => $target,
                'newid' => $revId,
                'tags' => $tags
            ],
            [ 'current' => '1.35', 'target' => '1.35' ],
            __METHOD__
        );
 
        // TODO: make this return a Status object and wrap $resultDetails in that.
        return [];
    }
 
    public static function onArticleCreate( Title $title ) {
        // TODO: move this into a PageEventEmitter service
 
        // Update existence markers on article/talk tabs...
        $other = $title->getOtherPage();
 
        $hcu = MediaWikiServices::getInstance()->getHtmlCacheUpdater();
        $hcu->purgeTitleUrls( [ $title, $other ], $hcu::PURGE_INTENT_TXROUND_REFLECTED );
 
        $title->touchLinks();
        $title->deleteTitleProtection();
 
        MediaWikiServices::getInstance()->getLinkCache()->invalidateTitle( $title );
 
        // Invalidate caches of articles which include this page
        $job = HTMLCacheUpdateJob::newForBacklinks(
            $title,
            'templatelinks',
            [ 'causeAction' => 'page-create' ]
        );
        JobQueueGroup::singleton()->lazyPush( $job );
 
        if ( $title->getNamespace() === NS_CATEGORY ) {
            // Load the Category object, which will schedule a job to create
            // the category table row if necessary. Checking a replica DB is ok
            // here, in the worst case it'll run an unnecessary recount job on
            // a category that probably doesn't have many members.
            Category::newFromTitle( $title )->getID();
        }
    }
 
    public static function onArticleDelete( Title $title ) {
        // TODO: move this into a PageEventEmitter service
 
        // Update existence markers on article/talk tabs...
        $other = $title->getOtherPage();
 
        $hcu = MediaWikiServices::getInstance()->getHtmlCacheUpdater();
        $hcu->purgeTitleUrls( [ $title, $other ], $hcu::PURGE_INTENT_TXROUND_REFLECTED );
 
        $title->touchLinks();
 
        $services = MediaWikiServices::getInstance();
        $services->getLinkCache()->invalidateTitle( $title );
 
        InfoAction::invalidateCache( $title );
 
        // Messages
        if ( $title->getNamespace() === NS_MEDIAWIKI ) {
            $services->getMessageCache()->updateMessageOverride( $title, null );
        }
 
        // Images
        if ( $title->getNamespace() === NS_FILE ) {
            $job = HTMLCacheUpdateJob::newForBacklinks(
                $title,
                'imagelinks',
                [ 'causeAction' => 'page-delete' ]
            );
            JobQueueGroup::singleton()->lazyPush( $job );
        }
 
        // User talk pages
        if ( $title->getNamespace() === NS_USER_TALK ) {
            $user = User::newFromName( $title->getText(), false );
            if ( $user ) {
                MediaWikiServices::getInstance()
                    ->getTalkPageNotificationManager()
                    ->removeUserHasNewMessages( $user );
            }
        }
 
        // Image redirects
        $services->getRepoGroup()->getLocalRepo()->invalidateImageRedirect( $title );
 
        // Purge cross-wiki cache entities referencing this page
        self::purgeInterwikiCheckKey( $title );
    }
 
    public static function onArticleEdit(
        Title $title,
        $revRecord = null,
        $slotsChanged = null
    ) {
        if ( $revRecord && $revRecord instanceof Revision ) {
            wfDeprecated( __METHOD__ . ' with a Revision object', '1.35' );
            $revRecord = $revRecord->getRevisionRecord();
        }
 
        // TODO: move this into a PageEventEmitter service
 
        $jobs = [];
        if ( $slotsChanged === null || in_array( SlotRecord::MAIN, $slotsChanged ) ) {
            // Invalidate caches of articles which include this page.
            // Only for the main slot, because only the main slot is transcluded.
            // TODO: MCR: not true for TemplateStyles! [SlotHandler]
            $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
                $title,
                'templatelinks',
                [ 'causeAction' => 'page-edit' ]
            );
        }
        // Invalidate the caches of all pages which redirect here
        $jobs[] = HTMLCacheUpdateJob::newForBacklinks(
            $title,
            'redirect',
            [ 'causeAction' => 'page-edit' ]
        );
        JobQueueGroup::singleton()->lazyPush( $jobs );
 
        MediaWikiServices::getInstance()->getLinkCache()->invalidateTitle( $title );
 
        $hcu = MediaWikiServices::getInstance()->getHtmlCacheUpdater();
        $hcu->purgeTitleUrls( $title, $hcu::PURGE_INTENT_TXROUND_REFLECTED );
 
        // Purge ?action=info cache
        $revid = $revRecord ? $revRecord->getId() : null;
        DeferredUpdates::addCallableUpdate( static function () use ( $title, $revid ) {
            InfoAction::invalidateCache( $title, $revid );
        } );
 
        // Purge cross-wiki cache entities referencing this page
        self::purgeInterwikiCheckKey( $title );
    }
 
    private static function purgeInterwikiCheckKey( Title $title ) {
        global $wgEnableScaryTranscluding;
 
        if ( !$wgEnableScaryTranscluding ) {
            return; // @todo: perhaps this wiki is only used as a *source* for content?
        }
 
        DeferredUpdates::addCallableUpdate( static function () use ( $title ) {
            $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
            $cache->resetCheckKey(
                // Do not include the namespace since there can be multiple aliases to it
                // due to different namespace text definitions on different wikis. This only
                // means that some cache invalidations happen that are not strictly needed.
                $cache->makeGlobalKey(
                    'interwiki-page',
                    WikiMap::getCurrentWikiDbDomain()->getId(),
                    $title->getDBkey()
                )
            );
        } );
    }
 
    public function getCategories() {
        $id = $this->getId();
        if ( $id == 0 ) {
            return TitleArray::newFromResult( new FakeResultWrapper( [] ) );
        }
 
        $dbr = wfGetDB( DB_REPLICA );
        $res = $dbr->select( 'categorylinks',
            [ 'page_title' => 'cl_to', 'page_namespace' => NS_CATEGORY ],
            [ 'cl_from' => $id ],
            __METHOD__
        );
 
        return TitleArray::newFromResult( $res );
    }
 
    public function getHiddenCategories() {
        $result = [];
        $id = $this->getId();
 
        if ( $id == 0 ) {
            return [];
        }
 
        $dbr = wfGetDB( DB_REPLICA );
        $res = $dbr->select( [ 'categorylinks', 'page_props', 'page' ],
            [ 'cl_to' ],
            [ 'cl_from' => $id, 'pp_page=page_id', 'pp_propname' => 'hiddencat',
                'page_namespace' => NS_CATEGORY, 'page_title=cl_to' ],
            __METHOD__ );
 
        if ( $res !== false ) {
            foreach ( $res as $row ) {
                $result[] = Title::makeTitle( NS_CATEGORY, $row->cl_to );
            }
        }
 
        return $result;
    }
 
    public function getAutoDeleteReason( &$hasHistory ) {
        return $this->getContentHandler()->getAutoDeleteReason( $this->getTitle(), $hasHistory );
    }
 
    public function updateCategoryCounts( array $added, array $deleted, $id = 0 ) {
        $id = $id ?: $this->getId();
        $type = MediaWikiServices::getInstance()->getNamespaceInfo()->
            getCategoryLinkType( $this->getTitle()->getNamespace() );
 
        $addFields = [ 'cat_pages = cat_pages + 1' ];
        $removeFields = [ 'cat_pages = cat_pages - 1' ];
        if ( $type !== 'page' ) {
            $addFields[] = "cat_{$type}s = cat_{$type}s + 1";
            $removeFields[] = "cat_{$type}s = cat_{$type}s - 1";
        }
 
        $dbw = wfGetDB( DB_MASTER );
 
        if ( count( $added ) ) {
            $existingAdded = $dbw->selectFieldValues(
                'category',
                'cat_title',
                [ 'cat_title' => $added ],
                __METHOD__
            );
 
            // For category rows that already exist, do a plain
            // UPDATE instead of INSERT...ON DUPLICATE KEY UPDATE
            // to avoid creating gaps in the cat_id sequence.
            if ( count( $existingAdded ) ) {
                $dbw->update(
                    'category',
                    $addFields,
                    [ 'cat_title' => $existingAdded ],
                    __METHOD__
                );
            }
 
            $missingAdded = array_diff( $added, $existingAdded );
            if ( count( $missingAdded ) ) {
                $insertRows = [];
                foreach ( $missingAdded as $cat ) {
                    $insertRows[] = [
                        'cat_title'   => $cat,
                        'cat_pages'   => 1,
                        'cat_subcats' => ( $type === 'subcat' ) ? 1 : 0,
                        'cat_files'   => ( $type === 'file' ) ? 1 : 0,
                    ];
                }
                $dbw->upsert(
                    'category',
                    $insertRows,
                    'cat_title',
                    $addFields,
                    __METHOD__
                );
            }
        }
 
        if ( count( $deleted ) ) {
            $dbw->update(
                'category',
                $removeFields,
                [ 'cat_title' => $deleted ],
                __METHOD__
            );
        }
 
        foreach ( $added as $catName ) {
            $cat = Category::newFromName( $catName );
            $this->getHookRunner()->onCategoryAfterPageAdded( $cat, $this );
        }
 
        foreach ( $deleted as $catName ) {
            $cat = Category::newFromName( $catName );
            $this->getHookRunner()->onCategoryAfterPageRemoved( $cat, $this, $id );
            // Refresh counts on categories that should be empty now (after commit, T166757)
            DeferredUpdates::addCallableUpdate( static function () use ( $cat ) {
                $cat->refreshCountsIfEmpty();
            } );
        }
    }
 
    public function triggerOpportunisticLinksUpdate( ParserOutput $parserOutput ) {
        if ( wfReadOnly() ) {
            return;
        }
 
        if ( !$this->getHookRunner()->onOpportunisticLinksUpdate( $this,
            $this->mTitle, $parserOutput )
        ) {
            return;
        }
 
        $config = RequestContext::getMain()->getConfig();
 
        $params = [
            'isOpportunistic' => true,
            'rootJobTimestamp' => $parserOutput->getCacheTime()
        ];
 
        if ( $this->mTitle->areRestrictionsCascading() ) {
            // If the page is cascade protecting, the links should really be up-to-date
            JobQueueGroup::singleton()->lazyPush(
                RefreshLinksJob::newPrioritized( $this->mTitle, $params )
            );
        } elseif ( !$config->get( 'MiserMode' ) && $parserOutput->hasDynamicContent() ) {
            // Assume the output contains "dynamic" time/random based magic words.
            // Only update pages that expired due to dynamic content and NOT due to edits
            // to referenced templates/files. When the cache expires due to dynamic content,
            // page_touched is unchanged. We want to avoid triggering redundant jobs due to
            // views of pages that were just purged via HTMLCacheUpdateJob. In that case, the
            // template/file edit already triggered recursive RefreshLinksJob jobs.
            if ( $this->getLinksTimestamp() > $this->getTouched() ) {
                // If a page is uncacheable, do not keep spamming a job for it.
                // Although it would be de-duplicated, it would still waste I/O.
                $cache = ObjectCache::getLocalClusterInstance();
                $key = $cache->makeKey( 'dynamic-linksupdate', 'last', $this->getId() );
                $ttl = max( $parserOutput->getCacheExpiry(), 3600 );
                if ( $cache->add( $key, time(), $ttl ) ) {
                    JobQueueGroup::singleton()->lazyPush(
                        RefreshLinksJob::newDynamic( $this->mTitle, $params )
                    );
                }
            }
        }
    }
 
    public function getDeletionUpdates( $rev = null ) {
        if ( !$rev ) {
            wfDeprecated( __METHOD__ . ' without a RevisionRecord', '1.32' );
 
            try {
                $rev = $this->getRevisionRecord();
            } catch ( Exception $ex ) {
                // If we can't load the content, something is wrong. Perhaps that's why
                // the user is trying to delete the page, so let's not fail in that case.
                // Note that doDeleteArticleReal() will already have logged an issue with
                // loading the content.
                wfDebug( __METHOD__ . ' failed to load current revision of page ' . $this->getId() );
            }
        }
 
        if ( !$rev ) {
            $slotContent = [];
        } elseif ( $rev instanceof Content ) {
            wfDeprecated( __METHOD__ . ' with a Content object instead of a RevisionRecord', '1.32' );
 
            $slotContent = [ SlotRecord::MAIN => $rev ];
        } else {
            $slotContent = array_map( static function ( SlotRecord $slot ) {
                return $slot->getContent();
            }, $rev->getSlots()->getSlots() );
        }
 
        $allUpdates = [ new LinksDeletionUpdate( $this ) ];
 
        // NOTE: once Content::getDeletionUpdates() is removed, we only need to content
        // model here, not the content object!
        // TODO: consolidate with similar logic in DerivedPageDataUpdater::getSecondaryDataUpdates()
        $content = null; // in case $slotContent is zero-length
        foreach ( $slotContent as $role => $content ) {
            $handler = $content->getContentHandler();
 
            $updates = $handler->getDeletionUpdates(
                $this->getTitle(),
                $role
            );
            $allUpdates = array_merge( $allUpdates, $updates );
 
            // TODO: remove B/C hack in 1.32!
            $legacyUpdates = $content->getDeletionUpdates( $this );
 
            // HACK: filter out redundant and incomplete LinksDeletionUpdate
            $legacyUpdates = array_filter( $legacyUpdates, static function ( $update ) {
                return !( $update instanceof LinksDeletionUpdate );
            } );
 
            $allUpdates = array_merge( $allUpdates, $legacyUpdates );
        }
 
        $this->getHookRunner()->onPageDeletionDataUpdates(
            $this->getTitle(), $rev, $allUpdates );
 
        // TODO: hard deprecate old hook in 1.33
        $this->getHookRunner()->onWikiPageDeletionUpdates( $this, $content, $allUpdates );
        return $allUpdates;
    }
 
    public function isLocal() {
        return true;
    }
 
    public function getWikiDisplayName() {
        global $wgSitename;
        return $wgSitename;
    }
 
    public function getSourceURL() {
        return $this->getTitle()->getCanonicalURL();
    }
 
    public function getMutableCacheKeys( WANObjectCache $cache ) {
        $linkCache = MediaWikiServices::getInstance()->getLinkCache();
 
        return $linkCache->getMutableCacheKeys( $cache, $this->getTitle() );
    }
 
    public function __wakeup() {
        // Make sure we re-fetch the latest state from the database.
        // In particular, the latest revision may have changed.
        // As a side-effect, this makes sure mLastRevision doesn't
        // end up being an instance of the old Revision class (see T259181).
        $this->clear();
    }
 
    public function getNamespace(): int {
        return $this->getTitle()->getNamespace();
    }
 
    public function getDBkey(): string {
        return $this->getTitle()->getDBkey();
    }
 
    public function getWikiId() {
        return $this->getTitle()->getWikiId();
    }
 
    public function canExist(): bool {
        // NOTE: once WikiPage becomes a ProperPageIdentity, this should always return true
        return $this->mTitle->canExist();
    }
 
    public function __toString(): string {
        return $this->mTitle->__toString();
    }
 
    public function isSamePageAs( PageIdentity $other ): bool {
        // NOTE: keep in sync with PageIdentityValue::isSamePageAs()!
 
        if ( $other->getWikiId() !== $this->getWikiId()
            || $other->getId() !== $this->getId() ) {
            return false;
        }
 
        if ( $this->getId() === 0 ) {
            if ( $other->getNamespace() !== $this->getNamespace()
                || $other->getDBkey() !== $this->getDBkey() ) {
                return false;
            }
        }
 
        return true;
    }
 
}