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

net/filter/gzip_source_stream.h

Index: net/filter/gzip_source_stream.h
diff --git a/net/filter/gzip_source_stream.h b/net/filter/gzip_source_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c2906b64ba14f4c0a66140492c791dbe1cfabf8
--- /dev/null
+++ b/net/filter/gzip_source_stream.h
@@ -0,0 +1,116 @@
+// 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_SOURCE_STREAM_H_
+#define NET_FILTER_GZIP_SOURCE_STREAM_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_export.h"
+#include "net/filter/filter_source_stream.h"
+#include "net/filter/gzip_header.h"
+
+typedef struct z_stream_s z_stream;

[mmenke, 2016/08/01 21:55:30]

Can we get this out of the global namespace, move it into GzipSourceStream or
something?

[xunjieli, 2016/08/02 13:44:32]

It fails to compile if I move it elsewhere. I think this is needed so we can
forward declare z_stream_s and somehow it has to be in the global namespace.

+
+namespace net {
+
+// GZipSourceStream applies gzip and deflate content encoding/decoding to a data
+// stream. As specified by HTTP 1.1, with gzip encoding the content is
+// wrapped with a gzip header, and with deflate encoding the content is in
+// a raw, headerless DEFLATE stream.
+//
+// Internally GZipSourceStream uses zlib inflate to do decoding.
+//
+class NET_EXPORT_PRIVATE GzipSourceStream : public FilterSourceStream {
+ public:
+  enum GzipSourceStreamMode {
+    GZIP_SOURCE_STREAM_DEFLATE,
+    GZIP_SOURCE_STREAM_GZIP,
+    // Same as GZIP_SOURCE_STREAM_GZIP, but allow fallback to plain text.
+    GZIP_SOURCE_STREAM_GZIP_WITH_FALLBACK,
+  };
+
+  ~GzipSourceStream() override;
+
+  // Creates a GzipSourceStream. Return nullptr if initialization fails.
+  static std::unique_ptr<GzipSourceStream> Create(
+      std::unique_ptr<SourceStream> previous,
+      GzipSourceStreamMode mode);
+
+ private:
+  GzipSourceStream(std::unique_ptr<SourceStream> previous,
+                   GzipSourceStreamMode mode);
+  bool Init();
+  // SourceStream implementation
+  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_;
+
+  // Indicates the type of content decoding the stream source is performing.
+  // This variable is set only once by Init.
+  GzipSourceStreamMode 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_SOURCE_STREAM_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_;
+
+  DISALLOW_COPY_AND_ASSIGN(GzipSourceStream);
+};
+
+}  // namespace net
+
+#endif  // NET_FILTER_GZIP_SOURCE_STREAM_H__