[ZLIB] Add support for windowBits, memLevel, raw

runtime/bin/filter.h

Index: runtime/bin/filter.h
diff --git a/runtime/bin/filter.h b/runtime/bin/filter.h
index 16f1c6e16896942401aadf3f94d644769010dfb7..543f82ea255fada7a75dfac091413bc6ef96660e 100644
--- a/runtime/bin/filter.h
+++ b/runtime/bin/filter.h
@@ -21,14 +21,12 @@ class Filter {
   virtual bool Init() = 0;
 
   /**
-   * On a succesfull call to Process, Process will take ownership of data. On
+   * On a successful call to Process, Process will take ownership of data. On
    * successive calls to either Processed or ~Filter, data will be freed with
    * a delete[] call.
    */
   virtual bool Process(uint8_t* data, intptr_t length) = 0;
-  virtual intptr_t Processed(uint8_t* buffer,
-                             intptr_t length,
-                             bool finish,
+  virtual intptr_t Processed(uint8_t* buffer, intptr_t length, bool finish,
                              bool end) = 0;
 
   static Dart_Handle SetFilterPointerNativeField(Dart_Handle filter,
@@ -54,20 +52,28 @@ class Filter {
 
 class ZLibDeflateFilter : public Filter {
  public:
-  ZLibDeflateFilter(bool gzip = false, int32_t level = 6)
-    : gzip_(gzip), level_(level), current_buffer_(NULL) {}
+  ZLibDeflateFilter(bool gzip, int32_t level, int32_t window_bits,
+                    int32_t mem_level, int32_t strategy,
+                    Dart_Handle dictionary, bool raw)
+      : gzip_(gzip), level_(level), window_bits_(window_bits),
+        mem_level_(mem_level), strategy_(strategy), dictionary_(dictionary),
+        raw_(raw), current_buffer_(NULL)
+    {}
   virtual ~ZLibDeflateFilter();
 
   virtual bool Init();
   virtual bool Process(uint8_t* data, intptr_t length);
-  virtual intptr_t Processed(uint8_t* buffer,
-                             intptr_t length,
-                             bool finish,
+  virtual intptr_t Processed(uint8_t* buffer, intptr_t length, bool finish,
                              bool end);
 
  private:
   const bool gzip_;
   const int32_t level_;
+  const int32_t window_bits_;
+  const int32_t mem_level_;
+  const int32_t strategy_;
+  const Dart_Handle dictionary_;

[Anders Johnsen, 2014/01/27 12:27:45]

This should be a Dart_PersistentHandle. Checkout Dart_NewPersistentHandle and
Dart_DeletePersistentHandle.

[vicb, 2014/01/27 15:14:19]

The thing is IOBuffer::Allocate returns a Dart_Handle.

This also leads to one question I had about this code, should it rather reads
like:

Dart_Handle IOBuffer::Allocate(intptr_t size, uint8_t **buffer) {
  uint8_t* data = Allocate(size);
  Dart_Handle result = Dart_NewExternalTypedData(
      Dart_TypedData_kUint8, data, size);
  **result =**Dart_NewWeakPersistentHandle(result, data, IOBuffer::Finalizer);

  if (Dart_IsError(result)) {
    Free(data);
    Dart_PropagateError(result);
  }
  if (buffer != NULL) {
    *buffer = data;
  }
  return result;
}

Or should I turn the returned handle to a persistent one by hand ?

+  const bool raw_;
   uint8_t* current_buffer_;
   z_stream stream_;
 
@@ -76,17 +82,21 @@ class ZLibDeflateFilter : public Filter {
 
 class ZLibInflateFilter : public Filter {
  public:
-  ZLibInflateFilter() : current_buffer_(NULL) {}
+  ZLibInflateFilter(int32_t window_bits, Dart_Handle dictionary, bool raw)
+        : window_bits_(window_bits), dictionary_(dictionary), raw_(raw),
+        current_buffer_(NULL)
+    {}
   virtual ~ZLibInflateFilter();
 
   virtual bool Init();
   virtual bool Process(uint8_t* data, intptr_t length);
-  virtual intptr_t Processed(uint8_t* buffer,
-                             intptr_t length,
-                             bool finish,
+  virtual intptr_t Processed(uint8_t* buffer, intptr_t length, bool finish,
                              bool end);
 
  private:
+  const int32_t window_bits_;
+  const Dart_Handle dictionary_;

[Anders Johnsen, 2014/01/27 12:27:45]

Ditto.

+  const bool raw_;
   uint8_t* current_buffer_;
   z_stream stream_;