diff --git a/src/applications/project/editor/PhabricatorProjectTransactionEditor.php b/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
index 2a90d6ce29..ef0cc65c8e 100644
--- a/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
+++ b/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
@@ -1,477 +1,471 @@
 <?php
 
 final class PhabricatorProjectTransactionEditor
   extends PhabricatorApplicationTransactionEditor {
 
   private $isMilestone;
 
   private function setIsMilestone($is_milestone) {
     $this->isMilestone = $is_milestone;
     return $this;
   }
 
   public function getIsMilestone() {
     return $this->isMilestone;
   }
 
   public function getEditorApplicationClass() {
     return 'PhabricatorProjectApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Projects');
   }
 
   public function getCreateObjectTitle($author, $object) {
     return pht('%s created this project.', $author);
   }
 
   public function getCreateObjectTitleForFeed($author, $object) {
     return pht('%s created %s.', $author, $object);
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_EDGE;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
     $types[] = PhabricatorTransactions::TYPE_JOIN_POLICY;
 
     return $types;
   }
 
   protected function validateAllTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $errors = array();
 
     // Prevent creating projects which are both subprojects and milestones,
     // since this does not make sense, won't work, and will break everything.
     $parent_xaction = null;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorProjectParentTransaction::TRANSACTIONTYPE:
         case PhabricatorProjectMilestoneTransaction::TRANSACTIONTYPE:
           if ($xaction->getNewValue() === null) {
             continue;
           }
 
           if (!$parent_xaction) {
             $parent_xaction = $xaction;
             continue;
           }
 
           $errors[] = new PhabricatorApplicationTransactionValidationError(
             $xaction->getTransactionType(),
             pht('Invalid'),
             pht(
               'When creating a project, specify a maximum of one parent '.
               'project or milestone project. A project can not be both a '.
               'subproject and a milestone.'),
             $xaction);
           break;
           break;
       }
     }
 
     $is_milestone = $this->getIsMilestone();
 
     $is_parent = $object->getHasSubprojects();
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorTransactions::TYPE_EDGE:
           $type = $xaction->getMetadataValue('edge:type');
           if ($type != PhabricatorProjectProjectHasMemberEdgeType::EDGECONST) {
             break;
           }
 
           if ($is_parent) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $xaction->getTransactionType(),
               pht('Invalid'),
               pht(
                 'You can not change members of a project with subprojects '.
                 'directly. Members of any subproject are automatically '.
                 'members of the parent project.'),
               $xaction);
           }
 
           if ($is_milestone) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $xaction->getTransactionType(),
               pht('Invalid'),
               pht(
                 'You can not change members of a milestone. Members of the '.
                 'parent project are automatically members of the milestone.'),
               $xaction);
           }
           break;
       }
     }
 
     return $errors;
   }
 
   protected function requireCapabilities(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
-      case PhabricatorProjectLockTransaction::TRANSACTIONTYPE:
-        PhabricatorPolicyFilter::requireCapability(
-          $this->requireActor(),
-          newv($this->getEditorApplicationClass(), array()),
-          ProjectCanLockProjectsCapability::CAPABILITY);
-        return;
       case PhabricatorTransactions::TYPE_EDGE:
         switch ($xaction->getMetadataValue('edge:type')) {
           case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
             $old = $xaction->getOldValue();
             $new = $xaction->getNewValue();
 
             $add = array_keys(array_diff_key($new, $old));
             $rem = array_keys(array_diff_key($old, $new));
 
             $actor_phid = $this->requireActor()->getPHID();
 
             $is_join = (($add === array($actor_phid)) && !$rem);
             $is_leave = (($rem === array($actor_phid)) && !$add);
 
             if ($is_join) {
               // You need CAN_JOIN to join a project.
               PhabricatorPolicyFilter::requireCapability(
                 $this->requireActor(),
                 $object,
                 PhabricatorPolicyCapability::CAN_JOIN);
             } else if ($is_leave) {
               // You usually don't need any capabilities to leave a project.
               if ($object->getIsMembershipLocked()) {
                 // you must be able to edit though to leave locked projects
                 PhabricatorPolicyFilter::requireCapability(
                   $this->requireActor(),
                   $object,
                   PhabricatorPolicyCapability::CAN_EDIT);
               }
             } else {
               if (!$this->getIsNewObject()) {
                 // You need CAN_EDIT to change members other than yourself.
                 // (PHI193) Just skip this check if we're creating a project.
                 PhabricatorPolicyFilter::requireCapability(
                   $this->requireActor(),
                   $object,
                   PhabricatorPolicyCapability::CAN_EDIT);
               }
             }
             return;
         }
         break;
     }
 
     return parent::requireCapabilities($object, $xaction);
   }
 
   protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
     // NOTE: We're using the omnipotent user here because the original actor
     // may no longer have permission to view the object.
     return id(new PhabricatorProjectQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs(array($object->getPHID()))
       ->needAncestorMembers(true)
       ->executeOne();
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function getMailSubjectPrefix() {
     return pht('[Project]');
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $this->getActingAsPHID(),
     );
   }
 
   protected function getMailCc(PhabricatorLiskDAO $object) {
     return array();
   }
 
   public function getMailTagsMap() {
     return array(
       PhabricatorProjectTransaction::MAILTAG_METADATA =>
         pht('Project name, hashtags, icon, image, or color changes.'),
       PhabricatorProjectTransaction::MAILTAG_MEMBERS =>
         pht('Project membership changes.'),
       PhabricatorProjectTransaction::MAILTAG_WATCHERS =>
         pht('Project watcher list changes.'),
       PhabricatorProjectTransaction::MAILTAG_OTHER =>
         pht('Other project activity not listed above occurs.'),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new ProjectReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $name = $object->getName();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("{$name}");
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $uri = '/project/profile/'.$object->getID().'/';
     $body->addLinkSection(
       pht('PROJECT DETAIL'),
       PhabricatorEnv::getProductionURI($uri));
 
     return $body;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $materialize = false;
     $new_parent = null;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorTransactions::TYPE_EDGE:
           switch ($xaction->getMetadataValue('edge:type')) {
             case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
               $materialize = true;
               break;
           }
           break;
         case PhabricatorProjectParentTransaction::TRANSACTIONTYPE:
         case PhabricatorProjectMilestoneTransaction::TRANSACTIONTYPE:
           $materialize = true;
           $new_parent = $object->getParentProject();
           break;
       }
     }
 
     if ($new_parent) {
       // If we just created the first subproject of this parent, we want to
       // copy all of the real members to the subproject.
       if (!$new_parent->getHasSubprojects()) {
         $member_type = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;
 
         $project_members = PhabricatorEdgeQuery::loadDestinationPHIDs(
           $new_parent->getPHID(),
           $member_type);
 
         if ($project_members) {
           $editor = id(new PhabricatorEdgeEditor());
           foreach ($project_members as $phid) {
             $editor->addEdge($object->getPHID(), $member_type, $phid);
           }
           $editor->save();
         }
       }
     }
 
     // TODO: We should dump an informational transaction onto the parent
     // project to show that we created the sub-thing.
 
     if ($materialize) {
       id(new PhabricatorProjectsMembershipIndexEngineExtension())
         ->rematerialize($object);
     }
 
     if ($new_parent) {
       id(new PhabricatorProjectsMembershipIndexEngineExtension())
         ->rematerialize($new_parent);
     }
 
     return parent::applyFinalEffects($object, $xactions);
   }
 
   public function addSlug(PhabricatorProject $project, $slug, $force) {
     $slug = PhabricatorSlug::normalizeProjectSlug($slug);
     $table = new PhabricatorProjectSlug();
     $project_phid = $project->getPHID();
 
     if ($force) {
       // If we have the `$force` flag set, we only want to ignore an existing
       // slug if it's for the same project. We'll error on collisions with
       // other projects.
       $current = $table->loadOneWhere(
         'slug = %s AND projectPHID = %s',
         $slug,
         $project_phid);
     } else {
       // Without the `$force` flag, we'll just return without doing anything
       // if any other project already has the slug.
       $current = $table->loadOneWhere(
         'slug = %s',
         $slug);
     }
 
     if ($current) {
       return;
     }
 
     return id(new PhabricatorProjectSlug())
       ->setSlug($slug)
       ->setProjectPHID($project_phid)
       ->save();
   }
 
   public function removeSlugs(PhabricatorProject $project, array $slugs) {
     if (!$slugs) {
       return;
     }
 
     // We're going to try to delete both the literal and normalized versions
     // of all slugs. This allows us to destroy old slugs that are no longer
     // valid.
     foreach ($this->normalizeSlugs($slugs) as $slug) {
       $slugs[] = $slug;
     }
 
     $objects = id(new PhabricatorProjectSlug())->loadAllWhere(
       'projectPHID = %s AND slug IN (%Ls)',
       $project->getPHID(),
       $slugs);
 
     foreach ($objects as $object) {
       $object->delete();
     }
   }
 
   public function normalizeSlugs(array $slugs) {
     foreach ($slugs as $key => $slug) {
       $slugs[$key] = PhabricatorSlug::normalizeProjectSlug($slug);
     }
 
     $slugs = array_unique($slugs);
     $slugs = array_values($slugs);
 
     return $slugs;
   }
 
   protected function adjustObjectForPolicyChecks(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $copy = parent::adjustObjectForPolicyChecks($object, $xactions);
 
     $type_edge = PhabricatorTransactions::TYPE_EDGE;
     $edgetype_member = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;
 
     $member_xaction = null;
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() !== $type_edge) {
         continue;
       }
 
       $edgetype = $xaction->getMetadataValue('edge:type');
       if ($edgetype !== $edgetype_member) {
         continue;
       }
 
       $member_xaction = $xaction;
     }
 
     if ($member_xaction) {
       $object_phid = $object->getPHID();
 
       if ($object_phid) {
         $project = id(new PhabricatorProjectQuery())
           ->setViewer($this->getActor())
           ->withPHIDs(array($object_phid))
           ->needMembers(true)
           ->executeOne();
         $members = $project->getMemberPHIDs();
       } else {
         $members = array();
       }
 
       $clone_xaction = clone $member_xaction;
       $hint = $this->getPHIDTransactionNewValue($clone_xaction, $members);
       $rule = new PhabricatorProjectMembersPolicyRule();
 
       $hint = array_fuse($hint);
 
       PhabricatorPolicyRule::passTransactionHintToRule(
         $copy,
         $rule,
         $hint);
     }
 
     return $copy;
   }
 
   protected function expandTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $actor = $this->getActor();
     $actor_phid = $actor->getPHID();
 
     $results = parent::expandTransactions($object, $xactions);
 
     $is_milestone = $object->isMilestone();
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorProjectMilestoneTransaction::TRANSACTIONTYPE:
           if ($xaction->getNewValue() !== null) {
             $is_milestone = true;
           }
           break;
       }
     }
 
     $this->setIsMilestone($is_milestone);
 
     return $results;
   }
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // Herald rules may run on behalf of other users and need to execute
     // membership checks against ancestors.
     $project = id(new PhabricatorProjectQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs(array($object->getPHID()))
       ->needAncestorMembers(true)
       ->executeOne();
 
     return id(new PhabricatorProjectHeraldAdapter())
       ->setProject($project);
   }
 
 }
