diff --git a/scripts/celerity_mapper.php b/scripts/celerity_mapper.php
index 7fa40e2d87..4a30d205a6 100755
--- a/scripts/celerity_mapper.php
+++ b/scripts/celerity_mapper.php
@@ -1,172 +1,185 @@
 #!/usr/bin/env php
 <?php
 
 $package_spec = array(
   'core.pkg.css' => array(
     'phabricator-core-css',
     'phabricator-core-buttons-css',
     'phabricator-standard-page-view',
     'aphront-dialog-view-css',
     'aphront-form-view-css',
     'aphront-panel-view-css',
     'aphront-side-nav-view-css',
     'aphront-table-view-css',
     'aphront-tokenizer-control-css',
     'aphront-typeahead-control-css',
 
     'phabricator-directory-css',
+
+    'phabricator-remarkup-css',
+    'syntax-highlighting-css',
   ),
   'differential.pkg.css' => array(
     'differential-core-view-css',
     'differential-changeset-view-css',
     'differential-revision-detail-css',
     'differential-revision-history-css',
     'differential-table-of-contents-css',
+    'differential-revision-comment-css',
+    'differential-revision-add-comment-css',
+    'differential-revision-comment-list-css',
+  ),
+  'differential.pkg.js' => array(
+    'javelin-behavior-differential-feedback-preview',
+    'javelin-behavior-differential-edit-inline-comments',
+    'javelin-behavior-differential-populate',
+    'javelin-behavior-differential-show-more',
+    'javelin-behavior-differential-diff-radios',
   ),
 );
 
 
 require_once dirname(__FILE__).'/__init_script__.php';
 
 if ($argc != 2) {
   $self = basename($argv[0]);
   echo "usage: {$self} <webroot>\n";
   exit(1);
 }
 
 phutil_require_module('phutil', 'filesystem');
 phutil_require_module('phutil', 'filesystem/filefinder');
 phutil_require_module('phutil', 'future/exec');
 phutil_require_module('phutil', 'parser/docblock');
 
 $root = Filesystem::resolvePath($argv[1]);
 
 echo "Finding static resources...\n";
 $files = id(new FileFinder($root))
   ->withType('f')
   ->withSuffix('js')
   ->withSuffix('css')
   ->setGenerateChecksums(true)
   ->find();
 
 echo "Processing ".count($files)." files";
 
 $file_map = array();
 foreach ($files as $path => $hash) {
   echo ".";
   $name = '/'.Filesystem::readablePath($path, $root);
   $file_map[$name] = array(
     'hash' => $hash,
     'disk' => $path,
   );
 }
 echo "\n";
 
 $runtime_map = array();
 
 $hash_map = array();
 
 $parser = new PhutilDocblockParser();
 foreach ($file_map as $path => $info) {
   $data = Filesystem::readFile($info['disk']);
   $matches = array();
   $ok = preg_match('@/[*][*].*?[*]/@s', $data, $matches);
   if (!$ok) {
     throw new Exception(
       "File {$path} does not have a header doc comment. Encode dependency ".
       "data in a header docblock.");
   }
   
   list($description, $metadata) = $parser->parse($matches[0]);
   
   $provides = preg_split('/\s+/', trim(idx($metadata, 'provides')));
   $requires = preg_split('/\s+/', trim(idx($metadata, 'requires')));
   $provides = array_filter($provides);
   $requires = array_filter($requires);
   
   if (count($provides) !== 1) {
     throw new Exception(
       "File {$path} must @provide exactly one Celerity target.");
   }
   
   $provides = reset($provides);
 
   $type = 'js';
   if (preg_match('/\.css$/', $path)) {
     $type = 'css';
   }
   
   $uri = '/res/'.substr($info['hash'], 0, 8).$path;
   
   $hash_map[$provides] = $info['hash'];
   
   $runtime_map[$provides] = array(
     'uri'       => $uri,
     'type'      => $type,
     'requires'  => $requires,
     'disk'      => $path,
   );
 }
 
 $package_map = array();
 foreach ($package_spec as $name => $package) {
   $hashes = array();
   $type = null;
   foreach ($package as $symbol) {
     if (empty($hash_map[$symbol])) {
       throw new Exception(
         "Package specification for '{$name}' includes '{$symbol}', but that ".
         "symbol is not defined anywhere.");
     }
     if ($type === null) {
       $type = $runtime_map[$symbol]['type'];
     } else {
       $ntype = $runtime_map[$symbol]['type'];
       if ($type !== $ntype) {
         throw new Exception(
           "Package specification for '{$name}' mixes resources of type ".
           "'{$type}' with resources of type '{$ntype}'. Each package may only ".
           "contain one type of resource.");
       }
     }
     $hashes[] = $symbol.':'.$hash_map[$symbol];
   }
   $key = substr(md5(implode("\n", $hashes)), 0, 8);
   $package_map['packages'][$key] = array(
     'name'    => $name,
     'symbols' => $package,
     'uri'     => '/res/pkg/'.$key.'/'.$name,
     'type'    => $type,
   );
   foreach ($package as $symbol) {
     $package_map['reverse'][$symbol] = $key;
   }
 }
     
 
 $runtime_map = var_export($runtime_map, true);
 $runtime_map = preg_replace('/\s+$/m', '', $runtime_map);
 $runtime_map = preg_replace('/array \(/', 'array(', $runtime_map);
 
 $package_map = var_export($package_map, true);
 $pacakge_map = preg_replace('/\s+$/m', '', $package_map);
 $package_map = preg_replace('/array \(/', 'array(', $package_map);
 
 $resource_map = <<<EOFILE
 <?php
 
 /**
  * This file is automatically generated. Use 'celerity_mapper.php' to rebuild
  * it.
  * @generated
  */
 
 celerity_register_resource_map({$runtime_map}, {$pacakge_map});
 
 EOFILE;
 
 echo "Writing map...\n";
 Filesystem::writeFile(
   $root.'/../src/__celerity_resource_map__.php',
   $resource_map);
 echo "Done.\n";  
diff --git a/src/__celerity_resource_map__.php b/src/__celerity_resource_map__.php
index ba1232db01..190cd9ad09 100644
--- a/src/__celerity_resource_map__.php
+++ b/src/__celerity_resource_map__.php
@@ -1,425 +1,454 @@
 <?php
 
 /**
  * This file is automatically generated. Use 'celerity_mapper.php' to rebuild
  * it.
  * @generated
  */
 
 celerity_register_resource_map(array(
   'aphront-dark-console-css' =>
   array(
     'uri' => '/res/056b0c12/rsrc/css/aphront/dark-console.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/aphront/dark-console.css',
   ),
   'aphront-dialog-view-css' =>
   array(
     'uri' => '/res/a05107ae/rsrc/css/aphront/dialog-view.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/aphront/dialog-view.css',
   ),
   'aphront-form-view-css' =>
   array(
     'uri' => '/res/785ac1c6/rsrc/css/aphront/form-view.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/aphront/form-view.css',
   ),
   'aphront-panel-view-css' =>
   array(
     'uri' => '/res/63672373/rsrc/css/aphront/panel-view.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/aphront/panel-view.css',
   ),
   'aphront-request-failure-view-css' =>
   array(
     'uri' => '/res/97b8337a/rsrc/css/aphront/request-failure-view.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/aphront/request-failure-view.css',
   ),
   'aphront-side-nav-view-css' =>
   array(
     'uri' => '/res/0fc0545c/rsrc/css/aphront/side-nav-view.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/aphront/side-nav-view.css',
   ),
   'aphront-table-view-css' =>
   array(
     'uri' => '/res/6a70f0f0/rsrc/css/aphront/table-view.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/aphront/table-view.css',
   ),
   'aphront-tokenizer-control-css' =>
   array(
     'uri' => '/res/a3d23074/rsrc/css/aphront/tokenizer.css',
     'type' => 'css',
     'requires' =>
     array(
       0 => 'aphront-typeahead-control-css',
     ),
     'disk' => '/rsrc/css/aphront/tokenizer.css',
   ),
   'aphront-typeahead-control-css' =>
   array(
     'uri' => '/res/928df9f0/rsrc/css/aphront/typeahead.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/aphront/typeahead.css',
   ),
   'phabricator-standard-page-view' =>
   array(
     'uri' => '/res/fb02fb0e/rsrc/css/application/base/standard-page-view.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/base/standard-page-view.css',
   ),
   'differential-revision-add-comment-css' =>
   array(
     'uri' => '/res/9be761de/rsrc/css/application/differential/add-comment.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/differential/add-comment.css',
   ),
   'differential-changeset-view-css' =>
   array(
-    'uri' => '/res/4e0295a9/rsrc/css/application/differential/changeset-view.css',
+    'uri' => '/res/8b893b8e/rsrc/css/application/differential/changeset-view.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/differential/changeset-view.css',
   ),
   'differential-core-view-css' =>
   array(
     'uri' => '/res/525d1a12/rsrc/css/application/differential/core.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/differential/core.css',
   ),
   'differential-revision-comment-list-css' =>
   array(
     'uri' => '/res/a1c117db/rsrc/css/application/differential/revision-comment-list.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/differential/revision-comment-list.css',
   ),
   'differential-revision-comment-css' =>
   array(
     'uri' => '/res/274eb3f1/rsrc/css/application/differential/revision-comment.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/differential/revision-comment.css',
   ),
   'differential-revision-detail-css' =>
   array(
     'uri' => '/res/230a67c6/rsrc/css/application/differential/revision-detail.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/differential/revision-detail.css',
   ),
   'differential-revision-history-css' =>
   array(
     'uri' => '/res/755f3da3/rsrc/css/application/differential/revision-history.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/differential/revision-history.css',
   ),
   'differential-table-of-contents-css' =>
   array(
-    'uri' => '/res/a4a7b2b5/rsrc/css/application/differential/table-of-contents.css',
+    'uri' => '/res/e68f6f05/rsrc/css/application/differential/table-of-contents.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/differential/table-of-contents.css',
   ),
   'phabricator-directory-css' =>
   array(
     'uri' => '/res/6a000601/rsrc/css/application/directory/phabricator-directory.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/application/directory/phabricator-directory.css',
   ),
   'phabricator-core-buttons-css' =>
   array(
     'uri' => '/res/6e348ba4/rsrc/css/core/buttons.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/core/buttons.css',
   ),
   'phabricator-core-css' =>
   array(
-    'uri' => '/res/39ce37c2/rsrc/css/core/core.css',
+    'uri' => '/res/41c62455/rsrc/css/core/core.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/core/core.css',
   ),
   'phabricator-core-dialog-css' =>
   array(
     'uri' => '/res/f66cec41/rsrc/css/core/dialog.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/core/dialog.css',
   ),
   'phabricator-remarkup-css' =>
   array(
     'uri' => '/res/786989c3/rsrc/css/core/remarkup.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/core/remarkup.css',
   ),
   'syntax-highlighting-css' =>
   array(
     'uri' => '/res/fb673ece/rsrc/css/core/syntax.css',
     'type' => 'css',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/css/core/syntax.css',
   ),
   'javelin-behavior-dark-console' =>
   array(
     'uri' => '/res/020b0265/rsrc/js/application/core/behavior-dark-console.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/application/core/behavior-dark-console.js',
   ),
   'javelin-behavior-aphront-basic-tokenizer' =>
   array(
     'uri' => '/res/8317d761/rsrc/js/application/core/behavior-tokenizer.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-lib-dev',
     ),
     'disk' => '/rsrc/js/application/core/behavior-tokenizer.js',
   ),
   'javelin-behavior-differential-feedback-preview' =>
   array(
     'uri' => '/res/8695d8b8/rsrc/js/application/differential/behavior-comment-preview.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-lib-dev',
     ),
     'disk' => '/rsrc/js/application/differential/behavior-comment-preview.js',
   ),
   'javelin-behavior-differential-diff-radios' =>
   array(
-    'uri' => '/res/ea6b0062/rsrc/js/application/differential/behavior-diff-radios.js',
+    'uri' => '/res/fdeb3823/rsrc/js/application/differential/behavior-diff-radios.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-lib-dev',
     ),
     'disk' => '/rsrc/js/application/differential/behavior-diff-radios.js',
   ),
   'javelin-behavior-differential-edit-inline-comments' =>
   array(
     'uri' => '/res/74747b2e/rsrc/js/application/differential/behavior-edit-inline-comments.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-lib-dev',
     ),
     'disk' => '/rsrc/js/application/differential/behavior-edit-inline-comments.js',
   ),
   'javelin-behavior-differential-populate' =>
   array(
-    'uri' => '/res/f7efbf62/rsrc/js/application/differential/behavior-populate.js',
+    'uri' => '/res/a13dcd7e/rsrc/js/application/differential/behavior-populate.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-lib-dev',
     ),
     'disk' => '/rsrc/js/application/differential/behavior-populate.js',
   ),
   'javelin-behavior-differential-show-more' =>
   array(
     'uri' => '/res/ea998002/rsrc/js/application/differential/behavior-show-more.js',
     'type' => 'js',
     'requires' =>
     array(
       0 => 'javelin-lib-dev',
     ),
     'disk' => '/rsrc/js/application/differential/behavior-show-more.js',
   ),
   'javelin-magical-init' =>
   array(
     'uri' => '/res/76614f84/rsrc/js/javelin/init.dev.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/javelin/init.dev.js',
   ),
   'javelin-init-prod' =>
   array(
     'uri' => '/res/1267c868/rsrc/js/javelin/init.min.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/javelin/init.min.js',
   ),
   'javelin-lib-dev' =>
   array(
     'uri' => '/res/a0e7a5e9/rsrc/js/javelin/javelin.dev.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/javelin/javelin.dev.js',
   ),
   'javelin-lib-prod' =>
   array(
     'uri' => '/res/2f2b3b2e/rsrc/js/javelin/javelin.min.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/javelin/javelin.min.js',
   ),
   'javelin-typeahead-dev' =>
   array(
     'uri' => '/res/6de6ae59/rsrc/js/javelin/typeahead.dev.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/javelin/typeahead.dev.js',
   ),
   'javelin-typeahead-prod' =>
   array(
     'uri' => '/res/69d5fad1/rsrc/js/javelin/typeahead.min.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/javelin/typeahead.min.js',
   ),
   'javelin-workflow-dev' =>
   array(
-    'uri' => '/res/7e690e16/rsrc/js/javelin/workflow.dev.js',
+    'uri' => '/res/c6b17f93/rsrc/js/javelin/workflow.dev.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/javelin/workflow.dev.js',
   ),
   'javelin-workflow-prod' =>
   array(
     'uri' => '/res/b758e0a0/rsrc/js/javelin/workflow.min.js',
     'type' => 'js',
     'requires' =>
     array(
     ),
     'disk' => '/rsrc/js/javelin/workflow.min.js',
   ),
 ), array (
   'packages' =>
   array (
-    '1a33af6b' =>
+    '85861df3' =>
     array (
       'name' => 'core.pkg.css',
       'symbols' =>
       array (
         0 => 'phabricator-core-css',
         1 => 'phabricator-core-buttons-css',
         2 => 'phabricator-standard-page-view',
         3 => 'aphront-dialog-view-css',
         4 => 'aphront-form-view-css',
         5 => 'aphront-panel-view-css',
         6 => 'aphront-side-nav-view-css',
         7 => 'aphront-table-view-css',
         8 => 'aphront-tokenizer-control-css',
         9 => 'aphront-typeahead-control-css',
         10 => 'phabricator-directory-css',
+        11 => 'phabricator-remarkup-css',
+        12 => 'syntax-highlighting-css',
       ),
-      'uri' => '/res/pkg/1a33af6b/core.pkg.css',
+      'uri' => '/res/pkg/85861df3/core.pkg.css',
       'type' => 'css',
     ),
-    '9d9c881c' =>
+    '86498b42' =>
     array (
       'name' => 'differential.pkg.css',
       'symbols' =>
       array (
         0 => 'differential-core-view-css',
         1 => 'differential-changeset-view-css',
         2 => 'differential-revision-detail-css',
         3 => 'differential-revision-history-css',
         4 => 'differential-table-of-contents-css',
+        5 => 'differential-revision-comment-css',
+        6 => 'differential-revision-add-comment-css',
+        7 => 'differential-revision-comment-list-css',
       ),
-      'uri' => '/res/pkg/9d9c881c/differential.pkg.css',
+      'uri' => '/res/pkg/86498b42/differential.pkg.css',
       'type' => 'css',
     ),
+    '30d594cf' =>
+    array (
+      'name' => 'differential.pkg.js',
+      'symbols' =>
+      array (
+        0 => 'javelin-behavior-differential-feedback-preview',
+        1 => 'javelin-behavior-differential-edit-inline-comments',
+        2 => 'javelin-behavior-differential-populate',
+        3 => 'javelin-behavior-differential-show-more',
+        4 => 'javelin-behavior-differential-diff-radios',
+      ),
+      'uri' => '/res/pkg/30d594cf/differential.pkg.js',
+      'type' => 'js',
+    ),
   ),
   'reverse' =>
   array (
-    'phabricator-core-css' => '1a33af6b',
-    'phabricator-core-buttons-css' => '1a33af6b',
-    'phabricator-standard-page-view' => '1a33af6b',
-    'aphront-dialog-view-css' => '1a33af6b',
-    'aphront-form-view-css' => '1a33af6b',
-    'aphront-panel-view-css' => '1a33af6b',
-    'aphront-side-nav-view-css' => '1a33af6b',
-    'aphront-table-view-css' => '1a33af6b',
-    'aphront-tokenizer-control-css' => '1a33af6b',
-    'aphront-typeahead-control-css' => '1a33af6b',
-    'phabricator-directory-css' => '1a33af6b',
-    'differential-core-view-css' => '9d9c881c',
-    'differential-changeset-view-css' => '9d9c881c',
-    'differential-revision-detail-css' => '9d9c881c',
-    'differential-revision-history-css' => '9d9c881c',
-    'differential-table-of-contents-css' => '9d9c881c',
+    'phabricator-core-css' => '85861df3',
+    'phabricator-core-buttons-css' => '85861df3',
+    'phabricator-standard-page-view' => '85861df3',
+    'aphront-dialog-view-css' => '85861df3',
+    'aphront-form-view-css' => '85861df3',
+    'aphront-panel-view-css' => '85861df3',
+    'aphront-side-nav-view-css' => '85861df3',
+    'aphront-table-view-css' => '85861df3',
+    'aphront-tokenizer-control-css' => '85861df3',
+    'aphront-typeahead-control-css' => '85861df3',
+    'phabricator-directory-css' => '85861df3',
+    'phabricator-remarkup-css' => '85861df3',
+    'syntax-highlighting-css' => '85861df3',
+    'differential-core-view-css' => '86498b42',
+    'differential-changeset-view-css' => '86498b42',
+    'differential-revision-detail-css' => '86498b42',
+    'differential-revision-history-css' => '86498b42',
+    'differential-table-of-contents-css' => '86498b42',
+    'differential-revision-comment-css' => '86498b42',
+    'differential-revision-add-comment-css' => '86498b42',
+    'differential-revision-comment-list-css' => '86498b42',
+    'javelin-behavior-differential-feedback-preview' => '30d594cf',
+    'javelin-behavior-differential-edit-inline-comments' => '30d594cf',
+    'javelin-behavior-differential-populate' => '30d594cf',
+    'javelin-behavior-differential-show-more' => '30d594cf',
+    'javelin-behavior-differential-diff-radios' => '30d594cf',
   ),
 ));
diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
index 0287bcc21c..a7ce107e3d 100644
--- a/src/__phutil_library_map__.php
+++ b/src/__phutil_library_map__.php
@@ -1,376 +1,378 @@
 <?php
 
 /**
  * This file is automatically generated. Use 'phutil_mapper.php' to rebuild it.
  * @generated
  */
 
 phutil_register_library_map(array(
   'class' =>
   array(
     'Aphront400Response' => 'aphront/response/400',
     'Aphront404Response' => 'aphront/response/404',
     'AphrontAjaxResponse' => 'aphront/response/ajax',
     'AphrontApplicationConfiguration' => 'aphront/applicationconfiguration',
     'AphrontController' => 'aphront/controller',
     'AphrontDatabaseConnection' => 'storage/connection/base',
     'AphrontDefaultApplicationConfiguration' => 'aphront/default/configuration',
     'AphrontDefaultApplicationController' => 'aphront/default/controller',
     'AphrontDialogResponse' => 'aphront/response/dialog',
     'AphrontDialogView' => 'view/dialog',
     'AphrontErrorView' => 'view/form/error',
     'AphrontException' => 'aphront/exception/base',
     'AphrontFileResponse' => 'aphront/response/file',
     'AphrontFormCheckboxControl' => 'view/form/control/checkbox',
     'AphrontFormControl' => 'view/form/control/base',
+    'AphrontFormDividerControl' => 'view/form/control/divider',
     'AphrontFormFileControl' => 'view/form/control/file',
     'AphrontFormMarkupControl' => 'view/form/control/markup',
     'AphrontFormPasswordControl' => 'view/form/control/password',
     'AphrontFormRecaptchaControl' => 'view/form/control/recaptcha',
     'AphrontFormSelectControl' => 'view/form/control/select',
     'AphrontFormStaticControl' => 'view/form/control/static',
     'AphrontFormSubmitControl' => 'view/form/control/submit',
     'AphrontFormTextAreaControl' => 'view/form/control/textarea',
     'AphrontFormTextControl' => 'view/form/control/text',
     'AphrontFormTokenizerControl' => 'view/form/control/tokenizer',
     'AphrontFormView' => 'view/form/base',
     'AphrontMySQLDatabaseConnection' => 'storage/connection/mysql',
     'AphrontNullView' => 'view/null',
     'AphrontPageView' => 'view/page/base',
     'AphrontPanelView' => 'view/layout/panel',
     'AphrontQueryConnectionException' => 'storage/exception/connection',
     'AphrontQueryConnectionLostException' => 'storage/exception/connectionlost',
     'AphrontQueryCountException' => 'storage/exception/count',
     'AphrontQueryDuplicateKeyException' => 'storage/exception/duplicatekey',
     'AphrontQueryException' => 'storage/exception/base',
     'AphrontQueryObjectMissingException' => 'storage/exception/objectmissing',
     'AphrontQueryParameterException' => 'storage/exception/parameter',
     'AphrontQueryRecoverableException' => 'storage/exception/recoverable',
     'AphrontRedirectException' => 'aphront/exception/redirect',
     'AphrontRedirectResponse' => 'aphront/response/redirect',
     'AphrontRequest' => 'aphront/request',
     'AphrontRequestFailureView' => 'view/page/failure',
     'AphrontResponse' => 'aphront/response/base',
     'AphrontSideNavView' => 'view/layout/sidenav',
     'AphrontTableView' => 'view/control/table',
     'AphrontURIMapper' => 'aphront/mapper',
     'AphrontView' => 'view/base',
     'AphrontWebpageResponse' => 'aphront/response/webpage',
     'CelerityAPI' => 'infrastructure/celerity/api',
     'CelerityResourceController' => 'infrastructure/celerity/controller',
     'CelerityResourceMap' => 'infrastructure/celerity/map',
     'CelerityStaticResourceResponse' => 'infrastructure/celerity/response',
     'ConduitAPIMethod' => 'applications/conduit/method/base',
     'ConduitAPIRequest' => 'applications/conduit/protocol/request',
     'ConduitAPI_conduit_connect_Method' => 'applications/conduit/method/conduit/connect',
     'ConduitAPI_differential_creatediff_Method' => 'applications/conduit/method/differential/creatediff',
     'ConduitAPI_differential_setdiffproperty_Method' => 'applications/conduit/method/differential/setdiffproperty',
     'ConduitAPI_file_upload_Method' => 'applications/conduit/method/file/upload',
     'ConduitAPI_user_find_Method' => 'applications/conduit/method/user/find',
     'ConduitException' => 'applications/conduit/protocol/exception',
     'DarkConsole' => 'aphront/console/api',
     'DarkConsoleController' => 'aphront/console/controller',
     'DarkConsoleCore' => 'aphront/console/core',
     'DarkConsoleErrorLogPlugin' => 'aphront/console/plugin/errorlog',
     'DarkConsoleErrorLogPluginAPI' => 'aphront/console/plugin/errorlog/api',
     'DarkConsolePlugin' => 'aphront/console/plugin/base',
     'DarkConsoleRequestPlugin' => 'aphront/console/plugin/request',
     'DarkConsoleServicesPlugin' => 'aphront/console/plugin/services',
     'DarkConsoleServicesPluginAPI' => 'aphront/console/plugin/services/api',
     'DarkConsoleXHProfPlugin' => 'aphront/console/plugin/xhprof',
     'DarkConsoleXHProfPluginAPI' => 'aphront/console/plugin/xhprof/api',
     'DifferentialAction' => 'applications/differential/constants/action',
     'DifferentialAddCommentView' => 'applications/differential/view/addcomment',
     'DifferentialCCWelcomeMail' => 'applications/differential/mail/ccwelcome',
     'DifferentialChangeType' => 'applications/differential/constants/changetype',
     'DifferentialChangeset' => 'applications/differential/storage/changeset',
     'DifferentialChangesetDetailView' => 'applications/differential/view/changesetdetailview',
     'DifferentialChangesetListView' => 'applications/differential/view/changesetlistview',
     'DifferentialChangesetParser' => 'applications/differential/parser/changeset',
     'DifferentialChangesetViewController' => 'applications/differential/controller/changesetview',
     'DifferentialComment' => 'applications/differential/storage/comment',
     'DifferentialCommentEditor' => 'applications/differential/editor/comment',
     'DifferentialCommentMail' => 'applications/differential/mail/comment',
     'DifferentialCommentPreviewController' => 'applications/differential/controller/commentpreview',
     'DifferentialCommentSaveController' => 'applications/differential/controller/commentsave',
     'DifferentialController' => 'applications/differential/controller/base',
     'DifferentialDAO' => 'applications/differential/storage/base',
     'DifferentialDiff' => 'applications/differential/storage/diff',
     'DifferentialDiffContentMail' => 'applications/differential/mail/diffcontent',
     'DifferentialDiffProperty' => 'applications/differential/storage/diffproperty',
     'DifferentialDiffTableOfContentsView' => 'applications/differential/view/difftableofcontents',
     'DifferentialDiffViewController' => 'applications/differential/controller/diffview',
     'DifferentialHunk' => 'applications/differential/storage/hunk',
     'DifferentialInlineComment' => 'applications/differential/storage/inlinecomment',
     'DifferentialInlineCommentEditController' => 'applications/differential/controller/inlinecommentedit',
     'DifferentialInlineCommentPreviewController' => 'applications/differential/controller/inlinecommentpreview',
     'DifferentialInlineCommentView' => 'applications/differential/view/inlinecomment',
     'DifferentialLintStatus' => 'applications/differential/constants/lintstatus',
     'DifferentialMail' => 'applications/differential/mail/base',
     'DifferentialMarkupEngineFactory' => 'applications/differential/parser/markup',
     'DifferentialNewDiffMail' => 'applications/differential/mail/newdiff',
     'DifferentialReviewRequestMail' => 'applications/differential/mail/reviewrequest',
     'DifferentialRevision' => 'applications/differential/storage/revision',
     'DifferentialRevisionCommentListView' => 'applications/differential/view/revisioncommentlist',
     'DifferentialRevisionCommentView' => 'applications/differential/view/revisioncomment',
     'DifferentialRevisionControlSystem' => 'applications/differential/constants/revisioncontrolsystem',
     'DifferentialRevisionDetailView' => 'applications/differential/view/revisiondetail',
     'DifferentialRevisionEditController' => 'applications/differential/controller/revisionedit',
     'DifferentialRevisionEditor' => 'applications/differential/editor/revision',
     'DifferentialRevisionListController' => 'applications/differential/controller/revisionlist',
     'DifferentialRevisionListData' => 'applications/differential/data/revisionlist',
     'DifferentialRevisionStatus' => 'applications/differential/constants/revisionstatus',
     'DifferentialRevisionUpdateHistoryView' => 'applications/differential/view/revisionupdatehistory',
     'DifferentialRevisionViewController' => 'applications/differential/controller/revisionview',
     'DifferentialUnitStatus' => 'applications/differential/constants/unitstatus',
     'Javelin' => 'infrastructure/javelin/api',
     'LiskDAO' => 'storage/lisk/dao',
     'Phabricator404Controller' => 'applications/base/controller/404',
     'PhabricatorAuthController' => 'applications/auth/controller/base',
     'PhabricatorConduitAPIController' => 'applications/conduit/controller/api',
     'PhabricatorConduitConnectionLog' => 'applications/conduit/storage/connectionlog',
     'PhabricatorConduitConsoleController' => 'applications/conduit/controller/console',
     'PhabricatorConduitController' => 'applications/conduit/controller/base',
     'PhabricatorConduitDAO' => 'applications/conduit/storage/base',
     'PhabricatorConduitLogController' => 'applications/conduit/controller/log',
     'PhabricatorConduitMethodCallLog' => 'applications/conduit/storage/methodcalllog',
     'PhabricatorController' => 'applications/base/controller/base',
     'PhabricatorDirectoryCategory' => 'applications/directory/storage/category',
     'PhabricatorDirectoryCategoryDeleteController' => 'applications/directory/controller/categorydelete',
     'PhabricatorDirectoryCategoryEditController' => 'applications/directory/controller/categoryedit',
     'PhabricatorDirectoryCategoryListController' => 'applications/directory/controller/categorylist',
     'PhabricatorDirectoryController' => 'applications/directory/controller/base',
     'PhabricatorDirectoryDAO' => 'applications/directory/storage/base',
     'PhabricatorDirectoryItem' => 'applications/directory/storage/item',
     'PhabricatorDirectoryItemDeleteController' => 'applications/directory/controller/itemdelete',
     'PhabricatorDirectoryItemEditController' => 'applications/directory/controller/itemedit',
     'PhabricatorDirectoryItemListController' => 'applications/directory/controller/itemlist',
     'PhabricatorDirectoryMainController' => 'applications/directory/controller/main',
     'PhabricatorEmailLoginController' => 'applications/auth/controller/email',
     'PhabricatorEmailTokenController' => 'applications/auth/controller/emailtoken',
     'PhabricatorEnv' => 'infrastructure/env',
     'PhabricatorFacebookAuthController' => 'applications/auth/controller/facebookauth',
     'PhabricatorFacebookAuthDiagnosticsController' => 'applications/auth/controller/facebookauth/diagnostics',
     'PhabricatorFile' => 'applications/files/storage/file',
     'PhabricatorFileController' => 'applications/files/controller/base',
     'PhabricatorFileDAO' => 'applications/files/storage/base',
     'PhabricatorFileListController' => 'applications/files/controller/list',
     'PhabricatorFileStorageBlob' => 'applications/files/storage/storageblob',
     'PhabricatorFileURI' => 'applications/files/uri',
     'PhabricatorFileUploadController' => 'applications/files/controller/upload',
     'PhabricatorFileViewController' => 'applications/files/controller/view',
     'PhabricatorLiskDAO' => 'applications/base/storage/lisk',
     'PhabricatorLoginController' => 'applications/auth/controller/login',
     'PhabricatorLogoutController' => 'applications/auth/controller/logout',
     'PhabricatorMailImplementationAdapter' => 'applications/metamta/adapter/base',
     'PhabricatorMailImplementationPHPMailerLiteAdapter' => 'applications/metamta/adapter/phpmailerlite',
     'PhabricatorMetaMTAController' => 'applications/metamta/controller/base',
     'PhabricatorMetaMTADAO' => 'applications/metamta/storage/base',
     'PhabricatorMetaMTAListController' => 'applications/metamta/controller/list',
     'PhabricatorMetaMTAMail' => 'applications/metamta/storage/mail',
     'PhabricatorMetaMTAMailingList' => 'applications/metamta/storage/mailinglist',
     'PhabricatorMetaMTAMailingListEditController' => 'applications/metamta/controller/mailinglistedit',
     'PhabricatorMetaMTAMailingListsController' => 'applications/metamta/controller/mailinglists',
     'PhabricatorMetaMTASendController' => 'applications/metamta/controller/send',
     'PhabricatorMetaMTAViewController' => 'applications/metamta/controller/view',
     'PhabricatorObjectHandle' => 'applications/phid/handle',
     'PhabricatorObjectHandleData' => 'applications/phid/handle/data',
     'PhabricatorPHID' => 'applications/phid/storage/phid',
     'PhabricatorPHIDAllocateController' => 'applications/phid/controller/allocate',
     'PhabricatorPHIDController' => 'applications/phid/controller/base',
     'PhabricatorPHIDDAO' => 'applications/phid/storage/base',
     'PhabricatorPHIDListController' => 'applications/phid/controller/list',
     'PhabricatorPHIDLookupController' => 'applications/phid/controller/lookup',
     'PhabricatorPHIDType' => 'applications/phid/storage/type',
     'PhabricatorPHIDTypeEditController' => 'applications/phid/controller/typeedit',
     'PhabricatorPHIDTypeListController' => 'applications/phid/controller/typelist',
     'PhabricatorPeopleController' => 'applications/people/controller/base',
     'PhabricatorPeopleEditController' => 'applications/people/controller/edit',
     'PhabricatorPeopleListController' => 'applications/people/controller/list',
     'PhabricatorPeopleProfileController' => 'applications/people/controller/profile',
     'PhabricatorStandardPageView' => 'view/page/standard',
     'PhabricatorTypeaheadCommonDatasourceController' => 'applications/typeahead/controller/common',
     'PhabricatorTypeaheadDatasourceController' => 'applications/typeahead/controller/base',
     'PhabricatorUser' => 'applications/people/storage/user',
     'PhabricatorUserDAO' => 'applications/people/storage/base',
     'PhabricatorXHProfController' => 'applications/xhprof/controller/base',
     'PhabricatorXHProfProfileController' => 'applications/xhprof/controller/profile',
     'PhabricatorXHProfProfileSymbolView' => 'applications/xhprof/view/symbol',
     'PhabricatorXHProfProfileTopLevelView' => 'applications/xhprof/view/toplevel',
   ),
   'function' =>
   array(
     '_qsprintf_check_scalar_type' => 'storage/qsprintf',
     '_qsprintf_check_type' => 'storage/qsprintf',
     'celerity_generate_unique_node_id' => 'infrastructure/celerity/api',
     'celerity_register_resource_map' => 'infrastructure/celerity/map',
     'javelin_render_tag' => 'infrastructure/javelin/markup',
     'phabricator_format_relative_time' => 'view/utils',
     'phabricator_format_timestamp' => 'view/utils',
     'phabricator_format_units_generic' => 'view/utils',
     'qsprintf' => 'storage/qsprintf',
     'queryfx' => 'storage/queryfx',
     'queryfx_all' => 'storage/queryfx',
     'queryfx_one' => 'storage/queryfx',
     'require_celerity_resource' => 'infrastructure/celerity/api',
     'vqsprintf' => 'storage/qsprintf',
     'vqueryfx' => 'storage/queryfx',
     'vqueryfx_all' => 'storage/queryfx',
     'xsprintf_query' => 'storage/qsprintf',
   ),
   'requires_class' =>
   array(
     'Aphront400Response' => 'AphrontResponse',
     'Aphront404Response' => 'AphrontResponse',
     'AphrontAjaxResponse' => 'AphrontResponse',
     'AphrontDefaultApplicationConfiguration' => 'AphrontApplicationConfiguration',
     'AphrontDefaultApplicationController' => 'AphrontController',
     'AphrontDialogResponse' => 'AphrontResponse',
     'AphrontDialogView' => 'AphrontView',
     'AphrontErrorView' => 'AphrontView',
     'AphrontFileResponse' => 'AphrontResponse',
     'AphrontFormCheckboxControl' => 'AphrontFormControl',
     'AphrontFormControl' => 'AphrontView',
+    'AphrontFormDividerControl' => 'AphrontFormControl',
     'AphrontFormFileControl' => 'AphrontFormControl',
     'AphrontFormMarkupControl' => 'AphrontFormControl',
     'AphrontFormPasswordControl' => 'AphrontFormControl',
     'AphrontFormRecaptchaControl' => 'AphrontFormControl',
     'AphrontFormSelectControl' => 'AphrontFormControl',
     'AphrontFormStaticControl' => 'AphrontFormControl',
     'AphrontFormSubmitControl' => 'AphrontFormControl',
     'AphrontFormTextAreaControl' => 'AphrontFormControl',
     'AphrontFormTextControl' => 'AphrontFormControl',
     'AphrontFormTokenizerControl' => 'AphrontFormControl',
     'AphrontFormView' => 'AphrontView',
     'AphrontMySQLDatabaseConnection' => 'AphrontDatabaseConnection',
     'AphrontNullView' => 'AphrontView',
     'AphrontPageView' => 'AphrontView',
     'AphrontPanelView' => 'AphrontView',
     'AphrontQueryConnectionException' => 'AphrontQueryException',
     'AphrontQueryConnectionLostException' => 'AphrontQueryRecoverableException',
     'AphrontQueryCountException' => 'AphrontQueryException',
     'AphrontQueryDuplicateKeyException' => 'AphrontQueryException',
     'AphrontQueryObjectMissingException' => 'AphrontQueryException',
     'AphrontQueryParameterException' => 'AphrontQueryException',
     'AphrontQueryRecoverableException' => 'AphrontQueryException',
     'AphrontRedirectException' => 'AphrontException',
     'AphrontRedirectResponse' => 'AphrontResponse',
     'AphrontRequestFailureView' => 'AphrontView',
     'AphrontSideNavView' => 'AphrontView',
     'AphrontTableView' => 'AphrontView',
     'AphrontWebpageResponse' => 'AphrontResponse',
     'CelerityResourceController' => 'AphrontController',
     'ConduitAPI_conduit_connect_Method' => 'ConduitAPIMethod',
     'ConduitAPI_differential_creatediff_Method' => 'ConduitAPIMethod',
     'ConduitAPI_differential_setdiffproperty_Method' => 'ConduitAPIMethod',
     'ConduitAPI_file_upload_Method' => 'ConduitAPIMethod',
     'ConduitAPI_user_find_Method' => 'ConduitAPIMethod',
     'DarkConsoleController' => 'PhabricatorController',
     'DarkConsoleErrorLogPlugin' => 'DarkConsolePlugin',
     'DarkConsoleRequestPlugin' => 'DarkConsolePlugin',
     'DarkConsoleServicesPlugin' => 'DarkConsolePlugin',
     'DarkConsoleXHProfPlugin' => 'DarkConsolePlugin',
     'DifferentialAddCommentView' => 'AphrontView',
     'DifferentialCCWelcomeMail' => 'DifferentialReviewRequestMail',
     'DifferentialChangeset' => 'DifferentialDAO',
     'DifferentialChangesetDetailView' => 'AphrontView',
     'DifferentialChangesetListView' => 'AphrontView',
     'DifferentialChangesetViewController' => 'DifferentialController',
     'DifferentialComment' => 'DifferentialDAO',
     'DifferentialCommentMail' => 'DifferentialMail',
     'DifferentialCommentPreviewController' => 'DifferentialController',
     'DifferentialCommentSaveController' => 'DifferentialController',
     'DifferentialController' => 'PhabricatorController',
     'DifferentialDAO' => 'PhabricatorLiskDAO',
     'DifferentialDiff' => 'DifferentialDAO',
     'DifferentialDiffContentMail' => 'DifferentialMail',
     'DifferentialDiffProperty' => 'DifferentialDAO',
     'DifferentialDiffTableOfContentsView' => 'AphrontView',
     'DifferentialDiffViewController' => 'DifferentialController',
     'DifferentialHunk' => 'DifferentialDAO',
     'DifferentialInlineComment' => 'DifferentialDAO',
     'DifferentialInlineCommentEditController' => 'DifferentialController',
     'DifferentialInlineCommentPreviewController' => 'DifferentialController',
     'DifferentialInlineCommentView' => 'AphrontView',
     'DifferentialNewDiffMail' => 'DifferentialReviewRequestMail',
     'DifferentialReviewRequestMail' => 'DifferentialMail',
     'DifferentialRevision' => 'DifferentialDAO',
     'DifferentialRevisionCommentListView' => 'AphrontView',
     'DifferentialRevisionCommentView' => 'AphrontView',
     'DifferentialRevisionDetailView' => 'AphrontView',
     'DifferentialRevisionEditController' => 'DifferentialController',
     'DifferentialRevisionListController' => 'DifferentialController',
     'DifferentialRevisionUpdateHistoryView' => 'AphrontView',
     'DifferentialRevisionViewController' => 'DifferentialController',
     'Phabricator404Controller' => 'PhabricatorController',
     'PhabricatorAuthController' => 'PhabricatorController',
     'PhabricatorConduitAPIController' => 'PhabricatorConduitController',
     'PhabricatorConduitConnectionLog' => 'PhabricatorConduitDAO',
     'PhabricatorConduitConsoleController' => 'PhabricatorConduitController',
     'PhabricatorConduitController' => 'PhabricatorController',
     'PhabricatorConduitDAO' => 'PhabricatorLiskDAO',
     'PhabricatorConduitLogController' => 'PhabricatorConduitController',
     'PhabricatorConduitMethodCallLog' => 'PhabricatorConduitDAO',
     'PhabricatorController' => 'AphrontController',
     'PhabricatorDirectoryCategory' => 'PhabricatorDirectoryDAO',
     'PhabricatorDirectoryCategoryDeleteController' => 'PhabricatorDirectoryController',
     'PhabricatorDirectoryCategoryEditController' => 'PhabricatorDirectoryController',
     'PhabricatorDirectoryCategoryListController' => 'PhabricatorDirectoryController',
     'PhabricatorDirectoryController' => 'PhabricatorController',
     'PhabricatorDirectoryDAO' => 'PhabricatorLiskDAO',
     'PhabricatorDirectoryItem' => 'PhabricatorDirectoryDAO',
     'PhabricatorDirectoryItemDeleteController' => 'PhabricatorDirectoryController',
     'PhabricatorDirectoryItemEditController' => 'PhabricatorDirectoryController',
     'PhabricatorDirectoryItemListController' => 'PhabricatorDirectoryController',
     'PhabricatorDirectoryMainController' => 'PhabricatorDirectoryController',
     'PhabricatorEmailLoginController' => 'PhabricatorAuthController',
     'PhabricatorEmailTokenController' => 'PhabricatorAuthController',
     'PhabricatorFacebookAuthController' => 'PhabricatorAuthController',
     'PhabricatorFacebookAuthDiagnosticsController' => 'PhabricatorAuthController',
     'PhabricatorFile' => 'PhabricatorFileDAO',
     'PhabricatorFileController' => 'PhabricatorController',
     'PhabricatorFileDAO' => 'PhabricatorLiskDAO',
     'PhabricatorFileListController' => 'PhabricatorFileController',
     'PhabricatorFileStorageBlob' => 'PhabricatorFileDAO',
     'PhabricatorFileUploadController' => 'PhabricatorFileController',
     'PhabricatorFileViewController' => 'PhabricatorFileController',
     'PhabricatorLiskDAO' => 'LiskDAO',
     'PhabricatorLoginController' => 'PhabricatorAuthController',
     'PhabricatorLogoutController' => 'PhabricatorAuthController',
     'PhabricatorMailImplementationPHPMailerLiteAdapter' => 'PhabricatorMailImplementationAdapter',
     'PhabricatorMetaMTAController' => 'PhabricatorController',
     'PhabricatorMetaMTADAO' => 'PhabricatorLiskDAO',
     'PhabricatorMetaMTAListController' => 'PhabricatorMetaMTAController',
     'PhabricatorMetaMTAMail' => 'PhabricatorMetaMTADAO',
     'PhabricatorMetaMTAMailingList' => 'PhabricatorMetaMTADAO',
     'PhabricatorMetaMTAMailingListEditController' => 'PhabricatorMetaMTAController',
     'PhabricatorMetaMTAMailingListsController' => 'PhabricatorMetaMTAController',
     'PhabricatorMetaMTASendController' => 'PhabricatorMetaMTAController',
     'PhabricatorMetaMTAViewController' => 'PhabricatorMetaMTAController',
     'PhabricatorPHID' => 'PhabricatorPHIDDAO',
     'PhabricatorPHIDAllocateController' => 'PhabricatorPHIDController',
     'PhabricatorPHIDController' => 'PhabricatorController',
     'PhabricatorPHIDDAO' => 'PhabricatorLiskDAO',
     'PhabricatorPHIDListController' => 'PhabricatorPHIDController',
     'PhabricatorPHIDLookupController' => 'PhabricatorPHIDController',
     'PhabricatorPHIDType' => 'PhabricatorPHIDDAO',
     'PhabricatorPHIDTypeEditController' => 'PhabricatorPHIDController',
     'PhabricatorPHIDTypeListController' => 'PhabricatorPHIDController',
     'PhabricatorPeopleController' => 'PhabricatorController',
     'PhabricatorPeopleEditController' => 'PhabricatorPeopleController',
     'PhabricatorPeopleListController' => 'PhabricatorPeopleController',
     'PhabricatorPeopleProfileController' => 'PhabricatorPeopleController',
     'PhabricatorStandardPageView' => 'AphrontPageView',
     'PhabricatorTypeaheadCommonDatasourceController' => 'PhabricatorTypeaheadDatasourceController',
     'PhabricatorTypeaheadDatasourceController' => 'PhabricatorController',
     'PhabricatorUser' => 'PhabricatorUserDAO',
     'PhabricatorUserDAO' => 'PhabricatorLiskDAO',
     'PhabricatorXHProfController' => 'PhabricatorController',
     'PhabricatorXHProfProfileController' => 'PhabricatorXHProfController',
     'PhabricatorXHProfProfileSymbolView' => 'AphrontView',
     'PhabricatorXHProfProfileTopLevelView' => 'AphrontView',
   ),
   'requires_interface' =>
   array(
   ),
 ));
diff --git a/src/aphront/default/configuration/AphrontDefaultApplicationConfiguration.php b/src/aphront/default/configuration/AphrontDefaultApplicationConfiguration.php
index 52b9040d22..e78c6217b7 100644
--- a/src/aphront/default/configuration/AphrontDefaultApplicationConfiguration.php
+++ b/src/aphront/default/configuration/AphrontDefaultApplicationConfiguration.php
@@ -1,210 +1,211 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * @group aphront
  */
 class AphrontDefaultApplicationConfiguration
   extends AphrontApplicationConfiguration {
 
   public function getApplicationName() {
     return 'aphront-default';
   }
 
   public function getURIMap() {
     return array(
       '/repository/' => array(
         '$'                     => 'RepositoryListController',
         'new/$'                 => 'RepositoryEditController',
         'edit/(?<id>\d+)/$'     => 'RepositoryEditController',
         'delete/(?<id>\d+)/$'   => 'RepositoryDeleteController',
       ),
       '/' => array(
         '$'                     => 'PhabricatorDirectoryMainController',
       ),
       '/directory/' => array(
         'item/$'
           => 'PhabricatorDirectoryItemListController',
         'item/edit/(?:(?<id>\d+)/)?$'
           => 'PhabricatorDirectoryItemEditController',
         'item/delete/(?<id>\d+)/'
           => 'PhabricatorDirectoryItemDeleteController',
         'category/$'
           => 'PhabricatorDirectoryCategoryListController',
         'category/edit/(?:(?<id>\d+)/)?$'
           => 'PhabricatorDirectoryCategoryEditController',
         'category/delete/(?<id>\d+)/'
           => 'PhabricatorDirectoryCategoryDeleteController',
       ),
       '/file/' => array(
         '$' => 'PhabricatorFileListController',
         'upload/$' => 'PhabricatorFileUploadController',
         '(?<view>info)/(?<phid>[^/]+)/' => 'PhabricatorFileViewController',
         '(?<view>view)/(?<phid>[^/]+)/' => 'PhabricatorFileViewController',
         '(?<view>download)/(?<phid>[^/]+)/' => 'PhabricatorFileViewController',
       ),
       '/phid/' => array(
         '$' => 'PhabricatorPHIDLookupController',
         'list/$' => 'PhabricatorPHIDListController',
         'type/$' => 'PhabricatorPHIDTypeListController',
         'type/edit/(?:(?<id>\d+)/)?$' => 'PhabricatorPHIDTypeEditController',
         'new/$' => 'PhabricatorPHIDAllocateController',
       ),
       '/people/' => array(
         '$' => 'PhabricatorPeopleListController',
         'edit/(?:(?<username>\w+)/)?$' => 'PhabricatorPeopleEditController',
       ),
       '/p/(?<username>\w+)/$' => 'PhabricatorPeopleProfileController',
       '/conduit/' => array(
         '$' => 'PhabricatorConduitConsoleController',
         'method/(?<method>[^/]+)$' => 'PhabricatorConduitConsoleController',
         'log/$' => 'PhabricatorConduitLogController',
       ),
       '/api/(?<method>[^/]+)$' => 'PhabricatorConduitAPIController',
 
 
       '/D(?<id>\d+)' => 'DifferentialRevisionViewController',
       '/differential/' => array(
         '$' => 'DifferentialRevisionListController',
         'filter/(?<filter>\w+)/$' => 'DifferentialRevisionListController',
         'diff/(?<id>\d+)/$'       => 'DifferentialDiffViewController',
         'changeset/$'  => 'DifferentialChangesetViewController',
         'revision/edit/(?:(?<id>\d+)/)?$'
           => 'DifferentialRevisionEditController',
         'comment/' => array(
           'preview/(?<id>\d+)/$' => 'DifferentialCommentPreviewController',
           'save/$' => 'DifferentialCommentSaveController',
           'inline/' => array(
             'preview/(?<id>\d+)/$' =>
               'DifferentialInlineCommentPreviewController',
             'edit/(?<id>\d+)/$' => 'DifferentialInlineCommentEditController',
           ),
         ),
       ),
 
       '/res/' => array(
         '(?<package>pkg/)?(?<hash>[a-f0-9]{8})/(?<path>.+\.(?:css|js))$'
           => 'CelerityResourceController',
       ),
 
       '/typeahead/' => array(
         'common/(?<type>\w+)/$'
           => 'PhabricatorTypeaheadCommonDatasourceController',
       ),
 
       '/mail/' => array(
         '$' => 'PhabricatorMetaMTAListController',
         'send/$' => 'PhabricatorMetaMTASendController',
         'view/(?<id>\d+)/$' => 'PhabricatorMetaMTAViewController',
         'lists/$' => 'PhabricatorMetaMTAMailingListsController',
         'lists/edit/(?:(?<id>\d+)/)?$'
           => 'PhabricatorMetaMTAMailingListEditController',
       ),
 
       '/login/' => array(
         '$' => 'PhabricatorLoginController',
         'email/$' => 'PhabricatorEmailLoginController',
         'etoken/(?<token>\w+)/$' => 'PhabricatorEmailTokenController',
       ),
       '/logout/$' => 'PhabricatorLogoutController',
       '/facebook-auth/' => array(
         '$' => 'PhabricatorFacebookAuthController',
         'diagnose/$' => 'PhabricatorFacebookAuthDiagnosticsController',
       ),
 
       '/xhprof/' => array(
         'profile/(?<phid>[^/]+)/$' => 'PhabricatorXHProfProfileController',
       ),
 
       '/~/' => 'DarkConsoleController',
     );
   }
 
   public function buildRequest() {
     $request = new AphrontRequest($this->getHost(), $this->getPath());
     $request->setRequestData($_GET + $_POST);
     $request->setApplicationConfiguration($this);
     return $request;
   }
 
   public function handleException(Exception $ex) {
 
     $class    = phutil_escape_html(get_class($ex));
     $message  = phutil_escape_html($ex->getMessage());
 
     $content =
       '<div class="aphront-unhandled-exception">'.
         '<h1>Unhandled Exception "'.$class.'": '.$message.'</h1>'.
         '<code>'.phutil_escape_html((string)$ex).'</code>'.
       '</div>';
 
     $view = new PhabricatorStandardPageView();
     $view->setRequest($this->getRequest());
     $view->appendChild($content);
 
     $response = new AphrontWebpageResponse();
     $response->setContent($view->render());
 
     return $response;
   }
 
   public function willSendResponse(AphrontResponse $response) {
     $request = $this->getRequest();
     if ($response instanceof AphrontDialogResponse) {
       if (!$request->isAjax()) {
         $view = new PhabricatorStandardPageView();
+        $view->setRequest($request);
         $view->appendChild(
           '<div style="padding: 2em 0;">'.
             $response->buildResponseString().
           '</div>');
         $response = new AphrontWebpageResponse();
         $response->setContent($view->render());
         return $response;
       } else {
         return id(new AphrontAjaxResponse())
           ->setContent(array(
             'dialog' => $response->buildResponseString(),
           ));
       }
     } else if ($response instanceof Aphront404Response) {
 
       $failure = new AphrontRequestFailureView();
       $failure->setHeader('404 Not Found');
       $failure->appendChild(
         '<p>The page you requested was not found.</p>');
 
       $view = new PhabricatorStandardPageView();
       $view->setTitle('404 Not Found');
       $view->setRequest($this->getRequest());
       $view->appendChild($failure);
 
       $response = new AphrontWebpageResponse();
       $response->setContent($view->render());
       $response->setHTTPResponseCode(404);
       return $response;
     }
 
     return $response;
   }
 
   public function build404Controller() {
     return array(new Phabricator404Controller($this->getRequest()), array());
   }
 
 
 }
