diff --git a/src/applications/differential/controller/DifferentialController.php b/src/applications/differential/controller/DifferentialController.php
index 43252c07f6..1991580116 100644
--- a/src/applications/differential/controller/DifferentialController.php
+++ b/src/applications/differential/controller/DifferentialController.php
@@ -1,228 +1,228 @@
 <?php
 
 abstract class DifferentialController extends PhabricatorController {
 
   public function buildSideNavView($for_app = false) {
     $viewer = $this->getRequest()->getUser();
 
     $nav = new AphrontSideNavFilterView();
     $nav->setBaseURI(new PhutilURI($this->getApplicationURI()));
 
     id(new DifferentialRevisionSearchEngine())
       ->setViewer($viewer)
       ->addNavigationItems($nav->getMenu());
 
     $nav->selectFilter(null);
 
     return $nav;
   }
 
   public function buildApplicationMenu() {
     return $this->buildSideNavView(true)->getMenu();
   }
 
   protected function buildTableOfContents(
     array $changesets,
     array $visible_changesets,
     array $coverage) {
     $viewer = $this->getViewer();
 
     $toc_view = id(new PHUIDiffTableOfContentsListView())
-      ->setUser($viewer)
-      ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);
+      ->setViewer($viewer)
+      ->setBare(true);
 
     $have_owners = PhabricatorApplication::isClassInstalledForViewer(
       'PhabricatorOwnersApplication',
       $viewer);
     if ($have_owners) {
       $repository_phid = null;
       if ($changesets) {
         $changeset = head($changesets);
         $diff = $changeset->getDiff();
         $repository_phid = $diff->getRepositoryPHID();
       }
 
       if (!$repository_phid) {
         $have_owners = false;
       } else {
         if ($viewer->getPHID()) {
           $packages = id(new PhabricatorOwnersPackageQuery())
             ->setViewer($viewer)
             ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
             ->withAuthorityPHIDs(array($viewer->getPHID()))
             ->execute();
           $toc_view->setAuthorityPackages($packages);
         }
 
         // TODO: For Subversion, we should adjust these paths to be relative to
         // the repository root where possible.
         $paths = mpull($changesets, 'getFilename');
 
         $control_query = id(new PhabricatorOwnersPackageQuery())
           ->setViewer($viewer)
           ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
           ->withControl($repository_phid, $paths);
         $control_query->execute();
       }
     }
 
     foreach ($changesets as $changeset_id => $changeset) {
       $is_visible = isset($visible_changesets[$changeset_id]);
       $anchor = $changeset->getAnchorName();
 
       $filename = $changeset->getFilename();
       $coverage_id = 'differential-mcoverage-'.md5($filename);
 
       $item = id(new PHUIDiffTableOfContentsItemView())
         ->setChangeset($changeset)
         ->setIsVisible($is_visible)
         ->setAnchor($anchor)
         ->setCoverage(idx($coverage, $filename))
         ->setCoverageID($coverage_id);
 
       if ($have_owners) {
         $packages = $control_query->getControllingPackagesForPath(
           $repository_phid,
           $changeset->getFilename());
         $item->setPackages($packages);
       }
 
       $toc_view->addItem($item);
     }
 
     return $toc_view;
   }
 
   protected function loadDiffProperties(array $diffs) {
     $diffs = mpull($diffs, null, 'getID');
 
     $properties = id(new DifferentialDiffProperty())->loadAllWhere(
       'diffID IN (%Ld)',
       array_keys($diffs));
     $properties = mgroup($properties, 'getDiffID');
 
     foreach ($diffs as $id => $diff) {
       $values = idx($properties, $id, array());
       $values = mpull($values, 'getData', 'getName');
       $diff->attachDiffProperties($values);
     }
   }
 
 
   protected function loadHarbormasterData(array $diffs) {
     $viewer = $this->getViewer();
 
     $diffs = mpull($diffs, null, 'getPHID');
 
     $buildables = id(new HarbormasterBuildableQuery())
       ->setViewer($viewer)
       ->withBuildablePHIDs(array_keys($diffs))
       ->withManualBuildables(false)
       ->needBuilds(true)
       ->needTargets(true)
       ->execute();
 
     $buildables = mpull($buildables, null, 'getBuildablePHID');
     foreach ($diffs as $phid => $diff) {
       $diff->attachBuildable(idx($buildables, $phid));
     }
 
     $target_map = array();
     foreach ($diffs as $phid => $diff) {
       $target_map[$phid] = $diff->getBuildTargetPHIDs();
     }
     $all_target_phids = array_mergev($target_map);
 
     if ($all_target_phids) {
       $unit_messages = id(new HarbormasterBuildUnitMessage())->loadAllWhere(
         'buildTargetPHID IN (%Ls)',
         $all_target_phids);
       $unit_messages = mgroup($unit_messages, 'getBuildTargetPHID');
     } else {
       $unit_messages = array();
     }
 
     foreach ($diffs as $phid => $diff) {
       $target_phids = idx($target_map, $phid, array());
       $messages = array_select_keys($unit_messages, $target_phids);
       $messages = array_mergev($messages);
       $diff->attachUnitMessages($messages);
     }
 
     // For diffs with no messages, look for legacy unit messages stored on the
     // diff itself.
     foreach ($diffs as $phid => $diff) {
       if ($diff->getUnitMessages()) {
         continue;
       }
 
       if (!$diff->hasDiffProperty('arc:unit')) {
         continue;
       }
 
       $legacy_messages = $diff->getProperty('arc:unit');
       if (!$legacy_messages) {
         continue;
       }
 
       // Show the top 100 legacy lint messages. Previously, we showed some
       // by default and let the user toggle the rest. With modern messages,
       // we can send the user to the Harbormaster detail page. Just show
       // "a lot" of messages in legacy cases to try to strike a balance
       // between implementation simplicitly and compatibility.
       $legacy_messages = array_slice($legacy_messages, 0, 100);
 
       $messages = array();
       foreach ($legacy_messages as $message) {
         $messages[] = HarbormasterBuildUnitMessage::newFromDictionary(
           new HarbormasterBuildTarget(),
           $this->getModernUnitMessageDictionary($message));
       }
 
       $diff->attachUnitMessages($messages);
     }
   }
 
   private function getModernUnitMessageDictionary(array $map) {
     // Strip out `null` values to satisfy stricter typechecks.
     foreach ($map as $key => $value) {
       if ($value === null) {
         unset($map[$key]);
       }
     }
 
     // Cast duration to a float since it used to be a string in some
     // cases.
     if (isset($map['duration'])) {
       $map['duration'] = (double)$map['duration'];
     }
 
     return $map;
   }
 
   protected function getDiffTabLabels(array $diffs) {
     // Make sure we're only going to render unique diffs.
     $diffs = mpull($diffs, null, 'getID');
     $labels = array(pht('Left'), pht('Right'));
 
     $results = array();
 
     foreach ($diffs as $diff) {
       if (count($diffs) == 2) {
         $label = array_shift($labels);
         $label = pht('%s (Diff %d)', $label, $diff->getID());
       } else {
         $label = pht('Diff %d', $diff->getID());
       }
 
       $results[] = array(
         $label,
         $diff,
       );
     }
 
     return $results;
   }
 
 
 }