diff --git a/src/applications/project/xaction/PhabricatorProjectLockTransaction.php b/src/applications/project/xaction/PhabricatorProjectLockTransaction.php
index 42551dfb2c..c54c9284ce 100644
--- a/src/applications/project/xaction/PhabricatorProjectLockTransaction.php
+++ b/src/applications/project/xaction/PhabricatorProjectLockTransaction.php
@@ -1,56 +1,64 @@
 <?php
 
 final class PhabricatorProjectLockTransaction
   extends PhabricatorProjectTransactionType {
 
   const TRANSACTIONTYPE = 'project:locked';
 
   public function generateOldValue($object) {
     return (int)$object->getIsMembershipLocked();
   }
 
   public function applyInternalEffects($object, $value) {
     $object->setIsMembershipLocked($value);
   }
 
   public function getTitle() {
     $new = $this->getNewValue();
 
     if ($new) {
       return pht(
         "%s locked this project's membership.",
         $this->renderAuthor());
     } else {
       return pht(
         "%s unlocked this project's membership.",
         $this->renderAuthor());
     }
   }
 
   public function getTitleForFeed() {
     $new = $this->getNewValue();
 
     if ($new) {
       return pht(
         '%s locked %s membership.',
         $this->renderAuthor(),
         $this->renderObject());
     } else {
       return pht(
         '%s unlocked %s membership.',
         $this->renderAuthor(),
         $this->renderObject());
     }
   }
 
   public function getIcon() {
     $new = $this->getNewValue();
 
     if ($new) {
       return 'fa-lock';
     } else {
       return 'fa-unlock';
     }
   }
 
+  public function validateTransactions($object, array $xactions) {
+    if ($xactions) {
+      $this->requireApplicationCapability(
+        ProjectCanLockProjectsCapability::CAPABILITY);
+    }
+    return array();
+  }
+
 }