diff --git a/src/applications/differential/controller/inlinecommentedit/DifferentialInlineCommentEditController.php b/src/applications/differential/controller/inlinecommentedit/DifferentialInlineCommentEditController.php
index 7134a83220..23315323bc 100644
--- a/src/applications/differential/controller/inlinecommentedit/DifferentialInlineCommentEditController.php
+++ b/src/applications/differential/controller/inlinecommentedit/DifferentialInlineCommentEditController.php
@@ -1,193 +1,194 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class DifferentialInlineCommentEditController extends DifferentialController {
 
   private $revisionID;
 
   public function willProcessRequest(array $data) {
     $this->revisionID = $data['id'];
   }
 
   public function processRequest() {
     $request = $this->getRequest();
 
     $changeset = $request->getInt('changeset');
     $is_new = $request->getInt('is_new');
     $on_right = $request->getInt('on_right');
     $number = $request->getInt('number');
     $length = $request->getInt('length');
     $text = $request->getStr('text');
     $op = $request->getStr('op');
     $inline_id = $request->getInt('id');
 
     $user = $request->getUser();
 
     $submit_uri = '/differential/comment/inline/edit/'.$this->revisionID.'/';
 
     $edit_dialog = new AphrontDialogView();
     $edit_dialog->setUser($user);
     $edit_dialog->setSubmitURI($submit_uri);
 
     $edit_dialog->addHiddenInput('on_right', $on_right);
 
     $edit_dialog->addSubmitButton();
     $edit_dialog->addCancelButton('#');
 
     $inline = null;
     if ($inline_id) {
       $inline = id(new DifferentialInlineComment())
         ->load($inline_id);
 
       if (!$inline ||
           $inline->getAuthorPHID() != $user->getPHID() ||
           $inline->getCommentID() ||
           $inline->getRevisionID() != $this->revisionID) {
         throw new Exception("That comment is not editable!");
       }
     }
 
     switch ($op) {
       case 'delete':
         if (!$inline) {
           return new Aphront400Response();
         }
 
         if ($request->isFormPost()) {
           $inline->delete();
           return $this->buildDeletedResponse();
         }
 
         $edit_dialog->setTitle('Really delete this comment?');
         $edit_dialog->addHiddenInput('id', $inline_id);
         $edit_dialog->addHiddenInput('op', 'delete');
         $edit_dialog->appendChild(
           '<p>Delete this inline comment?</p>');
 
         return id(new AphrontDialogResponse())->setDialog($edit_dialog);
       case 'edit':
         if (!$inline) {
           return new Aphront400Response();
         }
 
         if ($request->isFormPost()) {
           if (strlen($text)) {
             $inline->setContent($text);
             $inline->setCache(null);
             $inline->save();
             return $this->buildRenderedCommentResponse(
               $inline,
               $on_right);
           } else {
             $inline->delete();
             return $this->buildDeletedResponse();
           }
         }
 
         $edit_dialog->setTitle('Edit Inline Comment');
 
         $edit_dialog->addHiddenInput('id', $inline_id);
         $edit_dialog->addHiddenInput('op', 'edit');
 
         $edit_dialog->appendChild(
           $this->renderTextArea(
             $inline->getContent()));
 
         return id(new AphrontDialogResponse())->setDialog($edit_dialog);
       case 'create':
 
         if (!$request->isFormPost() || !strlen($text)) {
           return new AphrontAjaxResponse();
         }
 
         $inline = id(new DifferentialInlineComment())
           ->setRevisionID($this->revisionID)
           ->setChangesetID($changeset)
           ->setCommentID(null)
           ->setAuthorPHID($user->getPHID())
           ->setLineNumber($number)
           ->setLineLength($length)
           ->setIsNewFile($is_new)
           ->setContent($text)
           ->save();
 
         return $this->buildRenderedCommentResponse($inline, $on_right);
       default:
         $edit_dialog->setTitle('New Inline Comment');
 
         $edit_dialog->addHiddenInput('op', 'create');
         $edit_dialog->addHiddenInput('changeset', $changeset);
         $edit_dialog->addHiddenInput('is_new', $is_new);
         $edit_dialog->addHiddenInput('number', $number);
         $edit_dialog->addHiddenInput('length', $length);
 
         $edit_dialog->appendChild($this->renderTextArea(''));
 
         return id(new AphrontDialogResponse())->setDialog($edit_dialog);
     }
   }
 
   private function buildRenderedCommentResponse(
     DifferentialInlineComment $inline,
     $on_right) {
 
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $factory = new DifferentialMarkupEngineFactory();
     $engine = $factory->newDifferentialCommentMarkupEngine();
 
     $phids = array($user->getPHID());
 
     $handles = id(new PhabricatorObjectHandleData($phids))
       ->loadHandles();
 
     $view = new DifferentialInlineCommentView();
     $view->setInlineComment($inline);
     $view->setOnRight($on_right);
     $view->setBuildScaffolding(true);
     $view->setMarkupEngine($engine);
     $view->setHandles($handles);
     $view->setEditable(true);
 
     return id(new AphrontAjaxResponse())
       ->setContent(
         array(
           'inlineCommentID' => $inline->getID(),
           'markup'          => $view->render(),
         ));
   }
 
   private function buildDeletedResponse() {
     return id(new AphrontAjaxResponse())
       ->setContent(
         array(
           'markup'          => '',
         ));
   }
 
   private function renderTextArea($text) {
     return phutil_render_tag(
       'textarea',
       array(
+        'class' => 'differential-inline-comment-edit-textarea',
         'name' => 'text',
       ),
       $text);
   }
 
 }
diff --git a/src/applications/differential/controller/revisionedit/DifferentialRevisionEditController.php b/src/applications/differential/controller/revisionedit/DifferentialRevisionEditController.php
index 5f4822db12..3e1ce67956 100644
--- a/src/applications/differential/controller/revisionedit/DifferentialRevisionEditController.php
+++ b/src/applications/differential/controller/revisionedit/DifferentialRevisionEditController.php
@@ -1,208 +1,227 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class DifferentialRevisionEditController extends DifferentialController {
 
   private $id;
 
   public function willProcessRequest(array $data) {
     $this->id = idx($data, 'id');
   }
 
   public function processRequest() {
 
     $request = $this->getRequest();
 
     if (!$this->id) {
       $this->id = $request->getInt('revisionID');
     }
 
     if ($this->id) {
       $revision = id(new DifferentialRevision())->load($this->id);
       if (!$revision) {
         return new Aphront404Response();
       }
     } else {
       $revision = new DifferentialRevision();
     }
 
     $diff_id = $request->getInt('diffID');
     if ($diff_id) {
       $diff = id(new DifferentialDiff())->load($diff_id);
       if (!$diff) {
         return new Aphront404Response();
       }
       if ($diff->getRevisionID()) {
         // TODO: Redirect?
         throw new Exception("This diff is already attached to a revision!");
       }
     } else {
       $diff = null;
     }
 
     $e_title = true;
     $e_testplan = true;
     $errors = array();
 
     $revision->loadRelationships();
 
     if ($request->isFormPost() && !$request->getStr('viaDiffView')) {
       $revision->setTitle($request->getStr('title'));
       $revision->setSummary($request->getStr('summary'));
       $revision->setTestPlan($request->getStr('testplan'));
       $revision->setBlameRevision($request->getStr('blame'));
       $revision->setRevertPlan($request->getStr('revert'));
 
       if (!strlen(trim($revision->getTitle()))) {
         $errors[] = 'You must provide a title.';
         $e_title = 'Required';
       }
 
       if (!strlen(trim($revision->getTestPlan()))) {
         $errors[] = 'You must provide a test plan.';
         $e_testplan = 'Required';
       }
 
       $user_phid = $request->getUser()->getPHID();
 
       if (in_array($user_phid, $request->getArr('reviewers'))) {
         $errors[] = 'You may not review your own revision.';
       }
 
       if (!$errors) {
         $editor = new DifferentialRevisionEditor($revision, $user_phid);
         if ($diff) {
           $editor->addDiff($diff, $request->getStr('comments'));
         }
         $editor->setCCPHIDs($request->getArr('cc'));
         $editor->setReviewers($request->getArr('reviewers'));
         $editor->save();
 
         return id(new AphrontRedirectResponse())
           ->setURI('/D'.$revision->getID());
       }
 
       $reviewer_phids = $request->getArr('reviewers');
       $cc_phids = $request->getArr('cc');
     } else {
       $reviewer_phids = $revision->getReviewers();
       $cc_phids = $revision->getCCPHIDs();
     }
 
     $phids = array_merge($reviewer_phids, $cc_phids);
     $phids = array_unique($phids);
 
     $handles = id(new PhabricatorObjectHandleData($phids))
       ->loadHandles();
     $handles = mpull($handles, 'getFullName', 'getPHID');
 
     $reviewer_map = array_select_keys($handles, $reviewer_phids);
     $cc_map = array_select_keys($handles, $cc_phids);
 
     $form = new AphrontFormView();
     $form->setUser($request->getUser());
     if ($diff) {
       $form->addHiddenInput('diffID', $diff->getID());
     }
 
     if ($revision->getID()) {
       $form->setAction('/differential/revision/edit/'.$revision->getID().'/');
     } else {
       $form->setAction('/differential/revision/edit/');
     }
 
     $error_view = null;
     if ($errors) {
       $error_view = id(new AphrontErrorView())
         ->setTitle('Form Errors')
         ->setErrors($errors);
     }
 
+    if ($diff && $revision->getID()) {
+      $form
+        ->appendChild(
+          id(new AphrontFormTextAreaControl())
+            ->setLabel('Comments')
+            ->setName('comments')
+            ->setCaption("Explain what's new in this diff.")
+            ->setValue($request->getStr('comments')))
+        ->appendChild(
+          id(new AphrontFormSubmitControl())
+            ->setValue('Save'))
+        ->appendChild(
+          id(new AphrontFormDividerControl()));
+    }
+
     $form
       ->appendChild(
         id(new AphrontFormTextAreaControl())
           ->setLabel('Title')
           ->setName('title')
           ->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_SHORT)
           ->setValue($revision->getTitle())
           ->setError($e_title))
       ->appendChild(
         id(new AphrontFormTextAreaControl())
           ->setLabel('Summary')
           ->setName('summary')
           ->setValue($revision->getSummary()))
       ->appendChild(
         id(new AphrontFormTextAreaControl())
           ->setLabel('Test Plan')
           ->setName('testplan')
           ->setValue($revision->getTestPlan())
           ->setError($e_testplan))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setLabel('Reviewers')
           ->setName('reviewers')
           ->setDatasource('/typeahead/common/users/')
           ->setValue($reviewer_map))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setLabel('CC')
           ->setName('cc')
           ->setDatasource('/typeahead/common/mailable/')
           ->setValue($cc_map))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel('Blame Revision')
           ->setName('blame')
           ->setValue($revision->getBlameRevision())
           ->setCaption('Revision which broke the stuff which this '.
                        'change fixes.'))
       ->appendChild(
         id(new AphrontFormTextAreaControl())
           ->setLabel('Revert Plan')
           ->setName('revert')
           ->setValue($revision->getRevertPlan())
           ->setCaption('Special steps required to safely revert this change.'));
 
     $submit = id(new AphrontFormSubmitControl())
       ->setValue('Save');
     if ($diff) {
       $submit->addCancelButton('/differential/diff/'.$diff->getID().'/');
     } else {
       $submit->addCancelButton('/D'.$revision->getID());
     }
 
     $form->appendChild($submit);
 
     $panel = new AphrontPanelView();
     if ($revision->getID()) {
-      $panel->setHeader('Edit Differential Revision');
+      if ($diff) {
+        $panel->setHeader('Update Differential Revision');
+      } else {
+        $panel->setHeader('Edit Differential Revision');
+      }
     } else {
       $panel->setHeader('Create New Differential Revision');
     }
 
     $panel->appendChild($form);
     $panel->setWidth(AphrontPanelView::WIDTH_FORM);
 
     return $this->buildStandardPageResponse(
       array($error_view, $panel),
       array(
         'title' => 'Edit Differential Revision',
       ));
   }
 
 }
diff --git a/src/applications/differential/controller/revisionedit/__init__.php b/src/applications/differential/controller/revisionedit/__init__.php
index 805b2c0977..456f221fef 100644
--- a/src/applications/differential/controller/revisionedit/__init__.php
+++ b/src/applications/differential/controller/revisionedit/__init__.php
@@ -1,25 +1,26 @@
 <?php
 /**
  * This file is automatically generated. Lint this module to rebuild it.
  * @generated
  */
 
 
 
 phutil_require_module('phabricator', 'aphront/response/404');
 phutil_require_module('phabricator', 'aphront/response/redirect');
 phutil_require_module('phabricator', 'applications/differential/controller/base');
 phutil_require_module('phabricator', 'applications/differential/editor/revision');
 phutil_require_module('phabricator', 'applications/differential/storage/diff');
 phutil_require_module('phabricator', 'applications/differential/storage/revision');
 phutil_require_module('phabricator', 'applications/phid/handle/data');
 phutil_require_module('phabricator', 'view/form/base');
+phutil_require_module('phabricator', 'view/form/control/divider');
 phutil_require_module('phabricator', 'view/form/control/submit');
 phutil_require_module('phabricator', 'view/form/control/textarea');
 phutil_require_module('phabricator', 'view/form/error');
 phutil_require_module('phabricator', 'view/layout/panel');
 
 phutil_require_module('phutil', 'utils');
 
 
 phutil_require_source('DifferentialRevisionEditController.php');
