diff --git a/src/applications/auth/provider/PhabricatorAuthProvider.php b/src/applications/auth/provider/PhabricatorAuthProvider.php
index bcccca5121..04548d1f0c 100644
--- a/src/applications/auth/provider/PhabricatorAuthProvider.php
+++ b/src/applications/auth/provider/PhabricatorAuthProvider.php
@@ -1,525 +1,526 @@
 <?php
 
 abstract class PhabricatorAuthProvider extends Phobject {
 
   private $providerConfig;
 
   public function attachProviderConfig(PhabricatorAuthProviderConfig $config) {
     $this->providerConfig = $config;
     return $this;
   }
 
   public function hasProviderConfig() {
     return (bool)$this->providerConfig;
   }
 
   public function getProviderConfig() {
     if ($this->providerConfig === null) {
       throw new PhutilInvalidStateException('attachProviderConfig');
     }
     return $this->providerConfig;
   }
 
   public function getConfigurationHelp() {
     return null;
   }
 
   public function getDefaultProviderConfig() {
     return id(new PhabricatorAuthProviderConfig())
       ->setProviderClass(get_class($this))
       ->setIsEnabled(1)
       ->setShouldAllowLogin(1)
       ->setShouldAllowRegistration(1)
       ->setShouldAllowLink(1)
       ->setShouldAllowUnlink(1);
   }
 
   public function getNameForCreate() {
     return $this->getProviderName();
   }
 
   public function getDescriptionForCreate() {
     return null;
   }
 
   public function getProviderKey() {
     return $this->getAdapter()->getAdapterKey();
   }
 
   public function getProviderType() {
     return $this->getAdapter()->getAdapterType();
   }
 
   public function getProviderDomain() {
     return $this->getAdapter()->getAdapterDomain();
   }
 
   public static function getAllBaseProviders() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass(__CLASS__)
       ->execute();
   }
 
   public static function getAllProviders() {
     static $providers;
 
     if ($providers === null) {
       $objects = self::getAllBaseProviders();
 
       $configs = id(new PhabricatorAuthProviderConfigQuery())
         ->setViewer(PhabricatorUser::getOmnipotentUser())
         ->execute();
 
       $providers = array();
       foreach ($configs as $config) {
         if (!isset($objects[$config->getProviderClass()])) {
           // This configuration is for a provider which is not installed.
           continue;
         }
 
         $object = clone $objects[$config->getProviderClass()];
         $object->attachProviderConfig($config);
 
         $key = $object->getProviderKey();
         if (isset($providers[$key])) {
           throw new Exception(
             pht(
               "Two authentication providers use the same provider key ".
               "('%s'). Each provider must be identified by a unique key.",
               $key));
         }
         $providers[$key] = $object;
       }
     }
 
     return $providers;
   }
 
   public static function getAllEnabledProviders() {
     $providers = self::getAllProviders();
     foreach ($providers as $key => $provider) {
       if (!$provider->isEnabled()) {
         unset($providers[$key]);
       }
     }
     return $providers;
   }
 
   public static function getEnabledProviderByKey($provider_key) {
     return idx(self::getAllEnabledProviders(), $provider_key);
   }
 
   abstract public function getProviderName();
   abstract public function getAdapter();
 
   public function isEnabled() {
     return $this->getProviderConfig()->getIsEnabled();
   }
 
   public function shouldAllowLogin() {
     return $this->getProviderConfig()->getShouldAllowLogin();
   }
 
   public function shouldAllowRegistration() {
     if (!$this->shouldAllowLogin()) {
       return false;
     }
 
     return $this->getProviderConfig()->getShouldAllowRegistration();
   }
 
   public function shouldAllowAccountLink() {
     return $this->getProviderConfig()->getShouldAllowLink();
   }
 
   public function shouldAllowAccountUnlink() {
     return $this->getProviderConfig()->getShouldAllowUnlink();
   }
 
   public function shouldTrustEmails() {
     return $this->shouldAllowEmailTrustConfiguration() &&
            $this->getProviderConfig()->getShouldTrustEmails();
   }
 
   /**
    * Should we allow the adapter to be marked as "trusted". This is true for
    * all adapters except those that allow the user to type in emails (see
    * @{class:PhabricatorPasswordAuthProvider}).
    */
   public function shouldAllowEmailTrustConfiguration() {
     return true;
   }
 
   public function buildLoginForm(PhabricatorAuthStartController $controller) {
     return $this->renderLoginForm($controller->getRequest(), $mode = 'start');
   }
 
   public function buildInviteForm(PhabricatorAuthStartController $controller) {
     return $this->renderLoginForm($controller->getRequest(), $mode = 'invite');
   }
 
   abstract public function processLoginRequest(
     PhabricatorAuthLoginController $controller);
 
   public function buildLinkForm(PhabricatorAuthLinkController $controller) {
     return $this->renderLoginForm($controller->getRequest(), $mode = 'link');
   }
 
   public function shouldAllowAccountRefresh() {
     return true;
   }
 
   public function buildRefreshForm(
     PhabricatorAuthLinkController $controller) {
     return $this->renderLoginForm($controller->getRequest(), $mode = 'refresh');
   }
 
   protected function renderLoginForm(AphrontRequest $request, $mode) {
     throw new PhutilMethodNotImplementedException();
   }
 
   public function createProviders() {
     return array($this);
   }
 
   protected function willSaveAccount(PhabricatorExternalAccount $account) {
     return;
   }
 
   public function willRegisterAccount(PhabricatorExternalAccount $account) {
     return;
   }
 
   protected function loadOrCreateAccount($account_id) {
     if (!strlen($account_id)) {
       throw new Exception(pht('Empty account ID!'));
     }
 
     $adapter = $this->getAdapter();
     $adapter_class = get_class($adapter);
 
     if (!strlen($adapter->getAdapterType())) {
       throw new Exception(
         pht(
           "AuthAdapter (of class '%s') has an invalid implementation: ".
           "no adapter type.",
           $adapter_class));
     }
 
     if (!strlen($adapter->getAdapterDomain())) {
       throw new Exception(
         pht(
           "AuthAdapter (of class '%s') has an invalid implementation: ".
           "no adapter domain.",
           $adapter_class));
     }
 
     $account = id(new PhabricatorExternalAccount())->loadOneWhere(
       'accountType = %s AND accountDomain = %s AND accountID = %s',
       $adapter->getAdapterType(),
       $adapter->getAdapterDomain(),
       $account_id);
     if (!$account) {
       $account = id(new PhabricatorExternalAccount())
         ->setAccountType($adapter->getAdapterType())
         ->setAccountDomain($adapter->getAdapterDomain())
         ->setAccountID($account_id);
     }
 
     $account->setUsername($adapter->getAccountName());
     $account->setRealName($adapter->getAccountRealName());
     $account->setEmail($adapter->getAccountEmail());
     $account->setAccountURI($adapter->getAccountURI());
 
     $account->setProfileImagePHID(null);
     $image_uri = $adapter->getAccountImageURI();
     if ($image_uri) {
       try {
         $name = PhabricatorSlug::normalize($this->getProviderName());
         $name = $name.'-profile.jpg';
 
         // TODO: If the image has not changed, we do not need to make a new
         // file entry for it, but there's no convenient way to do this with
         // PhabricatorFile right now. The storage will get shared, so the impact
         // here is negligible.
         $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
           $image_file = PhabricatorFile::newFromFileDownload(
             $image_uri,
             array(
               'name' => $name,
               'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
             ));
           if ($image_file->isViewableImage()) {
             $image_file
               ->setViewPolicy(PhabricatorPolicies::getMostOpenPolicy())
               ->setCanCDN(true)
               ->save();
             $account->setProfileImagePHID($image_file->getPHID());
           } else {
             $image_file->delete();
           }
         unset($unguarded);
 
       } catch (Exception $ex) {
         // Log this but proceed, it's not especially important that we
         // be able to pull profile images.
         phlog($ex);
       }
     }
 
     $this->willSaveAccount($account);
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
     $account->save();
     unset($unguarded);
 
     return $account;
   }
 
   public function getLoginURI() {
     $app = PhabricatorApplication::getByClass('PhabricatorAuthApplication');
     return $app->getApplicationURI('/login/'.$this->getProviderKey().'/');
   }
 
   public function getSettingsURI() {
     return '/settings/panel/external/';
   }
 
   public function getStartURI() {
     $app = PhabricatorApplication::getByClass('PhabricatorAuthApplication');
     $uri = $app->getApplicationURI('/start/');
     return $uri;
   }
 
   public function isDefaultRegistrationProvider() {
     return false;
   }
 
   public function shouldRequireRegistrationPassword() {
     return false;
   }
 
   public function getDefaultExternalAccount() {
     throw new PhutilMethodNotImplementedException();
   }
 
   public function getLoginOrder() {
     return '500-'.$this->getProviderName();
   }
 
   protected function getLoginIcon() {
     return 'Generic';
   }
 
   public function newIconView() {
     return id(new PHUIIconView())
       ->setSpriteSheet(PHUIIconView::SPRITE_LOGIN)
       ->setSpriteIcon($this->getLoginIcon());
   }
 
   public function isLoginFormAButton() {
     return false;
   }
 
   public function renderConfigPropertyTransactionTitle(
     PhabricatorAuthProviderConfigTransaction $xaction) {
 
     return null;
   }
 
   public function readFormValuesFromProvider() {
     return array();
   }
 
   public function readFormValuesFromRequest(AphrontRequest $request) {
     return array();
   }
 
   public function processEditForm(
     AphrontRequest $request,
     array $values) {
 
     $errors = array();
     $issues = array();
 
     return array($errors, $issues, $values);
   }
 
   public function extendEditForm(
     AphrontRequest $request,
     AphrontFormView $form,
     array $values,
     array $issues) {
 
     return;
   }
 
   public function willRenderLinkedAccount(
     PhabricatorUser $viewer,
     PHUIObjectItemView $item,
     PhabricatorExternalAccount $account) {
 
     $account_view = id(new PhabricatorAuthAccountView())
       ->setExternalAccount($account)
       ->setAuthProvider($this);
 
     $item->appendChild(
       phutil_tag(
         'div',
         array(
           'class' => 'mmr mml mst mmb',
         ),
         $account_view));
   }
 
   /**
    * Return true to use a two-step configuration (setup, configure) instead of
    * the default single-step configuration. In practice, this means that
    * creating a new provider instance will redirect back to the edit page
    * instead of the provider list.
    *
    * @return bool True if this provider uses two-step configuration.
    */
   public function hasSetupStep() {
     return false;
   }
 
   /**
    * Render a standard login/register button element.
    *
    * The `$attributes` parameter takes these keys:
    *
    *   - `uri`: URI the button should take the user to when clicked.
    *   - `method`: Optional HTTP method the button should use, defaults to GET.
    *
    * @param   AphrontRequest  HTTP request.
    * @param   string          Request mode string.
    * @param   map             Additional parameters, see above.
    * @return  wild            Log in button.
    */
   protected function renderStandardLoginButton(
     AphrontRequest $request,
     $mode,
     array $attributes = array()) {
 
     PhutilTypeSpec::checkMap(
       $attributes,
       array(
         'method' => 'optional string',
         'uri' => 'string',
         'sigil' => 'optional string',
       ));
 
     $viewer = $request->getUser();
     $adapter = $this->getAdapter();
 
     if ($mode == 'link') {
       $button_text = pht('Link External Account');
     } else if ($mode == 'refresh') {
       $button_text = pht('Refresh Account Link');
     } else if ($mode == 'invite') {
       $button_text = pht('Register Account');
     } else if ($this->shouldAllowRegistration()) {
       $button_text = pht('Log In or Register');
     } else {
       $button_text = pht('Log In');
     }
 
     $icon = id(new PHUIIconView())
       ->setSpriteSheet(PHUIIconView::SPRITE_LOGIN)
       ->setSpriteIcon($this->getLoginIcon());
 
     $button = id(new PHUIButtonView())
       ->setSize(PHUIButtonView::BIG)
       ->setColor(PHUIButtonView::GREY)
       ->setIcon($icon)
       ->setText($button_text)
       ->setSubtext($this->getProviderName());
 
     $uri = $attributes['uri'];
     $uri = new PhutilURI($uri);
-    $params = $uri->getQueryParams();
+    $params = $uri->getQueryParamsAsPairList();
     $uri->setQueryParams(array());
 
     $content = array($button);
 
-    foreach ($params as $key => $value) {
+    foreach ($params as $pair) {
+      list($key, $value) = $pair;
       $content[] = phutil_tag(
         'input',
         array(
           'type' => 'hidden',
           'name' => $key,
           'value' => $value,
         ));
     }
 
     $static_response = CelerityAPI::getStaticResourceResponse();
     $static_response->addContentSecurityPolicyURI('form-action', (string)$uri);
 
     foreach ($this->getContentSecurityPolicyFormActions() as $csp_uri) {
       $static_response->addContentSecurityPolicyURI('form-action', $csp_uri);
     }
 
     return phabricator_form(
       $viewer,
       array(
         'method' => idx($attributes, 'method', 'GET'),
         'action' => (string)$uri,
         'sigil'  => idx($attributes, 'sigil'),
       ),
       $content);
   }
 
   public function renderConfigurationFooter() {
     return null;
   }
 
   public function getAuthCSRFCode(AphrontRequest $request) {
     $phcid = $request->getCookie(PhabricatorCookies::COOKIE_CLIENTID);
     if (!strlen($phcid)) {
       throw new AphrontMalformedRequestException(
         pht('Missing Client ID Cookie'),
         pht(
           'Your browser did not submit a "%s" cookie with client state '.
           'information in the request. Check that cookies are enabled. '.
           'If this problem persists, you may need to clear your cookies.',
           PhabricatorCookies::COOKIE_CLIENTID),
         true);
     }
 
     return PhabricatorHash::weakDigest($phcid);
   }
 
   protected function verifyAuthCSRFCode(AphrontRequest $request, $actual) {
     $expect = $this->getAuthCSRFCode($request);
 
     if (!strlen($actual)) {
       throw new Exception(
         pht(
           'The authentication provider did not return a client state '.
           'parameter in its response, but one was expected. If this '.
           'problem persists, you may need to clear your cookies.'));
     }
 
     if (!phutil_hashes_are_identical($actual, $expect)) {
       throw new Exception(
         pht(
           'The authentication provider did not return the correct client '.
           'state parameter in its response. If this problem persists, you may '.
           'need to clear your cookies.'));
     }
   }
 
   public function supportsAutoLogin() {
     return false;
   }
 
   public function getAutoLoginURI(AphrontRequest $request) {
     throw new PhutilMethodNotImplementedException();
   }
 
   protected function getContentSecurityPolicyFormActions() {
     return array();
   }
 
 }
