Api roll 1: 2014-09-23

generated/googleapis/lib/src/common_internal.dart

 library googleapis.common_internal;
 
 import "dart:async";
 import "dart:convert";
 import "dart:collection" as collection;
 
 import "package:crypto/crypto.dart" as crypto;
 import "../common/common.dart" as common_external;
 import "package:http/http.dart" as http;
 
 const String USER_AGENT_STRING =
-    'google-api-dart-client googleapis/0.1.1';
+    'google-api-dart-client googleapis/0.2.0';
 
 const CONTENT_TYPE_JSON_UTF8 = 'application/json; charset=utf-8';
 
 /**
  * Base class for all API clients, offering generic methods for
  * HTTP Requests to the API
  */
 class ApiRequester {
   final http.Client _httpClient;
   final String _rootUrl;
@@ skipping 122 matching lines @@
     if (downloadAsMedia) {
       queryParams['alt'] = const ['media'];
     } else if (downloadOptions != null) {
       queryParams['alt'] = const ['json'];
     }
 
     var path;
     if (requestUrl.startsWith('/')) {
       path ="$_rootUrl${requestUrl.substring(1)}";
     } else {
-      path ="$_rootUrl${_basePath.substring(1)}$requestUrl";
+      path ="$_rootUrl${_basePath}$requestUrl";
     }
 
     bool containsQueryParameter = path.contains('?');
     addQueryParameter(String name, String value) {
       name = Escaper.escapeQueryComponent(name);
       value = Escaper.escapeQueryComponent(value);
       if (containsQueryParameter) {
         path = '$path&$name=$value';
       } else {
         path = '$path?$name=$value';
@@ skipping 257 matching lines @@
 
       var completer = new Completer<http.StreamedResponse>();
       bool completed = false;
 
       var chunkStack = new ChunkStack(_options.chunkSize);
       subscription = _uploadMedia.stream.listen((List<int> bytes) {
         chunkStack.addBytes(bytes);
 
         // Upload all but the last chunk.
         // The final send will be done in the [onDone] handler.
-        if (chunkStack.length > 1) {
+        bool hasPartialChunk = chunkStack.hasPartialChunk;
+        if (chunkStack.length > 1 ||
+            (chunkStack.length == 1 && hasPartialChunk)) {
           // Pause the input stream.
           subscription.pause();
 
           // Upload all chunks except the last one.
-          var fullChunks = chunkStack.removeSublist(0, chunkStack.length - 1);
+          var fullChunks;
+          if (hasPartialChunk) {
+            fullChunks = chunkStack.removeSublist(0, chunkStack.length);
+          } else {
+            fullChunks = chunkStack.removeSublist(0, chunkStack.length - 1);
+          }
           Future.forEach(fullChunks,
                          (c) => _uploadChunkDrained(uploadUri, c)).then((_) {
             // All chunks uploaded, we can continue consuming data.
             subscription.resume();
           }).catchError((error, stack) {
             subscription.cancel();
             completed = true;
             completer.completeError(error, stack);
           });
         }
       }, onError: (error, stack) {
         subscription.cancel();
         if (!completed) {
           completed = true;
           completer.completeError(error, stack);
         }
       }, onDone: () {
         if (!completed) {
           chunkStack.finalize();
 
           var lastChunk;
-          if (chunkStack.totalByteLength > 0) {
-            assert(chunkStack.length == 1);
+          if (chunkStack.length == 1) {
             lastChunk = chunkStack.removeSublist(0, chunkStack.length).first;
           } else {
-            lastChunk = new ResumableChunk([], 0, 0);
+            completer.completeError(new StateError(
+                'Resumable uploads need to result in at least one non-empty '
+                'chunk at the end.'));
+            return;
           }
           var end = lastChunk.endOfChunk;
 
           // Validate that we have the correct number of bytes if length was
           // specified.
           if (_uploadMedia.length != null) {
             if (end < _uploadMedia.length) {
               completer.completeError(new common_external.ApiRequestError(
                   'Received less bytes than indicated by [Media.length].'));
               return;
@@ skipping 172 matching lines @@
 /**
  * Represents a stack of [ResumableChunk]s.
  */
 class ChunkStack {
   final int _chunkSize;
   final List<ResumableChunk> _chunkStack = [];
 
   // Currently accumulated data.
   List<List<int>> _byteArrays = [];
   int _length = 0;
-  int _totalLength = 0;
   int _offset = 0;
 
   bool _finalized = false;
 
   ChunkStack(this._chunkSize);
 
+  /**
+   * Whether data for a not-yet-finished [ResumableChunk] is present. A call to
+   * `finalize` will create a [ResumableChunk] of this data.
+   */
+  bool get hasPartialChunk => _length > 0;
+
+  /**
+   * The number of chunks in this [ChunkStack].
+   */
   int get length => _chunkStack.length;
 
-  int get totalByteLength => _offset;
+  /**
+   * The total number of bytes which have been converted to [ResumableChunk]s.
+   * Can only be called once this [ChunkStack] has been finalized.
+   */
+  int get totalByteLength {
+    if (!_finalized) {
+      throw new StateError('ChunkStack has not been finalized yet.');
+    }
+
+    return _offset;
+  }
 
   /**
    * Returns the chunks [from] ... [to] and deletes it from the stack.
    */
   List<ResumableChunk> removeSublist(int from, int to) {
     var sublist = _chunkStack.sublist(from, to);
     _chunkStack.removeRange(from, to);
     return sublist;
   }
 
@@ skipping 208 matching lines @@
     assert(key != null);
     if(convert == null) {
       result[key] = value;
     } else {
       result[key] = convert(value);
     }
   });
   return result;
 }