diff --git a/src/applications/feed/story/PhabricatorFeedStory.php b/src/applications/feed/story/PhabricatorFeedStory.php
index 8a15301216..c3984573c7 100644
--- a/src/applications/feed/story/PhabricatorFeedStory.php
+++ b/src/applications/feed/story/PhabricatorFeedStory.php
@@ -1,483 +1,483 @@
 <?php
 
 /**
  * Manages rendering and aggregation of a story. A story is an event (like a
  * user adding a comment) which may be represented in different forms on
  * different channels (like feed, notifications and realtime alerts).
  *
  * @task load     Loading Stories
  * @task policy   Policy Implementation
  */
 abstract class PhabricatorFeedStory
   extends Phobject
   implements
     PhabricatorPolicyInterface,
     PhabricatorMarkupInterface {
 
   private $data;
   private $hasViewed;
   private $hovercard = false;
   private $renderingTarget = PhabricatorApplicationTransaction::TARGET_HTML;
 
   private $handles = array();
   private $objects = array();
   private $projectPHIDs = array();
   private $markupFieldOutput = array();
 
 /* -(  Loading Stories  )---------------------------------------------------- */
 
 
   /**
    * Given @{class:PhabricatorFeedStoryData} rows, load them into objects and
    * construct appropriate @{class:PhabricatorFeedStory} wrappers for each
    * data row.
    *
    * @param list<dict>  List of @{class:PhabricatorFeedStoryData} rows from the
    *                    database.
    * @return list<PhabricatorFeedStory>   List of @{class:PhabricatorFeedStory}
    *                                      objects.
    * @task load
    */
   public static function loadAllFromRows(array $rows, PhabricatorUser $viewer) {
     $stories = array();
 
     $data = id(new PhabricatorFeedStoryData())->loadAllFromArray($rows);
     foreach ($data as $story_data) {
       $class = $story_data->getStoryType();
 
       try {
         $ok =
           class_exists($class) &&
           is_subclass_of($class, __CLASS__);
       } catch (PhutilMissingSymbolException $ex) {
         $ok = false;
       }
 
       // If the story type isn't a valid class or isn't a subclass of
       // PhabricatorFeedStory, decline to load it.
       if (!$ok) {
         continue;
       }
 
       $key = $story_data->getChronologicalKey();
       $stories[$key] = newv($class, array($story_data));
     }
 
     $object_phids = array();
     $key_phids = array();
     foreach ($stories as $key => $story) {
       $phids = array();
       foreach ($story->getRequiredObjectPHIDs() as $phid) {
         $phids[$phid] = true;
       }
       if ($story->getPrimaryObjectPHID()) {
         $phids[$story->getPrimaryObjectPHID()] = true;
       }
       $key_phids[$key] = $phids;
       $object_phids += $phids;
     }
 
     $object_query = id(new PhabricatorObjectQuery())
       ->setViewer($viewer)
       ->withPHIDs(array_keys($object_phids));
 
     $objects = $object_query->execute();
 
     foreach ($key_phids as $key => $phids) {
       if (!$phids) {
         continue;
       }
       $story_objects = array_select_keys($objects, array_keys($phids));
       if (count($story_objects) != count($phids)) {
         // An object this story requires either does not exist or is not visible
         // to the user. Decline to render the story.
         unset($stories[$key]);
         unset($key_phids[$key]);
         continue;
       }
 
       $stories[$key]->setObjects($story_objects);
     }
 
     // If stories are about PhabricatorProjectInterface objects, load the
     // projects the objects are a part of so we can render project tags
     // on the stories.
 
     $project_phids = array();
     foreach ($objects as $object) {
       if ($object instanceof PhabricatorProjectInterface) {
         $project_phids[$object->getPHID()] = array();
       }
     }
 
     if ($project_phids) {
       $edge_query = id(new PhabricatorEdgeQuery())
         ->withSourcePHIDs(array_keys($project_phids))
         ->withEdgeTypes(
           array(
             PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
           ));
       $edge_query->execute();
       foreach ($project_phids as $phid => $ignored) {
         $project_phids[$phid] = $edge_query->getDestinationPHIDs(array($phid));
       }
     }
 
     $handle_phids = array();
     foreach ($stories as $key => $story) {
       foreach ($story->getRequiredHandlePHIDs() as $phid) {
         $key_phids[$key][$phid] = true;
       }
       if ($story->getAuthorPHID()) {
         $key_phids[$key][$story->getAuthorPHID()] = true;
       }
 
       $object_phid = $story->getPrimaryObjectPHID();
       $object_project_phids = idx($project_phids, $object_phid, array());
       $story->setProjectPHIDs($object_project_phids);
       foreach ($object_project_phids as $dst) {
         $key_phids[$key][$dst] = true;
       }
 
       $handle_phids += $key_phids[$key];
     }
 
     // NOTE: This setParentQuery() is a little sketchy. Ideally, this whole
     // method should be inside FeedQuery and it should be the parent query of
     // both subqueries. We're just trying to share the workspace cache.
 
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($viewer)
       ->setParentQuery($object_query)
       ->withPHIDs(array_keys($handle_phids))
       ->execute();
 
     foreach ($key_phids as $key => $phids) {
       if (!$phids) {
         continue;
       }
       $story_handles = array_select_keys($handles, array_keys($phids));
       $stories[$key]->setHandles($story_handles);
     }
 
     // Load and process story markup blocks.
 
     $engine = new PhabricatorMarkupEngine();
     $engine->setViewer($viewer);
     foreach ($stories as $story) {
       foreach ($story->getFieldStoryMarkupFields() as $field) {
         $engine->addObject($story, $field);
       }
     }
 
     $engine->process();
 
     foreach ($stories as $story) {
       foreach ($story->getFieldStoryMarkupFields() as $field) {
         $story->setMarkupFieldOutput(
           $field,
           $engine->getOutput($story, $field));
       }
     }
 
     return $stories;
   }
 
   public function setMarkupFieldOutput($field, $output) {
     $this->markupFieldOutput[$field] = $output;
     return $this;
   }
 
   public function getMarkupFieldOutput($field) {
     if (!array_key_exists($field, $this->markupFieldOutput)) {
       throw new Exception(
         pht(
           'Trying to retrieve markup field key "%s", but this feed story '.
           'did not request it be rendered.',
           $field));
     }
 
     return $this->markupFieldOutput[$field];
   }
 
   public function setHovercard($hover) {
     $this->hovercard = $hover;
     return $this;
   }
 
   public function setRenderingTarget($target) {
     $this->validateRenderingTarget($target);
     $this->renderingTarget = $target;
     return $this;
   }
 
   public function getRenderingTarget() {
     return $this->renderingTarget;
   }
 
   private function validateRenderingTarget($target) {
     switch ($target) {
       case PhabricatorApplicationTransaction::TARGET_HTML:
       case PhabricatorApplicationTransaction::TARGET_TEXT:
         break;
       default:
         throw new Exception(pht('Unknown rendering target: %s', $target));
         break;
     }
   }
 
   public function setObjects(array $objects) {
     $this->objects = $objects;
     return $this;
   }
 
   public function getObject($phid) {
     $object = idx($this->objects, $phid);
     if (!$object) {
       throw new Exception(
         pht(
           "Story is asking for an object it did not request ('%s')!",
           $phid));
     }
     return $object;
   }
 
   public function getPrimaryObject() {
     $phid = $this->getPrimaryObjectPHID();
     if (!$phid) {
       throw new Exception(pht('Story has no primary object!'));
     }
     return $this->getObject($phid);
   }
 
   public function getPrimaryObjectPHID() {
     return null;
   }
 
   final public function __construct(PhabricatorFeedStoryData $data) {
     $this->data = $data;
   }
 
   abstract public function renderView();
   public function renderAsTextForDoorkeeper(
     DoorkeeperFeedStoryPublisher $publisher) {
 
     // TODO: This (and text rendering) should be properly abstract and
     // universal. However, this is far less bad than it used to be, and we
     // need to clean up more old feed code to really make this reasonable.
 
     return pht(
       '(Unable to render story of class %s for Doorkeeper.)',
       get_class($this));
   }
 
   public function getRequiredHandlePHIDs() {
     return array();
   }
 
   public function getRequiredObjectPHIDs() {
     return array();
   }
 
   public function setHasViewed($has_viewed) {
     $this->hasViewed = $has_viewed;
     return $this;
   }
 
   public function getHasViewed() {
     return $this->hasViewed;
   }
 
   final public function setHandles(array $handles) {
     assert_instances_of($handles, 'PhabricatorObjectHandle');
     $this->handles = $handles;
     return $this;
   }
 
   final protected function getObjects() {
     return $this->objects;
   }
 
   final protected function getHandles() {
     return $this->handles;
   }
 
   final protected function getHandle($phid) {
     if (isset($this->handles[$phid])) {
       if ($this->handles[$phid] instanceof PhabricatorObjectHandle) {
         return $this->handles[$phid];
       }
     }
 
     $handle = new PhabricatorObjectHandle();
     $handle->setPHID($phid);
     $handle->setName(pht("Unloaded Object '%s'", $phid));
 
     return $handle;
   }
 
   final public function getStoryData() {
     return $this->data;
   }
 
   final public function getEpoch() {
     return $this->getStoryData()->getEpoch();
   }
 
   final public function getChronologicalKey() {
     return $this->getStoryData()->getChronologicalKey();
   }
 
   final public function getValue($key, $default = null) {
     return $this->getStoryData()->getValue($key, $default);
   }
 
   final public function getAuthorPHID() {
     return $this->getStoryData()->getAuthorPHID();
   }
 
   final protected function renderHandleList(array $phids) {
     $items = array();
     foreach ($phids as $phid) {
       $items[] = $this->linkTo($phid);
     }
     $list = null;
     switch ($this->getRenderingTarget()) {
       case PhabricatorApplicationTransaction::TARGET_TEXT:
         $list = implode(', ', $items);
         break;
       case PhabricatorApplicationTransaction::TARGET_HTML:
         $list = phutil_implode_html(', ', $items);
         break;
     }
     return $list;
   }
 
   final protected function linkTo($phid) {
     $handle = $this->getHandle($phid);
 
     switch ($this->getRenderingTarget()) {
       case PhabricatorApplicationTransaction::TARGET_TEXT:
         return $handle->getLinkName();
     }
 
     return $handle->renderLink();
   }
 
   final protected function renderString($str) {
     switch ($this->getRenderingTarget()) {
       case PhabricatorApplicationTransaction::TARGET_TEXT:
         return $str;
       case PhabricatorApplicationTransaction::TARGET_HTML:
         return phutil_tag('strong', array(), $str);
     }
   }
 
   final public function renderSummary($text, $len = 128) {
     if ($len) {
       $text = id(new PhutilUTF8StringTruncator())
         ->setMaximumGlyphs($len)
         ->truncateString($text);
     }
     switch ($this->getRenderingTarget()) {
       case PhabricatorApplicationTransaction::TARGET_HTML:
         $text = phutil_escape_html_newlines($text);
         break;
     }
     return $text;
   }
 
   public function getNotificationAggregations() {
     return array();
   }
 
   protected function newStoryView() {
     $view = id(new PHUIFeedStoryView())
       ->setChronologicalKey($this->getChronologicalKey())
       ->setEpoch($this->getEpoch())
       ->setViewed($this->getHasViewed());
 
     $project_phids = $this->getProjectPHIDs();
     if ($project_phids) {
       $view->setTags($this->renderHandleList($project_phids));
     }
 
     return $view;
   }
 
   public function setProjectPHIDs(array $phids) {
     $this->projectPHIDs = $phids;
     return $this;
   }
 
   public function getProjectPHIDs() {
     return $this->projectPHIDs;
   }
 
   public function getFieldStoryMarkupFields() {
     return array();
   }
 
 
 /* -(  PhabricatorPolicyInterface Implementation  )-------------------------- */
 
   public function getPHID() {
     return null;
   }
 
   /**
    * @task policy
    */
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
 
   /**
    * @task policy
    */
   public function getPolicy($capability) {
     // NOTE: We enforce that a user can see all the objects a story is about
     // when loading it, so we don't need to perform a equivalent secondary
     // policy check later.
     return PhabricatorPolicies::getMostOpenPolicy();
   }
 
 
   /**
    * @task policy
    */
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
 
 /* -(  PhabricatorMarkupInterface Implementation )--------------------------- */
 
 
   public function getMarkupFieldKey($field) {
     return 'feed:'.$this->getChronologicalKey().':'.$field;
   }
 
   public function newMarkupEngine($field) {
-    return PhabricatorMarkupEngine::getEngine();
+    return PhabricatorMarkupEngine::getEngine('feed');
   }
 
   public function getMarkupText($field) {
     throw new PhutilMethodNotImplementedException();
   }
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
   public function shouldUseMarkupCache($field) {
     return true;
   }
 
 }
