Refactor http.Client and http.BaseClient to allow http.Client in type annotations.

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 '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.BaseClient], while sending OAuth2 authorization credentials along with
-/// each request.
+/// 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
@@ skipping 25 matching lines @@
   /// certainty that a client is who it claims to be.
   final String secret;
 
   /// The credentials this client uses to prove to the resource server that it's
   /// authorized. This may change from request to request as the credentials
   /// expire and the client refreshes them automatically.
   Credentials get credentials => _credentials;
   Credentials _credentials;
 
   /// The underlying HTTP client.
-  http.BaseClient _httpClient;
+  http.Client _httpClient;
 
   /// Creates a new client from a pre-existing set of credentials. When
   /// authorizing a client for the first time, you should use
   /// [AuthorizationCodeGrant] instead of constructing a [Client] directly.
   ///
   /// [httpClient] is the underlying client that this forwards requests to after
   /// adding authorization credentials to them.
   Client(
       this.identifier,
       this.secret,
       this._credentials,
-      {http.BaseClient httpClient})
+      {http.Client httpClient})
     : _httpClient = httpClient == null ? new http.Client() : httpClient;
 
   /// Sends an HTTP request with OAuth2 authorization credentials attached. This
   /// 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();
@@ skipping 28 matching lines @@
       return this;
     });
   }
 
   /// Closes this client and its underlying HTTP client.
   void close() {
     if (_httpClient != null) _httpClient.close();
     _httpClient = null;
   }
 }