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 "base/logging.h"
 #include "net/quic/iovector.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_session.h"
@@ skipping 106 matching lines @@
       stream_bytes_written_(0),
       stream_error_(QUIC_STREAM_NO_ERROR),
       connection_error_(QUIC_NO_ERROR),
       read_side_closed_(false),
       write_side_closed_(false),
       fin_buffered_(false),
       fin_sent_(false),
       fin_received_(false),
       rst_sent_(false),
       rst_received_(false),
+      fec_policy_(FEC_PROTECT_OPTIONAL),
       is_server_(session_->is_server()),
       flow_controller_(
           session_->connection(),
           id_,
           is_server_,
           session_->config()->HasReceivedInitialFlowControlWindowBytes() ?
               session_->config()->ReceivedInitialFlowControlWindowBytes() :
               kDefaultFlowControlSendWindow,
-          session_->max_flow_control_receive_window_bytes(),
-          session_->max_flow_control_receive_window_bytes()),
+          session_->config()->GetInitialFlowControlWindowToSend(),
+          session_->config()->GetInitialFlowControlWindowToSend()),
       connection_flow_controller_(session_->flow_controller()) {
 }
 
 ReliableQuicStream::~ReliableQuicStream() {
 }
 
 bool ReliableQuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
   if (read_side_closed_) {
     DVLOG(1) << ENDPOINT << "Ignoring frame " << frame.stream_id;
     // We don't want to be reading: blackhole the data.
@@ skipping 206 matching lines @@
 
       // Writing more data would be a violation of flow control.
       write_length = send_window;
     }
   }
 
   // Fill an IOVector with bytes from the iovec.
   IOVector data;
   data.AppendIovecAtMostBytes(iov, iov_count, write_length);
 
-  // TODO(jri): Use the correct FecProtection based on FecPolicy on stream.
   QuicConsumedData consumed_data = session()->WritevData(
-      id(), data, stream_bytes_written_, fin, MAY_FEC_PROTECT,
+      id(), data, stream_bytes_written_, fin, GetFecProtection(),
       ack_notifier_delegate);
   stream_bytes_written_ += consumed_data.bytes_consumed;
 
   AddBytesSent(consumed_data.bytes_consumed);
 
   if (consumed_data.bytes_consumed == write_length) {
     if (!fin_with_zero_data) {
       MaybeSendBlocked();
     }
     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());
   }
   return consumed_data;
 }
 
+FecProtection ReliableQuicStream::GetFecProtection() {
+  return fec_policy_ == FEC_PROTECT_ALWAYS ? MUST_FEC_PROTECT : MAY_FEC_PROTECT;
+}
+
 void ReliableQuicStream::CloseReadSide() {
   if (read_side_closed_) {
     return;
   }
   DVLOG(1) << ENDPOINT << "Done reading from stream " << id();
 
   read_side_closed_ = true;
   if (write_side_closed_) {
     DVLOG(1) << ENDPOINT << "Closing stream: " << id();
     session_->CloseStream(id());
@@ skipping 91 matching lines @@
     connection_flow_controller_->AddBytesConsumed(bytes);
   }
 }
 
 bool ReliableQuicStream::IsFlowControlBlocked() {
   return flow_controller_.IsBlocked() ||
          connection_flow_controller_->IsBlocked();
 }
 
 }  // namespace net