Added FEC policy per stream, which is translated to an FEC protection

net/tools/quic/test_tools/quic_test_client.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/tools/quic/test_tools/quic_test_client.h"
 
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/x509_certificate.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_server_id.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
+#include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
+#include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/tools/balsa/balsa_headers.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_packet_writer_wrapper.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/http_message.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "url/gurl.h"
 
 using base::StringPiece;
 using net::QuicServerId;
+using net::test::QuicConnectionPeer;
+using net::test::QuicSessionPeer;
+using net::test::ReliableQuicStreamPeer;
 using net::test::kInitialFlowControlWindowForTest;
-using net::test::QuicConnectionPeer;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
 namespace test {
 namespace {
 
 // RecordingProofVerifier accepts any certificate chain and records the common
 // name of the leaf.
@@ skipping 163 matching lines @@
     stream_->set_visitor(NULL);
   }
 }
 
 void QuicTestClient::Initialize(bool secure) {
   priority_ = 3;
   connect_attempted_ = false;
   secure_ = secure;
   auto_reconnect_ = false;
   buffer_body_ = true;
+  fec_policy_ = PROTECT_OPTIONAL;
   proof_verifier_ = NULL;
   ClearPerRequestState();
   ExpectCertificates(secure_);
 }
 
 void QuicTestClient::ExpectCertificates(bool on) {
   if (on) {
     proof_verifier_ = new RecordingProofVerifier;
     client_->SetProofVerifier(proof_verifier_);
   } else {
@@ skipping 98 matching lines @@
       return NULL;
     }
   }
   if (!stream_) {
     stream_ = client_->CreateReliableClientStream();
     if (stream_ == NULL) {
       return NULL;
     }
     stream_->set_visitor(this);
     reinterpret_cast<QuicSpdyClientStream*>(stream_)->set_priority(priority_);
+    // Set FEC policy on stream.
+    ReliableQuicStreamPeer::SetFecPolicy(stream_, fec_policy_);
   }
 
   return stream_;
 }
 
 QuicErrorCode QuicTestClient::connection_error() {
   return client()->session()->error();
 }
 
 MockableQuicClient* QuicTestClient::client() { return client_.get(); }
@@ skipping 192 matching lines @@
   LOG(DFATAL) << "Not implemented";
   return 0;
 }
 
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
+void QuicTestClient::SetFecPolicy(FecPolicy fec_policy) {
+  fec_policy_ = fec_policy;
+  // Set policy for headers and crypto streams.
+  ReliableQuicStreamPeer::SetFecPolicy(
+      QuicSessionPeer::GetHeadersStream(client()->session()), fec_policy);
+  ReliableQuicStreamPeer::SetFecPolicy(client()->session()->GetCryptoStream(),
+                                       fec_policy);
+}
+
 }  // namespace test
 }  // namespace tools
 }  // namespace net