diff --git a/src/applications/differential/controller/DifferentialRevisionViewController.php b/src/applications/differential/controller/DifferentialRevisionViewController.php
index f2078a57de..c66da78035 100644
--- a/src/applications/differential/controller/DifferentialRevisionViewController.php
+++ b/src/applications/differential/controller/DifferentialRevisionViewController.php
@@ -1,1170 +1,1201 @@
 <?php
 
 final class DifferentialRevisionViewController extends DifferentialController {
 
   private $revisionID;
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $this->getViewer();
     $this->revisionID = $request->getURIData('id');
 
     $viewer_is_anonymous = !$viewer->isLoggedIn();
 
     $revision = id(new DifferentialRevisionQuery())
       ->withIDs(array($this->revisionID))
       ->setViewer($request->getUser())
       ->needRelationships(true)
       ->needReviewerStatus(true)
       ->needReviewerAuthority(true)
       ->executeOne();
 
     if (!$revision) {
       return new Aphront404Response();
     }
 
     $diffs = id(new DifferentialDiffQuery())
       ->setViewer($request->getUser())
       ->withRevisionIDs(array($this->revisionID))
       ->execute();
     $diffs = array_reverse($diffs, $preserve_keys = true);
 
     if (!$diffs) {
       throw new Exception(
         pht('This revision has no diffs. Something has gone quite wrong.'));
     }
 
     $revision->attachActiveDiff(last($diffs));
 
     $diff_vs = $request->getInt('vs');
     $target_id = $request->getInt('id');
     $target = idx($diffs, $target_id, end($diffs));
 
     $target_manual = $target;
     if (!$target_id) {
       foreach ($diffs as $diff) {
         if ($diff->getCreationMethod() != 'commit') {
           $target_manual = $diff;
         }
       }
     }
 
     if (empty($diffs[$diff_vs])) {
       $diff_vs = null;
     }
 
     $repository = null;
     $repository_phid = $target->getRepositoryPHID();
     if ($repository_phid) {
       if ($repository_phid == $revision->getRepositoryPHID()) {
         $repository = $revision->getRepository();
       } else {
         $repository = id(new PhabricatorRepositoryQuery())
           ->setViewer($viewer)
           ->withPHIDs(array($repository_phid))
           ->executeOne();
       }
     }
 
     list($changesets, $vs_map, $vs_changesets, $rendering_references) =
       $this->loadChangesetsAndVsMap(
         $target,
         idx($diffs, $diff_vs),
         $repository);
 
     if ($request->getExists('download')) {
       return $this->buildRawDiffResponse(
         $revision,
         $changesets,
         $vs_changesets,
         $vs_map,
         $repository);
     }
 
     $map = $vs_map;
     if (!$map) {
       $map = array_fill_keys(array_keys($changesets), 0);
     }
 
     $old_ids = array();
     $new_ids = array();
     foreach ($map as $id => $vs) {
       if ($vs <= 0) {
         $old_ids[] = $id;
         $new_ids[] = $id;
       } else {
         $new_ids[] = $id;
         $new_ids[] = $vs;
       }
     }
 
     $this->loadDiffProperties($diffs);
     $props = $target_manual->getDiffProperties();
 
     $object_phids = array_merge(
       $revision->getReviewers(),
       $revision->getCCPHIDs(),
       $revision->loadCommitPHIDs(),
       array(
         $revision->getAuthorPHID(),
         $viewer->getPHID(),
       ));
 
     foreach ($revision->getAttached() as $type => $phids) {
       foreach ($phids as $phid => $info) {
         $object_phids[] = $phid;
       }
     }
 
     $field_list = PhabricatorCustomField::getObjectFields(
       $revision,
       PhabricatorCustomField::ROLE_VIEW);
 
     $field_list->setViewer($viewer);
     $field_list->readFieldsFromStorage($revision);
 
     $warning_handle_map = array();
     foreach ($field_list->getFields() as $key => $field) {
       $req = $field->getRequiredHandlePHIDsForRevisionHeaderWarnings();
       foreach ($req as $phid) {
         $warning_handle_map[$key][] = $phid;
         $object_phids[] = $phid;
       }
     }
 
     $handles = $this->loadViewerHandles($object_phids);
 
     $request_uri = $request->getRequestURI();
 
     $limit = 100;
     $large = $request->getStr('large');
     if (count($changesets) > $limit && !$large) {
       $count = count($changesets);
       $warning = new PHUIInfoView();
       $warning->setTitle(pht('Very Large Diff'));
       $warning->setSeverity(PHUIInfoView::SEVERITY_WARNING);
       $warning->appendChild(hsprintf(
         '%s <strong>%s</strong>',
         pht(
           'This diff is very large and affects %s files. '.
           'You may load each file individually or ',
           new PhutilNumber($count)),
         phutil_tag(
           'a',
           array(
             'class' => 'button grey',
             'href' => $request_uri
               ->alter('large', 'true')
               ->setFragment('toc'),
           ),
           pht('Show All Files Inline'))));
       $warning = $warning->render();
 
       $old = array_select_keys($changesets, $old_ids);
       $new = array_select_keys($changesets, $new_ids);
 
       $query = id(new DifferentialInlineCommentQuery())
         ->setViewer($viewer)
         ->needHidden(true)
         ->withRevisionPHIDs(array($revision->getPHID()));
       $inlines = $query->execute();
       $inlines = $query->adjustInlinesForChangesets(
         $inlines,
         $old,
         $new,
         $revision);
 
       $visible_changesets = array();
       foreach ($inlines as $inline) {
         $changeset_id = $inline->getChangesetID();
         if (isset($changesets[$changeset_id])) {
           $visible_changesets[$changeset_id] = $changesets[$changeset_id];
         }
       }
     } else {
       $warning = null;
       $visible_changesets = $changesets;
     }
 
     $commit_hashes = mpull($diffs, 'getSourceControlBaseRevision');
     $local_commits = idx($props, 'local:commits', array());
     foreach ($local_commits as $local_commit) {
       $commit_hashes[] = idx($local_commit, 'tree');
       $commit_hashes[] = idx($local_commit, 'local');
     }
     $commit_hashes = array_unique(array_filter($commit_hashes));
     if ($commit_hashes) {
       $commits_for_links = id(new DiffusionCommitQuery())
         ->setViewer($viewer)
         ->withIdentifiers($commit_hashes)
         ->execute();
       $commits_for_links = mpull(
         $commits_for_links,
         null,
         'getCommitIdentifier');
     } else {
       $commits_for_links = array();
     }
 
     $header = $this->buildHeader($revision);
     $subheader = $this->buildSubheaderView($revision);
     $details = $this->buildDetails($revision, $field_list);
     $curtain = $this->buildCurtain($revision);
 
     $whitespace = $request->getStr(
       'whitespace',
       DifferentialChangesetParser::WHITESPACE_IGNORE_MOST);
 
     $repository = $revision->getRepository();
     if ($repository) {
       $symbol_indexes = $this->buildSymbolIndexes(
         $repository,
         $visible_changesets);
     } else {
       $symbol_indexes = array();
     }
 
     $revision_warnings = $this->buildRevisionWarnings(
       $revision,
       $field_list,
       $warning_handle_map,
       $handles);
     $info_view = null;
     if ($revision_warnings) {
       $info_view = id(new PHUIInfoView())
         ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
         ->setErrors($revision_warnings);
     }
 
     $detail_diffs = array_select_keys(
       $diffs,
       array($diff_vs, $target->getID()));
     $detail_diffs = mpull($detail_diffs, null, 'getPHID');
 
     $this->loadHarbormasterData($detail_diffs);
 
     $diff_detail_box = $this->buildDiffDetailView(
       $detail_diffs,
       $revision,
       $field_list);
 
     $unit_box = $this->buildUnitMessagesView(
       $target,
       $revision);
 
     $comment_view = $this->buildTransactions(
       $revision,
       $diff_vs ? $diffs[$diff_vs] : $target,
       $target,
       $old_ids,
       $new_ids);
 
     if (!$viewer_is_anonymous) {
       $comment_view->setQuoteRef('D'.$revision->getID());
       $comment_view->setQuoteTargetID('comment-content');
     }
 
     $changeset_view = id(new DifferentialChangesetListView())
       ->setChangesets($changesets)
       ->setVisibleChangesets($visible_changesets)
       ->setStandaloneURI('/differential/changeset/')
       ->setRawFileURIs(
         '/differential/changeset/?view=old',
         '/differential/changeset/?view=new')
       ->setUser($viewer)
       ->setDiff($target)
       ->setRenderingReferences($rendering_references)
       ->setVsMap($vs_map)
       ->setWhitespace($whitespace)
       ->setSymbolIndexes($symbol_indexes)
       ->setTitle(pht('Diff %s', $target->getID()))
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);
 
     if ($repository) {
       $changeset_view->setRepository($repository);
     }
 
     if (!$viewer_is_anonymous) {
       $changeset_view->setInlineCommentControllerURI(
         '/differential/comment/inline/edit/'.$revision->getID().'/');
     }
 