diff --git a/src/applications/differential/controller/revisionview/DifferentialRevisionViewController.php b/src/applications/differential/controller/revisionview/DifferentialRevisionViewController.php
index b92c29e98f..ca96ea78a7 100644
--- a/src/applications/differential/controller/revisionview/DifferentialRevisionViewController.php
+++ b/src/applications/differential/controller/revisionview/DifferentialRevisionViewController.php
@@ -1,1609 +1,1614 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class DifferentialRevisionViewController extends DifferentialController {
 
   private $revisionID;
 
   public function willProcessRequest(array $data) {
     $this->revisionID = $data['id'];
   }
 
   public function processRequest() {
 
     $request = $this->getRequest();
 
     $revision = id(new DifferentialRevision())->load($this->revisionID);
     if (!$revision) {
       return new Aphront404Response();
     }
 
     $revision->loadRelationships();
 
     $diffs = $revision->loadDiffs();
 
     $diff_vs = $request->getInt('vs');
     $target = end($diffs);
 
     $diffs = mpull($diffs, null, 'getID');
     if (empty($diffs[$diff_vs])) {
       $diff_vs = null;
     }
 
     list($changesets, $vs_map) =
       $this->loadChangesetsAndVsMap($diffs, $diff_vs, $target);
 
     $comments = $revision->loadComments();
     $comments = array_merge(
       $this->getImplicitComments($revision),
       $comments);
 
     $inlines = $this->loadInlineComments($comments, $changesets);
 
     $object_phids = array_merge(
       $revision->getReviewers(),
       $revision->getCCPHIDs(),
       array(
         $revision->getAuthorPHID(),
         $request->getUser()->getPHID(),
       ),
       mpull($comments, 'getAuthorPHID'));
     $object_phids = array_unique($object_phids);
 
     $handles = id(new PhabricatorObjectHandleData($object_phids))
       ->loadHandles();
 
     $revision_detail = new DifferentialRevisionDetailView();
     $revision_detail->setRevision($revision);
 
     $properties = $this->getRevisionProperties($revision, $target, $handles);
     $revision_detail->setProperties($properties);
 
     $actions = $this->getRevisionActions($revision);
     $revision_detail->setActions($actions);
 
     $comment_view = new DifferentialRevisionCommentListView();
     $comment_view->setComments($comments);
     $comment_view->setHandles($handles);
     $comment_view->setInlineComments($inlines);
     $comment_view->setChangesets($changesets);
 
     $diff_history = new DifferentialRevisionUpdateHistoryView();
     $diff_history->setDiffs($diffs);
     $diff_history->setSelectedVersusDiffID($diff_vs);
     $diff_history->setSelectedDiffID($target->getID());
 
     $toc_view = new DifferentialDiffTableOfContentsView();
     $toc_view->setChangesets($changesets);
 
     $changeset_view = new DifferentialChangesetListView();
     $changeset_view->setChangesets($changesets);
     $changeset_view->setEditable(true);
     $changeset_view->setRevision($revision);
     $changeset_view->setVsMap($vs_map);
 
     $comment_form = new DifferentialAddCommentView();
     $comment_form->setRevision($revision);
     $comment_form->setActions($this->getRevisionCommentActions($revision));
     $comment_form->setActionURI('/differential/comment/save/');
     $comment_form->setUser($request->getUser());
 
     return $this->buildStandardPageResponse(
       '<div class="differential-primary-pane">'.
         $revision_detail->render().
         $comment_view->render().
         $diff_history->render().
         $toc_view->render().
         $changeset_view->render().
         $comment_form->render().
       '</div>',
       array(
         'title' => $revision->getTitle(),
       ));
   }
 
   private function getImplicitComments(DifferentialRevision $revision) {
 
     $template = new DifferentialComment();
     $template->setAuthorPHID($revision->getAuthorPHID());
     $template->setRevisionID($revision->getID());
     $template->setDateCreated($revision->getDateCreated());
 
     $comments = array();
 
     if (strlen($revision->getSummary())) {
       $summary_comment = clone $template;
       $summary_comment->setContent($revision->getSummary());
       $summary_comment->setAction(DifferentialAction::ACTION_SUMMARIZE);
       $comments[] = $summary_comment;
     }
 
     if (strlen($revision->getTestPlan())) {
       $testplan_comment = clone $template;
       $testplan_comment->setContent($revision->getTestPlan());
       $testplan_comment->setAction(DifferentialAction::ACTION_TESTPLAN);
       $comments[] = $testplan_comment;
     }
 
     return $comments;
   }
 
   private function getRevisionProperties(
     DifferentialRevision $revision,
     DifferentialDiff $diff,
     array $handles) {
 
     $properties = array();
 
     $status = $revision->getStatus();
     $status = DifferentialRevisionStatus::getNameForRevisionStatus($status);
     $properties['Revision Status'] = '<strong>'.$status.'</strong>';
 
     $author = $handles[$revision->getAuthorPHID()];
     $properties['Author'] = $author->renderLink();
 
     $properties['Reviewers'] = $this->renderHandleLinkList(
       array_select_keys(
         $handles,
         $revision->getReviewers()));
 
     $properties['CCs'] = $this->renderHandleLinkList(
       array_select_keys(
         $handles,
         $revision->getCCPHIDs()));
 
+    $host = $diff->getSourceMachine();
+    if ($host) {
+      $properties['Host'] = phutil_escape_html($host);
+    }
+
     $path = $diff->getSourcePath();
     if ($path) {
-      $branch = $diff->getBranch() ? ' (' . $diff->getBranch() . ')' : '';
-      $host = $diff->getSourceMachine();
-      if ($host) {
-        $host .= ':';
-      }
-      $properties['Path'] = phutil_escape_html("{$host}{$path} {$branch}");
+      $branch = $diff->getBranch() ? ' ('.$diff->getBranch().')' : '';
+      $properties['Path'] = phutil_escape_html("{$path} {$branch}");
     }
 
+    $lstar = DifferentialRevisionUpdateHistoryView::renderDiffLintStar($diff);
+    $lmsg = DifferentialRevisionUpdateHistoryView::getDiffLintMessage($diff);
+    $properties['Lint'] = $lstar.' '.$lmsg;
 
-    $properties['Lint'] = 'TODO';
-    $properties['Unit'] = 'TODO';
+    $ustar = DifferentialRevisionUpdateHistoryView::renderDiffUnitStar($diff);
+    $umsg = DifferentialRevisionUpdateHistoryView::getDiffUnitMessage($diff);
+    $properties['Unit'] = $ustar.' '.$umsg;
 
     return $properties;
   }
 
   private function getRevisionActions(DifferentialRevision $revision) {
     $viewer_phid = $this->getRequest()->getUser()->getPHID();
     $viewer_is_owner = ($revision->getAuthorPHID() == $viewer_phid);
     $viewer_is_reviewer = in_array($viewer_phid, $revision->getReviewers());
     $viewer_is_cc = in_array($viewer_phid, $revision->getCCPHIDs());
     $status = $revision->getStatus();
     $revision_id = $revision->getID();
     $revision_phid = $revision->getPHID();
 
     $links = array();
 
     if ($viewer_is_owner) {
       $links[] = array(
         'class' => 'revision-edit',
         'href'  => "/differential/revision/edit/{$revision_id}/",
         'name'  => 'Edit Revision',
       );
     }
 
     if (!$viewer_is_owner && !$viewer_is_reviewer) {
       $action = $viewer_is_cc ? 'rem' : 'add';
       $links[] = array(
         'class' => $viewer_is_cc ? 'subscribe-rem' : 'subscribe-add',
         'href'  => "/differential/subscribe/{$action}/{$revision_id}/",
         'name'  => $viewer_is_cc ? 'Unsubscribe' : 'Subscribe',
       );
     } else {
       $links[] = array(
         'class' => 'subscribe-rem unavailable',
         'name'  => 'Automatically Subscribed',
       );
     }
 
     $links[] = array(
       'class' => 'transcripts-metamta',
       'name'  => 'MetaMTA Transcripts',
       'href'  => "/mail/?phid={$revision_phid}",
     );
 
     return $links;
   }
 
 
   private function renderHandleLinkList(array $list) {
     if (empty($list)) {
       return '<em>None</em>';
     }
     return implode(', ', mpull($list, 'renderLink'));
   }
 
   private function getRevisionCommentActions(DifferentialRevision $revision) {
 
     $actions = array(
       DifferentialAction::ACTION_COMMENT => true,
     );
 
     $viewer_phid = $this->getRequest()->getUser()->getPHID();
     $viewer_is_owner = ($viewer_phid == $revision->getAuthorPHID());
 
     if ($viewer_is_owner) {
       switch ($revision->getStatus()) {
         case DifferentialRevisionStatus::NEEDS_REVIEW:
           $actions[DifferentialAction::ACTION_ABANDON] = true;
           break;
         case DifferentialRevisionStatus::NEEDS_REVISION:
         case DifferentialRevisionStatus::ACCEPTED:
           $actions[DifferentialAction::ACTION_ABANDON] = true;
           $actions[DifferentialAction::ACTION_REQUEST] = true;
           break;
         case DifferentialRevisionStatus::COMMITTED:
           break;
         case DifferentialRevisionStatus::ABANDONED:
           $actions[DifferentialAction::ACTION_RECLAIM] = true;
           break;
       }
     } else {
       switch ($revision->getStatus()) {
         case DifferentialRevisionStatus::NEEDS_REVIEW:
           $actions[DifferentialAction::ACTION_ACCEPT] = true;
           $actions[DifferentialAction::ACTION_REJECT] = true;
           break;
         case DifferentialRevisionStatus::NEEDS_REVISION:
           $actions[DifferentialAction::ACTION_ACCEPT] = true;
           break;
         case DifferentialRevisionStatus::ACCEPTED:
           $actions[DifferentialAction::ACTION_REJECT] = true;
           break;
         case DifferentialRevisionStatus::COMMITTED:
         case DifferentialRevisionStatus::ABANDONED:
           break;
       }
     }
 
     $actions[DifferentialAction::ACTION_ADDREVIEWERS] = true;
 
     return array_keys($actions);
   }
 
   private function loadInlineComments(array $comments, array &$changesets) {
 
     $inline_comments = array();
 
     $comment_ids = array_filter(mpull($comments, 'getID'));
     if (!$comment_ids) {
       return $inline_comments;
     }
 
     $inline_comments = id(new DifferentialInlineComment())
       ->loadAllWhere(
         'commentID in (%Ld)',
         $comment_ids);
 
     $load_changesets = array();
     foreach ($inline_comments as $inline) {
       $changeset_id = $inline->getChangesetID();
       if (isset($changesets[$changeset_id])) {
         continue;
       }
       $load_changesets[$changeset_id] = true;
     }
 
     $more_changesets = array();
     if ($load_changesets) {
       $changeset_ids = array_keys($load_changesets);
       $more_changesets += id(new DifferentialChangeset())
         ->loadAllWhere(
           'id IN (%Ld)',
           $changeset_ids);
     }
 
     if ($more_changesets) {
       $changesets += $more_changesets;
       $changesets = msort($changesets, 'getSortKey');
     }
 
     return $inline_comments;
   }
 
   private function loadChangesetsAndVsMap(array $diffs, $diff_vs, $target) {
     $load_ids = array();
     if ($diff_vs) {
       $load_ids[] = $diff_vs;
     }
     $load_ids[] = $target->getID();
 
     $raw_changesets = id(new DifferentialChangeset())
       ->loadAllWhere(
         'diffID IN (%Ld)',
         $load_ids);
     $changeset_groups = mgroup($raw_changesets, 'getDiffID');
 
     $changesets = idx($changeset_groups, $target->getID(), array());
     $changesets = mpull($changesets, null, 'getID');
 
     $vs_map = array();
     if ($diff_vs) {
       $vs_changesets = idx($changeset_groups, $diff_vs, array());
       $vs_changesets = mpull($vs_changesets, null, 'getFilename');
       foreach ($changesets as $key => $changeset) {
         $file = $changeset->getFilename();
         if (isset($vs_changesets[$file])) {
           $vs_map[$changeset->getID()] = $vs_changesets[$file]->getID();
           unset($vs_changesets[$file]);
         }
       }
       foreach ($vs_changesets as $changeset) {
         $changesets[$changeset->getID()] = $changeset;
         $vs_map[$changeset->getID()] = -1;
       }
     }
 
     $changesets = msort($changesets, 'getSortKey');
 
     return array($changesets, $vs_map);
   }
 
 }
 /*
 
 
   protected function getRevisionActions(DifferentialRevision $revision) {
 
     $viewer_id = $this->getRequest()->getViewerContext()->getUserID();
     $viewer_is_owner = ($viewer_id == $revision->getOwnerID());
     $viewer_is_reviewer =
       ((array_search($viewer_id, $revision->getReviewers())) !== false);
     $viewer_is_cc =
       ((array_search($viewer_id, $revision->getCCFBIDs())) !== false);
     $status = $revision->getStatus();
 
     $links = array();
 
     if (!$viewer_is_owner && !$viewer_is_reviewer) {
       $action = $viewer_is_cc
         ? 'rem'
         : 'add';
       $revision_id = $revision->getID();
       $href = "/differential/subscribe/{$action}/{$revision_id}";
       $links[] = array(
         $viewer_is_cc ? 'subscribe-disabled' : 'subscribe-enabled',
         <a href={$href}>{$viewer_is_cc ? 'Unsubscribe' : 'Subscribe'}</a>,
       );
     } else {
       $links[] = array(
         'subscribe-disabled unavailable',
         <a>Automatically Subscribed</a>,
       );
     }
 
     $blast_uri = RedirectURI(
       '/intern/differential/?action=tasks&fbid='.$revision->getFBID())
       ->setTier('intern');
     $links[] = array(
       'tasks',
       <a href={$blast_uri}>Edit Tasks</a>,
     );
 
     $engineering_repository_id = RepositoryRef::getByCallsign('E')->getID();
     $svn_revision = $revision->getSVNRevision();
     if ($status == DifferentialConstants::COMMITTED &&
         $svn_revision &&
         $revision->getRepositoryID() == $engineering_repository_id) {
       $href = '/intern/push/request.php?rev='.$svn_revision;
       $href = RedirectURI($href)->setTier('intern');
       $links[] = array(
         'merge',
         <a href={$href} id="ask_for_merge_link">Ask for Merge</a>,
       );
     }
 
     $links[] = array(
       'herald-transcript',
       <a href={"/herald/transcript/?fbid=".$revision->getFBID()}
         >Herald Transcripts</a>,
     );
     $links[] = array(
       'metamta-transcript',
       <a href={"/mail/?view=all&fbid=".$revision->getFBID()}
         >MetaMTA Transcripts</a>,
     );
 
 
     $list = <ul class="differential-actions" />;
     foreach ($links as $link) {
       list($class, $tag) = $link;
       $list->appendChild(<li class={$class}>{$tag}</li>);
     }
 
     return $list;
 
 
 
 /*
 // TODO
 //    $sandcastle = $this->getSandcastleURI($diff);
 //    if ($sandcastle) {
 //      $fields['Sandcastle'] = <a href={$sandcastle}>{$sandcastle}</a>;
 //    }
 
     $path = $diff->getSourcePath();
     if ($path) {
       $host = $diff->getSourceMachine();
       $branch = $diff->getGitBranch() ? ' (' . $diff->getGitBranch() . ')' : '';
 
       if ($host) {
 // TODO
 //        $user = $handles[$this->getRequest()->getViewerContext()->getUserID()]
 //          ->getName();
         $user = 'TODO';
         $fields['Path'] =
           <x:frag>
             <a href={"ssh://{$user}@{$host}"}>{$host}</a>:{$path}{$branch}
           </x:frag>;
       } else {
         $fields['Path'] = $path;
       }
     }
 
 
     $ccs = $revision->getCCFBIDs();
     if ($ccs) {
       $links = array();
       foreach ($ccs as $cc) {
         $links[] = <tools:handle handle={$handles[$cc]}
                                    link={true} />;
       }
       $fields['CCs'] = array_implode(', ', $links);
     }
 
     $blame_rev = $revision->getSvnBlameRevision();
     if ($blame_rev) {
       if ($revision->getRepositoryRef() && is_numeric($blame_rev)) {
         $ref = new RevisionRef($revision->getRepositoryRef(), $blame_rev);
         $fields['Blame Revision'] =
           <a href={URI($ref->getDetailURL())}>
             {$ref->getName()}
           </a>;
       } else {
         $fields['Blame Revision'] = $blame_rev;
       }
     }
 
     $tasks = $revision->getTaskHandles();
 
     if ($tasks) {
       $links = array();
       foreach ($tasks as $task) {
         $links[] = <tools:handle handle={$task} link={true} />;
       }
       $fields['Tasks'] = array_implode(<br />, $links);
     }
 
     $bugzilla_id = $revision->getBugzillaID();
     if ($bugzilla_id) {
       $href = 'http://bugs.developers.facebook.com/show_bug.cgi?id='.
         $bugzilla_id;
       $fields['Bugzilla'] = <a href={$href}>{'#'.$bugzilla_id}</a>;
     }
 
     $fields['Apply Patch'] = <tt>arc patch --revision {$revision->getID()}</tt>;
 
     if ($diff->getParentRevisionID()) {
       $parent = id(new DifferentialRevision())->load(
         $diff->getParentRevisionID());
       if ($parent) {
         $fields['Depends On'] =
           <a href={$parent->getURI()}>
             D{$parent->getID()}: {$parent->getName()}
           </a>;
       }
     }
 
     $star = <span class="star">{"\xE2\x98\x85"}</span>;
 
     Javelin::initBehavior('differential-star-more');
 
     switch ($diff->getLinted()) {
       case Diff::LINT_FAIL:
         $more = $this->renderDiffPropertyMoreLink($diff, 'lint');
         $fields['Lint'] =
           <x:frag>
             <span class="star-warn">{$star} Lint Failures</span>
             {$more}
           </x:frag>;
         break;
       case Diff::LINT_WARNINGS:
         $more = $this->renderDiffPropertyMoreLink($diff, 'lint');
         $fields['Lint'] =
           <x:frag>
             <span class="star-warn">{$star} Lint Warnings</span>
             {$more}
           </x:frag>;
         break;
       case Diff::LINT_OKAY:
         $fields['Lint'] =
           <span class="star-okay">{$star} Lint Free</span>;
         break;
       default:
       case Diff::LINT_NO:
         $fields['Lint'] =
           <span class="star-none">{$star} Not Linted</span>;
         break;
     }
 
     $unit_details = false;
     switch ($diff->getUnitTested()) {
       case Diff::UNIT_FAIL:
         $fields['Unit Tests'] =
             <span class="star-warn">{$star} Unit Test Failures</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_WARN:
         $fields['Unit Tests'] =
             <span class="star-warn">{$star} Unit Test Warnings</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_OKAY:
         $fields['Unit Tests'] =
           <span class="star-okay">{$star} Unit Tests Passed</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_NO_TESTS:
         $fields['Unit Tests'] =
           <span class="star-none">{$star} No Test Coverage</span>;
         break;
       case Diff::UNIT_NO:
       default:
         $fields['Unit Tests'] =
           <span class="star-none">{$star} Not Unit Tested</span>;
         break;
     }
 
     if ($unit_details) {
       $fields['Unit Tests'] =
         <x:frag>
           {$fields['Unit Tests']}
           {$this->renderDiffPropertyMoreLink($diff, 'unit')}
         </x:frag>;
     }
 
     $platform_impact = $revision->getPlatformImpact();
     if ($platform_impact) {
       $fields['Platform Impact'] =
         <text linebreaks="true">{$platform_impact}</text>;
     }
 
     return $fields;
   }
 
 
 }
 
 /*
 
 
 
   protected function getSandcastleURI(Diff $diff) {
     $uri = $this->getDiffProperty($diff, 'facebook:sandcastle_uri');
     if (!$uri) {
       $uri = $diff->getSandboxURL();
     }
     return $uri;
   }
 
   protected function getDiffProperty(Diff $diff, $property, $default = null) {
     $diff_id = $diff->getID();
     if (empty($this->diffProperties[$diff_id])) {
       $props = id(new DifferentialDiffProperty())
         ->loadAllWhere('diffID = %s', $diff_id);
       $dict = array_pull($props, 'getData', 'getName');
       $this->diffProperties[$diff_id] = $dict;
     }
     return idx($this->diffProperties[$diff_id], $property, $default);
   }
 
   public function process() {
     $uri = $this->getRequest()->getPath();
     if (starts_with($uri, '/d')) {
       return <alite:redirect uri={strtoupper($uri)}/>;
     }
 
     $revision = id(new DifferentialRevision())->load($this->revisionID);
     if (!$revision) {
       throw new Exception("Bad revision ID.");
     }
 
     $diffs = id(new Diff())->loadAllWhere(
       'revisionID = %d',
       $revision->getID());
     $diffs = array_psort($diffs, 'getID');
 
     $request = $this->getRequest();
     $new = $request->getInt('new');
     $old = $request->getInt('old');
 
     if (($new || $old) && $new <= $old) {
       throw new Exception(
         "You can only view the diff of an older update relative to a newer ".
         "update.");
     }
 
     if ($new && empty($diffs[$new])) {
       throw new Exception(
         "The 'new' diff does not exist.");
     } else if ($new) {
       $diff = $diffs[$new];
     } else {
       $diff = end($diffs);
       if (!$diff) {
         throw new Exception("No diff attached to this revision?");
       }
       $new = $diff->getID();
     }
 
     $target_diff = $diff;
 
     if ($old && empty($diffs[$old])) {
       throw new Exception(
         "The 'old' diff does not exist.");
     }
 
     $rows = array(array('Base', '', true, false, null,
       $diff->getSourceControlBaseRevision()
         ? $diff->getSourceControlBaseRevision()
         : <em>Master</em>));
     $idx = 0;
     foreach ($diffs as $cdiff) {
       $rows[] = array(
         'Diff '.(++$idx),
         $cdiff->getID(),
         $cdiff->getID() != max(array_pull($diffs, 'getID')),
         true,
         $cdiff->getDateCreated(),
         $cdiff->getDescription()
           ? $cdiff->getDescription()
           : <em>No description available.</em>,
         $cdiff->getUnitTested(),
         $cdiff->getLinted());
     }
 
     $diff_table =
       <table class="differential-diff-differ">
         <tr>
           <th>Diff</th>
           <th>Diff ID</th>
           <th>Description</th>
           <th>Age</th>
           <th>Lint</th>
           <th>Unit</th>
         </tr>
       </table>;
     $ii = 0;
 
     $old_ids = array();
     foreach ($rows as $row) {
       $xold = null;
       if ($row[2]) {
         $lradio = <input name="old" value={$row[1]} type="radio"
           disabled={$row[1] >= $new}
           checked={$old == $row[1]} />;
         if ($old == $row[1]) {
           $xold = 'old-now';
         }
         $old_ids[] = $lradio->requireUniqueID();
       } else {
         $lradio = null;
       }
       $xnew = null;
       if ($row[3]) {
         $rradio = <input name="new" value={$row[1]} type="radio"
           sigil="new-radio"
           checked={$new == $row[1]} />;
         if ($new == $row[1]) {
           $xnew = 'new-now';
         }
       } else {
         $rradio = null;
       }
 
       if ($row[3]) {
         $unit_star = 'star-none';
         switch ($row[6]) {
           case Diff::UNIT_FAIL:
           case Diff::UNIT_WARN: $unit_star = 'star-warn'; break;
           case Diff::UNIT_OKAY: $unit_star = 'star-okay'; break;
         }
 
         $lint_star = 'star-none';
         switch ($row[7]) {
           case Diff::LINT_FAIL:
           case Diff::LINT_WARNINGS: $lint_star = 'star-warn'; break;
           case Diff::LINT_OKAY:     $lint_star = 'star-okay'; break;
         }
 
         $star = "\xE2\x98\x85";
 
         $unit_star =
           <span class={$unit_star}>
             <span class="star">{$star}</span>
           </span>;
 
         $lint_star =
           <span class={$lint_star}>
             <span class="star">{$star}</span>
           </span>;
       } else {
         $unit_star = null;
         $lint_star = null;
       }
 
       $diff_table->appendChild(
         <tr class={++$ii % 2 ? 'alt' : null}>
           <td class="name">{$row[0]}</td>
           <td class="diffid">{$row[1]}</td>
           <td class="desc">{$row[5]}</td>
           <td class="age">{$row[4] ? ago(time() - $row[4]) : null}</td>
           <td class="star">{$lint_star}</td>
           <td class="star">{$unit_star}</td>
           <td class={"old {$xold}"}>{$lradio}</td>
           <td class={"new {$xnew}"}>{$rradio}</td>
         </tr>);
     }
 
     Javelin::initBehavior('differential-diff-radios', array(
       'radios' => $old_ids,
     ));
 
     $diff_table->appendChild(
       <tr>
         <td colspan="8" class="diff-differ-submit">
           <label>Whitespace Changes:</label>
           {id(<select name="whitespace" />)->setOptions(
             array(
               'ignore-all'      => 'Ignore All',
               'ignore-trailing' => 'Ignore Trailing',
               'show-all'        => 'Show All',
             ), $request->getStr('whitespace'))}{' '}
           <button type="submit">Show Diff</button>
         </td>
       </tr>);
 
     $diff_table =
       <div class="differential-table-of-contents">
         <h1>Revision Update History</h1>
         <form action={URI::getRequestURI()} method="get">
           {$diff_table}
         </form>
       </div>;
 
 
     $load_ids = array_filter(array($old, $diff->getID()));
 
     $viewer_id = $this->getRequest()->getViewerContext()->getUserID();
 
     $raw_objects = queryfx_all(
       smc_get_db('cdb.differential', 'r'),
       'SELECT * FROM changeset WHERE changeset.diffID IN (%Ld)',
       $load_ids);
 
     $raw_objects = array_group($raw_objects, 'diffID');
     $objects = $raw_objects[$diff->getID()];
 
     if (!$objects) {
       $changesets = array();
     } else {
       $changesets = id(new DifferentialChangeset())->loadAllFromArray($objects);
     }
 
 
     $changesets = array_psort($changesets, 'getSortKey');
 
     $warning = null;
     $limit = 100;
     if (count($changesets) > $limit && !$this->getRequest()->getStr('large')) {
       $count = number_format(count($changesets));
       $warning =
         <tools:notice title="Very Large Diff">
           This diff is extremely large and affects {$count} files. Only the
           first {number_format($limit)} files are shown.
           <strong>
             <a href={$revision->getURI().'?large=true'}>Show All Files</a>
           </strong>
         </tools:notice>;
       $changesets = array_slice($changesets, 0, $limit);
       if (!$old) {
         $visible_changesets = array_pull($changesets, 'getID');
       }
     }
 
 
     $feedback = id(new DifferentialFeedback())->loadAllWithRevision($revision);
     $feedback = array_merge($implied_feedback, $feedback);
 
     $inline_comments = $this->loadInlineComments($feedback, $changesets);
 
     $diff_map = array();
     $diffs = array_psort($diffs, 'getID');
     foreach ($diffs as $diff) {
       $diff_map[$diff->getID()] = count($diff_map) + 1;
     }
     $visible_changesets = array_fill_keys($visible_changesets, true);
     $hidden_changesets = array();
     foreach ($changesets as $changeset) {
       $id = $changeset->getID();
       if (isset($visible_changesets[$id])) {
         continue;
       }
       $hidden_changesets[$id] = $diff_map[$changeset->getDiffID()];
     }
 
     $revision->loadRelationships();
     $ccs = $revision->getCCFBIDs();
     $reviewers = $revision->getReviewers();
 
     $actors = array_pull($feedback, 'getUserID');
     $actors[] = $revision->getOwnerID();
 
     $tasks = array();
     assoc_get_by_type(
       $revision->getFBID(),
       22284182462, // TODO: include issue, DIFFCAMP_TASK_ASSOC
       $start = null,
       $limit = null,
       $pending = true,
       $tasks);
     memcache_dispatch();
     $tasks = array_keys($tasks);
 
     $preparer = new Preparer();
       $fbids = array_merge_fast(
         array($actors, array($viewer_id), $reviewers, $ccs, $tasks),
         true);
       $handles = array();
       $handle_data = id(new ToolsHandleData($fbids, $handles))
         ->needNames()
         ->needAlternateNames()
         ->needAlternateIDs()
         ->needThumbnails();
       $preparer->waitFor($handle_data);
     $preparer->go();
 
     $revision->attachTaskHandles(array_select_keys($handles, $tasks));
 
     $inline_comments = array_group($inline_comments, 'getFeedbackID');
 
     $engine = new RemarkupEngine();
     $engine->enableFeature(RemarkupEngine::FEATURE_GUESS_IMAGES);
     $engine->enableFeature(RemarkupEngine::FEATURE_YOUTUBE);
     $engine->setCurrentSandcastle($this->getSandcastleURI($target_diff));
     $feed = array();
     foreach ($feedback as $comment) {
       $inlines = null;
       if (isset($inline_comments[$comment->getID()])) {
         $inlines = $inline_comments[$comment->getID()];
       }
       $feed[] =
         <differential:feedback
             feedback={$comment}
               handle={$handles[$comment->getUserID()]}
               engine={$engine}
               inline={$inlines}
           changesets={$changesets}
               hidden={$hidden_changesets} />;
     }
 
     $feed = $this->renderFeedbackList($feed, $feedback, $viewer_id);
 
     $fields = $this->getDetailFields($revision, $diff, $handles);
     $table = <table class="differential-revision-properties" />;
     foreach ($fields as $key => $value) {
       $table->appendChild(
         <tr>
           <th>{$key}:</th><td>{$value}</td>
         </tr>);
     }
 
     $quick_links = $this->getQuickLinks($revision);
 
 
     $info =
       <div class="differential-revision-information">
         <div class="differential-revision-actions">
           {$quick_links}
         </div>
         <div class="differential-revision-detail">
           <h1>{$revision->getName()}{$edit_link}</h1>
           {$table}
         </div>
       </div>;
 
     $actions = $this->getRevisionActions($revision);
     $revision_id = $revision->getID();
 
     $content = SavedCopy::loadData(
       $viewer_id,
       SavedCopy::Type_DifferentialRevisionFeedback,
       $revision->getFBID());
 
 
     $syntax_link =
       <a href={'http://www.intern.facebook.com/intern/wiki/index.php' .
                '/Articles/Remarkup_Syntax_Reference'}
          target="_blank"
          tabindex="4">Remarkup Reference</a>;
 
     Javelin::initBehavior(
       'differential-add-reviewers',
       array(
         'src'       => redirect_str('/datasource/employee/', 'tools'),
         'tokenizer' => 'reviewer-tokenizer',
         'select'    => 'feedback-action',
         'row'       => 'reviewer-tokenizer-row',
       ));
 
 
     $notice = null;
     if ($this->getRequest()->getBool('diff_changed')) {
       $notice =
         <tools:notice title="Revision Updated Recently">
           This revision was updated with a <strong>new diff</strong> while you
           were providing feedback. Your inline comments appear on the
           <strong>old diff</strong>.
         </tools:notice>;
     }
 
     return
       <differential:standard-page title={$revision->getName()}>
         <div class="differential-primary-pane">
           {$warning}
           {$notice}
           {$info}
           <div class="differential-feedback">
             {$feed}
           </div>
           {$diff_table}
           {$table_of_contents}
           {$against_warn}
           {$detail_view}
           {$feedback_form}
         </div>
       </differential:standard-page>;
   }
 
   protected function getQuickLinks(DifferentialRevision $revision) {
 
     $viewer_id = $this->getRequest()->getViewerContext()->getUserID();
     $viewer_is_owner = ($viewer_id == $revision->getOwnerID());
     $viewer_is_reviewer =
       ((array_search($viewer_id, $revision->getReviewers())) !== false);
     $viewer_is_cc =
       ((array_search($viewer_id, $revision->getCCFBIDs())) !== false);
     $status = $revision->getStatus();
 
     $links = array();
 
     if (!$viewer_is_owner && !$viewer_is_reviewer) {
       $action = $viewer_is_cc
         ? 'rem'
         : 'add';
       $revision_id = $revision->getID();
       $href = "/differential/subscribe/{$action}/{$revision_id}";
       $links[] = array(
         $viewer_is_cc ? 'subscribe-disabled' : 'subscribe-enabled',
         <a href={$href}>{$viewer_is_cc ? 'Unsubscribe' : 'Subscribe'}</a>,
       );
     } else {
       $links[] = array(
         'subscribe-disabled unavailable',
         <a>Automatically Subscribed</a>,
       );
     }
 
     $blast_uri = RedirectURI(
       '/intern/differential/?action=blast&fbid='.$revision->getFBID())
       ->setTier('intern');
     $links[] = array(
       'blast',
       <a href={$blast_uri}>Blast Revision</a>,
     );
 
     $blast_uri = RedirectURI(
       '/intern/differential/?action=tasks&fbid='.$revision->getFBID())
       ->setTier('intern');
     $links[] = array(
       'tasks',
       <a href={$blast_uri}>Edit Tasks</a>,
     );
 
     if ($viewer_is_owner && false) {
       $perflab_uri = RedirectURI(
         '/intern/differential/?action=perflab&fbid='.$revision->getFBID())
         ->setTier('intern');
       $links[] = array(
         'perflab',
         <a href={$perflab_uri}>Run in Perflab</a>,
       );
     }
 
     $engineering_repository_id = RepositoryRef::getByCallsign('E')->getID();
     $svn_revision = $revision->getSVNRevision();
     if ($status == DifferentialConstants::COMMITTED &&
         $svn_revision &&
         $revision->getRepositoryID() == $engineering_repository_id) {
       $href = '/intern/push/request.php?rev='.$svn_revision;
       $href = RedirectURI($href)->setTier('intern');
       $links[] = array(
         'merge',
         <a href={$href} id="ask_for_merge_link">Ask for Merge</a>,
       );
     }
 
     $links[] = array(
       'herald-transcript',
       <a href={"/herald/transcript/?fbid=".$revision->getFBID()}
         >Herald Transcripts</a>,
     );
     $links[] = array(
       'metamta-transcript',
       <a href={"/mail/?view=all&fbid=".$revision->getFBID()}
         >MetaMTA Transcripts</a>,
     );
 
 
     $list = <ul class="differential-actions" />;
     foreach ($links as $link) {
       list($class, $tag) = $link;
       $list->appendChild(<li class={$class}>{$tag}</li>);
     }
 
     return $list;
   }
 
   protected function getDetailFields(
     DifferentialRevision $revision,
     Diff $diff,
     array $handles) {
 
     $fields = array();
     $fields['Revision Status'] = $this->getRevisionStatusDisplay($revision);
 
     $author = $revision->getOwnerID();
     $fields['Author'] = <tools:handle handle={$handles[$author]}
                                         link={true} />;
 
     $sandcastle = $this->getSandcastleURI($diff);
     if ($sandcastle) {
       $fields['Sandcastle'] = <a href={$sandcastle}>{$sandcastle}</a>;
     }
 
     $path = $diff->getSourcePath();
     if ($path) {
       $host = $diff->getSourceMachine();
       $branch = $diff->getGitBranch() ? ' (' . $diff->getGitBranch() . ')' : '';
 
       if ($host) {
         $user = $handles[$this->getRequest()->getViewerContext()->getUserID()]
           ->getName();
         $fields['Path'] =
           <x:frag>
             <a href={"ssh://{$user}@{$host}"}>{$host}</a>:{$path}{$branch}
           </x:frag>;
       } else {
         $fields['Path'] = $path;
       }
     }
 
     $reviewer_links = array();
     foreach ($revision->getReviewers() as $reviewer) {
       $reviewer_links[] = <tools:handle handle={$handles[$reviewer]}
                                           link={true} />;
     }
     if ($reviewer_links) {
       $fields['Reviewers'] = array_implode(', ', $reviewer_links);
     } else {
       $fields['Reviewers'] = <em>None</em>;
     }
 
     $ccs = $revision->getCCFBIDs();
     if ($ccs) {
       $links = array();
       foreach ($ccs as $cc) {
         $links[] = <tools:handle handle={$handles[$cc]}
                                    link={true} />;
       }
       $fields['CCs'] = array_implode(', ', $links);
     }
 
     $blame_rev = $revision->getSvnBlameRevision();
     if ($blame_rev) {
       if ($revision->getRepositoryRef() && is_numeric($blame_rev)) {
         $ref = new RevisionRef($revision->getRepositoryRef(), $blame_rev);
         $fields['Blame Revision'] =
           <a href={URI($ref->getDetailURL())}>
             {$ref->getName()}
           </a>;
       } else {
         $fields['Blame Revision'] = $blame_rev;
       }
     }
 
     $tasks = $revision->getTaskHandles();
 
     if ($tasks) {
       $links = array();
       foreach ($tasks as $task) {
         $links[] = <tools:handle handle={$task} link={true} />;
       }
       $fields['Tasks'] = array_implode(<br />, $links);
     }
 
     $bugzilla_id = $revision->getBugzillaID();
     if ($bugzilla_id) {
       $href = 'http://bugs.developers.facebook.com/show_bug.cgi?id='.
         $bugzilla_id;
       $fields['Bugzilla'] = <a href={$href}>{'#'.$bugzilla_id}</a>;
     }
 
     $fields['Apply Patch'] = <tt>arc patch --revision {$revision->getID()}</tt>;
 
     if ($diff->getParentRevisionID()) {
       $parent = id(new DifferentialRevision())->load(
         $diff->getParentRevisionID());
       if ($parent) {
         $fields['Depends On'] =
           <a href={$parent->getURI()}>
             D{$parent->getID()}: {$parent->getName()}
           </a>;
       }
     }
 
     $star = <span class="star">{"\xE2\x98\x85"}</span>;
 
     Javelin::initBehavior('differential-star-more');
 
     switch ($diff->getLinted()) {
       case Diff::LINT_FAIL:
         $more = $this->renderDiffPropertyMoreLink($diff, 'lint');
         $fields['Lint'] =
           <x:frag>
             <span class="star-warn">{$star} Lint Failures</span>
             {$more}
           </x:frag>;
         break;
       case Diff::LINT_WARNINGS:
         $more = $this->renderDiffPropertyMoreLink($diff, 'lint');
         $fields['Lint'] =
           <x:frag>
             <span class="star-warn">{$star} Lint Warnings</span>
             {$more}
           </x:frag>;
         break;
       case Diff::LINT_OKAY:
         $fields['Lint'] =
           <span class="star-okay">{$star} Lint Free</span>;
         break;
       default:
       case Diff::LINT_NO:
         $fields['Lint'] =
           <span class="star-none">{$star} Not Linted</span>;
         break;
     }
 
     $unit_details = false;
     switch ($diff->getUnitTested()) {
       case Diff::UNIT_FAIL:
         $fields['Unit Tests'] =
             <span class="star-warn">{$star} Unit Test Failures</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_WARN:
         $fields['Unit Tests'] =
             <span class="star-warn">{$star} Unit Test Warnings</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_OKAY:
         $fields['Unit Tests'] =
           <span class="star-okay">{$star} Unit Tests Passed</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_NO_TESTS:
         $fields['Unit Tests'] =
           <span class="star-none">{$star} No Test Coverage</span>;
         break;
       case Diff::UNIT_NO:
       default:
         $fields['Unit Tests'] =
           <span class="star-none">{$star} Not Unit Tested</span>;
         break;
     }
 
     if ($unit_details) {
       $fields['Unit Tests'] =
         <x:frag>
           {$fields['Unit Tests']}
           {$this->renderDiffPropertyMoreLink($diff, 'unit')}
         </x:frag>;
     }
 
     $platform_impact = $revision->getPlatformImpact();
     if ($platform_impact) {
       $fields['Platform Impact'] =
         <text linebreaks="true">{$platform_impact}</text>;
     }
 
     return $fields;
   }
 
   protected function renderDiffPropertyMoreLink(Diff $diff, $name) {
     $target = <div class="star-more"
                    style="display: none;">
                 <div class="star-loading">Loading...</div>
               </div>;
     $meta = array(
       'target'  => $target->requireUniqueID(),
       'uri'     => '/differential/diffprop/'.$diff->getID().'/'.$name.'/',
     );
     $more =
       <span sigil="star-link-container">
         &middot;
         <a mustcapture="true"
                  sigil="star-more"
                   href="#"
                   meta={$meta}>Show Details</a>
       </span>;
     return <x:frag>{$more}{$target}</x:frag>;
   }
 
 
 
   protected function getRevisionStatusDisplay(DifferentialRevision $revision) {
     $viewer_id = $this->getRequest()->getViewerContext()->getUserID();
     $viewer_is_owner = ($viewer_id == $revision->getOwnerID());
     $status = $revision->getStatus();
 
     $more = null;
     switch ($status) {
       case DifferentialConstants::NEEDS_REVIEW:
         $message = 'Pending Review';
         break;
       case DifferentialConstants::NEEDS_REVISION:
         $message = 'Awaiting Revision';
         if ($viewer_is_owner) {
           $more = 'Make the requested changes and update the revision.';
         }
         break;
       case DifferentialConstants::ACCEPTED:
         $message = 'Ready for Commit';
         if ($viewer_is_owner) {
           $more =
             <x:frag>
               Run <tt>arc commit</tt> (svn) or <tt>arc amend</tt> (git) to
               proceed.
             </x:frag>;
         }
         break;
       case DifferentialConstants::COMMITTED:
         $message = 'Committed';
         $ref = $revision->getRevisionRef();
         $more = $ref
                 ? (<a href={URI($ref->getDetailURL())}>
                      {$ref->getName()}
                    </a>)
                 : null;
 
         $engineering_repository_id = RepositoryRef::getByCallsign('E')->getID();
         if ($revision->getSVNRevision() &&
             $revision->getRepositoryID() == $engineering_repository_id) {
           Javelin::initBehavior(
             'differential-revtracker-status',
             array(
               'uri' => '/differential/revtracker/'.$revision->getID().'/',
               'statusId' => 'revtracker_status',
               'mergeLinkId' => 'ask_for_merge_link',
             ));
         }
         break;
       case DifferentialConstants::ABANDONED:
         $message = 'Abandoned';
         break;
       default:
         throw new Exception("Unknown revision status.");
     }
 
     if ($more) {
       $message =
         <x:frag>
           <strong id="revtracker_status">{$message}</strong>
           &middot; {$more}
         </x:frag>;
     } else {
       $message = <strong id="revtracker_status">{$message}</strong>;
     }
 
     return $message;
   }
 
   protected function renderFeedbackList(array $xhp, array $obj, $viewer_id) {
 
     // Use magical heuristics to try to hide older comments.
 
     $obj = array_reverse($obj);
     $obj = array_values($obj);
     $xhp = array_reverse($xhp);
     $xhp = array_values($xhp);
 
     $last_comment = null;
     foreach ($obj as $position => $feedback) {
       if ($feedback->getUserID() == $viewer_id) {
         if ($last_comment === null) {
           $last_comment = $position;
         } else if ($last_comment == $position - 1) {
           // If you made consecuitive comments, show them all. This is a spaz
           // rule for epriestley comments.
           $last_comment = $position;
         }
       }
     }
 
     $header = array();
 
     $hide = array();
     if ($last_comment !== null) {
       foreach ($obj as $position => $feedback) {
         $action = $feedback->getAction();
         if ($action == 'testplan' || $action == 'summarize') {
           // Always show summary and test plan.
           $header[] = $xhp[$position];
           unset($xhp[$position]);
           continue;
         }
 
         if ($position <= $last_comment) {
           // Always show comments after your last comment.
           continue;
         }
 
         if ($position < 3) {
           // Always show the most recent 3 comments.
           continue;
         }
 
         // Hide everything else.
         $hide[] = $position;
       }
     }
 
     if (count($hide) <= 3) {
       // Don't hide if there's not much to hide.
       $hide = array();
     }
 
     $header = array_reverse($header);
 
     $hidden = array_select_keys($xhp, $hide);
     $visible = array_diff_key($xhp, $hidden);
 
     $visible = array_reverse($visible);
     $hidden  = array_reverse($hidden);
 
     if ($hidden) {
       Javelin::initBehavior(
         'differential-show-all-feedback',
         array(
           'markup' => id(<x:frag>{$hidden}</x:frag>)->toString(),
         ));
       $hidden =
         <div sigil="all-feedback-container">
           <div class="older-replies-are-hidden">
             {number_format(count($hidden))} older replies are hidden.
             <a href="#" sigil="show-all-feedback"
               mustcapture="true">Show all feedback.</a>
           </div>
         </div>;
     } else {
       $hidden = null;
     }
 
     return
       <x:frag>
         {$header}
         {$hidden}
         {$visible}
       </x:frag>;
   }
 
 }
   protected function getDetailFields(
     DifferentialRevision $revision,
     Diff $diff,
     array $handles) {
 
     $fields = array();
     $fields['Revision Status'] = $this->getRevisionStatusDisplay($revision);
 
     $author = $revision->getOwnerID();
     $fields['Author'] = <tools:handle handle={$handles[$author]}
                                         link={true} />;
 
     $sandcastle = $this->getSandcastleURI($diff);
     if ($sandcastle) {
       $fields['Sandcastle'] = <a href={$sandcastle}>{$sandcastle}</a>;
     }
 
     $path = $diff->getSourcePath();
     if ($path) {
       $host = $diff->getSourceMachine();
       $branch = $diff->getGitBranch() ? ' (' . $diff->getGitBranch() . ')' : '';
 
       if ($host) {
         $user = $handles[$this->getRequest()->getViewerContext()->getUserID()]
           ->getName();
         $fields['Path'] =
           <x:frag>
             <a href={"ssh://{$user}@{$host}"}>{$host}</a>:{$path}{$branch}
           </x:frag>;
       } else {
         $fields['Path'] = $path;
       }
     }
 
     $reviewer_links = array();
     foreach ($revision->getReviewers() as $reviewer) {
       $reviewer_links[] = <tools:handle handle={$handles[$reviewer]}
                                           link={true} />;
     }
     if ($reviewer_links) {
       $fields['Reviewers'] = array_implode(', ', $reviewer_links);
     } else {
       $fields['Reviewers'] = <em>None</em>;
     }
 
     $ccs = $revision->getCCFBIDs();
     if ($ccs) {
       $links = array();
       foreach ($ccs as $cc) {
         $links[] = <tools:handle handle={$handles[$cc]}
                                    link={true} />;
       }
       $fields['CCs'] = array_implode(', ', $links);
     }
 
     $blame_rev = $revision->getSvnBlameRevision();
     if ($blame_rev) {
       if ($revision->getRepositoryRef() && is_numeric($blame_rev)) {
         $ref = new RevisionRef($revision->getRepositoryRef(), $blame_rev);
         $fields['Blame Revision'] =
           <a href={URI($ref->getDetailURL())}>
             {$ref->getName()}
           </a>;
       } else {
         $fields['Blame Revision'] = $blame_rev;
       }
     }
 
     $tasks = $revision->getTaskHandles();
 
     if ($tasks) {
       $links = array();
       foreach ($tasks as $task) {
         $links[] = <tools:handle handle={$task} link={true} />;
       }
       $fields['Tasks'] = array_implode(<br />, $links);
     }
 
     $bugzilla_id = $revision->getBugzillaID();
     if ($bugzilla_id) {
       $href = 'http://bugs.developers.facebook.com/show_bug.cgi?id='.
         $bugzilla_id;
       $fields['Bugzilla'] = <a href={$href}>{'#'.$bugzilla_id}</a>;
     }
 
     $fields['Apply Patch'] = <tt>arc patch --revision {$revision->getID()}</tt>;
 
     if ($diff->getParentRevisionID()) {
       $parent = id(new DifferentialRevision())->load(
         $diff->getParentRevisionID());
       if ($parent) {
         $fields['Depends On'] =
           <a href={$parent->getURI()}>
             D{$parent->getID()}: {$parent->getName()}
           </a>;
       }
     }
 
     $star = <span class="star">{"\xE2\x98\x85"}</span>;
 
     Javelin::initBehavior('differential-star-more');
 
     switch ($diff->getLinted()) {
       case Diff::LINT_FAIL:
         $more = $this->renderDiffPropertyMoreLink($diff, 'lint');
         $fields['Lint'] =
           <x:frag>
             <span class="star-warn">{$star} Lint Failures</span>
             {$more}
           </x:frag>;
         break;
       case Diff::LINT_WARNINGS:
         $more = $this->renderDiffPropertyMoreLink($diff, 'lint');
         $fields['Lint'] =
           <x:frag>
             <span class="star-warn">{$star} Lint Warnings</span>
             {$more}
           </x:frag>;
         break;
       case Diff::LINT_OKAY:
         $fields['Lint'] =
           <span class="star-okay">{$star} Lint Free</span>;
         break;
       default:
       case Diff::LINT_NO:
         $fields['Lint'] =
           <span class="star-none">{$star} Not Linted</span>;
         break;
     }
 
     $unit_details = false;
     switch ($diff->getUnitTested()) {
       case Diff::UNIT_FAIL:
         $fields['Unit Tests'] =
             <span class="star-warn">{$star} Unit Test Failures</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_WARN:
         $fields['Unit Tests'] =
             <span class="star-warn">{$star} Unit Test Warnings</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_OKAY:
         $fields['Unit Tests'] =
           <span class="star-okay">{$star} Unit Tests Passed</span>;
         $unit_details = true;
         break;
       case Diff::UNIT_NO_TESTS:
         $fields['Unit Tests'] =
           <span class="star-none">{$star} No Test Coverage</span>;
         break;
       case Diff::UNIT_NO:
       default:
         $fields['Unit Tests'] =
           <span class="star-none">{$star} Not Unit Tested</span>;
         break;
     }
 
     if ($unit_details) {
       $fields['Unit Tests'] =
         <x:frag>
           {$fields['Unit Tests']}
           {$this->renderDiffPropertyMoreLink($diff, 'unit')}
         </x:frag>;
     }
 
     $platform_impact = $revision->getPlatformImpact();
     if ($platform_impact) {
       $fields['Platform Impact'] =
         <text linebreaks="true">{$platform_impact}</text>;
     }
 
     return $fields;
   }
 
 
 */
