Land Recent QUIC changes.

net/quic/reliable_quic_stream.cc

 // Copyright (c) 2012 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/quic/reliable_quic_stream.h"
 
 #include "net/quic/quic_session.h"
 #include "net/quic/quic_spdy_decompressor.h"
 #include "net/spdy/write_blocked_list.h"
 
@@ skipping 230 matching lines @@
 }
 
 QuicConsumedData ReliableQuicStream::WriteDataInternal(
     StringPiece data, bool fin) {
   struct iovec iov = {const_cast<char*>(data.data()),
                       static_cast<size_t>(data.size())};
   return WritevDataInternal(&iov, 1, fin);
 }
 
 QuicConsumedData ReliableQuicStream::WritevDataInternal(const struct iovec* iov,
-                                                        int count,
+                                                        int iov_count,
                                                         bool fin) {
   if (write_side_closed_) {
     DLOG(ERROR) << "Attempt to write when the write side is closed";
     return QuicConsumedData(0, false);
   }
 
   size_t write_length = 0u;
-  for (int i = 0; i < count; ++i) {
+  for (int i = 0; i < iov_count; ++i) {
     write_length += iov[i].iov_len;
   }
   QuicConsumedData consumed_data =
-      session()->WritevData(id(), iov, count, stream_bytes_written_, fin);
+      session()->WritevData(id(), iov, iov_count, stream_bytes_written_, fin);
   stream_bytes_written_ += consumed_data.bytes_consumed;
   if (consumed_data.bytes_consumed == write_length) {
     if (fin && consumed_data.fin_consumed) {
       fin_sent_ = true;
       CloseWriteSide();
     } else if (fin && !consumed_data.fin_consumed) {
       session_->MarkWriteBlocked(id(), EffectivePriority());
     }
   } else {
     session_->MarkWriteBlocked(id(), EffectivePriority());
@@ skipping 12 matching lines @@
   DLOG(INFO) << "Done reading from stream " << id();
 
   read_side_closed_ = true;
   if (write_side_closed_) {
     DLOG(INFO) << "Closing stream: " << id();
     session_->CloseStream(id());
   }
 }
 
 uint32 ReliableQuicStream::ProcessRawData(const char* data, uint32 data_len) {
+  DCHECK_NE(0u, data_len);
   if (id() == kCryptoStreamId) {
-    if (data_len == 0) {
-      return 0;
-    }
     // The crypto stream does not use compression.
     return ProcessData(data, data_len);
   }
 
   uint32 total_bytes_consumed = 0;
   if (headers_id_ == 0u) {
     total_bytes_consumed += StripPriorityAndHeaderId(data, data_len);
     data += total_bytes_consumed;
     data_len -= total_bytes_consumed;
     if (data_len == 0 || !session_->connection()->connected()) {
@@ skipping 197 matching lines @@
   if (data_len > 0 && headers_id_ == 0u) {
     // The headers ID has not yet been read.  Strip it from the beginning of
     // the data stream.
     total_bytes_parsed += StripUint32(
         data, data_len, &headers_id_and_priority_buffer_, &headers_id_);
   }
   return total_bytes_parsed;
 }
 
 }  // namespace net