Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
27.26% covered (danger)
27.26%
268 / 983
6.12% covered (danger)
6.12%
3 / 49
CRAP
0.00% covered (danger)
0.00%
0 / 1
Article
27.26% covered (danger)
27.26%
268 / 983
6.12% covered (danger)
6.12%
3 / 49
26677.58
0.00% covered (danger)
0.00%
0 / 1
 __construct
0.00% covered (danger)
0.00%
0 / 14
0.00% covered (danger)
0.00%
0 / 1
2
 newPage
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 newFromID
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
6
 newFromTitle
0.00% covered (danger)
0.00%
0 / 15
0.00% covered (danger)
0.00%
0 / 1
42
 newFromWikiPage
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
2
 getRedirectedFrom
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 setRedirectedFrom
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getTitle
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getPage
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 clear
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
2
 getOldID
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
2
 getOldIDFromRequest
0.00% covered (danger)
0.00%
0 / 34
0.00% covered (danger)
0.00%
0 / 1
210
 fetchRevisionRecord
0.00% covered (danger)
0.00%
0 / 26
0.00% covered (danger)
0.00%
0 / 1
72
 isCurrent
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
20
 getRevIdFetched
75.00% covered (warning)
75.00%
3 / 4
0.00% covered (danger)
0.00%
0 / 1
3.14
 view
57.89% covered (warning)
57.89%
44 / 76
0.00% covered (danger)
0.00%
0 / 1
49.86
 showProtectionIndicator
92.11% covered (success)
92.11%
35 / 38
0.00% covered (danger)
0.00%
0 / 1
10.05
 generateContentOutput
61.39% covered (warning)
61.39%
62 / 101
0.00% covered (danger)
0.00%
0 / 1
49.87
 doOutputMetaData
0.00% covered (danger)
0.00%
0 / 9
0.00% covered (danger)
0.00%
0 / 1
20
 doOutputFromParserCache
0.00% covered (danger)
0.00%
0 / 8
0.00% covered (danger)
0.00%
0 / 1
6
 doOutputFromRenderStatus
0.00% covered (danger)
0.00%
0 / 23
0.00% covered (danger)
0.00%
0 / 1
42
 getRevisionRedirectTarget
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
6
 adjustDisplayTitle
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
6
 showDiffPage
0.00% covered (danger)
0.00%
0 / 48
0.00% covered (danger)
0.00%
0 / 1
20
 isDiffOnlyView
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
2
 getRobotPolicy
0.00% covered (danger)
0.00%
0 / 51
0.00% covered (danger)
0.00%
0 / 1
210
 formatRobotPolicy
0.00% covered (danger)
0.00%
0 / 12
0.00% covered (danger)
0.00%
0 / 1
72
 showRedirectedFromHeader
0.00% covered (danger)
0.00%
0 / 41
0.00% covered (danger)
0.00%
0 / 1
56
 showNamespaceHeader
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
12
 showViewFooter
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
12
 showPatrolFooter
73.68% covered (warning)
73.68%
70 / 95
0.00% covered (danger)
0.00%
0 / 1
40.29
 purgePatrolFooterCache
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
 showMissingArticle
42.72% covered (danger)
42.72%
44 / 103
0.00% covered (danger)
0.00%
0 / 1
187.07
 showViewError
100.00% covered (success)
100.00%
6 / 6
100.00% covered (success)
100.00%
1 / 1
1
 showDeletedRevisionHeader
0.00% covered (danger)
0.00%
0 / 37
0.00% covered (danger)
0.00%
0 / 1
42
 setOldSubtitle
0.00% covered (danger)
0.00%
0 / 127
0.00% covered (danger)
0.00%
0 / 1
272
 getRedirectHeaderHtml
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
2
 addHelpLink
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
12
 render
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
2
 protect
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
 unprotect
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 tryFileCache
0.00% covered (danger)
0.00%
0 / 15
0.00% covered (danger)
0.00%
0 / 1
20
 isFileCacheable
