Make the oauth2 lib handle OAuth2 401 errors.

pkg/oauth2/lib/src/client.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 client;
 
 import 'dart:uri';
 
 import '../../../http/lib/http.dart' as http;
 
+import 'authorization_exception.dart';
 import 'credentials.dart';
 import 'expiration_exception.dart';
 import 'utils.dart';
 
 // TODO(nweiz): Add an onCredentialsRefreshed event once we have some event
 // infrastructure.
 /// An OAuth2 client. This acts as a drop-in replacement for an [http.Client],
 /// while sending OAuth2 authorization credentials along with each request.
 ///
 /// The client also automatically refreshes its credentials if possible. When it
 /// makes a request, if its credentials are expired, it will first refresh them.
 /// This means that any request may throw an [AuthorizationException] if the
 /// refresh is not authorized for some reason, a [FormatException] if the
 /// authorization server provides ill-formatted responses, or an
 /// [ExpirationException] if the credentials are expired and can't be refreshed.
 ///
-/// Currently this client doesn't attempt to identify errors from the resource
-/// server that are caused by authentication failure. However, it may throw
-/// [AuthorizationException]s for such errors in the future.
+/// The client will also throw an [AuthorizationException] if the resource
+/// server returns a 401 response with a WWW-Authenticate header indicating that
+/// the current credentials are invalid.
 ///
 /// If you already have a set of [Credentials], you can construct a [Client]
 /// directly. However, in order to first obtain the credentials, you must
 /// authorize. At the time of writing, the only authorization method this
 /// library supports is [AuthorizationCodeGrant].
 class Client extends http.BaseClient {
   /// The client identifier for this client. The authorization server will issue
   /// each client a separate client identifier and secret, which allows the
   /// server to tell which client is accessing it. Some servers may also have an
   /// anonymous identifier/secret pair that any client may use.
@@ skipping 40 matching lines @@
   /// will also automatically refresh this client's [Credentials] before sending
   /// the request if necessary.
   Future<http.StreamedResponse> send(http.BaseRequest request) {
     return async.chain((_) {
       if (!credentials.isExpired) return new Future.immediate(null);
       if (!credentials.canRefresh) throw new ExpirationException(credentials);
       return refreshCredentials();
     }).chain((_) {
       request.headers['authorization'] = "Bearer ${credentials.accessToken}";
       return _httpClient.send(request);
+    }).transform((response) {
+      if (response.statusCode != 401 ||
+          !response.headers.containsKey('www-authenticate')) {
+        return response;
+      }
+
+      var authenticate;
+      try {
+        authenticate = parseAuthenticateHeader(
+            response.headers['www-authenticate']);
+      } on FormatException catch (e) {
+        return response;
+      }
+
+      if (authenticate.first != 'bearer') return response;
+
+      var params = authenticate.last;
+      if (!params.containsKey('error')) return response;
+
+      throw new AuthorizationException(
+          params['error'], params['error_description'], params['error_uri']);
     });
-    // TODO(nweiz): parse 401 errors that are caused by OAuth errors here.
   }
 
   /// Explicitly refreshes this client's credentials. Returns this client.
   ///
   /// This will throw a [StateError] if the [Credentials] can't be refreshed, an
   /// [AuthorizationException] if refreshing the credentials fails, or a
   /// [FormatError] if the authorization server returns invalid responses.
   ///
   /// You may request different scopes than the default by passing in
   /// [newScopes]. These must be a subset of the scopes in the
@@ skipping 13 matching lines @@
       return this;
     });
   }
 
   /// Closes this client and its underlying HTTP client.
   void close() {
     if (_httpClient != null) _httpClient.close();
     _httpClient = null;
   }
 }