diff --git a/src/applications/auth/controller/PhabricatorAuthStartController.php b/src/applications/auth/controller/PhabricatorAuthStartController.php
index 633339a356..982252d29f 100644
--- a/src/applications/auth/controller/PhabricatorAuthStartController.php
+++ b/src/applications/auth/controller/PhabricatorAuthStartController.php
@@ -1,285 +1,308 @@
 <?php
 
 final class PhabricatorAuthStartController
   extends PhabricatorAuthController {
 
   public function shouldRequireLogin() {
     return false;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getUser();
 
     if ($viewer->isLoggedIn()) {
       // Kick the user home if they are already logged in.
       return id(new AphrontRedirectResponse())->setURI('/');
     }
 
     if ($request->isAjax()) {
       return $this->processAjaxRequest();
     }
 
     if ($request->isConduit()) {
       return $this->processConduitRequest();
     }
 
     // If the user gets this far, they aren't logged in, so if they have a
     // user session token we can conclude that it's invalid: if it was valid,
     // they'd have been logged in above and never made it here. Try to clear
     // it and warn the user they may need to nuke their cookies.
 
     $session_token = $request->getCookie(PhabricatorCookies::COOKIE_SESSION);
     $did_clear = $request->getStr('cleared');
 
     if (strlen($session_token)) {
       $kind = PhabricatorAuthSessionEngine::getSessionKindFromToken(
         $session_token);
       switch ($kind) {
         case PhabricatorAuthSessionEngine::KIND_ANONYMOUS:
           // If this is an anonymous session. It's expected that they won't
           // be logged in, so we can just continue.
           break;
         default:
           // The session cookie is invalid, so try to clear it.
           $request->clearCookie(PhabricatorCookies::COOKIE_USERNAME);
           $request->clearCookie(PhabricatorCookies::COOKIE_SESSION);
 
           // We've previously tried to clear the cookie but we ended up back
           // here, so it didn't work. Hard fatal instead of trying again.
           if ($did_clear) {
             return $this->renderError(
               pht(
                 'Your login session is invalid, and clearing the session '.
                 'cookie was unsuccessful. Try clearing your browser cookies.'));
           }
 
           $redirect_uri = $request->getRequestURI();
           $redirect_uri->setQueryParam('cleared', 1);
           return id(new AphrontRedirectResponse())->setURI($redirect_uri);
       }
     }
 
     // If we just cleared the session cookie and it worked, clean up after
     // ourselves by redirecting to get rid of the "cleared" parameter. The
     // the workflow will continue normally.
     if ($did_clear) {
       $redirect_uri = $request->getRequestURI();
       $redirect_uri->setQueryParam('cleared', null);
       return id(new AphrontRedirectResponse())->setURI($redirect_uri);
     }
 
     $providers = PhabricatorAuthProvider::getAllEnabledProviders();
     foreach ($providers as $key => $provider) {
       if (!$provider->shouldAllowLogin()) {
         unset($providers[$key]);
       }
     }
 
     if (!$providers) {
       if ($this->isFirstTimeSetup()) {
         // If this is a fresh install, let the user register their admin
         // account.
         return id(new AphrontRedirectResponse())
           ->setURI($this->getApplicationURI('/register/'));
       }
 
       return $this->renderError(
         pht(
           'This Phabricator install is not configured with any enabled '.
           'authentication providers which can be used to log in. If you '.
           'have accidentally locked yourself out by disabling all providers, '.
           'you can use `%s` to recover access to an administrative account.',
           'phabricator/bin/auth recover <username>'));
     }
 
     $next_uri = $request->getStr('next');
     if (!strlen($next_uri)) {
       if ($this->getDelegatingController()) {
         // Only set a next URI from the request path if this controller was
         // delegated to, which happens when a user tries to view a page which
         // requires them to login.
 
         // If this controller handled the request directly, we're on the main
         // login page, and never want to redirect the user back here after they
         // login.
         $next_uri = (string)$this->getRequest()->getRequestURI();
       }
     }
 
     if (!$request->isFormPost()) {
       if (strlen($next_uri)) {
         PhabricatorCookies::setNextURICookie($request, $next_uri);
       }
       PhabricatorCookies::setClientIDCookie($request);
     }
 
-    if (!$request->getURIData('loggedout') && count($providers) == 1) {
-      $auto_login_provider = head($providers);
-      $auto_login_config = $auto_login_provider->getProviderConfig();
-      if ($auto_login_provider instanceof PhabricatorPhabricatorAuthProvider &&
-          $auto_login_config->getShouldAutoLogin()) {
-        $auto_login_adapter = $provider->getAdapter();
-        $auto_login_adapter->setState($provider->getAuthCSRFCode($request));
-        return id(new AphrontRedirectResponse())
-          ->setIsExternal(true)
-          ->setURI($provider->getAdapter()->getAuthenticateURI());
-      }
+    $auto_response = $this->tryAutoLogin($providers);
+    if ($auto_response) {
+      return $auto_response;
     }
 
     $invite = $this->loadInvite();
 
     $not_buttons = array();
     $are_buttons = array();
     $providers = msort($providers, 'getLoginOrder');
     foreach ($providers as $provider) {
       if ($invite) {
         $form = $provider->buildInviteForm($this);
       } else {
         $form = $provider->buildLoginForm($this);
       }
       if ($provider->isLoginFormAButton()) {
         $are_buttons[] = $form;
       } else {
         $not_buttons[] = $form;
       }
     }
 
     $out = array();
     $out[] = $not_buttons;
     if ($are_buttons) {
       require_celerity_resource('auth-css');
 
       foreach ($are_buttons as $key => $button) {
         $are_buttons[$key] = phutil_tag(
           'div',
           array(
             'class' => 'phabricator-login-button mmb',
           ),
           $button);
       }
 
       // If we only have one button, add a second pretend button so that we
       // always have two columns. This makes it easier to get the alignments
       // looking reasonable.
       if (count($are_buttons) == 1) {
         $are_buttons[] = null;
       }
 
       $button_columns = id(new AphrontMultiColumnView())
         ->setFluidLayout(true);
       $are_buttons = array_chunk($are_buttons, ceil(count($are_buttons) / 2));
       foreach ($are_buttons as $column) {
         $button_columns->addColumn($column);
       }
 
       $out[] = phutil_tag(
         'div',
         array(
           'class' => 'phabricator-login-buttons',
         ),
         $button_columns);
     }
 
     $handlers = PhabricatorAuthLoginHandler::getAllHandlers();
 
     $delegating_controller = $this->getDelegatingController();
 
     $header = array();
     foreach ($handlers as $handler) {
       $handler = clone $handler;
 
       $handler->setRequest($request);
 
       if ($delegating_controller) {
         $handler->setDelegatingController($delegating_controller);
       }
 
       $header[] = $handler->getAuthLoginHeaderContent();
     }
 
     $invite_message = null;
     if ($invite) {
       $invite_message = $this->renderInviteHeader($invite);
     }
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb(pht('Login'));
     $crumbs->setBorder(true);
 
     $title = pht('Login to Phabricator');
     $view = array(
       $header,
       $invite_message,
       $out,
     );
 
     return $this->newPage()
       ->setTitle($title)
       ->setCrumbs($crumbs)
       ->appendChild($view);
   }
 
 
   private function processAjaxRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     // We end up here if the user clicks a workflow link that they need to
     // login to use. We give them a dialog saying "You need to login...".
 
     if ($request->isDialogFormPost()) {
       return id(new AphrontRedirectResponse())->setURI(
         $request->getRequestURI());
     }
 
     // Often, users end up here by clicking a disabled action link in the UI
     // (for example, they might click "Edit Blocking Tasks" on a Maniphest
     // task page). After they log in we want to send them back to that main
     // object page if we can, since it's confusing to end up on a standalone
     // page with only a dialog (particularly if that dialog is another error,
     // like a policy exception).
 
     $via_header = AphrontRequest::getViaHeaderName();
     $via_uri = AphrontRequest::getHTTPHeader($via_header);
     if (strlen($via_uri)) {
       PhabricatorCookies::setNextURICookie($request, $via_uri, $force = true);
     }
 
     return $this->newDialog()
       ->setTitle(pht('Login Required'))
       ->appendParagraph(pht('You must login to take this action.'))
       ->addSubmitButton(pht('Login'))
       ->addCancelButton('/');
   }
 
 
   private function processConduitRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     // A common source of errors in Conduit client configuration is getting
     // the request path wrong. The client will end up here, so make some
     // effort to give them a comprehensible error message.
 
     $request_path = $this->getRequest()->getPath();
     $conduit_path = '/api/<method>';
     $example_path = '/api/conduit.ping';
 
     $message = pht(
       'ERROR: You are making a Conduit API request to "%s", but the correct '.
       'HTTP request path to use in order to access a COnduit method is "%s" '.
       '(for example, "%s"). Check your configuration.',
       $request_path,
       $conduit_path,
       $example_path);
 
     return id(new AphrontPlainTextResponse())->setContent($message);
   }
 
   protected function renderError($message) {
     return $this->renderErrorPage(
       pht('Authentication Failure'),
       array($message));
   }
 
