Change DrainableIOBuffer to IBuffer and int* in FilterData() arguments

R=mmenke@chromium.org
CC=rdsmith@chromium.org

BUG=474859

Review-Url: https://codereview.chromium.org/2338043002
Cr-Commit-Position: refs/heads/master@{#418951}

net/filter/filter_source_stream.cc

@@ -126,9 +126,15 @@ int FilterSourceStream::DoFilterData() {
   DCHECK(output_buffer_);
   DCHECK(drainable_input_buffer_);
 
-  int bytes_output =
-      FilterData(output_buffer_.get(), output_buffer_size_,
-                 drainable_input_buffer_.get(), upstream_end_reached_);
+  int consumed_bytes = 0;
+  int bytes_output = FilterData(output_buffer_.get(), output_buffer_size_,
+                                drainable_input_buffer_.get(),
+                                drainable_input_buffer_->BytesRemaining(),
+                                &consumed_bytes, upstream_end_reached_);
+  DCHECK_LE(consumed_bytes, drainable_input_buffer_->BytesRemaining());
+  DCHECK(bytes_output != 0 ||
+         consumed_bytes == drainable_input_buffer_->BytesRemaining());
+
   if (bytes_output == ERR_CONTENT_DECODING_FAILED) {
     UMA_HISTOGRAM_ENUMERATION("Net.ContentDecodingFailed.FilterType", type(),
                               TYPE_MAX);
@@ -136,6 +142,9 @@ int FilterSourceStream::DoFilterData() {
   // FilterData() is not allowed to return ERR_IO_PENDING.
   DCHECK_NE(ERR_IO_PENDING, bytes_output);
 
+  if (consumed_bytes > 0)
+    drainable_input_buffer_->DidConsume(consumed_bytes);
+
   // Received data or encountered an error.
   if (bytes_output != 0)
     return bytes_output;

net/filter/filter_source_stream.h

@@ -66,15 +66,16 @@ class NET_EXPORT_PRIVATE FilterSourceStream : public SourceStream {
   // 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() returns 0 or an error. If FilterData() returns 0,
-  // |input_buffer| must be fully drained. Upstream EOF is reached when
-  // FilterData() is called with |upstream_eof_reached| = true.
+  // If FilterData() returns 0, *|consumed_bytes| must be equal to
+  // |input_buffer_size|. Upstream EOF is reached when FilterData() is called
+  // with |upstream_eof_reached| = true.
   // TODO(xunjieli): consider allowing asynchronous response via callback
   // to support off-thread decompression.
   virtual int FilterData(IOBuffer* output_buffer,
                          int output_buffer_size,
-                         DrainableIOBuffer* input_buffer,
+                         IOBuffer* input_buffer,
+                         int input_buffer_size,
+                         int* consumed_bytes,
                          bool upstream_eof_reached) = 0;
 
   // Returns a string representation of the type of this FilterSourceStream.

net/filter/filter_source_stream_unittest.cc

@@ -66,12 +66,14 @@ class NeedsAllInputFilterSourceStream : public TestFilterSourceStreamBase {
         expected_input_bytes_(expected_input_bytes) {}
   int FilterData(IOBuffer* output_buffer,
                  int output_buffer_size,
-                 DrainableIOBuffer* input_buffer,
+                 IOBuffer* input_buffer,
+                 int input_buffer_size,
+                 int* consumed_bytes,
                  bool upstream_eof_reached) override {
-    buffer_.append(input_buffer->data(), input_buffer->BytesRemaining());
-    EXPECT_GE(expected_input_bytes_, input_buffer->BytesRemaining());
-    expected_input_bytes_ -= input_buffer->BytesRemaining();
-    input_buffer->DidConsume(input_buffer->BytesRemaining());
+    buffer_.append(input_buffer->data(), input_buffer_size);
+    EXPECT_GE(expected_input_bytes_, input_buffer_size);
+    expected_input_bytes_ -= input_buffer_size;
+    *consumed_bytes = input_buffer_size;
     if (!upstream_eof_reached) {
       // Keep returning 0 bytes read until all input has been consumed.
       return 0;
@@ -96,13 +98,15 @@ class MultiplySourceStream : public TestFilterSourceStreamBase {
         multiplier_(multiplier) {}
   int FilterData(IOBuffer* output_buffer,
                  int output_buffer_size,
-                 DrainableIOBuffer* input_buffer,
+                 IOBuffer* input_buffer,
+                 int input_buffer_size,
+                 int* consumed_bytes,
                  bool /*upstream_eof_reached*/) override {
-    for (int i = 0; i < input_buffer->BytesRemaining(); i++) {
+    for (int i = 0; i < input_buffer_size; i++) {
       for (int j = 0; j < multiplier_; j++)
         buffer_.append(input_buffer->data() + i, 1);
     }
-    input_buffer->DidConsume(input_buffer->BytesRemaining());
+    *consumed_bytes = input_buffer_size;
     return WriteBufferToOutput(output_buffer, output_buffer_size);
   }
 
@@ -119,10 +123,12 @@ class PassThroughFilterSourceStream : public TestFilterSourceStreamBase {
       : TestFilterSourceStreamBase(std::move(upstream)) {}
   int FilterData(IOBuffer* output_buffer,
                  int output_buffer_size,
-                 DrainableIOBuffer* input_buffer,
+                 IOBuffer* input_buffer,
+                 int input_buffer_size,
+                 int* consumed_bytes,
                  bool /*upstream_eof_reached*/) override {
-    buffer_.append(input_buffer->data(), input_buffer->BytesRemaining());
-    input_buffer->DidConsume(input_buffer->BytesRemaining());
+    buffer_.append(input_buffer->data(), input_buffer_size);
+    *consumed_bytes = input_buffer_size;
     return WriteBufferToOutput(output_buffer, output_buffer_size);
   }
 
@@ -138,10 +144,12 @@ class ThrottleSourceStream : public TestFilterSourceStreamBase {
       : TestFilterSourceStreamBase(std::move(upstream)) {}
   int FilterData(IOBuffer* output_buffer,
                  int output_buffer_size,
-                 DrainableIOBuffer* input_buffer,
+                 IOBuffer* input_buffer,
+                 int input_buffer_size,
+                 int* consumed_bytes,
                  bool /*upstream_eof_reached*/) override {
-    buffer_.append(input_buffer->data(), input_buffer->BytesRemaining());
-    input_buffer->DidConsume(input_buffer->BytesRemaining());
+    buffer_.append(input_buffer->data(), input_buffer_size);
+    *consumed_bytes = input_buffer_size;
     int bytes_to_read = std::min(1, static_cast<int>(buffer_.size()));
     memcpy(output_buffer->data(), buffer_.data(), bytes_to_read);
     buffer_.erase(0, bytes_to_read);
@@ -162,10 +170,12 @@ class NoOutputSourceStream : public TestFilterSourceStreamBase {
         consumed_all_input_(false) {}
   int FilterData(IOBuffer* output_buffer,
                  int output_buffer_size,
-                 DrainableIOBuffer* input_buffer,
+                 IOBuffer* input_buffer,
+                 int input_buffer_size,
+                 int* consumed_bytes,
                  bool /*upstream_eof_reached*/) override {
-    expected_input_size_ -= input_buffer->BytesRemaining();
-    input_buffer->DidConsume(input_buffer->BytesRemaining());
+    expected_input_size_ -= input_buffer_size;
+    *consumed_bytes = input_buffer_size;
     EXPECT_LE(0, expected_input_size_);
     consumed_all_input_ = (expected_input_size_ == 0);
     return OK;
@@ -189,7 +199,9 @@ class ErrorFilterSourceStream : public FilterSourceStream {
 
   int FilterData(IOBuffer* output_buffer,
                  int output_buffer_size,
-                 DrainableIOBuffer* input_buffer,
+                 IOBuffer* input_buffer,
+                 int input_buffer_size,
+                 int* consumed_bytes,
                  bool /*upstream_eof_reached*/) override {
     return ERR_CONTENT_DECODING_FAILED;
   }