Blimp: add packet-level DEFLATE compression using zlib.

blimp/net/stream_packet_reader.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 "blimp/net/stream_packet_reader.h"
 
 #include <iostream>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 29 matching lines @@
   header_buffer_ = new net::GrowableIOBuffer;
   header_buffer_->SetCapacity(kPacketHeaderSizeBytes);
 }
 
 StreamPacketReader::~StreamPacketReader() {}
 
 void StreamPacketReader::ReadPacket(
     const scoped_refptr<net::GrowableIOBuffer>& buf,
     const net::CompletionCallback& callback) {
   DCHECK_EQ(ReadState::IDLE, read_state_);
-  DCHECK_GT(buf->capacity(), 0);
+  if (static_cast<size_t>(buf->capacity()) < kPacketHeaderSizeBytes) {
+    buf->SetCapacity(kPacketHeaderSizeBytes);
+  }
 
   header_buffer_->set_offset(0);
   payload_buffer_ = buf;
   payload_buffer_->set_offset(0);
   read_state_ = ReadState::HEADER;
 
   int result = DoReadLoop(net::OK);
   if (result != net::ERR_IO_PENDING) {
     // Release the payload buffer, since the read operation has completed
     // synchronously.
@@ skipping 46 matching lines @@
     int result = socket_->Read(
         header_buffer_.get(), kPacketHeaderSizeBytes - header_buffer_->offset(),
         base::Bind(&StreamPacketReader::OnReadComplete,
                    weak_factory_.GetWeakPtr()));
     return (result != 0 ? result : net::ERR_CONNECTION_CLOSED);
   }
 
   // Finished reading the header. Parse the size and prepare for payload read.
   payload_size_ = base::NetToHost32(
       *reinterpret_cast<uint32_t*>(header_buffer_->StartOfBuffer()));
-  if (payload_size_ > static_cast<size_t>(payload_buffer_->capacity()) ||
-      payload_size_ == 0) {
+  if (payload_size_ == 0 || payload_size_ > kMaxPacketPayloadSizeBytes) {
     DLOG(ERROR) << "Illegal payload size: " << payload_size_;
     return net::ERR_INVALID_RESPONSE;
   }
+  if (static_cast<size_t>(payload_buffer_->capacity()) < payload_size_) {
+    payload_buffer_->SetCapacity(payload_size_);
+  }
   read_state_ = ReadState::PAYLOAD;
   return net::OK;
 }
 
 int StreamPacketReader::DoReadPayload(int result) {
   DCHECK_EQ(ReadState::PAYLOAD, read_state_);
   DCHECK_GE(result, 0);
 
   payload_buffer_->set_offset(payload_buffer_->offset() + result);
   if (static_cast<size_t>(payload_buffer_->offset()) < payload_size_) {
@@ skipping 26 matching lines @@
   // If all reading completed, either successfully or by error, inform the
   // caller.
   if (result != net::ERR_IO_PENDING) {
     payload_buffer_ = nullptr;
     base::ResetAndReturn(&callback_)
         .Run(result == net::OK ? payload_size_ : result);
   }
 }
 
 }  // namespace blimp