File.php

Go to the documentation of this file.

<?php
abstract class File {
    // Bitfield values akin to the Revision deletion constants
    const DELETED_FILE = 1;
    const DELETED_COMMENT = 2;
    const DELETED_USER = 4;
    const DELETED_RESTRICTED = 8;
 
    const RENDER_NOW = 1;
    const RENDER_FORCE = 2;
 
    const DELETE_SOURCE = 1;
 
    // Audience options for File::getDescription()
    const FOR_PUBLIC = 1;
    const FOR_THIS_USER = 2;
    const RAW = 3;
 
    // Options for File::thumbName()
    const THUMB_FULL_NAME = 1;
 
    public $repo;
 
    protected $title;
 
    protected $lastError;
 
    protected $redirected;
 
    protected $redirectedTitle;
 
    protected $fsFile;
 
    protected $handler;
 
    protected $url;
 
    protected $extension;
 
    protected $name;
 
    protected $path;
 
    protected $hashPath;
 
    protected $pageCount;
 
    protected $transformScript;
 
    protected $redirectTitle;
 
    protected $canRender;
 
    protected $isSafeFile;
 
    protected $repoClass = 'FileRepo';
 
    function __construct( $title, $repo ) {
        if ( $title !== false ) { // subclasses may not use MW titles
            $title = self::normalizeTitle( $title, 'exception' );
        }
        $this->title = $title;
        $this->repo = $repo;
    }
 
    static function normalizeTitle( $title, $exception = false ) {
        $ret = $title;
        if ( $ret instanceof Title ) {
            # Normalize NS_MEDIA -> NS_FILE
            if ( $ret->getNamespace() == NS_MEDIA ) {
                $ret = Title::makeTitleSafe( NS_FILE, $ret->getDBkey() );
            # Sanity check the title namespace
            } elseif ( $ret->getNamespace() !== NS_FILE ) {
                $ret = null;
            }
        } else {
            # Convert strings to Title objects
            $ret = Title::makeTitleSafe( NS_FILE, (string)$ret );
        }
        if ( !$ret && $exception !== false ) {
            throw new MWException( "`$title` is not a valid file title." );
        }
 
        return $ret;
    }
 
    function __get( $name ) {
        $function = array( $this, 'get' . ucfirst( $name ) );
        if ( !is_callable( $function ) ) {
            return null;
        } else {
            $this->$name = call_user_func( $function );
 
            return $this->$name;
        }
    }
 
    static function normalizeExtension( $ext ) {
        $lower = strtolower( $ext );
        $squish = array(
            'htm' => 'html',
            'jpeg' => 'jpg',
            'mpeg' => 'mpg',
            'tiff' => 'tif',
            'ogv' => 'ogg' );
        if ( isset( $squish[$lower] ) ) {
            return $squish[$lower];
        } elseif ( preg_match( '/^[0-9a-z]+$/', $lower ) ) {
            return $lower;
        } else {
            return '';
        }
    }
 
    static function checkExtensionCompatibility( File $old, $new ) {
        $oldMime = $old->getMimeType();
        $n = strrpos( $new, '.' );
        $newExt = self::normalizeExtension( $n ? substr( $new, $n + 1 ) : '' );
        $mimeMagic = MimeMagic::singleton();
 
        return $mimeMagic->isMatchingExtension( $newExt, $oldMime );
    }
 
    function upgradeRow() {
    }
 
    public static function splitMime( $mime ) {
        if ( strpos( $mime, '/' ) !== false ) {
            return explode( '/', $mime, 2 );
        } else {
            return array( $mime, 'unknown' );
        }
    }
 
    public static function compare( File $a, File $b ) {
        return strcmp( $a->getName(), $b->getName() );
    }
 
    public function getName() {
        if ( !isset( $this->name ) ) {
            $this->assertRepoDefined();
            $this->name = $this->repo->getNameFromTitle( $this->title );
        }
 
        return $this->name;
    }
 
    function getExtension() {
        if ( !isset( $this->extension ) ) {
            $n = strrpos( $this->getName(), '.' );
            $this->extension = self::normalizeExtension(
                $n ? substr( $this->getName(), $n + 1 ) : '' );
        }
 
        return $this->extension;
    }
 