-    $diff_history = id(new DifferentialRevisionUpdateHistoryView())
+    $history = id(new DifferentialRevisionUpdateHistoryView())
       ->setUser($viewer)
       ->setDiffs($diffs)
       ->setSelectedVersusDiffID($diff_vs)
       ->setSelectedDiffID($target->getID())
       ->setSelectedWhitespace($whitespace)
       ->setCommitsForLinks($commits_for_links);
 
-    $local_view = id(new DifferentialLocalCommitsView())
+    $local_table = id(new DifferentialLocalCommitsView())
       ->setUser($viewer)
       ->setLocalCommits(idx($props, 'local:commits'))
       ->setCommitsForLinks($commits_for_links);
 
     if ($repository) {
       $other_revisions = $this->loadOtherRevisions(
         $changesets,
         $target,
         $repository);
     } else {
       $other_revisions = array();
     }
 
     $other_view = null;
     if ($other_revisions) {
       $other_view = $this->renderOtherRevisions($other_revisions);
     }
 
     $toc_view = $this->buildTableOfContents(
       $changesets,
       $visible_changesets,
       $target->loadCoverageMap($viewer));
 
+    $tab_group = id(new PHUITabGroupView())
+      ->addTab(
+        id(new PHUITabView())
+          ->setName(pht('Files'))
+          ->setKey('files')
+          ->appendChild($toc_view))
+      ->addTab(
+        id(new PHUITabView())
+          ->setName(pht('History'))
+          ->setKey('history')
+          ->appendChild($history))
+      ->addTab(
+        id(new PHUITabView())
+          ->setName(pht('Commits'))
+          ->setKey('commits')
+          ->appendChild($local_table));
+
+    if ($other_view) {
+      $tab_group->addTab(
+        id(new PHUITabView())
+          ->setName(pht('Similar'))
+          ->setKey('similar')
+          ->appendChild($other_view));
+    }
+
+    $tab_view = id(new PHUIObjectBoxView())
+      ->setHeaderText(pht('Revision Contents'))
+      ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
+      ->addTabGroup($tab_group);
+
     $comment_form = null;
     if (!$viewer_is_anonymous) {
       $comment_form = $this->buildCommentForm($revision, $field_list);
     }
 
     $signatures = DifferentialRequiredSignaturesField::loadForRevision(
       $revision);
     $missing_signatures = false;
     foreach ($signatures as $phid => $signed) {
       if (!$signed) {
         $missing_signatures = true;
       }
     }
 
     $footer = array();
     $signature_message = null;
     if ($missing_signatures) {
       $signature_message = id(new PHUIInfoView())
         ->setTitle(pht('Content Hidden'))
         ->appendChild(
           pht(
             'The content of this revision is hidden until the author has '.
             'signed all of the required legal agreements.'));
     } else {
-      $footer[] =
-        array(
-          $diff_history,
-          $warning,
-          $local_view,
-          $toc_view,
-          $other_view,
-          $changeset_view,
-        );
+      $anchor = id(new PhabricatorAnchorView())
+        ->setAnchorName('toc')
+        ->setNavigationMarker(true);
+
+      $footer[] = array(
+        $anchor,
+        $warning,
+        $tab_view,
+        $changeset_view,
+      );
     }
 
     if ($comment_form) {
       $footer[] = $comment_form;
     } else {
       // TODO: For now, just use this to get "Login to Comment".
       $footer[] = id(new PhabricatorApplicationTransactionCommentView())
         ->setUser($viewer)
         ->setRequestURI($request->getRequestURI());
     }
 
     $object_id = 'D'.$revision->getID();
     $operations_box = $this->buildOperationsBox($revision);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb($object_id, '/'.$object_id);
     $crumbs->setBorder(true);
 
     $filetree_on = $viewer->compareUserSetting(
       PhabricatorShowFiletreeSetting::SETTINGKEY,
       PhabricatorShowFiletreeSetting::VALUE_ENABLE_FILETREE);
 
     $nav = null;
     if ($filetree_on) {
       $collapsed_key = PhabricatorFiletreeVisibleSetting::SETTINGKEY;
       $collapsed_value = $viewer->getUserSetting($collapsed_key);
 
       $nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
         ->setTitle('D'.$revision->getID())
         ->setBaseURI(new PhutilURI('/D'.$revision->getID()))
         ->setCollapsed((bool)$collapsed_value)
         ->build($changesets);
     }
 
     // Haunt Mode
     $pane_id = celerity_generate_unique_node_id();
     Javelin::initBehavior(
       'differential-keyboard-navigation',
       array(
         'haunt' => $pane_id,
       ));
     Javelin::initBehavior('differential-user-select');
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setSubheader($subheader)
       ->setCurtain($curtain)
       ->setID($pane_id)
       ->setMainColumn(array(
         $operations_box,
         $info_view,
         $details,
         $diff_detail_box,
         $unit_box,
         $comment_view,
         $signature_message,
       ))
       ->setFooter($footer);
 
     $page =  $this->newPage()
       ->setTitle($object_id.' '.$revision->getTitle())
       ->setCrumbs($crumbs)
       ->setPageObjectPHIDs(array($revision->getPHID()))
       ->appendChild($view);
 
     if ($nav) {
       $page->setNavigation($nav);
     }
 
     return $page;
   }
 
   private function buildHeader(DifferentialRevision $revision) {
     $view = id(new PHUIHeaderView())
       ->setHeader($revision->getTitle($revision))
       ->setUser($this->getViewer())
       ->setPolicyObject($revision)
       ->setHeaderIcon('fa-cog');
 
     $status = $revision->getStatus();
     $status_name =
       DifferentialRevisionStatus::renderFullDescription($status);
 
     $view->addProperty(PHUIHeaderView::PROPERTY_STATUS, $status_name);
 
     return $view;
   }
 
   private function buildSubheaderView(DifferentialRevision $revision) {
     $viewer = $this->getViewer();
 
     $author_phid = $revision->getAuthorPHID();
 
     $author = $viewer->renderHandle($author_phid)->render();
     $date = phabricator_datetime($revision->getDateCreated(), $viewer);
     $author = phutil_tag('strong', array(), $author);
 
     $handles = $viewer->loadHandles(array($author_phid));
     $image_uri = $handles[$author_phid]->getImageURI();
     $image_href = $handles[$author_phid]->getURI();
 
     $content = pht('Authored by %s on %s.', $author, $date);
 
     return id(new PHUIHeadThingView())
       ->setImage($image_uri)
       ->setImageHref($image_href)
       ->setContent($content);
   }
 
   private function buildDetails(
     DifferentialRevision $revision,
     $custom_fields) {
     $viewer = $this->getViewer();
     $properties = id(new PHUIPropertyListView())
       ->setUser($viewer);
 
     if ($custom_fields) {
       $custom_fields->appendFieldsToPropertyList(
         $revision,
         $viewer,
         $properties);
     }
 
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Details'));
 
     return id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->appendChild($properties);
   }
 
   private function buildCurtain(DifferentialRevision $revision) {
     $viewer = $this->getViewer();
     $revision_id = $revision->getID();
     $revision_phid = $revision->getPHID();
     $curtain = $this->newCurtainView($revision);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $revision,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $curtain->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-pencil')
         ->setHref("/differential/revision/edit/{$revision_id}/")
         ->setName(pht('Edit Revision'))
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit));
 
     $curtain->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-upload')
         ->setHref("/differential/revision/update/{$revision_id}/")
         ->setName(pht('Update Diff'))
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit));
 
     $request_uri = $this->getRequest()->getRequestURI();
     $curtain->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-download')
         ->setName(pht('Download Raw Diff'))
         ->setHref($request_uri->alter('download', 'true')));
 
     $relationship_list = PhabricatorObjectRelationshipList::newForObject(
       $viewer,
       $revision);
 
     $revision_actions = array(
       DifferentialRevisionHasParentRelationship::RELATIONSHIPKEY,
       DifferentialRevisionHasChildRelationship::RELATIONSHIPKEY,
     );
 
     $revision_submenu = $relationship_list->newActionSubmenu($revision_actions)
       ->setName(pht('Edit Related Revisions...'))
       ->setIcon('fa-cog');
 
     $curtain->addAction($revision_submenu);
 
     $relationship_submenu = $relationship_list->newActionMenu();
     if ($relationship_submenu) {
       $curtain->addAction($relationship_submenu);
     }
 
     return $curtain;
   }
 
   private function buildCommentForm(
     DifferentialRevision $revision,
     $field_list) {
 
     $viewer = $this->getViewer();
 
     $draft = id(new PhabricatorDraft())->loadOneWhere(
       'authorPHID = %s AND draftKey = %s',
       $viewer->getPHID(),
       'differential-comment-'.$revision->getID());
 
     $reviewers = array();
     $ccs = array();
     if ($draft) {
       $reviewers = idx($draft->getMetadata(), 'reviewers', array());
       $ccs = idx($draft->getMetadata(), 'ccs', array());
       if ($reviewers || $ccs) {
         $handles = $this->loadViewerHandles(array_merge($reviewers, $ccs));
         $reviewers = array_select_keys($handles, $reviewers);
         $ccs = array_select_keys($handles, $ccs);
       }
     }
 
     $comment_form = id(new DifferentialAddCommentView())
       ->setRevision($revision);
 
     $review_warnings = array();
     foreach ($field_list->getFields() as $field) {
       $review_warnings[] = $field->getWarningsForDetailView();
     }
     $review_warnings = array_mergev($review_warnings);
 
     if ($review_warnings) {
       $review_warnings_panel = id(new PHUIInfoView())
         ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
         ->setErrors($review_warnings);
       $comment_form->setInfoView($review_warnings_panel);
     }
 
     $action_uri = $this->getApplicationURI(
       'comment/save/'.$revision->getID().'/');
 
     $comment_form->setActions($this->getRevisionCommentActions($revision))
       ->setActionURI($action_uri)
       ->setUser($viewer)
       ->setDraft($draft)
       ->setReviewers(mpull($reviewers, 'getFullName', 'getPHID'))
       ->setCCs(mpull($ccs, 'getFullName', 'getPHID'));
 
     // TODO: This just makes the "Z" key work. Generalize this and remove
     // it at some point.
     $comment_form = phutil_tag(
       'div',
       array(
         'class' => 'differential-add-comment-panel',
       ),
       $comment_form);
     return $comment_form;
   }
 
   private function getRevisionCommentActions(DifferentialRevision $revision) {
     $actions = array(
       DifferentialAction::ACTION_COMMENT => true,
     );
 
     $viewer = $this->getViewer();
     $viewer_phid = $viewer->getPHID();
     $viewer_is_owner = ($viewer_phid == $revision->getAuthorPHID());
     $viewer_is_reviewer = in_array($viewer_phid, $revision->getReviewers());
     $status = $revision->getStatus();
 
     $viewer_has_accepted = false;
     $viewer_has_rejected = false;
     $status_accepted = DifferentialReviewerStatus::STATUS_ACCEPTED;
     $status_rejected = DifferentialReviewerStatus::STATUS_REJECTED;
     foreach ($revision->getReviewerStatus() as $reviewer) {
       if ($reviewer->getReviewerPHID() == $viewer_phid) {
         if ($reviewer->getStatus() == $status_accepted) {
           $viewer_has_accepted = true;
         }
         if ($reviewer->getStatus() == $status_rejected) {
           $viewer_has_rejected = true;
         }
         break;
       }
     }
 
     $allow_self_accept = PhabricatorEnv::getEnvConfig(
       'differential.allow-self-accept');
     $always_allow_abandon = PhabricatorEnv::getEnvConfig(
       'differential.always-allow-abandon');
     $always_allow_close = PhabricatorEnv::getEnvConfig(
       'differential.always-allow-close');
     $allow_reopen = PhabricatorEnv::getEnvConfig(
       'differential.allow-reopen');
 
     if ($viewer_is_owner) {
       switch ($status) {
         case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
           $actions[DifferentialAction::ACTION_ACCEPT] = $allow_self_accept;
           $actions[DifferentialAction::ACTION_ABANDON] = true;
           $actions[DifferentialAction::ACTION_RETHINK] = true;
           break;
         case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
         case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
           $actions[DifferentialAction::ACTION_ACCEPT] = $allow_self_accept;
           $actions[DifferentialAction::ACTION_ABANDON] = true;
           $actions[DifferentialAction::ACTION_REQUEST] = true;
           break;
         case ArcanistDifferentialRevisionStatus::ACCEPTED:
           $actions[DifferentialAction::ACTION_ABANDON] = true;
           $actions[DifferentialAction::ACTION_REQUEST] = true;
           $actions[DifferentialAction::ACTION_RETHINK] = true;
           $actions[DifferentialAction::ACTION_CLOSE] = true;
           break;
         case ArcanistDifferentialRevisionStatus::CLOSED:
           break;
         case ArcanistDifferentialRevisionStatus::ABANDONED:
           $actions[DifferentialAction::ACTION_RECLAIM] = true;
           break;
       }
     } else {
       switch ($status) {
         case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
           $actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
           $actions[DifferentialAction::ACTION_ACCEPT] = true;
           $actions[DifferentialAction::ACTION_REJECT] = true;
           $actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
           break;
         case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
         case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
           $actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
           $actions[DifferentialAction::ACTION_ACCEPT] = true;
           $actions[DifferentialAction::ACTION_REJECT] = !$viewer_has_rejected;
           $actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
           break;
         case ArcanistDifferentialRevisionStatus::ACCEPTED:
           $actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
           $actions[DifferentialAction::ACTION_ACCEPT] = !$viewer_has_accepted;
           $actions[DifferentialAction::ACTION_REJECT] = true;
           $actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
           break;
         case ArcanistDifferentialRevisionStatus::CLOSED:
         case ArcanistDifferentialRevisionStatus::ABANDONED:
           break;
       }
       if ($status != ArcanistDifferentialRevisionStatus::CLOSED) {
         $actions[DifferentialAction::ACTION_CLAIM] = true;
         $actions[DifferentialAction::ACTION_CLOSE] = $always_allow_close;
       }
     }
 
     $actions[DifferentialAction::ACTION_ADDREVIEWERS] = true;
     $actions[DifferentialAction::ACTION_ADDCCS] = true;
     $actions[DifferentialAction::ACTION_REOPEN] = $allow_reopen &&
       ($status == ArcanistDifferentialRevisionStatus::CLOSED);
 
     $actions = array_keys(array_filter($actions));
     $actions_dict = array();
     foreach ($actions as $action) {
       $actions_dict[$action] = DifferentialAction::getActionVerb($action);
     }
 
     return $actions_dict;
   }
 
   private function loadChangesetsAndVsMap(
     DifferentialDiff $target,
     DifferentialDiff $diff_vs = null,
     PhabricatorRepository $repository = null) {
 
     $load_diffs = array($target);
     if ($diff_vs) {
       $load_diffs[] = $diff_vs;
     }
 
     $raw_changesets = id(new DifferentialChangesetQuery())
       ->setViewer($this->getRequest()->getUser())
       ->withDiffs($load_diffs)
       ->execute();
     $changeset_groups = mgroup($raw_changesets, 'getDiffID');
 
     $changesets = idx($changeset_groups, $target->getID(), array());
     $changesets = mpull($changesets, null, 'getID');
 
     $refs          = array();
     $vs_map        = array();
     $vs_changesets = array();
     if ($diff_vs) {
       $vs_id                  = $diff_vs->getID();
       $vs_changesets_path_map = array();
       foreach (idx($changeset_groups, $vs_id, array()) as $changeset) {
         $path = $changeset->getAbsoluteRepositoryPath($repository, $diff_vs);
         $vs_changesets_path_map[$path] = $changeset;
         $vs_changesets[$changeset->getID()] = $changeset;
       }
       foreach ($changesets as $key => $changeset) {
         $path = $changeset->getAbsoluteRepositoryPath($repository, $target);
         if (isset($vs_changesets_path_map[$path])) {
           $vs_map[$changeset->getID()] =
             $vs_changesets_path_map[$path]->getID();
           $refs[$changeset->getID()] =
             $changeset->getID().'/'.$vs_changesets_path_map[$path]->getID();
           unset($vs_changesets_path_map[$path]);
         } else {
           $refs[$changeset->getID()] = $changeset->getID();
         }
       }
       foreach ($vs_changesets_path_map as $path => $changeset) {
         $changesets[$changeset->getID()] = $changeset;
         $vs_map[$changeset->getID()]     = -1;
         $refs[$changeset->getID()]       = $changeset->getID().'/-1';
       }
     } else {
       foreach ($changesets as $changeset) {
         $refs[$changeset->getID()] = $changeset->getID();
       }
     }
 
     $changesets = msort($changesets, 'getSortKey');
 
     return array($changesets, $vs_map, $vs_changesets, $refs);
   }
 
   private function buildSymbolIndexes(
     PhabricatorRepository $repository,
     array $visible_changesets) {
     assert_instances_of($visible_changesets, 'DifferentialChangeset');
 
     $engine = PhabricatorSyntaxHighlighter::newEngine();
 
     $langs = $repository->getSymbolLanguages();
     $langs = nonempty($langs, array());
 
     $sources = $repository->getSymbolSources();
     $sources = nonempty($sources, array());
 
     $symbol_indexes = array();
 
     if ($langs && $sources) {
       $have_symbols = id(new DiffusionSymbolQuery())
           ->existsSymbolsInRepository($repository->getPHID());
       if (!$have_symbols) {
         return $symbol_indexes;
       }
     }
 
     $repository_phids = array_merge(
       array($repository->getPHID()),
       $sources);
 
     $indexed_langs = array_fill_keys($langs, true);
     foreach ($visible_changesets as $key => $changeset) {
       $lang = $engine->getLanguageFromFilename($changeset->getFilename());
       if (empty($indexed_langs) || isset($indexed_langs[$lang])) {
         $symbol_indexes[$key] = array(
           'lang'         => $lang,
           'repositories' => $repository_phids,
         );
       }
     }
 
     return $symbol_indexes;
   }
 
   private function loadOtherRevisions(
     array $changesets,
     DifferentialDiff $target,
     PhabricatorRepository $repository) {
     assert_instances_of($changesets, 'DifferentialChangeset');
 
     $paths = array();
     foreach ($changesets as $changeset) {
       $paths[] = $changeset->getAbsoluteRepositoryPath(
         $repository,
         $target);
     }
 
     if (!$paths) {
       return array();
     }
 
     $path_map = id(new DiffusionPathIDQuery($paths))->loadPathIDs();
 
     if (!$path_map) {
       return array();
     }
 
     $recent = (PhabricatorTime::getNow() - phutil_units('30 days in seconds'));
 
     $query = id(new DifferentialRevisionQuery())
       ->setViewer($this->getRequest()->getUser())
       ->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
       ->withUpdatedEpochBetween($recent, null)
       ->setOrder(DifferentialRevisionQuery::ORDER_MODIFIED)
       ->setLimit(10)
       ->needFlags(true)
       ->needDrafts(true)
       ->needRelationships(true);
 
     foreach ($path_map as $path => $path_id) {
       $query->withPath($repository->getID(), $path_id);
     }
 
     $results = $query->execute();
 
     // Strip out *this* revision.
     foreach ($results as $key => $result) {
       if ($result->getID() == $this->revisionID) {
         unset($results[$key]);
       }
     }
 
     return $results;
   }
 
   private function renderOtherRevisions(array $revisions) {
     assert_instances_of($revisions, 'DifferentialRevision');
     $viewer = $this->getViewer();
 
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Recent Similar Revisions'));
 
     $view = id(new DifferentialRevisionListView())
-      ->setHeader($header)
       ->setRevisions($revisions)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
+      ->setNoBox(true)
       ->setUser($viewer);
 
     $phids = $view->getRequiredHandlePHIDs();
     $handles = $this->loadViewerHandles($phids);
     $view->setHandles($handles);
 
     return $view;
   }
 
 
   /**
    * Note this code is somewhat similar to the buildPatch method in
    * @{class:DifferentialReviewRequestMail}.
    *
    * @return @{class:AphrontRedirectResponse}
    */
   private function buildRawDiffResponse(
     DifferentialRevision $revision,
     array $changesets,
     array $vs_changesets,
     array $vs_map,
     PhabricatorRepository $repository = null) {
 
     assert_instances_of($changesets,    'DifferentialChangeset');
     assert_instances_of($vs_changesets, 'DifferentialChangeset');
 
     $viewer = $this->getViewer();
 
     id(new DifferentialHunkQuery())
       ->setViewer($viewer)
       ->withChangesets($changesets)
       ->needAttachToChangesets(true)
       ->execute();
 
     $diff = new DifferentialDiff();
     $diff->attachChangesets($changesets);
     $raw_changes = $diff->buildChangesList();
     $changes = array();
     foreach ($raw_changes as $changedict) {
       $changes[] = ArcanistDiffChange::newFromDictionary($changedict);
     }
 
     $loader = id(new PhabricatorFileBundleLoader())
       ->setViewer($viewer);
 
     $bundle = ArcanistBundle::newFromChanges($changes);
     $bundle->setLoadFileDataCallback(array($loader, 'loadFileData'));
 
     $vcs = $repository ? $repository->getVersionControlSystem() : null;
     switch ($vcs) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $raw_diff = $bundle->toGitPatch();
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
       default:
         $raw_diff = $bundle->toUnifiedDiff();
         break;
     }
 
     $request_uri = $this->getRequest()->getRequestURI();
 
     // this ends up being something like
     //   D123.diff
     // or the verbose
     //   D123.vs123.id123.whitespaceignore-all.diff
     // lame but nice to include these options
     $file_name = ltrim($request_uri->getPath(), '/').'.';
     foreach ($request_uri->getQueryParams() as $key => $value) {
       if ($key == 'download') {
         continue;
       }
       $file_name .= $key.$value.'.';
     }
     $file_name .= 'diff';
 
     $file = PhabricatorFile::buildFromFileDataOrHash(
       $raw_diff,
       array(
         'name' => $file_name,
         'ttl' => (60 * 60 * 24),
         'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
       ));
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
       $file->attachToObject($revision->getPHID());
     unset($unguarded);
 
     return $file->getRedirectResponse();
   }
 
   private function buildTransactions(
     DifferentialRevision $revision,
     DifferentialDiff $left_diff,
     DifferentialDiff $right_diff,
     array $old_ids,
     array $new_ids) {
 
     $timeline = $this->buildTransactionTimeline(
       $revision,
       new DifferentialTransactionQuery(),
       $engine = null,
       array(
         'left' => $left_diff->getID(),
         'right' => $right_diff->getID(),
         'old' => implode(',', $old_ids),
         'new' => implode(',', $new_ids),
       ));
 
     return $timeline;
   }
 
   private function buildRevisionWarnings(
     DifferentialRevision $revision,
     PhabricatorCustomFieldList $field_list,
     array $warning_handle_map,
     array $handles) {
 
     $warnings = array();
     foreach ($field_list->getFields() as $key => $field) {
       $phids = idx($warning_handle_map, $key, array());
       $field_handles = array_select_keys($handles, $phids);
       $field_warnings = $field->getWarningsForRevisionHeader($field_handles);
       foreach ($field_warnings as $warning) {
         $warnings[] = $warning;
       }
     }
 
     return $warnings;
   }
 
   private function buildDiffDetailView(
     array $diffs,
     DifferentialRevision $revision,
     PhabricatorCustomFieldList $field_list) {
     $viewer = $this->getViewer();
 
     $fields = array();
     foreach ($field_list->getFields() as $field) {
       if ($field->shouldAppearInDiffPropertyView()) {
         $fields[] = $field;
       }
     }
 
     if (!$fields) {
       return null;
     }
 
     $property_lists = array();
     foreach ($this->getDiffTabLabels($diffs) as $tab) {
       list($label, $diff) = $tab;
 
       $property_lists[] = array(
         $label,
         $this->buildDiffPropertyList($diff, $revision, $fields),
       );
     }
 
     $tab_group = id(new PHUITabGroupView())
       ->setHideSingleTab(true);
 
     foreach ($property_lists as $key => $property_list) {
       list($tab_name, $list_view) = $property_list;
 
       $tab = id(new PHUITabView())
         ->setKey($key)
         ->setName($tab_name)
         ->appendChild($list_view);
 
       $tab_group->addTab($tab);
       $tab_group->selectTab($key);
     }
 
     return id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Diff Detail'))
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->setUser($viewer)
       ->addTabGroup($tab_group);
   }
 
   private function buildDiffPropertyList(
     DifferentialDiff $diff,
     DifferentialRevision $revision,
     array $fields) {
     $viewer = $this->getViewer();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setObject($diff);
 
     foreach ($fields as $field) {
       $label = $field->renderDiffPropertyViewLabel($diff);
       $value = $field->renderDiffPropertyViewValue($diff);
       if ($value !== null) {
         $view->addProperty($label, $value);
       }
     }
 
     return $view;
   }
 
   private function buildOperationsBox(DifferentialRevision $revision) {
     $viewer = $this->getViewer();
 
     // Save a query if we can't possibly have pending operations.
     $repository = $revision->getRepository();
     if (!$repository || !$repository->canPerformAutomation()) {
       return null;
     }
 
     $operations = id(new DrydockRepositoryOperationQuery())
       ->setViewer($viewer)
       ->withObjectPHIDs(array($revision->getPHID()))
       ->withIsDismissed(false)
       ->withOperationTypes(
         array(
           DrydockLandRepositoryOperation::OPCONST,
         ))
       ->execute();
     if (!$operations) {
       return null;
     }
 
     $state_fail = DrydockRepositoryOperation::STATE_FAIL;
 
     // We're going to show the oldest operation which hasn't failed, or the
     // most recent failure if they're all failures.
     $operations = msort($operations, 'getID');
     foreach ($operations as $operation) {
       if ($operation->getOperationState() != $state_fail) {
         break;
       }
     }
 
     // If we found a completed operation, don't render anything. We don't want
     // to show an older error after the thing worked properly.
     if ($operation->isDone()) {
       return null;
     }
 
     $box_view = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Active Operations'))
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);
 
     return id(new DrydockRepositoryOperationStatusView())
       ->setUser($viewer)
       ->setBoxView($box_view)
       ->setOperation($operation);
   }
 
   private function buildUnitMessagesView(
     $diff,
     DifferentialRevision $revision) {
     $viewer = $this->getViewer();
 
     if (!$diff->getBuildable()) {
       return null;
     }
 
     if (!$diff->getUnitMessages()) {
       return null;
     }
 
     $interesting_messages = array();
     foreach ($diff->getUnitMessages() as $message) {
       switch ($message->getResult()) {
         case ArcanistUnitTestResult::RESULT_PASS:
         case ArcanistUnitTestResult::RESULT_SKIP:
           break;
         default:
           $interesting_messages[] = $message;
           break;
       }
     }
 
     if (!$interesting_messages) {
       return null;
     }
 
     $excuse = null;
     if ($diff->hasDiffProperty('arc:unit-excuse')) {
       $excuse = $diff->getProperty('arc:unit-excuse');
     }
 
     return id(new HarbormasterUnitSummaryView())
       ->setUser($viewer)
       ->setExcuse($excuse)
       ->setBuildable($diff->getBuildable())
       ->setUnitMessages($diff->getUnitMessages())
       ->setLimit(5)
       ->setShowViewAll(true);
   }
 
 
 }