diff --git a/src/applications/differential/editor/revision/DifferentialRevisionEditor.php b/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
index 0bdc121d37..af07ca4da7 100644
--- a/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
+++ b/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
@@ -1,593 +1,589 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Handle major edit operations to DifferentialRevision -- adding and removing
  * reviewers, diffs, and CCs. Unlike simple edits, these changes trigger
  * complicated email workflows.
  */
 class DifferentialRevisionEditor {
 
   protected $revision;
   protected $actorPHID;
 
   protected $cc         = null;
   protected $reviewers  = null;
   protected $diff;
   protected $comments;
   protected $silentUpdate;
 
   public function __construct(DifferentialRevision $revision, $actor_phid) {
     $this->revision = $revision;
     $this->actorPHID = $actor_phid;
   }
 
 /*
   public static function newRevisionFromRawMessageWithDiff(
     DifferentialRawMessage $message,
     Diff $diff,
     $user) {
 
     if ($message->getRevisionID()) {
       throw new Exception(
         "The provided commit message is already associated with a ".
         "Differential revision.");
     }
 
     if ($message->getReviewedByNames()) {
       throw new Exception(
         "The provided commit message contains a 'Reviewed By:' field.");
     }
 
     $revision = new DifferentialRevision();
     $revision->setPHID($revision->generatePHID());
 
     $revision->setOwnerID($user);
     $revision->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW);
     $revision->attachReviewers(array());
     $revision->attachCCPHIDs(array());
 
     $editor = new DifferentialRevisionEditor($revision, $user);
 
     self::copyFields($editor, $revision, $message, $user);
 
     $editor->addDiff($diff, null);
     $editor->save();
 
     return $revision;
   }
 
   public static function newRevisionFromConduitWithDiff(
     array $fields,
     Diff $diff,
     $user) {
 
     $revision = new DifferentialRevision();
     $revision->setPHID($revision->generatePHID());
 
     $revision->setOwnerID($user);
     $revision->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW);
     $revision->attachReviewers(array());
     $revision->attachCCPHIDs(array());
 
     $editor = new DifferentialRevisionEditor($revision, $user);
 
     $editor->copyFieldFromConduit($fields);
 
     $editor->addDiff($diff, null);
     $editor->save();
 
     return $revision;
   }
 
 
   public static function copyFields(
     DifferentialRevisionEditor $editor,
     DifferentialRevision $revision,
     DifferentialRawMessage $message,
     $user) {
 
     $revision->setName($message->getTitle());
     $revision->setSummary($message->getSummary());
     $revision->setTestPlan($message->getTestPlan());
     $revision->setSVNBlameRevision($message->getBlameRevision());
     $revision->setRevert($message->getRevertPlan());
     $revision->setPlatformImpact($message->getPlatformImpact());
     $revision->setBugzillaID($message->getBugzillaID());
 
     $editor->setReviewers($message->getReviewerPHIDs());
     $editor->setCCPHIDs($message->getCCPHIDs());
   }
 
   public function copyFieldFromConduit(array $fields) {
 
     $user = $this->actorPHID;
     $revision = $this->revision;
 
     $revision->setName($fields['title']);
     $revision->setSummary($fields['summary']);
     $revision->setTestPlan($fields['testPlan']);
     $revision->setSVNBlameRevision($fields['blameRevision']);
     $revision->setRevert($fields['revertPlan']);
     $revision->setPlatformImpact($fields['platformImpact']);
     $revision->setBugzillaID($fields['bugzillaID']);
 
     $this->setReviewers($fields['reviewerGUIDs']);
     $this->setCCPHIDs($fields['ccGUIDs']);
   }
 */
 
   public function getRevision() {
     return $this->revision;
   }
 
   public function setReviewers(array $reviewers) {
     $this->reviewers = $reviewers;
     return $this;
   }
 
   public function setCCPHIDs(array $cc) {
     $this->cc = $cc;
     return $this;
   }
 
   public function addDiff(DifferentialDiff $diff, $comments) {
     if ($diff->getRevisionID() &&
         $diff->getRevisionID() != $this->getRevision()->getID()) {
       $diff_id = (int)$diff->getID();
       $targ_id = (int)$this->getRevision()->getID();
       $real_id = (int)$diff->getRevisionID();
       throw new Exception(
         "Can not attach diff #{$diff_id} to Revision D{$targ_id}, it is ".
         "already attached to D{$real_id}.");
     }
     $this->diff = $diff;
     $this->comments = $comments;
     return $this;
   }
 
   protected function getDiff() {
     return $this->diff;
   }
 
   protected function getComments() {
     return $this->comments;
   }
 
   protected function getActorPHID() {
     return $this->actorPHID;
   }
 
   public function isNewRevision() {
     return !$this->getRevision()->getID();
   }
 
   /**
    * A silent update does not trigger Herald rules or send emails. This is used
    * for auto-amends at commit time.
    */
   public function setSilentUpdate($silent) {
     $this->silentUpdate = $silent;
     return $this;
   }
 
   public function save() {
     $revision = $this->getRevision();
 
 // TODO
 //    $revision->openTransaction();
 
     $is_new = $this->isNewRevision();
     if ($is_new) {
       // These fields aren't nullable; set them to sensible defaults if they
       // haven't been configured. We're just doing this so we can generate an
       // ID for the revision if we don't have one already.
       $revision->setLineCount(0);
       if ($revision->getStatus() === null) {
         $revision->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW);
       }
       if ($revision->getTitle() === null) {
         $revision->setTitle('Untitled Revision');
       }
       if ($revision->getAuthorPHID() === null) {
         $revision->setAuthorPHID($this->getActorPHID());
       }
 
       $revision->save();
     }
 
     $revision->loadRelationships();
 
     if ($this->reviewers === null) {
       $this->reviewers = $revision->getReviewers();
     }
 
     if ($this->cc === null) {
       $this->cc = $revision->getCCPHIDs();
     }
 
     // We're going to build up three dictionaries: $add, $rem, and $stable. The
     // $add dictionary has added reviewers/CCs. The $rem dictionary has
     // reviewers/CCs who have been removed, and the $stable array is
     // reviewers/CCs who haven't changed. We're going to send new reviewers/CCs
     // a different ("welcome") email than we send stable reviewers/CCs.
 
     $old = array(
       'rev' => array_fill_keys($revision->getReviewers(), true),
       'ccs' => array_fill_keys($revision->getCCPHIDs(), true),
     );
 
     $diff = $this->getDiff();
 
     $xscript_header = null;
     $xscript_uri = null;
 
     $new = array(
       'rev' => array_fill_keys($this->reviewers, true),
       'ccs' => array_fill_keys($this->cc, true),
     );
 
 
     $rem_ccs = array();
     if ($diff) {
       $diff->setRevisionID($revision->getID());
       $revision->setLineCount($diff->getLineCount());
 
 // TODO!
 //      $revision->setRepositoryID($diff->getRepositoryID());
 
 /*
       $iface = new DifferentialRevisionHeraldable($revision);
       $iface->setExplicitCCs($new['ccs']);
       $iface->setExplicitReviewers($new['rev']);
       $iface->setForbiddenCCs($revision->getForbiddenCCPHIDs());
       $iface->setForbiddenReviewers($revision->getForbiddenReviewers());
       $iface->setDiff($diff);
 
       $xscript = HeraldEngine::loadAndApplyRules($iface);
       $xscript_uri = $xscript->getURI();
       $xscript_phid = $xscript->getPHID();
       $xscript_header = $xscript->getXHeraldRulesHeader();
 
 
       $sub = array(
         'rev' => array(),
         'ccs' => $iface->getCCsAddedByHerald(),
       );
       $rem_ccs = $iface->getCCsRemovedByHerald();
 */
   // TODO!
       $sub = array(
         'rev' => array(),
         'ccs' => array(),
       );
 
 
     } else {
       $sub = array(
         'rev' => array(),
         'ccs' => array(),
       );
     }
 
     // Remove any CCs which are prevented by Herald rules.
     $sub['ccs'] = array_diff_key($sub['ccs'], $rem_ccs);
     $new['ccs'] = array_diff_key($new['ccs'], $rem_ccs);
 
     $add = array();
     $rem = array();
     $stable = array();
     foreach (array('rev', 'ccs') as $key) {
       $add[$key] = array();
       if ($new[$key] !== null) {
         $add[$key] += array_diff_key($new[$key], $old[$key]);
       }
       $add[$key] += array_diff_key($sub[$key], $old[$key]);
 
       $combined = $sub[$key];
       if ($new[$key] !== null) {
         $combined += $new[$key];
       }
       $rem[$key] = array_diff_key($old[$key], $combined);
 
       $stable[$key] = array_diff_key($old[$key], $add[$key] + $rem[$key]);
     }
 
     self::alterReviewers(
       $revision,
       $this->reviewers,
       array_keys($rem['rev']),
       array_keys($add['rev']),
       $this->actorPHID);
 
     // Add the author to the relevant set of users so they get a copy of the
     // email.
     if (!$this->silentUpdate) {
       if ($is_new) {
         $add['rev'][$this->getActorPHID()] = true;
       } else {
         $stable['rev'][$this->getActorPHID()] = true;
       }
     }
 
     $mail = array();
 
     $changesets = null;
     $feedback = null;
     if ($diff) {
       $changesets = $diff->loadChangesets();
-      // TODO: move to DifferentialFeedbackEditor
+      // TODO: This should probably be in DifferentialFeedbackEditor?
       if (!$is_new) {
-        // TODO
-//        $feedback = $this->createFeedback();
+        $comment = $this->createComment();
       }
       if ($feedback) {
         $mail[] = id(new DifferentialNewDiffMail(
             $revision,
             $this->getActorPHID(),
             $changesets))
           ->setIsFirstMailAboutRevision($is_new)
           ->setIsFirstMailToRecipients($is_new)
           ->setComments($this->getComments())
           ->setToPHIDs(array_keys($stable['rev']))
           ->setCCPHIDs(array_keys($stable['ccs']));
       }
 
       // Save the changes we made above.
 
-// TODO
-//      $diff->setDescription(substr($this->getComments(), 0, 80));
+      $diff->setDescription(substr($this->getComments(), 0, 80));
       $diff->save();
 
       // An updated diff should require review, as long as it's not committed
       // or accepted. The "accepted" status is "sticky" to encourage courtesy
       // re-diffs after someone accepts with minor changes/suggestions.
 
       $status = $revision->getStatus();
       if ($status != DifferentialRevisionStatus::COMMITTED &&
           $status != DifferentialRevisionStatus::ACCEPTED) {
         $revision->setStatus(DifferentialRevisionStatus::NEEDS_REVIEW);
       }
 
     } else {
       $diff = $revision->loadActiveDiff();
       if ($diff) {
         $changesets = $diff->loadChangesets();
       } else {
         $changesets = array();
       }
     }
 
     $revision->save();
 
 // TODO
 //    $revision->saveTransaction();
 
     $event = array(
       'revision_id' => $revision->getID(),
       'PHID'        => $revision->getPHID(),
       'action'      => $is_new ? 'create' : 'update',
       'actor'       => $this->getActorPHID(),
     );
 
 //  TODO
 //    id(new ToolsTimelineEvent('difx', fb_json_encode($event)))->record();
 
     if ($this->silentUpdate) {
       return;
     }
 
 // TODO
 //    $revision->attachReviewers(array_keys($new['rev']));
 //    $revision->attachCCPHIDs(array_keys($new['ccs']));
 
     if ($add['ccs'] || $rem['ccs']) {
       foreach (array_keys($add['ccs']) as $id) {
         if (empty($new['ccs'][$id])) {
           $reason_phid = 'TODO';//$xscript_phid;
         } else {
           $reason_phid = $this->getActorPHID();
         }
         self::addCCPHID($revision, $id, $reason_phid);
       }
       foreach (array_keys($rem['ccs']) as $id) {
         if (empty($new['ccs'][$id])) {
           $reason_phid = $this->getActorPHID();
         } else {
           $reason_phid = 'TODO';//$xscript_phid;
         }
         self::removeCCPHID($revision, $id, $reason_phid);
       }
     }
 
     if ($add['rev']) {
       $message = id(new DifferentialNewDiffMail(
           $revision,
           $this->getActorPHID(),
           $changesets))
         ->setIsFirstMailAboutRevision($is_new)
         ->setIsFirstMailToRecipients(true)
         ->setToPHIDs(array_keys($add['rev']));
 
       if ($is_new) {
         // The first time we send an email about a revision, put the CCs in
         // the "CC:" field of the same "Review Requested" email that reviewers
         // get, so you don't get two initial emails if you're on a list that
         // is CC'd.
         $message->setCCPHIDs(array_keys($add['ccs']));
       }
 
       $mail[] = $message;
     }
 
     // If you were added as a reviewer and a CC, just give you the reviewer
     // email. We could go to greater lengths to prevent this, but there's
     // bunch of stuff with list subscriptions anyway. You can still get two
     // emails, but only if a revision is updated and you are added as a reviewer
     // at the same time a list you are on is added as a CC, which is rare and
     // reasonable.
     $add['ccs'] = array_diff_key($add['ccs'], $add['rev']);
 
     if (!$is_new && $add['ccs']) {
       $mail[] = id(new DifferentialCCWelcomeMail(
           $revision,
           $this->getActorPHID(),
           $changesets))
         ->setIsFirstMailToRecipients(true)
         ->setToPHIDs(array_keys($add['ccs']));
     }
 
     foreach ($mail as $message) {
 // TODO
 //      $message->setHeraldTranscriptURI($xscript_uri);
 //      $message->setXHeraldRulesHeader($xscript_header);
       $message->send();
     }
   }
 
   public function addCCPHID(
     DifferentialRevision $revision,
     $phid,
     $reason_phid) {
     self::alterCCPHID($revision, $phid, true, $reason_phid);
   }
 
   public function removeCCPHID(
     DifferentialRevision $revision,
     $phid,
     $reason_phid) {
     self::alterCCPHID($revision, $phid, false, $reason_phid);
   }
 
   protected static function alterCCPHID(
     DifferentialRevision $revision,
     $phid,
     $add,
     $reason_phid) {
 /*
     $relationship = new DifferentialRelationship();
     $relationship->setRevisionID($revision->getID());
     $relationship->setRelation(DifferentialRelationship::RELATION_SUBSCRIBED);
     $relationship->setRelatedPHID($phid);
     $relationship->setForbidden(!$add);
     $relationship->setReasonPHID($reason_phid);
     $relationship->replace();
 */
   }
 
 
   public static function alterReviewers(
     DifferentialRevision $revision,
     array $stable_phids,
     array $rem_phids,
     array $add_phids,
     $reason_phid) {
 
     $rem_map = array_fill_keys($rem_phids, true);
     $add_map = array_fill_keys($add_phids, true);
 
     $seq_map = array_values($stable_phids);
     $seq_map = array_flip($seq_map);
     foreach ($rem_map as $phid => $ignored) {
       if (!isset($seq_map[$phid])) {
         $seq_map[$phid] = count($seq_map);
       }
     }
     foreach ($add_map as $phid => $ignored) {
       if (!isset($seq_map[$phid])) {
         $seq_map[$phid] = count($seq_map);
       }
     }
 
     $raw = $revision->getRawRelations(DifferentialRevision::RELATION_REVIEWER);
     $raw = ipull($raw, null, 'objectPHID');
 
     $sequence = count($seq_map);
     foreach ($raw as $phid => $relation) {
       if (isset($seq_map[$phid])) {
         $raw[$phid]['sequence'] = $seq_map[$phid];
       } else {
         $raw[$phid]['sequence'] = $sequence++;
       }
     }
     $raw = isort($raw, 'sequence');
 
     foreach ($raw as $phid => $relation) {
       if (isset($rem_map[$phid])) {
         unset($raw[$phid]);
       }
     }
 
     foreach ($add_phids as $add) {
       $raw[$add] = array(
         'objectPHID'  => $add,
         'sequence'    => idx($seq_map, $add, $sequence++),
         'reasonPHID'  => $reason_phid,
       );
     }
 
     $conn_w = $revision->establishConnection('w');
 
     $sql = array();
     foreach ($raw as $relation) {
       $sql[] = qsprintf(
         $conn_w,
         '(%d, %s, %s, %d, %s)',
         $revision->getID(),
         DifferentialRevision::RELATION_REVIEWER,
         $relation['objectPHID'],
         $relation['sequence'],
         $relation['reasonPHID']);
     }
 
     $conn_w->openTransaction();
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE revisionID = %d AND relation = %s',
         DifferentialRevision::RELATIONSHIP_TABLE,
         $revision->getID(),
         DifferentialRevision::RELATION_REVIEWER);
       if ($sql) {
         queryfx(
           $conn_w,
           'INSERT INTO %T
             (revisionID, relation, objectPHID, sequence, reasonPHID)
           VALUES %Q',
           DifferentialRevision::RELATIONSHIP_TABLE,
           implode(', ', $sql));
       }
     $conn_w->saveTransaction();
   }
 
-/*
-  protected function createFeedback() {
-    $revision = $this->getRevision();
-    $feedback = id(new DifferentialFeedback())
-      ->setUserID($this->getActorPHID())
-      ->setRevision($revision)
+
+  private function createComment() {
+    $revision_id = $this->revision->getID();
+    $comment = id(new DifferentialComment())
+      ->setAuthorPHID($this->getActorPHID())
+      ->setRevisionID($revision_id)
       ->setContent($this->getComments())
       ->setAction('update');
+    $comment->save();
 
-    $feedback->save();
-
-    return $feedback;
+    return $comment;
   }
-*/
 
 }
 
diff --git a/src/applications/differential/editor/revision/__init__.php b/src/applications/differential/editor/revision/__init__.php
index de916456af..0961c81a68 100644
--- a/src/applications/differential/editor/revision/__init__.php
+++ b/src/applications/differential/editor/revision/__init__.php
@@ -1,19 +1,20 @@
 <?php
 /**
  * This file is automatically generated. Lint this module to rebuild it.
  * @generated
  */
 
 
 
 phutil_require_module('phabricator', 'applications/differential/constants/revisionstatus');
 phutil_require_module('phabricator', 'applications/differential/mail/ccwelcome');
 phutil_require_module('phabricator', 'applications/differential/mail/newdiff');
+phutil_require_module('phabricator', 'applications/differential/storage/comment');
 phutil_require_module('phabricator', 'applications/differential/storage/revision');
 phutil_require_module('phabricator', 'storage/qsprintf');
 phutil_require_module('phabricator', 'storage/queryfx');
 
 phutil_require_module('phutil', 'utils');
 
 
 phutil_require_source('DifferentialRevisionEditor.php');
