Remove FixRate congestion frame type.

net/quic/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/quic_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 1468 matching lines @@
             return false;
           }
           QuicPacketSequenceNumber packet = smallest_received + sequence_delta;
           inter_arrival->received_packet_times.insert(
               make_pair(packet, time_received.Add(
                   QuicTime::Delta::FromMicroseconds(time_delta_us))));
         }
       }
       break;
     }
-    case kFixRate: {
-      uint32 bitrate = 0;
-      if (!reader_->ReadUInt32(&bitrate)) {
-        set_detailed_error("Unable to read bitrate.");
-        return false;
-      }
-      frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(bitrate);
-      break;
-    }
     case kTCP: {
       CongestionFeedbackMessageTCP* tcp = &frame->tcp;
       // TODO(ianswett): Remove receive window, since it's constant.
       uint16 receive_window = 0;
       if (!reader_->ReadUInt16(&receive_window)) {
         set_detailed_error("Unable to read receive window.");
         return false;
       }
       // Simple bit packing, don't send the 4 least significant bits.
       tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4;
@@ skipping 316 matching lines @@
           len += 1;  // Number received packets.
           if (inter_arrival.received_packet_times.size() > 0) {
             len += PACKET_6BYTE_SEQUENCE_NUMBER;  // Smallest received.
             len += 8;  // Time.
             // 2 bytes per sequence number delta plus 4 bytes per delta time.
             len += PACKET_6BYTE_SEQUENCE_NUMBER *
                 (inter_arrival.received_packet_times.size() - 1);
           }
           break;
         }
-        case kFixRate:
-          len += 4;  // Bitrate.
-          break;
         case kTCP:
           len += 2;  // Receive window.
           break;
         default:
           set_detailed_error("Illegal feedback type.");
           DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type;
           break;
       }
       return len;
     }
@@ skipping 328 matching lines @@
 
           int32 time_delta_us =
               it->second.Subtract(lowest_time).ToMicroseconds();
           if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
             return false;
           }
         }
       }
       break;
     }
-    case kFixRate: {
-      const CongestionFeedbackMessageFixRate& fix_rate =
-          frame.fix_rate;
-      if (!writer->WriteUInt32(fix_rate.bitrate.ToBytesPerSecond())) {
-        return false;
-      }
-      break;
-    }
     case kTCP: {
       const CongestionFeedbackMessageTCP& tcp = frame.tcp;
       DCHECK_LE(tcp.receive_window, 1u << 20);
       // Simple bit packing, don't send the 4 least significant bits.
       uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4);
       if (!writer->WriteUInt16(receive_window)) {
         return false;
       }
       break;
     }
@@ skipping 109 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net