Fix bug in deflate code.

net/filter/mock_source_stream.cc

 // Copyright 2015 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.
 
 #include "net/filter/mock_source_stream.h"
 
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 MockSourceStream::MockSourceStream()
     : SourceStream(SourceStream::TYPE_NONE),
+      read_one_byte_at_a_time_(false),
       awaiting_completion_(false),
       dest_buffer_(nullptr),
       dest_buffer_size_(0) {}
 
 MockSourceStream::~MockSourceStream() {
   DCHECK(!awaiting_completion_);
-  DCHECK(results_.empty());
+  // All data should have been consumed.
+  EXPECT_TRUE(results_.empty());
 }
 
 int MockSourceStream::Read(IOBuffer* dest_buffer,
                            int buffer_size,
                            const CompletionCallback& callback) {
   DCHECK(!awaiting_completion_);
   DCHECK(!results_.empty());
 
   if (results_.empty())
     return ERR_UNEXPECTED;
@@ skipping 20 matching lines @@
 MockSourceStream::QueuedResult::QueuedResult(const char* data,
                                              int len,
                                              Error error,
                                              Mode mode)
     : data(data), len(len), error(error), mode(mode) {}
 
 void MockSourceStream::AddReadResult(const char* data,
                                      int len,
                                      Error error,
                                      Mode mode) {
-  // The read result must be between 0 and 32k (inclusive) because the read
-  // buffer used in FilterSourceStream is 32k.
-  DCHECK_GE(32 * 1024, len);
-  DCHECK_LE(0, len);
+  if (error != OK) {
+    // Doesn't make any sense to have both an error and data.
+    DCHECK_EQ(len, 0);
+  } else {
+    // The read result must be between 0 and 32k (inclusive) because the read
+    // buffer used in FilterSourceStream is 32k.
+    DCHECK_GE(32 * 1024, len);
+    DCHECK_LE(0, len);
+  }
+
+  if (len > 0 && read_one_byte_at_a_time_) {
+    for (int i = 0; i < len; ++i) {
+      QueuedResult result(data + i, 1, OK, mode);
+      results_.push(result);
+    }
+    return;
+  }
+
   QueuedResult result(data, len, error, mode);
   results_.push(result);
 }
 
 void MockSourceStream::CompleteNextRead() {
   DCHECK(awaiting_completion_);
 
   awaiting_completion_ = false;
   QueuedResult r = results_.front();
   DCHECK_EQ(ASYNC, r.mode);
   results_.pop();
   DCHECK_GE(dest_buffer_size_, r.len);
   memcpy(dest_buffer_->data(), r.data, r.len);
   dest_buffer_ = nullptr;
   callback_.Run(r.error == OK ? r.len : r.error);
 }
 
 }  // namespace net