Add brotli content-encoding filter.

net/filter/brotli_filter.cc

Index: net/filter/brotli_filter.cc
diff --git a/net/filter/brotli_filter.cc b/net/filter/brotli_filter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2ecc391b32b335e961e5deac95117784dede1fea
--- /dev/null
+++ b/net/filter/brotli_filter.cc
@@ -0,0 +1,144 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/filter/brotli_filter.h"
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "third_party/brotli/dec/decode.h"
+
+namespace net {
+
+#if !defined(DISABLE_BROTLI_SUPPORT)
+class BrotliFilter : public Filter {
+ public:
+  BrotliFilter(FilterType type, int buffer_size)
+      : Filter(type), decoding_status_(DECODING_UNINITIALIZED) {
+    InitBuffer(buffer_size);
+  }
+
+  ~BrotliFilter() override {
+    if (decoding_status_ != DECODING_UNINITIALIZED)
+      BrotliStateCleanup(brotli_state_.get());
+  }
+
+  // Initializes filter decoding mode and internal control blocks.
+  // The function returns true if success and false otherwise.
+  // The filter can only be initialized once.
+  bool InitDecoding() {
+    if (decoding_status_ != DECODING_UNINITIALIZED)
+      return false;
+
+    brotli_state_.reset(new BrotliState);
+    BrotliStateInit(brotli_state_.get());
+
+    decoding_status_ = DECODING_IN_PROGRESS;
+    return true;
+  }
+
+  // Decodes the pre-filter data and writes the output into the |dest_buffer|
+  // passed in.
+  // The function returns FilterStatus. See filter.h for its description.
+  //
+  // Upon entry, |*dest_len| is the total size (in number of chars) of the
+  // destination buffer. Upon exit, |*dest_len| is the actual number of chars
+  // written into the destination buffer.
+  //
+  // This function will fail if there is no pre-filter data in the
+  // |stream_buffer_|. On the other hand, |*dest_len| can be 0 upon successful
+  // return. For example, decompressor may process some pre-filter data
+  // but not produce output yet.
+  FilterStatus ReadFilteredData(char* dest_buffer, int* dest_len) override {

[Randy Smith (Not in Mondays), 2015/12/04 16:07:52]

When we did the initial review (a long time ago :-}) I remember that it would be
useful for Brotli to know when EOF was reached on the input.  What's the status
of that?  Is it waiting on Helen's filter refactor?  If so, just for my
curiosity, where would the information be used in this code?

[eustas, 2015/12/07 12:30:38]

We've modified decoder to have weaker requirements...
Now it doesn't need to know about EOF and pushes to output all the data it has
decoded so far.

So, we do not depend on Helen's refactoring now...

[Randy Smith (Not in Mondays), 2015/12/07 22:27:28]

Is there value in having that information?  (Which I guess is equivalent to:
Will you be modifying this code after Helen's refactor?)  Or is this just as
good with the weaker requirements?

+    if (!dest_buffer || !dest_len || *dest_len <= 0)
+      return Filter::FILTER_ERROR;
+
+    if (decoding_status_ == DECODING_DONE) {
+      *dest_len = 0;
+      return Filter::FILTER_DONE;
+    }
+
+    if (decoding_status_ != DECODING_IN_PROGRESS)
+      return Filter::FILTER_ERROR;
+
+    size_t available_in = stream_data_len_;
+    const uint8_t* next_in = bit_cast<uint8_t*>(next_stream_data_);
+    size_t available_out = *dest_len;
+    uint8_t* next_out = bit_cast<uint8_t*>(dest_buffer);
+    size_t total_out;

[Randy Smith (Not in Mondays), 2015/12/04 16:07:52]

According to the header file, this value must be initialized to zero?  I think
I'd like that, even if it isn't going to be used; uninitialized values disturb
me.

[eustas, 2015/12/07 12:30:37]

No problem.
(Ooops, headers are outdated now... currently there is no such requirement,
value is overwritten based on decoder internal data).

+    BrotliResult result =
+        BrotliDecompressStream(&available_in, &next_in, &available_out,

[Randy Smith (Not in Mondays), 2015/12/04 16:07:52]

The header file says 

"In the current implementation, the function requires that there is enough
   output buffer size to write all currently processed input, so
   *available_out must be large enough. "

While it doesn't specify how large "large enough" is, I don't see anything
confirming that *dest_len is greater than any given size or modifying processing
if it is.  Is this a bug?

[eustas, 2015/12/07 12:30:38]

This comment is outdated as well. I think it is for pre-March'15 version.
Output as small as 1 byte is enough (and we have tests for that).

+                               &next_out, &total_out, brotli_state_.get());
+    int bytes_written = *dest_len - available_out;
+
+    Filter::FilterStatus status;
+    switch (result) {
+      case BROTLI_RESULT_ERROR: {
+        status = Filter::FILTER_ERROR;
+        break;
+      }
+      // Fall through.
+      case BROTLI_RESULT_NEEDS_MORE_OUTPUT:
+      case BROTLI_RESULT_SUCCESS: {
+        status = Filter::FILTER_OK;
+        *dest_len = bytes_written;
+        stream_data_len_ = available_in;
+        next_stream_data_ = bit_cast<char*>(next_in);
+        if (result == BROTLI_RESULT_SUCCESS)
+          status = Filter::FILTER_DONE;
+        break;
+      }
+      case BROTLI_RESULT_NEEDS_MORE_INPUT: {

[Randy Smith (Not in Mondays), 2015/12/04 16:07:52]

How does the underlying Brotli decoding respond if both needs more input and
needs more output are true (i.e. its reached the end of the input available to
it, and completely filled the output available to it)?

[eustas, 2015/12/07 12:30:37]

Decoder has its internal ringbuffer (for backward-references).
When this buffer is full, the data is copied to destination buffer.
If destination buffer can't hold all the data, then Brotli returns
NEEDS_MORE_OUTPUT.

If there is not enough input to produce more output, decoder pushes all the data
produced so far and returns NEEDS_MORE_INPUT (even if the output buffer is full,
brotli could still continue decoding to internal ringbuffer).

For the decoder there is no situation that it needs more input and more output
simultaneously, because it is state machine inside. So if internal ringbuffer is
full and there is not enough data to decode further, decoder will ask for more
output first (until it is enough) and after that it will request for more input.

+        status = Filter::FILTER_NEED_MORE_DATA;
+        *dest_len = bytes_written;
+        stream_data_len_ = 0;
+        next_stream_data_ = nullptr;
+        break;
+      }
+      default: {
+        status = Filter::FILTER_ERROR;
+        break;
+      }
+    }
+
+    if (status == Filter::FILTER_DONE) {
+      decoding_status_ = DECODING_DONE;
+    } else if (status == Filter::FILTER_ERROR) {
+      decoding_status_ = DECODING_ERROR;
+    }
+
+    return status;
+  }
+
+ private:
+  enum DecodingStatus {
+    DECODING_UNINITIALIZED,
+    DECODING_IN_PROGRESS,
+    DECODING_DONE,
+    DECODING_ERROR
+  };
+
+  // Tracks the status of decoding.
+  // This variable is initialized by InitDecoding and updated only by
+  // ReadFilteredData.
+  DecodingStatus decoding_status_;
+
+  scoped_ptr<BrotliStateStruct> brotli_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(BrotliFilter);
+};
+#endif
+
+Filter* CreateBrotliFilter(Filter::FilterType type_id, int buffer_size) {
+#if !defined(DISABLE_BROTLI_SUPPORT)
+  scoped_ptr<BrotliFilter> brotli_filter(
+      new BrotliFilter(type_id, buffer_size));
+  return brotli_filter->InitDecoding() ? brotli_filter.release() : nullptr;
+#else
+  return nullptr;
+#endif
+}
+
+}  // namespace net