Actually end a ZLib stream with a Z_FINISH marker.

runtime/bin/filter.cc

 // Copyright (c) 2013, 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.
 
 #include "bin/dartutils.h"
 #include "bin/filter.h"
 #include "bin/io_buffer.h"
 
 #include "include/dart_api.h"
 
@@ skipping 117 matching lines @@
 void FUNCTION_NAME(Filter_Processed)(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle filter_obj = Dart_GetNativeArgument(args, 0);
   Filter* filter = GetFilter(filter_obj);
   Dart_Handle flush_obj = Dart_GetNativeArgument(args, 1);
   bool flush;
   if (Dart_IsError(Dart_BooleanValue(flush_obj, &flush))) {
     Dart_ThrowException(DartUtils::NewInternalError(
         "Failed to get 'flush' parameter"));
   }
+  Dart_Handle end_obj = Dart_GetNativeArgument(args, 2);
+  bool end;
+  if (Dart_IsError(Dart_BooleanValue(end_obj, &end))) {
+    Dart_ThrowException(DartUtils::NewInternalError(
+        "Failed to get 'end' parameter"));
+  }
   intptr_t read = filter->Processed(filter->processed_buffer(),
                                     filter->processed_buffer_size(),
-                                    flush);
+                                    flush,
+                                    end);
   if (read < 0) {
     // Error, end filter.
     EndFilter(filter_obj, filter);
     Dart_ThrowException(DartUtils::NewInternalError(
         "Filter error, bad data"));
   } else if (read == 0) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     uint8_t* io_buffer;
     Dart_Handle result = IOBuffer::Allocate(read, &io_buffer);
@@ skipping 58 matching lines @@
 
 bool ZLibDeflateFilter::Process(uint8_t* data, intptr_t length) {
   if (current_buffer_ != NULL) return false;
   stream_.avail_in = length;
   stream_.next_in = current_buffer_ = data;
   return true;
 }
 
 intptr_t ZLibDeflateFilter::Processed(uint8_t* buffer,
                                       intptr_t length,
-                                      bool flush) {
+                                      bool flush,
+                                      bool end) {
   stream_.avail_out = length;
   stream_.next_out = buffer;
-  switch (deflate(&stream_, flush ? Z_SYNC_FLUSH : Z_NO_FLUSH)) {
+  switch (deflate(&stream_,
+                  end ? Z_FINISH : flush ? Z_SYNC_FLUSH : Z_NO_FLUSH)) {
+    case Z_STREAM_END:
+    case Z_BUF_ERROR:
     case Z_OK: {
       intptr_t processed = length - stream_.avail_out;
       if (processed == 0) {
         delete[] current_buffer_;
         current_buffer_ = NULL;
         return 0;
       } else {
         // We processed data, should be called again.
         return processed;
       }
     }
 
-    case Z_STREAM_END:
-    case Z_BUF_ERROR:
-      // We processed all available input data.
-      delete[] current_buffer_;
-      current_buffer_ = NULL;
-      return 0;
-
     default:
     case Z_STREAM_ERROR:
       // An error occoured.
       delete[] current_buffer_;
       current_buffer_ = NULL;
       return -1;
   }
 }
 
 
@@ skipping 20 matching lines @@
 bool ZLibInflateFilter::Process(uint8_t* data, intptr_t length) {
   if (current_buffer_ != NULL) return false;
   stream_.avail_in = length;
   stream_.next_in = current_buffer_ = data;
   return true;
 }
 
 
 intptr_t ZLibInflateFilter::Processed(uint8_t* buffer,
                                       intptr_t length,
-                                      bool flush) {
+                                      bool flush,
+                                      bool end) {
   stream_.avail_out = length;
   stream_.next_out = buffer;
-  switch (inflate(&stream_, flush ? Z_SYNC_FLUSH : Z_NO_FLUSH)) {
+  switch (inflate(&stream_,
+                  end ? Z_FINISH : flush ? Z_SYNC_FLUSH : Z_NO_FLUSH)) {
     case Z_STREAM_END:
     case Z_BUF_ERROR:
     case Z_OK: {
       intptr_t processed = length - stream_.avail_out;
       if (processed == 0) {
         delete[] current_buffer_;
         current_buffer_ = NULL;
         return 0;
       } else {
         // We processed data, should be called again.
         return processed;
       }
     }
 
     default:
     case Z_MEM_ERROR:
     case Z_NEED_DICT:
     case Z_DATA_ERROR:
     case Z_STREAM_ERROR:
       // An error occoured.
       delete[] current_buffer_;
       current_buffer_ = NULL;
       return -1;
   }
 }
 
 }  // namespace bin
 }  // namespace dart