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

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..951f641e07865c257a15d467043838059a37c40b
--- /dev/null
+++ b/net/filter/filter_source_stream.h
@@ -0,0 +1,101 @@
+// 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 "base/macros.h"
+#include "net/base/completion_callback.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_export.h"
+#include "net/filter/source_stream.h"
+
+namespace net {
+
+class IOBuffer;
+
+// FilterSourceStream represents SourceStreams that always have a next
+// stream from which undecoded input can be read. Except the last stream in
+// the filter chain, all other streams should implement FilterSourceStream
+// instead of SourceStream.
+class NET_EXPORT_PRIVATE FilterSourceStream : public SourceStream {
+ public:
+  // |next| is the next SourceStream in the chain. |next| cannot be
+  // null.
+  FilterSourceStream(SourceType type, std::unique_ptr<SourceStream> next);
+
+  ~FilterSourceStream() override;
+
+  int Read(IOBuffer* read_buffer,
+           size_t read_buffer_size,
+           const CompletionCallback& callback) override;
+
+  std::string OrderedTypeStringList() const override;
+
+ private:
+  enum State {
+    STATE_NONE,
+    // Reading data from |next|.
+    STATE_READ_DATA,
+    // Reading data from |next| completed.
+    STATE_READ_DATA_COMPLETE,
+    // Filtering data contained in |buffer_|.
+    STATE_FILTER_DATA,
+    // Filtering data contained in |buffer_| completed.
+    STATE_FILTER_DATA_COMPLETE,
+    STATE_DONE,
+  };
+
+  int DoLoop(int result);
+  int DoReadData();
+  int DoReadDataComplete(int result);
+  int DoFilterData(int result);
+
+  void DoCallback(int result);
+
+  // Helper method used as a callback when |next_| is to complete a read
+  // asynchronously.
+  void OnNextReadCompleted(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).
+  virtual int FilterData(IOBuffer* output_buffer,
+                         size_t 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;
+
+  // Next SourceStream in the chain that is lower in the stack (closer to the
+  // HttpTransaction).
+  std::unique_ptr<SourceStream> next_;
+
+  State next_state_;
+
+  // Buffer for reading data out of |next_| and then for use by |this|
+  // before the filtered data is returned through Read().
+  scoped_refptr<IOBuffer> input_buffer_;
+  // 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_;
+  size_t output_buffer_size_;
+  CompletionCallback callback_;
+
+  // Reading from |next_| has returned 0 byte or an error code.
+  bool next_end_reached_;

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

next_stream_end_reached_?  (Since we also have next_state_, and next can also be
an adjective describing end, instead of a noun, seems a bit confusing)

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

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(FilterSourceStream);
+};
+
+}  // namespace net
+
+#endif  // NET_FILTER_FILTER_SOURCE_STREAM_H_