diff --git a/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php b/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
index 0fb2243d89..e054c2acd9 100644
--- a/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
+++ b/src/applications/files/markup/PhabricatorEmbedFileRemarkupRule.php
@@ -1,297 +1,303 @@
 <?php
 
 final class PhabricatorEmbedFileRemarkupRule
   extends PhabricatorObjectRemarkupRule {
 
   const KEY_EMBED_FILE_PHIDS = 'phabricator.embedded-file-phids';
 
   protected function getObjectNamePrefix() {
     return 'F';
   }
 
   protected function loadObjects(array $ids) {
     $engine = $this->getEngine();
 
     $viewer = $engine->getConfig('viewer');
     $objects = id(new PhabricatorFileQuery())
       ->setViewer($viewer)
       ->withIDs($ids)
       ->needTransforms(
         array(
           PhabricatorFileThumbnailTransform::TRANSFORM_PREVIEW,
         ))
       ->execute();
 
     $phids_key = self::KEY_EMBED_FILE_PHIDS;
     $phids = $engine->getTextMetadata($phids_key, array());
     foreach (mpull($objects, 'getPHID') as $phid) {
       $phids[] = $phid;
     }
     $engine->setTextMetadata($phids_key, $phids);
 
     return $objects;
   }
 
   protected function renderObjectEmbed(
     $object,
     PhabricatorObjectHandle $handle,
     $options) {
 
     $options = $this->getFileOptions($options) + array(
       'name' => $object->getName(),
     );
 
     $is_viewable_image = $object->isViewableImage();
     $is_audio = $object->isAudio();
     $is_video = $object->isVideo();
     $force_link = ($options['layout'] == 'link');
 
     // If a file is both audio and video, as with "application/ogg" by default,
     // render it as video but allow the user to specify `media=audio` if they
     // want to force it to render as audio.
     if ($is_audio && $is_video) {
       $media = $options['media'];
       if ($media == 'audio') {
         $is_video = false;
       } else {
         $is_audio = false;
       }
     }
 
     $options['viewable'] = ($is_viewable_image || $is_audio || $is_video);
 
     if ($is_viewable_image && !$force_link) {
       return $this->renderImageFile($object, $handle, $options);
     } else if ($is_video && !$force_link) {
       return $this->renderVideoFile($object, $handle, $options);
     } else if ($is_audio && !$force_link) {
       return $this->renderAudioFile($object, $handle, $options);
     } else {
       return $this->renderFileLink($object, $handle, $options);
     }
   }
 
   private function getFileOptions($option_string) {
     $options = array(
       'size' => null,
       'layout' => 'left',
       'float' => false,
       'width' => null,
       'height' => null,
       'alt' => null,
       'media' => null,
       'autoplay' => null,
       'loop' => null,
     );
 
     if ($option_string) {
       $option_string = trim($option_string, ', ');
       $parser = new PhutilSimpleOptions();
       $options = $parser->parse($option_string) + $options;
     }
 
     return $options;
   }
 
   private function renderImageFile(
     PhabricatorFile $file,
     PhabricatorObjectHandle $handle,
     array $options) {
 
     require_celerity_resource('phui-lightbox-css');
 
     $attrs = array();
     $image_class = 'phabricator-remarkup-embed-image';
 
     $use_size = true;
     if (!$options['size']) {
       $width = $this->parseDimension($options['width']);
       $height = $this->parseDimension($options['height']);
       if ($width || $height) {
         $use_size = false;
         $attrs += array(
           'src' => $file->getBestURI(),
           'width' => $width,
           'height' => $height,
         );
       }
     }
 
     if ($use_size) {
       switch ((string)$options['size']) {
         case 'full':
           $attrs += array(
             'src' => $file->getBestURI(),
             'height' => $file->getImageHeight(),
             'width' => $file->getImageWidth(),
           );
           $image_class = 'phabricator-remarkup-embed-image-full';
           break;
         // Displays "full" in normal Remarkup, "wide" in Documents
         case 'wide':
           $attrs += array(
             'src' => $file->getBestURI(),
             'width' => $file->getImageWidth(),
           );
           $image_class = 'phabricator-remarkup-embed-image-wide';
           break;
         case 'thumb':
         default:
           $preview_key = PhabricatorFileThumbnailTransform::TRANSFORM_PREVIEW;
           $xform = PhabricatorFileTransform::getTransformByKey($preview_key);
 
           $existing_xform = $file->getTransform($preview_key);
           if ($existing_xform) {
             $xform_uri = $existing_xform->getCDNURI();
           } else {
             $xform_uri = $file->getURIForTransform($xform);
           }
 
           $attrs['src'] = $xform_uri;
 
           $dimensions = $xform->getTransformedDimensions($file);
           if ($dimensions) {
             list($x, $y) = $dimensions;
             $attrs['width'] = $x;
             $attrs['height'] = $y;
           }
           break;
       }
     }
 
     if (isset($options['alt'])) {
       $attrs['alt'] = $options['alt'];
     }
 
     $img = phutil_tag('img', $attrs);
 
     $embed = javelin_tag(
       'a',
       array(
         'href'        => $file->getBestURI(),
         'class'       => $image_class,
         'sigil'       => 'lightboxable',
         'meta'        => array(
           'phid'     => $file->getPHID(),
           'uri'      => $file->getBestURI(),
           'dUri'     => $file->getDownloadURI(),
           'viewable' => true,
           'monogram' => $file->getMonogram(),
         ),
       ),
       $img);
 
     switch ($options['layout']) {
       case 'right':
       case 'center':
       case 'inline':
       case 'left':
         $layout_class = 'phabricator-remarkup-embed-layout-'.$options['layout'];
         break;
       default:
         $layout_class = 'phabricator-remarkup-embed-layout-left';
         break;
     }
 
     if ($options['float']) {
       switch ($options['layout']) {
         case 'center':
         case 'inline':
           break;
         case 'right':
           $layout_class .= ' phabricator-remarkup-embed-float-right';
           break;
         case 'left':
         default:
           $layout_class .= ' phabricator-remarkup-embed-float-left';
           break;
       }
     }
 
     return phutil_tag(
       ($options['layout'] == 'inline' ? 'span' : 'div'),
       array(
         'class' => $layout_class,
       ),
       $embed);
   }
 
   private function renderAudioFile(
     PhabricatorFile $file,
     PhabricatorObjectHandle $handle,
     array $options) {
     return $this->renderMediaFile('audio', $file, $handle, $options);
   }
 
   private function renderVideoFile(
     PhabricatorFile $file,
     PhabricatorObjectHandle $handle,
     array $options) {
     return $this->renderMediaFile('video', $file, $handle, $options);
   }
 
   private function renderMediaFile(
     $tag,
     PhabricatorFile $file,
     PhabricatorObjectHandle $handle,
     array $options) {
 
     $is_video = ($tag == 'video');
 
     if (idx($options, 'autoplay')) {
       $preload = 'auto';
       $autoplay = 'autoplay';
     } else {
       // If we don't preload video, the user can't see the first frame and
       // has no clue what they're looking at, so always preload.
       if ($is_video) {
         $preload = 'auto';
       } else {
         $preload = 'none';
       }
       $autoplay = null;
     }
 
+    // Rendering contexts like feed can disable autoplay.
+    $engine = $this->getEngine();
+    if ($engine->getConfig('autoplay.disable')) {
+      $autoplay = null;
+    }
+
     return $this->newTag(
       $tag,
       array(
         'controls' => 'controls',
         'preload' => $preload,
         'autoplay' => $autoplay,
         'loop' => idx($options, 'loop') ? 'loop' : null,
         'alt' => $options['alt'],
         'class' => 'phabricator-media',
       ),
       $this->newTag(
         'source',
         array(
           'src' => $file->getBestURI(),
           'type' => $file->getMimeType(),
         )));
   }
 
   private function renderFileLink(
     PhabricatorFile $file,
     PhabricatorObjectHandle $handle,
     array $options) {
 
     return id(new PhabricatorFileLinkView())
       ->setFilePHID($file->getPHID())
       ->setFileName($this->assertFlatText($options['name']))
       ->setFileDownloadURI($file->getDownloadURI())
       ->setFileViewURI($file->getBestURI())
       ->setFileViewable((bool)$options['viewable'])
       ->setFileMonogram($file->getMonogram());
   }
 
   private function parseDimension($string) {
     $string = trim($string);
 
     if (preg_match('/^(?:\d*\\.)?\d+%?$/', $string)) {
       return $string;
     }
 
     return null;
   }
 
 }