diff --git a/src/applications/differential/parser/changeset/DifferentialChangesetParser.php b/src/applications/differential/parser/changeset/DifferentialChangesetParser.php
index 6e4de2f90d..4e693165d1 100644
--- a/src/applications/differential/parser/changeset/DifferentialChangesetParser.php
+++ b/src/applications/differential/parser/changeset/DifferentialChangesetParser.php
@@ -1,1342 +1,1342 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class DifferentialChangesetParser {
 
   protected $visible      = array();
   protected $new          = array();
   protected $old          = array();
   protected $intra        = array();
   protected $newRender    = null;
   protected $oldRender    = null;
   protected $parsedHunk   = false;
 
   protected $filename     = null;
   protected $filetype     = null;
   protected $changesetID  = null;
   protected $missingOld   = array();
   protected $missingNew   = array();
 
   protected $comments     = array();
   protected $specialAttributes = array();
 
   protected $changeset;
   protected $whitespaceMode = null;
 
   protected $subparser;
   protected $oldChangesetID = null;
   protected $noHighlight;
 
   private $handles;
   private $user;
 
   const CACHE_VERSION = 4;
 
   const ATTR_GENERATED  = 'attr:generated';
   const ATTR_DELETED    = 'attr:deleted';
   const ATTR_UNCHANGED  = 'attr:unchanged';
   const ATTR_WHITELINES = 'attr:white';
 
   const LINES_CONTEXT = 8;
 
   const WHITESPACE_SHOW_ALL         = 'show-all';
   const WHITESPACE_IGNORE_TRAILING  = 'ignore-trailing';
   const WHITESPACE_IGNORE_ALL       = 'ignore-all';
 
   public function setRightSideCommentMapping($id, $is_new) {
 
   }
 
   public function setLeftSideCommentMapping($id, $is_new) {
 
   }
 
   public function setChangeset($changeset) {
     $this->changeset = $changeset;
 
     $this->setFilename($changeset->getFilename());
     $this->setChangesetID($changeset->getID());
 
     return $this;
   }
 
   public function setWhitespaceMode($whitespace_mode) {
     $this->whitespaceMode = $whitespace_mode;
     return $this;
   }
 
   public function setOldChangesetID($old_changeset_id) {
     $this->oldChangesetID = $old_changeset_id;
     return $this;
   }
 
   public function setChangesetID($changeset_id) {
     $this->changesetID = $changeset_id;
     return $this;
   }
 
   public function getChangesetID() {
     return $this->changesetID;
   }
 
   public function setFilename($filename) {
     $this->filename = $filename;
     if (strpos($filename, '.', 1) !== false) {
       $parts = explode('.', $filename);
       $this->filetype = end($parts);
     }
   }
 
   public function setHandles(array $handles) {
     $this->handles = $handles;
     return $this;
   }
 
   public function setMarkupEngine(PhutilMarkupEngine $engine) {
     $this->markupEngine = $engine;
     return $this;
   }
 
   public function setUser(PhabricatorUser $user) {
     $this->user = $user;
     return $this;
   }
 
   public function parseHunk(DifferentialHunk $hunk) {
     $this->parsedHunk = true;
     $lines = $hunk->getChanges();
 
     // Flatten UTF-8 into "\0". We don't support UTF-8 because the diffing
     // algorithms are byte-oriented (not character oriented) and everyone seems
     // to be in agreement that it's fairly reasonable not to allow UTF-8 in
     // source files. These bytes will later be replaced with a "?" glyph, but
     // in the meantime we replace them with "\0" since Pygments is happy to
     // deal with that.
     $lines = preg_replace('/[\x80-\xFF]/', "\0", $lines);
 
     $lines = str_replace(
       array("\t", "\r\n", "\r"),
       array('  ', "\n",   "\n"),
       $lines);
     $lines = explode("\n", $lines);
 
     $types = array();
     foreach ($lines as $line_index => $line) {
       $lines[$line_index] = $line;
       if (isset($line[0])) {
         $char = $line[0];
         if ($char == ' ') {
           $types[$line_index] = null;
         } else if ($char == '\\' && $line_index > 0) {
           $types[$line_index] = $types[$line_index - 1];
         } else {
           $types[$line_index] = $char;
         }
       } else {
         $types[$line_index] = null;
       }
     }
 
     $old_line = $hunk->getOldOffset();
     $new_line = $hunk->getNewOffset();
     $num_lines = count($lines);
 
     if ($old_line > 1) {
       $this->missingOld[$old_line] = true;
     } else if ($new_line > 1) {
       $this->missingNew[$new_line] = true;
     }
 
     for ($cursor = 0; $cursor < $num_lines; $cursor++) {
       $type = $types[$cursor];
       $data = array(
         'type'  => $type,
         'text'  => (string)substr($lines[$cursor], 1),
         'line'  => $new_line,
       );
       switch ($type) {
         case '+':
           $this->new[] = $data;
           ++$new_line;
           break;
         case '-':
           $data['line'] = $old_line;
           $this->old[] = $data;
           ++$old_line;
           break;
         default:
           $this->new[] = $data;
           $data['line'] = $old_line;
           $this->old[] = $data;
           ++$new_line;
           ++$old_line;
           break;
       }
     }
   }
 
   public function getDisplayLine($offset, $length) {
     $start = 1;
     for ($ii = $offset; $ii > 0; $ii--) {
       if ($this->new[$ii] && $this->new[$ii]['line']) {
         $start = $this->new[$ii]['line'];
         break;
       }
     }
     $end = $start;
     for ($ii = $offset + $length; $ii < count($this->new); $ii++) {
       if ($this->new[$ii] && $this->new[$ii]['line']) {
         $end = $this->new[$ii]['line'];
         break;
       }
     }
     return "{$start},{$end}";
   }
 
   public function parseInlineComment(DifferentialInlineComment $comment) {
     $this->comments[] = $comment;
     return $this;
   }
 
   public function process() {
 
     $old = array();
     $new = array();
 
     $n = 0;
 
     $this->old = array_reverse($this->old);
     $this->new = array_reverse($this->new);
 
     $whitelines = false;
     $changed = false;
 
     $skip_intra = array();
     while (count($this->old) || count($this->new)) {
       $o_desc = array_pop($this->old);
       $n_desc = array_pop($this->new);
 
       $oend = end($this->old);
       if ($oend) {
         $o_next = $oend['type'];
       } else {
         $o_next = null;
       }
 
       $nend = end($this->new);
       if ($nend) {
         $n_next = $nend['type'];
       } else {
         $n_next = null;
       }
 
       if ($o_desc) {
         $o_type = $o_desc['type'];
       } else {
         $o_type = null;
       }
 
       if ($n_desc) {
         $n_type = $n_desc['type'];
       } else {
         $n_type = null;
       }
 
       if (($o_type != null) && ($n_type == null)) {
         $old[] = $o_desc;
         $new[] = null;
         if ($n_desc) {
           array_push($this->new, $n_desc);
         }
         $changed = true;
         continue;
       }
 
       if (($n_type != null) && ($o_type == null)) {
         $old[] = null;
         $new[] = $n_desc;
         if ($o_desc) {
           array_push($this->old, $o_desc);
         }
         $changed = true;
         continue;
       }
 
       if ($this->whitespaceMode != self::WHITESPACE_SHOW_ALL) {
         $similar = false;
         switch ($this->whitespaceMode) {
           case self::WHITESPACE_IGNORE_TRAILING:
             if (rtrim($o_desc['text']) == rtrim($n_desc['text'])) {
               $similar = true;
             }
             break;
         }
         if ($similar) {
           $o_desc['type'] = null;
           $n_desc['type'] = null;
           $skip_intra[count($old)] = true;
           $whitelines = true;
         } else {
           $changed = true;
         }
       } else {
         $changed = true;
       }
 
       $old[] = $o_desc;
       $new[] = $n_desc;
     }
 
     $this->old = $old;
     $this->new = $new;
 
     if ($this->subparser && false) { // TODO: This is bugged
 
       // Use the subparser's side-by-side line information -- notably, the
       // change types -- but replace all the line text with ours. This lets us
       // render whitespace-only changes without marking them as different.
 
       $old = $this->subparser->old;
       $new = $this->subparser->new;
 
       $old_text = ipull($this->old, 'text', 'line');
       $new_text = ipull($this->new, 'text', 'line');
 
       foreach ($old as $k => $desc) {
         if (empty($desc)) {
           continue;
         }
         $old[$k]['text'] = idx($old_text, $desc['line']);
       }
       foreach ($new as $k => $desc) {
         if (empty($desc)) {
           continue;
         }
         $new[$k]['text'] = idx($new_text, $desc['line']);
       }
 
       $this->old = $old;
       $this->new = $new;
     }
 
     $min_length = min(count($this->old), count($this->new));
     for ($ii = 0; $ii < $min_length; $ii++) {
       if ($this->old[$ii] || $this->new[$ii]) {
         if (isset($this->old[$ii]['text'])) {
           $otext = $this->old[$ii]['text'];
         } else {
           $otext = '';
         }
         if (isset($this->new[$ii]['text'])) {
           $ntext = $this->new[$ii]['text'];
         } else {
           $ntext = '';
         }
         if ($otext != $ntext && empty($skip_intra[$ii])) {
           $this->intra[$ii] = ArcanistDiffUtils::generateIntralineDiff(
             $otext,
             $ntext);
         }
       }
     }
 
     $lines_context = self::LINES_CONTEXT;
     $max_length = max(count($this->old), count($this->new));
     $old = $this->old;
     $new = $this->new;
     $visible = false;
     $last = 0;
     for ($cursor = -$lines_context; $cursor < $max_length; $cursor++) {
       $offset = $cursor + $lines_context;
       if ((isset($old[$offset]) && $old[$offset]['type']) ||
           (isset($new[$offset]) && $new[$offset]['type'])) {
         $visible = true;
         $last = $offset;
       } else if ($cursor > $last + $lines_context) {
         $visible = false;
       }
       if ($visible && $cursor > 0) {
         $this->visible[$cursor] = 1;
       }
     }
 
     $old_corpus = ipull($this->old, 'text');
     $old_corpus_block = implode("\n", $old_corpus);
 
     $new_corpus = ipull($this->new, 'text');
     $new_corpus_block = implode("\n", $new_corpus);
 
     if ($this->noHighlight) {
       $this->oldRender = explode("\n", phutil_escape_html($old_corpus_block));
       $this->newRender = explode("\n", phutil_escape_html($new_corpus_block));
     } else {
       $this->oldRender = $this->sourceHighlight($this->old, $old_corpus_block);
       $this->newRender = $this->sourceHighlight($this->new, $new_corpus_block);
     }
 
     $this->applyIntraline(
       $this->oldRender,
       ipull($this->intra, 0),
       $old_corpus);
     $this->applyIntraline(
       $this->newRender,
       ipull($this->intra, 1),
       $new_corpus);
 
     $this->tokenHighlight($this->oldRender);
     $this->tokenHighlight($this->newRender);
 
     $unchanged = false;
     if ($this->subparser && false) {
       $unchanged = $this->subparser->isUnchanged();
       $whitelines = $this->subparser->isWhitespaceOnly();
     } else if (!$changed) {
       $filetype = $this->changeset->getFileType();
       if ($filetype == DifferentialChangeType::FILE_TEXT ||
           $filetype == DifferentialChangeType::FILE_SYMLINK) {
         $unchanged = true;
       }
     }
 
     $generated = (strpos($new_corpus_block, '@'.'generated') !== false);
 
     $this->specialAttributes = array(
       self::ATTR_GENERATED  => $generated,
       self::ATTR_UNCHANGED  => $unchanged,
       self::ATTR_DELETED    => array_filter($this->old) &&
                                !array_filter($this->new),
       self::ATTR_WHITELINES => $whitelines
     );
   }
 
   public function loadCache() {
     if (!$this->changesetID) {
       return false;
     }
 
     $data = null;
 
     $changeset = new DifferentialChangeset();
     $conn_r = $changeset->establishConnection('r');
     $data = queryfx_one(
       $conn_r,
       'SELECT * FROM %T WHERE id = %d',
       $changeset->getTableName().'_parse_cache',
       $this->changesetID);
 
     if (!$data) {
       return false;
     }
 
     $data = json_decode($data['cache'], true);
     if (!is_array($data) || !$data) {
       return false;
     }
 
     foreach (self::getCacheableProperties() as $cache_key) {
       if (!array_key_exists($cache_key, $data)) {
         // If we're missing a cache key, assume we're looking at an old cache
         // and ignore it.
         return false;
       }
     }
 
     if ($data['cacheVersion'] !== self::CACHE_VERSION) {
       return false;
     }
 
     unset($data['cacheVersion'], $data['cacheHost']);
     $cache_prop = array_select_keys($data, self::getCacheableProperties());
     foreach ($cache_prop as $cache_key => $v) {
       $this->$cache_key = $v;
     }
 
     return true;
   }
 
   protected static function getCacheableProperties() {
     return array(
       'visible',
       'new',
       'old',
       'intra',
       'newRender',
       'oldRender',
       'specialAttributes',
       'missingOld',
       'missingNew',
       'cacheVersion',
       'cacheHost',
     );
   }
 
   public function saveCache() {
     if (!$this->changesetID) {
       return false;
     }
 
     $cache = array();
     foreach (self::getCacheableProperties() as $cache_key) {
       switch ($cache_key) {
         case 'cacheVersion':
           $cache[$cache_key] = self::CACHE_VERSION;
           break;
         case 'cacheHost':
           $cache[$cache_key] = php_uname('n');
           break;
         default:
           $cache[$cache_key] = $this->$cache_key;
           break;
       }
     }
     $cache = json_encode($cache);
 
     try {
       $changeset = new DifferentialChangeset();
       $conn_w = $changeset->establishConnection('w');
       queryfx(
         $conn_w,
         'INSERT INTO %T (id, cache) VALUES (%d, %s)
           ON DUPLICATE KEY UPDATE cache = VALUES(cache)',
         $changeset->getTableName().'_parse_cache',
         $this->changesetID,
         $cache);
     } catch (QueryException $ex) {
       // TODO: uhoh
     }
   }
 
   public function isGenerated() {
     return idx($this->specialAttributes, self::ATTR_GENERATED, false);
   }
 
   public function isDeleted() {
     return idx($this->specialAttributes, self::ATTR_DELETED, false);
   }
 
   public function isUnchanged() {
     return idx($this->specialAttributes, self::ATTR_UNCHANGED, false);
   }
 
   public function isWhitespaceOnly() {
     return idx($this->specialAttributes, self::ATTR_WHITELINES, false);
   }
 
   public function getLength() {
     return max(count($this->old), count($this->new));
   }
 
   protected function applyIntraline(&$render, $intra, $corpus) {
     foreach ($render as $key => $text) {
       if (isset($intra[$key])) {
         $render[$key] = ArcanistDiffUtils::applyIntralineDiff(
           $text,
           $intra[$key]);
       }
       if (isset($corpus[$key]) && strlen($corpus[$key]) > 80) {
         $render[$key] = $this->lineWrap($render[$key]);
       }
     }
   }
 
   protected function lineWrap($l) {
     $c = 0;
     $len = strlen($l);
     $ins = array();
     for ($ii = 0; $ii < $len; ++$ii) {
       if ($l[$ii] == '&') {
         do {
           ++$ii;
         } while ($l[$ii] != ';');
         ++$c;
       } else if ($l[$ii] == '<') {
         do {
           ++$ii;
         } while ($l[$ii] != '>');
       } else {
         ++$c;
       }
       if ($c == 80) {
         $ins[] = ($ii + 1);
         $c = 0;
       }
     }
     while (($pos = array_pop($ins))) {
       $l = substr_replace(
         $l,
         "<span class=\"over-the-line\">\xE2\xAC\x85</span><br />",
         $pos,
         0);
     }
     return $l;
   }
 
 
   protected function tokenHighlight(&$render) {
     foreach ($render as $key => $text) {
       $render[$key] = str_replace(
       "\0",
       '<span class="uu">'."\xEF\xBF\xBD".'</span>',
       $text);
     }
   }
 
   protected function sourceHighlight($data, $corpus) {
     $result = $this->highlightEngine->highlightSource(
       $this->filetype,
       $corpus);
 
     $result_lines = explode("\n", $result);
     foreach ($data as $key => $info) {
       if (!$info) {
         unset($result_lines[$key]);
       }
     }
     return $result_lines;
   }
 
   private function tryCacheStuff() {
     $whitespace_mode = $this->whitespaceMode;
     switch ($whitespace_mode) {
       case self::WHITESPACE_SHOW_ALL:
       case self::WHITESPACE_IGNORE_TRAILING:
         break;
       default:
         $whitespace_mode = self::WHITESPACE_IGNORE_ALL;
         break;
     }
 
     $skip_cache = ($whitespace_mode != self::WHITESPACE_IGNORE_ALL);
     $this->whitespaceMode = $whitespace_mode;
 
     $changeset = $this->changeset;
 
     if ($changeset->getFileType() == DifferentialChangeType::FILE_TEXT ||
         $changeset->getFileType() == DifferentialChangeType::FILE_SYMLINK) {
       if ($skip_cache || !$this->loadCache()) {
         if ($this->whitespaceMode == self::WHITESPACE_IGNORE_ALL) {
 
           // Huge mess. Generate a "-bw" (ignore all whitespace changes) diff,
           // parse it out, and then play a shell game with the parsed format
           // in process() so we highlight only changed lines but render
           // whitespace differences. If we don't do this, we either fail to
           // render whitespace changes (which is incredibly confusing,
           // especially for python) or often produce a much larger set of
           // differences than necessary.
 
           $old_tmp = new TempFile();
           $new_tmp = new TempFile();
           Filesystem::writeFile($old_tmp, $changeset->makeOldFile());
           Filesystem::writeFile($new_tmp, $changeset->makeNewFile());
           list($err, $diff) = exec_manual(
             'diff -bw -U65535 %s %s',
             $old_tmp,
             $new_tmp);
 
           if (!strlen($diff)) {
             // If there's no diff text, that means the files are identical
             // except for whitespace changes. Build a synthetic, changeless
             // diff. TODO: this is incredibly hacky.
             $entire_file = explode("\n", $changeset->makeOldFile());
             foreach ($entire_file as $k => $line) {
               $entire_file[$k] = ' '.$line;
             }
             $len = count($entire_file);
             $entire_file = implode("\n", $entire_file);
 
             $diff = <<<EOSYNTHETIC
 --- ignored 9999-99-99
 +++ ignored 9999-99-99
 @@ -{$len},{$len} +{$len},{$len} @@
 {$entire_file}
 EOSYNTHETIC;
           }
 
           $changes = id(new ArcanistDiffParser())->parseDiff($diff);
 
           $diff = DifferentialDiff::newFromRawChanges($changes);
           $changesets = $diff->getChangesets();
           $alt_changeset = reset($changesets);
 
           $this->subparser = new DifferentialChangesetParser();
           $this->subparser->setChangeset($alt_changeset);
           $this->subparser->setWhitespaceMode(self::WHITESPACE_IGNORE_TRAILING);
         }
         foreach ($changeset->getHunks() as $hunk) {
           $this->parseHunk($hunk);
         }
         $this->process();
         if (!$skip_cache) {
           $this->saveCache();
         }
       }
     }
   }
 
   public function render(
     $range_start  = null,
     $range_len    = null,
     $mask_force   = array()) {
 
     $this->highlightEngine = new PhutilDefaultSyntaxHighlighterEngine();
 
     $this->tryCacheStuff();
 
     $changeset_id = $this->changesetID;
 
     $feedback_mask = array();
 
     switch ($this->changeset->getFileType()) {
       case DifferentialChangeType::FILE_IMAGE:
         $old = null;
         $cur = null;
 
         $metadata = $this->changeset->getMetadata();
         $data = idx($metadata, 'attachment-data');
 
         $old_phid = idx($metadata, 'old:binary-phid');
         $new_phid = idx($metadata, 'new:binary-phid');
         if ($old_phid || $new_phid) {
           if ($old_phid) {
             $old_uri = PhabricatorFileURI::getViewURIForPHID($old_phid);
             $old = phutil_render_tag(
               'img',
               array(
                 'src' => $old_uri,
               ));
           }
           if ($new_phid) {
             $new_uri = PhabricatorFileURI::getViewURIForPHID($new_phid);
             $cur = phutil_render_tag(
               'img',
               array(
                 'src' => $new_uri,
               ));
           }
         }
 
         $output = $this->renderChangesetTable(
           $this->changeset,
           '<tr>'.
             '<th></th>'.
             '<td class="differential-old-image">'.
               '<div class="differential-image-stage">'.
                 $old.
               '</div>'.
             '</td>'.
             '<th></th>'.
             '<td class="differential-new-image">'.
               '<div class="differential-image-stage">'.
                 $cur.
               '</div>'.
             '</td>'.
           '</tr>');
 
         return $output;
       case DifferentialChangeType::FILE_DIRECTORY:
       case DifferentialChangeType::FILE_BINARY:
         $output = $this->renderChangesetTable($this->changeset, null);
         return $output;
     }
 
     $shield = null;
     if ($range_start === null && $range_len === null) {
       if ($this->isGenerated()) {
         $shield = $this->renderShield(
           "This file contains generated code, which does not normally need ".
           "to be reviewed.",
           true);
       } else if ($this->isUnchanged()) {
         if ($this->isWhitespaceOnly()) {
           $shield = $this->renderShield(
             "This file was changed only by adding or removing trailing ".
             "whitespace.",
             false);
         } else {
           $shield = $this->renderShield(
             "The contents of this file were not changed.",
             false);
         }
       } else if ($this->isDeleted()) {
         $shield = $this->renderShield(
           "This file was completely deleted.",
           true);
       } else if ($this->changeset->getAffectedLineCount() > 2500) {
         $lines = number_format($this->changeset->getAffectedLineCount());
         $shield = $this->renderShield(
           "This file has a very large number of changes ({$lines} lines).",
           true);
       } else if (preg_match('/\.sql3$/', $this->changeset->getFilename())) {
         $shield = $this->renderShield(
           ".sql3 files are hidden by default.",
           true);
       }
     }
 
     if ($shield) {
       return $this->renderChangesetTable($this->changeset, $shield);
     }
 
     $old_comments = array();
     $new_comments = array();
 
     $old_mask = array();
     $new_mask = array();
     $feedback_mask = array();
 
     if ($this->comments) {
       foreach ($this->comments as $comment) {
         $start = max($comment->getLineNumber() - self::LINES_CONTEXT, 0);
         $end = $comment->getLineNumber() +
                $comment->getLineLength() +
                self::LINES_CONTEXT;
         $new = $this->isCommentInNewFile($comment);
         for ($ii = $start; $ii <= $end; $ii++) {
           if ($new) {
             $new_mask[$ii] = true;
           } else {
             $old_mask[$ii] = true;
           }
         }
       }
 
       foreach ($this->old as $ii => $old) {
         if (isset($old['line']) && isset($old_mask[$old['line']])) {
           $feedback_mask[$ii] = true;
         }
       }
 
       foreach ($this->new as $ii => $new) {
         if (isset($new['line']) && isset($new_mask[$new['line']])) {
           $feedback_mask[$ii] = true;
         }
       }
       $this->comments = msort($this->comments, 'getID');
       foreach ($this->comments as $comment) {
         $final = $comment->getLineNumber() +
                  $comment->getLineLength();
         if ($this->isCommentInNewFile($comment)) {
           $new_comments[$final][] = $comment;
         } else {
           $old_comments[$final][] = $comment;
         }
       }
     }
 
     $html = $this->renderTextChange(
       $range_start,
       $range_len,
       $mask_force,
       $feedback_mask,
       $old_comments,
       $new_comments);
 
     return $this->renderChangesetTable($this->changeset, $html);
   }
 
   private function isCommentInNewFile(DifferentialInlineComment $comment) {
     if ($this->oldChangesetID) {
       return ($comment->getChangesetID() != $this->oldChangesetID);
     } else {
       return $comment->getIsNewFile();
     }
   }
 
   protected function renderShield($message, $more) {
     $end = $this->getLength();
     $changeset_id = $this->getChangesetID();
 
     if ($more) {
       $more =
         ' '.
         javelin_render_tag(
           'a',
           array(
             'mustcapture' => true,
             'sigil'       => 'show-more',
             'class'       => 'complete',
             'href'        => '#',
             'meta'        => array(
               'id'    => $changeset_id,
               'range' => "0-{$end}",
             ),
           ),
           'Show File Contents');
     } else {
       $more = null;
     }
 
     return javelin_render_tag(
       'tr',
       array(
         'sigil' => 'context-target',
       ),
       '<td class="differential-shield" colspan="4">'.
         phutil_escape_html($message).
         $more.
       '</td>');
   }
 
   protected function renderTextChange(
     $range_start,
     $range_len,
     $mask_force,
     $feedback_mask,
     array $old_comments,
     array $new_comments) {
 
     $context_not_available = null;
     if ($this->missingOld || $this->missingNew) {
       $context_not_available = javelin_render_tag(
         'tr',
         array(
           'sigil' => 'context-target',
         ),
         '<td colspan="4" class="show-more">'.
             'Context not available.'.
         '</td>');
       $context_not_available = $context_not_available;
     }
 
     $html = array();
 
     $rows = max(
       count($this->old),
       count($this->new));
 
     if ($range_start === null) {
       $range_start = 0;
     }
 
     if ($range_len === null) {
       $range_len = $rows;
     }
 
     $range_len = min($range_len, $rows - $range_start);
 
     $gaps = array();
     $gap_start = 0;
     $in_gap = false;
     $mask = $this->visible + $mask_force + $feedback_mask;
     $mask[$range_start + $range_len] = true;
     for ($ii = $range_start; $ii <= $range_start + $range_len; $ii++) {
       if (isset($mask[$ii])) {
         if ($in_gap) {
           $gap_length = $ii - $gap_start;
           if ($gap_length <= self::LINES_CONTEXT) {
             for ($jj = $gap_start; $jj <= $gap_start + $gap_length; $jj++) {
               $mask[$jj] = true;
             }
           } else {
             $gaps[] = array($gap_start, $gap_length);
           }
           $in_gap = false;
         }
       } else {
         if (!$in_gap) {
           $gap_start = $ii;
           $in_gap = true;
         }
       }
     }
 
     $gaps = array_reverse($gaps);
 
     $changeset = $this->changesetID;
 
     for ($ii = $range_start; $ii < $range_start + $range_len; $ii++) {
       if (empty($mask[$ii])) {
         $gap = array_pop($gaps);
         $top = $gap[0];
         $len = $gap[1];
 
         $end   = $top + $len - 20;
 
         $contents = array();
 
         if ($len > 40) {
           $contents[] = javelin_render_tag(
             'a',
             array(
               'href' => '#',
               'mustcapture' => true,
               'sigil'       => 'show-more',
               'meta'        => array(
                 'id'    => $changeset,
                 'range' => "{$top}-{$len}/{$top}-20",
               ),
             ),
             "\xE2\x96\xB2 Show 20 Lines");
         }
 
         $contents[] = javelin_render_tag(
           'a',
           array(
             'href' => '#',
             'mustcapture' => true,
             'sigil'       => 'show-more',
             'meta'        => array(
               'id'    => $changeset,
               'range' => "{$top}-{$len}/{$top}-{$len}",
             ),
           ),
           'Show All '.$len.' Lines');
 
         if ($len > 40) {
           $contents[] = javelin_render_tag(
             'a',
             array(
               'href' => '#',
               'mustcapture' => true,
               'sigil'       => 'show-more',
               'meta'        => array(
                 'id'    => $changeset,
                 'range' => "{$top}-{$len}/{$end}-20",
               ),
             ),
             "\xE2\x96\xBC Show 20 Lines");
         };
 
         $container = javelin_render_tag(
           'tr',
           array(
             'sigil' => 'context-target',
           ),
           '<td colspan="4" class="show-more">'.
             implode(' &bull; ', $contents).
           '</td>');
 
         $html[] = $container;
 
         $ii += ($len - 1);
         continue;
       }
 
       if (isset($this->old[$ii])) {
         $o_num  = $this->old[$ii]['line'];
-        $o_text = $this->oldRender[$ii];
+        $o_text = isset($this->oldRender[$ii]) ? $this->oldRender[$ii] : null;
         $o_attr = null;
         if ($this->old[$ii]['type']) {
           if (empty($this->new[$ii])) {
             $o_attr = ' class="old old-full"';
           } else {
             $o_attr = ' class="old"';
           }
         }
       } else {
         $o_num  = null;
         $o_text = null;
         $o_attr = null;
       }
 
       if (isset($this->new[$ii])) {
         $n_num  = $this->new[$ii]['line'];
-        $n_text = $this->newRender[$ii];
+        $n_text = isset($this->newRender[$ii]) ? $this->newRender[$ii] : null;
         $n_attr = null;
         if ($this->new[$ii]['type']) {
           if (empty($this->old[$ii])) {
             $n_attr = ' class="new new-full"';
           } else {
             $n_attr = ' class="new"';
           }
         }
       } else {
         $n_num   = null;
         $n_text  = null;
         $n_attr  = null;
       }
 
 
       if (($o_num && !empty($this->missingOld[$o_num])) ||
           ($n_num && !empty($this->missingNew[$n_num]))) {
         $html[] = $context_not_available;
       }
 
       if ($o_num) {
         $o_id = ' id="C'.$changeset.'OL'.$o_num.'"';
       } else {
         $o_id = null;
       }
 
       if ($n_num) {
         $n_id = ' id="C'.$changeset.'NL'.$n_num.'"';
       } else {
         $n_id = null;
       }
 
       // NOTE: The Javascript is sensitive to whitespace changes in this
       // block!
       $html[] =
         '<tr>'.
           '<th'.$o_id.'>'.$o_num.'</th>'.
           '<td'.$o_attr.'>'.$o_text.'</td>'.
           '<th'.$n_id.'>'.$n_num.'</th>'.
           '<td'.$n_attr.'>'.$n_text.'</td>'.
         '</tr>';
 
       if ($context_not_available && ($ii == $rows - 1)) {
         $html[] = $context_not_available;
       }
 
       if ($o_num && isset($old_comments[$o_num])) {
         foreach ($old_comments[$o_num] as $comment) {
           $xhp = $this->renderInlineComment($comment);
           $html[] =
             '<tr class="inline"><th /><td>'.
               $xhp.
             '</td><th /><td /></tr>';
         }
       }
       if ($n_num && isset($new_comments[$n_num])) {
         foreach ($new_comments[$n_num] as $comment) {
           $xhp = $this->renderInlineComment($comment);
           $html[] =
             '<tr class="inline"><th /><td /><th /><td>'.
               $xhp.
             '</td></tr>';
         }
       }
     }
 
     return implode('', $html);
   }
 
   private function renderInlineComment(DifferentialInlineComment $comment) {
 
     $user = $this->user;
     $edit = $user &&
             ($comment->getAuthorPHID() == $user->getPHID()) &&
             (!$comment->getCommentID());
 
     $on_right = $this->isCommentInNewFile($comment);
 
     return id(new DifferentialInlineCommentView())
       ->setInlineComment($comment)
       ->setOnRight($on_right)
       ->setHandles($this->handles)
       ->setMarkupEngine($this->markupEngine)
       ->setEditable($edit)
       ->render();
   }
 
   protected function renderPropertyChangeHeader($changeset) {
     $old = $changeset->getOldProperties();
     $new = $changeset->getNewProperties();
 
     if ($old === $new) {
       return null;
     }
 
     if ($changeset->getChangeType() == DifferentialChangeType::TYPE_ADD &&
         $new == array('unix:filemode' => '100644')) {
       return null;
     }
 
     if ($changeset->getChangeType() == DifferentialChangeType::TYPE_DELETE &&
         $old == array('unix:filemode' => '100644')) {
       return null;
     }
 
     return null;
 /*
   TODO
 
     $table = <table class="differential-property-table" />;
     $table->appendChild(
       <tr class="property-table-header">
         <th>Property Changes</th>
         <td class="oval">Old Value</td>
         <td class="nval">New Value</td>
       </tr>);
 
     $keys = array_keys($old + $new);
     sort($keys);
     foreach ($keys as $key) {
       $oval = idx($old, $key);
       $nval = idx($new, $key);
       if ($oval !== $nval) {
         if ($oval === null) {
           $oval = <em>null</em>;
         }
         if ($nval === null) {
           $nval = <em>null</em>;
         }
         $table->appendChild(
           <tr>
             <th>{$key}</th>
             <td class="oval">{$oval}</td>
             <td class="nval">{$nval}</td>
           </tr>);
       }
     }
 
     return $table;
 */
   }
 
   protected function renderChangesetTable($changeset, $contents) {
     $props  = $this->renderPropertyChangeHeader($this->changeset);
     $table = null;
     if ($contents) {
       $table =
         '<table class="differential-diff remarkup-code">'.
           $contents.
         '</table>';
     }
 
     if (!$table && !$props) {
       $notice = $this->renderChangeTypeHeader($this->changeset, true);
     } else {
       $notice = $this->renderChangeTypeHeader($this->changeset, false);
     }
 
     return implode(
       "\n",
       array(
         $notice,
         $props,
         $table,
       ));
   }
 
   protected function renderChangeTypeHeader($changeset, $force) {
 
     static $articles = array(
       DifferentialChangeType::FILE_IMAGE      => 'an',
     );
 
     static $files = array(
       DifferentialChangeType::FILE_TEXT       => 'file',
       DifferentialChangeType::FILE_IMAGE      => 'image',
       DifferentialChangeType::FILE_DIRECTORY  => 'directory',
       DifferentialChangeType::FILE_BINARY     => 'binary file',
       DifferentialChangeType::FILE_SYMLINK    => 'symlink',
     );
 
     static $changes = array(
       DifferentialChangeType::TYPE_ADD        => 'added',
       DifferentialChangeType::TYPE_CHANGE     => 'changed',
       DifferentialChangeType::TYPE_DELETE     => 'deleted',
       DifferentialChangeType::TYPE_MOVE_HERE  => 'moved from',
       DifferentialChangeType::TYPE_COPY_HERE  => 'copied from',
       DifferentialChangeType::TYPE_MOVE_AWAY  => 'moved to',
       DifferentialChangeType::TYPE_COPY_AWAY  => 'copied to',
       DifferentialChangeType::TYPE_MULTICOPY
         => 'deleted after being copied to',
     );
 
     $change = $changeset->getChangeType();
     $file = $changeset->getFileType();
 
     $message = null;
     if ($change == DifferentialChangeType::TYPE_CHANGE &&
         $file   == DifferentialChangeType::FILE_TEXT) {
       if ($force) {
         // We have to force something to render because there were no changes
         // of other kinds.
         $message = "This {$files[$file]} was not modified.";
       } else {
         // Default case of changes to a text file, no metadata.
         return null;
       }
     } else {
       $verb = idx($changes, $change, 'changed');
       switch ($change) {
         default:
           $message = "This {$files[$file]} was <strong>{$verb}</strong>.";
           break;
         case DifferentialChangeType::TYPE_MOVE_HERE:
         case DifferentialChangeType::TYPE_COPY_HERE:
           $message =
             "This {$files[$file]} was {$verb} ".
             "<strong>{$changeset->getOldFile()}</strong>.";
           break;
         case DifferentialChangeType::TYPE_MOVE_AWAY:
         case DifferentialChangeType::TYPE_COPY_AWAY:
         case DifferentialChangeType::TYPE_MULTICOPY:
           $paths = $changeset->getAwayPaths();
           if (count($paths) > 1) {
             $message =
               "This {$files[$file]} was {$verb}: ".
               "<strong>".implode(', ', $paths)."</strong>.";
           } else {
             $message =
               "This {$files[$file]} was {$verb} ".
               "<strong>".reset($paths)."</strong>.";
           }
           break;
         case DifferentialChangeType::TYPE_CHANGE:
           $message = "This is ".idx($articles, $file, 'a')." {$files[$file]}.";
           break;
       }
     }
 
     return
       '<div class="differential-meta-notice">'.
         $message.
       '</div>';
   }
 
   public function renderForEmail() {
     $ret = '';
 
     $min = min(count($this->old), count($this->new));
     for ($i = 0; $i < $min; $i++) {
       $o = $this->old[$i];
       $n = $this->new[$i];
 
       if (!isset($this->visible[$i])) {
         continue;
       }
 
       if ($o['line'] && $n['line']) {
         // It is quite possible there are better ways to achieve this. For
         // example, "white-space: pre;" can do a better job, WERE IT NOT for
         // broken email clients like OWA which use newlines to do weird
         // wrapping. So dont give them newlines.
         if (isset($this->intra[$i])) {
           $ret .= sprintf(
             "<font color=\"red\">-&nbsp;%s</font><br/>",
             str_replace(" ", "&nbsp;", phutil_escape_html($o['text']))
           );
           $ret .= sprintf(
             "<font color=\"green\">+&nbsp;%s</font><br/>",
             str_replace(" ", "&nbsp;", phutil_escape_html($n['text']))
           );
         } else {
           $ret .= sprintf("&nbsp;&nbsp;%s<br/>",
             str_replace(" ", "&nbsp;", phutil_escape_html($n['text']))
           );
         }
       } else if ($o['line'] && !$n['line']) {
         $ret .= sprintf(
           "<font color=\"red\">-&nbsp;%s</font><br/>",
           str_replace(" ", "&nbsp;", phutil_escape_html($o['text']))
         );
       } else {
         $ret .= sprintf(
           "<font color=\"green\">+&nbsp;%s</font><br/>",
           str_replace(" ", "&nbsp;", phutil_escape_html($n['text']))
         );
       }
     }
 
     return $ret;
   }
 
 }