+  private function tryAutoLogin(array $providers) {
+    $request = $this->getRequest();
+
+    // If the user just logged out, don't immediately log them in again.
+    if ($request->getURIData('loggedout')) {
+      return null;
+    }
+
+    // If we have more than one provider, we can't autologin because we
+    // don't know which one the user wants.
+    if (count($providers) != 1) {
+      return null;
+    }
+
+    $provider = head($providers);
+    if (!$provider->supportsAutoLogin()) {
+      return null;
+    }
+
+    $config = $provider->getProviderConfig();
+    if (!$config->getShouldAutoLogin()) {
+      return null;
+    }
+
+    $auto_uri = $provider->getAutoLoginURI($request);
+
+    return id(new AphrontRedirectResponse())
+      ->setIsExternal(true)
+      ->setURI($auto_uri);
+  }
+
 }
diff --git a/src/applications/auth/controller/config/PhabricatorAuthEditController.php b/src/applications/auth/controller/config/PhabricatorAuthEditController.php
index 049edfacef..ec2941a3fb 100644
--- a/src/applications/auth/controller/config/PhabricatorAuthEditController.php
+++ b/src/applications/auth/controller/config/PhabricatorAuthEditController.php
@@ -1,380 +1,380 @@
 <?php
 
 final class PhabricatorAuthEditController
   extends PhabricatorAuthProviderConfigController {
 
   public function handleRequest(AphrontRequest $request) {
     $this->requireApplicationCapability(
       AuthManageProvidersCapability::CAPABILITY);
     $viewer = $request->getUser();
     $provider_class = $request->getURIData('className');
     $config_id = $request->getURIData('id');
 
     if ($config_id) {
       $config = id(new PhabricatorAuthProviderConfigQuery())
         ->setViewer($viewer)
         ->requireCapabilities(
           array(
             PhabricatorPolicyCapability::CAN_VIEW,
             PhabricatorPolicyCapability::CAN_EDIT,
           ))
         ->withIDs(array($config_id))
         ->executeOne();
       if (!$config) {
         return new Aphront404Response();
       }
 
       $provider = $config->getProvider();
       if (!$provider) {
         return new Aphront404Response();
       }
 
       $is_new = false;
     } else {
       $provider = null;
 
       $providers = PhabricatorAuthProvider::getAllBaseProviders();
       foreach ($providers as $candidate_provider) {
         if (get_class($candidate_provider) === $provider_class) {
           $provider = $candidate_provider;
           break;
         }
       }
 
       if (!$provider) {
         return new Aphront404Response();
       }
 
       // TODO: When we have multi-auth providers, support them here.
 
       $configs = id(new PhabricatorAuthProviderConfigQuery())
         ->setViewer($viewer)
         ->withProviderClasses(array(get_class($provider)))
         ->execute();
 
       if ($configs) {
         $id = head($configs)->getID();
         $dialog = id(new AphrontDialogView())
           ->setUser($viewer)
           ->setMethod('GET')
           ->setSubmitURI($this->getApplicationURI('config/edit/'.$id.'/'))
           ->setTitle(pht('Provider Already Configured'))
           ->appendChild(
             pht(
               'This provider ("%s") already exists, and you can not add more '.
               'than one instance of it. You can edit the existing provider, '.
               'or you can choose a different provider.',
               $provider->getProviderName()))
           ->addCancelButton($this->getApplicationURI('config/new/'))
           ->addSubmitButton(pht('Edit Existing Provider'));
 
         return id(new AphrontDialogResponse())->setDialog($dialog);
       }
 
       $config = $provider->getDefaultProviderConfig();
       $provider->attachProviderConfig($config);
 
       $is_new = true;
     }
 
     $errors = array();
 
     $v_login = $config->getShouldAllowLogin();
     $v_registration = $config->getShouldAllowRegistration();
     $v_link = $config->getShouldAllowLink();
     $v_unlink = $config->getShouldAllowUnlink();
     $v_trust_email = $config->getShouldTrustEmails();
     $v_auto_login = $config->getShouldAutoLogin();
 
     if ($request->isFormPost()) {
 
       $properties = $provider->readFormValuesFromRequest($request);
       list($errors, $issues, $properties) = $provider->processEditForm(
         $request,
         $properties);
 
       $xactions = array();
 
       if (!$errors) {
         if ($is_new) {
           if (!strlen($config->getProviderType())) {
             $config->setProviderType($provider->getProviderType());
           }
           if (!strlen($config->getProviderDomain())) {
             $config->setProviderDomain($provider->getProviderDomain());
           }
         }
 
         $xactions[] = id(new PhabricatorAuthProviderConfigTransaction())
           ->setTransactionType(
             PhabricatorAuthProviderConfigTransaction::TYPE_LOGIN)
           ->setNewValue($request->getInt('allowLogin', 0));
 
         $xactions[] = id(new PhabricatorAuthProviderConfigTransaction())
           ->setTransactionType(
             PhabricatorAuthProviderConfigTransaction::TYPE_REGISTRATION)
           ->setNewValue($request->getInt('allowRegistration', 0));
 
         $xactions[] = id(new PhabricatorAuthProviderConfigTransaction())
           ->setTransactionType(
             PhabricatorAuthProviderConfigTransaction::TYPE_LINK)
           ->setNewValue($request->getInt('allowLink', 0));
 
         $xactions[] = id(new PhabricatorAuthProviderConfigTransaction())
           ->setTransactionType(
             PhabricatorAuthProviderConfigTransaction::TYPE_UNLINK)
           ->setNewValue($request->getInt('allowUnlink', 0));
 
         $xactions[] = id(new PhabricatorAuthProviderConfigTransaction())
           ->setTransactionType(
             PhabricatorAuthProviderConfigTransaction::TYPE_TRUST_EMAILS)
           ->setNewValue($request->getInt('trustEmails', 0));
 
-        if ($provider instanceof PhabricatorPhabricatorAuthProvider) {
+        if ($provider->supportsAutoLogin()) {
           $xactions[] = id(new PhabricatorAuthProviderConfigTransaction())
             ->setTransactionType(
               PhabricatorAuthProviderConfigTransaction::TYPE_AUTO_LOGIN)
             ->setNewValue($request->getInt('autoLogin', 0));
         }
 
         foreach ($properties as $key => $value) {
           $xactions[] = id(new PhabricatorAuthProviderConfigTransaction())
             ->setTransactionType(
               PhabricatorAuthProviderConfigTransaction::TYPE_PROPERTY)
             ->setMetadataValue('auth:property', $key)
             ->setNewValue($value);
         }
 
         if ($is_new) {
           $config->save();
         }
 
         $editor = id(new PhabricatorAuthProviderConfigEditor())
           ->setActor($viewer)
           ->setContentSourceFromRequest($request)
           ->setContinueOnNoEffect(true)
           ->applyTransactions($config, $xactions);
 
         if ($provider->hasSetupStep() && $is_new) {
           $id = $config->getID();
           $next_uri = $this->getApplicationURI('config/edit/'.$id.'/');
         } else {
           $next_uri = $this->getApplicationURI();
         }
 
         return id(new AphrontRedirectResponse())->setURI($next_uri);
       }
     } else {
       $properties = $provider->readFormValuesFromProvider();
       $issues = array();
     }
 
     if ($is_new) {
       if ($provider->hasSetupStep()) {
         $button = pht('Next Step');
       } else {
         $button = pht('Add Provider');
       }
       $crumb = pht('Add Provider');
       $title = pht('Add Auth Provider');
       $header_icon = 'fa-plus-square';
       $cancel_uri = $this->getApplicationURI('/config/new/');
     } else {
       $button = pht('Save');
       $crumb = pht('Edit Provider');
       $title = pht('Edit Auth Provider');
       $header_icon = 'fa-pencil';
       $cancel_uri = $this->getApplicationURI();
     }
 
     $header = id(new PHUIHeaderView())
       ->setHeader(pht('%s: %s', $title, $provider->getProviderName()))
       ->setHeaderIcon($header_icon);
 
     if ($config->getIsEnabled()) {
       $status_name = pht('Enabled');
       $status_color = 'green';
       $status_icon = 'fa-check';
       $header->setStatus($status_icon, $status_color, $status_name);
     } else if (!$is_new) {
       $status_name = pht('Disabled');
       $status_color = 'indigo';
       $status_icon = 'fa-ban';
       $header->setStatus($status_icon, $status_color, $status_name);
     }
 
     $config_name = 'auth.email-domains';
     $config_href = '/config/edit/'.$config_name.'/';
 
     $email_domains = PhabricatorEnv::getEnvConfig($config_name);
     if ($email_domains) {
       $registration_warning = pht(
         'Users will only be able to register with a verified email address '.
         'at one of the configured [[ %s | %s ]] domains: **%s**',
         $config_href,
         $config_name,
         implode(', ', $email_domains));
     } else {
       $registration_warning = pht(
         "NOTE: Any user who can browse to this install's login page will be ".
         "able to register a Phabricator account. To restrict who can register ".
         "an account, configure [[ %s | %s ]].",
         $config_href,
         $config_name);
     }
 
     $str_login = array(
       phutil_tag('strong', array(), pht('Allow Login:')),
       ' ',
       pht(
         'Allow users to log in using this provider. If you disable login, '.
         'users can still use account integrations for this provider.'),
     );
 
     $str_registration = array(
       phutil_tag('strong', array(), pht('Allow Registration:')),
       ' ',
       pht(
         'Allow users to register new Phabricator accounts using this '.
         'provider. If you disable registration, users can still use this '.
         'provider to log in to existing accounts, but will not be able to '.
         'create new accounts.'),
     );
 
     $str_link = hsprintf(
       '<strong>%s:</strong> %s',
       pht('Allow Linking Accounts'),
       pht(
         'Allow users to link account credentials for this provider to '.
         'existing Phabricator accounts. There is normally no reason to '.
         'disable this unless you are trying to move away from a provider '.
         'and want to stop users from creating new account links.'));
 
     $str_unlink = hsprintf(
       '<strong>%s:</strong> %s',
       pht('Allow Unlinking Accounts'),
       pht(
         'Allow users to unlink account credentials for this provider from '.
         'existing Phabricator accounts. If you disable this, Phabricator '.
         'accounts will be permanently bound to provider accounts.'));
 
     $str_trusted_email = hsprintf(
       '<strong>%s:</strong> %s',
       pht('Trust Email Addresses'),
       pht(
         'Phabricator will skip email verification for accounts registered '.
         'through this provider.'));
     $str_auto_login = hsprintf(
       '<strong>%s:</strong> %s',
       pht('Allow Auto Login'),
       pht(
         'Phabricator will automatically login with this provider if it is '.
         'the only available provider.'));
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->appendChild(
         id(new AphrontFormCheckboxControl())
           ->setLabel(pht('Allow'))
           ->addCheckbox(
             'allowLogin',
             1,
             $str_login,
             $v_login))
       ->appendChild(
         id(new AphrontFormCheckboxControl())
           ->addCheckbox(
             'allowRegistration',
             1,
             $str_registration,
             $v_registration))
       ->appendRemarkupInstructions($registration_warning)
       ->appendChild(
         id(new AphrontFormCheckboxControl())
           ->addCheckbox(
             'allowLink',
             1,
             $str_link,
             $v_link))
       ->appendChild(
         id(new AphrontFormCheckboxControl())
           ->addCheckbox(
             'allowUnlink',
             1,
             $str_unlink,
             $v_unlink));
 
     if ($provider->shouldAllowEmailTrustConfiguration()) {
       $form->appendChild(
         id(new AphrontFormCheckboxControl())
           ->addCheckbox(
             'trustEmails',
             1,
             $str_trusted_email,
             $v_trust_email));
     }
 
-    if ($provider instanceof PhabricatorPhabricatorAuthProvider) {
+    if ($provider->supportsAutoLogin()) {
       $form->appendChild(
         id(new AphrontFormCheckboxControl())
           ->addCheckbox(
             'autoLogin',
             1,
             $str_auto_login,
             $v_auto_login));
     }
 
     $provider->extendEditForm($request, $form, $properties, $issues);
 
     $form
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->addCancelButton($cancel_uri)
           ->setValue($button));
 
     $help = $provider->getConfigurationHelp();
     if ($help) {
       $form->appendChild(id(new PHUIFormDividerControl()));
       $form->appendRemarkupInstructions($help);
     }
 
     $footer = $provider->renderConfigurationFooter();
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb($crumb);
     $crumbs->setBorder(true);
 
     $timeline = null;
     if (!$is_new) {
       $timeline = $this->buildTransactionTimeline(
         $config,
         new PhabricatorAuthProviderConfigTransactionQuery());
       $xactions = $timeline->getTransactions();
       foreach ($xactions as $xaction) {
         $xaction->setProvider($provider);
       }
       $timeline->setShouldTerminate(true);
     }
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Provider'))
       ->setFormErrors($errors)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->setForm($form);
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setFooter(array(
         $form_box,
         $footer,
         $timeline,
       ));
 
     return $this->newPage()
       ->setTitle($title)
       ->setCrumbs($crumbs)
       ->appendChild($view);
 
   }
 
 }
diff --git a/src/applications/auth/provider/PhabricatorAuthProvider.php b/src/applications/auth/provider/PhabricatorAuthProvider.php
index 9484109943..c949764c9a 100644
--- a/src/applications/auth/provider/PhabricatorAuthProvider.php
+++ b/src/applications/auth/provider/PhabricatorAuthProvider.php
@@ -1,498 +1,506 @@
 <?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 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            Login 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('Login or Register');
     } else {
       $button_text = pht('Login');
     }
 
     $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();
     $uri->setQueryParams(array());
 
     $content = array($button);
 
     foreach ($params as $key => $value) {
       $content[] = phutil_tag(
         'input',
         array(
           'type' => 'hidden',
           'name' => $key,
           'value' => $value,
         ));
     }
 
     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 Exception(
         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));
     }
 
     return PhabricatorHash::digest($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();
+  }
+
 }
