Handle timeouts in BrowserClient

.gitignore

@@ -1,15 +1,27 @@
-# Don’t commit the following directories created by pub.
+# See https://www.dartlang.org/tools/private-files.html
+
+# Files and directories created by pub
 .buildlog
+.packages
+.project
 .pub/
 build/
-packages
-.packages
+**/packages/
 
-# Or the files created by dart2js.
+# Files created by dart2js
+# (Most Dart developers will use pub build to compile Dart, use/modify these
+#  rules if you intend to use dart2js directly
+#  Convention is to use extension '.dart.js' for Dart compiled to Javascript to
+#  differentiate from explicit Javascript files)
 *.dart.js
-*.js_
+*.part.js
 *.js.deps
 *.js.map
+*.info.json
+
+# Directory created by dartdoc
+doc/api/
 
-# Include when developing application packages.
-pubspec.lock
+# Don't commit pubspec lock file
+# (Library packages only! Remove pattern if developing an application package)
+pubspec.lock

.travis.yml

@@ -0,0 +1,26 @@
+language: dart
+sudo: false
+
+dart:
+  - dev
+  - stable
+
+dart_task:
+  - test: --platform vm,firefox
+
+# Only run one instance of the formatter and the analyzer, rather than running
+# them against each Dart version.
+matrix:
+  include:
+  - dart: stable
+    dart_task: dartfmt
+  - dart: dev
+    dart_task: dartanalyzer
+
+# Only building master means that we don't run two builds for each pull request.
+branches:
+  only: [master]
+
+cache:
+  directories:
+    - $HOME/.pub-cache

CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.11.3+14
+
+* Remove single quote ("'" - ASCII 39) from boundary characters.
+  Causes issues with Google Cloud Storage.
+
 ## 0.11.3+13
 
 * remove boundary characters that package:http_parser cannot parse.

README.md