diff --git a/src/applications/differential/view/DifferentialLocalCommitsView.php b/src/applications/differential/view/DifferentialLocalCommitsView.php
index 639b62fc4b..4ac2bc14b3 100644
--- a/src/applications/differential/view/DifferentialLocalCommitsView.php
+++ b/src/applications/differential/view/DifferentialLocalCommitsView.php
@@ -1,154 +1,151 @@
 <?php
 
 final class DifferentialLocalCommitsView extends AphrontView {
 
   private $localCommits;
   private $commitsForLinks = array();
 
   public function setLocalCommits($local_commits) {
     $this->localCommits = $local_commits;
     return $this;
   }
 
   public function setCommitsForLinks(array $commits) {
     assert_instances_of($commits, 'PhabricatorRepositoryCommit');
     $this->commitsForLinks = $commits;
     return $this;
   }
 
   public function render() {
     $viewer = $this->getViewer();
 
     $local = $this->localCommits;
     if (!$local) {
       return null;
     }
 
     $has_tree = false;
     $has_local = false;
 
     foreach ($local as $commit) {
       if (idx($commit, 'tree')) {
         $has_tree = true;
       }
       if (idx($commit, 'local')) {
         $has_local = true;
       }
     }
 
     $rows = array();
     foreach ($local as $commit) {
       $row = array();
       if (idx($commit, 'commit')) {
         $commit_link = $this->buildCommitLink($commit['commit']);
       } else if (isset($commit['rev'])) {
         $commit_link = $this->buildCommitLink($commit['rev']);
       } else {
         $commit_link = null;
       }
       $row[] = $commit_link;
 
       if ($has_tree) {
         $row[] = $this->buildCommitLink($commit['tree']);
       }
 
       if ($has_local) {
         $row[] = $this->buildCommitLink($commit['local']);
       }
 
       $parents = idx($commit, 'parents', array());
       foreach ($parents as $k => $parent) {
         if (is_array($parent)) {
           $parent = idx($parent, 'rev');
         }
         $parents[$k] = $this->buildCommitLink($parent);
       }
       $parents = phutil_implode_html(phutil_tag('br'), $parents);
       $row[] = $parents;
 
       $author = nonempty(
         idx($commit, 'user'),
         idx($commit, 'author'));
       $row[] = $author;
 
       $message = idx($commit, 'message');
 
       $summary = idx($commit, 'summary');
       $summary = id(new PhutilUTF8StringTruncator())
         ->setMaximumGlyphs(80)
         ->truncateString($summary);
 
       $view = new AphrontMoreView();
       $view->setSome($summary);
 
       if ($message && (trim($summary) != trim($message))) {
         $view->setMore(phutil_escape_html_newlines($message));
       }
 
       $row[] = $view->render();
 
       $date = nonempty(
         idx($commit, 'date'),
         idx($commit, 'time'));
       if ($date) {
         $date = phabricator_datetime($date, $viewer);
       }
       $row[] = $date;
 
       $rows[] = $row;
     }
 
     $column_classes = array('');
     if ($has_tree) {
       $column_classes[] = '';
     }
     if ($has_local) {
       $column_classes[] = '';
     }
     $column_classes[] = '';
     $column_classes[] = '';
     $column_classes[] = 'wide';
     $column_classes[] = 'date';
     $table = id(new AphrontTableView($rows))
       ->setColumnClasses($column_classes);
     $headers = array();
     $headers[] = pht('Commit');
     if ($has_tree) {
       $headers[] = pht('Tree');
     }
     if ($has_local) {
       $headers[] = pht('Local');
     }
     $headers[] = pht('Parents');
     $headers[] = pht('Author');
     $headers[] = pht('Summary');
     $headers[] = pht('Date');
     $table->setHeaders($headers);
 
-    return id(new PHUIObjectBoxView())
-      ->setHeaderText(pht('Local Commits'))
-      ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
-      ->setTable($table);
+    return $table;
   }
 
   private static function formatCommit($commit) {
     return substr($commit, 0, 12);
   }
 
   private function buildCommitLink($hash) {
     $commit_for_link = idx($this->commitsForLinks, $hash);
     $commit_hash = self::formatCommit($hash);
     if ($commit_for_link) {
       $link = phutil_tag(
         'a',
         array(
           'href' => $commit_for_link->getURI(),
         ),
         $commit_hash);
     } else {
       $link = $commit_hash;
     }
     return $link;
   }
 
 }