diff --git a/src/applications/auth/provider/PhabricatorOAuth2AuthProvider.php b/src/applications/auth/provider/PhabricatorOAuth2AuthProvider.php
index aff6367840..a3300126af 100644
--- a/src/applications/auth/provider/PhabricatorOAuth2AuthProvider.php
+++ b/src/applications/auth/provider/PhabricatorOAuth2AuthProvider.php
@@ -1,276 +1,289 @@
 <?php
 
 abstract class PhabricatorOAuth2AuthProvider
   extends PhabricatorOAuthAuthProvider {
 
   const PROPERTY_APP_ID = 'oauth:app:id';
   const PROPERTY_APP_SECRET = 'oauth:app:secret';
 
   protected function getIDKey() {
     return self::PROPERTY_APP_ID;
   }
 
   protected function getSecretKey() {
     return self::PROPERTY_APP_SECRET;
   }
 
 
   protected function configureAdapter(PhutilOAuthAuthAdapter $adapter) {
     $config = $this->getProviderConfig();
     $adapter->setClientID($config->getProperty(self::PROPERTY_APP_ID));
     $adapter->setClientSecret(
       new PhutilOpaqueEnvelope(
         $config->getProperty(self::PROPERTY_APP_SECRET)));
     $adapter->setRedirectURI(PhabricatorEnv::getURI($this->getLoginURI()));
     return $adapter;
   }
 
   protected function renderLoginForm(AphrontRequest $request, $mode) {
     $adapter = $this->getAdapter();
     $adapter->setState($this->getAuthCSRFCode($request));
 
     $scope = $request->getStr('scope');
     if ($scope) {
       $adapter->setScope($scope);
     }
 
     $attributes = array(
       'method' => 'GET',
       'uri' => $adapter->getAuthenticateURI(),
     );
 
     return $this->renderStandardLoginButton($request, $mode, $attributes);
   }
 
   public function processLoginRequest(
     PhabricatorAuthLoginController $controller) {
 
     $request = $controller->getRequest();
     $adapter = $this->getAdapter();
     $account = null;
     $response = null;
 
     $error = $request->getStr('error');
     if ($error) {
       $response = $controller->buildProviderErrorResponse(
         $this,
         pht(
           'The OAuth provider returned an error: %s',
           $error));
 
       return array($account, $response);
     }
 
     $this->verifyAuthCSRFCode($request, $request->getStr('state'));
 
     $code = $request->getStr('code');
     if (!strlen($code)) {
       $response = $controller->buildProviderErrorResponse(
         $this,
         pht(
           'The OAuth provider did not return a "code" parameter in its '.
           'response.'));
 
       return array($account, $response);
     }
 
     $adapter->setCode($code);
 
     // NOTE: As a side effect, this will cause the OAuth adapter to request
     // an access token.
 
     try {
       $account_id = $adapter->getAccountID();
     } catch (Exception $ex) {
       // TODO: Handle this in a more user-friendly way.
       throw $ex;
     }
 
     if (!strlen($account_id)) {
       $response = $controller->buildProviderErrorResponse(
         $this,
         pht(
           'The OAuth provider failed to retrieve an account ID.'));
 
       return array($account, $response);
     }
 
     return array($this->loadOrCreateAccount($account_id), $response);
   }
 
   public function processEditForm(
     AphrontRequest $request,
     array $values) {
 
     return $this->processOAuthEditForm(
       $request,
       $values,
       pht('Application ID is required.'),
       pht('Application secret is required.'));
   }
 
   public function extendEditForm(
     AphrontRequest $request,
     AphrontFormView $form,
     array $values,
     array $issues) {
 
     return $this->extendOAuthEditForm(
       $request,
       $form,
       $values,
       $issues,
       pht('OAuth App ID'),
       pht('OAuth App Secret'));
   }
 
   public function renderConfigPropertyTransactionTitle(
     PhabricatorAuthProviderConfigTransaction $xaction) {
 
     $author_phid = $xaction->getAuthorPHID();
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
     $key = $xaction->getMetadataValue(
       PhabricatorAuthProviderConfigTransaction::PROPERTY_KEY);
 
     switch ($key) {
       case self::PROPERTY_APP_ID:
         if (strlen($old)) {
           return pht(
             '%s updated the OAuth application ID for this provider from '.
             '"%s" to "%s".',
             $xaction->renderHandleLink($author_phid),
             $old,
             $new);
         } else {
           return pht(
             '%s set the OAuth application ID for this provider to '.
             '"%s".',
             $xaction->renderHandleLink($author_phid),
             $new);
         }
       case self::PROPERTY_APP_SECRET:
         if (strlen($old)) {
           return pht(
             '%s updated the OAuth application secret for this provider.',
             $xaction->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s set the OAuth application secret for this provider.',
             $xaction->renderHandleLink($author_phid));
         }
       case self::PROPERTY_NOTE:
         if (strlen($old)) {
           return pht(
             '%s updated the OAuth application notes for this provider.',
             $xaction->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s set the OAuth application notes for this provider.',
             $xaction->renderHandleLink($author_phid));
         }
 
     }
 
     return parent::renderConfigPropertyTransactionTitle($xaction);
   }
 
   protected function synchronizeOAuthAccount(
     PhabricatorExternalAccount $account) {
     $adapter = $this->getAdapter();
 
     $oauth_token = $adapter->getAccessToken();
     $account->setProperty('oauth.token.access', $oauth_token);
 
     if ($adapter->supportsTokenRefresh()) {
       $refresh_token = $adapter->getRefreshToken();
       $account->setProperty('oauth.token.refresh', $refresh_token);
     } else {
       $account->setProperty('oauth.token.refresh', null);
     }
 
     $expires = $adapter->getAccessTokenExpires();
     $account->setProperty('oauth.token.access.expires', $expires);
   }
 
   public function getOAuthAccessToken(
     PhabricatorExternalAccount $account,
     $force_refresh = false) {
 
     if ($account->getProviderKey() !== $this->getProviderKey()) {
       throw new Exception(pht('Account does not match provider!'));
     }
 
     if (!$force_refresh) {
       $access_expires = $account->getProperty('oauth.token.access.expires');
       $access_token = $account->getProperty('oauth.token.access');
 
       // Don't return a token with fewer than this many seconds remaining until
       // it expires.
       $shortest_token = 60;
       if ($access_token) {
         if ($access_expires === null ||
             $access_expires > (time() + $shortest_token)) {
           return $access_token;
         }
       }
     }
 
     $refresh_token = $account->getProperty('oauth.token.refresh');
     if ($refresh_token) {
       $adapter = $this->getAdapter();
       if ($adapter->supportsTokenRefresh()) {
         $adapter->refreshAccessToken($refresh_token);
 
         $this->synchronizeOAuthAccount($account);
         $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
           $account->save();
         unset($unguarded);
 
         return $account->getProperty('oauth.token.access');
       }
     }
 
     return null;
   }
 
   public function willRenderLinkedAccount(
     PhabricatorUser $viewer,
     PHUIObjectItemView $item,
     PhabricatorExternalAccount $account) {
 
     // Get a valid token, possibly refreshing it. If we're unable to refresh
     // it, render a message to that effect. The user may be able to repair the
     // link by manually reconnecting.
 
     $is_invalid = false;
     try {
       $oauth_token = $this->getOAuthAccessToken($account);
     } catch (Exception $ex) {
       $oauth_token = null;
       $is_invalid = true;
     }
 
     $item->addAttribute(pht('OAuth2 Account'));
 
     if ($oauth_token) {
       $oauth_expires = $account->getProperty('oauth.token.access.expires');
       if ($oauth_expires) {
         $item->addAttribute(
           pht(
             'Active OAuth Token (Expires: %s)',
             phabricator_datetime($oauth_expires, $viewer)));
       } else {
         $item->addAttribute(
           pht('Active OAuth Token'));
       }
     } else if ($is_invalid) {
       $item->addAttribute(pht('Invalid OAuth Access Token'));
     } else {
       $item->addAttribute(pht('No OAuth Access Token'));
     }
 
     parent::willRenderLinkedAccount($viewer, $item, $account);
   }
 
+  public function supportsAutoLogin() {
+    return true;
+  }
+
+  public function getAutoLoginURI(AphrontRequest $request) {
+    $csrf_code = $this->getAuthCSRFCode($request);
+
+    $adapter = $this->getAdapter();
+    $adapter->setState($csrf_code);
+
+    return $adapter->getAuthenticateURI();
+  }
+
 }