Add net::SourceStream and net::FilterSourceStream

net/filter/filter_source_stream.h

Index: net/filter/filter_source_stream.h
diff --git a/net/filter/filter_source_stream.h b/net/filter/filter_source_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c28755270bdeeb30820b03cc27b12f3c650217d
--- /dev/null
+++ b/net/filter/filter_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_FILTER_SOURCE_STREAM_H_
+#define NET_FILTER_FILTER_SOURCE_STREAM_H_
+
+#include <memory>
+#include <string>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_export.h"
+#include "net/filter/source_stream.h"
+
+namespace net {
+
+class DrainableIOBuffer;
+class IOBuffer;
+
+// FilterSourceStream represents SourceStreams that always have an upstream
+// from which undecoded input can be read. Except the ultimate upstream in
+// the filter chain, all other streams should implement FilterSourceStream
+// instead of SourceStream.
+class NET_EXPORT_PRIVATE FilterSourceStream : public SourceStream {
+ public:
+  // |upstream| is the SourceStream from which |this| will read data.
+  // |upstream| cannot be null.
+  FilterSourceStream(SourceType type, std::unique_ptr<SourceStream> upstream);
+
+  ~FilterSourceStream() override;
+
+  int Read(IOBuffer* read_buffer,
+           int read_buffer_size,
+           const CompletionCallback& callback) override;
+
+  std::string Description() const override;
+
+ private:
+  enum State {
+    STATE_NONE,
+    // Reading data from |upstream_| into |input_buffer_|.
+    STATE_READ_DATA,
+    // Reading data from |upstream_| completed.
+    STATE_READ_DATA_COMPLETE,
+    // Filtering data contained in |input_buffer_|.
+    STATE_FILTER_DATA,
+    // Filtering data contained in |input_buffer_| completed.
+    STATE_FILTER_DATA_COMPLETE,
+    STATE_DONE,
+  };
+
+  int DoLoop(int result);
+  int DoReadData();
+  int DoReadDataComplete(int result);
+  int DoFilterData();
+
+  // Helper method used as a callback argument passed to |upstream_->Read()|.
+  void OnIOComplete(int result);
+
+  // Subclasses should implement this method to filter data from
+  // |input_buffer| and write to |output_buffer|.
+  // This method must complete synchronously (i.e. It cannot return
+  // ERR_IO_PENDING). If an unrecoverable error occurred, this should return
+  // ERR_CONTENT_DECODING_FAILED or a more specific error code.
+  //
+  // FilterData() will be repeatedly invoked with the same |input_buffer| until
+  // FilterData() return 0, at which point, FilterSourceStream will read more

[Randy Smith (Not in Mondays), 2016/09/08 18:57:41]

Should we not document the requirement that all data must have been read from
input_buffer if FilterData() returns zero?

[xunjieli, 2016/09/08 19:11:43]

Done.

+  // input data from |upstream_|. Upstream EOF is reached when

[Randy Smith (Not in Mondays), 2016/09/08 18:57:41]

nit: "... when FilterData() is called with |input_buffer->BytesRemaining() == 0|
(to distinguish from the above case when the subclass has drained all the
bytes).

Also, should we say something about FilterData being called repeatedly in this
case until 0 (EOF) or an error is returned from the subclass?

[xunjieli, 2016/09/08 19:11:43]

Done.
The "repeated" part is in the first sentence of this paragraph.

+  // |input_buffer->BytesRemaining()| is 0.
+  // TODO(xunjieli): consider allowing asynchronous decompression.

[Randy Smith (Not in Mondays), 2016/09/08 18:57:41]

nit, suggestion: "consider allowing asynchronous response via callback, to
support off-thread decompression"?

[xunjieli, 2016/09/08 19:11:43]

Done.

+  virtual int FilterData(IOBuffer* output_buffer,
+                         int output_buffer_size,
+                         DrainableIOBuffer* input_buffer) = 0;
+
+  // Returns a string representation of the type of this FilterSourceStream.
+  // This is for UMA logging.
+  virtual std::string GetTypeAsString() const = 0;
+
+  // Returns whether |this| still needs more input data from |upstream_|.
+  // By default, |this| will continue reading until |upstream_| returns an error
+  // or EOF. Subclass can override this to return false to skip reading all the
+  // input from |upstream_|.
+  virtual bool NeedMoreData() const;
+
+  // The SourceStream from which |this| will read data from. Data flows from
+  // |upstream_| to |this_|.
+  std::unique_ptr<SourceStream> upstream_;
+
+  State next_state_;
+
+  // Buffer for reading data out of |upstream_| and then for use by |this|
+  // before the filtered data is returned through Read().
+  scoped_refptr<IOBuffer> input_buffer_;
+
+  // Wrapper around |input_buffer_| that makes visible only the unread data.
+  // Keep this as a member because subclass might not drain everything in a
+  // single FilterData().
+  scoped_refptr<DrainableIOBuffer> drainable_input_buffer_;
+
+  // Not null if there is a pending Read.
+  scoped_refptr<IOBuffer> output_buffer_;
+  int output_buffer_size_;
+  CompletionCallback callback_;
+
+  // Reading from |upstream_| has returned 0 byte or an error code.
+  bool upstream_end_reached_;
+
+  DISALLOW_COPY_AND_ASSIGN(FilterSourceStream);
+};
+
+}  // namespace net
+
+#endif  // NET_FILTER_FILTER_SOURCE_STREAM_H_