Remove FEC code from receive path.

net/quic/test_tools/simple_quic_framer.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/test_tools/simple_quic_framer.h"
 
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
@@ skipping 19 matching lines @@
   bool OnProtocolVersionMismatch(QuicVersion version) override { return false; }
 
   void OnPacket() override {}
   void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) override {
     version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
   }
-  void OnRevivedPacket() override {}
 
   bool OnUnauthenticatedPublicHeader(
       const QuicPacketPublicHeader& header) override {
     return true;
   }
   bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override {
     return true;
   }
   void OnDecryptedPacket(EncryptionLevel level) override {}
   bool OnPacketHeader(const QuicPacketHeader& header) override {
     has_header_ = true;
     header_ = header;
     return true;
   }
 
-  void OnFecProtectedPayload(StringPiece payload) override {}
-
   bool OnStreamFrame(const QuicStreamFrame& frame) override {
     // Save a copy of the data so it is valid after the packet is processed.
     string* string_data = new string();
     StringPiece(frame.frame_buffer, frame.frame_length)
         .AppendToString(string_data);
     stream_data_.push_back(string_data);
     // TODO(ianswett): A pointer isn't necessary with emplace_back.
     stream_frames_.push_back(new QuicStreamFrame(
         frame.stream_id, frame.fin, frame.offset, StringPiece(*string_data)));
     return true;
   }
 
   bool OnAckFrame(const QuicAckFrame& frame) override {
     ack_frames_.push_back(frame);
     return true;
   }
 
   bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
     stop_waiting_frames_.push_back(frame);
     return true;
   }
 
   bool OnPingFrame(const QuicPingFrame& frame) override {
     ping_frames_.push_back(frame);
     return true;
   }
 
-  void OnFecData(StringPiece redundancy) override {
-    fec_redundancy_ = redundancy.as_string();
-  }
-
   bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
     rst_stream_frames_.push_back(frame);
     return true;
   }
 
   bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override {
     connection_close_frames_.push_back(frame);
     return true;
   }
 
@@ skipping 30 matching lines @@
   const vector<QuicRstStreamFrame>& rst_stream_frames() const {
     return rst_stream_frames_;
   }
   const vector<QuicStreamFrame*>& stream_frames() const {
     return stream_frames_;
   }
   const vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
     return stop_waiting_frames_;
   }
   const vector<QuicPingFrame>& ping_frames() const { return ping_frames_; }
-  StringPiece fec_data() const { return fec_redundancy_; }
   const QuicVersionNegotiationPacket* version_negotiation_packet() const {
     return version_negotiation_packet_.get();
   }
 
  private:
   QuicErrorCode error_;
   bool has_header_;
   QuicPacketHeader header_;
   scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
   scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
-  string fec_redundancy_;
   vector<QuicAckFrame> ack_frames_;
   vector<QuicStopWaitingFrame> stop_waiting_frames_;
   vector<QuicPingFrame> ping_frames_;
   vector<QuicStreamFrame*> stream_frames_;
   vector<QuicRstStreamFrame> rst_stream_frames_;
   vector<QuicGoAwayFrame> goaway_frames_;
   vector<QuicConnectionCloseFrame> connection_close_frames_;
   vector<QuicWindowUpdateFrame> window_update_frames_;
   vector<QuicBlockedFrame> blocked_frames_;
   vector<QuicPathCloseFrame> path_close_frames_;
@@ skipping 19 matching lines @@
 }
 
 void SimpleQuicFramer::Reset() {
   visitor_.reset(new SimpleFramerVisitor);
 }
 
 const QuicPacketHeader& SimpleQuicFramer::header() const {
   return visitor_->header();
 }
 
-StringPiece SimpleQuicFramer::fec_data() const {
-  return visitor_->fec_data();
-}
-
 const QuicVersionNegotiationPacket*
 SimpleQuicFramer::version_negotiation_packet() const {
   return visitor_->version_negotiation_packet();
 }
 
 QuicFramer* SimpleQuicFramer::framer() {
   return &framer_;
 }
 
 size_t SimpleQuicFramer::num_frames() const {
@@ skipping 28 matching lines @@
   return visitor_->goaway_frames();
 }
 
 const vector<QuicConnectionCloseFrame>&
 SimpleQuicFramer::connection_close_frames() const {
   return visitor_->connection_close_frames();
 }
 
 }  // namespace test
 }  // namespace net