    public function getTitle() {
        return $this->title;
    }
 
    public function getOriginalTitle() {
        if ( $this->redirected ) {
            return $this->getRedirectedTitle();
        }
 
        return $this->title;
    }
 
    public function getUrl() {
        if ( !isset( $this->url ) ) {
            $this->assertRepoDefined();
            $ext = $this->getExtension();
            $this->url = $this->repo->getZoneUrl( 'public', $ext ) . '/' . $this->getUrlRel();
        }
 
        return $this->url;
    }
 
    public function getFullUrl() {
        return wfExpandUrl( $this->getUrl(), PROTO_RELATIVE );
    }
 
    public function getCanonicalUrl() {
        return wfExpandUrl( $this->getUrl(), PROTO_CANONICAL );
    }
 
    function getViewURL() {
        if ( $this->mustRender() ) {
            if ( $this->canRender() ) {
                return $this->createThumb( $this->getWidth() );
            } else {
                wfDebug( __METHOD__ . ': supposed to render ' . $this->getName() .
                    ' (' . $this->getMimeType() . "), but can't!\n" );
 
                return $this->getURL(); #hm... return NULL?
            }
        } else {
            return $this->getURL();
        }
    }
 
    public function getPath() {
        if ( !isset( $this->path ) ) {
            $this->assertRepoDefined();
            $this->path = $this->repo->getZonePath( 'public' ) . '/' . $this->getRel();
        }
 
        return $this->path;
    }
 
    public function getLocalRefPath() {
        $this->assertRepoDefined();
        if ( !isset( $this->fsFile ) ) {
            $this->fsFile = $this->repo->getLocalReference( $this->getPath() );
            if ( !$this->fsFile ) {
                $this->fsFile = false; // null => false; cache negative hits
            }
        }
 
        return ( $this->fsFile )
            ? $this->fsFile->getPath()
            : false;
    }
 
    public function getWidth( $page = 1 ) {
        return false;
    }
 
    public function getHeight( $page = 1 ) {
        return false;
    }
 
    public function getUser( $type = 'text' ) {
        return null;
    }
 
