File.php

Go to the documentation of this file.

<?php
abstract class File {
        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;

        var $repo;

        var $title;

        var $lastError, $redirected, $redirectedTitle;

        protected $fsFile;

        protected $handler;

        protected $url, $extension, $name, $path, $hashPath, $pageCount, $transformScript;

        protected $redirectTitle;

        protected $canRender, $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();
                        $this->url = $this->repo->getZoneUrl( 'public' ) . '/' . $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 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 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->_getIsSafeFile();
                }
                return $this->isSafeFile;
        }

        protected function getIsSafeFile() {
                return $this->isSafeFile();
        }

        protected function _getIsSafeFile() {
                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 = "$script?f=" . urlencode( $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, $thumbMime ) = $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 ( is_null( $thumb ) || $thumb->isError() ) {
                        return '';
                }
                return $thumb->getUrl();
        }

        protected function transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags ) {
                global $wgIgnoreImageErrors;

                if ( $wgIgnoreImageErrors && !( $flags & self::RENDER_NOW ) ) {
                        return $this->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 );
                        }

                        $script = $this->getTransformScript();
                        if ( $script && !( $flags & self::RENDER_NOW ) ) {
                                // Use a script to transform on client request, if possible
                                $thumb = $this->handler->getScriptedTransform( $this, $script, $params );
                                if ( $thumb ) {
                                        break;
                                }
                        }

                        $normalisedParams = $params;
                        $this->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." );
                                        // 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 = $this->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 ( $this->repo->fileExists( $thumbPath ) && !( $flags & self::RENDER_FORCE ) ) {
                                        $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 = $this->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 = $this->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 = $this->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 ) {
                $fileName = $this->name; // file name to suggest
                $thumbExt = FileBackend::extensionFromPath( $thumbName );
                if ( $thumbExt != '' && $thumbExt !== $this->getExtension() ) {
                        $fileName .= ".$thumbExt";
                }
                return FileBackend::makeContentDisposition( 'inline', $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 getArchiveUrl( $suffix = false ) {
                $this->assertRepoDefined();
                $path = $this->repo->getZoneUrl( 'public' ) . '/archive/' . $this->getHashPath();
                if ( $suffix === false ) {
                        $path = substr( $path, 0, -1 );
                } else {
                        $path .= rawurlencode( $suffix );
                }
                return $path;
        }

        function getArchiveThumbUrl( $archiveName, $suffix = false ) {
                $this->assertRepoDefined();
                $path = $this->repo->getZoneUrl( 'thumb' ) . '/archive/' .
                        $this->getHashPath() . rawurlencode( $archiveName ) . "/";
                if ( $suffix === false ) {
                        $path = substr( $path, 0, -1 );
                } else {
                        $path .= rawurlencode( $suffix );
                }
                return $path;
        }

        function getThumbUrl( $suffix = false ) {
                $this->assertRepoDefined();
                $path = $this->repo->getZoneUrl( 'thumb' ) . '/' . $this->getUrlRel();
                if ( $suffix !== false ) {
                        $path .= '/' . rawurlencode( $suffix );
                }
                return $path;
        }

        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 ) {
                $this->readOnlyError();
        }

        function publish( $srcPath, $flags = 0 ) {
                $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() {
                global $wgMemc, $wgLang;
                if ( !$this->repo || !$this->repo->fetchDescription ) {
                        return false;
                }
                $renderUrl = $this->repo->getDescriptionRenderUrl( $this->getName(), $wgLang->getCode() );
                if ( $renderUrl ) {
                        if ( $this->repo->descriptionCacheExpiry > 0 ) {
                                wfDebug("Attempting to get the description from cache...");
                                $key = $this->repo->getLocalCacheKey( 'RemoteFileDescription', 'url', $wgLang->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 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;
                }
        }

        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" );
                }
        }
}