@@ -63,7 +63,7 @@ class UserAgentClient extends http.BaseClient {
 
   UserAgentClient(this.userAgent, this._inner);
 
-  Future<StreamedResponse> send(BaseRequest request) {
+  Future<http.StreamedResponse> send(http.BaseRequest request) {
     request.headers['user-agent'] = userAgent;
     return _inner.send(request);
   }

lib/browser_client.dart

@@ -6,25 +6,35 @@ import 'dart:async';
 import 'dart:html';
 import 'dart:typed_data';
 
-import 'package:stack_trace/stack_trace.dart';
+import 'package:async/async.dart';
 
 import 'src/base_client.dart';
-import 'src/base_request.dart';
-import 'src/byte_stream.dart';
 import 'src/exception.dart';
-import 'src/streamed_response.dart';
+import 'src/request.dart';
+import 'src/response.dart';
 
 // TODO(nweiz): Move this under src/, re-export from lib/http.dart, and use this
 // automatically from [new Client] once sdk#24581 is fixed.
 
 /// A `dart:html`-based HTTP client that runs in the browser and is backed by
 /// XMLHttpRequests.
 ///
-/// This client inherits some of the limitations of XMLHttpRequest. It ignores
-/// the [BaseRequest.contentLength], [BaseRequest.persistentConnection],
-/// [BaseRequest.followRedirects], and [BaseRequest.maxRedirects] fields. It is
-/// also unable to stream requests or responses; a request will only be sent and
-/// a response will only be returned once all the data is available.
+/// This client inherits some of the limitations of XMLHttpRequest. It is
+/// unable to directly set some headers, such as `content-length`. It is also
+/// unable to stream requests or responses; a request will only be sent and a
+/// response will only be returned once all the data is available.
+///
+/// You can control the underlying `dart:html` [HttpRequest] by adding values to
+/// [Request.context]:
+///
+/// * `"http.html.with_credentials"` is a boolean that defaults to `false`. If
+///   it's `true`, cross-site requests will include credentials such as cookies
+///   or authorization headers. See also [HttpRequest.withCredentials].
+///
+/// * `"http.html.timeout"` is an integer that specifies the time in
+///   milliseconds before a request is automatically terminated. It defaults to
+///   `0` which prevents a request from timing out. See also
+///   [HttpRequest.timeout].
 class BrowserClient extends BaseClient {
   /// The currently active XHRs.
   ///
@@ -34,23 +44,20 @@ class BrowserClient extends BaseClient {
   /// Creates a new HTTP client.
   BrowserClient();
 
-  /// Whether to send credentials such as cookies or authorization headers for
-  /// cross-site requests.
-  ///
-  /// Defaults to `false`.
-  bool withCredentials = false;
-
-  /// Sends an HTTP request and asynchronously returns the response.
-  Future<StreamedResponse> send(BaseRequest request) async {
-    var bytes = await request.finalize().toBytes();
+  Future<Response> send(Request request) async {
+    var bytes = await collectBytes(request.read());
     var xhr = new HttpRequest();
     _xhrs.add(xhr);
     _openHttpRequest(xhr, request.method, request.url.toString(), asynch: true);
-    xhr.responseType = 'blob';
-    xhr.withCredentials = withCredentials;
+
+    xhr
+      ..responseType = 'blob'
+      ..withCredentials = request.context['http.html.with_credentials'] ?? false
+      ..timeout = request.context['http.html.timeout'] ?? 0;
+
     request.headers.forEach(xhr.setRequestHeader);
 
-    var completer = new Completer<StreamedResponse>();
+    var completer = new Completer<Response>();
     xhr.onLoad.first.then((_) {
       // TODO(nweiz): Set the response type to "arraybuffer" when issue 18542
       // is fixed.
@@ -59,30 +66,34 @@ class BrowserClient extends BaseClient {
 
       reader.onLoad.first.then((_) {
         var body = reader.result as Uint8List;
-        completer.complete(new StreamedResponse(
-            new ByteStream.fromBytes(body),
-            xhr.status,
-            contentLength: body.length,
-            request: request,
-            headers: xhr.responseHeaders,
-            reasonPhrase: xhr.statusText));
+        completer.complete(new Response(xhr.responseUrl, xhr.status,
+            reasonPhrase: xhr.statusText,
+            body: new Stream.fromIterable([body]),
+            headers: xhr.responseHeaders));
       });
 
       reader.onError.first.then((error) {
         completer.completeError(
             new ClientException(error.toString(), request.url),
-            new Chain.current());
+            StackTrace.current);
       });
 
       reader.readAsArrayBuffer(blob);
     });
 
+    xhr.onTimeout.first.then((error) {
+      completer.completeError(
+          new ClientException(
+              'XMLHttpRequest timeout after ${xhr.timeout}ms.', request.url),
+          StackTrace.current);
+    });
+
     xhr.onError.first.then((_) {
       // Unfortunately, the underlying XMLHttpRequest API doesn't expose any
       // specific information about the error itself.
       completer.completeError(
           new ClientException("XMLHttpRequest error.", request.url),
-          new Chain.current());
+          StackTrace.current);
     });
 
     xhr.send(bytes);
@@ -100,9 +111,6 @@ class BrowserClient extends BaseClient {
     request.open(method, url, async: asynch, user: user, password: password);
   }
 
-  /// Closes the client.
-  ///
-  /// This terminates all active requests.
   void close() {
     for (var xhr in _xhrs) {
       xhr.abort();

lib/http.dart

@@ -11,18 +11,15 @@ import 'src/client.dart';
 import 'src/response.dart';
 
 export 'src/base_client.dart';
-export 'src/base_request.dart';
-export 'src/base_response.dart';
-export 'src/byte_stream.dart';
 export 'src/client.dart';
 export 'src/exception.dart';
+export 'src/handler.dart';
 export 'src/io_client.dart';
+export 'src/middleware.dart';
 export 'src/multipart_file.dart';
-export 'src/multipart_request.dart';
+export 'src/pipeline.dart';
 export 'src/request.dart';
 export 'src/response.dart';
-export 'src/streamed_request.dart';
-export 'src/streamed_response.dart';
 
 /// Sends an HTTP HEAD request with the given headers to the given URL, which
 /// can be a [Uri] or a [String].
@@ -31,9 +28,11 @@ export 'src/streamed_response.dart';
 /// the request is complete. If you're planning on making multiple requests to
 /// the same server, you should use a single [Client] for all of those requests.
 ///
-/// For more fine-grained control over the request, use [Request] instead.
+/// This automatically initializes a new [Client] and closes that client once
+/// the request is complete. If you're planning on making multiple requests to
+/// the same server, you should use a single [Client] for all of those requests.
 Future<Response> head(url, {Map<String, String> headers}) =>
-  _withClient((client) => client.head(url, headers: headers));
+    _withClient((client) => client.head(url, headers: headers));
 
 /// Sends an HTTP GET request with the given headers to the given URL, which can
 /// be a [Uri] or a [String].
@@ -42,9 +41,11 @@ Future<Response> head(url, {Map<String, String> headers}) =>
 /// the request is complete. If you're planning on making multiple requests to
 /// the same server, you should use a single [Client] for all of those requests.
 ///
-/// For more fine-grained control over the request, use [Request] instead.
+/// This automatically initializes a new [Client] and closes that client once
+/// the request is complete. If you're planning on making multiple requests to
+/// the same server, you should use a single [Client] for all of those requests.
 Future<Response> get(url, {Map<String, String> headers}) =>
-  _withClient((client) => client.get(url, headers: headers));
+    _withClient((client) => client.get(url, headers: headers));
 
 /// Sends an HTTP POST request with the given headers and body to the given URL,
 /// which can be a [Uri] or a [String].
@@ -63,12 +64,13 @@ Future<Response> get(url, {Map<String, String> headers}) =>
 ///
 /// [encoding] defaults to [UTF8].
 ///
-/// For more fine-grained control over the request, use [Request] or
-/// [StreamedRequest] instead.
-Future<Response> post(url, {Map<String, String> headers, body,
-    Encoding encoding}) =>
-  _withClient((client) => client.post(url,
-      headers: headers, body: body, encoding: encoding));
+/// This automatically initializes a new [Client] and closes that client once
+/// the request is complete. If you're planning on making multiple requests to
+/// the same server, you should use a single [Client] for all of those requests.
+Future<Response> post(url, body,
+        {Map<String, String> headers, Encoding encoding}) =>
+    _withClient((client) =>
+        client.post(url, body, headers: headers, encoding: encoding));
 
 /// Sends an HTTP PUT request with the given headers and body to the given URL,
 /// which can be a [Uri] or a [String].
@@ -87,12 +89,13 @@ Future<Response> post(url, {Map<String, String> headers, body,
 ///
 /// [encoding] defaults to [UTF8].
 ///
-/// For more fine-grained control over the request, use [Request] or
-/// [StreamedRequest] instead.
-Future<Response> put(url, {Map<String, String> headers, body,
-    Encoding encoding}) =>
-  _withClient((client) => client.put(url,
-      headers: headers, body: body, encoding: encoding));
+/// This automatically initializes a new [Client] and closes that client once
+/// the request is complete. If you're planning on making multiple requests to
+/// the same server, you should use a single [Client] for all of those requests.
+Future<Response> put(url, body,
+        {Map<String, String> headers, Encoding encoding}) =>
+    _withClient((client) =>
+        client.put(url, body, headers: headers, encoding: encoding));
 
 /// Sends an HTTP PATCH request with the given headers and body to the given
 /// URL, which can be a [Uri] or a [String].
@@ -111,23 +114,22 @@ Future<Response> put(url, {Map<String, String> headers, body,
 ///
 /// [encoding] defaults to [UTF8].
 ///
-/// For more fine-grained control over the request, use [Request] or
-/// [StreamedRequest] instead.
-Future<Response> patch(url, {Map<String, String> headers, body,
-    Encoding encoding}) =>
-  _withClient((client) => client.patch(url,
-      headers: headers, body: body, encoding: encoding));
+/// This automatically initializes a new [Client] and closes that client once
+/// the request is complete. If you're planning on making multiple requests to
+/// the same server, you should use a single [Client] for all of those requests.
+Future<Response> patch(url, body,
+        {Map<String, String> headers, Encoding encoding}) =>
+    _withClient((client) =>
+        client.patch(url, body, headers: headers, encoding: encoding));
 
 /// Sends an HTTP DELETE request with the given headers to the given URL, which
 /// can be a [Uri] or a [String].
 ///
 /// This automatically initializes a new [Client] and closes that client once
 /// the request is complete. If you're planning on making multiple requests to
 /// the same server, you should use a single [Client] for all of those requests.
-///
-/// For more fine-grained control over the request, use [Request] instead.
 Future<Response> delete(url, {Map<String, String> headers}) =>
-  _withClient((client) => client.delete(url, headers: headers));
+    _withClient((client) => client.delete(url, headers: headers));
 
 /// Sends an HTTP GET request with the given headers to the given URL, which can
 /// be a [Uri] or a [String], and returns a Future that completes to the body of
@@ -139,11 +141,8 @@ Future<Response> delete(url, {Map<String, String> headers}) =>
 /// This automatically initializes a new [Client] and closes that client once
 /// the request is complete. If you're planning on making multiple requests to
 /// the same server, you should use a single [Client] for all of those requests.
-///
-/// For more fine-grained control over the request and response, use [Request]
-/// instead.
 Future<String> read(url, {Map<String, String> headers}) =>
-  _withClient((client) => client.read(url, headers: headers));
+    _withClient((client) => client.read(url, headers: headers));
 
 /// Sends an HTTP GET request with the given headers to the given URL, which can
 /// be a [Uri] or a [String], and returns a Future that completes to the body of
@@ -155,11 +154,8 @@ Future<String> read(url, {Map<String, String> headers}) =>
 /// This automatically initializes a new [Client] and closes that client once
 /// the request is complete. If you're planning on making multiple requests to
 /// the same server, you should use a single [Client] for all of those requests.
-///
-/// For more fine-grained control over the request and response, use [Request]
-/// instead.
 Future<Uint8List> readBytes(url, {Map<String, String> headers}) =>
-  _withClient((client) => client.readBytes(url, headers: headers));
+    _withClient((client) => client.readBytes(url, headers: headers));
 
 Future<T> _withClient<T>(Future<T> fn(Client client)) async {
   var client = new Client();