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..6553112c9e97929053dfb0d8f0673a42fbb12347
--- /dev/null
+++ b/net/filter/filter_source_stream.h
@@ -0,0 +1,100 @@
+// 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 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 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();
+
+  // Helper method used as a callback in |upstream_->Read()|.
+  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).

[mmenke, 2016/08/18 16:18:42]

Mention explicitly that it will continue to be called with the same input_buffer
until it returns 0 (Regardless of whether it's consumed all bytes or not)?

[mmenke, 2016/08/18 16:18:42]

Also, should we explicitly say what the filter should do if it gets extra bytes
it doesn't care about?  Ignore them vs return an error.  Presumably all filters
should handle that the same. 

[xunjieli, 2016/08/19 14:31:39]

I am not sure if we can enforce that for this interface. SDCH can recover from
extra bytes and pass through inputs unchanged, whereas Gzip filter probably
returns ERR_CONTENT_DECODING_FAILED. I've adjusted the  documentation. Let me
know if that is clearer.

[xunjieli, 2016/08/19 14:31:39]

Done.

+  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;

[mmenke, 2016/08/18 16:18:42]

include <string>

[xunjieli, 2016/08/19 14:31:39]

Done.

+
+  // 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_;

[mmenke, 2016/08/18 16:18:42]

include base/memory/ref_counted.h

[xunjieli, 2016/08/19 14:31:39]

Done.

+
+  // 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 |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_