Async-ify.

lib/src/authorization_code_grant.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library authorization_code_grant;
 
 import 'dart:async';
 
 import 'package:http/http.dart' as http;
 
@@ skipping 78 matching lines @@
 
   /// The current state of the grant object. One of [_INITIAL_STATE],
   /// [_AWAITING_RESPONSE_STATE], or [_FINISHED_STATE].
   int _state = _INITIAL_STATE;
 
   /// Creates a new grant.
   ///
   /// [httpClient] is used for all HTTP requests made by this grant, as well as
   /// those of the [Client] is constructs.
   AuthorizationCodeGrant(
-      this.identifier,
-      this.secret,
-      this.authorizationEndpoint,
-      this.tokenEndpoint,
-      {http.Client httpClient})
-    : _httpClient = httpClient == null ? new http.Client() : httpClient;
+          this.identifier,
+          this.secret,
+          this.authorizationEndpoint,
+          this.tokenEndpoint,
+          {http.Client httpClient})
+      : _httpClient = httpClient == null ? new http.Client() : httpClient;
 
   /// Returns the URL to which the resource owner should be redirected to
   /// authorize this client. The resource owner will then be redirected to
   /// [redirect], which should point to a server controlled by the client. This
   /// redirect will have additional query parameters that should be passed to
   /// [handleAuthorizationResponse].
   ///
   /// The specific permissions being requested from the authorization server may
   /// be specified via [scopes]. The scope strings are specific to the
   /// authorization server and may be found in its documentation. Note that you
@@ skipping 35 matching lines @@
   /// It is a [StateError] to call this more than once, to call it before
   /// [getAuthorizationUrl] is called, or to call it after
   /// [handleAuthorizationCode] is called.
   ///
   /// Throws [FormatError] if [parameters] is invalid according to the OAuth2
   /// spec or if the authorization server otherwise provides invalid responses.
   /// If `state` was passed to [getAuthorizationUrl], this will throw a
   /// [FormatError] if the `state` parameter doesn't match the original value.
   ///
   /// Throws [AuthorizationException] if the authorization fails.