    public function getLength() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getLength( $this );
        } else {
            return 0;
        }
    }
 
    public function isVectorized() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->isVectorized( $this );
        } else {
            return false;
        }
    }
 
    public function getAvailableLanguages() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getAvailableLanguages( $this );
        } else {
            return array();
        }
    }
 
    public function getDefaultRenderLanguage() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getDefaultRenderLanguage( $this );
        } else {
            return null;
        }
    }
 
    public function canAnimateThumbIfAppropriate() {
        $handler = $this->getHandler();
        if ( !$handler ) {
            // We cannot handle image whatsoever, thus
            // one would not expect it to be animated
            // so true.
            return true;
        } else {
            if ( $this->allowInlineDisplay()
                && $handler->isAnimatedImage( $this )
                && !$handler->canAnimateThumbnail( $this )
            ) {
                // Image is animated, but thumbnail isn't.
                // This is unexpected to the user.
                return false;
            } else {
                // Image is not animated, so one would
                // not expect thumb to be
                return true;
            }
        }
    }
 
    public function getMetadata() {
        return false;
    }
 
    public function getCommonMetaArray() {
        $handler = $this->getHandler();
 
        if ( !$handler ) {
            return false;
        }
 
        return $handler->getCommonMetaArray( $this );
    }
 
    public function convertMetadataVersion( $metadata, $version ) {
        $handler = $this->getHandler();
        if ( !is_array( $metadata ) ) {
            // Just to make the return type consistent
            $metadata = unserialize( $metadata );
        }
        if ( $handler ) {
            return $handler->convertMetadataVersion( $metadata, $version );
        } else {
            return $metadata;
        }
    }
 
    public function getBitDepth() {
        return 0;
    }
 
    public function getSize() {
        return false;
    }
 
    function getMimeType() {
        return 'unknown/unknown';
    }
 
    function getMediaType() {
        return MEDIATYPE_UNKNOWN;
    }
 
    function canRender() {
        if ( !isset( $this->canRender ) ) {
            $this->canRender = $this->getHandler() && $this->handler->canRender( $this );
        }
 
        return $this->canRender;
    }
 
    protected function getCanRender() {
        return $this->canRender();
    }
 
    function mustRender() {
        return $this->getHandler() && $this->handler->mustRender( $this );
    }
 
    function allowInlineDisplay() {
        return $this->canRender();
    }
 
    function isSafeFile() {
        if ( !isset( $this->isSafeFile ) ) {
            $this->isSafeFile = $this->getIsSafeFileUncached();
        }
 
        return $this->isSafeFile;
    }
 
    protected function getIsSafeFile() {
        return $this->isSafeFile();
    }
 
    protected function getIsSafeFileUncached() {
        global $wgTrustedMediaFormats;
 
        if ( $this->allowInlineDisplay() ) {
            return true;
        }
        if ( $this->isTrustedFile() ) {
            return true;
        }
 
        $type = $this->getMediaType();
        $mime = $this->getMimeType();
        #wfDebug( "LocalFile::isSafeFile: type= $type, mime= $mime\n" );
 
        if ( !$type || $type === MEDIATYPE_UNKNOWN ) {
            return false; #unknown type, not trusted
        }
        if ( in_array( $type, $wgTrustedMediaFormats ) ) {
            return true;
        }
 
        if ( $mime === "unknown/unknown" ) {
            return false; #unknown type, not trusted
        }
        if ( in_array( $mime, $wgTrustedMediaFormats ) ) {
            return true;
        }
 
        return false;
    }
 
    function isTrustedFile() {
        #this could be implemented to check a flag in the database,
        #look for signatures, etc
        return false;
    }
 
    public function exists() {
        return $this->getPath() && $this->repo->fileExists( $this->path );
    }
 
    public function isVisible() {
        return $this->exists();
    }
 
    function getTransformScript() {
        if ( !isset( $this->transformScript ) ) {
            $this->transformScript = false;
            if ( $this->repo ) {
                $script = $this->repo->getThumbScriptUrl();
                if ( $script ) {
                    $this->transformScript = wfAppendQuery( $script, array( 'f' => $this->getName() ) );
                }
            }
        }
 
        return $this->transformScript;
    }
 
    function getUnscaledThumb( $handlerParams = array() ) {
        $hp =& $handlerParams;
        $page = isset( $hp['page'] ) ? $hp['page'] : false;
        $width = $this->getWidth( $page );
        if ( !$width ) {
            return $this->iconThumb();
        }
        $hp['width'] = $width;
 
        return $this->transform( $hp );
    }
 
    public function thumbName( $params, $flags = 0 ) {
        $name = ( $this->repo && !( $flags & self::THUMB_FULL_NAME ) )
            ? $this->repo->nameForThumb( $this->getName() )
            : $this->getName();
 
        return $this->generateThumbName( $name, $params );
    }
 
    public function generateThumbName( $name, $params ) {
        if ( !$this->getHandler() ) {
            return null;
        }
        $extension = $this->getExtension();
        list( $thumbExt, ) = $this->handler->getThumbType(
            $extension, $this->getMimeType(), $params );
        $thumbName = $this->handler->makeParamString( $params ) . '-' . $name;
        if ( $thumbExt != $extension ) {
            $thumbName .= ".$thumbExt";
        }
 
        return $thumbName;
    }
 
    public function createThumb( $width, $height = -1 ) {
        $params = array( 'width' => $width );
        if ( $height != -1 ) {
            $params['height'] = $height;
        }
        $thumb = $this->transform( $params );
        if ( !$thumb || $thumb->isError() ) {
            return '';
        }
 
        return $thumb->getUrl();
    }
 
    protected function transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags ) {
        global $wgIgnoreImageErrors;
 
        $handler = $this->getHandler();
        if ( $handler && $wgIgnoreImageErrors && !( $flags & self::RENDER_NOW ) ) {
            return $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
        } else {
            return new MediaTransformError( 'thumbnail_error',
                $params['width'], 0, wfMessage( 'thumbnail-dest-create' )->text() );
        }
    }
 
    function transform( $params, $flags = 0 ) {
        global $wgUseSquid, $wgIgnoreImageErrors, $wgThumbnailEpoch;
 
        wfProfileIn( __METHOD__ );
        do {
            if ( !$this->canRender() ) {
                $thumb = $this->iconThumb();
                break; // not a bitmap or renderable image, don't try
            }
 
            // Get the descriptionUrl to embed it as comment into the thumbnail. Bug 19791.
            $descriptionUrl = $this->getDescriptionUrl();
            if ( $descriptionUrl ) {
                $params['descriptionUrl'] = wfExpandUrl( $descriptionUrl, PROTO_CANONICAL );
            }
 
            $handler = $this->getHandler();
            $script = $this->getTransformScript();
            if ( $script && !( $flags & self::RENDER_NOW ) ) {
                // Use a script to transform on client request, if possible
                $thumb = $handler->getScriptedTransform( $this, $script, $params );
                if ( $thumb ) {
                    break;
                }
            }
 
            $normalisedParams = $params;
            $handler->normaliseParams( $this, $normalisedParams );
 
            $thumbName = $this->thumbName( $normalisedParams );
            $thumbUrl = $this->getThumbUrl( $thumbName );
            $thumbPath = $this->getThumbPath( $thumbName ); // final thumb path
 
            if ( $this->repo ) {
                // Defer rendering if a 404 handler is set up...
                if ( $this->repo->canTransformVia404() && !( $flags & self::RENDER_NOW ) ) {
                    wfDebug( __METHOD__ . " transformation deferred.\n" );
                    // XXX: Pass in the storage path even though we are not rendering anything
                    // and the path is supposed to be an FS path. This is due to getScalerType()
                    // getting called on the path and clobbering $thumb->getUrl() if it's false.
                    $thumb = $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
                    break;
                }
                // Clean up broken thumbnails as needed
                $this->migrateThumbFile( $thumbName );
                // Check if an up-to-date thumbnail already exists...
                wfDebug( __METHOD__ . ": Doing stat for $thumbPath\n" );
                if ( !( $flags & self::RENDER_FORCE ) && $this->repo->fileExists( $thumbPath ) ) {
                    $timestamp = $this->repo->getFileTimestamp( $thumbPath );
                    if ( $timestamp !== false && $timestamp >= $wgThumbnailEpoch ) {
                        // XXX: Pass in the storage path even though we are not rendering anything
                        // and the path is supposed to be an FS path. This is due to getScalerType()
                        // getting called on the path and clobbering $thumb->getUrl() if it's false.
                        $thumb = $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
                        $thumb->setStoragePath( $thumbPath );
                        break;
                    }
                } elseif ( $flags & self::RENDER_FORCE ) {
                    wfDebug( __METHOD__ . " forcing rendering per flag File::RENDER_FORCE\n" );
                }
            }
 
            // If the backend is ready-only, don't keep generating thumbnails
            // only to return transformation errors, just return the error now.
            if ( $this->repo->getReadOnlyReason() !== false ) {
                $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags );
                break;
            }
 
            // Create a temp FS file with the same extension and the thumbnail
            $thumbExt = FileBackend::extensionFromPath( $thumbPath );
            $tmpFile = TempFSFile::factory( 'transform_', $thumbExt );
            if ( !$tmpFile ) {
                $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags );
                break;
            }
            $tmpThumbPath = $tmpFile->getPath(); // path of 0-byte temp file
 
            // Actually render the thumbnail...
            wfProfileIn( __METHOD__ . '-doTransform' );
            $thumb = $handler->doTransform( $this, $tmpThumbPath, $thumbUrl, $params );
            wfProfileOut( __METHOD__ . '-doTransform' );
            $tmpFile->bind( $thumb ); // keep alive with $thumb
 
            if ( !$thumb ) { // bad params?
                $thumb = null;
            } elseif ( $thumb->isError() ) { // transform error
                $this->lastError = $thumb->toText();
                // Ignore errors if requested
                if ( $wgIgnoreImageErrors && !( $flags & self::RENDER_NOW ) ) {
                    $thumb = $handler->getTransform( $this, $tmpThumbPath, $thumbUrl, $params );
                }
            } elseif ( $this->repo && $thumb->hasFile() && !$thumb->fileIsSource() ) {
                // Copy the thumbnail from the file system into storage...
                $disposition = $this->getThumbDisposition( $thumbName );
                $status = $this->repo->quickImport( $tmpThumbPath, $thumbPath, $disposition );
                if ( $status->isOK() ) {
                    $thumb->setStoragePath( $thumbPath );
                } else {
                    $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags );
                }
                // Give extensions a chance to do something with this thumbnail...
                wfRunHooks( 'FileTransformed', array( $this, $thumb, $tmpThumbPath, $thumbPath ) );
            }
 
            // Purge. Useful in the event of Core -> Squid connection failure or squid
            // purge collisions from elsewhere during failure. Don't keep triggering for
            // "thumbs" which have the main image URL though (bug 13776)
            if ( $wgUseSquid ) {
                if ( !$thumb || $thumb->isError() || $thumb->getUrl() != $this->getURL() ) {
                    SquidUpdate::purge( array( $thumbUrl ) );
                }
            }
        } while ( false );
 
        wfProfileOut( __METHOD__ );
 
        return is_object( $thumb ) ? $thumb : false;
    }
 
    function getThumbDisposition( $thumbName, $dispositionType = 'inline' ) {
        $fileName = $this->name; // file name to suggest
        $thumbExt = FileBackend::extensionFromPath( $thumbName );
        if ( $thumbExt != '' && $thumbExt !== $this->getExtension() ) {
            $fileName .= ".$thumbExt";
        }
 
        return FileBackend::makeContentDisposition( $dispositionType, $fileName );
    }
 
    function migrateThumbFile( $thumbName ) {
    }
 
    function getHandler() {
        if ( !isset( $this->handler ) ) {
            $this->handler = MediaHandler::getHandler( $this->getMimeType() );
        }
 
        return $this->handler;
    }
 
    function iconThumb() {
        global $wgStylePath, $wgStyleDirectory;
 
        $try = array( 'fileicon-' . $this->getExtension() . '.png', 'fileicon.png' );
        foreach ( $try as $icon ) {
            $path = '/common/images/icons/' . $icon;
            $filepath = $wgStyleDirectory . $path;
            if ( file_exists( $filepath ) ) { // always FS
                $params = array( 'width' => 120, 'height' => 120 );
 
                return new ThumbnailImage( $this, $wgStylePath . $path, false, $params );
            }
        }
 
        return null;
    }
 
    function getLastError() {
        return $this->lastError;
    }
 
    function getThumbnails() {
        return array();
    }
 
    function purgeCache( $options = array() ) {
    }
 
    function purgeDescription() {
        $title = $this->getTitle();
        if ( $title ) {
            $title->invalidateCache();
            $title->purgeSquid();
        }
    }
 
    function purgeEverything() {
        // Delete thumbnails and refresh file metadata cache
        $this->purgeCache();
        $this->purgeDescription();
 
        // Purge cache of all pages using this file
        $title = $this->getTitle();
        if ( $title ) {
            $update = new HTMLCacheUpdate( $title, 'imagelinks' );
            $update->doUpdate();
        }
    }
 
    function getHistory( $limit = null, $start = null, $end = null, $inc = true ) {
        return array();
    }
 
    public function nextHistoryLine() {
        return false;
    }
 
    public function resetHistory() {
    }
 
    function getHashPath() {
        if ( !isset( $this->hashPath ) ) {
            $this->assertRepoDefined();
            $this->hashPath = $this->repo->getHashPath( $this->getName() );
        }
 
        return $this->hashPath;
    }
 
    function getRel() {
        return $this->getHashPath() . $this->getName();
    }
 
    function getArchiveRel( $suffix = false ) {
        $path = 'archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= $suffix;
        }
 
        return $path;
    }
 
    function getThumbRel( $suffix = false ) {
        $path = $this->getRel();
        if ( $suffix !== false ) {
            $path .= '/' . $suffix;
        }
 
        return $path;
    }
 
    function getUrlRel() {
        return $this->getHashPath() . rawurlencode( $this->getName() );
    }
 
    function getArchiveThumbRel( $archiveName, $suffix = false ) {
        $path = 'archive/' . $this->getHashPath() . $archiveName . "/";
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= $suffix;
        }
 
        return $path;
    }
 
    function getArchivePath( $suffix = false ) {
        $this->assertRepoDefined();
 
        return $this->repo->getZonePath( 'public' ) . '/' . $this->getArchiveRel( $suffix );
    }
 
    function getArchiveThumbPath( $archiveName, $suffix = false ) {
        $this->assertRepoDefined();
 
        return $this->repo->getZonePath( 'thumb' ) . '/' .
        $this->getArchiveThumbRel( $archiveName, $suffix );
    }
 
    function getThumbPath( $suffix = false ) {
        $this->assertRepoDefined();
 
        return $this->repo->getZonePath( 'thumb' ) . '/' . $this->getThumbRel( $suffix );
    }
 
    function getTranscodedPath( $suffix = false ) {
        $this->assertRepoDefined();
 
        return $this->repo->getZonePath( 'transcoded' ) . '/' . $this->getThumbRel( $suffix );
    }
 
    function getArchiveUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( 'public', $ext ) . '/archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    function getArchiveThumbUrl( $archiveName, $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( 'thumb', $ext ) . '/archive/' .
            $this->getHashPath() . rawurlencode( $archiveName ) . "/";
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    function getZoneUrl( $zone, $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( $zone, $ext ) . '/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    function getThumbUrl( $suffix = false ) {
        return $this->getZoneUrl( 'thumb', $suffix );
    }
 
    function getTranscodedUrl( $suffix = false ) {
        return $this->getZoneUrl( 'transcoded', $suffix );
    }
 
    function getVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/public/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    function getArchiveVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/public/archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    function getThumbVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/thumb/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    function isHashed() {
        $this->assertRepoDefined();
 
        return (bool)$this->repo->getHashLevels();
    }
 
    function readOnlyError() {
        throw new MWException( get_class( $this ) . ': write operations are not supported' );
    }
 
    function recordUpload( $oldver, $desc, $license = '', $copyStatus = '', $source = '',
        $watch = false, $timestamp = false, User $user = null
    ) {
        $this->readOnlyError();
    }
 
    function publish( $srcPath, $flags = 0, array $options = array() ) {
        $this->readOnlyError();
    }
 
    function formatMetadata() {
        if ( !$this->getHandler() ) {
            return false;
        }
 
        return $this->getHandler()->formatMetadata( $this, $this->getMetadata() );
    }
 
    function isLocal() {
        return $this->repo && $this->repo->isLocal();
    }
 
    function getRepoName() {
        return $this->repo ? $this->repo->getName() : 'unknown';
    }
 
    function getRepo() {
        return $this->repo;
    }
 
    function isOld() {
        return false;
    }
 
    function isDeleted( $field ) {
        return false;
    }
 
    function getVisibility() {
        return 0;
    }
 
    function wasDeleted() {
        $title = $this->getTitle();
 
        return $title && $title->isDeletedQuick();
    }
 
    function move( $target ) {
        $this->readOnlyError();
    }
 
    function delete( $reason, $suppress = false ) {
        $this->readOnlyError();
    }
 
    function restore( $versions = array(), $unsuppress = false ) {
        $this->readOnlyError();
    }
 
    function isMultipage() {
        return $this->getHandler() && $this->handler->isMultiPage( $this );
    }
 
    function pageCount() {
        if ( !isset( $this->pageCount ) ) {
            if ( $this->getHandler() && $this->handler->isMultiPage( $this ) ) {
                $this->pageCount = $this->handler->pageCount( $this );
            } else {
                $this->pageCount = false;
            }
        }
 
        return $this->pageCount;
    }
 
    static function scaleHeight( $srcWidth, $srcHeight, $dstWidth ) {
        // Exact integer multiply followed by division
        if ( $srcWidth == 0 ) {
            return 0;
        } else {
            return round( $srcHeight * $dstWidth / $srcWidth );
        }
    }
 
    function getImageSize( $fileName ) {
        if ( !$this->getHandler() ) {
            return false;
        }
 
        return $this->handler->getImageSize( $this, $fileName );
    }
 
    function getDescriptionUrl() {
        if ( $this->repo ) {
            return $this->repo->getDescriptionUrl( $this->getName() );
        } else {
            return false;
        }
    }
 
    function getDescriptionText( $lang = false ) {
        global $wgMemc, $wgLang;
        if ( !$this->repo || !$this->repo->fetchDescription ) {
            return false;
        }
        if ( !$lang ) {
            $lang = $wgLang;
        }
        $renderUrl = $this->repo->getDescriptionRenderUrl( $this->getName(), $lang->getCode() );
        if ( $renderUrl ) {
            if ( $this->repo->descriptionCacheExpiry > 0 ) {
                wfDebug( "Attempting to get the description from cache..." );
                $key = $this->repo->getLocalCacheKey(
                    'RemoteFileDescription',
                    'url',
                    $lang->getCode(),
                    $this->getName()
                );
                $obj = $wgMemc->get( $key );
                if ( $obj ) {
                    wfDebug( "success!\n" );
 
                    return $obj;
                }
                wfDebug( "miss\n" );
            }
            wfDebug( "Fetching shared description from $renderUrl\n" );
            $res = Http::get( $renderUrl );
            if ( $res && $this->repo->descriptionCacheExpiry > 0 ) {
                $wgMemc->set( $key, $res, $this->repo->descriptionCacheExpiry );
            }
 
            return $res;
        } else {
            return false;
        }
    }
 
    function getDescription( $audience = self::FOR_PUBLIC, User $user = null ) {
        return null;
    }
 
    function getTimestamp() {
        $this->assertRepoDefined();
 
        return $this->repo->getFileTimestamp( $this->getPath() );
    }
 
    function getSha1() {
        $this->assertRepoDefined();
 
        return $this->repo->getFileSha1( $this->getPath() );
    }
 
    function getStorageKey() {
        $hash = $this->getSha1();
        if ( !$hash ) {
            return false;
        }
        $ext = $this->getExtension();
        $dotExt = $ext === '' ? '' : ".$ext";
 
        return $hash . $dotExt;
    }
 
    function userCan( $field, User $user = null ) {
        return true;
    }
 
    static function getPropsFromPath( $path, $ext = true ) {
        wfDebug( __METHOD__ . ": Getting file info for $path\n" );
        wfDeprecated( __METHOD__, '1.19' );
 
        $fsFile = new FSFile( $path );
 
        return $fsFile->getProps();
    }
 
    static function sha1Base36( $path ) {
        wfDeprecated( __METHOD__, '1.19' );
 
        $fsFile = new FSFile( $path );
 
        return $fsFile->getSha1Base36();
    }
 
    function getStreamHeaders() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getStreamHeaders( $this->getMetadata() );
        } else {
            return array();
        }
    }
 
    function getLongDesc() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getLongDesc( $this );
        } else {
            return MediaHandler::getGeneralLongDesc( $this );
        }
    }
 
    function getShortDesc() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getShortDesc( $this );
        } else {
            return MediaHandler::getGeneralShortDesc( $this );
        }
    }
 
    function getDimensionsString() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getDimensionsString( $this );
        } else {
            return '';
        }
    }
 
    function getRedirected() {
        return $this->redirected;
    }
 
    function getRedirectedTitle() {
        if ( $this->redirected ) {
            if ( !$this->redirectTitle ) {
                $this->redirectTitle = Title::makeTitle( NS_FILE, $this->redirected );
            }
 
            return $this->redirectTitle;
        }
 
        return null;
    }
 
    function redirectedFrom( $from ) {
        $this->redirected = $from;
    }
 
    function isMissing() {
        return false;
    }
 
    public function isCacheable() {
        return true;
    }
 
    protected function assertRepoDefined() {
        if ( !( $this->repo instanceof $this->repoClass ) ) {
            throw new MWException( "A {$this->repoClass} object is not set for this File.\n" );
        }
    }
 
    protected function assertTitleDefined() {
        if ( !( $this->title instanceof Title ) ) {
            throw new MWException( "A Title object is not set for this File.\n" );
        }
    }
}