diff --git a/src/applications/differential/storage/changeset/DifferentialChangeset.php b/src/applications/differential/storage/changeset/DifferentialChangeset.php
index 794ef437b0..9fde61affb 100644
--- a/src/applications/differential/storage/changeset/DifferentialChangeset.php
+++ b/src/applications/differential/storage/changeset/DifferentialChangeset.php
@@ -1,147 +1,147 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class DifferentialChangeset extends DifferentialDAO {
 
   protected $diffID;
   protected $oldFile;
   protected $fileName;
   protected $awayPaths;
   protected $changeType;
   protected $fileType;
   protected $metadata;
   protected $oldProperties;
   protected $newProperties;
   protected $addLines;
   protected $delLines;
 
   private $unsavedHunks = array();
   private $hunks;
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_SERIALIZATION => array(
         'metadata'      => self::SERIALIZATION_JSON,
         'oldProperties' => self::SERIALIZATION_JSON,
         'newProperties' => self::SERIALIZATION_JSON,
         'awayPaths'     => self::SERIALIZATION_JSON,
       )) + parent::getConfiguration();
   }
 
   public function getAffectedLineCount() {
     return $this->getAddLines() + $this->getDelLines();
   }
 
   public function getFileType() {
     return $this->fileType;
   }
 
   public function getChangeType() {
     return $this->changeType;
   }
 
   public function attachHunks(array $hunks) {
     $this->hunks = $hunks;
     return $this;
   }
 
   public function getHunks() {
     if ($this->hunks === null) {
       throw new Exception("Must load and attach hunks first!");
     }
     return $this->hunks;
   }
 
   public function getDisplayFilename() {
     $name = $this->getFilename();
     if ($this->getFileType() == DifferentialChangeType::FILE_DIRECTORY) {
       $name .= '/';
     }
     return $name;
   }
 
   public function addUnsavedHunk(DifferentialHunk $hunk) {
     if ($this->hunks === null) {
       $this->hunks = array();
     }
     $this->hunks[] = $hunk;
     $this->unsavedHunks[] = $hunk;
     return $this;
   }
 
   public function loadHunks() {
     if (!$this->getID()) {
       return array();
     }
     return id(new DifferentialHunk())->loadAllWhere(
       'changesetID = %d',
       $this->getID());
   }
 
   public function save() {
 // TODO: Sort out transactions
 //    $this->openTransaction();
       $ret = parent::save();
       foreach ($this->unsavedHunks as $hunk) {
         $hunk->setChangesetID($this->getID());
         $hunk->save();
       }
 //    $this->saveTransaction();
     return $ret;
   }
 
   public function delete() {
 //    $this->openTransaction();
       foreach ($this->loadHunks() as $hunk) {
         $hunk->delete();
       }
       $this->_hunks = array();
     $ret = parent::delete();
 //    $this->saveTransaction();
     return $ret;
   }
 
   public function getSortKey() {
     $sort_key = $this->getFilename();
     // Sort files with ".h" in them first, so headers (.h, .hpp) come before
     // implementations (.c, .cpp, .cs).
     $sort_key = str_replace('.h', '.!h', $sort_key);
     return $sort_key;
   }
 
   public function makeNewFile() {
     $file = array();
     foreach ($this->getHunks() as $hunk) {
       $file[] = $hunk->makeNewFile();
     }
     return implode("\n", $file);
   }
 
   public function makeOldFile() {
     $file = array();
     foreach ($this->getHunks() as $hunk) {
       $file[] = $hunk->makeOldFile();
     }
     return implode("\n", $file);
   }
-  
+
   public function getAnchorName() {
     return substr(md5($this->getFilename()), 0, 8);
   }
 
 }
diff --git a/src/applications/differential/storage/diff/DifferentialDiff.php b/src/applications/differential/storage/diff/DifferentialDiff.php
index 3a89cc4161..a76626cebc 100644
--- a/src/applications/differential/storage/diff/DifferentialDiff.php
+++ b/src/applications/differential/storage/diff/DifferentialDiff.php
@@ -1,137 +1,139 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class DifferentialDiff extends DifferentialDAO {
 
   protected $revisionID;
   protected $authorPHID;
 
   protected $sourceMachine;
   protected $sourcePath;
 
   protected $sourceControlSystem;
   protected $sourceControlBaseRevision;
   protected $sourceControlPath;
 
   protected $lintStatus;
   protected $unitStatus;
 
   protected $lineCount;
 
   protected $branch;
 
   protected $parentRevisionID;
   protected $arcanistProject;
   protected $creationMethod;
 
+  protected $description;
+
   private $unsavedChangesets = array();
   private $changesets;
 
   public function addUnsavedChangeset(DifferentialChangeset $changeset) {
     if ($this->changesets === null) {
       $this->changesets = array();
     }
     $this->unsavedChangesets[] = $changeset;
     $this->changesets[] = $changeset;
     return $this;
   }
 
   public function attachChangesets(array $changesets) {
     $this->changesets = $changesets;
     return $this;
   }
 
   public function getChangesets() {
     if ($this->changesets === null) {
       throw new Exception("Must load and attach changesets first!");
     }
     return $this->changesets;
   }
 
   public function loadChangesets() {
     if (!$this->getID()) {
       return array();
     }
     return id(new DifferentialChangeset())->loadAllWhere(
       'diffID = %d',
       $this->getID());
   }
 
   public function save() {
 // TODO: sort out transactions
 //    $this->openTransaction();
       $ret = parent::save();
       foreach ($this->unsavedChangesets as $changeset) {
         $changeset->setDiffID($this->getID());
         $changeset->save();
       }
 //    $this->saveTransaction();
     return $ret;
   }
 
   public function delete() {
 //    $this->openTransaction();
       foreach ($this->loadChangesets() as $changeset) {
         $changeset->delete();
       }
       $ret = parent::delete();
 //    $this->saveTransaction();
     return $ret;
   }
 
   public static function newFromRawChanges(array $changes) {
     $diff = new DifferentialDiff();
 
     $lines = 0;
     foreach ($changes as $change) {
       $changeset = new DifferentialChangeset();
       $add_lines = 0;
       $del_lines = 0;
       foreach ($change->getHunks() as $hunk) {
         $dhunk = new DifferentialHunk();
         $dhunk->setOldOffset($hunk->getOldOffset());
         $dhunk->setOldLen($hunk->getOldLength());
         $dhunk->setNewOffset($hunk->getNewOffset());
         $dhunk->setNewLen($hunk->getNewLength());
         $dhunk->setChanges($hunk->getCorpus());
         $changeset->addUnsavedHunk($dhunk);
         $add_lines += $hunk->getAddLines();
         $del_lines += $hunk->getDelLines();
         $lines += $add_lines + $del_lines;
       }
 
       $changeset->setOldFile($change->getOldPath());
       $changeset->setFilename($change->getCurrentPath());
       $changeset->setChangeType($change->getType());
 
       $changeset->setFileType($change->getFileType());
       $changeset->setMetadata($change->getAllMetadata());
       $changeset->setOldProperties($change->getOldProperties());
       $changeset->setNewProperties($change->getNewProperties());
       $changeset->setAwayPaths($change->getAwayPaths());
       $changeset->setAddLines($add_lines);
       $changeset->setDelLines($del_lines);
 
       $diff->addUnsavedChangeset($changeset);
     }
     $diff->setLineCount($lines);
 
     return $diff;
   }
 
 }
diff --git a/src/applications/differential/view/changesetlistview/DifferentialChangesetListView.php b/src/applications/differential/view/changesetlistview/DifferentialChangesetListView.php
index e05ae7a836..fe526ae440 100644
--- a/src/applications/differential/view/changesetlistview/DifferentialChangesetListView.php
+++ b/src/applications/differential/view/changesetlistview/DifferentialChangesetListView.php
@@ -1,128 +1,128 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class DifferentialChangesetListView extends AphrontView {
 
   private $changesets = array();
   private $editable;
   private $revision;
-  private $vsMap;
+  private $vsMap = array();
 
   public function setChangesets($changesets) {
     $this->changesets = $changesets;
     return $this;
   }
 
   public function setEditable($editable) {
     $this->editable = $editable;
     return $this;
   }
 
   public function setRevision(DifferentialRevision $revision) {
     $this->revision = $revision;
     return $this;
   }
 
   public function setVsMap(array $vs_map) {
     $this->vsMap = $vs_map;
     return $this;
   }
 
   public function render() {
     require_celerity_resource('differential-changeset-view-css');
 
     $vs_map = $this->vsMap;
     $changesets = $this->changesets;
 
     $output = array();
     $mapping = array();
     foreach ($changesets as $key => $changeset) {
       $file = $changeset->getFilename();
       $class = 'differential-changeset';
       if (!$this->editable) {
         $class .= ' differential-changeset-noneditable';
       }
       $id = $changeset->getID();
       if ($id) {
         $vs_id = idx($vs_map, $id);
       } else {
         $vs_id = null;
       }
 
       $detail_uri = new PhutilURI('/differential/changeset/');
       $detail_uri->setQueryParams(
         array(
           'id'          => $id,
           'vs'          => $vs_id,
           'whitespace'  => 'TODO',
         ));
 
       $detail_button = phutil_render_tag(
         'a',
         array(
           'style'   => 'float: right',
           'class'   => 'button small grey',
           'href'    => $detail_uri,
           'target'  => '_blank',
         ),
         'Standalone View');
 
       $uniq_id = celerity_generate_unique_node_id();
 
       $detail = new DifferentialChangesetDetailView();
       $detail->setChangeset($changeset);
       $detail->addButton($detail_button);
       $detail->appendChild(
         phutil_render_tag(
           'div',
           array(
             'id' => $uniq_id,
           ),
           '<div class="differential-loading">Loading...</div>'));
       $output[] = $detail->render();
 
       $mapping[$uniq_id] = array(
         $changeset->getID(),
         $vs_id);
     }
 
     $whitespace = null;
     Javelin::initBehavior('differential-populate', array(
       'registry'    => $mapping,
       'whitespace'  => $whitespace,
       'uri'         => '/differential/changeset/',
     ));
 
     Javelin::initBehavior('differential-show-more', array(
       'uri' => '/differential/changeset/',
     ));
 
     if ($this->editable) {
       $revision = $this->revision;
       Javelin::initBehavior('differential-edit-inline-comments', array(
         'uri' => '/differential/comment/inline/edit/'.$revision->getID().'/',
       ));
     }
 
     return
       '<div class="differential-review-stage">'.
         implode("\n", $output).
       '</div>';
   }
 
 }
diff --git a/src/applications/differential/view/revisionupdatehistory/DifferentialRevisionUpdateHistoryView.php b/src/applications/differential/view/revisionupdatehistory/DifferentialRevisionUpdateHistoryView.php
index 17fc0d3e28..d7fcd54c9a 100644
--- a/src/applications/differential/view/revisionupdatehistory/DifferentialRevisionUpdateHistoryView.php
+++ b/src/applications/differential/view/revisionupdatehistory/DifferentialRevisionUpdateHistoryView.php
@@ -1,179 +1,261 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 final class DifferentialRevisionUpdateHistoryView extends AphrontView {
 
   private $diffs = array();
   private $selectedVersusDiffID;
   private $selectedDiffID;
 
   public function setDiffs($diffs) {
     $this->diffs = $diffs;
     return $this;
   }
 
   public function setSelectedVersusDiffID($id) {
     $this->selectedVersusDiffID = $id;
     return $this;
   }
 
   public function setSelectedDiffID($id) {
     $this->selectedDiffID = $id;
     return $this;
   }
 
   public function render() {
 
     require_celerity_resource('differential-core-view-css');
     require_celerity_resource('differential-revision-history-css');
 
     $data = array(
       array(
         'name' => 'Base',
         'id'   => null,
         'desc' => 'Base',
         'age'  => null,
-        'lint' => null,
-        'unit' => null,
+        'obj'  => null,
       ),
     );
 
     $seq = 0;
     foreach ($this->diffs as $diff) {
       $data[] = array(
         'name' => 'Diff '.(++$seq),
         'id'   => $diff->getID(),
-        'desc' => 'TODO',//$diff->getDescription(),
+        'desc' => $diff->getDescription(),
         'age'  => $diff->getDateCreated(),
-        'lint' => $diff->getLintStatus(),
-        'unit' => $diff->getUnitStatus(),
+        'obj'  => $diff,
       );
     }
 
     $max_id = $diff->getID();
 
     $idx = 0;
     $rows = array();
     $disable = false;
     $radios = array();
     foreach ($data as $row) {
 
       $name = phutil_escape_html($row['name']);
       $id   = phutil_escape_html($row['id']);
 
-      $lint = '*';
-      $unit = '*';
-
       $old_class = null;
       $new_class = null;
 
       if ($id) {
         $new_checked = ($this->selectedDiffID == $id);
         $new = javelin_render_tag(
           'input',
           array(
             'type' => 'radio',
             'name' => 'id',
             'value' => $id,
             'checked' => $new_checked ? 'checked' : null,
             'sigil' => 'differential-new-radio',
           ));
         if ($new_checked) {
           $new_class = " revhistory-new-now";
           $disable = true;
         }
       } else {
         $new = null;
       }
 
       if ($max_id != $id) {
         $uniq = celerity_generate_unique_node_id();
         $old_checked = ($this->selectedVersusDiffID == $id);
         $old = phutil_render_tag(
           'input',
           array(
             'type' => 'radio',
             'name' => 'vs',
             'value' => $id,
             'id' => $uniq,
             'checked' => $old_checked ? 'checked' : null,
             'disabled' => $disable ? 'disabled' : null,
           ));
         $radios[] = $uniq;
         if ($old_checked) {
           $old_class = " revhistory-old-now";
         }
       } else {
         $old = null;
       }
 
-      $desc = 'TODO';
-      $age = '-';
+      $desc = phutil_escape_html($row['desc']);
+      if ($row['age']) {
+        $age = phabricator_format_timestamp($row['age']);
+      } else {
+        $age = null;
+      }
 
       if (++$idx % 2) {
         $class = ' class="alt"';
       } else {
         $class = null;
       }
 
+      if ($row['obj']) {
+        $lint = self::renderDiffLintStar($row['obj']);
+        $unit = self::renderDiffUnitStar($row['obj']);
+      } else {
+        $lint = null;
+        $unit = null;
+      }
+
       $rows[] =
         '<tr'.$class.'>'.
           '<td class="revhistory-name">'.$name.'</td>'.
           '<td class="revhistory-id">'.$id.'</td>'.
           '<td class="revhistory-desc">'.$desc.'</td>'.
           '<td class="revhistory-age">'.$age.'</td>'.
           '<td class="revhistory-star">'.$lint.'</td>'.
           '<td class="revhistory-star">'.$unit.'</td>'.
           '<td class="revhistory-old'.$old_class.'">'.$old.'</td>'.
           '<td class="revhistory-new'.$new_class.'">'.$new.'</td>'.
         '</tr>';
     }
 
       Javelin::initBehavior(
         'differential-diff-radios',
         array(
           'radios' => $radios,
         ));
 
     $select = '<select><option>Ignore All</option></select>';
 
     return
       '<div class="differential-revision-history differential-panel">'.
         '<h1>Revision Update History</h1>'.
         '<form>'.
           '<table class="differential-revision-history-table">'.
             '<tr>'.
               '<th>Diff</th>'.
               '<th>ID</th>'.
               '<th>Description</th>'.
-              '<th>Age</th>'.
+              '<th>Created</th>'.
               '<th>Lint</th>'.
               '<th>Unit</th>'.
             '</tr>'.
             implode("\n", $rows).
             '<tr>'.
               '<td colspan="8" class="diff-differ-submit">'.
                 '<label>Whitespace Changes: '.$select.'</label>'.
                 '<button>Show Diff</button>'.
               '</td>'.
             '</tr>'.
           '</table>'.
         '</form>'.
       '</div>';
   }
+
+  const STAR_NONE = 'none';
+  const STAR_OKAY = 'okay';
+  const STAR_WARN = 'warn';
+  const STAR_FAIL = 'fail';
+  const STAR_SKIP = 'skip';
+
+  public static function renderDiffLintStar(DifferentialDiff $diff) {
+    static $map = array(
+      DifferentialLintStatus::LINT_NONE => self::STAR_NONE,
+      DifferentialLintStatus::LINT_OKAY => self::STAR_OKAY,
+      DifferentialLintStatus::LINT_WARN => self::STAR_WARN,
+      DifferentialLintStatus::LINT_FAIL => self::STAR_FAIL,
+      DifferentialLintStatus::LINT_SKIP => self::STAR_SKIP,
+    );
+
+    $star = idx($map, $diff->getLintStatus(), self::STAR_FAIL);
+
+    return self::renderDiffStar($star);
+  }
+
+  public static function renderDiffUnitStar(DifferentialDiff $diff) {
+    static $map = array(
+      DifferentialUnitStatus::UNIT_NONE => self::STAR_NONE,
+      DifferentialUnitStatus::UNIT_OKAY => self::STAR_OKAY,
+      DifferentialUnitStatus::UNIT_WARN => self::STAR_WARN,
+      DifferentialUnitStatus::UNIT_FAIL => self::STAR_FAIL,
+      DifferentialUnitStatus::UNIT_SKIP => self::STAR_SKIP,
+    );
+
+    $star = idx($map, $diff->getUnitStatus(), self::STAR_FAIL);
+
+    return self::renderDiffStar($star);
+  }
+
+  public static function getDiffLintMessage(DifferentialDiff $diff) {
+    switch ($diff->getLintStatus()) {
+      case DifferentialLintStatus::LINT_NONE:
+        return 'No Linters Available';
+      case DifferentialLintStatus::LINT_OKAY:
+        return 'Lint OK';
+      case DifferentialLintStatus::LINT_WARN:
+        return 'Lint Warnings';
+      case DifferentialLintStatus::LINT_FAIL:
+        return 'Lint Errors';
+      case DifferentialLintStatus::LINT_SKIP:
+        return 'Lint Skipped';
+    }
+    return '???';
+  }
+
+  public static function getDiffUnitMessage(DifferentialDiff $diff) {
+    switch ($diff->getUnitStatus()) {
+      case DifferentialUnitStatus::UNIT_NONE:
+        return 'No Unit Test Coverage';
+      case DifferentialUnitStatus::UNIT_OKAY:
+        return 'Unit Tests OK';
+      case DifferentialUnitStatus::UNIT_WARN:
+        return 'Unit Test Warnings';
+      case DifferentialUnitStatus::UNIT_FAIL:
+        return 'Unit Test Errors';
+      case DifferentialUnitStatus::UNIT_SKIP:
+        return 'Unit Tests Skipped';
+    }
+    return '???';
+  }
+
+  private static function renderDiffStar($star) {
+    $class = 'diff-star-'.$star;
+    return
+      '<span class="'.$class.'">'.
+        "\xE2\x98\x85".
+      '</span>';
+  }
+
 }
