diff --git a/src/applications/differential/field/specification/DifferentialUnitFieldSpecification.php b/src/applications/differential/field/specification/DifferentialUnitFieldSpecification.php
index 546dcd2177..a3d701475e 100644
--- a/src/applications/differential/field/specification/DifferentialUnitFieldSpecification.php
+++ b/src/applications/differential/field/specification/DifferentialUnitFieldSpecification.php
@@ -1,227 +1,236 @@
 <?php
 
 final class DifferentialUnitFieldSpecification
   extends DifferentialFieldSpecification {
 
   public function shouldAppearOnDiffView() {
       return true;
   }
 
   public function renderLabelForDiffView() {
     return $this->renderLabelForRevisionView();
   }
 
   public function renderValueForDiffView() {
     return $this->renderValueForRevisionView();
   }
 
   public function shouldAppearOnRevisionView() {
     return true;
   }
 
   public function renderLabelForRevisionView() {
     return 'Unit:';
   }
 
   private function getUnitExcuse() {
     return $this->getDiffProperty('arc:unit-excuse');
   }
 
   public function renderValueForRevisionView() {
     $diff = $this->getManualDiff();
 
     $ustar = DifferentialRevisionUpdateHistoryView::renderDiffUnitStar($diff);
     $umsg = DifferentialRevisionUpdateHistoryView::getDiffUnitMessage($diff);
 
     $rows = array();
 
     $rows[] = array(
       'style' => 'star',
       'name'  => $ustar,
       'value' => $umsg,
       'show'  => true,
     );
 
     $excuse = $this->getUnitExcuse();
     if ($excuse) {
       $rows[] = array(
         'style' => 'excuse',
         'name'  => 'Excuse',
         'value' => phutil_escape_html_newlines($excuse),
         'show'  => true,
       );
     }
 
     $show_limit = 10;
     $hidden = array();
 
     $udata = $this->getDiffProperty('arc:unit');
     if ($udata) {
       $sort_map = array(
         ArcanistUnitTestResult::RESULT_BROKEN     => 0,
         ArcanistUnitTestResult::RESULT_FAIL       => 1,
         ArcanistUnitTestResult::RESULT_UNSOUND    => 2,
         ArcanistUnitTestResult::RESULT_SKIP       => 3,
         ArcanistUnitTestResult::RESULT_POSTPONED  => 4,
         ArcanistUnitTestResult::RESULT_PASS       => 5,
       );
 
       foreach ($udata as $key => $test) {
         $udata[$key]['sort'] = idx($sort_map, idx($test, 'result'));
       }
       $udata = isort($udata, 'sort');
-
-      foreach ($udata as $test) {
+      $engine = new PhabricatorMarkupEngine();
+      $engine->setViewer($this->getUser());
+      $markup_objects = array();
+      foreach ($udata as $key => $test) {
+        $userdata = idx($test, 'userdata');
+        if ($userdata) {
+          if ($userdata !== false) {
+            $userdata = str_replace("\000", '', $userdata);
+          }
+          $markup_object = id(new PhabricatorMarkupOneOff())
+              ->setContent($userdata)
+              ->setPreserveLinebreaks(true);
+          $engine->addObject($markup_object, 'default');
+          $markup_objects[$key] = $markup_object;
+        }
+      }
+      $engine->process();
+      foreach ($udata as $key => $test) {
         $result = idx($test, 'result');
 
         $default_hide = false;
         switch ($result) {
           case ArcanistUnitTestResult::RESULT_POSTPONED:
           case ArcanistUnitTestResult::RESULT_PASS:
             $default_hide = true;
             break;
         }
 
         if ($show_limit && !$default_hide) {
           --$show_limit;
           $show = true;
         } else {
           $show = false;
           if (empty($hidden[$result])) {
             $hidden[$result] = 0;
           }
           $hidden[$result]++;
         }
 
         $value = idx($test, 'name');
         if (!empty($test['link'])) {
           $value = phutil_tag(
             'a',
             array(
               'href' => $test['link'],
               'target' => '_blank',
             ),
             $value);
         }
         $rows[] = array(
           'style' => $this->getResultStyle($result),
           'name'  => ucwords($result),
           'value' => $value,
           'show'  => $show,
         );
 
-        $userdata = idx($test, 'userdata');
-        if ($userdata) {
-          if ($userdata !== false) {
-            $userdata = str_replace("\000", '', $userdata);
-          }
-          $engine = PhabricatorMarkupEngine::newDifferentialMarkupEngine();
-          $engine->setConfig('viewer', $this->getUser());
-          $userdata = $engine->markupText($userdata);
+        if (isset($markup_objects[$key])) {
           $rows[] = array(
             'style' => 'details',
-            'value' => $userdata,
+            'value' => $engine->getOutput($markup_objects[$key], 'default'),
             'show'  => false,
           );
           if (empty($hidden['details'])) {
             $hidden['details'] = 0;
           }
           $hidden['details']++;
         }
       }
     }
 
     $show_string = $this->renderShowString($hidden);
 
     $view = new DifferentialResultsTableView();
     $view->setRows($rows);
     $view->setShowMoreString($show_string);
 
     return $view->render();
   }
 
   private function getResultStyle($result) {
     $map = array(
       ArcanistUnitTestResult::RESULT_PASS       => 'green',
       ArcanistUnitTestResult::RESULT_FAIL       => 'red',
       ArcanistUnitTestResult::RESULT_SKIP       => 'blue',
       ArcanistUnitTestResult::RESULT_BROKEN     => 'red',
       ArcanistUnitTestResult::RESULT_UNSOUND    => 'yellow',
       ArcanistUnitTestResult::RESULT_POSTPONED  => 'blue',
     );
     return idx($map, $result);
   }
 
   private function renderShowString(array $hidden) {
     if (!$hidden) {
       return null;
     }
 
     // Reorder hidden things by severity.
     $hidden = array_select_keys(
       $hidden,
       array(
         ArcanistUnitTestResult::RESULT_BROKEN,
         ArcanistUnitTestResult::RESULT_FAIL,
         ArcanistUnitTestResult::RESULT_UNSOUND,
         ArcanistUnitTestResult::RESULT_SKIP,
         ArcanistUnitTestResult::RESULT_POSTPONED,
         ArcanistUnitTestResult::RESULT_PASS,
         'details',
       )) + $hidden;
 
     $noun = array(
       ArcanistUnitTestResult::RESULT_BROKEN     => 'Broken',
       ArcanistUnitTestResult::RESULT_FAIL       => 'Failed',
       ArcanistUnitTestResult::RESULT_UNSOUND    => 'Unsound',
       ArcanistUnitTestResult::RESULT_SKIP       => 'Skipped',
       ArcanistUnitTestResult::RESULT_POSTPONED  => 'Postponed',
       ArcanistUnitTestResult::RESULT_PASS       => 'Passed',
     );
 
     $show = array();
     foreach ($hidden as $key => $value) {
       if ($key == 'details') {
         $show[] = pht('%d Detail(s)', $value);
       } else {
         $show[] = $value.' '.idx($noun, $key);
       }
     }
 
     return "Show Full Unit Results (".implode(', ', $show).")";
   }
 
   public function renderWarningBoxForRevisionAccept() {
     $diff = $this->getDiff();
     $unit_warning = null;
     if ($diff->getUnitStatus() >= DifferentialUnitStatus::UNIT_WARN) {
       $titles =
         array(
           DifferentialUnitStatus::UNIT_WARN => 'Unit Tests Warning',
           DifferentialUnitStatus::UNIT_FAIL => 'Unit Tests Failure',
           DifferentialUnitStatus::UNIT_SKIP => 'Unit Tests Skipped',
           DifferentialUnitStatus::UNIT_POSTPONED => 'Unit Tests Postponed'
         );
       if ($diff->getUnitStatus() == DifferentialUnitStatus::UNIT_POSTPONED) {
         $content =
           "This diff has postponed unit tests. The results should be ".
           "coming in soon. You should probably wait for them before accepting ".
           "this diff.";
       } else if ($diff->getUnitStatus() == DifferentialUnitStatus::UNIT_SKIP) {
         $content =
           "Unit tests were skipped when this diff was created. Make sure ".
           "you are OK with that before you accept this diff.";
       } else {
         $content =
           "This diff has Unit Test Problems. Make sure you are OK with ".
           "them before you accept this diff.";
       }
       $unit_warning = id(new AphrontErrorView())
         ->setSeverity(AphrontErrorView::SEVERITY_ERROR)
         ->appendChild(phutil_tag('p', array(), $content))
         ->setTitle(idx($titles, $diff->getUnitStatus(), 'Warning'));
     }
     return $unit_warning;
   }
 
 }
diff --git a/src/infrastructure/markup/PhabricatorMarkupEngine.php b/src/infrastructure/markup/PhabricatorMarkupEngine.php
index 764ca6f79a..ff01cb4bc1 100644
--- a/src/infrastructure/markup/PhabricatorMarkupEngine.php
+++ b/src/infrastructure/markup/PhabricatorMarkupEngine.php
@@ -1,583 +1,585 @@
 <?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 {
 
   private $objects = array();
   private $viewer;
   private $version = 8;
 
 
 /* -(  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.
    * @return string                     Marked up output.
    * @task markup
    */
   public static function renderOneObject(
     PhabricatorMarkupInterface $object,
     $field,
     PhabricatorUser $viewer) {
     return id(new PhabricatorMarkupEngine())
       ->setViewer($viewer)
       ->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);
     }
 
     // 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(
         "Call addObject() before using results (key = '{$key}').");
     }
 
     if (!isset($this->objects[$key]['output'])) {
       throw new Exception(
         "Call process() before using results.");
     }
   }
 
 
   /**
    * @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);
       }
     }
 
     foreach ($objects as $key => $info) {
-      if (isset($blocks[$key])) {
+      // 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])) {
         // 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;
   }
 
 
 /* -(  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,
     ));
   }
 
 
   /**
    * @task engine
    */
   public static function newFeedMarkupEngine() {
     return self::newMarkupEngine(
       array(
         'macros'      => false,
         'youtube'     => false,
 
       ));
   }
 
 
   /**
    * @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(
     ));
   }
 
   /**
    * @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 'nolinebreaks':
         $engine = self::newMarkupEngine(array());
         $engine->setConfig('preserve-linebreaks', false);
         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;
       default:
         throw new Exception("Unknown engine ruleset: {$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'),
       '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']);
 
     $rules = array();
     $rules[] = new PhutilRemarkupRuleEscapeRemarkup();
     $rules[] = new PhutilRemarkupRuleMonospace();
 
 
     $rules[] = new PhutilRemarkupRuleDocumentLink();
 
     if ($options['youtube']) {
       $rules[] = new PhabricatorRemarkupRuleYoutube();
     }
 
     $applications = PhabricatorApplication::getAllInstalledApplications();
     foreach ($applications as $application) {
       foreach ($application->getRemarkupRules() as $rule) {
         $rules[] = $rule;
       }
     }
 
     $rules[] = new PhutilRemarkupRuleHyperlink();
 
     if ($options['macros']) {
       $rules[] = new PhabricatorRemarkupRuleImageMacro();
       $rules[] = new PhabricatorRemarkupRuleMeme();
     }
 
     $rules[] = new PhutilRemarkupRuleBold();
     $rules[] = new PhutilRemarkupRuleItalic();
     $rules[] = new PhutilRemarkupRuleDel();
 
     foreach (self::loadCustomInlineRules() as $rule) {
       $rules[] = $rule;
     }
 
     $blocks = array();
     $blocks[] = new PhutilRemarkupEngineRemarkupQuotesBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupLiteralBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupHeaderBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupHorizontalRuleBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupListBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupCodeBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupNoteBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupTableBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupSimpleTableBlockRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupInterpreterRule();
     $blocks[] = new PhutilRemarkupEngineRemarkupDefaultBlockRule();
 
     foreach (self::loadCustomBlockRules() as $rule) {
       $blocks[] = $rule;
     }
 
     foreach ($blocks as $block) {
       $block->setMarkupRules($rules);
     }
 
     $engine->setBlockRules($blocks);
 
     return $engine;
   }
 
   public static function extractPHIDsFromMentions(array $content_blocks) {
     $mentions = array();
 
     $engine = self::newDifferentialMarkupEngine();
     $engine->setConfig('viewer', PhabricatorUser::getOmnipotentUser());
 
     foreach ($content_blocks as $content_block) {
       $engine->markupText($content_block);
       $phids = $engine->getTextMetadata(
         PhabricatorRemarkupRuleMention::KEY_MENTIONED,
         array());
       $mentions += $phids;
     }
 
     return $mentions;
   }
 
   public static function extractFilePHIDsFromEmbeddedFiles(
     array $content_blocks) {
     $files = array();
 
     $engine = self::newDifferentialMarkupEngine();
     $engine->setConfig('viewer', PhabricatorUser::getOmnipotentUser());
 
     foreach ($content_blocks as $content_block) {
       $engine->markupText($content_block);
       $ids = $engine->getTextMetadata(
         PhabricatorRemarkupRuleEmbedFile::KEY_EMBED_FILE_PHIDS,
         array());
       $files += $ids;
     }
 
     return $files;
   }
 
   /**
    * 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*/", trim($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 PhutilSymbolLoader())
       ->setAncestorClass('PhabricatorRemarkupCustomInlineRule')
       ->loadObjects();
   }
 
   private static function loadCustomBlockRules() {
     return id(new PhutilSymbolLoader())
       ->setAncestorClass('PhabricatorRemarkupCustomBlockRule')
       ->loadObjects();
   }
 
 }