diff --git a/src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php b/src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php
index 5ce766afb9..2d311fd0bd 100644
--- a/src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php
+++ b/src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php
@@ -1,432 +1,429 @@
 <?php
 
 final class DifferentialRevisionUpdateHistoryView extends AphrontView {
 
   private $diffs = array();
   private $selectedVersusDiffID;
   private $selectedDiffID;
   private $selectedWhitespace;
   private $commitsForLinks = array();
 
   public function setDiffs(array $diffs) {
     assert_instances_of($diffs, 'DifferentialDiff');
     $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 setSelectedWhitespace($whitespace) {
     $this->selectedWhitespace = $whitespace;
     return $this;
   }
 
   public function setCommitsForLinks(array $commits) {
     assert_instances_of($commits, 'PhabricatorRepositoryCommit');
     $this->commitsForLinks = $commits;
     return $this;
   }
 
   public function render() {
     $this->requireResource('differential-core-view-css');
     $this->requireResource('differential-revision-history-css');
 
     $data = array(
       array(
         'name' => pht('Base'),
         'id'   => null,
         'desc' => pht('Base'),
         'age'  => null,
         'obj'  => null,
       ),
     );
 
     $seq = 0;
     foreach ($this->diffs as $diff) {
       $data[] = array(
         'name' => pht('Diff %d', ++$seq),
         'id'   => $diff->getID(),
         'desc' => $diff->getDescription(),
         'age'  => $diff->getDateCreated(),
         'obj'  => $diff,
       );
     }
 
     $max_id = $diff->getID();
     $revision_id = $diff->getRevisionID();
 
     $idx = 0;
     $rows = array();
     $disable = false;
     $radios = array();
     $last_base = null;
     $rowc = array();
     foreach ($data as $row) {
 
       $diff = $row['obj'];
       $name = $row['name'];
       $id   = $row['id'];
 
       $old_class = false;
       $new_class = false;
 
       if ($id) {
         $new_checked = ($this->selectedDiffID == $id);
         $new = javelin_tag(
           'input',
           array(
             'type' => 'radio',
             'name' => 'id',
             'value' => $id,
             'checked' => $new_checked ? 'checked' : null,
             'sigil' => 'differential-new-radio',
           ));
         if ($new_checked) {
           $new_class = true;
           $disable = true;
         }
         $new = phutil_tag(
           'div',
           array(
             'class' => 'differential-update-history-radio',
           ),
           $new);
       } else {
         $new = null;
       }
 
       if ($max_id != $id) {
         $uniq = celerity_generate_unique_node_id();
         $old_checked = ($this->selectedVersusDiffID == $id);
         $old = phutil_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 = true;
         }
         $old = phutil_tag(
           'div',
           array(
             'class' => 'differential-update-history-radio',
           ),
           $old);
       } else {
         $old = null;
       }
 
       $desc = $row['desc'];
 
       if ($row['age']) {
         $age = phabricator_datetime($row['age'], $this->getUser());
       } else {
         $age = null;
       }
 
       if ($diff) {
         $lint = self::renderDiffLintStar($row['obj']);
         $lint = phutil_tag(
           'div',
           array(
             'class' => 'lintunit-star',
             'title' => self::getDiffLintMessage($diff),
           ),
           $lint);
 
         $unit = self::renderDiffUnitStar($row['obj']);
         $unit = phutil_tag(
           'div',
           array(
             'class' => 'lintunit-star',
             'title' => self::getDiffUnitMessage($diff),
           ),
           $unit);
 
         $base = $this->renderBaseRevision($diff);
       } else {
         $lint = null;
         $unit = null;
         $base = null;
       }
 
       if ($last_base !== null && $base !== $last_base) {
         // TODO: Render some kind of notice about rebases.
       }
       $last_base = $base;
 
       if ($revision_id) {
         $id_link = phutil_tag(
           'a',
           array(
             'href' => '/D'.$revision_id.'?id='.$id,
           ),
           $id);
       } else {
         $id_link = phutil_tag(
           'a',
           array(
             'href' => '/differential/diff/'.$id.'/',
           ),
           $id);
       }
 
       $rows[] = array(
         $name,
         $id_link,
         $base,
         $desc,
         $age,
         $lint,
         $unit,
         $old,
         $new,
       );
 
       $classes = array();
       if ($old_class) {
         $classes[] = 'differential-update-history-old-now';
       }
       if ($new_class) {
         $classes[] = 'differential-update-history-new-now';
       }
       $rowc[] = nonempty(implode(' ', $classes), null);
     }
 
     Javelin::initBehavior(
       'differential-diff-radios',
       array(
         'radios' => $radios,
       ));
 
     $options = array(
       DifferentialChangesetParser::WHITESPACE_IGNORE_ALL => pht('Ignore All'),
       DifferentialChangesetParser::WHITESPACE_IGNORE_MOST => pht('Ignore Most'),
       DifferentialChangesetParser::WHITESPACE_IGNORE_TRAILING =>
         pht('Ignore Trailing'),
       DifferentialChangesetParser::WHITESPACE_SHOW_ALL => pht('Show All'),
     );
 
     foreach ($options as $value => $label) {
       $options[$value] = phutil_tag(
         'option',
         array(
           'value' => $value,
           'selected' => ($value == $this->selectedWhitespace)
           ? 'selected'
           : null,
         ),
         $label);
     }
     $select = phutil_tag('select', array('name' => 'whitespace'), $options);
 
 
     $table = id(new AphrontTableView($rows));
     $table->setHeaders(
       array(
         pht('Diff'),
         pht('ID'),
         pht('Base'),
         pht('Description'),
         pht('Created'),
         pht('Lint'),
         pht('Unit'),
         '',
         '',
       ));
     $table->setColumnClasses(
       array(
         'pri',
         '',
         '',
         'wide',
         'date',
         'center',
         'center',
         'center differential-update-history-old',
         'center differential-update-history-new',
       ));
     $table->setRowClasses($rowc);
     $table->setDeviceVisibility(
       array(
         true,
         true,
         false,
         true,
         false,
         false,
         false,
         true,
         true,
       ));
 
     $show_diff = phutil_tag(
       'div',
       array(
         'class' => 'differential-update-history-footer',
       ),
       array(
         phutil_tag(
           'label',
           array(),
           array(
             pht('Whitespace Changes:'),
             $select,
           )),
         phutil_tag(
           'button',
           array(),
           pht('Show Diff')),
       ));
 
     $content = phabricator_form(
       $this->getUser(),
       array(
         'action' => '#toc',
       ),
       array(
         $table,
         $show_diff,
       ));
 
-    return id(new PHUIObjectBoxView())
-      ->setHeaderText(pht('Revision Update History'))
-      ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
-      ->setTable($content);
+    return $content;
   }
 
   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,
       DifferentialLintStatus::LINT_AUTO_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,
       DifferentialUnitStatus::UNIT_AUTO_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 pht('No Linters Available');
       case DifferentialLintStatus::LINT_OKAY:
         return pht('Lint OK');
       case DifferentialLintStatus::LINT_WARN:
         return pht('Lint Warnings');
       case DifferentialLintStatus::LINT_FAIL:
         return pht('Lint Errors');
       case DifferentialLintStatus::LINT_SKIP:
         return pht('Lint Skipped');
       case DifferentialLintStatus::LINT_AUTO_SKIP:
         return pht('Automatic diff as part of commit; lint not applicable.');
     }
     return pht('Unknown');
   }
 
   public static function getDiffUnitMessage(DifferentialDiff $diff) {
     switch ($diff->getUnitStatus()) {
       case DifferentialUnitStatus::UNIT_NONE:
         return pht('No Unit Test Coverage');
       case DifferentialUnitStatus::UNIT_OKAY:
         return pht('Unit Tests OK');
       case DifferentialUnitStatus::UNIT_WARN:
         return pht('Unit Test Warnings');
       case DifferentialUnitStatus::UNIT_FAIL:
         return pht('Unit Test Errors');
       case DifferentialUnitStatus::UNIT_SKIP:
         return pht('Unit Tests Skipped');
       case DifferentialUnitStatus::UNIT_AUTO_SKIP:
         return pht(
           'Automatic diff as part of commit; unit tests not applicable.');
     }
     return pht('Unknown');
   }
 
   private static function renderDiffStar($star) {
     $class = 'diff-star-'.$star;
     return phutil_tag(
       'span',
       array('class' => $class),
       "\xE2\x98\x85");
   }
 
   private function renderBaseRevision(DifferentialDiff $diff) {
     switch ($diff->getSourceControlSystem()) {
       case 'git':
         $base = $diff->getSourceControlBaseRevision();
         if (strpos($base, '@') === false) {
           $label = substr($base, 0, 7);
         } else {
           // The diff is from git-svn
           $base = explode('@', $base);
           $base = last($base);
           $label = $base;
         }
         break;
       case 'svn':
         $base = $diff->getSourceControlBaseRevision();
         $base = explode('@', $base);
         $base = last($base);
         $label = $base;
         break;
       default:
         $label = null;
         break;
     }
     $link = null;
     if ($label) {
       $commit_for_link = idx(
         $this->commitsForLinks,
         $diff->getSourceControlBaseRevision());
       if ($commit_for_link) {
         $link = phutil_tag(
           'a',
           array('href' => $commit_for_link->getURI()),
           $label);
       } else {
         $link = $label;
       }
     }
     return $link;
   }
 }
