Add net::GzipSourceStream

net/filter/gzip_source_stream.h

+// 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;
+
+namespace net {
+
+class IOBuffer;
+
+// 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,

[Randy Smith (Not in Mondays), 2016/09/14 22:25:24]

nit, suggestion: "previous -> upstream"?

[xunjieli, 2016/09/19 13:57:03]

Done.

+                   GzipSourceStreamMode mode);
+
+  // Returns true if initialization is successful, false otherwise.

[Randy Smith (Not in Mondays), 2016/09/14 22:25:23]

Under what circumstances can initialization fail?

More specifically, it doesn't look like there's any variations in consumer input
to the stream to this point, and it doesn't read anything from the upstream
stream as part of Init().  So why should the Init() return be constant for all
calls?  

Digging down into the implementation, the reasons I see for Init() returning
false are:

* new failing.  We don't bother to check this in any other chrome code; OOM
errors are crashes.  
* inflateInit{,2} failing.  The documentation on inflateInit says that it
returns errors if OOM, the version is incompatible between header and linked
library, or an invalid argument (e.g. null pointer) was passed.  

Based on that, I'd suggest documenting this as returning false in the case of a
version mismatch and DHCECKing other than that, or alternatively DHCECKing
everything--all these errors really sound like they're bugs in our code (or
OOM), not something that's useful or actionable to the caller.  

(This is a suggestion, both because I'm not sure about it and because this
problem (return value and lack of documentation of return value) predates this
CL.  

[xunjieli, 2016/09/19 13:57:03]

Done. I am not sure if it's a good idea to DCHECK on version mismatch though.
Will it be better to pass raw input to user (current behavior) than to crash the
browser process? I guess we can land the DCHECK first, if this breaks people, we
can remove the DCHECK?

+  bool Init();
+
+  // SourceStream implementation
+  std::string GetTypeAsString() const override;
+  int FilterData(IOBuffer* output_buffer,
+                 int output_buffer_size,
+                 IOBuffer* input_buffer,
+                 int input_buffer_size,
+                 int* consumed_bytes,
+                 bool upstream_end_reached) 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,
+                 int output_buffer_size,
+                 char* input_buffer,
+                 int input_buffer_size,
+                 int* consumed_bytes);
+
+  // Returns how many bytes are copied from |input_buffer| to |output_buffer|.
+  size_t Passthrough(char* output_buffer,
+                     int output_buffer_size,
+                     char* input_buffer,
+                     int input_buffer_size,
+                     int* consumed_bytes);
+
+  // 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 can be called multiple times with
+  // multiple |input_buffer|. The number of consumed bytes will be written to
+  // |consumed_bytes|.
+  bool IsGzipHeaderInvalid(char* input_buffer,
+                           int input_buffer_size,
+                           int* consumed_bytes);
+
+  // 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 first byte of the stream.
+  bool ShouldFallbackToPlain(char first_byte);
+
+  // Returns number of footer bytes to skip.
+  size_t NumGzipFooterBytesToSkip(int input_buffer_size);
+
+  // Indicates the type of content decoding the stream source is performing.
+  // This variable is set only once by Init.

[Randy Smith (Not in Mondays), 2016/09/14 22:25:23]

nit: No longer set by Init, correct?  And "const" pretty much means "only set in
the constructor", so we could probably nuke the second sentence entirely.

[xunjieli, 2016/09/19 13:57:03]

Done.

+  const 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_;
+
+  // Whether the first byte of the input stream should be checked.
+  bool should_check_first_byte_;
+
+  // 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__