-  Future<Client> handleAuthorizationResponse(Map<String, String> parameters) {
-    return async.then((_) {
-      if (_state == _INITIAL_STATE) {
-        throw new StateError(
-            'The authorization URL has not yet been generated.');
-      } else if (_state == _FINISHED_STATE) {
-        throw new StateError(
-            'The authorization code has already been received.');
+  Future<Client> handleAuthorizationResponse(Map<String, String> parameters)
+      async {
+    if (_state == _INITIAL_STATE) {
+      throw new StateError(
+          'The authorization URL has not yet been generated.');
+    } else if (_state == _FINISHED_STATE) {

[Bob Nystrom, 2015/08/24 21:36:51]

Nit, but the "else" isn't useful.

[nweiz, 2015/08/24 23:58:34]

I like using "else"s when they make the code terser and draw attention to an
intentional repetition of actions, like they do here.

+      throw new StateError(
+          'The authorization code has already been received.');
+    }
+    _state = _FINISHED_STATE;
+
+    if (_stateString != null) {
+      if (!parameters.containsKey('state')) {
+        throw new FormatException('Invalid OAuth response for '
+            '"$authorizationEndpoint": parameter "state" expected to be '
+            '"$_stateString", was missing.');
+      } else if (parameters['state'] != _stateString) {
+        throw new FormatException('Invalid OAuth response for '
+            '"$authorizationEndpoint": parameter "state" expected to be '
+            '"$_stateString", was "${parameters['state']}".');
       }
-      _state = _FINISHED_STATE;
+    }
 
-      if (_stateString != null) {
-        if (!parameters.containsKey('state')) {
-          throw new FormatException('Invalid OAuth response for '
-              '"$authorizationEndpoint": parameter "state" expected to be '
-              '"$_stateString", was missing.');
-        } else if (parameters['state'] != _stateString) {
-          throw new FormatException('Invalid OAuth response for '
-              '"$authorizationEndpoint": parameter "state" expected to be '
-              '"$_stateString", was "${parameters['state']}".');
-        }
-      }
+    if (parameters.containsKey('error')) {
+      var description = parameters['error_description'];
+      var uriString = parameters['error_uri'];
+      var uri = uriString == null ? null : Uri.parse(uriString);
+      throw new AuthorizationException(parameters['error'], description, uri);
+    } else if (!parameters.containsKey('code')) {
+      throw new FormatException('Invalid OAuth response for '
+          '"$authorizationEndpoint": did not contain required parameter '
+          '"code".');
+    }
 
-      if (parameters.containsKey('error')) {
-        var description = parameters['error_description'];
-        var uriString = parameters['error_uri'];
-        var uri = uriString == null ? null : Uri.parse(uriString);
-        throw new AuthorizationException(parameters['error'], description, uri);
-      } else if (!parameters.containsKey('code')) {
-        throw new FormatException('Invalid OAuth response for '
-            '"$authorizationEndpoint": did not contain required parameter '
-            '"code".');
-      }
-
-      return _handleAuthorizationCode(parameters['code']);
-    });
+    return await _handleAuthorizationCode(parameters['code']);
   }
 
   /// Processes an authorization code directly. Usually
   /// [handleAuthorizationResponse] is preferable to this method, since it
   /// validates all of the query parameters. However, some authorization servers
   /// allow the user to copy and paste an authorization code into a command-line
   /// application, in which case this method must be used.
   ///
   /// It is a [StateError] to call this more than once, to call it before
   /// [getAuthorizationUrl] is called, or to call it after
   /// [handleAuthorizationCode] is called.
   ///
   /// Throws [FormatError] if the authorization server provides invalid
   /// responses while retrieving credentials.
   ///
   /// Throws [AuthorizationException] if the authorization fails.
-  Future<Client> handleAuthorizationCode(String authorizationCode) {
-    return async.then((_) {
-      if (_state == _INITIAL_STATE) {
-        throw new StateError(
-            'The authorization URL has not yet been generated.');
-      } else if (_state == _FINISHED_STATE) {
-        throw new StateError(
-            'The authorization code has already been received.');
-      }
-      _state = _FINISHED_STATE;
+  Future<Client> handleAuthorizationCode(String authorizationCode) async {
+    if (_state == _INITIAL_STATE) {
+      throw new StateError(
+          'The authorization URL has not yet been generated.');
+    } else if (_state == _FINISHED_STATE) {
+      throw new StateError(
+          'The authorization code has already been received.');
+    }
+    _state = _FINISHED_STATE;
 
-      return _handleAuthorizationCode(authorizationCode);
-    });
+    return await _handleAuthorizationCode(authorizationCode);
   }
 
   /// This works just like [handleAuthorizationCode], except it doesn't validate
   /// the state beforehand.
-  Future<Client> _handleAuthorizationCode(String authorizationCode) {
+  Future<Client> _handleAuthorizationCode(String authorizationCode) async {
     var startTime = new DateTime.now();
-    return _httpClient.post(this.tokenEndpoint, body: {
+    var response = await _httpClient.post(this.tokenEndpoint, body: {
       "grant_type": "authorization_code",
       "code": authorizationCode,
       "redirect_uri": this._redirectEndpoint.toString(),
       // TODO(nweiz): the spec recommends that HTTP basic auth be used in
       // preference to form parameters, but Google doesn't support that. Should
       // it be configurable?
       "client_id": this.identifier,
       "client_secret": this.secret
-    }).then((response) {
-      var credentials = handleAccessTokenResponse(
-          response, tokenEndpoint, startTime, _scopes);
-      return new Client(
-          this.identifier, this.secret, credentials, httpClient: _httpClient);
     });
+
+    var credentials = handleAccessTokenResponse(
+        response, tokenEndpoint, startTime, _scopes);
+    return new Client(
+        this.identifier, this.secret, credentials, httpClient: _httpClient);
   }
 
   /// Closes the grant and frees its resources.
   ///
   /// This will close the underlying HTTP client, which is shared by the
   /// [Client] created by this grant, so it's not safe to close the grant and
   /// continue using the client.
   void close() {
     if (_httpClient != null) _httpClient.close();
     _httpClient = null;
   }
 }