0.00% covered (danger)
0.00%
0 / 7
0.00% covered (danger)
0.00%
0 / 1
30
 getParserOutput
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
6
 getParserOptions
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
2
 setContext
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getContext
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
6
 getActionOverrides
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getMissingRevisionMsg
0.00% covered (danger)
0.00%
0 / 15
0.00% covered (danger)
0.00%
0 / 1
20
1<?php
2/**
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 * http://www.gnu.org/copyleft/gpl.html
17 *
18 * @file
19 */
20
21use MediaWiki\Block\DatabaseBlock;
22use MediaWiki\Block\DatabaseBlockStore;
23use MediaWiki\CommentFormatter\CommentFormatter;
24use MediaWiki\Context\IContextSource;
25use MediaWiki\Context\RequestContext;
26use MediaWiki\EditPage\EditPage;
27use MediaWiki\HookContainer\HookRunner;
28use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
29use MediaWiki\Html\Html;
30use MediaWiki\Linker\Linker;
31use MediaWiki\Linker\LinkRenderer;
32use MediaWiki\MainConfigNames;
33use MediaWiki\MediaWikiServices;
34use MediaWiki\Message\Message;
35use MediaWiki\Output\OutputPage;
36use MediaWiki\Page\ParserOutputAccess;
37use MediaWiki\Page\ProtectionForm;
38use MediaWiki\Page\WikiPageFactory;
39use MediaWiki\Parser\Parser;
40use MediaWiki\Parser\ParserOutput;
41use MediaWiki\Permissions\Authority;
42use MediaWiki\Permissions\PermissionStatus;
43use MediaWiki\Permissions\RestrictionStore;
44use MediaWiki\Revision\ArchivedRevisionLookup;
45use MediaWiki\Revision\BadRevisionException;
46use MediaWiki\Revision\RevisionRecord;
47use MediaWiki\Revision\RevisionStore;
48use MediaWiki\Revision\SlotRecord;
49use MediaWiki\Status\Status;
50use MediaWiki\Title\Title;
51use MediaWiki\User\Options\UserOptionsLookup;
52use MediaWiki\User\User;
53use MediaWiki\User\UserIdentity;
54use MediaWiki\User\UserNameUtils;
55use MediaWiki\Xml\Xml;
56use Wikimedia\IPUtils;
57use Wikimedia\LightweightObjectStore\ExpirationAwareness;
58use Wikimedia\NonSerializable\NonSerializableTrait;
59use Wikimedia\Rdbms\IConnectionProvider;
60
61/**
62 * Legacy class representing an editable page and handling UI for some page actions.
63 *
64 * This has largely been superseded by WikiPage, with Action subclasses for the
65 * user interface of page actions, and service classes for their backend logic.
66 *
67 * @todo Move and refactor remaining code
68 * @todo Deprecate
69 */
70class Article implements Page {
71    use ProtectedHookAccessorTrait;
72    use NonSerializableTrait;
73
74    /**
75     * @var IContextSource|null The context this Article is executed in.
76     * If null, RequestContext::getMain() is used.
77     * @deprecated since 1.35, must be private, use {@link getContext}
78     */
79    protected $mContext;
80
81    /** @var WikiPage The WikiPage object of this instance */
82    protected $mPage;
83
84    /**
85     * @var int|null The oldid of the article that was requested to be shown,
86     * 0 for the current revision.
87     */
88    public $mOldId;
89
90    /** @var Title|null Title from which we were redirected here, if any. */
91    public $mRedirectedFrom = null;
92
93    /** @var string|false URL to redirect to or false if none */
94    public $mRedirectUrl = false;
95
96    /**
97     * @var Status|null represents the outcome of fetchRevisionRecord().
98     * $fetchResult->value is the RevisionRecord object, if the operation was successful.
99     */
100    private $fetchResult = null;
101
102    /**
103     * @var ParserOutput|null|false The ParserOutput generated for viewing the page,
104     * initialized by view(). If no ParserOutput could be generated, this is set to false.
105     * @deprecated since 1.32
106     */
107    public $mParserOutput = null;
108
109    /**
110     * @var bool Whether render() was called. With the way subclasses work
111     * here, there doesn't seem to be any other way to stop calling
112     * OutputPage::enableSectionEditLinks() and still have it work as it did before.
113     */
114    protected $viewIsRenderAction = false;
115
116    protected LinkRenderer $linkRenderer;
117    private RevisionStore $revisionStore;
118    private UserNameUtils $userNameUtils;
119    private UserOptionsLookup $userOptionsLookup;
120    private CommentFormatter $commentFormatter;
121    private WikiPageFactory $wikiPageFactory;
122    private JobQueueGroup $jobQueueGroup;
123    private ArchivedRevisionLookup $archivedRevisionLookup;
124    protected IConnectionProvider $dbProvider;
125    protected DatabaseBlockStore $blockStore;
126
127    protected RestrictionStore $restrictionStore;
128
129    /**
130     * @var RevisionRecord|null Revision to be shown
131     *
132     * Initialized by getOldIDFromRequest() or fetchRevisionRecord(). While the output of
133     * Article::view is typically based on this revision, it may be replaced by extensions.
134     */
135    private $mRevisionRecord = null;
136
137    /**
138     * @param Title $title
139     * @param int|null $oldId Revision ID, null to fetch from request, zero for current
140     */
141    public function __construct( Title $title, $oldId = null ) {
142        $this->mOldId = $oldId;
143        $this->mPage = $this->newPage( $title );
144
145        $services = MediaWikiServices::getInstance();
146        $this->linkRenderer = $services->getLinkRenderer();
147        $this->revisionStore = $services->getRevisionStore();
148        $this->userNameUtils = $services->getUserNameUtils();
149        $this->userOptionsLookup = $services->getUserOptionsLookup();
150        $this->commentFormatter = $services->getCommentFormatter();
151        $this->wikiPageFactory = $services->getWikiPageFactory();
152        $this->jobQueueGroup = $services->getJobQueueGroup();
153        $this->archivedRevisionLookup = $services->getArchivedRevisionLookup();
154        $this->dbProvider = $services->getConnectionProvider();
155        $this->blockStore = $services->getDatabaseBlockStore();
156        $this->restrictionStore = $services->getRestrictionStore();
157    }
158
159    /**
160     * @param Title $title
161     * @return WikiPage
162     */
163    protected function newPage( Title $title ) {
164        return new WikiPage( $title );
165    }
166
167    /**
168     * Constructor from a page id
169     * @param int $id Article ID to load
170     * @return Article|null
171     */
172    public static function newFromID( $id ) {
173        $t = Title::newFromID( $id );
174        return $t === null ? null : new static( $t );
175    }
176
177    /**
178     * Create an Article object of the appropriate class for the given page.
179     *
180     * @param Title $title
181     * @param IContextSource $context
182     * @return Article
183     */
184    public static function newFromTitle( $title, IContextSource $context ): self {
185        if ( $title->getNamespace() === NS_MEDIA ) {
186            // XXX: This should not be here, but where should it go?
187            $title = Title::makeTitle( NS_FILE, $title->getDBkey() );
188        }
189
190        $page = null;
191        ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
192            // @phan-suppress-next-line PhanTypeMismatchArgument Type mismatch on pass-by-ref args
193            ->onArticleFromTitle( $title, $page, $context );
194        if ( !$page ) {
195            switch ( $title->getNamespace() ) {
196                case NS_FILE:
197                    $page = new ImagePage( $title );
198                    break;
199                case NS_CATEGORY:
200                    $page = new CategoryPage( $title );
201                    break;
202                default:
203                    $page = new Article( $title );
204            }
205        }
206        $page->setContext( $context );
207
208        return $page;
209    }
210
211    /**
212     * Create an Article object of the appropriate class for the given page.
213     *
214     * @param WikiPage $page
215     * @param IContextSource $context
216     * @return Article
217     */
218    public static function newFromWikiPage( WikiPage $page, IContextSource $context ) {
219        $article = self::newFromTitle( $page->getTitle(), $context );
220        $article->mPage = $page; // override to keep process cached vars
221        return $article;
222    }
223
224    /**
225     * Get the page this view was redirected from
226     * @return Title|null
227     * @since 1.28
228     */
229    public function getRedirectedFrom() {
230        return $this->mRedirectedFrom;
231    }
232
233    /**
234     * Tell the page view functions that this view was redirected
235     * from another page on the wiki.
236     * @param Title $from
237     */
238    public function setRedirectedFrom( Title $from ) {
239        $this->mRedirectedFrom = $from;
240    }
241
242    /**
243     * Get the title object of the article
244     *
245     * @return Title Title object of this page
246     */
247    public function getTitle() {
248        return $this->mPage->getTitle();
249    }
250
251    /**
252     * Get the WikiPage object of this instance
253     *
254     * @since 1.19
255     * @return WikiPage
256     */
257    public function getPage() {
258        return $this->mPage;
259    }
260
261    public function clear() {
262        $this->mRedirectedFrom = null; # Title object if set
263        $this->mRedirectUrl = false;
264        $this->mRevisionRecord = null;
265        $this->fetchResult = null;
266
267        // TODO hard-deprecate direct access to public fields
268
269        $this->mPage->clear();
270    }
271
272    /**
273     * @see getOldIDFromRequest()
274     * @see getRevIdFetched()
275     *
276     * @return int The oldid of the article that is was requested in the constructor or via the
277     *         context's WebRequest.
278     */
279    public function getOldID() {
280        if ( $this->mOldId === null ) {
281            $this->mOldId = $this->getOldIDFromRequest();
282        }
283
284        return $this->mOldId;
285    }
286
287    /**
288     * Sets $this->mRedirectUrl to a correct URL if the query parameters are incorrect
289     *
290     * @return int The old id for the request
291     */
292    public function getOldIDFromRequest() {
293        $this->mRedirectUrl = false;
294
295        $request = $this->getContext()->getRequest();
296        $oldid = $request->getIntOrNull( 'oldid' );
297
298        if ( $oldid === null ) {
299            return 0;
300        }
301
302        if ( $oldid !== 0 ) {
303            # Load the given revision and check whether the page is another one.
304            # In that case, update this instance to reflect the change.
305            if ( $oldid === $this->mPage->getLatest() ) {
306                $this->mRevisionRecord = $this->mPage->getRevisionRecord();
307            } else {
308                $this->mRevisionRecord = $this->revisionStore->getRevisionById( $oldid );
309                if ( $this->mRevisionRecord !== null ) {
310                    $revPageId = $this->mRevisionRecord->getPageId();
311                    // Revision title doesn't match the page title given?
312                    if ( $this->mPage->getId() !== $revPageId ) {
313                        $this->mPage = $this->wikiPageFactory->newFromID( $revPageId );
314                    }
315                }
316            }
317        }
318
319        $oldRev = $this->mRevisionRecord;
320        if ( $request->getRawVal( 'direction' ) === 'next' ) {
321            $nextid = 0;
322            if ( $oldRev ) {
323                $nextRev = $this->revisionStore->getNextRevision( $oldRev );
324                if ( $nextRev ) {
325                    $nextid = $nextRev->getId();
326                }
327            }
328            if ( $nextid ) {
329                $oldid = $nextid;
330                $this->mRevisionRecord = null;
331            } else {
332                $this->mRedirectUrl = $this->getTitle()->getFullURL( 'redirect=no' );
333            }
334        } elseif ( $request->getRawVal( 'direction' ) === 'prev' ) {
335            $previd = 0;
336            if ( $oldRev ) {
337                $prevRev = $this->revisionStore->getPreviousRevision( $oldRev );
338                if ( $prevRev ) {
339                    $previd = $prevRev->getId();
340                }
341            }
342            if ( $previd ) {
343                $oldid = $previd;
344                $this->mRevisionRecord = null;
345            }
346        }
347
348        return $oldid;
349    }
350
351    /**
352     * Fetches the revision to work on.
353     * The revision is loaded from the database. Refer to $this->fetchResult for the revision
354     * or any errors encountered while loading it.
355     *
356     * Public since 1.35
357     *
358     * @return RevisionRecord|null
359     */
360    public function fetchRevisionRecord() {
361        if ( $this->fetchResult ) {
362            return $this->mRevisionRecord;
363        }
364
365        $oldid = $this->getOldID();
366
367        // $this->mRevisionRecord might already be fetched by getOldIDFromRequest()
368        if ( !$this->mRevisionRecord ) {
369            if ( !$oldid ) {
370                $this->mRevisionRecord = $this->mPage->getRevisionRecord();
371
372                if ( !$this->mRevisionRecord ) {
373                    wfDebug( __METHOD__ . " failed to find page data for title " .
374                        $this->getTitle()->getPrefixedText() );
375
376                    // Output for this case is done by showMissingArticle().
377                    $this->fetchResult = Status::newFatal( 'noarticletext' );
378                    return null;
379                }
380            } else {
381                $this->mRevisionRecord = $this->revisionStore->getRevisionById( $oldid );
382
383                if ( !$this->mRevisionRecord ) {
384                    wfDebug( __METHOD__ . " failed to load revision, rev_id $oldid" );
385
386                    $this->fetchResult = Status::newFatal( $this->getMissingRevisionMsg( $oldid ) );
387                    return null;
388                }
389            }
390        }
391
392        if ( !$this->mRevisionRecord->userCan( RevisionRecord::DELETED_TEXT, $this->getContext()->getAuthority() ) ) {
393            wfDebug( __METHOD__ . " failed to retrieve content of revision " . $this->mRevisionRecord->getId() );
394
395            // Output for this case is done by showDeletedRevisionHeader().
396            // title used in wikilinks, should not contain whitespaces
397            $this->fetchResult = new Status;
398            $title = $this->getTitle()->getPrefixedDBkey();
399
400            if ( $this->mRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) ) {
401                $this->fetchResult->fatal( 'rev-suppressed-text' );
402            } else {
403                $this->fetchResult->fatal( 'rev-deleted-text-permission', $title );
404            }
405
406            return null;
407        }
408
409        $this->fetchResult = Status::newGood( $this->mRevisionRecord );
410        return $this->mRevisionRecord;
411    }
412
413    /**
414     * Returns true if the currently-referenced revision is the current edit
415     * to this page (and it exists).
416     * @return bool
417     */
418    public function isCurrent() {
419        # If no oldid, this is the current version.
420        if ( $this->getOldID() == 0 ) {
421            return true;
422        }
423
424        return $this->mPage->exists() &&
425            $this->mRevisionRecord &&
426            $this->mRevisionRecord->isCurrent();
427    }
428
429    /**
430     * Use this to fetch the rev ID used on page views
431     *
432     * Before fetchRevisionRecord was called, this returns the page's latest revision,
433     * regardless of what getOldID() returns.
434     *
435     * @return int Revision ID of last article revision
436     */
437    public function getRevIdFetched() {
438        if ( $this->fetchResult && $this->fetchResult->isOK() ) {
439            /** @var RevisionRecord $rev */
440            $rev = $this->fetchResult->getValue();
441            return $rev->getId();
442        } else {
443            return $this->mPage->getLatest();
444        }
445    }
446
447    /**
448     * This is the default action of the index.php entry point: just view the
449     * page of the given title.
450     */
451    public function view() {
452        $context = $this->getContext();
453        $useFileCache = $context->getConfig()->get( MainConfigNames::UseFileCache );
454
455        # Get variables from query string
456        # As side effect this will load the revision and update the title
457        # in a revision ID is passed in the request, so this should remain
458        # the first call of this method even if $oldid is used way below.
459        $oldid = $this->getOldID();
460
461        $authority = $context->getAuthority();
462        # Another check in case getOldID() is altering the title
463        $permissionStatus = PermissionStatus::newEmpty();
464        if ( !$authority
465            ->authorizeRead( 'read', $this->getTitle(), $permissionStatus )
466        ) {
467            wfDebug( __METHOD__ . ": denied on secondary read check" );
468            throw new PermissionsError( 'read', $permissionStatus );
469        }
470
471        $outputPage = $context->getOutput();
472        # getOldID() may as well want us to redirect somewhere else
473        if ( $this->mRedirectUrl ) {
474            $outputPage->redirect( $this->mRedirectUrl );
475            wfDebug( __METHOD__ . ": redirecting due to oldid" );
476
477            return;
478        }
479
480        # If we got diff in the query, we want to see a diff page instead of the article.
481        if ( $context->getRequest()->getCheck( 'diff' ) ) {
482            wfDebug( __METHOD__ . ": showing diff page" );
483            $this->showDiffPage();
484
485            return;
486        }
487
488        $this->showProtectionIndicator();
489
490        # Set page title (may be overridden from ParserOutput if title conversion is enabled or DISPLAYTITLE is used)
491        $outputPage->setPageTitle( Parser::formatPageTitle(
492            str_replace( '_', ' ', $this->getTitle()->getNsText() ),
493            ':',
494            $this->getTitle()->getText()
495        ) );
496
497        $outputPage->setArticleFlag( true );
498        # Allow frames by default
499        $outputPage->setPreventClickjacking( false );
500
501        $parserOptions = $this->getParserOptions();
502
503        $poOptions = [];
504        # Allow extensions to vary parser options used for article rendering
505        ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
506            ->onArticleParserOptions( $this, $parserOptions );
507        # Render printable version, use printable version cache
508        if ( $outputPage->isPrintable() ) {
509            $parserOptions->setIsPrintable( true );
510            $poOptions['enableSectionEditLinks'] = false;
511            $outputPage->prependHTML(
512                Html::warningBox(
513                    $outputPage->msg( 'printableversion-deprecated-warning' )->escaped()
514                )
515            );
516        } elseif ( $this->viewIsRenderAction || !$this->isCurrent() ||
517            !$authority->probablyCan( 'edit', $this->getTitle() )
518        ) {
519            $poOptions['enableSectionEditLinks'] = false;
520        }
521
522        # Try client and file cache
523        if ( $oldid === 0 && $this->mPage->checkTouched() ) {
524            # Try to stream the output from file cache
525            if ( $useFileCache && $this->tryFileCache() ) {
526                wfDebug( __METHOD__ . ": done file cache" );
527                # tell wgOut that output is taken care of
528                $outputPage->disable();
529                $this->mPage->doViewUpdates( $authority, $oldid );
530
531                return;
532            }
533        }
534
535        $this->showRedirectedFromHeader();
536        $this->showNamespaceHeader();
537
538        if ( $this->viewIsRenderAction ) {
539            $poOptions += [ 'absoluteURLs' => true ];
540        }
541        $poOptions += [ 'includeDebugInfo' => true ];
542
543        try {
544            $continue =
545                $this->generateContentOutput( $authority, $parserOptions, $oldid, $outputPage, $poOptions );
546        } catch ( BadRevisionException $e ) {
547            $continue = false;
548            $this->showViewError( wfMessage( 'badrevision' )->text() );
549        }
550
551        if ( !$continue ) {
552            return;
553        }
554
555        # For the main page, overwrite the <title> element with the con-
556        # tents of 'pagetitle-view-mainpage' instead of the default (if
557        # that's not empty).
558        # This message always exists because it is in the i18n files
559        if ( $this->getTitle()->isMainPage() ) {
560            $msg = $context->msg( 'pagetitle-view-mainpage' )->inContentLanguage();
561            if ( !$msg->isDisabled() ) {
562                $outputPage->setHTMLTitle( $msg->text() );
563            }
564        }
565
566        # Use adaptive TTLs for CDN so delayed/failed purges are noticed less often.
567        # This could use getTouched(), but that could be scary for major template edits.
568        $outputPage->adaptCdnTTL( $this->mPage->getTimestamp(), ExpirationAwareness::TTL_DAY );
569
570        $this->showViewFooter();
571        $this->mPage->doViewUpdates( $authority, $oldid, $this->fetchRevisionRecord() );
572
573        # Load the postEdit module if the user just saved this revision
574        # See also EditPage::setPostEditCookie
575        $request = $context->getRequest();
576        $cookieKey = EditPage::POST_EDIT_COOKIE_KEY_PREFIX . $this->getRevIdFetched();
577        $postEdit = $request->getCookie( $cookieKey );
578        if ( $postEdit ) {
579            # Clear the cookie. This also prevents caching of the response.
580            $request->response()->clearCookie( $cookieKey );
581            $outputPage->addJsConfigVars( 'wgPostEdit', $postEdit );
582            $outputPage->addModules( 'mediawiki.action.view.postEdit' ); // FIXME: test this
583            if ( $this->getContext()->getConfig()->get( MainConfigNames::EnableEditRecovery )
584                && $this->userOptionsLookup->getOption( $this->getContext()->getUser(), 'editrecovery' )
585            ) {
586                $outputPage->addModules( 'mediawiki.editRecovery.postEdit' );
587            }
588        }
589    }
590
591    /**
592     * Show a lock icon above the article body if the page is protected.
593     */
594    public function showProtectionIndicator(): void {
595        $title = $this->getTitle();
596        $context = $this->getContext();
597        $outputPage = $context->getOutput();
598
599        $protectionIndicatorsAreEnabled = $context->getConfig()
600            ->get( MainConfigNames::EnableProtectionIndicators );
601
602        if ( !$protectionIndicatorsAreEnabled || $title->isMainPage() ) {
603            return;
604        }
605
606        $protection = $this->restrictionStore->getRestrictions( $title, 'edit' );
607
608        $cascadeProtection = $this->restrictionStore->getCascadeProtectionSources( $title )[1];
609
610        $isCascadeProtected = array_key_exists( 'edit', $cascadeProtection );
611
612        if ( !$protection && !$isCascadeProtected ) {
613            return;
614        }
615
616        if ( $isCascadeProtected ) {
617            // Cascade-protected pages are protected at the sysop level. So it
618            // should not matter if we take the protection level of the first
619            // or last page that is being cascaded to the current page.
620            $protectionLevel = $cascadeProtection['edit'][0];
621        } else {
622            $protectionLevel = $protection[0];
623        }
624
625        // Protection levels are stored in the database as plain text, but
626        // they are expected to be valid protection levels. So we should be able to
627        // safely use them. However phan thinks this could be a XSS problem so we
628        // are being paranoid and escaping them once more.
629        $protectionLevel = htmlspecialchars( $protectionLevel );
630
631        $protectionExpiry = $this->restrictionStore->getRestrictionExpiry( $title, 'edit' );
632        $formattedProtectionExpiry = $context->getLanguage()
633            ->formatExpiry( $protectionExpiry ?? '' );
634
635        $protectionMsg = 'protection-indicator-title';
636        if ( $protectionExpiry === 'infinity' || !$protectionExpiry ) {
637            $protectionMsg .= '-infinity';
638        }
639
640        // Potential values: 'protection-sysop', 'protection-autoconfirmed',
641        // 'protection-sysop-cascade' etc.
642        // If the wiki has more protection levels, the additional ids that get
643        // added take the form 'protection-<protectionLevel>' and
644        // 'protection-<protectionLevel>-cascade'.
645        $protectionIndicatorId = 'protection-' . $protectionLevel;
646        $protectionIndicatorId .= ( $isCascadeProtected ? '-cascade' : '' );
647
648        // Messages 'protection-indicator-title', 'protection-indicator-title-infinity'
649        $protectionMsg = $outputPage->msg( $protectionMsg, $protectionLevel, $formattedProtectionExpiry )->text();
650
651        // Use a trick similar to the one used in Action::addHelpLink() to allow wikis
652        // to customize where the help link points to.
653        $protectionHelpLink = $outputPage->msg( $protectionIndicatorId . '-helppage' );
654        if ( $protectionHelpLink->isDisabled() ) {
655            $protectionHelpLink = 'https://mediawiki.org/wiki/Special:MyLanguage/Help:Protection';
656        } else {
657            $protectionHelpLink = $protectionHelpLink->text();
658        }
659
660        $outputPage->setIndicators( [
661            $protectionIndicatorId => Html::rawElement( 'a', [
662                'class' => 'mw-protection-indicator-icon--lock',
663                'title' => $protectionMsg,
664                'href' => $protectionHelpLink
665            ],
666            // Screen reader-only text describing the same thing as
667            // was mentioned in the title attribute.
668            Html::element( 'span', [], $protectionMsg ) )
669        ] );
670
671        $outputPage->addModuleStyles( 'mediawiki.protectionIndicators.styles' );
672    }
673
674    /**
675     * Determines the desired ParserOutput and passes it to $outputPage.
676     *
677     * @param Authority $performer
678     * @param ParserOptions $parserOptions
679     * @param int $oldid
680     * @param OutputPage $outputPage
681     * @param array $textOptions
682     *
683     * @return bool True if further processing like footer generation should be applied,
684     *              false to skip further processing.
685     */
686    private function generateContentOutput(
687        Authority $performer,
688        ParserOptions $parserOptions,
689        int $oldid,
690        OutputPage $outputPage,
691        array $textOptions
692    ): bool {
693        # Should the parser cache be used?
694        $useParserCache = true;
695        $pOutput = null;
696        $parserOutputAccess = MediaWikiServices::getInstance()->getParserOutputAccess();
697
698        // NOTE: $outputDone and $useParserCache may be changed by the hook
699        $this->getHookRunner()->onArticleViewHeader( $this, $outputDone, $useParserCache );
700        if ( $outputDone ) {
701            if ( $outputDone instanceof ParserOutput ) {
702                $pOutput = $outputDone;
703            }
704
705            if ( $pOutput ) {
706                $this->doOutputMetaData( $pOutput, $outputPage );
707            }
708            return true;
709        }
710
711        // Early abort if the page doesn't exist
712        if ( !$this->mPage->exists() ) {
713            wfDebug( __METHOD__ . ": showing missing article" );
714            $this->showMissingArticle();
715            $this->mPage->doViewUpdates( $performer );
716            return false; // skip all further output to OutputPage
717        }
718
719        // Try the latest parser cache
720        // NOTE: try latest-revision cache first to avoid loading revision.
721        if ( $useParserCache && !$oldid ) {
722            $pOutput = $parserOutputAccess->getCachedParserOutput(
723                $this->getPage(),
724                $parserOptions,
725                null,
726                ParserOutputAccess::OPT_NO_AUDIENCE_CHECK // we already checked
727            );
728
729            if ( $pOutput ) {
730                $this->doOutputFromParserCache( $pOutput, $outputPage, $textOptions );
731                $this->doOutputMetaData( $pOutput, $outputPage );
732                return true;
733            }
734        }
735
736        $rev = $this->fetchRevisionRecord();
737        if ( !$this->fetchResult->isOK() ) {
738            $this->showViewError( $this->fetchResult->getWikiText(
739                false, false, $this->getContext()->getLanguage()
740            ) );
741            return true;
742        }
743
744        # Are we looking at an old revision
745        if ( $oldid ) {
746            $this->setOldSubtitle( $oldid );
747
748            if ( !$this->showDeletedRevisionHeader() ) {
749                wfDebug( __METHOD__ . ": cannot view deleted revision" );
750                return false; // skip all further output to OutputPage
751            }
752
753            // Try the old revision parser cache
754            // NOTE: Repeating cache check for old revision to avoid fetching $rev
755            // before it's absolutely necessary.
756            if ( $useParserCache ) {
757                $pOutput = $parserOutputAccess->getCachedParserOutput(
758                    $this->getPage(),
759                    $parserOptions,
760                    $rev,
761                    ParserOutputAccess::OPT_NO_AUDIENCE_CHECK // we already checked in fetchRevisionRecord
762                );
763
764                if ( $pOutput ) {
765                    $this->doOutputFromParserCache( $pOutput, $outputPage, $textOptions );
766                    $this->doOutputMetaData( $pOutput, $outputPage );
767                    return true;
768                }
769            }
770        }
771
772        # Ensure that UI elements requiring revision ID have
773        # the correct version information. (This may be overwritten after creation of ParserOutput)
774        $outputPage->setRevisionId( $this->getRevIdFetched() );
775        $outputPage->setRevisionIsCurrent( $rev->isCurrent() );
776        # Preload timestamp to avoid a DB hit
777        $outputPage->setRevisionTimestamp( $rev->getTimestamp() );
778
779        # Pages containing custom CSS or JavaScript get special treatment
780        if ( $this->getTitle()->isSiteConfigPage() || $this->getTitle()->isUserConfigPage() ) {
781            $dir = $this->getContext()->getLanguage()->getDir();
782            $lang = $this->getContext()->getLanguage()->getHtmlCode();
783
784            $outputPage->wrapWikiMsg(
785                "<div id='mw-clearyourcache' lang='$lang' dir='$dir' class='mw-content-$dir'>\n$1\n</div>",
786                'clearyourcache'
787            );
788            $outputPage->addModuleStyles( 'mediawiki.action.styles' );
789        } elseif ( !$this->getHookRunner()->onArticleRevisionViewCustom(
790            $rev,
791            $this->getTitle(),
792            $oldid,
793            $outputPage )
794        ) {
795            // NOTE: sync with hooks called in DifferenceEngine::renderNewRevision()
796            // Allow extensions do their own custom view for certain pages
797            $this->doOutputMetaData( $pOutput, $outputPage );
798            return true;
799        }
800
801        # Run the parse, protected by a pool counter
802        wfDebug( __METHOD__ . ": doing uncached parse" );
803
804        $opt = 0;
805
806        // we already checked the cache in case 2, don't check again.
807        $opt |= ParserOutputAccess::OPT_NO_CHECK_CACHE;
808
809        // we already checked in fetchRevisionRecord()
810        $opt |= ParserOutputAccess::OPT_NO_AUDIENCE_CHECK;
811
812        // enable stampede protection and allow stale content
813        $opt |= ParserOutputAccess::OPT_FOR_ARTICLE_VIEW;
814
815        // Attempt to trigger WikiPage::triggerOpportunisticLinksUpdate
816        // Ideally this should not be the responsibility of the ParserCache to control this.
817        // See https://phabricator.wikimedia.org/T329842#8816557 for more context.
818        $opt |= ParserOutputAccess::OPT_LINKS_UPDATE;
819
820        if ( !$rev->getId() || !$useParserCache ) {
821            // fake revision or uncacheable options
822            $opt |= ParserOutputAccess::OPT_NO_CACHE;
823        }
824
825        $renderStatus = $parserOutputAccess->getParserOutput(
826            $this->getPage(),
827            $parserOptions,
828            $rev,
829            $opt
830        );
831
832        // T327164: If parsoid cache warming is enabled, we want to ensure that the page
833        // the user is currently looking at has a cached parsoid rendering, in case they
834        // open visual editor. The cache entry would typically be missing if it has expired
835        // from the cache or it was invalidated by RefreshLinksJob. When "traditional"
836        // parser output has been invalidated by RefreshLinksJob, we will render it on
837        // the fly when a user requests the page, and thereby populate the cache again,
838        // per the code above.
839        // The code below is intended to do the same for parsoid output, but asynchronously
840        // in a job, so the user does not have to wait.
841        // Note that we get here if the traditional parser output was missing from the cache.
842        // We do not check if the parsoid output is present in the cache, because that check
843        // takes time. The assumption is that if we have traditional parser output
844        // cached, we probably also have parsoid output cached.
845        // So we leave it to ParsoidCachePrewarmJob to determine whether or not parsing is
846        // needed.
847        if ( $oldid === 0 || $oldid === $this->getPage()->getLatest() ) {
848            $parsoidCacheWarmingEnabled = $this->getContext()->getConfig()
849                ->get( MainConfigNames::ParsoidCacheConfig )['WarmParsoidParserCache'];
850
851            if ( $parsoidCacheWarmingEnabled ) {
852                $parsoidJobSpec = ParsoidCachePrewarmJob::newSpec(
853                    $rev->getId(),
854                    $this->getPage()->toPageRecord(),
855                    [ 'causeAction' => 'view' ]
856                );
857                $this->jobQueueGroup->lazyPush( $parsoidJobSpec );
858            }
859        }
860
861        $this->doOutputFromRenderStatus(
862            $rev,
863            $renderStatus,
864            $outputPage,
865            $textOptions
866        );
867
868        if ( !$renderStatus->isOK() ) {
869            return true;
870        }
871
872        $pOutput = $renderStatus->getValue();
873        $this->doOutputMetaData( $pOutput, $outputPage );
874        return true;
875    }
876
877    /**
878     * @param ?ParserOutput $pOutput
879     * @param OutputPage $outputPage
880     */
881    private function doOutputMetaData( ?ParserOutput $pOutput, OutputPage $outputPage ) {
882        # Adjust title for main page & pages with displaytitle
883        if ( $pOutput ) {
884            $this->adjustDisplayTitle( $pOutput );
885
886            // It would be nice to automatically set this during the first call
887            // to OutputPage::addParserOutputMetadata, but we can't because doing
888            // so would break non-pageview actions where OutputPage::getContLangForJS
889            // has different requirements.
890            $pageLang = $pOutput->getLanguage();
891            if ( $pageLang ) {
892                $outputPage->setContentLangForJS( $pageLang );
893            }
894        }
895
896        # Check for any __NOINDEX__ tags on the page using $pOutput
897        $policy = $this->getRobotPolicy( 'view', $pOutput ?: null );
898        $outputPage->setIndexPolicy( $policy['index'] );
899        $outputPage->setFollowPolicy( $policy['follow'] ); // FIXME: test this
900
901        $this->mParserOutput = $pOutput;
902    }
903
904    /**
905     * @param ParserOutput $pOutput
906     * @param OutputPage $outputPage
907     * @param array $textOptions
908     */
909    private function doOutputFromParserCache(
910        ParserOutput $pOutput,
911        OutputPage $outputPage,
912        array $textOptions
913    ) {
914        # Ensure that UI elements requiring revision ID have
915        # the correct version information.
916        $oldid = $pOutput->getCacheRevisionId() ?? $this->getRevIdFetched();
917        $outputPage->setRevisionId( $oldid );
918        $outputPage->setRevisionIsCurrent( $oldid === $this->mPage->getLatest() );
919        $outputPage->addParserOutput( $pOutput, $textOptions );
920        # Preload timestamp to avoid a DB hit
921        $cachedTimestamp = $pOutput->getRevisionTimestamp();
922        if ( $cachedTimestamp !== null ) {
923            $outputPage->setRevisionTimestamp( $cachedTimestamp );
924            $this->mPage->setTimestamp( $cachedTimestamp );
925        }
926    }
927
928    /**
929     * @param RevisionRecord $rev
930     * @param Status $renderStatus
931     * @param OutputPage $outputPage
932     * @param array $textOptions
933     */
934    private function doOutputFromRenderStatus(
935        RevisionRecord $rev,
936        Status $renderStatus,
937        OutputPage $outputPage,
938        array $textOptions
939    ) {
940        $context = $this->getContext();
941        if ( !$renderStatus->isOK() ) {
942            $this->showViewError( $renderStatus->getWikiText(
943                false, 'view-pool-error', $context->getLanguage()
944            ) );
945            return;
946        }
947
948        $pOutput = $renderStatus->getValue();
949
950        // Cache stale ParserOutput object with a short expiry
951        if ( $renderStatus->hasMessage( 'view-pool-dirty-output' ) ) {
952            $outputPage->lowerCdnMaxage( $context->getConfig()->get( MainConfigNames::CdnMaxageStale ) );
953            $outputPage->setLastModified( $pOutput->getCacheTime() );
954            $staleReason = $renderStatus->hasMessage( 'view-pool-contention' )
955                ? $context->msg( 'view-pool-contention' )->escaped()
956                : $context->msg( 'view-pool-timeout' )->escaped();
957            $outputPage->addHTML( "<!-- parser cache is expired, " .
958                "sending anyway due to $staleReason-->\n" );
959
960            // Ensure OutputPage knowns the id from the dirty cache, but keep the current flag (T341013)
961            $cachedId = $pOutput->getCacheRevisionId();
962            if ( $cachedId !== null ) {
963                $outputPage->setRevisionId( $cachedId );
964                $outputPage->setRevisionTimestamp( $pOutput->getTimestamp() );
965            }
966        }
967
968        $outputPage->addParserOutput( $pOutput, $textOptions );
969
970        if ( $this->getRevisionRedirectTarget( $rev ) ) {
971            $outputPage->addSubtitle( "<span id=\"redirectsub\">" .
972                $context->msg( 'redirectpagesub' )->parse() . "</span>" );
973        }
974    }
975
976    /**
977     * @param RevisionRecord $revision
978     * @return null|Title
979     */
980    private function getRevisionRedirectTarget( RevisionRecord $revision ) {
981        // TODO: find a *good* place for the code that determines the redirect target for
982        // a given revision!
983        // NOTE: Use main slot content. Compare code in DerivedPageDataUpdater::revisionIsRedirect.
984        $content = $revision->getContent( SlotRecord::MAIN );
985        return $content ? $content->getRedirectTarget() : null;
986    }
987
988    /**
989     * Adjust title for pages with displaytitle, -{T|}- or language conversion
990     * @param ParserOutput $pOutput
991     */
992    public function adjustDisplayTitle( ParserOutput $pOutput ) {
993        $out = $this->getContext()->getOutput();
994
995        # Adjust the title if it was set by displaytitle, -{T|}- or language conversion
996        $titleText = $pOutput->getTitleText();
997        if ( strval( $titleText ) !== '' ) {
998            $out->setPageTitle( $titleText );
999            $out->setDisplayTitle( $titleText );
1000        }
1001    }
1002
1003    /**
1004     * Show a diff page according to current request variables. For use within
1005     * Article::view() only, other callers should use the DifferenceEngine class.
1006     */
1007    protected function showDiffPage() {
1008        $context = $this->getContext();
1009        $outputPage = $context->getOutput();
1010        $outputPage->addBodyClasses( 'mw-article-diff' );
1011        $request = $context->getRequest();
1012        $diff = $request->getVal( 'diff' );
1013        $rcid = $request->getInt( 'rcid' );
1014        $purge = $request->getRawVal( 'action' ) === 'purge';
1015        $unhide = $request->getInt( 'unhide' ) === 1;
1016        $oldid = $this->getOldID();
1017
1018        $rev = $this->fetchRevisionRecord();
1019
1020        if ( !$rev ) {
1021            // T213621: $rev maybe null due to either lack of permission to view the
1022            // revision or actually not existing. So let's try loading it from the id
1023            $rev = $this->revisionStore->getRevisionById( $oldid );
1024            if ( $rev ) {
1025                // Revision exists but $user lacks permission to diff it.
1026                // Do nothing here.
1027                // The $rev will later be used to create standard diff elements however.
1028            } else {
1029                $outputPage->setPageTitleMsg( $context->msg( 'errorpagetitle' ) );
1030                $msg = $context->msg( 'difference-missing-revision' )
1031                    ->params( $oldid )
1032                    ->numParams( 1 )
1033                    ->parseAsBlock();
1034                $outputPage->addHTML( $msg );
1035                return;
1036            }
1037        }
1038
1039        $services = MediaWikiServices::getInstance();
1040
1041        $contentHandler = $services
1042            ->getContentHandlerFactory()
1043            ->getContentHandler(
1044                $rev->getSlot( SlotRecord::MAIN, RevisionRecord::RAW )->getModel()
1045            );
1046        $de = $contentHandler->createDifferenceEngine(
1047            $context,
1048            $oldid,
1049            $diff,
1050            $rcid,
1051            $purge,
1052            $unhide
1053        );
1054
1055        $diffType = $request->getVal( 'diff-type' );
1056
1057        if ( $diffType === null ) {
1058            $diffType = $this->userOptionsLookup
1059                ->getOption( $context->getUser(), 'diff-type' );
1060        } else {
1061            $de->setExtraQueryParams( [ 'diff-type' => $diffType ] );
1062        }
1063
1064        $de->setSlotDiffOptions( [
1065            'diff-type' => $diffType,
1066            'expand-url' => $this->viewIsRenderAction,
1067            'inline-toggle' => true,
1068        ] );
1069        $de->showDiffPage( $this->isDiffOnlyView() );
1070
1071        // Run view updates for the newer revision being diffed (and shown
1072        // below the diff if not diffOnly).
1073        [ , $new ] = $de->mapDiffPrevNext( $oldid, $diff );
1074        // New can be false, convert it to 0 - this conveniently means the latest revision
1075        $this->mPage->doViewUpdates( $context->getAuthority(), (int)$new );
1076
1077        // Add link to help page; see T321569
1078        $context->getOutput()->addHelpLink( 'Help:Diff' );
1079    }
1080
1081    protected function isDiffOnlyView() {
1082        return $this->getContext()->getRequest()->getBool(
1083            'diffonly',
1084            $this->userOptionsLookup->getBoolOption( $this->getContext()->getUser(), 'diffonly' )
1085        );
1086    }
1087
1088    /**
1089     * Get the robot policy to be used for the current view
1090     * @param string $action The action= GET parameter
1091     * @param ParserOutput|null $pOutput
1092     * @return string[] The policy that should be set
1093     * @todo actions other than 'view'
1094     */
1095    public function getRobotPolicy( $action, ParserOutput $pOutput = null ) {
1096        $context = $this->getContext();
1097        $mainConfig = $context->getConfig();
1098        $articleRobotPolicies = $mainConfig->get( MainConfigNames::ArticleRobotPolicies );
1099        $namespaceRobotPolicies = $mainConfig->get( MainConfigNames::NamespaceRobotPolicies );
1100        $defaultRobotPolicy = $mainConfig->get( MainConfigNames::DefaultRobotPolicy );
1101        $title = $this->getTitle();
1102        $ns = $title->getNamespace();
1103
1104        # Don't index user and user talk pages for blocked users (T13443)
1105        if ( $ns === NS_USER || $ns === NS_USER_TALK ) {
1106            $specificTarget = null;
1107            $vagueTarget = null;
1108            $titleText = $title->getText();
1109            if ( IPUtils::isValid( $titleText ) ) {
1110                $vagueTarget = $titleText;
1111            } else {
1112                $specificTarget = $title->getRootText();
1113            }
1114            if ( $this->blockStore->newFromTarget( $specificTarget, $vagueTarget ) instanceof DatabaseBlock ) {
1115                return [
1116                    'index' => 'noindex',
1117                    'follow' => 'nofollow'
1118                ];
1119            }
1120        }
1121
1122        if ( $this->mPage->getId() === 0 || $this->getOldID() ) {
1123            # Non-articles (special pages etc), and old revisions
1124            return [
1125                'index' => 'noindex',
1126                'follow' => 'nofollow'
1127            ];
1128        } elseif ( $context->getOutput()->isPrintable() ) {
1129            # Discourage indexing of printable versions, but encourage following
1130            return [
1131                'index' => 'noindex',
1132                'follow' => 'follow'
1133            ];
1134        } elseif ( $context->getRequest()->getInt( 'curid' ) ) {
1135            # For ?curid=x urls, disallow indexing
1136            return [
1137                'index' => 'noindex',
1138                'follow' => 'follow'
1139            ];
1140        }
1141
1142        # Otherwise, construct the policy based on the various config variables.
1143        $policy = self::formatRobotPolicy( $defaultRobotPolicy );
1144
1145        if ( isset( $namespaceRobotPolicies[$ns] ) ) {
1146            # Honour customised robot policies for this namespace
1147            $policy = array_merge(
1148                $policy,
1149                self::formatRobotPolicy( $namespaceRobotPolicies[$ns] )
1150            );
1151        }
1152        if ( $title->canUseNoindex() && $pOutput && $pOutput->getIndexPolicy() ) {
1153            # __INDEX__ and __NOINDEX__ magic words, if allowed. Incorporates
1154            # a final check that we have really got the parser output.
1155            $policy = array_merge(
1156                $policy,
1157                [ 'index' => $pOutput->getIndexPolicy() ]
1158            );
1159        }
1160
1161        if ( isset( $articleRobotPolicies[$title->getPrefixedText()] ) ) {
1162            # (T16900) site config can override user-defined __INDEX__ or __NOINDEX__
1163            $policy = array_merge(
1164                $policy,
1165                self::formatRobotPolicy( $articleRobotPolicies[$title->getPrefixedText()] )
1166            );
1167        }
1168
1169        return $policy;
1170    }
1171
1172    /**
1173     * Converts a String robot policy into an associative array, to allow
1174     * merging of several policies using array_merge().
1175     * @param array|string $policy Returns empty array on null/false/'', transparent
1176     *   to already-converted arrays, converts string.
1177     * @return array 'index' => \<indexpolicy\>, 'follow' => \<followpolicy\>
1178     */
1179    public static function formatRobotPolicy( $policy ) {
1180        if ( is_array( $policy ) ) {
1181            return $policy;
1182        } elseif ( !$policy ) {
1183            return [];
1184        }
1185
1186        $arr = [];
1187        foreach ( explode( ',', $policy ) as $var ) {
1188            $var = trim( $var );
1189            if ( $var === 'index' || $var === 'noindex' ) {
1190                $arr['index'] = $var;
1191            } elseif ( $var === 'follow' || $var === 'nofollow' ) {
1192                $arr['follow'] = $var;
1193            }
1194        }
1195
1196        return $arr;
1197    }
1198
1199    /**
1200     * If this request is a redirect view, send "redirected from" subtitle to
1201     * the output. Returns true if the header was needed, false if this is not
1202     * a redirect view. Handles both local and remote redirects.
1203     *
1204     * @return bool
1205     */
1206    public function showRedirectedFromHeader() {
1207        $context = $this->getContext();
1208        $redirectSources = $context->getConfig()->get( MainConfigNames::RedirectSources );
1209        $outputPage = $context->getOutput();
1210        $request = $context->getRequest();
1211        $rdfrom = $request->getVal( 'rdfrom' );
1212
1213        // Construct a URL for the current page view, but with the target title
1214        $query = $request->getValues();
1215        unset( $query['rdfrom'] );
1216        unset( $query['title'] );
1217        if ( $this->getTitle()->isRedirect() ) {
1218            // Prevent double redirects
1219            $query['redirect'] = 'no';
1220        }
1221        $redirectTargetUrl = $this->getTitle()->getLinkURL( $query );
1222
1223        if ( isset( $this->mRedirectedFrom ) ) {
1224            // This is an internally redirected page view.
1225            // We'll need a backlink to the source page for navigation.
1226            if ( $this->getHookRunner()->onArticleViewRedirect( $this ) ) {
1227                $redir = $this->linkRenderer->makeKnownLink(
1228                    $this->mRedirectedFrom,
1229                    null,
1230                    [],
1231                    [ 'redirect' => 'no' ]
1232                );
1233
1234                $outputPage->addSubtitle( "<span class=\"mw-redirectedfrom\">" .
1235                    $context->msg( 'redirectedfrom' )->rawParams( $redir )->parse()
1236                . "</span>" );
1237
1238                // Add the script to update the displayed URL and
1239                // set the fragment if one was specified in the redirect
1240                $outputPage->addJsConfigVars( [
1241                    'wgInternalRedirectTargetUrl' => $redirectTargetUrl,
1242                ] );
1243                $outputPage->addModules( 'mediawiki.action.view.redirect' );
1244
1245                // Add a <link rel="canonical"> tag
1246                $outputPage->setCanonicalUrl( $this->getTitle()->getCanonicalURL() );
1247
1248                // Tell the output object that the user arrived at this article through a redirect
1249                $outputPage->setRedirectedFrom( $this->mRedirectedFrom );
1250
1251                return true;
1252            }
1253        } elseif ( $rdfrom ) {
1254            // This is an externally redirected view, from some other wiki.
1255            // If it was reported from a trusted site, supply a backlink.
1256            if ( $redirectSources && preg_match( $redirectSources, $rdfrom ) ) {
1257                $redir = $this->linkRenderer->makeExternalLink( $rdfrom, $rdfrom, $this->getTitle() );
1258                $outputPage->addSubtitle( "<span class=\"mw-redirectedfrom\">" .
1259                    $context->msg( 'redirectedfrom' )->rawParams( $redir )->parse()
1260                . "</span>" );
1261
1262                // Add the script to update the displayed URL
1263                $outputPage->addJsConfigVars( [
1264                    'wgInternalRedirectTargetUrl' => $redirectTargetUrl,
1265                ] );
1266                $outputPage->addModules( 'mediawiki.action.view.redirect' );
1267
1268                return true;
1269            }
1270        }
1271
1272        return false;
1273    }
1274
1275    /**
1276     * Show a header specific to the namespace currently being viewed, like
1277     * [[MediaWiki:Talkpagetext]]. For Article::view().
1278     */
1279    public function showNamespaceHeader() {
1280        if ( $this->getTitle()->isTalkPage() && !$this->getContext()->msg( 'talkpageheader' )->isDisabled() ) {
1281            $this->getContext()->getOutput()->wrapWikiMsg(
1282                "<div class=\"mw-talkpageheader\">\n$1\n</div>",
1283                [ 'talkpageheader' ]
1284            );
1285        }
1286    }
1287
1288    /**
1289     * Show the footer section of an ordinary page view
1290     */
1291    public function showViewFooter() {
1292        # check if we're displaying a [[User talk:x.x.x.x]] anonymous talk page
1293        if ( $this->getTitle()->getNamespace() === NS_USER_TALK
1294            && IPUtils::isValid( $this->getTitle()->getText() )
1295        ) {
1296            $this->getContext()->getOutput()->addWikiMsg( 'anontalkpagetext' );
1297        }
1298
1299        // Show a footer allowing the user to patrol the shown revision or page if possible
1300        $patrolFooterShown = $this->showPatrolFooter();
1301
1302        $this->getHookRunner()->onArticleViewFooter( $this, $patrolFooterShown );
1303    }
1304
1305    /**
1306     * If patrol is possible, output a patrol UI box. This is called from the
1307     * footer section of ordinary page views. If patrol is not possible or not
1308     * desired, does nothing.
1309     *
1310     * Side effect: When the patrol link is build, this method will call
1311     * OutputPage::setPreventClickjacking(true) and load a JS module.
1312     *
1313     * @return bool
1314     */
1315    public function showPatrolFooter() {
1316        $context = $this->getContext();
1317        $mainConfig = $context->getConfig();
1318        $useNPPatrol = $mainConfig->get( MainConfigNames::UseNPPatrol );
1319        $useRCPatrol = $mainConfig->get( MainConfigNames::UseRCPatrol );
1320        $useFilePatrol = $mainConfig->get( MainConfigNames::UseFilePatrol );
1321        // Allow hooks to decide whether to not output this at all
1322        if ( !$this->getHookRunner()->onArticleShowPatrolFooter( $this ) ) {
1323            return false;
1324        }
1325
1326        $outputPage = $context->getOutput();
1327        $user = $context->getUser();
1328        $title = $this->getTitle();
1329        $rc = false;
1330
1331        if ( !$context->getAuthority()->probablyCan( 'patrol', $title )
1332            || !( $useRCPatrol || $useNPPatrol
1333                || ( $useFilePatrol && $title->inNamespace( NS_FILE ) ) )
1334        ) {
1335            // Patrolling is disabled or the user isn't allowed to
1336            return false;
1337        }
1338
1339        if ( $this->mRevisionRecord
1340            && !RecentChange::isInRCLifespan( $this->mRevisionRecord->getTimestamp(), 21600 )
1341        ) {
1342            // The current revision is already older than what could be in the RC table
1343            // 6h tolerance because the RC might not be cleaned out regularly
1344            return false;
1345        }
1346
1347        // Check for cached results
1348        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
1349        $key = $cache->makeKey( 'unpatrollable-page', $title->getArticleID() );
1350        if ( $cache->get( $key ) ) {
1351            return false;
1352        }
1353
1354        $dbr = $this->dbProvider->getReplicaDatabase();
1355        $oldestRevisionRow = $dbr->newSelectQueryBuilder()
1356            ->select( [ 'rev_id', 'rev_timestamp' ] )
1357            ->from( 'revision' )
1358            ->where( [ 'rev_page' => $title->getArticleID() ] )
1359            ->orderBy( [ 'rev_timestamp', 'rev_id' ] )
1360            ->caller( __METHOD__ )->fetchRow();
1361        $oldestRevisionTimestamp = $oldestRevisionRow ? $oldestRevisionRow->rev_timestamp : false;
1362
1363        // New page patrol: Get the timestamp of the oldest revision which
1364        // the revision table holds for the given page. Then we look
1365        // whether it's within the RC lifespan and if it is, we try
1366        // to get the recentchanges row belonging to that entry.
1367        $recentPageCreation = false;
1368        if ( $oldestRevisionTimestamp
1369            && RecentChange::isInRCLifespan( $oldestRevisionTimestamp, 21600 )
1370        ) {
1371            // 6h tolerance because the RC might not be cleaned out regularly
1372            $recentPageCreation = true;
1373            $rc = RecentChange::newFromConds(
1374                [
1375                    'rc_this_oldid' => intval( $oldestRevisionRow->rev_id ),
1376                    // Avoid selecting a categorization entry
1377                    'rc_type' => RC_NEW,
1378                ],
1379                __METHOD__
1380            );
1381            if ( $rc ) {
1382                // Use generic patrol message for new pages
1383                $markPatrolledMsg = $context->msg( 'markaspatrolledtext' );
1384            }
1385        }
1386
1387        // File patrol: Get the timestamp of the latest upload for this page,
1388        // check whether it is within the RC lifespan and if it is, we try
1389        // to get the recentchanges row belonging to that entry
1390        // (with rc_type = RC_LOG, rc_log_type = upload).
1391        $recentFileUpload = false;
1392        if ( ( !$rc || $rc->getAttribute( 'rc_patrolled' ) ) && $useFilePatrol
1393            && $title->getNamespace() === NS_FILE ) {
1394            // Retrieve timestamp from the current file (lastest upload)
1395            $newestUploadTimestamp = $dbr->newSelectQueryBuilder()
1396                ->select( 'img_timestamp' )
1397                ->from( 'image' )
1398                ->where( [ 'img_name' => $title->getDBkey() ] )
1399                ->caller( __METHOD__ )->fetchField();
1400            if ( $newestUploadTimestamp
1401                && RecentChange::isInRCLifespan( $newestUploadTimestamp, 21600 )
1402            ) {
1403                // 6h tolerance because the RC might not be cleaned out regularly
1404                $recentFileUpload = true;
1405                $rc = RecentChange::newFromConds(
1406                    [
1407                        'rc_type' => RC_LOG,
1408                        'rc_log_type' => 'upload',
1409                        'rc_timestamp' => $newestUploadTimestamp,
1410                        'rc_namespace' => NS_FILE,
1411                        'rc_cur_id' => $title->getArticleID()
1412                    ],
1413                    __METHOD__
1414                );
1415                if ( $rc ) {
1416                    // Use patrol message specific to files
1417                    $markPatrolledMsg = $context->msg( 'markaspatrolledtext-file' );
1418                }
1419            }
1420        }
1421
1422        if ( !$recentPageCreation && !$recentFileUpload ) {
1423            // Page creation and latest upload (for files) is too old to be in RC
1424
1425            // We definitely can't patrol so cache the information
1426            // When a new file version is uploaded, the cache is cleared
1427            $cache->set( $key, '1' );
1428
1429            return false;
1430        }
1431
1432        if ( !$rc ) {
1433            // Don't cache: This can be hit if the page gets accessed very fast after
1434            // its creation / latest upload or in case we have high replica DB lag. In case
1435            // the revision is too old, we will already return above.
1436            return false;
1437        }
1438
1439        if ( $rc->getAttribute( 'rc_patrolled' ) ) {
1440            // Patrolled RC entry around
1441
1442            // Cache the information we gathered above in case we can't patrol
1443            // Don't cache in case we can patrol as this could change
1444            $cache->set( $key, '1' );
1445
1446            return false;
1447        }
1448
1449        if ( $rc->getPerformerIdentity()->equals( $user ) ) {
1450            // Don't show a patrol link for own creations/uploads. If the user could
1451            // patrol them, they already would be patrolled
1452            return false;
1453        }
1454
1455        $outputPage->setPreventClickjacking( true );
1456        if ( $context->getAuthority()->isAllowed( 'writeapi' ) ) {
1457            $outputPage->addModules( 'mediawiki.misc-authed-curate' );
1458        }
1459
1460        $link = $this->linkRenderer->makeKnownLink(
1461            $title,
1462            // @phan-suppress-next-line PhanPossiblyUndeclaredVariable $markPatrolledMsg is always set when $rc is set
1463            $markPatrolledMsg->text(),
1464            [],
1465            [
1466                'action' => 'markpatrolled',
1467                'rcid' => $rc->getAttribute( 'rc_id' ),
1468            ]
1469        );
1470
1471        $outputPage->addModuleStyles( 'mediawiki.action.styles' );
1472        $outputPage->addHTML(
1473            "<div class='patrollink' data-mw='interface'>" .
1474                $context->msg( 'markaspatrolledlink' )->rawParams( $link )->escaped() .
1475            '</div>'
1476        );
1477
1478        return true;
1479    }
1480
1481    /**
1482     * Purge the cache used to check if it is worth showing the patrol footer
1483     * For example, it is done during re-uploads when file patrol is used.
1484     * @param int $articleID ID of the article to purge
1485     * @since 1.27
1486     */
1487    public static function purgePatrolFooterCache( $articleID ) {
1488        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
1489        $cache->delete( $cache->makeKey( 'unpatrollable-page', $articleID ) );
1490    }
1491
1492    /**
1493     * Show the error text for a missing article. For articles in the MediaWiki
1494     * namespace, show the default message text. To be called from Article::view().
1495     */
1496    public function showMissingArticle() {
1497        $context = $this->getContext();
1498        $send404Code = $context->getConfig()->get( MainConfigNames::Send404Code );
1499
1500        $outputPage = $context->getOutput();
1501        // Whether the page is a root user page of an existing user (but not a subpage)
1502        $validUserPage = false;
1503
1504        $title = $this->getTitle();
1505
1506        $services = MediaWikiServices::getInstance();
1507
1508        $contextUser = $context->getUser();
1509
1510        # Show info in user (talk) namespace. Does the user exist? Is he blocked?
1511        if ( $title->getNamespace() === NS_USER
1512            || $title->getNamespace() === NS_USER_TALK
1513        ) {
1514            $rootPart = $title->getRootText();
1515            $user = User::newFromName( $rootPart, false /* allow IP users */ );
1516            $ip = $this->userNameUtils->isIP( $rootPart );
1517            $block = $this->blockStore->newFromTarget( $user, $user );
1518
1519            if ( $user && $user->isRegistered() && $user->isHidden() &&
1520                !$context->getAuthority()->isAllowed( 'hideuser' )
1521            ) {
1522                // T120883 if the user is hidden and the viewer cannot see hidden
1523                // users, pretend like it does not exist at all.
1524                $user = false;
1525            }
1526
1527            if ( !( $user && $user->isRegistered() ) && !$ip ) {
1528                // User does not exist
1529                $outputPage->addHTML( Html::warningBox(
1530                    $context->msg( 'userpage-userdoesnotexist-view', wfEscapeWikiText( $rootPart ) )->parse(),
1531                    'mw-userpage-userdoesnotexist'
1532                ) );
1533
1534                // Show renameuser log extract
1535                LogEventsList::showLogExtract(
1536                    $outputPage,
1537                    'renameuser',
1538                    Title::makeTitleSafe( NS_USER, $rootPart ),
1539                    '',
1540                    [
1541                        'lim' => 10,
1542                        'showIfEmpty' => false,
1543                        'msgKey' => [ 'renameuser-renamed-notice', $title->getBaseText() ]
1544                    ]
1545                );
1546            } elseif (
1547                $block !== null &&
1548                $block->getType() != DatabaseBlock::TYPE_AUTO &&
1549                (
1550                    $block->isSitewide() ||
1551                    $services->getPermissionManager()->isBlockedFrom( $user, $title, true )
1552                )
1553            ) {
1554                // Show log extract if the user is sitewide blocked or is partially
1555                // blocked and not allowed to edit their user page or user talk page
1556                LogEventsList::showLogExtract(
1557                    $outputPage,
1558                    'block',
1559                    $services->getNamespaceInfo()->getCanonicalName( NS_USER ) . ':' .
1560                        $block->getTargetName(),
1561                    '',
1562                    [
1563                        'lim' => 1,
1564                        'showIfEmpty' => false,
1565                        'msgKey' => [
1566                            'blocked-notice-logextract',
1567                            $user->getName() # Support GENDER in notice
1568                        ]
1569                    ]
1570                );
1571                $validUserPage = !$title->isSubpage();
1572            } else {
1573                $validUserPage = !$title->isSubpage();
1574            }
1575        }
1576
1577        $this->getHookRunner()->onShowMissingArticle( $this );
1578
1579        # Show delete and move logs if there were any such events.
1580        # The logging query can DOS the site when bots/crawlers cause 404 floods,
1581        # so be careful showing this. 404 pages must be cheap as they are hard to cache.
1582        $dbCache = MediaWikiServices::getInstance()->getMainObjectStash();
1583        $key = $dbCache->makeKey( 'page-recent-delete', md5( $title->getPrefixedText() ) );
1584        $isRegistered = $contextUser->isRegistered();
1585        $sessionExists = $context->getRequest()->getSession()->isPersistent();
1586
1587        if ( $isRegistered || $dbCache->get( $key ) || $sessionExists ) {
1588            $logTypes = [ 'delete', 'move', 'protect' ];
1589
1590            $dbr = $this->dbProvider->getReplicaDatabase();
1591
1592            $conds = [ $dbr->expr( 'log_action', '!=', 'revision' ) ];
1593            // Give extensions a chance to hide their (unrelated) log entries
1594            $this->getHookRunner()->onArticle__MissingArticleConditions( $conds, $logTypes );
1595            LogEventsList::showLogExtract(
1596                $outputPage,
1597                $logTypes,
1598                $title,
1599                '',
1600                [
1601                    'lim' => 10,
1602                    'conds' => $conds,
1603                    'showIfEmpty' => false,
1604                    'msgKey' => [ $isRegistered || $sessionExists
1605                        ? 'moveddeleted-notice'
1606                        : 'moveddeleted-notice-recent'
1607                    ]
1608                ]
1609            );
1610        }
1611
1612        if ( !$this->mPage->hasViewableContent() && $send404Code && !$validUserPage ) {
1613            // If there's no backing content, send a 404 Not Found
1614            // for better machine handling of broken links.
1615            $context->getRequest()->response()->statusHeader( 404 );
1616        }
1617
1618        // Also apply the robot policy for nonexisting pages (even if a 404 was used)
1619        $policy = $this->getRobotPolicy( 'view' );
1620        $outputPage->setIndexPolicy( $policy['index'] );
1621        $outputPage->setFollowPolicy( $policy['follow'] );
1622
1623        $hookResult = $this->getHookRunner()->onBeforeDisplayNoArticleText( $this );
1624
1625        if ( !$hookResult ) {
1626            return;
1627        }
1628
1629        # Show error message
1630        $oldid = $this->getOldID();
1631        if ( !$oldid && $title->getNamespace() === NS_MEDIAWIKI && $title->hasSourceText() ) {
1632            $text = $this->getTitle()->getDefaultMessageText() ?? '';
1633            $outputPage->addWikiTextAsContent( $text );
1634        } else {
1635            if ( $oldid ) {
1636                $text = $this->getMissingRevisionMsg( $oldid )->plain();
1637            } elseif ( $context->getAuthority()->probablyCan( 'edit', $title ) ) {
1638                $message = $isRegistered ? 'noarticletext' : 'noarticletextanon';
1639                $text = $context->msg( $message )->plain();
1640            } else {
1641                $text = $context->msg( 'noarticletext-nopermission' )->plain();
1642            }
1643
1644            $dir = $context->getLanguage()->getDir();
1645            $lang = $context->getLanguage()->getHtmlCode();
1646            $outputPage->addWikiTextAsInterface( Xml::openElement( 'div', [
1647                'class' => "noarticletext mw-content-$dir",
1648                'dir' => $dir,
1649                'lang' => $lang,
1650            ] ) . "\n$text\n</div>" );
1651        }
1652    }
1653
1654    /**
1655     * Show error text for errors generated in Article::view().
1656     * @param string $errortext localized wikitext error message
1657     */
1658    private function showViewError( string $errortext ) {
1659        $outputPage = $this->getContext()->getOutput();
1660        $outputPage->setPageTitleMsg( $this->getContext()->msg( 'errorpagetitle' ) );
1661        $outputPage->disableClientCache();
1662        $outputPage->setRobotPolicy( 'noindex,nofollow' );
1663        $outputPage->clearHTML();
1664        $outputPage->addHTML( Html::errorBox( $outputPage->parseAsContent( $errortext ) ) );
1665    }
1666
1667    /**
1668     * If the revision requested for view is deleted, check permissions.
1669     * Send either an error message or a warning header to the output.
1670     *
1671     * @return bool True if the view is allowed, false if not.
1672     */
1673    public function showDeletedRevisionHeader() {
1674        if ( !$this->mRevisionRecord->isDeleted( RevisionRecord::DELETED_TEXT ) ) {
1675            // Not deleted
1676            return true;
1677        }
1678        $outputPage = $this->getContext()->getOutput();
1679        // Used in wikilinks, should not contain whitespaces
1680        $titleText = $this->getTitle()->getPrefixedDBkey();
1681        // If the user is not allowed to see it...
1682        if ( !$this->mRevisionRecord->userCan(
1683            RevisionRecord::DELETED_TEXT,
1684            $this->getContext()->getAuthority()
1685        ) ) {
1686            $outputPage->addHTML(
1687                Html::warningBox(
1688                    $outputPage->msg( 'rev-deleted-text-permission', $titleText )->parse(),
1689                    'plainlinks'
1690                )
1691            );
1692
1693            return false;
1694        // If the user needs to confirm that they want to see it...
1695        } elseif ( $this->getContext()->getRequest()->getInt( 'unhide' ) !== 1 ) {
1696            # Give explanation and add a link to view the revision...
1697            $oldid = intval( $this->getOldID() );
1698            $link = $this->getTitle()->getFullURL( "oldid={$oldid}&unhide=1" );
1699            $msg = $this->mRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED ) ?
1700                'rev-suppressed-text-unhide' : 'rev-deleted-text-unhide';
1701            $outputPage->addHTML(
1702                Html::warningBox(
1703                    $outputPage->msg( $msg, $link )->parse(),
1704                    'plainlinks'
1705                )
1706            );
1707
1708            return false;
1709        // We are allowed to see...
1710        } else {
1711            $msg = $this->mRevisionRecord->isDeleted( RevisionRecord::DELETED_RESTRICTED )
1712                ? [ 'rev-suppressed-text-view', $titleText ]
1713                : [ 'rev-deleted-text-view', $titleText ];
1714            $outputPage->addHTML(
1715                Html::warningBox(
1716                    $outputPage->msg( $msg[0], $msg[1] )->parse(),
1717                    'plainlinks'
1718                )
1719            );
1720
1721            return true;
1722        }
1723    }
1724
1725    /**
1726     * Generate the navigation links when browsing through an article revisions
1727     * It shows the information as:
1728     *   Revision as of \<date\>; view current revision
1729     *   \<- Previous version | Next Version -\>
1730     *
1731     * @param int $oldid Revision ID of this article revision
1732     */
1733    public function setOldSubtitle( $oldid = 0 ) {
1734        if ( !$this->getHookRunner()->onDisplayOldSubtitle( $this, $oldid ) ) {
1735            return;
1736        }
1737
1738        $context = $this->getContext();
1739        $unhide = $context->getRequest()->getInt( 'unhide' ) === 1;
1740
1741        # Cascade unhide param in links for easy deletion browsing
1742        $extraParams = [];
1743        if ( $unhide ) {
1744            $extraParams['unhide'] = 1;
1745        }
1746
1747        if ( $this->mRevisionRecord && $this->mRevisionRecord->getId() === $oldid ) {
1748            $revisionRecord = $this->mRevisionRecord;
1749        } else {
1750            $revisionRecord = $this->revisionStore->getRevisionById( $oldid );
1751        }
1752        if ( !$revisionRecord ) {
1753            throw new LogicException( 'There should be a revision record at this point.' );
1754        }
1755
1756        $timestamp = $revisionRecord->getTimestamp();
1757
1758        $current = ( $oldid == $this->mPage->getLatest() );
1759        $language = $context->getLanguage();
1760        $user = $context->getUser();
1761
1762        $td = $language->userTimeAndDate( $timestamp, $user );
1763        $tddate = $language->userDate( $timestamp, $user );
1764        $tdtime = $language->userTime( $timestamp, $user );
1765
1766        # Show user links if allowed to see them. If hidden, then show them only if requested...
1767        $userlinks = Linker::revUserTools( $revisionRecord, !$unhide );
1768
1769        $infomsg = $current && !$context->msg( 'revision-info-current' )->isDisabled()
1770            ? 'revision-info-current'
1771            : 'revision-info';
1772
1773        $outputPage = $context->getOutput();
1774        $outputPage->addModuleStyles( [
1775            'mediawiki.action.styles',
1776            'mediawiki.interface.helpers.styles'
1777        ] );
1778
1779        $revisionUser = $revisionRecord->getUser();
1780        $revisionInfo = "<div id=\"mw-{$infomsg}\">" .
1781            $context->msg( $infomsg, $td )
1782                ->rawParams( $userlinks )
1783                ->params(
1784                    $revisionRecord->getId(),
1785                    $tddate,
1786                    $tdtime,
1787                    $revisionUser ? $revisionUser->getName() : ''
1788                )
1789                ->rawParams( $this->commentFormatter->formatRevision(
1790                    $revisionRecord,
1791                    $user,
1792                    true,
1793                    !$unhide
1794                ) )
1795                ->parse() .
1796            "</div>";
1797
1798        $lnk = $current
1799            ? $context->msg( 'currentrevisionlink' )->escaped()
1800            : $this->linkRenderer->makeKnownLink(
1801                $this->getTitle(),
1802                $context->msg( 'currentrevisionlink' )->text(),
1803                [],
1804                $extraParams
1805            );
1806        $curdiff = $current
1807            ? $context->msg( 'diff' )->escaped()
1808            : $this->linkRenderer->makeKnownLink(
1809                $this->getTitle(),
1810                $context->msg( 'diff' )->text(),
1811                [],
1812                [
1813                    'diff' => 'cur',
1814                    'oldid' => $oldid
1815                ] + $extraParams
1816            );
1817        $prevExist = (bool)$this->revisionStore->getPreviousRevision( $revisionRecord );
1818        $prevlink = $prevExist
1819            ? $this->linkRenderer->makeKnownLink(
1820                $this->getTitle(),
1821                $context->msg( 'previousrevision' )->text(),
1822                [],
1823                [
1824                    'direction' => 'prev',
1825                    'oldid' => $oldid
1826                ] + $extraParams
1827            )
1828            : $context->msg( 'previousrevision' )->escaped();
1829        $prevdiff = $prevExist
1830            ? $this->linkRenderer->makeKnownLink(
1831                $this->getTitle(),
1832                $context->msg( 'diff' )->text(),
1833                [],
1834                [
1835                    'diff' => 'prev',
1836                    'oldid' => $oldid
1837                ] + $extraParams
1838            )
1839            : $context->msg( 'diff' )->escaped();
1840        $nextlink = $current
1841            ? $context->msg( 'nextrevision' )->escaped()
1842            : $this->linkRenderer->makeKnownLink(
1843                $this->getTitle(),
1844                $context->msg( 'nextrevision' )->text(),
1845                [],
1846                [
1847                    'direction' => 'next',
1848                    'oldid' => $oldid
1849                ] + $extraParams
1850            );
1851        $nextdiff = $current
1852            ? $context->msg( 'diff' )->escaped()
1853            : $this->linkRenderer->makeKnownLink(
1854                $this->getTitle(),
1855                $context->msg( 'diff' )->text(),
1856                [],
1857                [
1858                    'diff' => 'next',
1859                    'oldid' => $oldid
1860                ] + $extraParams
1861            );
1862
1863        $cdel = Linker::getRevDeleteLink(
1864            $context->getAuthority(),
1865            $revisionRecord,
1866            $this->getTitle()
1867        );
1868        if ( $cdel !== '' ) {
1869            $cdel .= ' ';
1870        }
1871
1872        // the outer div is need for styling the revision info and nav in MobileFrontend
1873        $outputPage->addSubtitle(
1874            Html::warningBox(
1875                $revisionInfo .
1876                "<div id=\"mw-revision-nav\">" . $cdel .
1877                $context->msg( 'revision-nav' )->rawParams(
1878                    $prevdiff, $prevlink, $lnk, $curdiff, $nextlink, $nextdiff
1879                )->escaped() . "</div>",
1880                'mw-revision'
1881            )
1882        );
1883    }
1884
1885    /**
1886     * Return the HTML for the top of a redirect page
1887     *
1888     * Chances are you should just be using the ParserOutput from
1889     * WikitextContent::getParserOutput instead of calling this for redirects.
1890     *
1891     * @since 1.23
1892     * @param Language $lang
1893     * @param Title $target Destination to redirect
1894     * @param bool $forceKnown Should the image be shown as a bluelink regardless of existence?
1895     * @return string Containing HTML with redirect link
1896     * @deprecated since 1.41, use LinkRenderer::makeRedirectHeader() instead
1897     */
1898    public static function getRedirectHeaderHtml( Language $lang, Title $target, $forceKnown = false ) {
1899        wfDeprecated( __METHOD__, '1.41' );
1900        $linkRenderer = MediaWikiServices::getInstance()->getLinkRenderer();
1901        return $linkRenderer->makeRedirectHeader( $lang, $target, $forceKnown );
1902    }
1903
1904    /**
1905     * Adds help link with an icon via page indicators.
1906     * Link target can be overridden by a local message containing a wikilink:
1907     * the message key is: 'namespace-' + namespace number + '-helppage'.
1908     * @param string $to Target MediaWiki.org page title or encoded URL.
1909     * @param bool $overrideBaseUrl Whether $url is a full URL, to avoid MW.o.
1910     * @since 1.25
1911     */
1912    public function addHelpLink( $to, $overrideBaseUrl = false ) {
1913        $out = $this->getContext()->getOutput();
1914        $msg = $out->msg( 'namespace-' . $this->getTitle()->getNamespace() . '-helppage' );
1915
1916        if ( !$msg->isDisabled() ) {
1917            $title = Title::newFromText( $msg->plain() );
1918            if ( $title instanceof Title ) {
1919                $out->addHelpLink( $title->getLocalURL(), true );
1920            }
1921        } else {
1922            $out->addHelpLink( $to, $overrideBaseUrl );
1923        }
1924    }
1925
1926    /**
1927     * Handle action=render
1928     */
1929    public function render() {
1930        $this->getContext()->getRequest()->response()->header( 'X-Robots-Tag: noindex' );
1931        $this->getContext()->getOutput()->setArticleBodyOnly( true );
1932        // We later set 'enableSectionEditLinks=false' based on this; also used by ImagePage
1933        $this->viewIsRenderAction = true;
1934        $this->view();
1935    }
1936
1937    /**
1938     * action=protect handler
1939     */
1940    public function protect() {
1941        $form = new ProtectionForm( $this );
1942        $form->execute();
1943    }
1944
1945    /**
1946     * action=unprotect handler (alias)
1947     */
1948    public function unprotect() {
1949        $this->protect();
1950    }
1951
1952    /* Caching functions */
1953
1954    /**
1955     * checkLastModified returns true if it has taken care of all
1956     * output to the client that is necessary for this request.
1957     * (that is, it has sent a cached version of the page)
1958     *
1959     * @return bool True if cached version send, false otherwise
1960     */
1961    protected function tryFileCache() {
1962        static $called = false;
1963
1964        if ( $called ) {
1965