Use actual length of dictionary, and not size of a pointer, in zlib.

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 54 matching lines @@
 
   return dictionary;
 }
 
 void FUNCTION_NAME(Filter_CreateZLibInflate)(Dart_NativeArguments args) {
   Dart_Handle filter_obj = Dart_GetNativeArgument(args, 0);
   Dart_Handle window_bits_obj = Dart_GetNativeArgument(args, 1);
   int64_t window_bits = DartUtils::GetIntegerValue(window_bits_obj);
   Dart_Handle dict_obj = Dart_GetNativeArgument(args, 2);
   uint8_t* dictionary = NULL;
+  intptr_t dictionary_length = 0;
   if (!Dart_IsNull(dict_obj)) {
     dictionary = copyDictionary(dict_obj);
+    if (dictionary != NULL) {
+      dictionary_length = 0;
+      Dart_ListLength(dict_obj, &dictionary_length);
+    }
   }
   Dart_Handle raw_obj = Dart_GetNativeArgument(args, 3);
   bool raw;
   if (Dart_IsError(Dart_BooleanValue(raw_obj, &raw))) {
     Dart_ThrowException(DartUtils::NewInternalError(
         "Failed to get 'raw' parameter"));
   }
   Filter* filter = new ZLibInflateFilter(static_cast<int32_t>(window_bits),
-                                         dictionary, raw);
+                                         dictionary, dictionary_length, raw);
   if (!filter->Init()) {
     delete filter;
     Dart_ThrowException(DartUtils::NewInternalError(
         "Failed to create ZLibInflateFilter"));
   }
   Dart_Handle result = Filter::SetFilterPointerNativeField(filter_obj, filter);
   if (Dart_IsError(result)) {
     delete filter;
     Dart_PropagateError(result);
   }
 }
 
 void FUNCTION_NAME(Filter_CreateZLibDeflate)(Dart_NativeArguments args) {
   Dart_Handle filter_obj = Dart_GetNativeArgument(args, 0);
   Dart_Handle gzip_obj = Dart_GetNativeArgument(args, 1);
   bool gzip = DartUtils::GetBooleanValue(gzip_obj);
   Dart_Handle level_obj = Dart_GetNativeArgument(args, 2);
   int64_t level = DartUtils::GetInt64ValueCheckRange(level_obj, kMinInt32,
       kMaxInt32);
   Dart_Handle window_bits_obj = Dart_GetNativeArgument(args, 3);
   int64_t window_bits = DartUtils::GetIntegerValue(window_bits_obj);
   Dart_Handle mLevel_obj = Dart_GetNativeArgument(args, 4);
   int64_t mem_level = DartUtils::GetIntegerValue(mLevel_obj);
   Dart_Handle strategy_obj = Dart_GetNativeArgument(args, 5);
   int64_t strategy = DartUtils::GetIntegerValue(strategy_obj);
   Dart_Handle dict_obj = Dart_GetNativeArgument(args, 6);
   uint8_t* dictionary = NULL;
+  intptr_t dictionary_length = 0;
   if (!Dart_IsNull(dict_obj)) {
     dictionary = copyDictionary(dict_obj);
+    if (dictionary != NULL) {
+      dictionary_length = 0;
+      Dart_ListLength(dict_obj, &dictionary_length);
+    }
   }
   Dart_Handle raw_obj = Dart_GetNativeArgument(args, 7);
   bool raw = DartUtils::GetBooleanValue(raw_obj);
   Filter* filter = new ZLibDeflateFilter(gzip, static_cast<int32_t>(level),
                                          static_cast<int32_t>(window_bits),
                                          static_cast<int32_t>(mem_level),
                                          static_cast<int32_t>(strategy),
-                                         dictionary, raw);
+                                         dictionary, dictionary_length, raw);
   if (!filter->Init()) {
     delete filter;
     Dart_ThrowException(DartUtils::NewInternalError(
         "Failed to create ZLibDeflateFilter"));
   }
   Dart_Handle result = Filter::SetFilterPointerNativeField(filter_obj, filter);
   if (Dart_IsError(result)) {
     delete filter;
     Dart_PropagateError(result);
   }
@@ skipping 121 matching lines @@
   stream_.next_in = Z_NULL;
   stream_.zalloc = Z_NULL;
   stream_.zfree = Z_NULL;
   stream_.opaque = Z_NULL;
   int result = deflateInit2(&stream_, level_, Z_DEFLATED, window_bits,
                             mem_level_, strategy_);
   if (result != Z_OK) {
     return false;
   }
   if (dictionary_ != NULL && !gzip_ && !raw_) {
-    result = deflateSetDictionary(&stream_, dictionary_, sizeof(dictionary_));
+    result = deflateSetDictionary(&stream_, dictionary_, dictionary_length_);
     delete[] dictionary_;
     dictionary_ = NULL;
     if (result != Z_OK) {
       return false;
     }
   }
   set_initialized(true);
   return true;
 }
 
@@ skipping 70 matching lines @@
 }
 
 
 intptr_t ZLibInflateFilter::Processed(uint8_t* buffer,
                                       intptr_t length,
                                       bool flush,
                                       bool end) {
   stream_.avail_out = length;
   stream_.next_out = buffer;
   bool error = false;
-  switch (inflate(&stream_,
+  int v;
+  switch (v = 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) {
         break;
       }
       return processed;
     }
 
     case Z_NEED_DICT:
       if (dictionary_ == NULL) {
         error = true;
       } else {
         int result = inflateSetDictionary(&stream_, dictionary_,
-                                          sizeof(dictionary_));
+                                          dictionary_length_);
         delete[] dictionary_;
         dictionary_ = NULL;
         error = result != Z_OK;
       }
       if (error) {
         break;
       } else {
         return Processed(buffer, length, flush, end);
       }
 
     default:
     case Z_MEM_ERROR:
     case Z_DATA_ERROR:
     case Z_STREAM_ERROR:
       error = true;
   }
 
   delete[] current_buffer_;
   current_buffer_ = NULL;
   // Either 0 Byte processed or error
   return error ? -1 : 0;
 }
 
 }  // namespace bin
 }  // namespace dart