diff --git a/src/applications/differential/controller/DifferentialRevisionViewController.php b/src/applications/differential/controller/DifferentialRevisionViewController.php
index 8216c11557..9bc6345576 100644
--- a/src/applications/differential/controller/DifferentialRevisionViewController.php
+++ b/src/applications/differential/controller/DifferentialRevisionViewController.php
@@ -1,1455 +1,1456 @@
 <?php
 
 final class DifferentialRevisionViewController
   extends DifferentialController {
 
   private $revisionID;
   private $changesetCount;
   private $hiddenChangesets;
   private $warnings = array();
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function isLargeDiff() {
     return ($this->getChangesetCount() > $this->getLargeDiffLimit());
   }
 
   public function isVeryLargeDiff() {
     return ($this->getChangesetCount() > $this->getVeryLargeDiffLimit());
   }
 
   public function getLargeDiffLimit() {
     return 100;
   }
 
   public function getVeryLargeDiffLimit() {
     return 1000;
   }
 
   public function getChangesetCount() {
     if ($this->changesetCount === null) {
       throw new PhutilInvalidStateException('setChangesetCount');
     }
     return $this->changesetCount;
   }
 
   public function setChangesetCount($count) {
     $this->changesetCount = $count;
     return $this;
   }
 
   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($viewer)
       ->needReviewers(true)
       ->needReviewerAuthority(true)
       ->executeOne();
     if (!$revision) {
       return new Aphront404Response();
     }
 
     $diffs = id(new DifferentialDiffQuery())
       ->setViewer($viewer)
       ->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 = $this->getOldDiffID($revision, $diffs);
     if ($diff_vs instanceof AphrontResponse) {
       return $diff_vs;
     }
 
     $target_id = $this->getNewDiffID($revision, $diffs);
     if ($target_id instanceof AphrontResponse) {
       return $target_id;
     }
 
     $target = $diffs[$target_id];
 
     $target_manual = $target;
     if (!$target_id) {
       foreach ($diffs as $diff) {
         if ($diff->getCreationMethod() != 'commit') {
           $target_manual = $diff;
         }
       }
     }
 
     $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);
 
     $this->setChangesetCount(count($rendering_references));
 
     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();
 
     $subscriber_phids = PhabricatorSubscribersQuery::loadSubscribersForPHID(
       $revision->getPHID());
 
     $object_phids = array_merge(
       $revision->getReviewerPHIDs(),
       $subscriber_phids,
       $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);
     $warnings = $this->warnings;
 
     $request_uri = $request->getRequestURI();
 
     $large = $request->getStr('large');
 
     $large_warning =
       ($this->isLargeDiff()) &&
       (!$this->isVeryLargeDiff()) &&
       (!$large);
 
     if ($large_warning) {
       $count = $this->getChangesetCount();
 
       $expand_uri = $request_uri
         ->alter('large', 'true')
         ->setFragment('toc');
 
       $message = array(
         pht(
           'This large diff affects %s files. Files without inline '.
           'comments have been collapsed.',
           new PhutilNumber($count)),
         ' ',
         phutil_tag(
           'strong',
           array(),
           phutil_tag(
             'a',
             array(
               'href' => $expand_uri,
             ),
             pht('Expand All Files'))),
       );
 
       $warnings[] = id(new PHUIInfoView())
         ->setTitle(pht('Large Diff'))
         ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
         ->appendChild($message);
 
       $folded_changesets = $changesets;
     } else {
       $folded_changesets = array();
     }
 
     // Don't hide or fold changesets which have inline comments.
     $hidden_changesets = $this->hiddenChangesets;
     if ($hidden_changesets || $folded_changesets) {
       $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);
 
       foreach ($inlines as $inline) {
         $changeset_id = $inline->getChangesetID();
         if (!isset($changesets[$changeset_id])) {
           continue;
         }
 
         unset($hidden_changesets[$changeset_id]);
         unset($folded_changesets[$changeset_id]);
       }
     }
 
     // If we would hide only one changeset, don't hide anything. The notice
     // we'd render about it is about the same size as the changeset.
     if (count($hidden_changesets) < 2) {
       $hidden_changesets = array();
     }
 
     // Update the set of hidden changesets, since we may have just un-hidden
     // some of them.
     if ($hidden_changesets) {
       $warnings[] = id(new PHUIInfoView())
         ->setTitle(pht('Showing Only Differences'))
         ->setSeverity(PHUIInfoView::SEVERITY_NOTICE)
         ->appendChild(
           pht(
             'This revision modifies %s more files that are hidden because '.
             'they were not modified between selected diffs and they have no '.
             'inline comments.',
             phutil_count($hidden_changesets)));
     }
 
     // Compute the unfolded changesets. By default, everything is unfolded.
     $unfolded_changesets = $changesets;
     foreach ($folded_changesets as $changeset_id => $changeset) {
       unset($unfolded_changesets[$changeset_id]);
     }
 
     // Throw away any hidden changesets.
     foreach ($hidden_changesets as $changeset_id => $changeset) {
       unset($changesets[$changeset_id]);
       unset($unfolded_changesets[$changeset_id]);
     }
 
     $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,
         $unfolded_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);
 
     $timeline = $this->buildTransactions(
       $revision,
       $diff_vs ? $diffs[$diff_vs] : $target,
       $target,
       $old_ids,
       $new_ids);
 
     $timeline->setQuoteRef($revision->getMonogram());
 
     if ($this->isVeryLargeDiff()) {
       $messages = array();
 
       $messages[] = pht(
         'This very large diff affects more than %s files. Use the %s to '.
         'browse changes.',
         new PhutilNumber($this->getVeryLargeDiffLimit()),
         phutil_tag(
           'a',
           array(
             'href' => '/differential/diff/'.$target->getID().'/changesets/',
           ),
           phutil_tag('strong', array(), pht('Changeset List'))));
 
       $changeset_view = id(new PHUIInfoView())
         ->setErrors($messages);
     } else {
       $changeset_view = id(new DifferentialChangesetListView())
         ->setChangesets($changesets)
         ->setVisibleChangesets($unfolded_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);
 
 
       $revision_id = $revision->getID();
       $inline_list_uri = "/revision/inlines/{$revision_id}/";
       $inline_list_uri = $this->getApplicationURI($inline_list_uri);
       $changeset_view->setInlineListURI($inline_list_uri);
 
       if ($repository) {
         $changeset_view->setRepository($repository);
       }
 
       if (!$viewer_is_anonymous) {
         $changeset_view->setInlineCommentControllerURI(
           '/differential/comment/inline/edit/'.$revision->getID().'/');
       }
     }
 
     $broken_diffs = $this->loadHistoryDiffStatus($diffs);
 
     $history = id(new DifferentialRevisionUpdateHistoryView())
       ->setUser($viewer)
       ->setDiffs($diffs)
       ->setDiffUnitStatuses($broken_diffs)
       ->setSelectedVersusDiffID($diff_vs)
       ->setSelectedDiffID($target->getID())
       ->setSelectedWhitespace($whitespace)
       ->setCommitsForLinks($commits_for_links);
 
     $local_table = id(new DifferentialLocalCommitsView())
       ->setUser($viewer)
       ->setLocalCommits(idx($props, 'local:commits'))
       ->setCommitsForLinks($commits_for_links);
 
     if ($repository && !$this->isVeryLargeDiff()) {
       $other_revisions = $this->loadOtherRevisions(
         $changesets,
         $target,
         $repository);
     } else {
       $other_revisions = array();
     }
 
     $other_view = null;
     if ($other_revisions) {
       $other_view = $this->renderOtherRevisions($other_revisions);
     }
 
     if ($this->isVeryLargeDiff()) {
       $toc_view = null;
 
       // When rendering a "very large" diff, we skip computation of owners
       // that own no files because it is significantly expensive and not very
       // valuable.
       foreach ($revision->getReviewers() as $reviewer) {
         // Give each reviewer a dummy nonempty value so the UI does not render
         // the "(Owns No Changed Paths)" note. If that behavior becomes more
         // sophisticated in the future, this behavior might also need to.
         $reviewer->attachChangesets($changesets);
       }
     } else {
       $this->buildPackageMaps($changesets);
 
       $toc_view = $this->buildTableOfContents(
         $changesets,
         $unfolded_changesets,
         $target->loadCoverageMap($viewer));
 
       // Attach changesets to each reviewer so we can show which Owners package
       // reviewers own no files.
       foreach ($revision->getReviewers() as $reviewer) {
         $reviewer_phid = $reviewer->getReviewerPHID();
         $reviewer_changesets = $this->getPackageChangesets($reviewer_phid);
         $reviewer->attachChangesets($reviewer_changesets);
       }
     }
 
     $tab_group = new PHUITabGroupView();
 
     if ($toc_view) {
       $tab_group->addTab(
         id(new PHUITabView())
           ->setName(pht('Files'))
           ->setKey('files')
           ->appendChild($toc_view));
     }
 
     $tab_group->addTab(
       id(new PHUITabView())
         ->setName(pht('History'))
         ->setKey('history')
         ->appendChild($history));
 
     $filetree_on = $viewer->compareUserSetting(
       PhabricatorShowFiletreeSetting::SETTINGKEY,
       PhabricatorShowFiletreeSetting::VALUE_ENABLE_FILETREE);
 
     $collapsed_key = PhabricatorFiletreeVisibleSetting::SETTINGKEY;
     $filetree_collapsed = (bool)$viewer->getUserSetting($collapsed_key);
 
     // See PHI811. If the viewer has the file tree on, the files tab with the
     // table of contents is redundant, so default to the "History" tab instead.
     if ($filetree_on && !$filetree_collapsed) {
       $tab_group->selectTab('history');
     }
 
     $tab_group->addTab(
       id(new PHUITabView())
         ->setName(pht('Commits'))
         ->setKey('commits')
         ->appendChild($local_table));
 
     $stack_graph = id(new DifferentialRevisionGraph())
       ->setViewer($viewer)
       ->setSeedPHID($revision->getPHID())
       ->setLoadEntireGraph(true)
       ->loadGraph();
     if (!$stack_graph->isEmpty()) {
       $stack_table = $stack_graph->newGraphTable();
 
       $parent_type = DifferentialRevisionDependsOnRevisionEdgeType::EDGECONST;
       $reachable = $stack_graph->getReachableObjects($parent_type);
 
       foreach ($reachable as $key => $reachable_revision) {
         if ($reachable_revision->isClosed()) {
           unset($reachable[$key]);
         }
       }
 
       if ($reachable) {
         $stack_name = pht('Stack (%s Open)', phutil_count($reachable));
         $stack_color = PHUIListItemView::STATUS_FAIL;
       } else {
         $stack_name = pht('Stack');
         $stack_color = null;
       }
 
       $tab_group->addTab(
         id(new PHUITabView())
           ->setName($stack_name)
           ->setKey('stack')
           ->setColor($stack_color)
           ->appendChild($stack_table));
     }
 
     if ($other_view) {
       $tab_group->addTab(
         id(new PHUITabView())
           ->setName(pht('Similar'))
           ->setKey('similar')
           ->appendChild($other_view));
     }
 
     $view_button = id(new PHUIButtonView())
       ->setTag('a')
       ->setText(pht('Changeset List'))
       ->setHref('/differential/diff/'.$target->getID().'/changesets/')
       ->setIcon('fa-align-left');
 
     $tab_header = id(new PHUIHeaderView())
       ->setHeader(pht('Revision Contents'))
       ->addActionLink($view_button);
 
     $tab_view = id(new PHUIObjectBoxView())
       ->setHeader($tab_header)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->addTabGroup($tab_group);
 
     $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 {
       $anchor = id(new PhabricatorAnchorView())
         ->setAnchorName('toc')
         ->setNavigationMarker(true);
 
       $footer[] = array(
         $anchor,
         $warnings,
         $tab_view,
         $changeset_view,
       );
     }
 
     $comment_view = id(new DifferentialRevisionEditEngine())
       ->setViewer($viewer)
       ->buildEditEngineCommentView($revision);
 
     $comment_view->setTransactionTimeline($timeline);
 
     $review_warnings = array();
     foreach ($field_list->getFields() as $field) {
       $review_warnings[] = $field->getWarningsForDetailView();
     }
     $review_warnings = array_mergev($review_warnings);
 
     if ($review_warnings) {
       $warnings_view = id(new PHUIInfoView())
         ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
         ->setErrors($review_warnings);
 
       $comment_view->setInfoView($warnings_view);
     }
 
     $footer[] = $comment_view;
 
     $monogram = $revision->getMonogram();
     $operations_box = $this->buildOperationsBox($revision);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb($monogram);
     $crumbs->setBorder(true);
 
     $nav = null;
     if ($filetree_on && !$this->isVeryLargeDiff()) {
       $width_key = PhabricatorFiletreeWidthSetting::SETTINGKEY;
       $width_value = $viewer->getUserSetting($width_key);
 
       $nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
         ->setTitle($monogram)
         ->setBaseURI(new PhutilURI($revision->getURI()))
         ->setCollapsed($filetree_collapsed)
         ->setWidth((int)$width_value)
         ->build($changesets);
     }
 
     Javelin::initBehavior('differential-user-select');
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setSubheader($subheader)
       ->setCurtain($curtain)
       ->setMainColumn(
         array(
           $operations_box,
           $info_view,
           $details,
           $diff_detail_box,
           $unit_box,
           $timeline,
           $signature_message,
         ))
       ->setFooter($footer);
 
     $page =  $this->newPage()
       ->setTitle($monogram.' '.$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_tag = id(new PHUITagView())
       ->setName($revision->getStatusDisplayName())
       ->setIcon($revision->getStatusIcon())
       ->setColor($revision->getStatusTagColor())
       ->setType(PHUITagView::TYPE_SHADE);
 
     $view->addProperty(PHUIHeaderView::PROPERTY_STATUS, $status_tag);
 
     // If the revision is in a status other than "Draft", but not broadcasting,
     // add an additional "Draft" tag to the header to make it clear that this
     // revision hasn't promoted yet.
     if (!$revision->getShouldBroadcast() && !$revision->isDraft()) {
       $draft_status = DifferentialRevisionStatus::newForStatus(
         DifferentialRevisionStatus::DRAFT);
 
       $draft_tag = id(new PHUITagView())
         ->setName($draft_status->getDisplayName())
         ->setIcon($draft_status->getIcon())
         ->setColor($draft_status->getTagColor())
         ->setType(PHUITagView::TYPE_SHADE);
 
       $view->addTag($draft_tag);
     }
 
     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);
     }
 
     $repository = $revision->getRepository();
     if ($repository && $repository->canPerformAutomation()) {
       $revision_id = $revision->getID();
 
       $op = new DrydockLandRepositoryOperation();
       $barrier = $op->getBarrierToLanding($viewer, $revision);
 
       if ($barrier) {
         $can_land = false;
       } else {
         $can_land = true;
       }
 
       $action = id(new PhabricatorActionView())
         ->setName(pht('Land Revision'))
         ->setIcon('fa-fighter-jet')
         ->setHref("/differential/revision/operation/{$revision_id}/")
         ->setWorkflow(true)
         ->setDisabled(!$can_land);
 
       $curtain->addAction($action);
     }
 
     return $curtain;
   }
 
   private function loadHistoryDiffStatus(array $diffs) {
     assert_instances_of($diffs, 'DifferentialDiff');
 
     $diff_phids = mpull($diffs, 'getPHID');
     $bad_unit_status = array(
       ArcanistUnitTestResult::RESULT_FAIL,
       ArcanistUnitTestResult::RESULT_BROKEN,
     );
 
     $message = new HarbormasterBuildUnitMessage();
     $target = new HarbormasterBuildTarget();
     $build = new HarbormasterBuild();
     $buildable = new HarbormasterBuildable();
 
     $broken_diffs = queryfx_all(
       $message->establishConnection('r'),
       'SELECT distinct a.buildablePHID
         FROM %T m
           JOIN %T t ON m.buildTargetPHID = t.phid
           JOIN %T b ON t.buildPHID = b.phid
           JOIN %T a ON b.buildablePHID = a.phid
         WHERE a.buildablePHID IN (%Ls)
           AND m.result in (%Ls)',
       $message->getTableName(),
       $target->getTableName(),
       $build->getTableName(),
       $buildable->getTableName(),
       $diff_phids,
       $bad_unit_status);
 
     $unit_status = array();
     foreach ($broken_diffs as $broken) {
       $phid = $broken['buildablePHID'];
       $unit_status[$phid] = DifferentialUnitStatus::UNIT_FAIL;
     }
 
     return $unit_status;
   }
 
   private function loadChangesetsAndVsMap(
     DifferentialDiff $target,
     DifferentialDiff $diff_vs = null,
     PhabricatorRepository $repository = null) {
     $viewer = $this->getViewer();
 
     $load_diffs = array($target);
     if ($diff_vs) {
       $load_diffs[] = $diff_vs;
     }
 
     $raw_changesets = id(new DifferentialChangesetQuery())
       ->setViewer($viewer)
       ->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();
     $must_compare = 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]);
 
           $must_compare[] = $changeset->getID();
 
         } 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');
 
     // See T13137. When displaying the diff between two updates, hide any
     // changesets which haven't actually changed.
     $this->hiddenChangesets = array();
     foreach ($must_compare as $changeset_id) {
       $changeset = $changesets[$changeset_id];
       $vs_changeset = $vs_changesets[$vs_map[$changeset_id]];
 
       if ($changeset->hasSameEffectAs($vs_changeset)) {
         $this->hiddenChangesets[$changeset_id] = $changesets[$changeset_id];
       }
     }
 
     return array($changesets, $vs_map, $vs_changesets, $refs);
   }
 
   private function buildSymbolIndexes(
     PhabricatorRepository $repository,
     array $unfolded_changesets) {
     assert_instances_of($unfolded_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 ($unfolded_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())
       ->withIsOpen(true)
       ->withUpdatedEpochBetween($recent, null)
       ->setOrder(DifferentialRevisionQuery::ORDER_MODIFIED)
       ->setLimit(10)
       ->needFlags(true)
       ->needDrafts(true)
       ->needReviewers(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'));
 
     return id(new DifferentialRevisionListView())
       ->setViewer($viewer)
       ->setRevisions($revisions)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->setNoBox(true);
   }
 
 
   /**
    * 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) {
+    foreach ($request_uri->getQueryParamsAsPairList() as $pair) {
+      list($key, $value) = $pair;
       if ($key == 'download') {
         continue;
       }
       $file_name .= $key.$value.'.';
     }
     $file_name .= 'diff';
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
       $file = PhabricatorFile::newFromFileData(
         $raw_diff,
         array(
           'name' => $file_name,
           'ttl.relative' => phutil_units('24 hours in seconds'),
           'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
         ));
 
       $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())
       ->setViewer($viewer)
       ->setExcuse($excuse)
       ->setBuildable($diff->getBuildable())
       ->setUnitMessages($diff->getUnitMessages())
       ->setLimit(5)
       ->setShowViewAll(true);
   }
 
   private function getOldDiffID(DifferentialRevision $revision, array $diffs) {
     assert_instances_of($diffs, 'DifferentialDiff');
     $request = $this->getRequest();
 
     $diffs = mpull($diffs, null, 'getID');
 
     $is_new = ($request->getURIData('filter') === 'new');
     $old_id = $request->getInt('vs');
 
     // This is ambiguous, so just 404 rather than trying to figure out what
     // the user expects.
     if ($is_new && $old_id) {
       return new Aphront404Response();
     }
 
     if ($is_new) {
       $viewer = $this->getViewer();
 
       $xactions = id(new DifferentialTransactionQuery())
         ->setViewer($viewer)
         ->withObjectPHIDs(array($revision->getPHID()))
         ->withAuthorPHIDs(array($viewer->getPHID()))
         ->setOrder('newest')
         ->setLimit(1)
         ->execute();
 
       if (!$xactions) {
         $this->warnings[] = id(new PHUIInfoView())
           ->setTitle(pht('No Actions'))
           ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
           ->appendChild(
             pht(
               'Showing all changes because you have never taken an '.
               'action on this revision.'));
       } else {
         $xaction = head($xactions);
 
         // Find the transactions which updated this revision. We want to
         // figure out which diff was active when you last took an action.
         $updates = id(new DifferentialTransactionQuery())
           ->setViewer($viewer)
           ->withObjectPHIDs(array($revision->getPHID()))
           ->withTransactionTypes(
             array(
               DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE,
             ))
           ->setOrder('oldest')
           ->execute();
 
         // Sort the diffs into two buckets: those older than your last action
         // and those newer than your last action.
         $older = array();
         $newer = array();
         foreach ($updates as $update) {
           // If you updated the revision with "arc diff", try to count that
           // update as "before your last action".
           if ($update->getDateCreated() <= $xaction->getDateCreated()) {
             $older[] = $update->getNewValue();
           } else {
             $newer[] = $update->getNewValue();
           }
         }
 
         if (!$newer) {
           $this->warnings[] = id(new PHUIInfoView())
             ->setTitle(pht('No Recent Updates'))
             ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
             ->appendChild(
               pht(
                 'Showing all changes because the diff for this revision '.
                 'has not been updated since your last action.'));
         } else {
           $older = array_fuse($older);
 
           // Find the most recent diff from before the last action.
           $old = null;
           foreach ($diffs as $diff) {
             if (!isset($older[$diff->getPHID()])) {
               break;
             }
 
             $old = $diff;
           }
 
           // It's possible we may not find such a diff: transactions may have
           // been removed from the database, for example. If we miss, just
           // fail into some reasonable state since 404'ing would be perplexing.
           if ($old) {
             $this->warnings[] = id(new PHUIInfoView())
               ->setTitle(pht('New Changes Shown'))
               ->setSeverity(PHUIInfoView::SEVERITY_NOTICE)
               ->appendChild(
                 pht(
                   'Showing changes since the last action you took on this '.
                   'revision.'));
 
             $old_id = $old->getID();
           }
         }
       }
     }
 
     if (isset($diffs[$old_id])) {
       return $old_id;
     }
 
     return null;
   }
 
   private function getNewDiffID(DifferentialRevision $revision, array $diffs) {
     assert_instances_of($diffs, 'DifferentialDiff');
     $request = $this->getRequest();
 
     $diffs = mpull($diffs, null, 'getID');
 
     $is_new = ($request->getURIData('filter') === 'new');
     $new_id = $request->getInt('id');
 
     if ($is_new && $new_id) {
       return new Aphront404Response();
     }
 
     if (isset($diffs[$new_id])) {
       return $new_id;
     }
 
     return (int)last_key($diffs);
   }
 
 }
diff --git a/src/applications/differential/view/DifferentialChangesetListView.php b/src/applications/differential/view/DifferentialChangesetListView.php
index 14de553e59..367991497c 100644
--- a/src/applications/differential/view/DifferentialChangesetListView.php
+++ b/src/applications/differential/view/DifferentialChangesetListView.php
@@ -1,424 +1,443 @@
 <?php
 
 final class DifferentialChangesetListView extends AphrontView {
 
   private $changesets = array();
   private $visibleChangesets = array();
   private $references = array();
   private $inlineURI;
   private $renderURI = '/differential/changeset/';
   private $whitespace;
   private $background;
   private $header;
   private $isStandalone;
 
   private $standaloneURI;
   private $leftRawFileURI;
   private $rightRawFileURI;
   private $inlineListURI;
 
   private $symbolIndexes = array();
   private $repository;
   private $branch;
   private $diff;
   private $vsMap = array();
 
   private $title;
   private $parser;
 
   public function setParser(DifferentialChangesetParser $parser) {
     $this->parser = $parser;
     return $this;
   }
 
   public function getParser() {
     return $this->parser;
   }
 
   public function setTitle($title) {
     $this->title = $title;
     return $this;
   }
   private function getTitle() {
     return $this->title;
   }
 
   public function setBranch($branch) {
     $this->branch = $branch;
     return $this;
   }
   private function getBranch() {
     return $this->branch;
   }
 
   public function setChangesets($changesets) {
     $this->changesets = $changesets;
     return $this;
   }
 
   public function setVisibleChangesets($visible_changesets) {
     $this->visibleChangesets = $visible_changesets;
     return $this;
   }
 
   public function setInlineCommentControllerURI($uri) {
     $this->inlineURI = $uri;
     return $this;
   }
 
   public function setInlineListURI($uri) {
     $this->inlineListURI = $uri;
     return $this;
   }
 
   public function getInlineListURI() {
     return $this->inlineListURI;
   }
 
   public function setRepository(PhabricatorRepository $repository) {
     $this->repository = $repository;
     return $this;
   }
 
   public function setDiff(DifferentialDiff $diff) {
     $this->diff = $diff;
     return $this;
   }
 
   public function setRenderingReferences(array $references) {
     $this->references = $references;
     return $this;
   }
 
   public function setSymbolIndexes(array $indexes) {
     $this->symbolIndexes = $indexes;
     return $this;
   }
 
   public function setRenderURI($render_uri) {
     $this->renderURI = $render_uri;
     return $this;
   }
 
   public function setWhitespace($whitespace) {
     $this->whitespace = $whitespace;
     return $this;
   }
 
   public function setVsMap(array $vs_map) {
     $this->vsMap = $vs_map;
     return $this;
   }
 
   public function getVsMap() {
     return $this->vsMap;
   }
 
   public function setStandaloneURI($uri) {
     $this->standaloneURI = $uri;
     return $this;
   }
 
   public function setRawFileURIs($l, $r) {
     $this->leftRawFileURI = $l;
     $this->rightRawFileURI = $r;
     return $this;
   }
 
   public function setIsStandalone($is_standalone) {
     $this->isStandalone = $is_standalone;
     return $this;
   }
 
   public function getIsStandalone() {
     return $this->isStandalone;
   }
 
   public function setBackground($background) {
     $this->background = $background;
     return $this;
   }
 
   public function setHeader($header) {
     $this->header = $header;
     return $this;
   }
 
   public function render() {
     $viewer = $this->getViewer();
 
     $this->requireResource('differential-changeset-view-css');
 
     $changesets = $this->changesets;
 
     $renderer = DifferentialChangesetParser::getDefaultRendererForViewer(
       $viewer);
 
     $output = array();
     $ids = array();
     foreach ($changesets as $key => $changeset) {
 
       $file = $changeset->getFilename();
       $ref = $this->references[$key];
 
       $detail = id(new DifferentialChangesetDetailView())
         ->setUser($viewer);
 
       $uniq_id = 'diff-'.$changeset->getAnchorName();
       $detail->setID($uniq_id);
 
       $view_options = $this->renderViewOptionsDropdown(
         $detail,
         $ref,
         $changeset);
 
       $detail->setChangeset($changeset);
       $detail->addButton($view_options);
       $detail->setSymbolIndex(idx($this->symbolIndexes, $key));
       $detail->setVsChangesetID(idx($this->vsMap, $changeset->getID()));
       $detail->setEditable(true);
       $detail->setRenderingRef($ref);
 
       $detail->setRenderURI($this->renderURI);
       $detail->setWhitespace($this->whitespace);
       $detail->setRenderer($renderer);
 
       if ($this->getParser()) {
         $detail->appendChild($this->getParser()->renderChangeset());
         $detail->setLoaded(true);
       } else {
         $detail->setAutoload(isset($this->visibleChangesets[$key]));
         if (isset($this->visibleChangesets[$key])) {
           $load = pht('Loading...');
         } else {
           $load = javelin_tag(
             'a',
             array(
               'class' => 'button button-grey',
               'href' => '#'.$uniq_id,
               'sigil' => 'differential-load',
               'meta' => array(
                 'id' => $detail->getID(),
                 'kill' => true,
               ),
               'mustcapture' => true,
             ),
             pht('Load File'));
         }
         $detail->appendChild(
           phutil_tag(
             'div',
             array(
               'id' => $uniq_id,
             ),
             phutil_tag(
               'div',
               array('class' => 'differential-loading'),
               $load)));
       }
 
       $output[] = $detail->render();
       $ids[] = $detail->getID();
     }
 
     $this->requireResource('aphront-tooltip-css');
 
     $this->initBehavior(
       'differential-populate',
       array(
       'changesetViewIDs' => $ids,
       'inlineURI' => $this->inlineURI,
       'inlineListURI' => $this->inlineListURI,
       'isStandalone' => $this->getIsStandalone(),
       'pht' => array(
         'Open in Editor' => pht('Open in Editor'),
         'Show All Context' => pht('Show All Context'),
         'All Context Shown' => pht('All Context Shown'),
         "Can't Toggle Unloaded File" => pht("Can't Toggle Unloaded File"),
         'Expand File' => pht('Expand File'),
         'Collapse File' => pht('Collapse File'),
         'Browse in Diffusion' => pht('Browse in Diffusion'),
         'View Standalone' => pht('View Standalone'),
         'Show Raw File (Left)' => pht('Show Raw File (Left)'),
         'Show Raw File (Right)' => pht('Show Raw File (Right)'),
         'Configure Editor' => pht('Configure Editor'),
         'Load Changes' => pht('Load Changes'),
         'View Side-by-Side' => pht('View Side-by-Side'),
         'View Unified' => pht('View Unified'),
         'Change Text Encoding...' => pht('Change Text Encoding...'),
         'Highlight As...' => pht('Highlight As...'),
 
         'Loading...' => pht('Loading...'),
 
         'Editing Comment' => pht('Editing Comment'),
 
         'Jump to next change.' => pht('Jump to next change.'),
         'Jump to previous change.' => pht('Jump to previous change.'),
         'Jump to next file.' => pht('Jump to next file.'),
         'Jump to previous file.' => pht('Jump to previous file.'),
         'Jump to next inline comment.' => pht('Jump to next inline comment.'),
         'Jump to previous inline comment.' =>
           pht('Jump to previous inline comment.'),
         'Jump to the table of contents.' =>
           pht('Jump to the table of contents.'),
 
         'Edit selected inline comment.' =>
           pht('Edit selected inline comment.'),
         'You must select a comment to edit.' =>
           pht('You must select a comment to edit.'),
 
         'Reply to selected inline comment or change.' =>
           pht('Reply to selected inline comment or change.'),
         'You must select a comment or change to reply to.' =>
           pht('You must select a comment or change to reply to.'),
         'Reply and quote selected inline comment.' =>
           pht('Reply and quote selected inline comment.'),
 
         'Mark or unmark selected inline comment as done.' =>
           pht('Mark or unmark selected inline comment as done.'),
         'You must select a comment to mark done.' =>
           pht('You must select a comment to mark done.'),
 
         'Collapse or expand inline comment.' =>
           pht('Collapse or expand inline comment.'),
         'You must select a comment to hide.' =>
           pht('You must select a comment to hide.'),
 
         'Jump to next inline comment, including collapsed comments.' =>
           pht('Jump to next inline comment, including collapsed comments.'),
         'Jump to previous inline comment, including collapsed comments.' =>
           pht('Jump to previous inline comment, including collapsed comments.'),
 
         'This file content has been collapsed.' =>
           pht('This file content has been collapsed.'),
         'Show Content' => pht('Show Content'),
 
         'Hide or show the current file.' =>
           pht('Hide or show the current file.'),
         'You must select a file to hide or show.' =>
           pht('You must select a file to hide or show.'),
 
         'Unsaved' => pht('Unsaved'),
         'Unsubmitted' => pht('Unsubmitted'),
         'Comments' => pht('Comments'),
 
         'Hide "Done" Inlines' => pht('Hide "Done" Inlines'),
         'Hide Collapsed Inlines' => pht('Hide Collapsed Inlines'),
         'Hide Older Inlines' => pht('Hide Older Inlines'),
         'Hide All Inlines' => pht('Hide All Inlines'),
         'Show All Inlines' => pht('Show All Inlines'),
 
         'List Inline Comments' => pht('List Inline Comments'),
         'Display Options' => pht('Display Options'),
 
         'Hide or show all inline comments.' =>
           pht('Hide or show all inline comments.'),
 
         'Finish editing inline comments before changing display modes.' =>
           pht('Finish editing inline comments before changing display modes.'),
       ),
     ));
 
     if ($this->header) {
       $header = $this->header;
     } else {
       $header = id(new PHUIHeaderView())
         ->setHeader($this->getTitle());
     }
 
     $content = phutil_tag(
       'div',
       array(
         'class' => 'differential-review-stage',
         'id'    => 'differential-review-stage',
       ),
       $output);
 
     $object_box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setBackground($this->background)
       ->setCollapsed(true)
       ->appendChild($content);
 
     return $object_box;
   }
 
   private function renderViewOptionsDropdown(
     DifferentialChangesetDetailView $detail,
     $ref,
     DifferentialChangeset $changeset) {
     $viewer = $this->getViewer();
 
     $meta = array();
 
     $qparams = array(
       'ref'         => $ref,
       'whitespace'  => $this->whitespace,
     );
 
     if ($this->standaloneURI) {
       $uri = new PhutilURI($this->standaloneURI);
-      $uri->setQueryParams($uri->getQueryParams() + $qparams);
+      $uri = $this->appendDefaultQueryParams($uri, $qparams);
       $meta['standaloneURI'] = (string)$uri;
     }
 
     $repository = $this->repository;
     if ($repository) {
       try {
         $meta['diffusionURI'] =
           (string)$repository->getDiffusionBrowseURIForPath(
             $viewer,
             $changeset->getAbsoluteRepositoryPath($repository, $this->diff),
             idx($changeset->getMetadata(), 'line:first'),
             $this->getBranch());
       } catch (DiffusionSetupException $e) {
         // Ignore
       }
     }
 
     $change = $changeset->getChangeType();
 
     if ($this->leftRawFileURI) {
       if ($change != DifferentialChangeType::TYPE_ADD) {
         $uri = new PhutilURI($this->leftRawFileURI);
-        $uri->setQueryParams($uri->getQueryParams() + $qparams);
+        $uri = $this->appendDefaultQueryParams($uri, $qparams);
         $meta['leftURI'] = (string)$uri;
       }
     }
 
     if ($this->rightRawFileURI) {
       if ($change != DifferentialChangeType::TYPE_DELETE &&
           $change != DifferentialChangeType::TYPE_MULTICOPY) {
         $uri = new PhutilURI($this->rightRawFileURI);
-        $uri->setQueryParams($uri->getQueryParams() + $qparams);
+        $uri = $this->appendDefaultQueryParams($uri, $qparams);
         $meta['rightURI'] = (string)$uri;
       }
     }
 
     if ($viewer && $repository) {
       $path = ltrim(
         $changeset->getAbsoluteRepositoryPath($repository, $this->diff),
         '/');
       $line = idx($changeset->getMetadata(), 'line:first', 1);
       $editor_link = $viewer->loadEditorLink($path, $line, $repository);
       if ($editor_link) {
         $meta['editor'] = $editor_link;
       } else {
         $meta['editorConfigure'] = '/settings/panel/display/';
       }
     }
 
     $meta['containerID'] = $detail->getID();
 
     return id(new PHUIButtonView())
       ->setTag('a')
       ->setText(pht('View Options'))
       ->setIcon('fa-bars')
       ->setColor(PHUIButtonView::GREY)
       ->setHref(idx($meta, 'detailURI', '#'))
       ->setMetadata($meta)
       ->addSigil('differential-view-options');
 
   }
 
+  private function appendDefaultQueryParams(PhutilURI $uri, array $params) {
+    // Add these default query parameters to the query string if they do not
+    // already exist.
+
+    $have = array();
+    foreach ($uri->getQueryParamsAsPairList() as $pair) {
+      list($key, $value) = $pair;
+      $have[$key] = true;
+    }
+
+    foreach ($params as $key => $value) {
+      if (!isset($have[$key])) {
+        $uri->appendQueryParam($key, $value);
+      }
+    }
+
+    return $uri;
+  }
+
 }
diff --git a/src/applications/diffusion/controller/DiffusionBrowseController.php b/src/applications/diffusion/controller/DiffusionBrowseController.php
index 6a863a4a92..fcef87b7ef 100644
--- a/src/applications/diffusion/controller/DiffusionBrowseController.php
+++ b/src/applications/diffusion/controller/DiffusionBrowseController.php
@@ -1,1122 +1,1120 @@
 <?php
 
 final class DiffusionBrowseController extends DiffusionController {
 
   private $lintCommit;
   private $lintMessages;
   private $corpusButtons = array();
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $response = $this->loadDiffusionContext();
     if ($response) {
       return $response;
     }
 
     $drequest = $this->getDiffusionRequest();
 
     // Figure out if we're browsing a directory, a file, or a search result
     // list.
 
     $grep = $request->getStr('grep');
     if (strlen($grep)) {
       return $this->browseSearch();
     }
 
     $pager = id(new PHUIPagerView())
       ->readFromRequest($request);
 
     $results = DiffusionBrowseResultSet::newFromConduit(
       $this->callConduitWithDiffusionRequest(
         'diffusion.browsequery',
         array(
           'path' => $drequest->getPath(),
           'commit' => $drequest->getStableCommit(),
           'offset' => $pager->getOffset(),
           'limit' => $pager->getPageSize() + 1,
         )));
 
     $reason = $results->getReasonForEmptyResultSet();
     $is_file = ($reason == DiffusionBrowseResultSet::REASON_IS_FILE);
 
     if ($is_file) {
       return $this->browseFile();
     }
 
     $paths = $results->getPaths();
     $paths = $pager->sliceResults($paths);
     $results->setPaths($paths);
 
     return $this->browseDirectory($results, $pager);
   }
 
   private function browseSearch() {
     $drequest = $this->getDiffusionRequest();
     $header = $this->buildHeaderView($drequest);
     $path = nonempty(basename($drequest->getPath()), '/');
 
     $search_results = $this->renderSearchResults();
     $search_form = $this->renderSearchForm($path);
 
     $search_form = phutil_tag(
       'div',
       array(
         'class' => 'diffusion-mobile-search-form',
       ),
       $search_form);
 
     $crumbs = $this->buildCrumbs(
       array(
         'branch' => true,
         'path'   => true,
         'view'   => 'browse',
       ));
     $crumbs->setBorder(true);
 
     $tabs = $this->buildTabsView('code');
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setTabs($tabs)
       ->setFooter(
         array(
           $search_form,
           $search_results,
         ));
 
     return $this->newPage()
       ->setTitle(
         array(
           nonempty(basename($drequest->getPath()), '/'),
           $drequest->getRepository()->getDisplayName(),
         ))
       ->setCrumbs($crumbs)
       ->appendChild($view);
   }
 
   private function browseFile() {
     $viewer = $this->getViewer();
     $request = $this->getRequest();
     $drequest = $this->getDiffusionRequest();
     $repository = $drequest->getRepository();
 
     $before = $request->getStr('before');
     if ($before) {
       return $this->buildBeforeResponse($before);
     }
 
     $path = $drequest->getPath();
     $params = array(
       'commit' => $drequest->getCommit(),
       'path' => $drequest->getPath(),
     );
 
     $view = $request->getStr('view');
 
     $byte_limit = null;
     if ($view !== 'raw') {
       $byte_limit = PhabricatorFileStorageEngine::getChunkThreshold();
       $time_limit = 10;
 
       $params += array(
         'timeout' => $time_limit,
         'byteLimit' => $byte_limit,
       );
     }
 
     $response = $this->callConduitWithDiffusionRequest(
       'diffusion.filecontentquery',
       $params);
 
     $hit_byte_limit = $response['tooHuge'];
     $hit_time_limit = $response['tooSlow'];
 
     $file_phid = $response['filePHID'];
     $show_editor = false;
     if ($hit_byte_limit) {
       $corpus = $this->buildErrorCorpus(
         pht(
           'This file is larger than %s byte(s), and too large to display '.
           'in the web UI.',
           phutil_format_bytes($byte_limit)));
     } else if ($hit_time_limit) {
       $corpus = $this->buildErrorCorpus(
         pht(
           'This file took too long to load from the repository (more than '.
           '%s second(s)).',
           new PhutilNumber($time_limit)));
     } else {
       $file = id(new PhabricatorFileQuery())
         ->setViewer($viewer)
         ->withPHIDs(array($file_phid))
         ->executeOne();
       if (!$file) {
         throw new Exception(pht('Failed to load content file!'));
       }
 
       if ($view === 'raw') {
         return $file->getRedirectResponse();
       }
 
       $data = $file->loadFileData();
 
       $lfs_ref = $this->getGitLFSRef($repository, $data);
       if ($lfs_ref) {
         if ($view == 'git-lfs') {
           $file = $this->loadGitLFSFile($lfs_ref);
 
           // Rename the file locally so we generate a better vanity URI for
           // it. In storage, it just has a name like "lfs-13f9a94c0923...",
           // since we don't get any hints about possible human-readable names
           // at upload time.
           $basename = basename($drequest->getPath());
           $file->makeEphemeral();
           $file->setName($basename);
 
           return $file->getRedirectResponse();
         }
 
         $corpus = $this->buildGitLFSCorpus($lfs_ref);
       } else {
         $show_editor = true;
 
         $ref = id(new PhabricatorDocumentRef())
           ->setFile($file);
 
         $engine = id(new DiffusionDocumentRenderingEngine())
           ->setRequest($request)
           ->setDiffusionRequest($drequest);
 
         $corpus = $engine->newDocumentView($ref);
 
         $this->corpusButtons[] = $this->renderFileButton();
       }
     }
 
     $bar = $this->buildButtonBar($drequest, $show_editor);
     $header = $this->buildHeaderView($drequest);
     $header->setHeaderIcon('fa-file-code-o');
 
     $follow  = $request->getStr('follow');
     $follow_notice = null;
     if ($follow) {
       $follow_notice = id(new PHUIInfoView())
         ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
         ->setTitle(pht('Unable to Continue'));
       switch ($follow) {
         case 'first':
           $follow_notice->appendChild(
             pht(
               'Unable to continue tracing the history of this file because '.
               'this commit is the first commit in the repository.'));
           break;
         case 'created':
           $follow_notice->appendChild(
             pht(
               'Unable to continue tracing the history of this file because '.
               'this commit created the file.'));
           break;
       }
     }
 
     $renamed = $request->getStr('renamed');
     $renamed_notice = null;
     if ($renamed) {
       $renamed_notice = id(new PHUIInfoView())
         ->setSeverity(PHUIInfoView::SEVERITY_NOTICE)
         ->setTitle(pht('File Renamed'))
         ->appendChild(
           pht(
             'File history passes through a rename from "%s" to "%s".',
             $drequest->getPath(),
             $renamed));
     }
 
     $open_revisions = $this->buildOpenRevisions();
     $owners_list = $this->buildOwnersList($drequest);
 
     $crumbs = $this->buildCrumbs(
       array(
         'branch' => true,
         'path'   => true,
         'view'   => 'browse',
       ));
     $crumbs->setBorder(true);
 
     $basename = basename($this->getDiffusionRequest()->getPath());
     $tabs = $this->buildTabsView('code');
     $bar->setRight($this->corpusButtons);
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setTabs($tabs)
       ->setFooter(array(
         $bar,
         $follow_notice,
         $renamed_notice,
         $corpus,
         $open_revisions,
         $owners_list,
       ));
 
     $title = array($basename, $repository->getDisplayName());
 
     return $this->newPage()
       ->setTitle($title)
       ->setCrumbs($crumbs)
       ->appendChild(
         array(
           $view,
       ));
 
   }
 
   public function browseDirectory(
     DiffusionBrowseResultSet $results,
     PHUIPagerView $pager) {
 
     $request = $this->getRequest();
     $drequest = $this->getDiffusionRequest();
     $repository = $drequest->getRepository();
 
     $reason = $results->getReasonForEmptyResultSet();
 
     $this->buildActionButtons($drequest, true);
     $details = $this->buildPropertyView($drequest);
 
     $header = $this->buildHeaderView($drequest);
     $header->setHeaderIcon('fa-folder-open');
 
     $empty_result = null;
     $browse_panel = null;
     $branch_panel = null;
     if (!$results->isValidResults()) {
       $empty_result = new DiffusionEmptyResultView();
       $empty_result->setDiffusionRequest($drequest);
       $empty_result->setDiffusionBrowseResultSet($results);
       $empty_result->setView($request->getStr('view'));
     } else {
       $phids = array();
       foreach ($results->getPaths() as $result) {
         $data = $result->getLastCommitData();
         if ($data) {
           if ($data->getCommitDetail('authorPHID')) {
             $phids[$data->getCommitDetail('authorPHID')] = true;
           }
         }
       }
 
       $phids = array_keys($phids);
       $handles = $this->loadViewerHandles($phids);
 
       $browse_table = id(new DiffusionBrowseTableView())
         ->setDiffusionRequest($drequest)
         ->setHandles($handles)
         ->setPaths($results->getPaths())
         ->setUser($request->getUser());
 
       $title = nonempty(basename($drequest->getPath()), '/');
       $icon = 'fa-folder-open';
       $browse_header = $this->buildPanelHeaderView($title, $icon);
 
       $browse_panel = id(new PHUIObjectBoxView())
         ->setHeader($browse_header)
         ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
         ->setTable($browse_table)
         ->addClass('diffusion-mobile-view')
         ->setPager($pager);
 
       $path = $drequest->getPath();
       $is_branch = (!strlen($path) && $repository->supportsBranchComparison());
       if ($is_branch) {
         $branch_panel = $this->buildBranchTable();
       }
     }
 
     $open_revisions = $this->buildOpenRevisions();
     $readme = $this->renderDirectoryReadme($results);
 
     $crumbs = $this->buildCrumbs(
       array(
         'branch' => true,
         'path'   => true,
         'view'   => 'browse',
       ));
 
     $crumbs->setBorder(true);
     $tabs = $this->buildTabsView('code');
     $owners_list = $this->buildOwnersList($drequest);
     $bar = id(new PHUILeftRightView())
       ->setRight($this->corpusButtons)
       ->addClass('diffusion-action-bar');
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setTabs($tabs)
       ->setFooter(
         array(
           $bar,
           $branch_panel,
           $empty_result,
           $browse_panel,
           $open_revisions,
           $owners_list,
           $readme,
         ));
 
     if ($details) {
       $view->addPropertySection(pht('Details'), $details);
     }
 
     return $this->newPage()
       ->setTitle(array(
           nonempty(basename($drequest->getPath()), '/'),
           $repository->getDisplayName(),
         ))
       ->setCrumbs($crumbs)
       ->appendChild(
         array(
           $view,
         ));
   }
 
   private function renderSearchResults() {
     $request = $this->getRequest();
 
     $drequest = $this->getDiffusionRequest();
     $repository = $drequest->getRepository();
     $results = array();
 
     $pager = id(new PHUIPagerView())
       ->readFromRequest($request);
 
     $search_mode = null;
     switch ($repository->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $results = array();
         break;
       default:
         if (strlen($this->getRequest()->getStr('grep'))) {
           $search_mode = 'grep';
           $query_string = $request->getStr('grep');
           $results = $this->callConduitWithDiffusionRequest(
             'diffusion.searchquery',
             array(
               'grep' => $query_string,
               'commit' => $drequest->getStableCommit(),
               'path' => $drequest->getPath(),
               'limit' => $pager->getPageSize() + 1,
               'offset' => $pager->getOffset(),
             ));
         }
         break;
     }
     $results = $pager->sliceResults($results);
 
     $table = null;
     $header = null;
     if ($search_mode == 'grep') {
       $table = $this->renderGrepResults($results, $query_string);
       $title = pht(
         'File content matching "%s" under "%s"',
         $query_string,
         nonempty($drequest->getPath(), '/'));
       $header = id(new PHUIHeaderView())
         ->setHeader($title)
         ->addClass('diffusion-search-result-header');
     }
 
     return array($header, $table, $pager);
 
   }
 
   private function renderGrepResults(array $results, $pattern) {
     $drequest = $this->getDiffusionRequest();
     require_celerity_resource('phabricator-search-results-css');
 
     if (!$results) {
       return id(new PHUIInfoView())
         ->setSeverity(PHUIInfoView::SEVERITY_NODATA)
         ->appendChild(
           pht(
             'The pattern you searched for was not found in the content of any '.
             'files.'));
     }
 
     $grouped = array();
     foreach ($results as $file) {
       list($path, $line, $string) = $file;
       $grouped[$path][] = array($line, $string);
     }
 
     $view = array();
     foreach ($grouped as $path => $matches) {
       $view[] = id(new DiffusionPatternSearchView())
         ->setPath($path)
         ->setMatches($matches)
         ->setPattern($pattern)
         ->setDiffusionRequest($drequest)
         ->render();
     }
 
     return $view;
   }
 
   private function buildButtonBar(
     DiffusionRequest $drequest,
     $show_editor) {
 
     $viewer = $this->getViewer();
     $base_uri = $this->getRequest()->getRequestURI();
 
     $user = $this->getRequest()->getUser();
     $repository = $drequest->getRepository();
     $path = $drequest->getPath();
     $line = nonempty((int)$drequest->getLine(), 1);
     $buttons = array();
 
     $editor_link = $user->loadEditorLink($path, $line, $repository);
     $template = $user->loadEditorLink($path, '%l', $repository);
 
     $buttons[] =
       id(new PHUIButtonView())
         ->setTag('a')
         ->setText(pht('Last Change'))
         ->setColor(PHUIButtonView::GREY)
         ->setHref(
           $drequest->generateURI(
             array(
               'action' => 'change',
             )))
         ->setIcon('fa-backward');
 
     if ($editor_link) {
       $buttons[] =
         id(new PHUIButtonView())
           ->setTag('a')
           ->setText(pht('Open File'))
           ->setHref($editor_link)
           ->setIcon('fa-pencil')
           ->setID('editor_link')
           ->setMetadata(array('link_template' => $template))
           ->setDisabled(!$editor_link)
           ->setColor(PHUIButtonView::GREY);
     }
 
     $bar = id(new PHUILeftRightView())
       ->setLeft($buttons)
       ->addClass('diffusion-action-bar full-mobile-buttons');
     return $bar;
   }
 
   private function buildOwnersList(DiffusionRequest $drequest) {
     $viewer = $this->getViewer();
 
     $have_owners = PhabricatorApplication::isClassInstalledForViewer(
       'PhabricatorOwnersApplication',
       $viewer);
     if (!$have_owners) {
       return null;
     }
 
     $repository = $drequest->getRepository();
 
     $package_query = id(new PhabricatorOwnersPackageQuery())
       ->setViewer($viewer)
       ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
       ->withControl(
         $repository->getPHID(),
         array(
           $drequest->getPath(),
         ));
 
     $package_query->execute();
 
     $packages = $package_query->getControllingPackagesForPath(
       $repository->getPHID(),
       $drequest->getPath());
 
     $ownership = id(new PHUIObjectItemListView())
       ->setUser($viewer)
       ->setNoDataString(pht('No Owners'));
 
     if ($packages) {
       foreach ($packages as $package) {
         $item = id(new PHUIObjectItemView())
           ->setObject($package)
           ->setObjectName($package->getMonogram())
           ->setHeader($package->getName())
           ->setHref($package->getURI());
 
         $owners = $package->getOwners();
         if ($owners) {
           $owner_list = $viewer->renderHandleList(
             mpull($owners, 'getUserPHID'));
         } else {
           $owner_list = phutil_tag('em', array(), pht('None'));
         }
         $item->addAttribute(pht('Owners: %s', $owner_list));
 
         $auto = $package->getAutoReview();
         $autoreview_map = PhabricatorOwnersPackage::getAutoreviewOptionsMap();
         $spec = idx($autoreview_map, $auto, array());
         $name = idx($spec, 'name', $auto);
         $item->addIcon('fa-code', $name);
 
         $rule = $package->newAuditingRule();
         $item->addIcon($rule->getIconIcon(), $rule->getDisplayName());
 
         if ($package->isArchived()) {
           $item->setDisabled(true);
         }
 
         $ownership->addItem($item);
       }
     }
 
     $view = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Owner Packages'))
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->addClass('diffusion-mobile-view')
       ->setObjectList($ownership);
 
     return $view;
   }
 
   private function renderFileButton($file_uri = null, $label = null) {
 
     $base_uri = $this->getRequest()->getRequestURI();
 
     if ($file_uri) {
       $text = pht('Download File');
       $href = $file_uri;
       $icon = 'fa-download';
     } else {
       $text = pht('Raw File');
       $href = $base_uri->alter('view', 'raw');
       $icon = 'fa-file-text';
     }
 
     if ($label !== null) {
       $text = $label;
     }
 
     $button = id(new PHUIButtonView())
       ->setTag('a')
       ->setText($text)
       ->setHref($href)
       ->setIcon($icon)
       ->setColor(PHUIButtonView::GREY);
 
     return $button;
   }
 
   private function renderGitLFSButton() {
     $viewer = $this->getViewer();
 
     $uri = $this->getRequest()->getRequestURI();
     $href = $uri->alter('view', 'git-lfs');
 
     $text = pht('Download from Git LFS');
     $icon = 'fa-download';
 
     return id(new PHUIButtonView())
       ->setTag('a')
       ->setText($text)
       ->setHref($href)
       ->setIcon($icon)
       ->setColor(PHUIButtonView::GREY);
   }
 
   private function buildErrorCorpus($message) {
     $text = id(new PHUIBoxView())
       ->addPadding(PHUI::PADDING_LARGE)
       ->appendChild($message);
 
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Details'));
 
     $box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->appendChild($text);
 
     return $box;
   }
 
   private function buildBeforeResponse($before) {
     $request = $this->getRequest();
     $drequest = $this->getDiffusionRequest();
 
     // NOTE: We need to get the grandparent so we can capture filename changes
     // in the parent.
 
     $parent = $this->loadParentCommitOf($before);
     $old_filename = null;
     $was_created = false;
     if ($parent) {
       $grandparent = $this->loadParentCommitOf($parent);
 
       if ($grandparent) {
         $rename_query = new DiffusionRenameHistoryQuery();
         $rename_query->setRequest($drequest);
         $rename_query->setOldCommit($grandparent);
         $rename_query->setViewer($request->getUser());
         $old_filename = $rename_query->loadOldFilename();
         $was_created = $rename_query->getWasCreated();
       }
     }
 
     $follow = null;
     if ($was_created) {
       // If the file was created in history, that means older commits won't
       // have it. Since we know it existed at 'before', it must have been
       // created then; jump there.
       $target_commit = $before;
       $follow = 'created';
     } else if ($parent) {
       // If we found a parent, jump to it. This is the normal case.
       $target_commit = $parent;
     } else {
       // If there's no parent, this was probably created in the initial commit?
       // And the "was_created" check will fail because we can't identify the
       // grandparent. Keep the user at 'before'.
       $target_commit = $before;
       $follow = 'first';
     }
 
     $path = $drequest->getPath();
     $renamed = null;
     if ($old_filename !== null &&
         $old_filename !== '/'.$path) {
       $renamed = $path;
       $path = $old_filename;
     }
 
     $line = null;
     // If there's a follow error, drop the line so the user sees the message.
     if (!$follow) {
       $line = $this->getBeforeLineNumber($target_commit);
     }
 
     $before_uri = $drequest->generateURI(
       array(
         'action'    => 'browse',
         'commit'    => $target_commit,
         'line'      => $line,
         'path'      => $path,
       ));
 
-    $before_uri->setQueryParams($request->getRequestURI()->getQueryParams());
-    $before_uri = $before_uri->alter('before', null);
     $before_uri = $before_uri->alter('renamed', $renamed);
     $before_uri = $before_uri->alter('follow', $follow);
 
     return id(new AphrontRedirectResponse())->setURI($before_uri);
   }
 
   private function getBeforeLineNumber($target_commit) {
     $drequest = $this->getDiffusionRequest();
     $viewer = $this->getViewer();
 
     $line = $drequest->getLine();
     if (!$line) {
       return null;
     }
 
     $diff_info = $this->callConduitWithDiffusionRequest(
       'diffusion.rawdiffquery',
       array(
         'commit' => $drequest->getCommit(),
         'path' => $drequest->getPath(),
         'againstCommit' => $target_commit,
       ));
 
     $file_phid = $diff_info['filePHID'];
     $file = id(new PhabricatorFileQuery())
       ->setViewer($viewer)
       ->withPHIDs(array($file_phid))
       ->executeOne();
     if (!$file) {
       throw new Exception(
         pht(
           'Failed to load file ("%s") returned by "%s".',
           $file_phid,
           'diffusion.rawdiffquery.'));
     }
 
     $raw_diff = $file->loadFileData();
 
     $old_line = 0;
     $new_line = 0;
 
     foreach (explode("\n", $raw_diff) as $text) {
       if ($text[0] == '-' || $text[0] == ' ') {
         $old_line++;
       }
       if ($text[0] == '+' || $text[0] == ' ') {
         $new_line++;
       }
       if ($new_line == $line) {
         return $old_line;
       }
     }
 
     // We didn't find the target line.
     return $line;
   }
 
   private function loadParentCommitOf($commit) {
     $drequest = $this->getDiffusionRequest();
     $user = $this->getRequest()->getUser();
 
     $before_req = DiffusionRequest::newFromDictionary(
       array(
         'user' => $user,
         'repository' => $drequest->getRepository(),
         'commit' => $commit,
       ));
 
     $parents = DiffusionQuery::callConduitWithDiffusionRequest(
       $user,
       $before_req,
       'diffusion.commitparentsquery',
       array(
         'commit' => $commit,
       ));
 
     return head($parents);
   }
 
   protected function markupText($text) {
     $engine = PhabricatorMarkupEngine::newDiffusionMarkupEngine();
     $engine->setConfig('viewer', $this->getRequest()->getUser());
     $text = $engine->markupText($text);
 
     $text = phutil_tag(
       'div',
       array(
         'class' => 'phabricator-remarkup',
       ),
       $text);
 
     return $text;
   }
 
   protected function buildHeaderView(DiffusionRequest $drequest) {
     $viewer = $this->getViewer();
     $repository = $drequest->getRepository();
 
     $commit_tag = $this->renderCommitHashTag($drequest);
 
     $path = nonempty($drequest->getPath(), '/');
 
     $search = $this->renderSearchForm($path);
 
     $header = id(new PHUIHeaderView())
       ->setUser($viewer)
       ->setHeader($this->renderPathLinks($drequest, $mode = 'browse'))
       ->addActionItem($search)
       ->addTag($commit_tag)
       ->addClass('diffusion-browse-header');
 
     if (!$repository->isSVN()) {
       $branch_tag = $this->renderBranchTag($drequest);
       $header->addTag($branch_tag);
     }
 
     return $header;
   }
 
   protected function buildPanelHeaderView($title, $icon) {
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title)
       ->setHeaderIcon($icon)
       ->addClass('diffusion-panel-header-view');
 
     return $header;
 
   }
 
   protected function buildActionButtons(
     DiffusionRequest $drequest,
     $is_directory = false) {
 
     $viewer = $this->getViewer();
     $repository = $drequest->getRepository();
     $history_uri = $drequest->generateURI(array('action' => 'history'));
     $behind_head = $drequest->getSymbolicCommit();
     $compare = null;
     $head_uri = $drequest->generateURI(
       array(
         'commit' => '',
         'action' => 'browse',
       ));
 
     if ($repository->supportsBranchComparison() && $is_directory) {
       $compare_uri = $drequest->generateURI(array('action' => 'compare'));
       $compare = id(new PHUIButtonView())
         ->setText(pht('Compare'))
         ->setIcon('fa-code-fork')
         ->setWorkflow(true)
         ->setTag('a')
         ->setHref($compare_uri)
         ->setColor(PHUIButtonView::GREY);
       $this->corpusButtons[] = $compare;
     }
 
     $head = null;
     if ($behind_head) {
       $head = id(new PHUIButtonView())
         ->setTag('a')
         ->setText(pht('Back to HEAD'))
         ->setHref($head_uri)
         ->setIcon('fa-home')
         ->setColor(PHUIButtonView::GREY);
       $this->corpusButtons[] = $head;
     }
 
     $history = id(new PHUIButtonView())
       ->setText(pht('History'))
       ->setHref($history_uri)
       ->setTag('a')
       ->setIcon('fa-history')
       ->setColor(PHUIButtonView::GREY);
     $this->corpusButtons[] = $history;
 
   }
 
   protected function buildPropertyView(
     DiffusionRequest $drequest) {
 
     $viewer = $this->getViewer();
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer);
 
     if ($drequest->getSymbolicType() == 'tag') {
       $symbolic = $drequest->getSymbolicCommit();
       $view->addProperty(pht('Tag'), $symbolic);
 
       $tags = $this->callConduitWithDiffusionRequest(
         'diffusion.tagsquery',
         array(
           'names' => array($symbolic),
           'needMessages' => true,
         ));
       $tags = DiffusionRepositoryTag::newFromConduit($tags);
 
       $tags = mpull($tags, null, 'getName');
       $tag = idx($tags, $symbolic);
 
       if ($tag && strlen($tag->getMessage())) {
         $view->addSectionHeader(
           pht('Tag Content'), 'fa-tag');
         $view->addTextContent($this->markupText($tag->getMessage()));
       }
     }
 
     if ($view->hasAnyProperties()) {
       return $view;
     }
 
     return null;
   }
 
   private function buildOpenRevisions() {
     $viewer = $this->getViewer();
 
     $drequest = $this->getDiffusionRequest();
     $repository = $drequest->getRepository();
     $path = $drequest->getPath();
 
     $path_map = id(new DiffusionPathIDQuery(array($path)))->loadPathIDs();
     $path_id = idx($path_map, $path);
     if (!$path_id) {
       return null;
     }
 
     $recent = (PhabricatorTime::getNow() - phutil_units('30 days in seconds'));
 
     $revisions = id(new DifferentialRevisionQuery())
       ->setViewer($viewer)
       ->withPath($repository->getID(), $path_id)
       ->withIsOpen(true)
       ->withUpdatedEpochBetween($recent, null)
       ->setOrder(DifferentialRevisionQuery::ORDER_MODIFIED)
       ->setLimit(10)
       ->needReviewers(true)
       ->needFlags(true)
       ->needDrafts(true)
       ->execute();
 
     if (!$revisions) {
       return null;
     }
 
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('Recently Open Revisions'));
 
     $list = id(new DifferentialRevisionListView())
       ->setViewer($viewer)
       ->setRevisions($revisions)
       ->setNoBox(true);
 
     $view = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->addClass('diffusion-mobile-view')
       ->appendChild($list);
 
     return $view;
   }
 
   private function getGitLFSRef(PhabricatorRepository $repository, $data) {
     if (!$repository->canUseGitLFS()) {
       return null;
     }
 
     $lfs_pattern = '(^version https://git-lfs\\.github\\.com/spec/v1[\r\n])';
     if (!preg_match($lfs_pattern, $data)) {
       return null;
     }
 
     $matches = null;
     if (!preg_match('(^oid sha256:(.*)$)m', $data, $matches)) {
       return null;
     }
 
     $hash = $matches[1];
     $hash = trim($hash);
 
     return id(new PhabricatorRepositoryGitLFSRefQuery())
       ->setViewer($this->getViewer())
       ->withRepositoryPHIDs(array($repository->getPHID()))
       ->withObjectHashes(array($hash))
       ->executeOne();
   }
 
   private function buildGitLFSCorpus(PhabricatorRepositoryGitLFSRef $ref) {
     // TODO: We should probably test if we can load the file PHID here and
     // show the user an error if we can't, rather than making them click
     // through to hit an error.
 
     $title = basename($this->getDiffusionRequest()->getPath());
     $icon = 'fa-archive';
     $drequest = $this->getDiffusionRequest();
     $this->buildActionButtons($drequest);
     $header = $this->buildPanelHeaderView($title, $icon);
 
     $severity = PHUIInfoView::SEVERITY_NOTICE;
 
     $messages = array();
     $messages[] = pht(
       'This %s file is stored in Git Large File Storage.',
       phutil_format_bytes($ref->getByteSize()));
 
     try {
       $file = $this->loadGitLFSFile($ref);
       $this->corpusButtons[] = $this->renderGitLFSButton();
     } catch (Exception $ex) {
       $severity = PHUIInfoView::SEVERITY_ERROR;
       $messages[] = pht('The data for this file could not be loaded.');
     }
 
     $this->corpusButtons[] = $this->renderFileButton(
       null, pht('View Raw LFS Pointer'));
 
     $corpus = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->addClass('diffusion-mobile-view')
       ->setCollapsed(true);
 
     if ($messages) {
       $corpus->setInfoView(
         id(new PHUIInfoView())
           ->setSeverity($severity)
           ->setErrors($messages));
     }
 
     return $corpus;
   }
 
   private function loadGitLFSFile(PhabricatorRepositoryGitLFSRef $ref) {
     $viewer = $this->getViewer();
 
     $file = id(new PhabricatorFileQuery())
       ->setViewer($viewer)
       ->withPHIDs(array($ref->getFilePHID()))
       ->executeOne();
     if (!$file) {
       throw new Exception(
         pht(
           'Failed to load file object for Git LFS ref "%s"!',
           $ref->getObjectHash()));
     }
 
     return $file;
   }
 
   private function buildBranchTable() {
     $viewer = $this->getViewer();
     $drequest = $this->getDiffusionRequest();
     $repository = $drequest->getRepository();
 
     $branch = $drequest->getBranch();
     $default_branch = $repository->getDefaultBranch();
 
     if ($branch === $default_branch) {
       return null;
     }
 
     $pager = id(new PHUIPagerView())
       ->setPageSize(10);
 
     try {
       $results = $this->callConduitWithDiffusionRequest(
         'diffusion.historyquery',
         array(
           'commit' => $branch,
           'against' => $default_branch,
           'path' => $drequest->getPath(),
           'offset' => $pager->getOffset(),
           'limit' => $pager->getPageSize() + 1,
         ));
     } catch (Exception $ex) {
       return null;
     }
 
     $history = DiffusionPathChange::newFromConduit($results['pathChanges']);
     $history = $pager->sliceResults($history);
 
     if (!$history) {
       return null;
     }
 
     $history_table = id(new DiffusionHistoryTableView())
       ->setViewer($viewer)
       ->setDiffusionRequest($drequest)
       ->setHistory($history);
 
     $history_table->loadRevisions();
 
     $history_table
       ->setParents($results['parents'])
       ->setFilterParents(true)
       ->setIsHead(true)
       ->setIsTail(!$pager->getHasMorePages());
 
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('%s vs %s', $branch, $default_branch));
 
     return id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->addClass('diffusion-mobile-view')
       ->setTable($history_table);
   }
 
 }
diff --git a/src/applications/oauthserver/PhabricatorOAuthServer.php b/src/applications/oauthserver/PhabricatorOAuthServer.php
index f5c074f4eb..889e960213 100644
--- a/src/applications/oauthserver/PhabricatorOAuthServer.php
+++ b/src/applications/oauthserver/PhabricatorOAuthServer.php
@@ -1,284 +1,284 @@
 <?php
 
 /**
  * Implements core OAuth 2.0 Server logic.
  *
  * This class should be used behind business logic that parses input to
  * determine pertinent @{class:PhabricatorUser} $user,
  * @{class:PhabricatorOAuthServerClient} $client(s),
  * @{class:PhabricatorOAuthServerAuthorizationCode} $code(s), and.
  * @{class:PhabricatorOAuthServerAccessToken} $token(s).
  *
  * For an OAuth 2.0 server, there are two main steps:
  *
  * 1) Authorization - the user authorizes a given client to access the data
  * the OAuth 2.0 server protects. Once this is achieved / if it has
  * been achived already, the OAuth server sends the client an authorization
  * code.
  * 2) Access Token - the client should send the authorization code received in
  * step 1 along with its id and secret to the OAuth server to receive an
  * access token. This access token can later be used to access Phabricator
  * data on behalf of the user.
  *
  * @task auth Authorizing @{class:PhabricatorOAuthServerClient}s and
  *            generating @{class:PhabricatorOAuthServerAuthorizationCode}s
  * @task token Validating @{class:PhabricatorOAuthServerAuthorizationCode}s
  *             and generating @{class:PhabricatorOAuthServerAccessToken}s
  * @task internal Internals
  */
 final class PhabricatorOAuthServer extends Phobject {
 
   const AUTHORIZATION_CODE_TIMEOUT = 300;
 
   private $user;
   private $client;
 
   private function getUser() {
     if (!$this->user) {
       throw new PhutilInvalidStateException('setUser');
     }
     return $this->user;
   }
 
   public function setUser(PhabricatorUser $user) {
     $this->user = $user;
     return $this;
   }
 
   private function getClient() {
     if (!$this->client) {
       throw new PhutilInvalidStateException('setClient');
     }
     return $this->client;
   }
 
   public function setClient(PhabricatorOAuthServerClient $client) {
     $this->client = $client;
     return $this;
   }
 
   /**
    * @task auth
    * @return tuple <bool hasAuthorized, ClientAuthorization or null>
    */
   public function userHasAuthorizedClient(array $scope) {
 
     $authorization = id(new PhabricatorOAuthClientAuthorization())
       ->loadOneWhere(
         'userPHID = %s AND clientPHID = %s',
         $this->getUser()->getPHID(),
         $this->getClient()->getPHID());
     if (empty($authorization)) {
       return array(false, null);
     }
 
     if ($scope) {
       $missing_scope = array_diff_key($scope, $authorization->getScope());
     } else {
       $missing_scope = false;
     }
 
     if ($missing_scope) {
       return array(false, $authorization);
     }
 
     return array(true, $authorization);
   }
 
   /**
    * @task auth
    */
   public function authorizeClient(array $scope) {
     $authorization = new PhabricatorOAuthClientAuthorization();
     $authorization->setUserPHID($this->getUser()->getPHID());
     $authorization->setClientPHID($this->getClient()->getPHID());
     $authorization->setScope($scope);
     $authorization->save();
 
     return $authorization;
   }
 
   /**
    * @task auth
    */
   public function generateAuthorizationCode(PhutilURI $redirect_uri) {
 
     $code   = Filesystem::readRandomCharacters(32);
     $client = $this->getClient();
 
     $authorization_code = new PhabricatorOAuthServerAuthorizationCode();
     $authorization_code->setCode($code);
     $authorization_code->setClientPHID($client->getPHID());
     $authorization_code->setClientSecret($client->getSecret());
     $authorization_code->setUserPHID($this->getUser()->getPHID());
     $authorization_code->setRedirectURI((string)$redirect_uri);
     $authorization_code->save();
 
     return $authorization_code;
   }
 
   /**
    * @task token
    */
   public function generateAccessToken() {
 
     $token = Filesystem::readRandomCharacters(32);
 
     $access_token = new PhabricatorOAuthServerAccessToken();
     $access_token->setToken($token);
     $access_token->setUserPHID($this->getUser()->getPHID());
     $access_token->setClientPHID($this->getClient()->getPHID());
     $access_token->save();
 
     return $access_token;
   }
 
   /**
    * @task token
    */
   public function validateAuthorizationCode(
     PhabricatorOAuthServerAuthorizationCode $test_code,
     PhabricatorOAuthServerAuthorizationCode $valid_code) {
 
     // check that all the meta data matches
     if ($test_code->getClientPHID() != $valid_code->getClientPHID()) {
       return false;
     }
     if ($test_code->getClientSecret() != $valid_code->getClientSecret()) {
       return false;
     }
 
     // check that the authorization code hasn't timed out
     $created_time = $test_code->getDateCreated();
     $must_be_used_by = $created_time + self::AUTHORIZATION_CODE_TIMEOUT;
     return (time() < $must_be_used_by);
   }
 
   /**
    * @task token
    */
   public function authorizeToken(
     PhabricatorOAuthServerAccessToken $token) {
 
     $user_phid = $token->getUserPHID();
     $client_phid = $token->getClientPHID();
 
     $authorization = id(new PhabricatorOAuthClientAuthorizationQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withUserPHIDs(array($user_phid))
       ->withClientPHIDs(array($client_phid))
       ->executeOne();
     if (!$authorization) {
       return null;
     }
 
     $application = $authorization->getClient();
     if ($application->getIsDisabled()) {
       return null;
     }
 
     return $authorization;
   }
 
   public function validateRedirectURI($uri) {
     try {
       $this->assertValidRedirectURI($uri);
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   /**
    * See http://tools.ietf.org/html/draft-ietf-oauth-v2-23#section-3.1.2
    * for details on what makes a given redirect URI "valid".
    */
   public function assertValidRedirectURI($raw_uri) {
     // This covers basics like reasonable formatting and the existence of a
     // protocol.
     PhabricatorEnv::requireValidRemoteURIForLink($raw_uri);
 
     $uri = new PhutilURI($raw_uri);
 
     $fragment = $uri->getFragment();
     if (strlen($fragment)) {
       throw new Exception(
         pht(
           'OAuth application redirect URIs must not contain URI '.
           'fragments, but the URI "%s" has a fragment ("%s").',
           $raw_uri,
           $fragment));
     }
 
     $protocol = $uri->getProtocol();
     switch ($protocol) {
       case 'http':
       case 'https':
         break;
       default:
         throw new Exception(
           pht(
             'OAuth application redirect URIs must only use the "http" or '.
             '"https" protocols, but the URI "%s" uses the "%s" protocol.',
             $raw_uri,
             $protocol));
     }
   }
 
   /**
    * If there's a URI specified in an OAuth request, it must be validated in
    * its own right. Further, it must have the same domain, the same path, the
    * same port, and (at least) the same query parameters as the primary URI.
    */
   public function validateSecondaryRedirectURI(
     PhutilURI $secondary_uri,
     PhutilURI $primary_uri) {
 
     // The secondary URI must be valid.
     if (!$this->validateRedirectURI($secondary_uri)) {
       return false;
     }
 
     // Both URIs must point at the same domain.
     if ($secondary_uri->getDomain() != $primary_uri->getDomain()) {
       return false;
     }
 
     // Both URIs must have the same path
     if ($secondary_uri->getPath() != $primary_uri->getPath()) {
       return false;
     }
 
     // Both URIs must have the same port
     if ($secondary_uri->getPort() != $primary_uri->getPort()) {
       return false;
     }
 
     // Any query parameters present in the first URI must be exactly present
     // in the second URI.
-    $need_params = $primary_uri->getQueryParams();
-    $have_params = $secondary_uri->getQueryParams();
+    $need_params = $primary_uri->getQueryParamsAsMap();
+    $have_params = $secondary_uri->getQueryParamsAsMap();
 
     foreach ($need_params as $key => $value) {
       if (!array_key_exists($key, $have_params)) {
         return false;
       }
       if ((string)$have_params[$key] != (string)$value) {
         return false;
       }
     }
 
     // If the first URI is HTTPS, the second URI must also be HTTPS. This
     // defuses an attack where a third party with control over the network
     // tricks you into using HTTP to authenticate over a link which is supposed
     // to be HTTPS only and sniffs all your token cookies.
     if (strtolower($primary_uri->getProtocol()) == 'https') {
       if (strtolower($secondary_uri->getProtocol()) != 'https') {
         return false;
       }
     }
 
     return true;
   }
 
 }
diff --git a/src/infrastructure/markup/rule/PhabricatorYoutubeRemarkupRule.php b/src/infrastructure/markup/rule/PhabricatorYoutubeRemarkupRule.php
index cbf322b2d9..9d79d223e0 100644
--- a/src/infrastructure/markup/rule/PhabricatorYoutubeRemarkupRule.php
+++ b/src/infrastructure/markup/rule/PhabricatorYoutubeRemarkupRule.php
@@ -1,60 +1,70 @@
 <?php
 
 final class PhabricatorYoutubeRemarkupRule extends PhutilRemarkupRule {
 
   public function getPriority() {
     return 350.0;
   }
 
   public function apply($text) {
     try {
       $uri = new PhutilURI($text);
     } catch (Exception $ex) {
       return $text;
     }
 
     $domain = $uri->getDomain();
     if (!preg_match('/(^|\.)youtube\.com\z/', $domain)) {
       return $text;
     }
 
-    $params = $uri->getQueryParams();
-    $v_param = idx($params, 'v');
-    if (!strlen($v_param)) {
+    $v_params = array();
+
+    $params = $uri->getQueryParamsAsPairList();
+    foreach ($params as $pair) {
+      list($k, $v) = $pair;
+      if ($k === 'v') {
+        $v_params[] = $v;
+      }
+    }
+
+    if (count($v_params) !== 1) {
       return $text;
     }
 
+    $v_param = head($v_params);
+
     $text_mode = $this->getEngine()->isTextMode();
     $mail_mode = $this->getEngine()->isHTMLMailMode();
 
     if ($text_mode || $mail_mode) {
       return $text;
     }
 
     $youtube_src = 'https://www.youtube.com/embed/'.$v_param;
 
     $iframe = $this->newTag(
       'div',
       array(
         'class' => 'embedded-youtube-video',
       ),
       $this->newTag(
         'iframe',
         array(
           'width'       => '650',
           'height'      => '400',
           'style'       => 'margin: 1em auto; border: 0px;',
           'src'         => $youtube_src,
           'frameborder' => 0,
         ),
         ''));
 
     return $this->getEngine()->storeText($iframe);
   }
 
   public function didMarkupText() {
     CelerityAPI::getStaticResourceResponse()
       ->addContentSecurityPolicyURI('frame-src', 'https://www.youtube.com/');
   }
 
 }