diff --git a/src/infrastructure/markup/PhabricatorMarkupEngine.php b/src/infrastructure/markup/PhabricatorMarkupEngine.php
index 6f13525c76..3ce5578f82 100644
--- a/src/infrastructure/markup/PhabricatorMarkupEngine.php
+++ b/src/infrastructure/markup/PhabricatorMarkupEngine.php
@@ -1,693 +1,697 @@
 <?php
 
 /**
  * Manages markup engine selection, configuration, application, caching and
  * pipelining.
  *
  * @{class:PhabricatorMarkupEngine} can be used to render objects which
  * implement @{interface:PhabricatorMarkupInterface} in a batched, cache-aware
  * way. For example, if you have a list of comments written in remarkup (and
  * the objects implement the correct interface) you can render them by first
  * building an engine and adding the fields with @{method:addObject}.
  *
  *   $field  = 'field:body'; // Field you want to render. Each object exposes
  *                           // one or more fields of markup.
  *
  *   $engine = new PhabricatorMarkupEngine();
  *   foreach ($comments as $comment) {
  *     $engine->addObject($comment, $field);
  *   }
  *
  * Now, call @{method:process} to perform the actual cache/rendering
  * step. This is a heavyweight call which does batched data access and
  * transforms the markup into output.
  *
  *   $engine->process();
  *
  * Finally, do something with the results:
  *
  *   $results = array();
  *   foreach ($comments as $comment) {
  *     $results[] = $engine->getOutput($comment, $field);
  *   }
  *
  * If you have a single object to render, you can use the convenience method
  * @{method:renderOneObject}.
  *
  * @task markup Markup Pipeline
  * @task engine Engine Construction
  */
 final class PhabricatorMarkupEngine extends Phobject {
 
   private $objects = array();
   private $viewer;
   private $contextObject;
   private $version = 16;
   private $engineCaches = array();
   private $auxiliaryConfig = array();
 
 
 /* -(  Markup Pipeline  )---------------------------------------------------- */
 
 
   /**
    * Convenience method for pushing a single object through the markup
    * pipeline.
    *
    * @param PhabricatorMarkupInterface  The object to render.
    * @param string                      The field to render.
    * @param PhabricatorUser             User viewing the markup.
    * @param object                      A context object for policy checks
    * @return string                     Marked up output.
    * @task markup
    */
   public static function renderOneObject(
     PhabricatorMarkupInterface $object,
     $field,
     PhabricatorUser $viewer,
     $context_object = null) {
     return id(new PhabricatorMarkupEngine())
       ->setViewer($viewer)
       ->setContextObject($context_object)
       ->addObject($object, $field)
       ->process()
       ->getOutput($object, $field);
   }
 
 
   /**
    * Queue an object for markup generation when @{method:process} is
    * called. You can retrieve the output later with @{method:getOutput}.
    *
    * @param PhabricatorMarkupInterface  The object to render.
    * @param string                      The field to render.
    * @return this
    * @task markup
    */
   public function addObject(PhabricatorMarkupInterface $object, $field) {
     $key = $this->getMarkupFieldKey($object, $field);
     $this->objects[$key] = array(
       'object' => $object,
       'field'  => $field,
     );
 
     return $this;
   }
 
 
   /**
    * Process objects queued with @{method:addObject}. You can then retrieve
    * the output with @{method:getOutput}.
    *
    * @return this
    * @task markup
    */
   public function process() {
     $keys = array();
     foreach ($this->objects as $key => $info) {
       if (!isset($info['markup'])) {
         $keys[] = $key;
       }
     }
 
     if (!$keys) {
       return;
     }
 
     $objects = array_select_keys($this->objects, $keys);
 
     // Build all the markup engines. We need an engine for each field whether
     // we have a cache or not, since we still need to postprocess the cache.
     $engines = array();
     foreach ($objects as $key => $info) {
       $engines[$key] = $info['object']->newMarkupEngine($info['field']);
       $engines[$key]->setConfig('viewer', $this->viewer);
       $engines[$key]->setConfig('contextObject', $this->contextObject);
 
       foreach ($this->auxiliaryConfig as $aux_key => $aux_value) {
         $engines[$key]->setConfig($aux_key, $aux_value);
       }
     }
 
     // Load or build the preprocessor caches.
     $blocks = $this->loadPreprocessorCaches($engines, $objects);
     $blocks = mpull($blocks, 'getCacheData');
 
     $this->engineCaches = $blocks;
 
     // Finalize the output.
     foreach ($objects as $key => $info) {
       $engine = $engines[$key];
       $field = $info['field'];
       $object = $info['object'];
 
       $output = $engine->postprocessText($blocks[$key]);
       $output = $object->didMarkupText($field, $output, $engine);
       $this->objects[$key]['output'] = $output;
     }
 
     return $this;
   }
 
 
   /**
    * Get the output of markup processing for a field queued with
    * @{method:addObject}. Before you can call this method, you must call
    * @{method:process}.
    *
    * @param PhabricatorMarkupInterface  The object to retrieve.
    * @param string                      The field to retrieve.
    * @return string                     Processed output.
    * @task markup
    */
   public function getOutput(PhabricatorMarkupInterface $object, $field) {
     $key = $this->getMarkupFieldKey($object, $field);
     $this->requireKeyProcessed($key);
 
     return $this->objects[$key]['output'];
   }
 
 
   /**
    * Retrieve engine metadata for a given field.
    *
    * @param PhabricatorMarkupInterface  The object to retrieve.
    * @param string                      The field to retrieve.
    * @param string                      The engine metadata field to retrieve.
    * @param wild                        Optional default value.
    * @task markup
    */
   public function getEngineMetadata(
     PhabricatorMarkupInterface $object,
     $field,
     $metadata_key,
     $default = null) {
 
     $key = $this->getMarkupFieldKey($object, $field);
     $this->requireKeyProcessed($key);
 
     return idx($this->engineCaches[$key]['metadata'], $metadata_key, $default);
   }
 
 
   /**
    * @task markup
    */
   private function requireKeyProcessed($key) {
     if (empty($this->objects[$key])) {
       throw new Exception(
         pht(
           "Call %s before using results (key = '%s').",
           'addObject()',
           $key));
     }
 
     if (!isset($this->objects[$key]['output'])) {
       throw new PhutilInvalidStateException('process');
     }
   }
 
 
   /**
    * @task markup
    */
   private function getMarkupFieldKey(
     PhabricatorMarkupInterface $object,
     $field) {
 
     static $custom;
     if ($custom === null) {
       $custom = array_merge(
         self::loadCustomInlineRules(),
         self::loadCustomBlockRules());
 
       $custom = mpull($custom, 'getRuleVersion', null);
       ksort($custom);
       $custom = PhabricatorHash::digestForIndex(serialize($custom));
     }
 
     return $object->getMarkupFieldKey($field).'@'.$this->version.'@'.$custom;
   }
 
 
   /**
    * @task markup
    */
   private function loadPreprocessorCaches(array $engines, array $objects) {
     $blocks = array();
 
     $use_cache = array();
     foreach ($objects as $key => $info) {
       if ($info['object']->shouldUseMarkupCache($info['field'])) {
         $use_cache[$key] = true;
       }
     }
 
     if ($use_cache) {
       try {
         $blocks = id(new PhabricatorMarkupCache())->loadAllWhere(
           'cacheKey IN (%Ls)',
           array_keys($use_cache));
         $blocks = mpull($blocks, null, 'getCacheKey');
       } catch (Exception $ex) {
         phlog($ex);
       }
     }
 
     $is_readonly = PhabricatorEnv::isReadOnly();
 
     foreach ($objects as $key => $info) {
       // False check in case MySQL doesn't support unicode characters
       // in the string (T1191), resulting in unserialize returning false.
       if (isset($blocks[$key]) && $blocks[$key]->getCacheData() !== false) {
         // If we already have a preprocessing cache, we don't need to rebuild
         // it.
         continue;
       }
 
       $text = $info['object']->getMarkupText($info['field']);
       $data = $engines[$key]->preprocessText($text);
 
       // NOTE: This is just debugging information to help sort out cache issues.
       // If one machine is misconfigured and poisoning caches you can use this
       // field to hunt it down.
 
       $metadata = array(
         'host' => php_uname('n'),
       );
 
       $blocks[$key] = id(new PhabricatorMarkupCache())
         ->setCacheKey($key)
         ->setCacheData($data)
         ->setMetadata($metadata);
 
       if (isset($use_cache[$key]) && !$is_readonly) {
         // This is just filling a cache and always safe, even on a read pathway.
         $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
           $blocks[$key]->replace();
         unset($unguarded);
       }
     }
 
     return $blocks;
   }
 
 
   /**
    * Set the viewing user. Used to implement object permissions.
    *
    * @param PhabricatorUser The viewing user.
    * @return this
    * @task markup
    */
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   /**
    * Set the context object. Used to implement object permissions.
    *
    * @param The object in which context this remarkup is used.
    * @return this
    * @task markup
    */
   public function setContextObject($object) {
     $this->contextObject = $object;
     return $this;
   }
 
   public function setAuxiliaryConfig($key, $value) {
     // TODO: This is gross and should be removed. Avoid use.
     $this->auxiliaryConfig[$key] = $value;
     return $this;
   }
 
 
 /* -(  Engine Construction  )------------------------------------------------ */
 
 
 
   /**
    * @task engine
    */
   public static function newManiphestMarkupEngine() {
     return self::newMarkupEngine(array(
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newPhrictionMarkupEngine() {
     return self::newMarkupEngine(array(
       'header.generate-toc' => true,
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newPhameMarkupEngine() {
     return self::newMarkupEngine(
       array(
         'macros' => false,
         'uri.full' => true,
         'uri.same-window' => true,
         'uri.base' => PhabricatorEnv::getURI('/'),
       ));
   }
 
 
   /**
    * @task engine
    */
   public static function newFeedMarkupEngine() {
     return self::newMarkupEngine(
       array(
         'macros'      => false,
         'youtube'     => false,
       ));
   }
 
   /**
    * @task engine
    */
   public static function newCalendarMarkupEngine() {
     return self::newMarkupEngine(array(
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newDifferentialMarkupEngine(array $options = array()) {
     return self::newMarkupEngine(array(
       'differential.diff' => idx($options, 'differential.diff'),
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newDiffusionMarkupEngine(array $options = array()) {
     return self::newMarkupEngine(array(
       'header.generate-toc' => true,
     ));
   }
 
   /**
    * @task engine
    */
   public static function getEngine($ruleset = 'default') {
     static $engines = array();
     if (isset($engines[$ruleset])) {
       return $engines[$ruleset];
     }
 
     $engine = null;
     switch ($ruleset) {
       case 'default':
         $engine = self::newMarkupEngine(array());
         break;
+      case 'feed':
+        $engine = self::newMarkupEngine(array());
+        $engine->setConfig('autoplay.disable', true);
+        break;
       case 'nolinebreaks':
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('preserve-linebreaks', false);
         break;
       case 'diffusion-readme':
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('preserve-linebreaks', false);
         $engine->setConfig('header.generate-toc', true);
         break;
       case 'diviner':
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('preserve-linebreaks', false);
   //    $engine->setConfig('diviner.renderer', new DivinerDefaultRenderer());
         $engine->setConfig('header.generate-toc', true);
         break;
       case 'extract':
         // Engine used for reference/edge extraction. Turn off anything which
         // is slow and doesn't change reference extraction.
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('pygments.enabled', false);
         break;
       default:
         throw new Exception(pht('Unknown engine ruleset: %s!', $ruleset));
     }
 
     $engines[$ruleset] = $engine;
     return $engine;
   }
 
   /**
    * @task engine
    */
   private static function getMarkupEngineDefaultConfiguration() {
     return array(
       'pygments'      => PhabricatorEnv::getEnvConfig('pygments.enabled'),
       'youtube'       => PhabricatorEnv::getEnvConfig(
         'remarkup.enable-embedded-youtube'),
       'differential.diff' => null,
       'header.generate-toc' => false,
       'macros'        => true,
       'uri.allowed-protocols' => PhabricatorEnv::getEnvConfig(
         'uri.allowed-protocols'),
       'uri.full' => false,
       'syntax-highlighter.engine' => PhabricatorEnv::getEnvConfig(
         'syntax-highlighter.engine'),
       'preserve-linebreaks' => true,
     );
   }
 
 
   /**
    * @task engine
    */
   public static function newMarkupEngine(array $options) {
     $options += self::getMarkupEngineDefaultConfiguration();
 
     $engine = new PhutilRemarkupEngine();
 
     $engine->setConfig('preserve-linebreaks', $options['preserve-linebreaks']);
 
     $engine->setConfig('pygments.enabled', $options['pygments']);
     $engine->setConfig(
       'uri.allowed-protocols',
       $options['uri.allowed-protocols']);
     $engine->setConfig('differential.diff', $options['differential.diff']);
     $engine->setConfig('header.generate-toc', $options['header.generate-toc']);
     $engine->setConfig(
       'syntax-highlighter.engine',
       $options['syntax-highlighter.engine']);
 
     $style_map = id(new PhabricatorDefaultSyntaxStyle())
       ->getRemarkupStyleMap();
     $engine->setConfig('phutil.codeblock.style-map', $style_map);
 
     $engine->setConfig('uri.full', $options['uri.full']);
 
     if (isset($options['uri.base'])) {
       $engine->setConfig('uri.base', $options['uri.base']);
     }
 
     if (isset($options['uri.same-window'])) {
       $engine->setConfig('uri.same-window', $options['uri.same-window']);
     }
 
     $rules = array();
     $rules[] = new PhutilRemarkupEscapeRemarkupRule();
     $rules[] = new PhutilRemarkupMonospaceRule();
 
 
     $rules[] = new PhutilRemarkupDocumentLinkRule();
     $rules[] = new PhabricatorNavigationRemarkupRule();
     $rules[] = new PhabricatorKeyboardRemarkupRule();
 
     if ($options['youtube']) {
       $rules[] = new PhabricatorYoutubeRemarkupRule();
     }
 
     $rules[] = new PhabricatorIconRemarkupRule();
     $rules[] = new PhabricatorEmojiRemarkupRule();
     $rules[] = new PhabricatorHandleRemarkupRule();
 
     $applications = PhabricatorApplication::getAllInstalledApplications();
     foreach ($applications as $application) {
       foreach ($application->getRemarkupRules() as $rule) {
         $rules[] = $rule;
       }
     }
 
     $rules[] = new PhutilRemarkupHyperlinkRule();
 
     if ($options['macros']) {
       $rules[] = new PhabricatorImageMacroRemarkupRule();
       $rules[] = new PhabricatorMemeRemarkupRule();
     }
 
     $rules[] = new PhutilRemarkupBoldRule();
     $rules[] = new PhutilRemarkupItalicRule();
     $rules[] = new PhutilRemarkupDelRule();
     $rules[] = new PhutilRemarkupUnderlineRule();
     $rules[] = new PhutilRemarkupHighlightRule();
 
     foreach (self::loadCustomInlineRules() as $rule) {
       $rules[] = clone $rule;
     }
 
     $blocks = array();
     $blocks[] = new PhutilRemarkupQuotesBlockRule();
     $blocks[] = new PhutilRemarkupReplyBlockRule();
     $blocks[] = new PhutilRemarkupLiteralBlockRule();
     $blocks[] = new PhutilRemarkupHeaderBlockRule();
     $blocks[] = new PhutilRemarkupHorizontalRuleBlockRule();
     $blocks[] = new PhutilRemarkupListBlockRule();
     $blocks[] = new PhutilRemarkupCodeBlockRule();
     $blocks[] = new PhutilRemarkupNoteBlockRule();
     $blocks[] = new PhutilRemarkupTableBlockRule();
     $blocks[] = new PhutilRemarkupSimpleTableBlockRule();
     $blocks[] = new PhutilRemarkupInterpreterBlockRule();
     $blocks[] = new PhutilRemarkupDefaultBlockRule();
 
     foreach (self::loadCustomBlockRules() as $rule) {
       $blocks[] = $rule;
     }
 
     foreach ($blocks as $block) {
       $block->setMarkupRules($rules);
     }
 
     $engine->setBlockRules($blocks);
 
     return $engine;
   }
 
   public static function extractPHIDsFromMentions(
     PhabricatorUser $viewer,
     array $content_blocks) {
 
     $mentions = array();
 
     $engine = self::newDifferentialMarkupEngine();
     $engine->setConfig('viewer', $viewer);
 
     foreach ($content_blocks as $content_block) {
       $engine->markupText($content_block);
       $phids = $engine->getTextMetadata(
         PhabricatorMentionRemarkupRule::KEY_MENTIONED,
         array());
       $mentions += $phids;
     }
 
     return $mentions;
   }
 
   public static function extractFilePHIDsFromEmbeddedFiles(
     PhabricatorUser $viewer,
     array $content_blocks) {
     $files = array();
 
     $engine = self::newDifferentialMarkupEngine();
     $engine->setConfig('viewer', $viewer);
 
     foreach ($content_blocks as $content_block) {
       $engine->markupText($content_block);
       $phids = $engine->getTextMetadata(
         PhabricatorEmbedFileRemarkupRule::KEY_EMBED_FILE_PHIDS,
         array());
       foreach ($phids as $phid) {
         $files[$phid] = $phid;
       }
     }
 
     return array_values($files);
   }
 
   public static function summarizeSentence($corpus) {
     $corpus = trim($corpus);
     $blocks = preg_split('/\n+/', $corpus, 2);
     $block = head($blocks);
 
     $sentences = preg_split(
       '/\b([.?!]+)\B/u',
       $block,
       2,
       PREG_SPLIT_DELIM_CAPTURE);
 
     if (count($sentences) > 1) {
       $result = $sentences[0].$sentences[1];
     } else {
       $result = head($sentences);
     }
 
     return id(new PhutilUTF8StringTruncator())
       ->setMaximumGlyphs(128)
       ->truncateString($result);
   }
 
   /**
    * Produce a corpus summary, in a way that shortens the underlying text
    * without truncating it somewhere awkward.
    *
    * TODO: We could do a better job of this.
    *
    * @param string  Remarkup corpus to summarize.
    * @return string Summarized corpus.
    */
   public static function summarize($corpus) {
 
     // Major goals here are:
     //  - Don't split in the middle of a character (utf-8).
     //  - Don't split in the middle of, e.g., **bold** text, since
     //    we end up with hanging '**' in the summary.
     //  - Try not to pick an image macro, header, embedded file, etc.
     //  - Hopefully don't return too much text. We don't explicitly limit
     //    this right now.
 
     $blocks = preg_split("/\n *\n\s*/", $corpus);
 
     $best = null;
     foreach ($blocks as $block) {
       // This is a test for normal spaces in the block, i.e. a heuristic to
       // distinguish standard paragraphs from things like image macros. It may
       // not work well for non-latin text. We prefer to summarize with a
       // paragraph of normal words over an image macro, if possible.
       $has_space = preg_match('/\w\s\w/', $block);
 
       // This is a test to find embedded images and headers. We prefer to
       // summarize with a normal paragraph over a header or an embedded object,
       // if possible.
       $has_embed = preg_match('/^[{=]/', $block);
 
       if ($has_space && !$has_embed) {
         // This seems like a good summary, so return it.
         return $block;
       }
 
       if (!$best) {
         // This is the first block we found; if everything is garbage just
         // use the first block.
         $best = $block;
       }
     }
 
     return $best;
   }
 
   private static function loadCustomInlineRules() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass('PhabricatorRemarkupCustomInlineRule')
       ->execute();
   }
 
   private static function loadCustomBlockRules() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass('PhabricatorRemarkupCustomBlockRule')
       ->execute();
   }
 
 }