diff --git a/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php b/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
index 3330620148..e6ca6cc53d 100644
--- a/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
+++ b/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
@@ -1,183 +1,197 @@
 <?php
 
 final class PHUIDiffTableOfContentsListView extends AphrontView {
 
   private $items = array();
   private $authorityPackages;
   private $header;
   private $infoView;
   private $background;
+  private $bare;
 
   public function addItem(PHUIDiffTableOfContentsItemView $item) {
     $this->items[] = $item;
     return $this;
   }
 
   public function setAuthorityPackages(array $authority_packages) {
     assert_instances_of($authority_packages, 'PhabricatorOwnersPackage');
     $this->authorityPackages = $authority_packages;
     return $this;
   }
 
   public function getAuthorityPackages() {
     return $this->authorityPackages;
   }
 
   public function setBackground($background) {
     $this->background = $background;
     return $this;
   }
 
   public function setHeader(PHUIHeaderView $header) {
     $this->header = $header;
     return $this;
   }
 
   public function setInfoView(PHUIInfoView $infoview) {
     $this->infoView = $infoview;
     return $this;
   }
 
+  public function setBare($bare) {
+    $this->bare = $bare;
+    return $this;
+  }
+
+  public function getBare() {
+    return $this->bare;
+  }
+
   public function render() {
     $this->requireResource('differential-core-view-css');
     $this->requireResource('differential-table-of-contents-css');
 
     Javelin::initBehavior('phabricator-tooltips');
 
     if ($this->getAuthorityPackages()) {
       $authority = mpull($this->getAuthorityPackages(), null, 'getPHID');
     } else {
       $authority = array();
     }
 
     $items = $this->items;
 
     $rows = array();
     $rowc = array();
     foreach ($items as $item) {
       $item->setUser($this->getUser());
       $rows[] = $item->render();
 
       $have_authority = false;
 
       $packages = $item->getPackages();
       if ($packages) {
         if (array_intersect_key($packages, $authority)) {
           $have_authority = true;
         }
       }
 
       if ($have_authority) {
         $rowc[] = 'highlighted';
       } else {
         $rowc[] = null;
       }
     }
 
     // Check if any item has content in these columns. If no item does, we'll
     // just hide them.
     $any_coverage = false;
     $any_context = false;
     $any_packages = false;
     foreach ($items as $item) {
       if ($item->getContext() !== null) {
         $any_context = true;
       }
 
       if (strlen($item->getCoverage())) {
         $any_coverage = true;
       }
 
       if ($item->getPackages() !== null) {
         $any_packages = true;
       }
     }
 
     $reveal_link = javelin_tag(
       'a',
       array(
         'sigil' => 'differential-reveal-all',
         'mustcapture' => true,
         'class' => 'button differential-toc-reveal-all',
       ),
       pht('Show All Context'));
 
     $buttons = phutil_tag(
       'div',
       array(
         'class' => 'differential-toc-buttons grouped',
       ),
       $reveal_link);
 
     $table = id(new AphrontTableView($rows))
       ->setRowClasses($rowc)
       ->setHeaders(
         array(
           null,
           null,
           null,
           null,
           pht('Path'),
           pht('Coverage (All)'),
           pht('Coverage (Touched)'),
           pht('Packages'),
         ))
       ->setColumnClasses(
         array(
           null,
           'differential-toc-char center',
           'differential-toc-prop center',
           'differential-toc-ftype center',
           'differential-toc-file wide',
           'differential-toc-cov',
           'differential-toc-cov',
           null,
         ))
       ->setColumnVisibility(
         array(
           $any_context,
           true,
           true,
           true,
           true,
           $any_coverage,
           $any_coverage,
           $any_packages,
         ))
       ->setDeviceVisibility(
         array(
           true,
           true,
           true,
           true,
           true,
           false,
           false,
           true,
         ));
 
     $anchor = id(new PhabricatorAnchorView())
       ->setAnchorName('toc')
       ->setNavigationMarker(true);
 
+    if ($this->bare) {
+      return $table;
+    }
+
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Table of Contents'));
 
     if ($this->header) {
       $header = $this->header;
     }
 
     $box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setBackground($this->background)
       ->setTable($table)
       ->appendChild($anchor)
       ->appendChild($buttons);
 
     if ($this->infoView) {
       $box->setInfoView($this->infoView);
     }
     return $box;
   }
 
 }