diff --git a/src/applications/differential/view/revisionupdatehistory/__init__.php b/src/applications/differential/view/revisionupdatehistory/__init__.php
index ab2bc66cee..ee163ad5cf 100644
--- a/src/applications/differential/view/revisionupdatehistory/__init__.php
+++ b/src/applications/differential/view/revisionupdatehistory/__init__.php
@@ -1,17 +1,21 @@
 <?php
 /**
  * This file is automatically generated. Lint this module to rebuild it.
  * @generated
  */
 
 
 
+phutil_require_module('phabricator', 'applications/differential/constants/lintstatus');
+phutil_require_module('phabricator', 'applications/differential/constants/unitstatus');
 phutil_require_module('phabricator', 'infrastructure/celerity/api');
 phutil_require_module('phabricator', 'infrastructure/javelin/api');
 phutil_require_module('phabricator', 'infrastructure/javelin/markup');
 phutil_require_module('phabricator', 'view/base');
+phutil_require_module('phabricator', 'view/utils');
 
 phutil_require_module('phutil', 'markup');
+phutil_require_module('phutil', 'utils');
 
 
 phutil_require_source('DifferentialRevisionUpdateHistoryView.php');
diff --git a/src/applications/directory/controller/categorydelete/PhabricatorDirectoryCategoryDeleteController.php b/src/applications/directory/controller/categorydelete/PhabricatorDirectoryCategoryDeleteController.php
index 58c619a7e3..122814fa76 100644
--- a/src/applications/directory/controller/categorydelete/PhabricatorDirectoryCategoryDeleteController.php
+++ b/src/applications/directory/controller/categorydelete/PhabricatorDirectoryCategoryDeleteController.php
@@ -1,51 +1,52 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class PhabricatorDirectoryCategoryDeleteController
   extends PhabricatorDirectoryController {
 
   public function willProcessRequest(array $data) {
     $this->id = $data['id'];
   }
 
   public function processRequest() {
 
     $category = id(new PhabricatorDirectoryCategory())->load($this->id);
     if (!$category) {
       return new Aphront404Response();
     }
 
     $request = $this->getRequest();
 
     if ($request->isFormPost()) {
       $category->delete();
       return id(new AphrontRedirectResponse())
         ->setURI('/directory/category/');
     }
 
     $dialog = new AphrontDialogView();
+    $dialog->setUser($request->getUser());
     $dialog->setTitle('Really delete this category?');
     $dialog->appendChild("Are you sure you want to delete this category?");
     $dialog->addSubmitButton('Delete');
     $dialog->addCancelButton('/directory/category/');
     $dialog->setSubmitURI($request->getPath());
 
     return id(new AphrontDialogResponse())->setDialog($dialog);
   }
 
 }
diff --git a/src/applications/directory/controller/itemdelete/PhabricatorDirectoryItemDeleteController.php b/src/applications/directory/controller/itemdelete/PhabricatorDirectoryItemDeleteController.php
index 076c73ced1..4c55f61246 100644
--- a/src/applications/directory/controller/itemdelete/PhabricatorDirectoryItemDeleteController.php
+++ b/src/applications/directory/controller/itemdelete/PhabricatorDirectoryItemDeleteController.php
@@ -1,51 +1,52 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class PhabricatorDirectoryItemDeleteController
   extends PhabricatorDirectoryController {
 
   public function willProcessRequest(array $data) {
     $this->id = $data['id'];
   }
 
   public function processRequest() {
 
     $item = id(new PhabricatorDirectoryItem())->load($this->id);
     if (!$item) {
       return new Aphront404Response();
     }
 
     $request = $this->getRequest();
 
     if ($request->isFormPost()) {
       $item->delete();
       return id(new AphrontRedirectResponse())
         ->setURI('/directory/item/');
     }
 
     $dialog = new AphrontDialogView();
+    $dialog->setUser($request->getUser());
     $dialog->setTitle('Really delete this item?');
     $dialog->appendChild("Are you sure you want to delete this item?");
     $dialog->addSubmitButton('Delete');
     $dialog->addCancelButton('/directory/item/');
     $dialog->setSubmitURI($request->getPath());
 
     return id(new AphrontDialogResponse())->setDialog($dialog);
   }
 
 }
diff --git a/src/applications/xhprof/view/toplevel/PhabricatorXHProfProfileTopLevelView.php b/src/applications/xhprof/view/toplevel/PhabricatorXHProfProfileTopLevelView.php
index ac6732802a..55d873bd2f 100644
--- a/src/applications/xhprof/view/toplevel/PhabricatorXHProfProfileTopLevelView.php
+++ b/src/applications/xhprof/view/toplevel/PhabricatorXHProfProfileTopLevelView.php
@@ -1,124 +1,125 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class PhabricatorXHProfProfileTopLevelView extends AphrontView {
 
   private $profileData;
   private $limit;
   private $baseURI;
 
   public function setProfileData(array $data) {
     $this->profileData = $data;
     return $this;
   }
 
   public function setLimit($limit) {
     $this->limit = $limit;
     return $this;
   }
 
   public function setBaseURI($uri) {
     $this->baseURI = $uri;
     return $this;
   }
 
   public function render() {
     DarkConsoleXHProfPluginAPI::includeXHProfLib();
 
     $GLOBALS['display_calls'] = true;
     $totals = array();
     $flat = xhprof_compute_flat_info($this->profileData, $totals);
     unset($GLOBALS['display_calls']);
 
     $aggregated = array();
     foreach ($flat as $call => $counters) {
-      $agg_call = reset(explode('@', $call, 2));
+      $parts = explode('@', $call, 2);
+      $agg_call = reset($parts);
       if (empty($aggregated[$agg_call])) {
         $aggregated[$agg_call] = $counters;
       } else {
         foreach ($aggregated[$agg_call] as $key => $val) {
           if ($key != 'wt') {
             $aggregated[$agg_call][$key] += $counters[$key];
           }
         }
       }
     }
     $flat = $aggregated;
 
     $flat = isort($flat, 'wt');
     $flat = array_reverse($flat);
 
     $rows = array();
     $rows[] = array(
       'Total',
       number_format($totals['ct']),
       number_format($totals['wt']).' us',
       '100.0%',
       number_format($totals['wt']).' us',
       '100.0%',
     );
 
     if ($this->limit) {
       $flat = array_slice($flat, 0, $this->limit);
     }
 
     $base_uri = $this->baseURI;
 
     foreach ($flat as $call => $counters) {
       $rows[] = array(
         phutil_render_tag(
           'a',
           array(
             'href' => $base_uri.'?symbol='.$call,
           ),
           phutil_escape_html($call)),
         number_format($counters['ct']),
         number_format($counters['wt']).' us',
         sprintf('%.1f%%', 100 * $counters['wt'] / $totals['wt']),
         number_format($counters['excl_wt']).' us',
         sprintf('%.1f%%', 100 * $counters['excl_wt'] / $totals['wt']),
       );
     }
 
     $table = new AphrontTableView($rows);
     $table->setHeaders(
       array(
         'Symbol',
         'Count',
         'Incl Wall Time',
         '%',
         'Excl Wall Time',
         '%',
       ));
     $table->setColumnClasses(
       array(
         'wide pri',
         'n',
         'n',
         'n',
         'n',
         'n',
       ));
 
     $panel = new AphrontPanelView();
     $panel->setHeader('XHProf Profile');
     $panel->appendChild($table);
 
     return $panel->render();
   }
 }
diff --git a/src/view/dialog/AphrontDialogView.php b/src/view/dialog/AphrontDialogView.php
index 83433b88b1..510574b9db 100755
--- a/src/view/dialog/AphrontDialogView.php
+++ b/src/view/dialog/AphrontDialogView.php
@@ -1,126 +1,129 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class AphrontDialogView extends AphrontView {
 
   private $title;
   private $submitButton;
   private $cancelURI;
   private $submitURI;
   private $user;
   private $hidden = array();
 
   public function setUser(PhabricatorUser $user) {
     $this->user = $user;
     return $this;
   }
 
   public function setSubmitURI($uri) {
     $this->submitURI = $uri;
     return $this;
   }
 
   public function setTitle($title) {
     $this->title = $title;
     return $this;
   }
 
   public function getTitle() {
     return $this->title;
   }
 
   public function addSubmitButton($text = 'Okay') {
     $this->submitButton = $text;
     return $this;
   }
 
   public function addCancelButton($uri) {
     $this->cancelURI = $uri;
     return $this;
   }
 
   public function addHiddenInput($key, $value) {
     $this->hidden[$key] = $value;
     return $this;
   }
 
   final public function render() {
     require_celerity_resource('aphront-dialog-view-css');
 
     $buttons = array();
     if ($this->submitButton) {
-      $buttons[] =
-        '<button name="__submit__">'.
-          phutil_escape_html($this->submitButton).
-        '</button>';
+      $buttons[] = phutil_render_tag(
+        'button',
+        array(
+          'name' => '__submit__',
+          'sigil' => '__default__',
+        ),
+        phutil_escape_html($this->submitButton));
     }
 
     if ($this->cancelURI) {
       $buttons[] = javelin_render_tag(
         'a',
         array(
           'href'  => $this->cancelURI,
           'class' => 'button grey',
           'name'  => '__cancel__',
           'sigil' => 'jx-workflow-button',
         ),
         'Cancel');
     }
 
     if (!$this->user) {
       throw new Exception(
         "You must call setUser() when rendering an AphrontDialogView.");
     }
     $csrf = $this->user->getCSRFToken();
 
     $hidden_inputs = array();
     foreach ($this->hidden as $key => $value) {
       $hidden_inputs[] = phutil_render_tag(
         'input',
         array(
           'type' => 'hidden',
           'name' => $key,
           'value' => $value,
         ));
     }
     $hidden_inputs = implode("\n", $hidden_inputs);
 
     return javelin_render_tag(
       'form',
       array(
         'class'   => 'aphront-dialog-view',
         'action'  => $this->submitURI,
         'method'  => 'post',
         'sigil'   => 'jx-dialog',
       ),
       '<input type="hidden" name="__form__" value="1" />'.
       '<input type="hidden" name="__csrf__" value="'.$csrf.'" />'.
       $hidden_inputs.
       '<div class="aphront-dialog-head">'.
         phutil_escape_html($this->title).
       '</div>'.
       '<div class="aphront-dialog-body">'.
         $this->renderChildren().
       '</div>'.
       '<div class="aphront-dialog-tail">'.
         implode('', $buttons).
         '<div style="clear: both;"></div>'.
       '</div>');
   }
 
 }
diff --git a/src/view/form/control/divider/AphrontFormDividerControl.php b/src/view/form/control/divider/AphrontFormDividerControl.php
new file mode 100755
index 0000000000..31c6dd81fc
--- /dev/null
+++ b/src/view/form/control/divider/AphrontFormDividerControl.php
@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class AphrontFormDividerControl extends AphrontFormControl {
+
+  protected function getCustomControlClass() {
+    return 'aphront-form-control-divider';
+  }
+
+  protected function renderInput() {
+    return '<hr />';
+  }
+
+}
diff --git a/src/view/form/control/divider/__init__.php b/src/view/form/control/divider/__init__.php
new file mode 100644
index 0000000000..4e96679f5c
--- /dev/null
+++ b/src/view/form/control/divider/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phabricator', 'view/form/control/base');
+
+
+phutil_require_source('AphrontFormDividerControl.php');
diff --git a/src/view/utils/viewutils.php b/src/view/utils/viewutils.php
index c884a051a7..be9835c5e6 100644
--- a/src/view/utils/viewutils.php
+++ b/src/view/utils/viewutils.php
@@ -1,85 +1,85 @@
 <?php
 
 /*
  * Copyright 2011 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 function phabricator_format_relative_time($duration) {
   return phabricator_format_units_generic(
     $duration,
     array(60, 60, 24, 7),
     array('s', 'm', 'h', 'd', 'w'),
     $precision = 0);
 }
 
 function phabricator_format_timestamp($epoch) {
   $difference = (time() - $epoch);
 
-  if ($difference < 60 * 60) {
+  if ($difference < 60 * 60 * 24) {
     return phabricator_format_relative_time($difference).' ago';
   } else if (date('Y') == date('Y', $epoch)) {
-    return date('M jS, g:i A', $epoch);
+    return date('M j, g:i A', $epoch);
   } else {
     return date('F jS, Y', $epoch);
   }
 }
 
 function phabricator_format_units_generic(
   $n,
   array $scales,
   array $labels,
   $precision  = 0,
   &$remainder = null) {
 
     $is_negative = false;
   if ($n < 0) {
     $is_negative = true;
     $n = abs($n);
   }
 
   $remainder = 0;
   $accum = 1;
 
   $scale = array_shift($scales);
   $label = array_shift($labels);
   while ($n > $scale && count($labels)) {
     $remainder += ($n % $scale) * $accum;
     $n /= $scale;
     $accum *= $scale;
     $label = array_shift($labels);
     if (!count($scales)) {
       break;
     }
     $scale = array_shift($scales);
   }
 
   if ($is_negative) {
     $n = -$n;
     $remainder = -$remainder;
   }
 
   if ($precision) {
     $num_string = number_format($n, $precision);
   } else {
     $num_string = (int)floor($n);
   }
 
   if ($label) {
     $num_string .= ' '.$label;
   }
 
   return $num_string;
 }
 
diff --git a/webroot/rsrc/css/application/differential/changeset-view.css b/webroot/rsrc/css/application/differential/changeset-view.css
index de9fa3004d..aaa5e7ae4a 100644
--- a/webroot/rsrc/css/application/differential/changeset-view.css
+++ b/webroot/rsrc/css/application/differential/changeset-view.css
@@ -1,166 +1,172 @@
 /**
  * @provides differential-changeset-view-css
  */
 
 .differential-diff {
   background:         #ffffff;
   font-family:        "Menlo", "Consolas", "Monaco", monospace;
   font-size:          10px;
   width:              100%;
 }
 
 .differential-diff td {
   /* using monospace fonts makes ex/em most useful:
    *
    * Unfortunately, firefox 3.6 renders diffs columns for added and removed
    * files "way-too-wide" when given em as the dimension measurement, so we
    * use an eyeballed ex equivalent and reset it to the ch character width
    * measurement for browsers that support that css3 measurement.
    */
   width:              88ex;
   width:              81ch;
   /*
     Disable ligatures in Firefox. Firefox 3 has fancypants ligature support, but
     it gets applied to monospaced fonts, which sucks because it means that the
     "fi" ligature only takes up one character, e.g. It's probably the font's
     fault that it even specifies ligatures (seriously, what the hell?) but
     that's hard to fix and this is "easy" to "fix": custom letter spacing
     disables ligatures, as long as it's at least 0.008333-repeating pixels of
     custom letter spacing. I have no idea where this number comes from, but note
     that .83333.. = 5/6. -epriestley
   */
   letter-spacing:     0.0083334px;
   vertical-align:     top;
   white-space:        pre;
   padding:            0 8px 1px;
   line-height:        16px;
   overflow:           hidden;
 }
 
 .differential-diff th {
   text-align:         right;
   padding:            2px 6px;
   width:              44px;
   vertical-align:     top;
   background:         #eeeeee;
   color:              #888888;
   cursor:             pointer;
   border-style:       solid;
   border-width:       0px 1px;
   border-color:       #eeeeee #999999 #eeeeee #dddddd;
   font-weight:        bold;
   font-family:        "Verdana";
   font-size:          11px;
   overflow:           hidden;
 }
 
 .differential-diff td.old {
   background:   #ffd0d0;
   color:        #161111;
 }
 
 .differential-diff td.new {
   background:   #d0ffd0;
   color:        #111611;
 }
 
 .differential-diff td.old-full,
 .differential-diff td.old span.bright {
   background: #ffaaaa;
   color:      #221111;
 }
 
 .differential-diff td.new-full,
 .differential-diff td.new span.bright {
   background: #aaffaa;
   color:      #112211;
 }
 
 .differential-diff td.show-more,
 .differential-diff td.differential-shield {
   background: #ffffee;
   padding: 1em;
   text-align: center;
   font-family: "Verdana";
   font-size:   11px;
   border: 1px solid #ccccaa;
   white-space: normal;
 }
 
 .differential-diff td.show-more {
   color:  #999966;
 }
 
 .differential-diff td.differential-shield {
   text-align: center;
   max-width: 1160px;
 }
 
 .differential-diff td.differential-shield a {
   font-weight: bold;
 }
 
 .differential-meta-notice {
   border:           1px solid #ffdd99;
   background:       #ffeeaa;
   font-family:      "Verdana";
   font-size:        11px;
   padding:          1em;
   margin:           0 0 6px 0;
 }
 
 .differential-changeset h1 {
   font-size:          14px;
   font-weight:        bold;
   padding:            2px 0 8px;
 }
 
 .differential-changeset {
   margin:             0.5em 0;
   padding:            10px 0px 20px;
 }
 
 .differential-reticle {
   background: #ffeeaa;
   border:     1px solid #ffcc00;
   position:   absolute;
   z-index:    2;
   opacity:    0.5;
   top:        0px;
   left:       0px;
 }
 
 .differential-inline-comment {
   background:         #f9f9f1;
   border:             1px solid #aaaa88;
   font-family:        Verdana;
   font-size:          11px;
   margin:             4px 0px;
   max-width:          81ch;
   padding:            8px 10px;
   width:              100%;
   -moz-box-sizing:    border-box;
   -webkit-box-sizing: border-box;
 }
 
 .differential-inline-comment-head {
   font-weight:  bold;
   color:        #333333;
   border-bottom:  1px solid #ccccaa;
   padding-bottom: 6px;
   margin-bottom:  4px;
 }
 
 .differential-inline-comment-links,
 .differential-inline-comment-line {
   font-weight:  normal;
   font-style:   italic;
   color:        #666666;
   float:        right;
   white-space:  nowrap;
 }
 
 .differential-inline-comment-links {
   margin-left:  8px;
   font-style:   normal;
 }
+
+
+.differential-inline-comment-edit-textarea {
+  width: 100%;
+  height: 12em;
+}
diff --git a/webroot/rsrc/css/application/differential/table-of-contents.css b/webroot/rsrc/css/application/differential/table-of-contents.css
index c79d38a955..06d459e015 100644
--- a/webroot/rsrc/css/application/differential/table-of-contents.css
+++ b/webroot/rsrc/css/application/differential/table-of-contents.css
@@ -1,25 +1,47 @@
 /**
  * @provides differential-table-of-contents-css
  */
 
 .differential-toc-meta {
   color:        #666666;
   padding-left: 1em;
 }
 
 .differential-toc-char,
 .differential-toc-prop {
   width: 1.25em;
   text-align: center;
   font-weight: bold;
 }
 
 .differential-toc-ftype {
   padding: 0 .5em;
   text-align: center;
   color: #666666;
 }
 
 .differential-toc-file {
   color: #444444;
 }
+
+.diff-star-none {
+  color: #666666;
+}
+
+.diff-star-okay {
+  color: #ff9700;
+}
+
+/* TODO: 'warn' and 'fail' are both red, but we can't make 'warn' yellow since
+   'okay' is a "gold star". */
+.diff-star-warn {
+  color: #aa0000;
+}
+
+.diff-star-fail {
+  color: #aa0000;
+}
+
+.diff-star-skip {
+  color: #ff00aa;
+}
diff --git a/webroot/rsrc/js/javelin/workflow.dev.js b/webroot/rsrc/js/javelin/workflow.dev.js
index 94710abf32..a7f4a5b29b 100644
--- a/webroot/rsrc/js/javelin/workflow.dev.js
+++ b/webroot/rsrc/js/javelin/workflow.dev.js
@@ -1,240 +1,242 @@
 /** @provides javelin-workflow-dev */
 
 /**
  * @requires javelin-install javelin-vector javelin-dom
  * @provides javelin-mask
  * @javelin
  */
 
 /**
  * Show a transparent "mask" over the page; used by Workflow to draw visual
  * attention to modal dialogs.
  */
 JX.install('Mask', {
   statics : {
     _depth : 0,
     _mask : null,
     show : function() {
       if (!JX.Mask._depth) {
         JX.Mask._mask = JX.$N('div', {className: 'jx-mask'});
         document.body.appendChild(JX.Mask._mask);
         JX.$V.getDocument().setDim(JX.Mask._mask);
       }
       ++JX.Mask._depth;
     },
     hide : function() {
       --JX.Mask._depth;
       if (!JX.Mask._depth) {
         JX.DOM.remove(JX.Mask._mask);
         JX.Mask._mask = null;
       }
     }
   }
 });
 /**
  * @requires javelin-stratcom
  *           javelin-request
  *           javelin-dom
  *           javelin-vector
  *           javelin-install
  *           javelin-util
  *           javelin-mask
  * @provides javelin-workflow
  * @javelin
  */
 
 JX.install('Workflow', {
   construct : function(uri, data) {
     if (__DEV__) {
       if (!uri || uri == '#') {
         throw new Error(
           'new JX.Workflow(<?>, ...): '+
           'bogus URI provided when creating workflow.');
       }
     }
     this.setURI(uri);
     this.setData(data || {});
   },
 
   events : ['error', 'finally', 'submit'],
 
   statics : {
     _stack   : [],
     newFromForm : function(form, data) {
       var inputs = [].concat(
         JX.DOM.scry(form, 'input'),
         JX.DOM.scry(form, 'button'),
         JX.DOM.scry(form, 'textarea'));
 
       for (var ii = 0; ii < inputs.length; ii++) {
         if (inputs[ii].disabled) {
           delete inputs[ii];
         } else {
           inputs[ii].disabled = true;
         }
       }
 
       var workflow = new JX.Workflow(
         form.getAttribute('action'),
         JX.copy(data || {}, JX.DOM.serialize(form)));
       workflow.setMethod(form.getAttribute('method'));
       workflow.listen('finally', function() {
         for (var ii = 0; ii < inputs.length; ii++) {
           inputs[ii] && (inputs[ii].disabled = false);
         }
       });
       return workflow;
     },
     newFromLink : function(link) {
       var workflow = new JX.Workflow(link.href);
       return workflow;
     },
     _push : function(workflow) {
       JX.Mask.show();
       JX.Workflow._stack.push(workflow);
     },
     _pop : function() {
       var dialog = JX.Workflow._stack.pop();
       (dialog.getCloseHandler() || JX.bag)();
       dialog._destroy();
       JX.Mask.hide();
     },
     disable : function() {
       JX.Workflow._disabled = true;
     },
     _onbutton : function(event) {
 
       if (JX.Stratcom.pass()) {
         return;
       }
 
       if (JX.Workflow._disabled) {
         return;
       }
 
       var t = event.getTarget();
       if (t.name == '__cancel__' || t.name == '__close__') {
         JX.Workflow._pop();
       } else {
 
         var form = event.getNode('jx-dialog');
         var data = JX.DOM.serialize(form);
         data[t.name] = true;
         data.__wflow__ = true;
 
         var active = JX.Workflow._stack[JX.Workflow._stack.length - 1];
         var e = active.invoke('submit', {form: form, data: data});
         if (!e.getStopped()) {
           active._destroy();
           active
             .setURI(form.getAttribute('action') || active.getURI())
             .setData(data)
             .start();
         }
       }
       event.prevent();
     }
   },
 
   members : {
     _root : null,
     _pushed : false,
     _onload : function(r) {
       // It is permissible to send back a falsey redirect to force a page
       // reload, so we need to take this branch if the key is present.
       if (r && (typeof r.redirect != 'undefined')) {
         JX.go(r.redirect, true);
       } else if (r && r.dialog) {
         this._push();
         this._root = JX.$N(
           'div',
           {className: 'jx-client-dialog'},
           JX.HTML(r.dialog));
         JX.DOM.listen(
           this._root,
           'click',
           [['jx-workflow-button'], ['tag:button']],
           JX.Workflow._onbutton);
         document.body.appendChild(this._root);
         var d = JX.$V.getDim(this._root);
         var v = JX.$V.getViewport();
         var s = JX.$V.getScroll();
         JX.$V((v.x - d.x) / 2, s.y + 100).setPos(this._root);
         try {
-          JX.DOM.focus(JX.DOM.find(this._root, 'button', '__default__'));
+          try {
+            JX.DOM.focus(JX.DOM.find(this._root, 'button', '__default__'));
+          } catch (_ignored) {}
           var inputs = JX.DOM.scry(this._root, 'input')
                          .concat(JX.DOM.scry(this._root, 'textarea'));
           var miny = Number.POSITIVE_INFINITY;
           var target = null;
           for (var ii = 0; ii < inputs.length; ++ii) {
             if (inputs[ii].type != 'hidden') {
               // Find the topleft-most displayed element.
               var p = JX.$V(inputs[ii]);
               if (p.y < miny) {
                  miny = p.y;
                  target = inputs[ii];
               }
             }
           }
           target && JX.DOM.focus(target);
         } catch (_ignored) {}
       } else if (this.getHandler()) {
         this.getHandler()(r);
         this._pop();
       } else if (r) {
         if (__DEV__) {
           throw new Error('Response to workflow request went unhandled.');
         }
       }
     },
     _push : function() {
       if (!this._pushed) {
         this._pushed = true;
         JX.Workflow._push(this);
       }
     },
     _pop : function() {
       if (this._pushed) {
         this._pushed = false;
         JX.Workflow._pop();
       }
     },
     _destroy : function() {
       if (this._root) {
         JX.DOM.remove(this._root);
         this._root = null;
       }
     },
     start : function() {
       var uri = this.getURI();
       var method = this.getMethod();
       var r = new JX.Request(uri, JX.bind(this, this._onload));
       r.setData(this.getData());
       r.setDataSerializer(this.getDataSerializer());
       if (method) {
         r.setMethod(method);
       }
       r.listen('finally', JX.bind(this, this.invoke, 'finally'));
       r.listen('error', JX.bind(this, function(error) {
         var e = this.invoke('error', error);
         if (e.getStopped()) {
           return;
         }
         // TODO: Default error behavior? On Facebook Lite, we just shipped the
         // user to "/error/". We could emit a blanket 'workflow-failed' type
         // event instead.
       }));
       r.send();
     }
   },
 
   properties : {
     handler : null,
     closeHandler : null,
     data : null,
     dataSerializer : null,
     method : null,
     URI : null
   }
 
 });