[ON HOLD] Implement pull-based design for content decoding

net/filter/gzip_stream_source.h

Index: net/filter/gzip_stream_source.h
diff --git a/net/filter/gzip_stream_source.h b/net/filter/gzip_stream_source.h
new file mode 100644
index 0000000000000000000000000000000000000000..f2fb7479b2dd3d5924601a938482fdc7bfbfd341
--- /dev/null
+++ b/net/filter/gzip_stream_source.h
@@ -0,0 +1,102 @@
+// Copyright 2016 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.
+
+#ifndef NET_FILTER_GZIP_STREAM_SOURCE_H_
+#define NET_FILTER_GZIP_STREAM_SOURCE_H_
+
+#include <memory>
+
+#include "net/base/net_export.h"
+#include "net/filter/filter_stream_source.h"
+#include "net/filter/gzip_header.h"
+
+typedef struct z_stream_s z_stream;
+
+namespace net {
+
+class BlockBuffer;
+
+class NET_EXPORT_PRIVATE GzipStreamSource : public FilterStreamSource {
+ public:
+  enum GzipStreamSourceMode {
+    GZIP_STREAM_SOURCE_DEFLATE,
+    GZIP_STREAM_SOURCE_GZIP,
+    // Same as GZIP_STREAM_SOURCE_GZIP, but allow fallback to plain text.
+    GZIP_STREAM_SOURCE_GZIP_WITH_FALLBACK,
+  };
+
+  explicit GzipStreamSource(std::unique_ptr<StreamSource> previous,
+                            GzipStreamSourceMode mode);

[mmenke, 2016/07/21 18:14:08]

nit:  explicit not needed.

[xunjieli, 2016/07/27 20:32:02]

Done.

+  ~GzipStreamSource() override;
+
+  bool Init() override;

[mmenke, 2016/07/21 18:14:08]

FilterStreamSource implementation.

[mmenke, 2016/07/21 18:14:08]

Randy (And you) may disagree, but I think requiring a constructor call and then
an init call to get something into a usable state is a bit ugly.  It means you
have an extra state - created, but uninitialized, which you expose to the world.
 Sometimes, that's needed (Like if init has to happen asynchronously, on another
thread).

But in general, if not needed, I think making the constructor and Init private,
and having a unique_ptr<FilterSource> Create() method is preferable.  Don't feel
too strongly about it, though, so feel free to keep as is.  Also fine to say
"Meh, this CL has gone on long enough, maybe later".

[xunjieli, 2016/07/27 20:32:01]

Done. Thanks for the excellent suggestion! I couldn't agree more that having an
extra state is confusing. I forgot a few times to call Init() in tests, which
resulted in runtime crashes. 

[xunjieli, 2016/07/27 20:32:02]

Done.

+
+ private:
+  // StreamSource implementation

[mmenke, 2016/07/21 18:14:08]

FilterStreamSource, actually.

[xunjieli, 2016/07/27 20:32:02]

Done.

+  std::string GetTypeAsString() const override;
+  int FilterData(IOBuffer* output_buffer,
+                 size_t output_buffer_size,
+                 DrainableIOBuffer* input_buffer) override;
+
+  // Synchronous decompressor. This function consumes bytes from |input_buffer|
+  // and decompresses them into |output_buffer| until it consumes all of
+  // |input_buffer|. This decompressor will decompress a zlib stream (either
+  // gzip or deflate) until the zlib reaches EOF, then will pass any further
+  // input through untouched.
+  int Decompress(IOBuffer* output_buffer,
+                 size_t output_buffer_size,
+                 DrainableIOBuffer* input_buffer);
+
+  // Returns how many bytes are drained from |input_buffer|.
+  size_t Passthrough(char* output_buffer,
+                     size_t output_buffer_size,
+                     DrainableIOBuffer* input_buffer);
+
+  // Inserts a zlib header to the data stream before calling zlib inflate.
+  // This is used to work around server bugs.
+  // The function returns true on success and false otherwise.
+  bool InsertZlibHeader();
+
+  // Returns whether an invalid GZip header has been observed. This method
+  // returns true as soon as an invalid GZip header is observed; it returns
+  // false if a complete, valid header has been observed, or not enough bytes
+  // have been seen to be sure. This method pulls its input from |buffer_|.
+  bool IsGzipHeaderInvalid(DrainableIOBuffer* input_buffer);
+
+  // Returns whether this stream looks like it could be plain text (ie, not
+  // actually gzipped). Right now this uses an extremely simple heuristic; see
+  // the source for details. This method checks the input in |buffer_|, but does
+  // not drain from it.
+  bool ShouldFallbackToPlain(DrainableIOBuffer* input_buffer);
+
+  // Skips gzip footer bytes if necessary. Might drain input from |buffer_| if
+  // there are still footer bytes to read.
+  void SkipGzipFooterIfNeeded(DrainableIOBuffer* input_buffer);
+
+  scoped_refptr<IOBuffer> pending_read_buffer_;

[mmenke, 2016/07/21 18:14:08]

include base/memory/ref_counted.h, net/base/io_buffer.h

[xunjieli, 2016/07/27 20:32:02]

Done.

+
+  // Indicates the type of content decoding the stream source is performing.
+  // This variable is set only once by Init.
+  GzipStreamSourceMode mode_;
+  // The control block of zlib which actually does the decoding.
+  // This data structure is initialized by Init and updated only by
+  // Decompress, with InsertZlibHeader being the exception as a workaround.
+  std::unique_ptr<z_stream> zlib_stream_;
+  // Whether end of stream has been reached.
+  bool zlib_eof_;
+  // A flag used by Decompress to record whether we've successfully added
+  // a zlib header to this stream.
+  bool zlib_header_added_;
+  // Used to parse the gzip header in gzip stream.
+  // It is used when the decoding mode is GZIP_STREAM_SOURCE_GZIP.
+  GZipHeader gzip_header_;
+  // Whether gzip header should be checked for validity.
+  bool should_check_gzip_header_;
+  // Tracks how many bytes of gzip footer are yet to be filtered.
+  size_t gzip_footer_bytes_left_;

[mmenke, 2016/07/21 18:14:08]

DISALLOW_COPY_AND_ASSIGN / include macros.h

[xunjieli, 2016/07/27 20:32:02]

Done.

+};
+
+}  // namespace net
+
+#endif  // NET_FILTER_GZIP_STREAM_SOURCE_H__