diff --git a/src/applications/transactions/storage/PhabricatorModularTransactionType.php b/src/applications/transactions/storage/PhabricatorModularTransactionType.php
index eaf7d029ce..b0714aeccf 100644
--- a/src/applications/transactions/storage/PhabricatorModularTransactionType.php
+++ b/src/applications/transactions/storage/PhabricatorModularTransactionType.php
@@ -1,359 +1,369 @@
 <?php
 
 abstract class PhabricatorModularTransactionType
   extends Phobject {
 
   private $storage;
   private $viewer;
   private $editor;
 
   final public function getTransactionTypeConstant() {
     return $this->getPhobjectClassConstant('TRANSACTIONTYPE');
   }
 
   public function generateOldValue($object) {
     throw new PhutilMethodNotImplementedException();
   }
 
   public function generateNewValue($object, $value) {
     return $value;
   }
 
   public function validateTransactions($object, array $xactions) {
     return array();
   }
 
   public function willApplyTransactions($object, array $xactions) {
     return;
   }
 
   public function applyInternalEffects($object, $value) {
     return;
   }
 
   public function applyExternalEffects($object, $value) {
     return;
   }
 
   public function getTransactionHasEffect($object, $old, $new) {
     return ($old !== $new);
   }
 
   public function extractFilePHIDs($object, $value) {
     return array();
   }
 
   public function shouldHide() {
     return false;
   }
 
   public function shouldHideForFeed() {
     return false;
   }
 
   public function shouldHideForMail() {
     return false;
   }
 
   public function getIcon() {
     return null;
   }
 
   public function getTitle() {
     return null;
   }
 
   public function getTitleForFeed() {
     return null;
   }
 
   public function getActionName() {
     return null;
   }
 
   public function getActionStrength() {
     return null;
   }
 
   public function getColor() {
     return null;
   }
 
   public function hasChangeDetailView() {
     return false;
   }
 
   public function newChangeDetailView() {
     return null;
   }
 
   public function getMailDiffSectionHeader() {
     return pht('EDIT DETAILS');
   }
 
   public function newRemarkupChanges() {
     return array();
   }
 
   public function mergeTransactions(
     $object,
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
     return null;
   }
 
   final public function setStorage(
     PhabricatorApplicationTransaction $xaction) {
     $this->storage = $xaction;
     return $this;
   }
 
   private function getStorage() {
     return $this->storage;
   }
 
   final public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   final protected function getViewer() {
     return $this->viewer;
   }
 
   final public function getActor() {
     return $this->getEditor()->getActor();
   }
 
   final public function getActingAsPHID() {
     return $this->getEditor()->getActingAsPHID();
   }
 
   final public function setEditor(
     PhabricatorApplicationTransactionEditor $editor) {
     $this->editor = $editor;
     return $this;
   }
 
   final protected function getEditor() {
     if (!$this->editor) {
       throw new PhutilInvalidStateException('setEditor');
     }
     return $this->editor;
   }
 
   final protected function hasEditor() {
     return (bool)$this->editor;
   }
 
   final protected function getAuthorPHID() {
     return $this->getStorage()->getAuthorPHID();
   }
 
   final protected function getObjectPHID() {
     return $this->getStorage()->getObjectPHID();
   }
 
   final protected function getObject() {
     return $this->getStorage()->getObject();
   }
 
   final protected function getOldValue() {
     return $this->getStorage()->getOldValue();
   }
 
   final protected function getNewValue() {
     return $this->getStorage()->getNewValue();
   }
 
   final protected function renderAuthor() {
     $author_phid = $this->getAuthorPHID();
     return $this->getStorage()->renderHandleLink($author_phid);
   }
 
   final protected function renderObject() {
     $object_phid = $this->getObjectPHID();
     return $this->getStorage()->renderHandleLink($object_phid);
   }
 
   final protected function renderHandle($phid) {
     $viewer = $this->getViewer();
     $display = $viewer->renderHandle($phid);
 
     if ($this->isTextMode()) {
       $display->setAsText(true);
     }
 
     return $display;
   }
 
   final protected function renderOldHandle() {
     return $this->renderHandle($this->getOldValue());
   }
 
   final protected function renderNewHandle() {
     return $this->renderHandle($this->getNewValue());
   }
 
   final protected function renderHandleList(array $phids) {
     $viewer = $this->getViewer();
     $display = $viewer->renderHandleList($phids)
       ->setAsInline(true);
 
     if ($this->isTextMode()) {
       $display->setAsText(true);
     }
 
     return $display;
   }
 
   final protected function renderValue($value) {
     if ($this->isTextMode()) {
       return sprintf('"%s"', $value);
     }
 
     return phutil_tag(
       'span',
       array(
         'class' => 'phui-timeline-value',
       ),
       $value);
   }
 
   final protected function renderValueList(array $values) {
     $result = array();
     foreach ($values as $value) {
       $result[] = $this->renderValue($value);
     }
 
     if ($this->isTextMode()) {
       return implode(', ', $result);
     }
 
     return phutil_implode_html(', ', $result);
   }
 
   final protected function renderOldValue() {
     return $this->renderValue($this->getOldValue());
   }
 
   final protected function renderNewValue() {
     return $this->renderValue($this->getNewValue());
   }
 
   final protected function renderDate($epoch) {
     $viewer = $this->getViewer();
 
     // We accept either epoch timestamps or dictionaries describing a
     // PhutilCalendarDateTime.
     if (is_array($epoch)) {
       $datetime = PhutilCalendarAbsoluteDateTime::newFromDictionary($epoch)
         ->setViewerTimezone($viewer->getTimezoneIdentifier());
 
       $all_day = $datetime->getIsAllDay();
 
       $epoch = $datetime->getEpoch();
     } else {
       $all_day = false;
     }
 
     if ($all_day) {
       $display = phabricator_date($epoch, $viewer);
     } else if ($this->isRenderingTargetExternal()) {
       // When rendering to text, we explicitly render the offset from UTC to
       // provide context to the date: the mail may be generating with the
       // server's settings, or the user may later refer back to it after
       // changing timezones.
 
       $display = phabricator_datetimezone($epoch, $viewer);
     } else {
       $display = phabricator_datetime($epoch, $viewer);
     }
 
     return $this->renderValue($display);
   }
 
   final protected function renderOldDate() {
     return $this->renderDate($this->getOldValue());
   }
 
   final protected function renderNewDate() {
     return $this->renderDate($this->getNewValue());
   }
 
   final protected function newError($title, $message, $xaction = null) {
     return new PhabricatorApplicationTransactionValidationError(
       $this->getTransactionTypeConstant(),
       $title,
       $message,
       $xaction);
   }
 
   final protected function newRequiredError($message, $xaction = null) {
     return $this->newError(pht('Required'), $message, $xaction)
       ->setIsMissingFieldError(true);
   }
 
   final protected function newInvalidError($message, $xaction = null) {
     return $this->newError(pht('Invalid'), $message, $xaction);
   }
 
   final protected function isNewObject() {
     return $this->getEditor()->getIsNewObject();
   }
 
   final protected function isEmptyTextTransaction($value, array $xactions) {
     foreach ($xactions as $xaction) {
       $value = $xaction->getNewValue();
     }
 
     return !strlen($value);
   }
 
   /**
    * When rendering to external targets (Email/Asana/etc), we need to include
    * more information that users can't obtain later.
    */
   final protected function isRenderingTargetExternal() {
     // Right now, this is our best proxy for this:
     return $this->isTextMode();
     // "TARGET_TEXT" means "EMail" and "TARGET_HTML" means "Web".
   }
 
   final protected function isTextMode() {
     $target = $this->getStorage()->getRenderingTarget();
     return ($target == PhabricatorApplicationTransaction::TARGET_TEXT);
   }
 
   final protected function newRemarkupChange() {
     return id(new PhabricatorTransactionRemarkupChange())
       ->setTransaction($this->getStorage());
   }
 
   final protected function isCreateTransaction() {
     return $this->getStorage()->getIsCreateTransaction();
   }
 
   final protected function getPHIDList(array $old, array $new) {
     $editor = $this->getEditor();
 
     return $editor->getPHIDList($old, $new);
   }
 
   public function getMetadataValue($key, $default = null) {
     return $this->getStorage()->getMetadataValue($key, $default);
   }
 
   public function loadTransactionTypeConduitData(array $xactions) {
     return null;
   }
 
   public function getTransactionTypeForConduit($xaction) {
     return null;
   }
 
   public function getFieldValuesForConduit($xaction, $data) {
     return array();
   }
 
+  protected function requireApplicationCapability($capability) {
+    $application_class = $this->getEditor()->getEditorApplicationClass();
+    $application = newv($application_class, array());
+
+    PhabricatorPolicyFilter::requireCapability(
+      $this->getActor(),
+      $application,
+      $capability);
+  }
+
 }