Revert 204046 "Land Recent QUIC changes."

> Land Recent QUIC changes.
> 
> Merge internal change: 47341065
> 
> Fix to ensure the version matches before declaring that the public header
> flags exceed the max value. b/9190456
> 
> Merge internal change: 47324563
> 
> Fixing another backup bug (exposed by the last fix) that if we failed to
> write a standalone fin the stream would not be marked as write blocked.
> 
> Merge internal change: 47272116
> 
> Don't add QuicStreams to ActiveSessionList; Instead call DumpSession on
> alive streams via QuicSession.
> 
> Merge internal change: 47226512
> 
> Making the packet sequence number variable length to minimize bytes on the wire.
> 
> Merge internal change: 47220850
> 
> Fixing a bug in quic stream where we'd send rst stream packets for
> successful streams. The fin bit should be sufficient for both good
> request/response pairs and early response pairs.
> 
> Merge internal change: 47086343
> 
> Don't let FEC packets consume congestion window forever. If a FEC packet
> is not acked after a certain time, it is cleared from the congestion
> window. This timeout is higher than normal RTO.
> 
> Merge internal change: 47056082
> 
> Add QuicSession to ActiveSessionList.
> 
> Merge internal change: 47048300
> 
> Fixing a backup/resumption bug in QUIC.
> 
> It's possible to have a full congestion window worth of packets on the wire.
> 
> If we are in this state and a session tries to SendStreamData, the
> QuicPacketGenerator short-circuits without queuing packets because it checks
> to see if the connection CanWrite.
> 
> When we get an ack, we check to see if we have locally queued packets, but
> never call OnCanWrite on the session to clear any streams which write blocked
> without queueing packets.
> 
> Merge internal change: 47000173
> 
> QUIC: wire up the server-nonce parameters to the server config.
> 
> Merge internal change: 46985067
> 
> R=rch@chromium.org
> 
> Review URL: https://codereview.chromium.org/16256017

TBR=rtenneti@chromium.org

Review URL: https://codereview.chromium.org/16374004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@204062 0039d316-1c4b-4281-b951-d872f2087c98

25 files changed, 405 insertions, 1188 deletions

diff --git a/net/quic/congestion_control/quic_congestion_manager.cc b/net/quic/congestion_control/quic_congestion_manager.cc
index a6bd0a8..d40293c 100644
--- a/net/quic/congestion_control/quic_congestion_manager.cc
+++ b/net/quic/congestion_control/quic_congestion_manager.cc
@@ -62,7 +62,6 @@ void QuicCongestionManager::AbandoningPacket(
     QuicPacketSequenceNumber sequence_number) {
   PendingPacketsMap::iterator it = pending_packets_.find(sequence_number);
   if (it != pending_packets_.end()) {
-    // Shouldn't this report loss as well? (decrease cgst window).
     send_algorithm_->AbandoningPacket(sequence_number, it->second);
     pending_packets_.erase(it);
   }
diff --git a/net/quic/crypto/crypto_server_config.cc b/net/quic/crypto/crypto_server_config.cc
index 8f3c980..aa30e67 100644
--- a/net/quic/crypto/crypto_server_config.cc
+++ b/net/quic/crypto/crypto_server_config.cc
@@ -631,18 +631,6 @@ void QuicCryptoServerConfig::set_source_address_token_lifetime_secs(
   source_address_token_lifetime_secs_ = lifetime_secs;
 }
 
-void QuicCryptoServerConfig::set_server_nonce_strike_register_max_entries(
-    uint32 max_entries) {
-  DCHECK(!server_nonce_strike_register_.get());
-  server_nonce_strike_register_max_entries_ = max_entries;
-}
-
-void QuicCryptoServerConfig::set_server_nonce_strike_register_window_secs(
-    uint32 window_secs) {
-  DCHECK(!server_nonce_strike_register_.get());
-  server_nonce_strike_register_window_secs_ = window_secs;
-}
-
 string QuicCryptoServerConfig::NewSourceAddressToken(
     const IPEndPoint& ip,
     QuicRandom* rand,
diff --git a/net/quic/crypto/crypto_server_config.h b/net/quic/crypto/crypto_server_config.h
index a37c914..7799fdd 100644
--- a/net/quic/crypto/crypto_server_config.h
+++ b/net/quic/crypto/crypto_server_config.h
@@ -140,21 +140,6 @@ class NET_EXPORT_PRIVATE QuicCryptoServerConfig {
   // source-address token will be valid for.
   void set_source_address_token_lifetime_secs(uint32 lifetime_secs);
 
-  // set_server_nonce_strike_register_max_entries sets the number of entries in
-  // the server-nonce strike-register. This is used to record that server nonce
-  // values have been used. If the number of entries is too small then clients
-  // which are depending on server nonces may fail to handshake because their
-  // nonce has expired in the amount of time it took to go from the server to
-  // the client and back.
-  void set_server_nonce_strike_register_max_entries(uint32 max_entries);
-
-  // set_server_nonce_strike_register_window_secs sets the number of seconds
-  // around the current time that the server-nonce strike-register will accept
-  // nonces from. Setting a larger value allows for clients to delay follow-up
-  // client hellos for longer and still use server nonces as proofs of
-  // uniqueness.
-  void set_server_nonce_strike_register_window_secs(uint32 window_secs);
-
  private:
   friend class test::QuicCryptoServerConfigPeer;
 
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index e630473..0698dd3 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -125,7 +125,7 @@ QuicConnection::~QuicConnection() {
        it != queued_packets_.end(); ++it) {
     delete it->packet;
   }
-  DLOG(INFO) << ENDPOINT << "write_blocked: " << write_blocked_;
+  LOG(ERROR) << "Quic connection " << write_blocked_;
 }
 
 bool QuicConnection::SelectMutualVersion(
@@ -242,7 +242,6 @@ void QuicConnection::OnVersionNegotiationPacket(
   if (!SelectMutualVersion(packet.versions)) {
     SendConnectionCloseWithDetails(QUIC_INVALID_VERSION,
                                    "no common version found");
-    return;
   }
 
   version_negotiation_state_ = NEGOTIATED_VERSION;
@@ -362,18 +361,19 @@ bool QuicConnection::OnAckFrame(const QuicAckFrame& incoming_ack) {
   congestion_manager_.OnIncomingAckFrame(incoming_ack,
                                          time_of_last_received_packet_);
 
-  // Now the we have received an ack, we might be able to send packets which are
-  // queued locally, or drain streams which are blocked.
-  QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
-      time_of_last_received_packet_, NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA);
-  if (delay.IsZero()) {
-    helper_->UnregisterSendAlarmIfRegistered();
-    if (!write_blocked_) {
-      OnCanWrite();
+  // Now the we have received an ack, we might be able to send queued packets.
+  if (!queued_packets_.empty()) {
+    QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
+        time_of_last_received_packet_, NOT_RETRANSMISSION,
+        HAS_RETRANSMITTABLE_DATA);
+    if (delay.IsZero()) {
+      helper_->UnregisterSendAlarmIfRegistered();
+      if (!write_blocked_) {
+        OnCanWrite();
+      }
+    } else if (!delay.IsInfinite()) {
+      helper_->SetSendAlarm(time_of_last_received_packet_.Add(delay));
     }
-  } else if (!delay.IsInfinite()) {
-    helper_->SetSendAlarm(time_of_last_received_packet_.Add(delay));
   }
   return connected_;
 }
@@ -461,8 +461,24 @@ bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
   return true;
 }
 
-void QuicConnection::HandleAckForSentPackets(const QuicAckFrame& incoming_ack,
-                                             SequenceNumberSet* acked_packets) {
+void QuicConnection::UpdatePacketInformationReceivedByPeer(
+    const QuicAckFrame& incoming_ack) {
+  SequenceNumberSet acked_packets;
+
+  // ValidateAck should fail if largest_observed ever shrinks.
+  DCHECK_LE(peer_largest_observed_packet_,
+            incoming_ack.received_info.largest_observed);
+  peer_largest_observed_packet_ = incoming_ack.received_info.largest_observed;
+
+  if (incoming_ack.received_info.missing_packets.empty()) {
+    least_packet_awaited_by_peer_ = peer_largest_observed_packet_ + 1;
+  } else {
+    least_packet_awaited_by_peer_ =
+        *(incoming_ack.received_info.missing_packets.begin());
+  }
+
+  entropy_manager_.ClearSentEntropyBefore(least_packet_awaited_by_peer_ - 1);
+
   int retransmitted_packets = 0;
   // Go through the packets we have not received an ack for and see if this
   // incoming_ack shows they've been seen by the peer.
@@ -476,9 +492,11 @@ void QuicConnection::HandleAckForSentPackets(const QuicAckFrame& incoming_ack,
     if (!IsAwaitingPacket(incoming_ack.received_info, sequence_number)) {
       // Packet was acked, so remove it from our unacked packet list.
       DVLOG(1) << ENDPOINT <<"Got an ack for packet " << sequence_number;
-      acked_packets->insert(sequence_number);
+      acked_packets.insert(sequence_number);
       delete unacked;
-      unacked_packets_.erase(it++);
+      UnackedPacketMap::iterator it_tmp = it;
+      ++it;
+      unacked_packets_.erase(it_tmp);
       retransmission_map_.erase(sequence_number);
     } else {
       // This is a packet which we planned on retransmitting and has not been
@@ -504,48 +522,6 @@ void QuicConnection::HandleAckForSentPackets(const QuicAckFrame& incoming_ack,
       }
     }
   }
-}
-
-void QuicConnection::HandleAckForSentFecPackets(
-    const QuicAckFrame& incoming_ack, SequenceNumberSet* acked_packets) {
-  UnackedPacketMap::iterator it = unacked_fec_packets_.begin();
-  while (it != unacked_fec_packets_.end()) {
-    QuicPacketSequenceNumber sequence_number = it->first;
-    if (sequence_number > peer_largest_observed_packet_) {
-      break;
-    }
-    if (!IsAwaitingPacket(incoming_ack.received_info, sequence_number)) {
-      DVLOG(1) << ENDPOINT << "Got an ack for fec packet: " << sequence_number;
-      acked_packets->insert(sequence_number);
-      unacked_fec_packets_.erase(it++);
-    } else {
-      DVLOG(1) << ENDPOINT << "Still missing ack for fec packet: "
-               << sequence_number;
-      ++it;
-    }
-  }
-}
-
-void QuicConnection::UpdatePacketInformationReceivedByPeer(
-    const QuicAckFrame& incoming_ack) {
-  // ValidateAck should fail if largest_observed ever shrinks.
-  DCHECK_LE(peer_largest_observed_packet_,
-            incoming_ack.received_info.largest_observed);
-  peer_largest_observed_packet_ = incoming_ack.received_info.largest_observed;
-
-  if (incoming_ack.received_info.missing_packets.empty()) {
-    least_packet_awaited_by_peer_ = peer_largest_observed_packet_ + 1;
-  } else {
-    least_packet_awaited_by_peer_ =
-        *(incoming_ack.received_info.missing_packets.begin());
-  }
-
-  entropy_manager_.ClearSentEntropyBefore(least_packet_awaited_by_peer_ - 1);
-
-  SequenceNumberSet acked_packets;
-  HandleAckForSentPackets(incoming_ack, &acked_packets);
-  HandleAckForSentFecPackets(incoming_ack, &acked_packets);
-
   if (acked_packets.size() > 0) {
     visitor_->OnAck(acked_packets);
   }
@@ -984,7 +960,7 @@ bool QuicConnection::IsRetransmission(
       it->second.number_retransmissions > 0;
 }
 
-void QuicConnection::SetupRetransmission(
+void QuicConnection::MaybeSetupRetransmission(
     QuicPacketSequenceNumber sequence_number) {
   RetransmissionMap::iterator it = retransmission_map_.find(sequence_number);
   if (it == retransmission_map_.end()) {
@@ -997,11 +973,9 @@ void QuicConnection::SetupRetransmission(
       congestion_manager_.GetRetransmissionDelay(
           unacked_packets_.size(),
           retransmission_info.number_retransmissions);
-
-  retransmission_timeouts_.push(RetransmissionTime(
-      sequence_number,
-      clock_->ApproximateNow().Add(retransmission_delay),
-      false));
+  retransmission_info.scheduled_time =
+      clock_->ApproximateNow().Add(retransmission_delay);
+  retransmission_timeouts_.push(retransmission_info);
 
   // Do not set the retransmisson alarm if we're already handling the
   // retransmission alarm because the retransmission alarm will be reset when
@@ -1013,18 +987,6 @@ void QuicConnection::SetupRetransmission(
   // SendStreamData().
 }
 
-void QuicConnection::SetupAbandonFecTimer(
-    QuicPacketSequenceNumber sequence_number) {
-  DCHECK(ContainsKey(unacked_fec_packets_, sequence_number));
-  QuicTime::Delta retransmission_delay =
-      QuicTime::Delta::FromMilliseconds(
-          congestion_manager_.DefaultRetransmissionTime().ToMilliseconds() * 3);
-  retransmission_timeouts_.push(RetransmissionTime(
-      sequence_number,
-      clock_->ApproximateNow().Add(retransmission_delay),
-      true));
-}
-
 void QuicConnection::DropPacket(QuicPacketSequenceNumber sequence_number) {
   UnackedPacketMap::iterator unacked_it =
       unacked_packets_.find(sequence_number);
@@ -1115,11 +1077,7 @@ bool QuicConnection::WritePacket(EncryptionLevel level,
   // Set the retransmit alarm only when we have sent the packet to the client
   // and not when it goes to the pending queue, otherwise we will end up adding
   // an entry to retransmission_timeout_ every time we attempt a write.
-  if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
-    SetupRetransmission(sequence_number);
-  } else if (packet->is_fec_packet()) {
-    SetupAbandonFecTimer(sequence_number);
-  }
+  MaybeSetupRetransmission(sequence_number);
 
   congestion_manager_.SentPacket(sequence_number, now, packet->length(),
                                  retransmission);
@@ -1153,10 +1111,6 @@ bool QuicConnection::OnSerializedPacket(
     retransmission_map_.insert(
         make_pair(serialized_packet.sequence_number,
                   RetransmissionInfo(serialized_packet.sequence_number)));
-  } else if (serialized_packet.packet->is_fec_packet()) {
-    unacked_fec_packets_.insert(make_pair(
-        serialized_packet.sequence_number,
-        serialized_packet.retransmittable_frames));
   }
   return SendOrQueuePacket(encryption_level_,
                            serialized_packet.sequence_number,
@@ -1226,17 +1180,6 @@ void QuicConnection::SendAck() {
   packet_generator_.SetShouldSendAck(send_feedback);
 }
 
-void QuicConnection::MaybeAbandonFecPacket(
-    QuicPacketSequenceNumber sequence_number) {
-  if (!ContainsKey(unacked_fec_packets_, sequence_number)) {
-    DVLOG(2) << ENDPOINT << "no need to abandon fec packet: "
-             << sequence_number << "; it's already acked'";
-    return;
-  }
-  congestion_manager_.AbandoningPacket(sequence_number);
-  // TODO(satyashekhar): Should this decrease the congestion window?
-}
-
 QuicTime QuicConnection::OnRetransmissionTimeout() {
   // This guards against registering the alarm later than we should.
   //
@@ -1249,24 +1192,19 @@ QuicTime QuicConnection::OnRetransmissionTimeout() {
 
   for (size_t i = 0; i < max_packets_per_retransmission_alarm_ &&
            !retransmission_timeouts_.empty(); ++i) {
-    RetransmissionTime retransmission_time = retransmission_timeouts_.top();
-    DCHECK(retransmission_time.scheduled_time.IsInitialized());
-    if (retransmission_time.scheduled_time > clock_->ApproximateNow()) {
+    RetransmissionInfo retransmission_info = retransmission_timeouts_.top();
+    DCHECK(retransmission_info.scheduled_time.IsInitialized());
+    if (retransmission_info.scheduled_time > clock_->ApproximateNow()) {
       break;
     }
     retransmission_timeouts_.pop();
-
-    if (retransmission_time.for_fec) {
-      MaybeAbandonFecPacket(retransmission_time.sequence_number);
-      continue;
-    } else if (
-        !MaybeRetransmitPacketForRTO(retransmission_time.sequence_number)) {
+    if (!MaybeRetransmitPacketForRTO(retransmission_info.sequence_number)) {
       DLOG(INFO) << ENDPOINT << "MaybeRetransmitPacketForRTO failed: "
                  << "adding an extra delay for "
-                 << retransmission_time.sequence_number;
-      retransmission_time.scheduled_time = clock_->ApproximateNow().Add(
+                 << retransmission_info.sequence_number;
+      retransmission_info.scheduled_time = clock_->ApproximateNow().Add(
           congestion_manager_.DefaultRetransmissionTime());
-      retransmission_timeouts_.push(retransmission_time);
+      retransmission_timeouts_.push(retransmission_info);
     }
   }
 
@@ -1439,21 +1377,21 @@ bool QuicConnection::HasQueuedData() const {
 }
 
 void QuicConnection::SetIdleNetworkTimeout(QuicTime::Delta timeout) {
-  if (timeout < idle_network_timeout_) {
+  // if (timeout < idle_network_timeout_) {
     idle_network_timeout_ = timeout;
     CheckForTimeout();
-  } else {
-     idle_network_timeout_ = timeout;
-  }
+  // } else {
+  //   idle_network_timeout_ = timeout;
+  // }
 }
 
 void QuicConnection::SetOverallConnectionTimeout(QuicTime::Delta timeout) {
-  if (timeout < overall_connection_timeout_) {
+  // if (timeout < overall_connection_timeout_) {
     overall_connection_timeout_ = timeout;
     CheckForTimeout();
-  } else {
-    overall_connection_timeout_ = timeout;
-  }
+  // } else {
+  //   overall_connection_timeout_ = timeout;
+  // }
 }
 
 bool QuicConnection::CheckForTimeout() {
@@ -1461,9 +1399,6 @@ bool QuicConnection::CheckForTimeout() {
   QuicTime time_of_last_packet = std::max(time_of_last_received_packet_,
                                           time_of_last_sent_packet_);
 
-  // |delta| can be < 0 as |now| is approximate time but |time_of_last_packet|
-  // is accurate time. However, this should not change the behavior of
-  // timeout handling.
   QuicTime::Delta delta = now.Subtract(time_of_last_packet);
   DVLOG(1) << ENDPOINT << "last packet "
            << time_of_last_packet.ToDebuggingValue()
diff --git a/net/quic/quic_connection.h b/net/quic/quic_connection.h
index 2aac2409..c37d9ad 100644
--- a/net/quic/quic_connection.h
+++ b/net/quic/quic_connection.h
@@ -431,6 +431,15 @@ class NET_EXPORT_PRIVATE QuicConnection
   // Make sure an ack we got from our peer is sane.
   bool ValidateAckFrame(const QuicAckFrame& incoming_ack);
 
+  // These two are called by OnAckFrame to update the appropriate internal
+  // state.
+  //
+  // Updates internal state based on incoming_ack.received_info
+  void UpdatePacketInformationReceivedByPeer(
+      const QuicAckFrame& incoming_ack);
+  // Updates internal state based in incoming_ack.sent_info
+  void UpdatePacketInformationSentByPeer(const QuicAckFrame& incoming_ack);
+
   QuicConnectionHelperInterface* helper() { return helper_.get(); }
 
  protected:
@@ -461,32 +470,21 @@ class NET_EXPORT_PRIVATE QuicConnection
   struct RetransmissionInfo {
     explicit RetransmissionInfo(QuicPacketSequenceNumber sequence_number)
         : sequence_number(sequence_number),
+          scheduled_time(QuicTime::Zero()),
           number_nacks(0),
           number_retransmissions(0) {
     }
 
     QuicPacketSequenceNumber sequence_number;
+    QuicTime scheduled_time;
     size_t number_nacks;
     size_t number_retransmissions;
   };
 
-  struct RetransmissionTime {
-    RetransmissionTime(QuicPacketSequenceNumber sequence_number,
-                       const QuicTime& scheduled_time,
-                       bool for_fec)
-        : sequence_number(sequence_number),
-          scheduled_time(scheduled_time),
-          for_fec(for_fec) { }
-
-    QuicPacketSequenceNumber sequence_number;
-    QuicTime scheduled_time;
-    bool for_fec;
-  };
-
-  class RetransmissionTimeComparator {
+  class RetransmissionInfoComparator {
    public:
-    bool operator()(const RetransmissionTime& lhs,
-                    const RetransmissionTime& rhs) const {
+    bool operator()(const RetransmissionInfo& lhs,
+                    const RetransmissionInfo& rhs) const {
       DCHECK(lhs.scheduled_time.IsInitialized() &&
              rhs.scheduled_time.IsInitialized());
       return lhs.scheduled_time > rhs.scheduled_time;
@@ -499,9 +497,9 @@ class NET_EXPORT_PRIVATE QuicConnection
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
   typedef base::hash_map<QuicPacketSequenceNumber,
                          RetransmissionInfo> RetransmissionMap;
-  typedef std::priority_queue<RetransmissionTime,
-                              std::vector<RetransmissionTime>,
-                              RetransmissionTimeComparator>
+  typedef std::priority_queue<RetransmissionInfo,
+                              std::vector<RetransmissionInfo>,
+                              RetransmissionInfoComparator>
       RetransmissionTimeouts;
 
   // Selects and updates the version of the protocol being used by selecting a
@@ -511,11 +509,9 @@ class NET_EXPORT_PRIVATE QuicConnection
   // Sends a version negotiation packet to the peer.
   void SendVersionNegotiationPacket();
 
-  void SetupRetransmission(QuicPacketSequenceNumber sequence_number);
+  void MaybeSetupRetransmission(QuicPacketSequenceNumber sequence_number);
   bool IsRetransmission(QuicPacketSequenceNumber sequence_number);
 
-  void SetupAbandonFecTimer(QuicPacketSequenceNumber sequence_number);
-
   // Drop packet corresponding to |sequence_number| by deleting entries from
   // |unacked_packets_| and |retransmission_map_|, if present. We need to drop
   // all packets with encryption level NONE after the default level has been set
@@ -530,25 +526,10 @@ class NET_EXPORT_PRIVATE QuicConnection
   // revive and process the packet.
   void MaybeProcessRevivedPacket();
 
-  void HandleAckForSentPackets(const QuicAckFrame& incoming_ack,
-                               SequenceNumberSet* acked_packets);
-  void HandleAckForSentFecPackets(const QuicAckFrame& incoming_ack,
-                                  SequenceNumberSet* acked_packets);
-
-  // These two are called by OnAckFrame.
-  //
-  // Updates internal state based on incoming_ack.received_info
-  void UpdatePacketInformationReceivedByPeer(
-      const QuicAckFrame& incoming_ack);
-  // Updates internal state based on incoming_ack.sent_info
-  void UpdatePacketInformationSentByPeer(const QuicAckFrame& incoming_ack);
-
   void UpdateOutgoingAck();
 
   void MaybeSendAckInResponseToPacket();
 
-  void MaybeAbandonFecPacket(QuicPacketSequenceNumber sequence_number);
-
   // Get the FEC group associate with the last processed packet or NULL, if the
   // group has already been deleted.
   QuicFecGroup* GetFecGroup();
@@ -591,12 +572,6 @@ class NET_EXPORT_PRIVATE QuicConnection
   // to this map, which contains owning pointers to the contained frames.
   UnackedPacketMap unacked_packets_;
 
-  // Pending fec packets that have not been acked yet. These packets need to be
-  // cleared out of the cgst_window after a timeout since FEC packets are never
-  // retransmitted.
-  // Ask: What should be the timeout for these packets?
-  UnackedPacketMap unacked_fec_packets_;
-
   // Heap of packets that we might need to retransmit, and the time at
   // which we should retransmit them. Every time a packet is sent it is added
   // to this heap which is O(log(number of pending packets to be retransmitted))
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index 6d982ce..597664d 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -501,7 +501,6 @@ class QuicConnectionTest : public ::testing::Test {
 
   void ProcessClosePacket(QuicPacketSequenceNumber number,
                           QuicFecGroupNumber fec_group) {
-    EXPECT_CALL(visitor_, OnCanWrite()).Times(1).WillOnce(Return(true));
     scoped_ptr<QuicPacket> packet(ConstructClosePacket(number, fec_group));
     scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
         ENCRYPTION_NONE, number, *packet));
@@ -550,8 +549,7 @@ class QuicConnectionTest : public ::testing::Test {
     if (((number - min_protected_packet) % 2) == 0) {
       for (size_t i = GetStartOfFecProtectedData(
                header_.public_header.guid_length,
-               header_.public_header.version_flag,
-               header_.public_header.sequence_number_length);
+               header_.public_header.version_flag);
            i < data_packet->length(); ++i) {
         data_packet->mutable_data()[i] ^= data_packet->data()[i];
       }
@@ -587,11 +585,7 @@ class QuicConnectionTest : public ::testing::Test {
     EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(AnyNumber());
   }
 
-  QuicPacketEntropyHash ProcessAckPacket(QuicAckFrame* frame,
-                                         bool expect_writes) {
-    if (expect_writes) {
-      EXPECT_CALL(visitor_, OnCanWrite()).Times(1).WillOnce(Return(true));
-    }
+  QuicPacketEntropyHash ProcessAckPacket(QuicAckFrame* frame) {
     return ProcessFramePacket(QuicFrame(frame));
   }
 
@@ -753,7 +747,7 @@ TEST_F(QuicConnectionTest, PacketsOutOfOrderWithAdditionsAndLeastAwaiting) {
   // retransmitted, and will remove it from the missing list.
   creator_.set_sequence_number(5);
   QuicAckFrame frame(0, QuicTime::Zero(), 4);
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
 
   // Force an ack to be sent.
   SendAckPacketToPeer();
@@ -782,7 +776,7 @@ TEST_F(QuicConnectionTest, TruncatedAck) {
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 192) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 191);
 
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
 
   EXPECT_TRUE(QuicConnectionPeer::GetReceivedTruncatedAck(&connection_));
 
@@ -791,7 +785,7 @@ TEST_F(QuicConnectionTest, TruncatedAck) {
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 192) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 190);
 
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
   EXPECT_FALSE(QuicConnectionPeer::GetReceivedTruncatedAck(&connection_));
 }
 
@@ -803,21 +797,21 @@ TEST_F(QuicConnectionTest, LeastUnackedLower) {
   // Start out saying the least unacked is 2
   creator_.set_sequence_number(5);
   QuicAckFrame frame(0, QuicTime::Zero(), 2);
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
 
   // Change it to 1, but lower the sequence number to fake out-of-order packets.
   // This should be fine.
   creator_.set_sequence_number(1);
   QuicAckFrame frame2(0, QuicTime::Zero(), 1);
   // The scheduler will not process out of order acks.
-  ProcessAckPacket(&frame2, false);
+  ProcessAckPacket(&frame2);
 
   // Now claim it's one, but set the ordering so it was sent "after" the first
   // one.  This should cause a connection error.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_INVALID_ACK_DATA, false));
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _));
   creator_.set_sequence_number(7);
-  ProcessAckPacket(&frame2, false);
+  ProcessAckPacket(&frame2);
 }
 
 TEST_F(QuicConnectionTest, LargestObservedLower) {
@@ -831,12 +825,12 @@ TEST_F(QuicConnectionTest, LargestObservedLower) {
   frame.received_info.entropy_hash = QuicConnectionPeer::GetSentEntropyHash(
       &connection_, 2);
   EXPECT_CALL(visitor_, OnAck(_));
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
 
   // Now change it to 1, and it should cause a connection error.
   QuicAckFrame frame2(1, QuicTime::Zero(), 0);
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_INVALID_ACK_DATA, false));
-  ProcessAckPacket(&frame2, false);
+  ProcessAckPacket(&frame2);
 }
 
 TEST_F(QuicConnectionTest, LeastUnackedGreaterThanPacketSequenceNumber) {
@@ -845,7 +839,7 @@ TEST_F(QuicConnectionTest, LeastUnackedGreaterThanPacketSequenceNumber) {
   // Create an ack with least_unacked is 2 in packet number 1.
   creator_.set_sequence_number(0);
   QuicAckFrame frame(0, QuicTime::Zero(), 2);
-  ProcessAckPacket(&frame, false);
+  ProcessAckPacket(&frame);
 }
 
 TEST_F(QuicConnectionTest,
@@ -858,7 +852,7 @@ TEST_F(QuicConnectionTest,
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _));
   QuicAckFrame frame(0, QuicTime::Zero(), 1);
   frame.received_info.missing_packets.insert(3);
-  ProcessAckPacket(&frame, false);
+  ProcessAckPacket(&frame);
 }
 
 TEST_F(QuicConnectionTest, AckUnsentData) {
@@ -866,7 +860,7 @@ TEST_F(QuicConnectionTest, AckUnsentData) {
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_INVALID_ACK_DATA, false));
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _));
   QuicAckFrame frame(1, QuicTime::Zero(), 0);
-  ProcessAckPacket(&frame, false);
+  ProcessAckPacket(&frame);
 }
 
 TEST_F(QuicConnectionTest, AckAll) {
@@ -874,7 +868,7 @@ TEST_F(QuicConnectionTest, AckAll) {
 
   creator_.set_sequence_number(1);
   QuicAckFrame frame1(0, QuicTime::Zero(), 1);
-  ProcessAckPacket(&frame1, true);
+  ProcessAckPacket(&frame1);
 }
 
 TEST_F(QuicConnectionTest, DontWaitForPacketsBefore) {
@@ -909,7 +903,7 @@ TEST_F(QuicConnectionTest, BasicSending) {
   QuicAckFrame frame(3, QuicTime::Zero(), 0);
   frame.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 3);
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
   SendAckPacketToPeer();  // Packet 6
 
   // As soon as we've acked one, we skip ack packets 2 and 3 and note lack of
@@ -924,7 +918,7 @@ TEST_F(QuicConnectionTest, BasicSending) {
   QuicAckFrame frame2(6, QuicTime::Zero(), 0);
   frame2.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 6);
-  ProcessAckPacket(&frame2, true);  // Even parity triggers ack packet 7
+  ProcessAckPacket(&frame2);  // Even parity triggers ack packet 7
 
   // The least packet awaiting ack should now be 7
   EXPECT_EQ(7u, last_ack()->sent_info.least_unacked);
@@ -971,58 +965,6 @@ TEST_F(QuicConnectionTest, FECQueueing) {
   EXPECT_EQ(2u, connection_.NumQueuedPackets());
 }
 
-TEST_F(QuicConnectionTest, AbandonFECFromCongestionWindow) {
-  connection_.options()->max_packets_per_fec_group = 1;
-  // 1 Data and 1 FEC packet.
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(2);
-  connection_.SendStreamData(1, "foo", 0, !kFin);
-
-  // Larger timeout for FEC bytes to expire.
-  const QuicTime::Delta retransmission_time =
-      QuicTime::Delta::FromMilliseconds(5000);
-  clock_.AdvanceTime(retransmission_time);
-
-  // Send only data packet.
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(1);
-  // Abandon both FEC and data packet.
-  EXPECT_CALL(*send_algorithm_, AbandoningPacket(_, _)).Times(2);
-
-  connection_.OnRetransmissionTimeout();
-}
-
-TEST_F(QuicConnectionTest, DontAbandonAckedFEC) {
-  connection_.options()->max_packets_per_fec_group = 1;
-  const QuicPacketSequenceNumber sequence_number =
-      QuicConnectionPeer::GetPacketCreator(&connection_)->sequence_number() + 1;
-
-  // 1 Data and 1 FEC packet.
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(2);
-  connection_.SendStreamData(1, "foo", 0, !kFin);
-
-  QuicAckFrame ack_fec(2, QuicTime::Zero(), 1);
-  // Data packet missing.
-  ack_fec.received_info.missing_packets.insert(1);
-  ack_fec.received_info.entropy_hash =
-      QuicConnectionPeer::GetSentEntropyHash(&connection_, 2) ^
-      QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
-
-  EXPECT_CALL(visitor_, OnAck(_)).Times(1);
-  EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
-  EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
-
-  ProcessAckPacket(&ack_fec, true);
-
-  const QuicTime::Delta kDefaultRetransmissionTime =
-      QuicTime::Delta::FromMilliseconds(5000);
-  clock_.AdvanceTime(kDefaultRetransmissionTime);
-
-  // Abandon only data packet, FEC has been acked.
-  EXPECT_CALL(*send_algorithm_, AbandoningPacket(sequence_number, _)).Times(1);
-  // Send only data packet.
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(1);
-  connection_.OnRetransmissionTimeout();
-}
-
 TEST_F(QuicConnectionTest, FramePacking) {
   // Block the connection.
   helper_->SetSendAlarm(
@@ -1127,9 +1069,9 @@ TEST_F(QuicConnectionTest, RetransmitOnNack) {
   QuicAckFrame ack_one(1, QuicTime::Zero(), 0);
   ack_one.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
-  ProcessAckPacket(&ack_one, true);
-  ProcessAckPacket(&ack_one, true);
-  ProcessAckPacket(&ack_one, true);
+  ProcessAckPacket(&ack_one);
+  ProcessAckPacket(&ack_one);
+  ProcessAckPacket(&ack_one);
 
   expected_acks.clear();
   expected_acks.insert(3);
@@ -1143,14 +1085,14 @@ TEST_F(QuicConnectionTest, RetransmitOnNack) {
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 3) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 2) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
-  ProcessAckPacket(&nack_two, true);
-  ProcessAckPacket(&nack_two, true);
+  ProcessAckPacket(&nack_two);
+  ProcessAckPacket(&nack_two);
 
   // The third nack should trigger a retransimission.
   EXPECT_CALL(*send_algorithm_,
               SentPacket(_, _, second_packet_size - kQuicVersionSize,
                          IS_RETRANSMISSION)).Times(1);
-  ProcessAckPacket(&nack_two, true);
+  ProcessAckPacket(&nack_two);
 }
 
 TEST_F(QuicConnectionTest, RetransmitNackedLargestObserved) {
@@ -1165,15 +1107,15 @@ TEST_F(QuicConnectionTest, RetransmitNackedLargestObserved) {
   frame.received_info.missing_packets.insert(largest_observed);
   frame.received_info.entropy_hash = QuicConnectionPeer::GetSentEntropyHash(
       &connection_, largest_observed - 1);
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
   // Second udp packet will force an ack frame.
   EXPECT_CALL(*send_algorithm_,
               SentPacket(_, _, _, NOT_RETRANSMISSION));
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
   // Third nack should retransmit the largest observed packet.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, packet_size - kQuicVersionSize,
                                            IS_RETRANSMISSION));
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
 }
 
 TEST_F(QuicConnectionTest, RetransmitNackedPacketsOnTruncatedAck) {
@@ -1194,7 +1136,7 @@ TEST_F(QuicConnectionTest, RetransmitNackedPacketsOnTruncatedAck) {
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
   EXPECT_CALL(visitor_, OnAck(_)).Times(1);
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
   EXPECT_TRUE(QuicConnectionPeer::GetReceivedTruncatedAck(&connection_));
 
   QuicConnectionPeer::SetMaxPacketsPerRetransmissionAlarm(&connection_, 200);
@@ -1240,17 +1182,17 @@ TEST_F(QuicConnectionTest, LimitPacketsPerNack) {
   EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
 
   // Nack three times.
-  ProcessAckPacket(&nack, true);
+  ProcessAckPacket(&nack);
   // The second call will trigger an ack.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(1);
-  ProcessAckPacket(&nack, true);
+  ProcessAckPacket(&nack);
   // The third call should trigger retransmitting 10 packets.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(10);
-  ProcessAckPacket(&nack, true);
+  ProcessAckPacket(&nack);
 
   // The fourth call should trigger retransmitting the 11th packet and an ack.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(2);
-  ProcessAckPacket(&nack, true);
+  ProcessAckPacket(&nack);
 }
 
 // Test sending multiple acks from the connection to the session.
@@ -1286,7 +1228,7 @@ TEST_F(QuicConnectionTest, MultipleAcks) {
   expected_acks.insert(5);
 
   EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
-  ProcessAckPacket(&frame1, true);
+  ProcessAckPacket(&frame1);
 
   // Now the client implicitly acks 2, and explicitly acks 6
   QuicAckFrame frame2(6, QuicTime::Zero(), 0);
@@ -1298,7 +1240,7 @@ TEST_F(QuicConnectionTest, MultipleAcks) {
   expected_acks.insert(6);
 
   EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
-  ProcessAckPacket(&frame2, true);
+  ProcessAckPacket(&frame2);
 }
 
 TEST_F(QuicConnectionTest, DontLatchUnackedPacket) {
@@ -1315,7 +1257,7 @@ TEST_F(QuicConnectionTest, DontLatchUnackedPacket) {
   QuicAckFrame frame(1, QuicTime::Zero(), 0);
   frame.received_info.entropy_hash = QuicConnectionPeer::GetSentEntropyHash(
       &connection_, 1);
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
 
   // Verify that our internal state has least-unacked as 3.
   EXPECT_EQ(3u, outgoing_ack()->sent_info.least_unacked);
@@ -1535,7 +1477,7 @@ TEST_F(QuicConnectionTest, TestRetransmissionCountCalculation) {
   ack.received_info.entropy_hash = QuicConnectionPeer::GetSentEntropyHash(
       &connection_, rto_sequence_number - 1);
   for (int i = 0; i < 3; i++) {
-    ProcessAckPacket(&ack, true);
+    ProcessAckPacket(&ack);
   }
   EXPECT_FALSE(QuicConnectionPeer::IsSavedForRetransmission(
       &connection_, rto_sequence_number));
@@ -1586,7 +1528,7 @@ TEST_F(QuicConnectionTest, CloseFecGroup) {
   // Now send non-fec protected ack packet and close the group
   QuicAckFrame frame(0, QuicTime::Zero(), 5);
   creator_.set_sequence_number(4);
-  ProcessAckPacket(&frame, true);
+  ProcessAckPacket(&frame);
   ASSERT_EQ(0u, connection_.NumFecGroups());
 }
 
@@ -1808,7 +1750,8 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndSend) {
                   testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm_,
               SentPacket(_, _, _, _));
-  ProcessAckPacket(&frame, true);
+  EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(Return(true));
+  ProcessAckPacket(&frame);
 
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   // Ensure alarm is not set
@@ -1830,7 +1773,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndHold) {
   EXPECT_CALL(*send_algorithm_,
               TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(1)));
-  ProcessAckPacket(&frame, false);
+  ProcessAckPacket(&frame);
 
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
@@ -1921,7 +1864,7 @@ TEST_F(QuicConnectionTest, MissingPacketsBeforeLeastUnacked) {
   QuicAckFrame ack(0, QuicTime::Zero(), 4);
   // Set the sequence number of the ack packet to be least unacked (4)
   creator_.set_sequence_number(3);
-  ProcessAckPacket(&ack, true);
+  ProcessAckPacket(&ack);
   EXPECT_TRUE(outgoing_ack()->received_info.missing_packets.empty());
 }
 
@@ -1946,7 +1889,7 @@ TEST_F(QuicConnectionTest, UpdateEntropyForReceivedPackets) {
   ack.sent_info.entropy_hash = kRandomEntropyHash;
   creator_.set_sequence_number(5);
   QuicPacketEntropyHash six_packet_entropy_hash = 0;
-  if (ProcessAckPacket(&ack, true)) {
+  if (ProcessAckPacket(&ack)) {
     six_packet_entropy_hash = 1 << 6;
   };
 
@@ -1965,7 +1908,7 @@ TEST_F(QuicConnectionTest, UpdateEntropyHashUptoCurrentPacket) {
   // Current packet is the least unacked packet.
   QuicAckFrame ack(0, QuicTime::Zero(), 23);
   ack.sent_info.entropy_hash = kRandomEntropyHash;
-  QuicPacketEntropyHash ack_entropy_hash =  ProcessAckPacket(&ack, true);
+  QuicPacketEntropyHash ack_entropy_hash =  ProcessAckPacket(&ack);
   EXPECT_EQ((kRandomEntropyHash + ack_entropy_hash),
             outgoing_ack()->received_info.entropy_hash);
   ProcessDataPacket(25, 1, kEntropyFlag);
@@ -2090,7 +2033,6 @@ TEST_F(QuicConnectionTest, CheckSendStats) {
   EXPECT_CALL(visitor_, OnAck(_));
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
-  EXPECT_CALL(visitor_, OnCanWrite()).Times(3).WillRepeatedly(Return(true));
 
   ProcessFramePacket(frame);
   ProcessFramePacket(frame);
@@ -2180,7 +2122,6 @@ TEST_F(QuicConnectionTest, DontProcessFramesIfPacketClosedConnection) {
   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
       ENCRYPTION_NONE, 1, *packet));
 
-  EXPECT_CALL(visitor_, OnCanWrite()).Times(1).WillOnce(Return(true));
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_PEER_GOING_AWAY, true));
   EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).Times(0);
 
diff --git a/net/quic/quic_framer.cc b/net/quic/quic_framer.cc
index 7b30344..4fd1539 100644
--- a/net/quic/quic_framer.cc
+++ b/net/quic/quic_framer.cc
@@ -22,14 +22,8 @@ namespace net {
 namespace {
 
 // Mask to select the lowest 48 bits of a sequence number.
-const QuicPacketSequenceNumber k6ByteSequenceNumberMask =
+const QuicPacketSequenceNumber kSequenceNumberMask =
     GG_UINT64_C(0x0000FFFFFFFFFFFF);
-const QuicPacketSequenceNumber k4ByteSequenceNumberMask =
-    GG_UINT64_C(0x00000000FFFFFFFF);
-const QuicPacketSequenceNumber k2ByteSequenceNumberMask =
-    GG_UINT64_C(0x000000000000FFFF);
-const QuicPacketSequenceNumber k1ByteSequenceNumberMask =
-    GG_UINT64_C(0x00000000000000FF);
 
 const QuicGuid k1ByteGuidMask = GG_UINT64_C(0x00000000000000FF);
 const QuicGuid k4ByteGuidMask = GG_UINT64_C(0x00000000FFFFFFFF);
@@ -89,10 +83,9 @@ size_t QuicFramer::GetMinStreamFrameSize() {
 
 // static
 size_t QuicFramer::GetMinAckFrameSize() {
-  return kQuicFrameTypeSize + kQuicEntropyHashSize +
-      PACKET_6BYTE_SEQUENCE_NUMBER + kQuicEntropyHashSize +
-      PACKET_6BYTE_SEQUENCE_NUMBER + kQuicDeltaTimeLargestObservedSize +
-      kNumberOfMissingPacketsSize;
+  return kQuicFrameTypeSize + kQuicEntropyHashSize + kSequenceNumberSize +
+      kQuicEntropyHashSize + kSequenceNumberSize +
+      kQuicDeltaTimeLargestObservedSize + kNumberOfMissingPacketsSize;
 }
 
 // static
@@ -120,7 +113,7 @@ size_t QuicFramer::GetMinGoAwayFrameSize() {
 // 12-byte tags.
 size_t QuicFramer::GetMaxUnackedPackets(QuicPacketHeader header) {
   return (kMaxPacketSize - GetPacketHeaderSize(header) -
-          GetMinAckFrameSize() - 16) / PACKET_6BYTE_SEQUENCE_NUMBER;
+          GetMinAckFrameSize() - 16) / kSequenceNumberSize;
 }
 
 bool QuicFramer::IsSupportedVersion(QuicTag version) {
@@ -248,8 +241,7 @@ SerializedPacket QuicFramer::ConstructFrameDataPacket(
   DCHECK_LE(len, packet_size);
   QuicPacket* packet = QuicPacket::NewDataPacket(
       writer.take(), len, true, header.public_header.guid_length,
-      header.public_header.version_flag,
-      header.public_header.sequence_number_length);
+      header.public_header.version_flag);
 
   if (fec_builder_) {
     fec_builder_->OnBuiltFecProtectedPayload(header,
@@ -282,8 +274,7 @@ SerializedPacket QuicFramer::ConstructFecPacket(
       header.packet_sequence_number,
       QuicPacket::NewFecPacket(writer.take(), len, true,
                                header.public_header.guid_length,
-                               header.public_header.version_flag,
-                               header.public_header.sequence_number_length),
+                               header.public_header.version_flag),
       GetPacketEntropyHash(header), NULL);
 }
 
@@ -295,8 +286,7 @@ QuicEncryptedPacket* QuicFramer::ConstructPublicResetPacket(
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST |
-                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID |
-                                   PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE);
+                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
@@ -309,8 +299,7 @@ QuicEncryptedPacket* QuicFramer::ConstructPublicResetPacket(
     return NULL;
   }
 
-  if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                  packet.rejected_sequence_number,
+  if (!AppendPacketSequenceNumber(packet.rejected_sequence_number,
                                   &writer)) {
     return NULL;
   }
@@ -326,8 +315,7 @@ QuicEncryptedPacket* QuicFramer::ConstructVersionNegotiationPacket(
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION |
-                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID |
-                                   PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE);
+                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
@@ -496,21 +484,6 @@ bool QuicFramer::WritePacketHeader(const QuicPacketHeader& header,
   if (header.public_header.version_flag) {
     public_flags |= PACKET_PUBLIC_FLAGS_VERSION;
   }
-  switch (header.public_header.sequence_number_length) {
-    case PACKET_1BYTE_SEQUENCE_NUMBER:
-      public_flags |= PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE;
-      break;
-    case PACKET_2BYTE_SEQUENCE_NUMBER:
-      public_flags |= PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE;
-      break;
-    case PACKET_4BYTE_SEQUENCE_NUMBER:
-      public_flags |= PACKET_PUBLIC_FLAGS_4BYTE_SEQUENCE;
-      break;
-    case PACKET_6BYTE_SEQUENCE_NUMBER:
-      public_flags |= PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE;
-      break;
-  }
-
   switch (header.public_header.guid_length) {
     case PACKET_0BYTE_GUID:
       if (!writer->WriteUInt8(public_flags | PACKET_PUBLIC_FLAGS_0BYTE_GUID)) {
@@ -549,8 +522,7 @@ bool QuicFramer::WritePacketHeader(const QuicPacketHeader& header,
     writer->WriteUInt32(quic_version_);
   }
 
-  if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
-                                  header.packet_sequence_number, writer)) {
+  if (!AppendPacketSequenceNumber(header.packet_sequence_number, writer)) {
     return false;
   }
 
@@ -586,47 +558,38 @@ bool QuicFramer::WritePacketHeader(const QuicPacketHeader& header,
 }
 
 QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire(
-    QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber packet_sequence_number) const {
   // The new sequence number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch.  Select the sequence number closest to the
-  // next expected sequence number, the previous sequence number plus 1.
-
-  // epoch_delta is the delta between epochs the sequence number was serialized
-  // with, so the correct value is likely the same epoch as the last sequence
-  // number or an adjacent epoch.
-  const QuicPacketSequenceNumber epoch_delta =
-      GG_UINT64_C(1) << (8 * sequence_number_length);
-  QuicPacketSequenceNumber next_sequence_number = last_sequence_number_ + 1;
-  QuicPacketSequenceNumber epoch = last_sequence_number_ & ~(epoch_delta - 1);
-  QuicPacketSequenceNumber prev_epoch = epoch - epoch_delta;
-  QuicPacketSequenceNumber next_epoch = epoch + epoch_delta;
-
-  return ClosestTo(next_sequence_number,
+  // previous sequence number.
+  QuicPacketSequenceNumber epoch = last_sequence_number_ & ~kSequenceNumberMask;
+  QuicPacketSequenceNumber prev_epoch = epoch - (GG_UINT64_C(1) << 48);
+  QuicPacketSequenceNumber next_epoch = epoch + (GG_UINT64_C(1) << 48);
+
+  return ClosestTo(last_sequence_number_,
                    epoch + packet_sequence_number,
-                   ClosestTo(next_sequence_number,
+                   ClosestTo(last_sequence_number_,
                              prev_epoch + packet_sequence_number,
                              next_epoch + packet_sequence_number));
 }
 
-bool QuicFramer::ProcessPublicHeader(
-    QuicPacketPublicHeader* public_header) {
+bool QuicFramer::ProcessPublicHeader(QuicPacketPublicHeader* public_header) {
   uint8 public_flags;
   if (!reader_->ReadBytes(&public_flags, 1)) {
     set_detailed_error("Unable to read public flags.");
     return false;
   }
 
-  public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
-  public_header->version_flag =
-      (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
-
-  if (!public_header->version_flag && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
+  if (public_flags > PACKET_PUBLIC_FLAGS_MAX) {
     set_detailed_error("Illegal public flags value.");
     return false;
   }
 
+  public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
+  public_header->version_flag =
+      (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
+
   if (public_header->reset_flag && public_header->version_flag) {
     set_detailed_error("Got version flag in reset packet");
     return false;
@@ -675,21 +638,6 @@ bool QuicFramer::ProcessPublicHeader(
       break;
   }
 
-  switch (public_flags & PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE) {
-    case PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE:
-      public_header->sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
-      break;
-    case PACKET_PUBLIC_FLAGS_4BYTE_SEQUENCE:
-      public_header->sequence_number_length = PACKET_4BYTE_SEQUENCE_NUMBER;
-      break;
-    case PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE:
-      public_header->sequence_number_length = PACKET_2BYTE_SEQUENCE_NUMBER;
-      break;
-    case PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE:
-      public_header->sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
-      break;
-  }
-
   if (public_header->version_flag && is_server_) {
     QuicTag version;
     if (!reader_->ReadUInt32(&version)) {
@@ -698,10 +646,6 @@ bool QuicFramer::ProcessPublicHeader(
       set_detailed_error("Unable to read protocol version.");
       return false;
     }
-    if (version == quic_version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
-      set_detailed_error("Illegal public flags value.");
-      return false;
-    }
     public_header->versions.push_back(version);
   }
   return true;
@@ -727,8 +671,7 @@ bool QuicFramer::ReadGuidFromPacket(const QuicEncryptedPacket& packet,
 bool QuicFramer::ProcessPacketHeader(
     QuicPacketHeader* header,
     const QuicEncryptedPacket& packet) {
-  if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length,
-                                   &header->packet_sequence_number)) {
+  if (!ProcessPacketSequenceNumber(&header->packet_sequence_number)) {
     set_detailed_error("Unable to read sequence number.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
@@ -738,7 +681,10 @@ bool QuicFramer::ProcessPacketHeader(
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
-  if (!DecryptPayload(*header, packet)) {
+  if (!DecryptPayload(header->packet_sequence_number,
+                      header->public_header.guid_length,
+                      header->public_header.version_flag,
+                      packet)) {
     set_detailed_error("Unable to decrypt payload.");
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
@@ -776,18 +722,14 @@ bool QuicFramer::ProcessPacketHeader(
 }
 
 bool QuicFramer::ProcessPacketSequenceNumber(
-    QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber* sequence_number) {
-  QuicPacketSequenceNumber wire_sequence_number = 0u;
-  if (!reader_->ReadBytes(&wire_sequence_number, sequence_number_length)) {
+  QuicPacketSequenceNumber wire_sequence_number;
+  if (!reader_->ReadUInt48(&wire_sequence_number)) {
     return false;
   }
 
-  // TODO(ianswett): Explore the usefulness of trying multiple sequence numbers
-  // in case the first guess is incorrect.
   *sequence_number =
-      CalculatePacketSequenceNumberFromWire(sequence_number_length,
-                                            wire_sequence_number);
+      CalculatePacketSequenceNumberFromWire(wire_sequence_number);
   return true;
 }
 
@@ -942,8 +884,7 @@ bool QuicFramer::ProcessReceivedInfo(ReceivedPacketInfo* received_info) {
     return false;
   }
 
-  if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                   &received_info->largest_observed)) {
+  if (!ProcessPacketSequenceNumber(&received_info->largest_observed)) {
      set_detailed_error("Unable to read largest observed.");
      return false;
   }
@@ -969,8 +910,7 @@ bool QuicFramer::ProcessReceivedInfo(ReceivedPacketInfo* received_info) {
 
   for (int i = 0; i < num_missing_packets; ++i) {
     QuicPacketSequenceNumber sequence_number;
-    if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                     &sequence_number)) {
+    if (!ProcessPacketSequenceNumber(&sequence_number)) {
       set_detailed_error("Unable to read sequence number in missing packets.");
       return false;
     }
@@ -986,8 +926,7 @@ bool QuicFramer::ProcessSentInfo(SentPacketInfo* sent_info) {
     return false;
   }
 
-  if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                   &sent_info->least_unacked)) {
+  if (!ProcessPacketSequenceNumber(&sent_info->least_unacked)) {
     set_detailed_error("Unable to read least unacked.");
     return false;
   }
@@ -1023,8 +962,7 @@ bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
 
       if (num_received_packets > 0u) {
         uint64 smallest_received;
-        if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                         &smallest_received)) {
+        if (!ProcessPacketSequenceNumber(&smallest_received)) {
           set_detailed_error("Unable to read smallest received.");
           return false;
         }
@@ -1192,12 +1130,10 @@ bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame* frame) {
 StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
     const QuicEncryptedPacket& encrypted,
     QuicGuidLength guid_length,
-    bool includes_version,
-    QuicSequenceNumberLength sequence_number_length) {
+    bool includes_version) {
   return StringPiece(encrypted.data() + kStartOfHashData,
                      GetStartOfEncryptedData(
-                         guid_length, includes_version, sequence_number_length)
-                     - kStartOfHashData);
+                         guid_length, includes_version) - kStartOfHashData);
 }
 
 void QuicFramer::SetDecrypter(QuicDecrypter* decrypter) {
@@ -1285,7 +1221,9 @@ size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size) {
   return min_plaintext_size;
 }
 
-bool QuicFramer::DecryptPayload(const QuicPacketHeader& header,
+bool QuicFramer::DecryptPayload(QuicPacketSequenceNumber sequence_number,
+                                QuicGuidLength guid_length,
+                                bool version_flag,
                                 const QuicEncryptedPacket& packet) {
   StringPiece encrypted;
   if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) {
@@ -1293,21 +1231,13 @@ bool QuicFramer::DecryptPayload(const QuicPacketHeader& header,
   }
   DCHECK(decrypter_.get() != NULL);
   decrypted_.reset(decrypter_->DecryptPacket(
-      header.packet_sequence_number,
-      GetAssociatedDataFromEncryptedPacket(
-          packet,
-          header.public_header.guid_length,
-          header.public_header.version_flag,
-          header.public_header.sequence_number_length),
+      sequence_number,
+      GetAssociatedDataFromEncryptedPacket(packet, guid_length, version_flag),
       encrypted));
   if  (decrypted_.get() == NULL && alternative_decrypter_.get() != NULL) {
     decrypted_.reset(alternative_decrypter_->DecryptPacket(
-        header.packet_sequence_number,
-        GetAssociatedDataFromEncryptedPacket(
-            packet,
-            header.public_header.guid_length,
-            header.public_header.version_flag,
-            header.public_header.sequence_number_length),
+        sequence_number,
+        GetAssociatedDataFromEncryptedPacket(packet, guid_length, version_flag),
         encrypted));
     if (decrypted_.get() != NULL) {
       if (alternative_decrypter_latch_) {
@@ -1335,8 +1265,8 @@ size_t QuicFramer::ComputeFrameLength(const QuicFrame& frame) {
       return GetMinStreamFrameSize() + frame.stream_frame->data.size();
     case ACK_FRAME: {
       const QuicAckFrame& ack = *frame.ack_frame;
-      return GetMinAckFrameSize() + PACKET_6BYTE_SEQUENCE_NUMBER *
-          ack.received_info.missing_packets.size();
+      return GetMinAckFrameSize() +
+          kSequenceNumberSize * ack.received_info.missing_packets.size();
     }
     case CONGESTION_FEEDBACK_FRAME: {
       size_t len = kQuicFrameTypeSize;
@@ -1351,10 +1281,10 @@ size_t QuicFramer::ComputeFrameLength(const QuicFrame& frame) {
           len += 2;
           len += 1;  // Number received packets.
           if (inter_arrival.received_packet_times.size() > 0) {
-            len += PACKET_6BYTE_SEQUENCE_NUMBER;  // Smallest received.
+            len += kSequenceNumberSize;  // Smallest received.
             len += 8;  // Time.
             // 2 bytes per sequence number delta plus 4 bytes per delta time.
-            len += PACKET_6BYTE_SEQUENCE_NUMBER *
+            len += kSequenceNumberSize *
                 (inter_arrival.received_packet_times.size() - 1);
           }
           break;
@@ -1379,8 +1309,7 @@ size_t QuicFramer::ComputeFrameLength(const QuicFrame& frame) {
       const QuicAckFrame& ack = frame.connection_close_frame->ack_frame;
       return GetMinConnectionCloseFrameSize() +
           frame.connection_close_frame->error_details.size() +
-          PACKET_6BYTE_SEQUENCE_NUMBER *
-          ack.received_info.missing_packets.size();
+          kSequenceNumberSize * ack.received_info.missing_packets.size();
     }
     case GOAWAY_FRAME:
       return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size();
@@ -1399,35 +1328,13 @@ size_t QuicFramer::ComputeFrameLength(const QuicFrame& frame) {
 
 // static
 bool QuicFramer::AppendPacketSequenceNumber(
-    QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber packet_sequence_number,
     QuicDataWriter* writer) {
   // Ensure the entire sequence number can be written.
-  if (writer->capacity() - writer->length() <
-      static_cast<size_t>( sequence_number_length)) {
+  if (writer->capacity() - writer->length() < kSequenceNumberSize) {
     return false;
   }
-  switch (sequence_number_length) {
-    case PACKET_1BYTE_SEQUENCE_NUMBER:
-      return writer->WriteUInt8(
-          packet_sequence_number & k1ByteSequenceNumberMask);
-      break;
-    case PACKET_2BYTE_SEQUENCE_NUMBER:
-      return writer->WriteUInt16(
-          packet_sequence_number & k2ByteSequenceNumberMask);
-      break;
-    case PACKET_4BYTE_SEQUENCE_NUMBER:
-      return writer->WriteUInt32(
-          packet_sequence_number & k4ByteSequenceNumberMask);
-      break;
-    case PACKET_6BYTE_SEQUENCE_NUMBER:
-      return writer->WriteUInt48(
-          packet_sequence_number & k6ByteSequenceNumberMask);
-      break;
-    default:
-      NOTREACHED() << "sequence_number_length: " << sequence_number_length;
-      return false;
-  }
+  return writer->WriteUInt48(packet_sequence_number & kSequenceNumberMask);
 }
 
 bool QuicFramer::AppendStreamFramePayload(
@@ -1445,7 +1352,8 @@ bool QuicFramer::AppendStreamFramePayload(
   if (!writer->WriteUInt16(frame.data.size())) {
     return false;
   }
-  if (!writer->WriteBytes(frame.data.data(), frame.data.size())) {
+  if (!writer->WriteBytes(frame.data.data(),
+                           frame.data.size())) {
     return false;
   }
   return true;
@@ -1478,8 +1386,7 @@ bool QuicFramer::AppendAckFramePayload(
     return false;
   }
 
-  if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                  frame.sent_info.least_unacked, writer)) {
+  if (!AppendPacketSequenceNumber(frame.sent_info.least_unacked, writer)) {
     return false;
   }
 
@@ -1489,8 +1396,7 @@ bool QuicFramer::AppendAckFramePayload(
   }
 
   size_t largest_observed_offset = writer->length();
-  if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                  frame.received_info.largest_observed,
+  if (!AppendPacketSequenceNumber(frame.received_info.largest_observed,
                                   writer)) {
     return false;
   }
@@ -1517,8 +1423,7 @@ bool QuicFramer::AppendAckFramePayload(
       frame.received_info.missing_packets.begin();
   int num_missing_packets_written = 0;
   for (; it != frame.received_info.missing_packets.end(); ++it) {
-    if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                    *it, writer)) {
+    if (!AppendPacketSequenceNumber(*it, writer)) {
       // We are truncating.
       QuicPacketSequenceNumber largest_observed =
           CalculateLargestObserved(frame.received_info.missing_packets, --it);
@@ -1527,7 +1432,7 @@ bool QuicFramer::AppendAckFramePayload(
           entropy_calculator_->ReceivedEntropyHash(largest_observed),
           received_entropy_offset);
       // Overwrite largest_observed.
-      writer->WriteUInt48ToOffset(largest_observed & k6ByteSequenceNumberMask,
+      writer->WriteUInt48ToOffset(largest_observed & kSequenceNumberMask,
                                   largest_observed_offset);
       writer->WriteUInt32ToOffset(kInvalidDeltaTime,
                                   delta_time_largest_observed_offset);
@@ -1574,8 +1479,7 @@ bool QuicFramer::AppendQuicCongestionFeedbackFramePayload(
             inter_arrival.received_packet_times.begin();
 
         QuicPacketSequenceNumber lowest_sequence = it->first;
-        if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                        lowest_sequence, writer)) {
+        if (!AppendPacketSequenceNumber(lowest_sequence, writer)) {
           return false;
         }
 
diff --git a/net/quic/quic_framer.h b/net/quic/quic_framer.h
index 76410db..8eb1f28 100644
--- a/net/quic/quic_framer.h
+++ b/net/quic/quic_framer.h
@@ -248,8 +248,7 @@ class NET_EXPORT_PRIVATE QuicFramer {
   static base::StringPiece GetAssociatedDataFromEncryptedPacket(
       const QuicEncryptedPacket& encrypted,
       QuicGuidLength guid_length,
-      bool includes_version,
-      QuicSequenceNumberLength sequence_number_length);
+      bool includes_version);
 
   // Returns a SerializedPacket whose |packet| member is owned by the caller,
   // and is populated with the fields in |header| and |frames|, or is NULL if
@@ -343,9 +342,7 @@ class NET_EXPORT_PRIVATE QuicFramer {
   bool ProcessPacketHeader(QuicPacketHeader* header,
                            const QuicEncryptedPacket& packet);
 
-  bool ProcessPacketSequenceNumber(
-      QuicSequenceNumberLength sequence_number_length,
-      QuicPacketSequenceNumber* sequence_number);
+  bool ProcessPacketSequenceNumber(QuicPacketSequenceNumber* sequence_number);
   bool ProcessFrameData();
   bool ProcessStreamFrame(QuicStreamFrame* frame);
   bool ProcessAckFrame(QuicAckFrame* frame);
@@ -357,20 +354,20 @@ class NET_EXPORT_PRIVATE QuicFramer {
   bool ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame);
   bool ProcessGoAwayFrame(QuicGoAwayFrame* frame);
 
-  bool DecryptPayload(const QuicPacketHeader& header,
+  bool DecryptPayload(QuicPacketSequenceNumber packet_sequence_number,
+                      QuicGuidLength guid_length,
+                      bool version_flag,
                       const QuicEncryptedPacket& packet);
 
   // Returns the full packet sequence number from the truncated
   // wire format version and the last seen packet sequence number.
   QuicPacketSequenceNumber CalculatePacketSequenceNumberFromWire(
-      QuicSequenceNumberLength sequence_number_length,
       QuicPacketSequenceNumber packet_sequence_number) const;
 
   // Computes the wire size in bytes of the payload of |frame|.
   size_t ComputeFrameLength(const QuicFrame& frame);
 
   static bool AppendPacketSequenceNumber(
-      QuicSequenceNumberLength sequence_number_length,
       QuicPacketSequenceNumber packet_sequence_number,
       QuicDataWriter* writer);
 
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index fbeb05c..9e6df0d 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -57,19 +57,13 @@ size_t GetSequenceNumberOffset(bool include_version) {
 // Index into the private flags offset in the data packet header.
 size_t GetPrivateFlagsOffset(QuicGuidLength guid_length, bool include_version) {
   return GetSequenceNumberOffset(guid_length, include_version) +
-      PACKET_6BYTE_SEQUENCE_NUMBER;
+      kSequenceNumberSize;
 }
 
 size_t GetPrivateFlagsOffset(bool include_version) {
   return GetPrivateFlagsOffset(PACKET_8BYTE_GUID, include_version);
 }
 
-size_t GetPrivateFlagsOffset(bool include_version,
-                             QuicSequenceNumberLength sequence_number_length) {
-  return GetSequenceNumberOffset(PACKET_8BYTE_GUID, include_version) +
-      sequence_number_length;
-}
-
 // Index into the fec group offset in the header.
 size_t GetFecGroupOffset(QuicGuidLength guid_length, bool include_version) {
   return GetPrivateFlagsOffset(guid_length, include_version) +
@@ -81,12 +75,6 @@ size_t GetFecGroupOffset(bool include_version) {
       kPrivateFlagsSize;
 }
 
-size_t GetFecGroupOffset(bool include_version,
-                         QuicSequenceNumberLength sequence_number_length) {
-  return GetPrivateFlagsOffset(include_version, sequence_number_length) +
-      kPrivateFlagsSize;
-}
-
 // Index into the nonce proof of the public reset packet.
 // Public resets always have full guids.
 const size_t kPublicResetPacketNonceProofOffset =
@@ -183,7 +171,6 @@ class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
  public:
   TestQuicVisitor()
       : error_count_(0),
-        version_mismatch_(0),
         packet_count_(0),
         frame_count_(0),
         fec_count_(0),
@@ -222,8 +209,7 @@ class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
   }
 
   virtual bool OnProtocolVersionMismatch(QuicTag version) OVERRIDE {
-    DLOG(INFO) << "QuicFramer Version Mismatch, version: " << version;
-    version_mismatch_++;
+    DCHECK(false);
     return true;
   }
 
@@ -284,7 +270,6 @@ class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
 
   // Counters from the visitor_ callbacks.
   int error_count_;
-  int version_mismatch_;
   int packet_count_;
   int frame_count_;
   int fec_count_;
@@ -351,21 +336,18 @@ class QuicFramerTest : public ::testing::Test {
       return false;
     }
     if (QuicFramer::GetAssociatedDataFromEncryptedPacket(
-            encrypted, PACKET_8BYTE_GUID,
-            includes_version, PACKET_6BYTE_SEQUENCE_NUMBER) !=
-        decrypter_->associated_data_) {
+            encrypted, PACKET_8BYTE_GUID, includes_version) !=
+                decrypter_->associated_data_) {
       LOG(ERROR) << "Decrypted incorrect associated data.  expected "
                  << QuicFramer::GetAssociatedDataFromEncryptedPacket(
-                     encrypted, PACKET_8BYTE_GUID,
-                     includes_version, PACKET_6BYTE_SEQUENCE_NUMBER)
+                     encrypted, PACKET_8BYTE_GUID, includes_version)
                  << " actual: " << decrypter_->associated_data_;
       return false;
     }
     StringPiece ciphertext(encrypted.AsStringPiece().substr(
-        GetStartOfEncryptedData(PACKET_8BYTE_GUID, includes_version,
-                                PACKET_6BYTE_SEQUENCE_NUMBER)));
+        GetStartOfEncryptedData(PACKET_8BYTE_GUID, includes_version)));
     if (ciphertext != decrypter_->ciphertext_) {
-      LOG(ERROR) << "Decrypted incorrect ciphertext data.  expected "
+      LOG(ERROR) << "Decrypted incorrect chipertext data.  expected "
                  << ciphertext << " actual: "
                  << decrypter_->ciphertext_;
       return false;
@@ -402,9 +384,9 @@ class QuicFramerTest : public ::testing::Test {
     QuicFramerPeer::SetLastSequenceNumber(&framer_, last_sequence_number);
     EXPECT_EQ(expected_sequence_number,
               QuicFramerPeer::CalculatePacketSequenceNumberFromWire(
-                  &framer_, PACKET_6BYTE_SEQUENCE_NUMBER, wire_sequence_number))
+                  &framer_, wire_sequence_number))
         << "last_sequence_number: " << last_sequence_number
-        << " wire_sequence_number: " << wire_sequence_number;
+        << "wire_sequence_number: " << wire_sequence_number;
   }
 
   test::TestEncrypter* encrypter_;
@@ -499,11 +481,9 @@ TEST_F(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearNextMax) {
 
   // Cases where the last number was close to the end of the range
   for (uint64 i = 0; i < 10; i++) {
-    // Subtract 1, because the expected next sequence number is 1 more than the
-    // last sequence number.
-    QuicPacketSequenceNumber last = max_number - i - 1;
+    QuicPacketSequenceNumber last = max_number - i;
 
-    // Small numbers should not wrap, because they have nowhere to go.
+    // Small numbers should not wrap (because they have nowhere to go.
     for (uint64 j = 0; j < 10; j++) {
       CheckCalculatePacketSequenceNumber(max_epoch + j, last);
     }
@@ -526,7 +506,7 @@ TEST_F(QuicFramerTest, EmptyPacket) {
 TEST_F(QuicFramerTest, LargePacket) {
   unsigned char packet[kMaxPacketSize + 1] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -538,11 +518,9 @@ TEST_F(QuicFramerTest, LargePacket) {
   };
 
   memset(packet + GetPacketHeaderSize(
-             PACKET_8BYTE_GUID, !kIncludeVersion,
-             PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 0,
+             PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP), 0,
          kMaxPacketSize - GetPacketHeaderSize(
-             PACKET_8BYTE_GUID, !kIncludeVersion,
-             PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP) + 1);
+             PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP) + 1);
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -558,7 +536,7 @@ TEST_F(QuicFramerTest, LargePacket) {
 TEST_F(QuicFramerTest, PacketHeader) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -587,9 +565,8 @@ TEST_F(QuicFramerTest, PacketHeader) {
 
   // Now test framing boundaries
   for (size_t i = 0;
-       i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                               PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-       ++i) {
+       i < GetPacketHeaderSize(
+           PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP); ++i) {
     string expected_error;
     if (i < kGuidOffset) {
       expected_error = "Unable to read public flags.";
@@ -612,7 +589,7 @@ TEST_F(QuicFramerTest, PacketHeaderWith4ByteGuid) {
 
   unsigned char packet[] = {
     // public flags (4 byte guid)
-    0x38,
+    0x08,
     // guid
     0x10, 0x32, 0x54, 0x76,
     // packet sequence number
@@ -640,9 +617,8 @@ TEST_F(QuicFramerTest, PacketHeaderWith4ByteGuid) {
 
   // Now test framing boundaries
   for (size_t i = 0;
-       i < GetPacketHeaderSize(PACKET_4BYTE_GUID, !kIncludeVersion,
-                               PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-       ++i) {
+       i < GetPacketHeaderSize(
+           PACKET_4BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP); ++i) {
     string expected_error;
     if (i < kGuidOffset) {
       expected_error = "Unable to read public flags.";
@@ -667,7 +643,7 @@ TEST_F(QuicFramerTest, PacketHeader1ByteGuid) {
 
   unsigned char packet[] = {
     // public flags (1 byte guid)
-    0x34,
+    0x04,
     // guid
     0x10,
     // packet sequence number
@@ -695,9 +671,8 @@ TEST_F(QuicFramerTest, PacketHeader1ByteGuid) {
 
   // Now test framing boundaries
   for (size_t i = 0;
-       i < GetPacketHeaderSize(PACKET_1BYTE_GUID, !kIncludeVersion,
-                               PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-       ++i) {
+       i < GetPacketHeaderSize(
+           PACKET_1BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP); ++i) {
     string expected_error;
     if (i < kGuidOffset) {
       expected_error = "Unable to read public flags.";
@@ -721,7 +696,7 @@ TEST_F(QuicFramerTest, PacketHeaderWith0ByteGuid) {
 
   unsigned char packet[] = {
     // public flags (0 byte guid)
-    0x30,
+    0x00,
     // guid
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
@@ -748,9 +723,8 @@ TEST_F(QuicFramerTest, PacketHeaderWith0ByteGuid) {
 
   // Now test framing boundaries
   for (size_t i = 0;
-       i < GetPacketHeaderSize(PACKET_0BYTE_GUID, !kIncludeVersion,
-                               PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-       ++i) {
+       i < GetPacketHeaderSize(
+           PACKET_0BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP); ++i) {
     string expected_error;
     if (i < kGuidOffset) {
       expected_error = "Unable to read public flags.";
@@ -771,12 +745,12 @@ TEST_F(QuicFramerTest, PacketHeaderWith0ByteGuid) {
 TEST_F(QuicFramerTest, PacketHeaderWithVersionFlag) {
   unsigned char packet[] = {
     // public flags (version)
-    0x3D,
+    0x0D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', '6',
+    'Q', '0', '0', '5',
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
@@ -803,9 +777,8 @@ TEST_F(QuicFramerTest, PacketHeaderWithVersionFlag) {
 
   // Now test framing boundaries
   for (size_t i = 0;
-       i < GetPacketHeaderSize(PACKET_8BYTE_GUID, kIncludeVersion,
-                               PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-       ++i) {
+       i < GetPacketHeaderSize(
+           PACKET_8BYTE_GUID, kIncludeVersion, NOT_IN_FEC_GROUP); ++i) {
     string expected_error;
     if (i < kGuidOffset) {
       expected_error = "Unable to read public flags.";
@@ -824,217 +797,14 @@ TEST_F(QuicFramerTest, PacketHeaderWithVersionFlag) {
   }
 }
 
-TEST_F(QuicFramerTest, PacketHeaderWith4ByteSequenceNumber) {
-  QuicFramerPeer::SetLastSequenceNumber(&framer_,
-                                        GG_UINT64_C(0x123456789ABA));
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid and 4 byte sequence number)
-    0x2C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    // private flags
-    0x00,
-  };
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.guid);
-  EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
-  EXPECT_FALSE(visitor_.header_->public_header.version_flag);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
-  EXPECT_FALSE(visitor_.header_->entropy_flag);
-  EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
-            visitor_.header_->packet_sequence_number);
-  EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
-
-  // Now test framing boundaries
-  for (size_t i = 0;
-       i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                               PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-       ++i) {
-    string expected_error;
-    if (i < kGuidOffset) {
-      expected_error = "Unable to read public flags.";
-    } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) {
-      expected_error = "Unable to read GUID.";
-    } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
-                                         PACKET_4BYTE_SEQUENCE_NUMBER)) {
-      expected_error = "Unable to read sequence number.";
-    } else if (i < GetFecGroupOffset(!kIncludeVersion,
-                                     PACKET_4BYTE_SEQUENCE_NUMBER)) {
-      expected_error = "Unable to read private flags.";
-    } else {
-      expected_error = "Unable to read first fec protected packet offset.";
-    }
-    CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
-  }
-}
-
-TEST_F(QuicFramerTest, PacketHeaderWith2ByteSequenceNumber) {
-  QuicFramerPeer::SetLastSequenceNumber(&framer_,
-                                        GG_UINT64_C(0x123456789ABA));
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid and 2 byte sequence number)
-    0x1C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A,
-    // private flags
-    0x00,
-  };
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.guid);
-  EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
-  EXPECT_FALSE(visitor_.header_->public_header.version_flag);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
-  EXPECT_FALSE(visitor_.header_->entropy_flag);
-  EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
-            visitor_.header_->packet_sequence_number);
-  EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
-
-  // Now test framing boundaries
-  for (size_t i = 0;
-       i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                               PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-       ++i) {
-    string expected_error;
-    if (i < kGuidOffset) {
-      expected_error = "Unable to read public flags.";
-    } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) {
-      expected_error = "Unable to read GUID.";
-    } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
-                                         PACKET_2BYTE_SEQUENCE_NUMBER)) {
-      expected_error = "Unable to read sequence number.";
-    } else if (i < GetFecGroupOffset(!kIncludeVersion,
-                                     PACKET_2BYTE_SEQUENCE_NUMBER)) {
-      expected_error = "Unable to read private flags.";
-    } else {
-      expected_error = "Unable to read first fec protected packet offset.";
-    }
-    CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
-  }
-}
-
-TEST_F(QuicFramerTest, PacketHeaderWith1ByteSequenceNumber) {
-  QuicFramerPeer::SetLastSequenceNumber(&framer_,
-                                        GG_UINT64_C(0x123456789ABA));
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid and 1 byte sequence number)
-    0x0C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC,
-    // private flags
-    0x00,
-  };
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.guid);
-  EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
-  EXPECT_FALSE(visitor_.header_->public_header.version_flag);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
-  EXPECT_FALSE(visitor_.header_->entropy_flag);
-  EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
-            visitor_.header_->packet_sequence_number);
-  EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
-
-  // Now test framing boundaries
-  for (size_t i = 0;
-       i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                               PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-       ++i) {
-    string expected_error;
-    if (i < kGuidOffset) {
-      expected_error = "Unable to read public flags.";
-    } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) {
-      expected_error = "Unable to read GUID.";
-    } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
-                                         PACKET_1BYTE_SEQUENCE_NUMBER)) {
-      expected_error = "Unable to read sequence number.";
-    } else if (i < GetFecGroupOffset(!kIncludeVersion,
-                                     PACKET_1BYTE_SEQUENCE_NUMBER)) {
-      expected_error = "Unable to read private flags.";
-    } else {
-      expected_error = "Unable to read first fec protected packet offset.";
-    }
-    CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
-  }
-}
 
 TEST_F(QuicFramerTest, InvalidPublicFlag) {
   unsigned char packet[] = {
-    // public flags
-    0x40,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // private flags
-    0x00,
-
-    // frame count
-    0x01,
-    // frame type (stream frame)
-    0x01,
-    // stream id
-    0x04, 0x03, 0x02, 0x01,
-    // fin
-    0x01,
-    // offset
-    0x54, 0x76, 0x10, 0x32,
-    0xDC, 0xFE, 0x98, 0xBA,
-    // data length
-    0x0c, 0x00,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-  };
-  CheckProcessingFails(packet,
-                       arraysize(packet),
-                       "Illegal public flags value.",
-                       QUIC_INVALID_PACKET_HEADER);
-};
-
-TEST_F(QuicFramerTest, InvalidPublicFlagWithMatchingVersions) {
-  unsigned char packet[] = {
-    // public flags (8 byte guid and version flag and an unknown flag)
-    0x4D,
+    // public flags (8 byte guid)
+    0x10,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
-    // version tag
-    'Q', '0', '0', '6',
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
@@ -1065,36 +835,10 @@ TEST_F(QuicFramerTest, InvalidPublicFlagWithMatchingVersions) {
                        QUIC_INVALID_PACKET_HEADER);
 };
 
-TEST_F(QuicFramerTest, LargePublicFlagWithMismatchedVersions) {
-  unsigned char packet[] = {
-    // public flags (8 byte guid, version flag and an unknown flag)
-    0x7D,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // version tag
-    'Q', '0', '0', '0',
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // private flags
-    0x00,
-
-    // frame type (padding frame)
-    0x00,
-  };
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(0, visitor_.frame_count_);
-  EXPECT_EQ(1, visitor_.version_mismatch_);
-};
-
 TEST_F(QuicFramerTest, InvalidPrivateFlag) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1131,7 +875,7 @@ TEST_F(QuicFramerTest, InvalidPrivateFlag) {
 TEST_F(QuicFramerTest, PaddingFrame) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1166,15 +910,15 @@ TEST_F(QuicFramerTest, PaddingFrame) {
   // A packet with no frames is not acceptable.
   CheckProcessingFails(
       packet,
-      GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+      GetPacketHeaderSize(
+          PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
       "Unable to read frame type.", QUIC_INVALID_FRAME_DATA);
 }
 
 TEST_F(QuicFramerTest, StreamFrame) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1235,8 +979,8 @@ TEST_F(QuicFramerTest, StreamFrame) {
     }
     CheckProcessingFails(
         packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        i + GetPacketHeaderSize(
+            PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
@@ -1244,12 +988,12 @@ TEST_F(QuicFramerTest, StreamFrame) {
 TEST_F(QuicFramerTest, StreamFrameWithVersion) {
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
-    0x3D,
+    0x0D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', '6',
+    'Q', '0', '0', '5',
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
@@ -1308,9 +1052,8 @@ TEST_F(QuicFramerTest, StreamFrameWithVersion) {
       expected_error = "Unable to read frame data.";
     }
     CheckProcessingFails(
-        packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        packet, i + GetPacketHeaderSize(PACKET_8BYTE_GUID, kIncludeVersion,
+                                        NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
@@ -1320,7 +1063,7 @@ TEST_F(QuicFramerTest, RejectPacket) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1419,7 +1162,7 @@ TEST_F(QuicFramerTest, RevivedStreamFrame) {
 TEST_F(QuicFramerTest, StreamFrameInFecGroup) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1457,10 +1200,11 @@ TEST_F(QuicFramerTest, StreamFrameInFecGroup) {
   EXPECT_EQ(IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
   EXPECT_EQ(GG_UINT64_C(0x341256789ABA),
             visitor_.header_->fec_group);
-  const size_t fec_offset = GetStartOfFecProtectedData(
-      PACKET_8BYTE_GUID, !kIncludeVersion, PACKET_6BYTE_SEQUENCE_NUMBER);
   EXPECT_EQ(
-      string(AsChars(packet) + fec_offset, arraysize(packet) - fec_offset),
+      string(AsChars(packet) + GetStartOfFecProtectedData(PACKET_8BYTE_GUID,
+                                                          !kIncludeVersion),
+             arraysize(packet) - GetStartOfFecProtectedData(PACKET_8BYTE_GUID,
+                                                            !kIncludeVersion)),
       visitor_.fec_protected_payload_);
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
@@ -1475,7 +1219,7 @@ TEST_F(QuicFramerTest, StreamFrameInFecGroup) {
 TEST_F(QuicFramerTest, AckFrame) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1528,17 +1272,17 @@ TEST_F(QuicFramerTest, AckFrame) {
   const size_t kSentEntropyOffset = kQuicFrameTypeSize;
   const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize;
   const size_t kReceivedEntropyOffset = kLeastUnackedOffset +
-      PACKET_6BYTE_SEQUENCE_NUMBER;
+      kSequenceNumberSize;
   const size_t kLargestObservedOffset = kReceivedEntropyOffset +
       kQuicEntropyHashSize;
   const size_t kMissingDeltaTimeOffset = kLargestObservedOffset +
-      PACKET_6BYTE_SEQUENCE_NUMBER;
+      kSequenceNumberSize;
   const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset +
       kQuicDeltaTimeLargestObservedSize;
   const size_t kMissingPacketsOffset = kNumMissingPacketOffset +
       kNumberOfMissingPacketsSize;
   // Now test framing boundaries
-  const size_t missing_packets_size = 1 * PACKET_6BYTE_SEQUENCE_NUMBER;
+  const size_t missing_packets_size = 1 * kSequenceNumberSize;
   for (size_t i = 0;
        i < QuicFramer::GetMinAckFrameSize() + missing_packets_size; ++i) {
     string expected_error;
@@ -1561,8 +1305,8 @@ TEST_F(QuicFramerTest, AckFrame) {
     }
     CheckProcessingFails(
         packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        i + GetPacketHeaderSize(
+            PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
@@ -1570,7 +1314,7 @@ TEST_F(QuicFramerTest, AckFrame) {
 TEST_F(QuicFramerTest, CongestionFeedbackFrameTCP) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1620,8 +1364,8 @@ TEST_F(QuicFramerTest, CongestionFeedbackFrameTCP) {
     }
     CheckProcessingFails(
         packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        i + GetPacketHeaderSize(
+            PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
@@ -1629,7 +1373,7 @@ TEST_F(QuicFramerTest, CongestionFeedbackFrameTCP) {
 TEST_F(QuicFramerTest, CongestionFeedbackFrameInterArrival) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1718,8 +1462,8 @@ TEST_F(QuicFramerTest, CongestionFeedbackFrameInterArrival) {
     }
     CheckProcessingFails(
         packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        i + GetPacketHeaderSize(
+            PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
@@ -1727,7 +1471,7 @@ TEST_F(QuicFramerTest, CongestionFeedbackFrameInterArrival) {
 TEST_F(QuicFramerTest, CongestionFeedbackFrameFixRate) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1772,8 +1516,8 @@ TEST_F(QuicFramerTest, CongestionFeedbackFrameFixRate) {
     }
     CheckProcessingFails(
         packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        i + GetPacketHeaderSize(
+            PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
@@ -1782,7 +1526,7 @@ TEST_F(QuicFramerTest, CongestionFeedbackFrameFixRate) {
 TEST_F(QuicFramerTest, CongestionFeedbackFrameInvalidFeedback) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1807,7 +1551,7 @@ TEST_F(QuicFramerTest, CongestionFeedbackFrameInvalidFeedback) {
 TEST_F(QuicFramerTest, RstStreamFrame) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1857,8 +1601,8 @@ TEST_F(QuicFramerTest, RstStreamFrame) {
     }
     CheckProcessingFails(
         packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        i + GetPacketHeaderSize(
+            PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_RST_STREAM_DATA);
   }
 }
@@ -1866,7 +1610,7 @@ TEST_F(QuicFramerTest, RstStreamFrame) {
 TEST_F(QuicFramerTest, ConnectionCloseFrame) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -1944,8 +1688,8 @@ TEST_F(QuicFramerTest, ConnectionCloseFrame) {
     }
     CheckProcessingFails(
         packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        i + GetPacketHeaderSize(
+            PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_CONNECTION_CLOSE_DATA);
   }
 }
@@ -1953,7 +1697,7 @@ TEST_F(QuicFramerTest, ConnectionCloseFrame) {
 TEST_F(QuicFramerTest, GoAwayFrame) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2005,8 +1749,8 @@ TEST_F(QuicFramerTest, GoAwayFrame) {
     }
     CheckProcessingFails(
         packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
+        i + GetPacketHeaderSize(
+            PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_GOAWAY_DATA);
   }
 }
@@ -2014,7 +1758,7 @@ TEST_F(QuicFramerTest, GoAwayFrame) {
 TEST_F(QuicFramerTest, PublicResetPacket) {
   unsigned char packet[] = {
     // public flags (public reset, 8 byte guid)
-    0x3E,
+    0x0E,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2066,12 +1810,12 @@ TEST_F(QuicFramerTest, PublicResetPacket) {
 TEST_F(QuicFramerTest, VersionNegotiationPacket) {
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
-    0x3D,
+    0x0D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', '6',
+    'Q', '0', '0', '5',
     'Q', '2', '.', '0',
   };
 
@@ -2103,7 +1847,7 @@ TEST_F(QuicFramerTest, VersionNegotiationPacket) {
 TEST_F(QuicFramerTest, FecPacket) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2154,7 +1898,7 @@ TEST_F(QuicFramerTest, ConstructPaddingFramePacket) {
 
   unsigned char packet[kMaxPacketSize] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2168,144 +1912,8 @@ TEST_F(QuicFramerTest, ConstructPaddingFramePacket) {
     0x00,
   };
 
-  uint64 header_size =
-      GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-  memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
-
-  scoped_ptr<QuicPacket> data(
-      framer_.ConstructFrameDataPacket(header, frames).packet);
-  ASSERT_TRUE(data != NULL);
-
-  test::CompareCharArraysWithHexError("constructed packet",
-                                      data->data(), data->length(),
-                                      AsChars(packet), arraysize(packet));
-}
-
-TEST_F(QuicFramerTest, Construct4ByteSequenceNumberPaddingFramePacket) {
-  QuicPacketHeader header;
-  header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.public_header.reset_flag = false;
-  header.public_header.version_flag = false;
-  header.fec_flag = false;
-  header.entropy_flag = false;
-  header.public_header.sequence_number_length = PACKET_4BYTE_SEQUENCE_NUMBER;
-  header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
-  header.fec_group = 0;
-
-  QuicPaddingFrame padding_frame;
-
-  QuicFrames frames;
-  frames.push_back(QuicFrame(&padding_frame));
-
-  unsigned char packet[kMaxPacketSize] = {
-    // public flags (8 byte guid and 4 byte sequence number)
-    0x2C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    // private flags
-    0x00,
-
-    // frame type (padding frame)
-    0x00,
-  };
-
-  uint64 header_size =
-      GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                          PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-  memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
-
-  scoped_ptr<QuicPacket> data(
-      framer_.ConstructFrameDataPacket(header, frames).packet);
-  ASSERT_TRUE(data != NULL);
-
-  test::CompareCharArraysWithHexError("constructed packet",
-                                      data->data(), data->length(),
-                                      AsChars(packet), arraysize(packet));
-}
-
-TEST_F(QuicFramerTest, Construct2ByteSequenceNumberPaddingFramePacket) {
-  QuicPacketHeader header;
-  header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.public_header.reset_flag = false;
-  header.public_header.version_flag = false;
-  header.fec_flag = false;
-  header.entropy_flag = false;
-  header.public_header.sequence_number_length = PACKET_2BYTE_SEQUENCE_NUMBER;
-  header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
-  header.fec_group = 0;
-
-  QuicPaddingFrame padding_frame;
-
-  QuicFrames frames;
-  frames.push_back(QuicFrame(&padding_frame));
-
-  unsigned char packet[kMaxPacketSize] = {
-    // public flags (8 byte guid and 2 byte sequence number)
-    0x1C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A,
-    // private flags
-    0x00,
-
-    // frame type (padding frame)
-    0x00,
-  };
-
-  uint64 header_size =
-      GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                          PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
-  memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
-
-  scoped_ptr<QuicPacket> data(
-      framer_.ConstructFrameDataPacket(header, frames).packet);
-  ASSERT_TRUE(data != NULL);
-
-  test::CompareCharArraysWithHexError("constructed packet",
-                                      data->data(), data->length(),
-                                      AsChars(packet), arraysize(packet));
-}
-
-TEST_F(QuicFramerTest, Construct1ByteSequenceNumberPaddingFramePacket) {
-  QuicPacketHeader header;
-  header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.public_header.reset_flag = false;
-  header.public_header.version_flag = false;
-  header.fec_flag = false;
-  header.entropy_flag = false;
-  header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
-  header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
-  header.fec_group = 0;
-
-  QuicPaddingFrame padding_frame;
-
-  QuicFrames frames;
-  frames.push_back(QuicFrame(&padding_frame));
-
-  unsigned char packet[kMaxPacketSize] = {
-    // public flags (8 byte guid and 1 byte sequence number)
-    0x0C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC,
-    // private flags
-    0x00,
-
-    // frame type (padding frame)
-    0x00,
-  };
-
-  uint64 header_size =
-      GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                          PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
+  uint64 header_size = GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
+                                           NOT_IN_FEC_GROUP);
   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
 
   scoped_ptr<QuicPacket> data(
@@ -2338,7 +1946,7 @@ TEST_F(QuicFramerTest, ConstructStreamFramePacket) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2395,12 +2003,12 @@ TEST_F(QuicFramerTest, ConstructStreamFramePacketWithVersionFlag) {
 
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
-    0x3D,
+    0x0D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', '6',
+    'Q', '0', '0', '5',
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
@@ -2442,12 +2050,12 @@ TEST_F(QuicFramerTest, ConstructVersionNegotiationPacket) {
 
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
-    0x3D,
+    0x0D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', '6',
+    'Q', '0', '0', '5',
     'Q', '2', '.', '0',
   };
 
@@ -2487,7 +2095,7 @@ TEST_F(QuicFramerTest, ConstructAckFramePacket) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2547,7 +2155,7 @@ TEST_F(QuicFramerTest, ConstructCongestionFeedbackFramePacketTCP) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2606,7 +2214,7 @@ TEST_F(QuicFramerTest, ConstructCongestionFeedbackFramePacketInterArrival) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2669,7 +2277,7 @@ TEST_F(QuicFramerTest, ConstructCongestionFeedbackFramePacketFixRate) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2735,7 +2343,7 @@ TEST_F(QuicFramerTest, ConstructRstFramePacket) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2798,7 +2406,7 @@ TEST_F(QuicFramerTest, ConstructCloseFramePacket) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2869,7 +2477,7 @@ TEST_F(QuicFramerTest, ConstructGoAwayPacket) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2913,7 +2521,7 @@ TEST_F(QuicFramerTest, ConstructPublicResetPacket) {
 
   unsigned char packet[] = {
     // public flags (public reset, 8 byte GUID)
-    0x3E,
+    0x0E,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2951,7 +2559,7 @@ TEST_F(QuicFramerTest, ConstructFecPacket) {
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -2983,7 +2591,7 @@ TEST_F(QuicFramerTest, EncryptPacket) {
   QuicPacketSequenceNumber sequence_number = GG_UINT64_C(0x123456789ABC);
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -3004,8 +2612,7 @@ TEST_F(QuicFramerTest, EncryptPacket) {
 
   scoped_ptr<QuicPacket> raw(
       QuicPacket::NewDataPacket(AsChars(packet), arraysize(packet), false,
-                                PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER));
+                                PACKET_8BYTE_GUID, !kIncludeVersion));
   scoped_ptr<QuicEncryptedPacket> encrypted(
       framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw));
 
@@ -3017,7 +2624,7 @@ TEST_F(QuicFramerTest, EncryptPacketWithVersionFlag) {
   QuicPacketSequenceNumber sequence_number = GG_UINT64_C(0x123456789ABC);
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
-    0x3D,
+    0x0D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -3040,8 +2647,7 @@ TEST_F(QuicFramerTest, EncryptPacketWithVersionFlag) {
 
   scoped_ptr<QuicPacket> raw(
       QuicPacket::NewDataPacket(AsChars(packet), arraysize(packet), false,
-                                PACKET_8BYTE_GUID, kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER));
+                                PACKET_8BYTE_GUID, kIncludeVersion));
   scoped_ptr<QuicEncryptedPacket> encrypted(
       framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw));
 
@@ -3210,7 +2816,7 @@ TEST_F(QuicFramerTest, CleanTruncation) {
 TEST_F(QuicFramerTest, EntropyFlagTest) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -3249,7 +2855,7 @@ TEST_F(QuicFramerTest, EntropyFlagTest) {
 TEST_F(QuicFramerTest, FecEntropyTest) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -3290,7 +2896,7 @@ TEST_F(QuicFramerTest, FecEntropyTest) {
 TEST_F(QuicFramerTest, StopPacketProcessing) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ -3351,7 +2957,7 @@ TEST_F(QuicFramerTest, StopPacketProcessing) {
 TEST_F(QuicFramerTest, ConnectionCloseWithInvalidAck) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
-    0x3C,
+    0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index eb6dbe8..b29a0e4 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -528,7 +528,8 @@ TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
 TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0, request_data_));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(2, 2, 1));
+  AddWrite(SYNCHRONOUS, ConstructRstPacket(2, 3));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1));
   use_closing_stream_ = true;
   Initialize();
 
diff --git a/net/quic/quic_packet_creator.cc b/net/quic/quic_packet_creator.cc
index d1c3ca1..c8d132f 100644
--- a/net/quic/quic_packet_creator.cc
+++ b/net/quic/quic_packet_creator.cc
@@ -30,7 +30,6 @@ QuicPacketCreator::QuicPacketCreator(QuicGuid guid,
       send_version_in_packet_(!is_server),
       packet_size_(GetPacketHeaderSize(options_.send_guid_length,
                                        send_version_in_packet_,
-                                       options_.send_sequence_number_length,
                                        NOT_IN_FEC_GROUP)) {
   framer_->set_fec_builder(this);
 }
@@ -59,7 +58,6 @@ void QuicPacketCreator::MaybeStartFEC() {
     fec_group_.reset(new QuicFecGroup());
     packet_size_ = GetPacketHeaderSize(options_.send_guid_length,
                                        send_version_in_packet_,
-                                       options_.send_sequence_number_length,
                                        IN_FEC_GROUP);
     DCHECK_LE(packet_size_, options_.max_packet_length);
   }
@@ -86,10 +84,8 @@ size_t QuicPacketCreator::StreamFramePacketOverhead(
     int num_frames,
     QuicGuidLength guid_length,
     bool include_version,
-    QuicSequenceNumberLength sequence_number_length,
     InFecGroup is_in_fec_group) {
-  return GetPacketHeaderSize(guid_length, include_version,
-                             sequence_number_length, is_in_fec_group) +
+  return GetPacketHeaderSize(guid_length, include_version, is_in_fec_group) +
       QuicFramer::GetMinStreamFrameSize() * num_frames;
 }
 
@@ -100,8 +96,7 @@ size_t QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                             QuicFrame* frame) {
   DCHECK_GT(options_.max_packet_length,
             StreamFramePacketOverhead(
-                1, PACKET_8BYTE_GUID, kIncludeVersion,
-                PACKET_6BYTE_SEQUENCE_NUMBER, IN_FEC_GROUP));
+                1, PACKET_8BYTE_GUID, kIncludeVersion, IN_FEC_GROUP));
   DCHECK(HasRoomForStreamFrame());
 
   const size_t free_bytes = BytesFree();
@@ -165,7 +160,6 @@ SerializedPacket QuicPacketCreator::SerializePacket() {
   queued_frames_.clear();
   packet_size_ = GetPacketHeaderSize(options_.send_guid_length,
                                      send_version_in_packet_,
-                                     options_.send_sequence_number_length,
                                      fec_group_.get() != NULL ?
                                          IN_FEC_GROUP : NOT_IN_FEC_GROUP);
   serialized.retransmittable_frames = queued_retransmittable_frames_.release();
@@ -187,7 +181,6 @@ SerializedPacket QuicPacketCreator::SerializeFec() {
   // Reset packet_size_, since the next packet may not have an FEC group.
   packet_size_ = GetPacketHeaderSize(options_.send_guid_length,
                                      send_version_in_packet_,
-                                     options_.send_sequence_number_length,
                                      NOT_IN_FEC_GROUP);
   DCHECK(serialized.packet);
   DCHECK_GE(options_.max_packet_length, serialized.packet->length());
diff --git a/net/quic/quic_packet_creator.h b/net/quic/quic_packet_creator.h
index 86a5c0e..cb58625 100644
--- a/net/quic/quic_packet_creator.h
+++ b/net/quic/quic_packet_creator.h
@@ -33,8 +33,7 @@ class NET_EXPORT_PRIVATE QuicPacketCreator : public QuicFecBuilderInterface {
         : max_packet_length(kMaxPacketSize),
           random_reorder(false),
           max_packets_per_fec_group(0),
-          send_guid_length(PACKET_8BYTE_GUID),
-          send_sequence_number_length(PACKET_6BYTE_SEQUENCE_NUMBER) {
+          send_guid_length(PACKET_8BYTE_GUID) {
     }
 
     size_t max_packet_length;
@@ -43,7 +42,6 @@ class NET_EXPORT_PRIVATE QuicPacketCreator : public QuicFecBuilderInterface {
     size_t max_packets_per_fec_group;
     // Length of guid to send over the wire.
     QuicGuidLength send_guid_length;
-    QuicSequenceNumberLength send_sequence_number_length;
   };
 
   // QuicRandom* required for packet entropy.
@@ -70,12 +68,10 @@ class NET_EXPORT_PRIVATE QuicPacketCreator : public QuicFecBuilderInterface {
   void StopSendingVersion();
 
   // The overhead the framing will add for a packet with num_frames frames.
-  static size_t StreamFramePacketOverhead(
-      int num_frames,
-      QuicGuidLength guid_length,
-      bool include_version,
-      QuicSequenceNumberLength sequence_number_length,
-      InFecGroup is_in_fec_group);
+  static size_t StreamFramePacketOverhead(int num_frames,
+                                          QuicGuidLength guid_length,
+                                          bool include_version,
+                                          InFecGroup is_in_fec_group);
 
   bool HasRoomForStreamFrame() const;
 
diff --git a/net/quic/quic_packet_creator_test.cc b/net/quic/quic_packet_creator_test.cc
index f972182..8e055b6 100644
--- a/net/quic/quic_packet_creator_test.cc
+++ b/net/quic/quic_packet_creator_test.cc
@@ -246,7 +246,6 @@ TEST_P(QuicPacketCreatorTest, AddFrameAndSerialize) {
             GetPacketHeaderSize(
                 creator_.options()->send_guid_length,
                 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
-                PACKET_6BYTE_SEQUENCE_NUMBER,
                 NOT_IN_FEC_GROUP),
             creator_.BytesFree());
 
@@ -290,7 +289,6 @@ TEST_P(QuicPacketCreatorTest, AddFrameAndSerialize) {
             GetPacketHeaderSize(
                 creator_.options()->send_guid_length,
                 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
-                PACKET_6BYTE_SEQUENCE_NUMBER,
                 NOT_IN_FEC_GROUP),
             creator_.BytesFree());
 }
diff --git a/net/quic/quic_protocol.cc b/net/quic/quic_protocol.cc
index 051a640..2293076 100644
--- a/net/quic/quic_protocol.cc
+++ b/net/quic/quic_protocol.cc
@@ -16,39 +16,31 @@ namespace net {
 size_t GetPacketHeaderSize(QuicPacketHeader header) {
   return GetPacketHeaderSize(header.public_header.guid_length,
                              header.public_header.version_flag,
-                             header.public_header.sequence_number_length,
                              header.is_in_fec_group);
 }
 
 size_t GetPacketHeaderSize(QuicGuidLength guid_length,
                            bool include_version,
-                           QuicSequenceNumberLength sequence_number_length,
                            InFecGroup is_in_fec_group) {
   return kPublicFlagsSize + guid_length +
-      (include_version ? kQuicVersionSize : 0) + sequence_number_length +
+      (include_version ? kQuicVersionSize : 0) + kSequenceNumberSize +
       kPrivateFlagsSize + (is_in_fec_group == IN_FEC_GROUP ? kFecGroupSize : 0);
 }
 
 size_t GetPublicResetPacketSize() {
   return kPublicFlagsSize + PACKET_8BYTE_GUID + kPublicResetNonceSize +
-      PACKET_6BYTE_SEQUENCE_NUMBER;
+      kSequenceNumberSize;
 }
 
-size_t GetStartOfFecProtectedData(
-    QuicGuidLength guid_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length) {
-  return GetPacketHeaderSize(
-      guid_length, include_version, sequence_number_length, IN_FEC_GROUP);
+size_t GetStartOfFecProtectedData(QuicGuidLength guid_length,
+                                  bool include_version) {
+  return GetPacketHeaderSize(guid_length, include_version, IN_FEC_GROUP);
 }
 
-size_t GetStartOfEncryptedData(
-    QuicGuidLength guid_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length) {
+size_t GetStartOfEncryptedData(QuicGuidLength guid_length,
+                               bool include_version) {
   // Don't include the fec size, since encryption starts before private flags.
-  return GetPacketHeaderSize(
-      guid_length, include_version, sequence_number_length, NOT_IN_FEC_GROUP) -
+  return GetPacketHeaderSize(guid_length, include_version, NOT_IN_FEC_GROUP) -
       kPrivateFlagsSize;
 }
 
@@ -63,8 +55,7 @@ QuicPacketPublicHeader::QuicPacketPublicHeader()
     : guid(0),
       guid_length(PACKET_8BYTE_GUID),
       reset_flag(false),
-      version_flag(false),
-      sequence_number_length(PACKET_6BYTE_SEQUENCE_NUMBER) {
+      version_flag(false) {
 }
 
 QuicPacketPublicHeader::QuicPacketPublicHeader(
@@ -73,7 +64,6 @@ QuicPacketPublicHeader::QuicPacketPublicHeader(
       guid_length(other.guid_length),
       reset_flag(other.reset_flag),
       version_flag(other.version_flag),
-      sequence_number_length(other.sequence_number_length),
       versions(other.versions) {
 }
 
@@ -261,6 +251,16 @@ QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
 
 QuicFecData::QuicFecData() {}
 
+bool QuicFecData::operator==(const QuicFecData& other) const {
+  if (fec_group != other.fec_group) {
+    return false;
+  }
+  if (redundancy != other.redundancy) {
+    return false;
+  }
+  return true;
+}
+
 QuicData::~QuicData() {
   if (owns_buffer_) {
     delete [] const_cast<char*>(buffer_);
@@ -268,29 +268,25 @@ QuicData::~QuicData() {
 }
 
 StringPiece QuicPacket::FecProtectedData() const {
-  const size_t start_of_fec = GetStartOfFecProtectedData(
-      guid_length_, includes_version_, sequence_number_length_);
+  const size_t start_of_fec = GetStartOfFecProtectedData(guid_length_,
+                                                         includes_version_);
   return StringPiece(data() + start_of_fec, length() - start_of_fec);
 }
 
 StringPiece QuicPacket::AssociatedData() const {
-  return StringPiece(
-      data() + kStartOfHashData,
-      GetStartOfEncryptedData(
-          guid_length_, includes_version_, sequence_number_length_) -
-      kStartOfHashData);
+  return StringPiece(data() + kStartOfHashData,
+                     GetStartOfEncryptedData(guid_length_, includes_version_) -
+                     kStartOfHashData);
 }
 
 StringPiece QuicPacket::BeforePlaintext() const {
   return StringPiece(data(), GetStartOfEncryptedData(guid_length_,
-                                                     includes_version_,
-                                                     sequence_number_length_));
+                                                     includes_version_));
 }
 
 StringPiece QuicPacket::Plaintext() const {
   const size_t start_of_encrypted_data =
-      GetStartOfEncryptedData(
-          guid_length_, includes_version_, sequence_number_length_);
+      GetStartOfEncryptedData(guid_length_, includes_version_);
   return StringPiece(data() + start_of_encrypted_data,
                      length() - start_of_encrypted_data);
 }
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h
index 608c526..4cde996 100644
--- a/net/quic/quic_protocol.h
+++ b/net/quic/quic_protocol.h
@@ -53,6 +53,8 @@ const size_t kDefaultMaxStreamsPerConnection = 100;
 const size_t kPublicFlagsSize = 1;
 // Number of bytes reserved for version number in the packet header.
 const size_t kQuicVersionSize = 4;
+// Number of bytes reserved for sequence number in the packet header.
+const size_t kSequenceNumberSize = 6;
 // Number of bytes reserved for private flags in the packet header.
 const size_t kPrivateFlagsSize = 1;
 // Number of bytes reserved for FEC group in the packet header.
@@ -117,13 +119,6 @@ enum InFecGroup {
   IN_FEC_GROUP,
 };
 
-enum QuicSequenceNumberLength {
-  PACKET_1BYTE_SEQUENCE_NUMBER = 1,
-  PACKET_2BYTE_SEQUENCE_NUMBER = 2,
-  PACKET_4BYTE_SEQUENCE_NUMBER = 4,
-  PACKET_6BYTE_SEQUENCE_NUMBER = 6
-};
-
 enum QuicPacketPublicFlags {
   PACKET_PUBLIC_FLAGS_NONE = 0,
   PACKET_PUBLIC_FLAGS_VERSION = 1 << 0,  // Packet header contains version info.
@@ -133,12 +128,7 @@ enum QuicPacketPublicFlags {
   PACKET_PUBLIC_FLAGS_1BYTE_GUID = 1 << 2,
   PACKET_PUBLIC_FLAGS_4BYTE_GUID = 1 << 3,
   PACKET_PUBLIC_FLAGS_8BYTE_GUID = 1 << 3 | 1 << 2,
-  // Packet sequence number length in bytes.
-  PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE = 0,
-  PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE = 1 << 4,
-  PACKET_PUBLIC_FLAGS_4BYTE_SEQUENCE = 1 << 5,
-  PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE = 1 << 5 | 1 << 4,
-  PACKET_PUBLIC_FLAGS_MAX = (1 << 6) - 1  // All bits set.
+  PACKET_PUBLIC_FLAGS_MAX = (1 << 4) - 1  // All bits set.
 };
 
 enum QuicPacketPrivateFlags {
@@ -152,25 +142,19 @@ enum QuicPacketPrivateFlags {
 // Size in bytes of the data or fec packet header.
 NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicPacketHeader header);
 
-NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(
-    QuicGuidLength guid_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length,
-    InFecGroup is_in_fec_group);
+NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicGuidLength guid_length,
+                                              bool include_version,
+                                              InFecGroup is_in_fec_group);
 
 // Size in bytes of the public reset packet.
 NET_EXPORT_PRIVATE size_t GetPublicResetPacketSize();
 
 // Index of the first byte in a QUIC packet of FEC protected data.
-NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(
-    QuicGuidLength guid_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length);
+NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(QuicGuidLength guid_length,
+                                                     bool include_version);
 // Index of the first byte in a QUIC packet of encrypted data.
-NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(
-    QuicGuidLength guid_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length);
+NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(QuicGuidLength guid_length,
+                                                  bool include_version);
 
 enum QuicRstStreamErrorCode {
   QUIC_STREAM_NO_ERROR = 0,
@@ -311,7 +295,7 @@ const QuicTag kUnsupportedVersion = -1;
 // Each time the wire format changes, this need needs to be incremented.
 // At some point, we will actually freeze the wire format and make an official
 // version number, but this works for now.
-const QuicTag kQuicVersion1 = TAG('Q', '0', '0', '6');
+const QuicTag kQuicVersion1 = TAG('Q', '0', '0', '5');
 #undef TAG
 
 // MakeQuicTag returns a value given the four bytes. For example:
@@ -330,7 +314,6 @@ struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
   QuicGuidLength guid_length;
   bool reset_flag;
   bool version_flag;
-  QuicSequenceNumberLength sequence_number_length;
   QuicTagVector versions;
 };
 
@@ -594,6 +577,8 @@ typedef std::vector<QuicFrame> QuicFrames;
 struct NET_EXPORT_PRIVATE QuicFecData {
   QuicFecData();
 
+  bool operator==(const QuicFecData& other) const;
+
   // The FEC group number is also the sequence number of the first
   // FEC protected packet.  The last protected packet's sequence number will
   // be one less than the sequence number of the FEC packet.
@@ -636,26 +621,22 @@ class NET_EXPORT_PRIVATE QuicData {
 
 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
-  static QuicPacket* NewDataPacket(
-      char* buffer,
-      size_t length,
-      bool owns_buffer,
-      QuicGuidLength guid_length,
-      bool includes_version,
-      QuicSequenceNumberLength sequence_number_length) {
-    return new QuicPacket(buffer, length, owns_buffer, guid_length,
-                          includes_version, sequence_number_length, false);
+  static QuicPacket* NewDataPacket(char* buffer,
+                                   size_t length,
+                                   bool owns_buffer,
+                                   QuicGuidLength guid_length,
+                                   bool includes_version) {
+    return new QuicPacket(
+        buffer, length, owns_buffer, guid_length, includes_version, false);
   }
 
-  static QuicPacket* NewFecPacket(
-      char* buffer,
-      size_t length,
-      bool owns_buffer,
-      QuicGuidLength guid_length,
-      bool includes_version,
-      QuicSequenceNumberLength sequence_number_length) {
-    return new QuicPacket(buffer, length, owns_buffer, guid_length,
-                          includes_version, sequence_number_length, true);
+  static QuicPacket* NewFecPacket(char* buffer,
+                                  size_t length,
+                                  bool owns_buffer,
+                                  QuicGuidLength guid_length,
+                                  bool includes_version) {
+    return new QuicPacket(
+        buffer, length, owns_buffer, guid_length, includes_version, true);
   }
 
   base::StringPiece FecProtectedData() const;
@@ -675,20 +656,17 @@ class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
              bool owns_buffer,
              QuicGuidLength guid_length,
              bool includes_version,
-             QuicSequenceNumberLength sequence_number_length,
              bool is_fec_packet)
       : QuicData(buffer, length, owns_buffer),
         buffer_(buffer),
         is_fec_packet_(is_fec_packet),
         guid_length_(guid_length),
-        includes_version_(includes_version),
-        sequence_number_length_(sequence_number_length) {}
+        includes_version_(includes_version) {}
 
   char* buffer_;
   const bool is_fec_packet_;
   const QuicGuidLength guid_length_;
   const bool includes_version_;
-  const QuicSequenceNumberLength sequence_number_length_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacket);
 };
diff --git a/net/quic/quic_session.cc b/net/quic/quic_session.cc
index 3df8b0a..2ed5b07 100644
--- a/net/quic/quic_session.cc
+++ b/net/quic/quic_session.cc
@@ -14,8 +14,6 @@ using std::vector;
 
 namespace net {
 
-#define ENDPOINT (is_server_ ? "Server: " : " Client: ")
-
 // We want to make sure we delete any closed streams in a safe manner.
 // To avoid deleting a stream in mid-operation, we have a simple shim between
 // us and the stream, so we can delete any streams when we return from
@@ -76,7 +74,6 @@ QuicSession::QuicSession(QuicConnection* connection,
       next_stream_id_(is_server ? 2 : 3),
       is_server_(is_server),
       largest_peer_created_stream_id_(0),
-      error_(QUIC_NO_ERROR),
       goaway_received_(false),
       goaway_sent_(false) {
   set_max_open_streams(config_.max_streams_per_connection());
@@ -98,7 +95,7 @@ bool QuicSession::OnPacket(const IPEndPoint& self_address,
                            const QuicPacketHeader& header,
                            const vector<QuicStreamFrame>& frames) {
   if (header.public_header.guid != connection()->guid()) {
-    DLOG(INFO) << ENDPOINT << "Got packet header for invalid GUID: "
+    DLOG(INFO) << "Got packet header for invalid GUID: "
                << header.public_header.guid;
     return false;
   }
@@ -152,17 +149,13 @@ void QuicSession::OnGoAway(const QuicGoAwayFrame& frame) {
 }
 
 void QuicSession::ConnectionClose(QuicErrorCode error, bool from_peer) {
-  if (error_ == QUIC_NO_ERROR) {
-    error_ = error;
-  }
-
   while (stream_map_.size() != 0) {
     ReliableStreamMap::iterator it = stream_map_.begin();
     QuicStreamId id = it->first;
     it->second->ConnectionClose(error, from_peer);
     // The stream should call CloseStream as part of ConnectionClose.
     if (stream_map_.find(id) != stream_map_.end()) {
-      LOG(DFATAL) << ENDPOINT << "Stream failed to close under ConnectionClose";
+      LOG(DFATAL) << "Stream failed to close under ConnectionClose";
       CloseStream(id);
     }
   }
@@ -208,11 +201,11 @@ void QuicSession::SendGoAway(QuicErrorCode error_code, const string& reason) {
 }
 
 void QuicSession::CloseStream(QuicStreamId stream_id) {
-  DLOG(INFO) << ENDPOINT << "Closing stream " << stream_id;
+  DLOG(INFO) << "Closing stream " << stream_id;
 
   ReliableStreamMap::iterator it = stream_map_.find(stream_id);
   if (it == stream_map_.end()) {
-    DLOG(INFO) << ENDPOINT << "Stream is already closed: " << stream_id;
+    DLOG(INFO) << "Stream is already closed: " << stream_id;
     return;
   }
   ReliableQuicStream* stream = it->second;
@@ -244,7 +237,7 @@ void QuicSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
       break;
 
     case HANDSHAKE_CONFIRMED:
-      LOG_IF(DFATAL, !config_.negotiated()) << ENDPOINT
+      LOG_IF(DFATAL, !config_.negotiated())
           << "Handshake confirmed without parameter negotiation.";
       connection_->SetIdleNetworkTimeout(
           config_.idle_connection_state_lifetime());
@@ -253,7 +246,7 @@ void QuicSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
       break;
 
     default:
-      LOG(ERROR) << ENDPOINT << "Got unknown handshake event: " << event;
+      LOG(ERROR) << "Got unknown handshake event: " << event;
   }
 }
 
@@ -262,8 +255,8 @@ QuicConfig* QuicSession::config() {
 }
 
 void QuicSession::ActivateStream(ReliableQuicStream* stream) {
-  DLOG(INFO) << ENDPOINT << "num_streams: " << stream_map_.size()
-             << ". activating " << stream->id();
+  DLOG(INFO) << "num_streams: " << stream_map_.size()
+            << ". activating " << stream->id();
   DCHECK(stream_map_.count(stream->id()) == 0);
   stream_map_[stream->id()] = stream;
 }
diff --git a/net/quic/quic_session.h b/net/quic/quic_session.h
index 5f85dd6..e5793d7 100644
--- a/net/quic/quic_session.h
+++ b/net/quic/quic_session.h
@@ -114,7 +114,6 @@ class NET_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface {
   bool IsClosedStream(QuicStreamId id);
 
   QuicConnection* connection() { return connection_.get(); }
-  const QuicConnection* connection() const { return connection_.get(); }
   size_t num_active_requests() const { return stream_map_.size(); }
   const IPEndPoint& peer_address() const {
     return connection_->peer_address();
@@ -145,8 +144,6 @@ class NET_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface {
   QuicSpdyDecompressor* decompressor() { return &decompressor_; }
   QuicSpdyCompressor* compressor() { return &compressor_; }
 
-  QuicErrorCode error() const { return error_; }
-
  protected:
   // Creates a new stream, owned by the caller, to handle a peer-initiated
   // stream.  Returns NULL and does error handling if the stream can not be
@@ -177,11 +174,6 @@ class NET_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface {
   base::hash_map<QuicStreamId, ReliableQuicStream*>* streams() {
     return &stream_map_;
   }
-
-  const base::hash_map<QuicStreamId, ReliableQuicStream*>* streams() const {
-    return &stream_map_;
-  }
-
   std::vector<ReliableQuicStream*>* closed_streams() {
     return &closed_streams_;
   }
@@ -236,9 +228,6 @@ class NET_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface {
 
   QuicStreamId largest_peer_created_stream_id_;
 
-  // The latched error with which the connection was closed.
-  QuicErrorCode error_;
-
   // Whether a GoAway has been received.
   bool goaway_received_;
   // Whether a GoAway has been sent.
diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index 781d971..608fdcf 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -129,12 +129,21 @@ TEST_F(QuicStreamFactoryTest, CreateIfSessionExists) {
 }
 
 TEST_F(QuicStreamFactoryTest, Create) {
+  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(1, 3));
+  scoped_ptr<QuicEncryptedPacket> rst5(ConstructRstPacket(2, 5));
+  scoped_ptr<QuicEncryptedPacket> rst7(ConstructRstPacket(3, 7));
+  MockWrite writes[] = {
+    MockWrite(SYNCHRONOUS, rst3->data(), rst3->length(), 0),
+    MockWrite(SYNCHRONOUS, rst5->data(), rst5->length(), 1),
+    MockWrite(SYNCHRONOUS, rst7->data(), rst7->length(), 2),
+  };
   MockRead reads[] = {
-    MockRead(ASYNC, OK, 0)  // EOF
+    MockRead(ASYNC, OK, 3)  // EOF
   };
-  DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+  DeterministicSocketData socket_data(reads, arraysize(reads),
+                                      writes, arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
-  socket_data.StopAfter(1);
+  socket_data.StopAfter(3);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, net_log_,
@@ -154,6 +163,8 @@ TEST_F(QuicStreamFactoryTest, Create) {
   stream = request2.ReleaseStream();  // Will reset stream 5.
   stream.reset();  // Will reset stream 7.
 
+  socket_data.RunFor(1);
+
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
@@ -175,10 +186,16 @@ TEST_F(QuicStreamFactoryTest, CreateError) {
 }
 
 TEST_F(QuicStreamFactoryTest, CancelCreate) {
+  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(1, 3));
+
+  MockWrite writes[] = {
+    MockWrite(SYNCHRONOUS, rst3->data(), rst3->length(), 0),
+  };
   MockRead reads[] = {
-    MockRead(ASYNC, OK, 0)  // EOF
+    MockRead(ASYNC, OK, 1)  // EOF
   };
-  DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+  DeterministicSocketData socket_data(reads, arraysize(reads),
+                                      writes, arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
   {
     QuicStreamRequest request(&factory_);
@@ -186,7 +203,7 @@ TEST_F(QuicStreamFactoryTest, CancelCreate) {
                                               callback_.callback()));
   }
 
-  socket_data.StopAfter(1);
+  socket_data.StopAfter(2);
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
@@ -195,22 +212,30 @@ TEST_F(QuicStreamFactoryTest, CancelCreate) {
   EXPECT_TRUE(stream.get());
   stream.reset();
 
+  socket_data.RunFor(1);
+
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
 TEST_F(QuicStreamFactoryTest, CloseAllSessions) {
+  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(1, 3));
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
-  DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+  DeterministicSocketData socket_data(reads, arraysize(reads),
+                                      NULL, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
+  MockWrite writes2[] = {
+    MockWrite(SYNCHRONOUS, rst3->data(), rst3->length(), 0),
+  };
   MockRead reads2[] = {
-    MockRead(ASYNC, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 1)  // EOF
   };
-  DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
+  DeterministicSocketData socket_data2(reads2, arraysize(reads2),
+                                        writes2, arraysize(writes2));
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
@@ -237,6 +262,8 @@ TEST_F(QuicStreamFactoryTest, CloseAllSessions) {
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
+  socket_data2.RunFor(1);
+
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
@@ -244,17 +271,23 @@ TEST_F(QuicStreamFactoryTest, CloseAllSessions) {
 }
 
 TEST_F(QuicStreamFactoryTest, OnIPAddressChanged) {
+  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(1, 3));
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
-  DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+  DeterministicSocketData socket_data(reads, arraysize(reads),
+                                      NULL, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
+  MockWrite writes2[] = {
+    MockWrite(SYNCHRONOUS, rst3->data(), rst3->length(), 0),
+  };
   MockRead reads2[] = {
-    MockRead(ASYNC, 0, 0)  // EOF
+    MockRead(ASYNC, 0, 1)  // EOF
   };
-  DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
+  DeterministicSocketData socket_data2(reads2, arraysize(reads2),
+                                        writes2, arraysize(writes2));
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
@@ -281,6 +314,8 @@ TEST_F(QuicStreamFactoryTest, OnIPAddressChanged) {
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
+  socket_data2.RunFor(1);
+
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
diff --git a/net/quic/reliable_quic_stream.cc b/net/quic/reliable_quic_stream.cc
index 144c908..0ed990e 100644
--- a/net/quic/reliable_quic_stream.cc
+++ b/net/quic/reliable_quic_stream.cc
@@ -95,12 +95,7 @@ void ReliableQuicStream::TerminateFromPeer(bool half_close) {
 
 void ReliableQuicStream::Close(QuicRstStreamErrorCode error) {
   stream_error_ = error;
-  if (error != QUIC_STREAM_NO_ERROR)  {
-    // Sending a RstStream results in calling CloseStream.
-    session()->SendRstStream(id(), error);
-  } else {
-    session_->CloseStream(id());
-  }
+  session()->SendRstStream(id(), error);
 }
 
 int ReliableQuicStream::Readv(const struct iovec* iov, size_t iov_len) {
@@ -160,7 +155,6 @@ QuicSpdyCompressor* ReliableQuicStream::compressor() {
 }
 
 QuicConsumedData ReliableQuicStream::WriteData(StringPiece data, bool fin) {
-  DCHECK(data.size() > 0 || fin);
   return WriteOrBuffer(data, fin);
 }
 
@@ -218,8 +212,6 @@ QuicConsumedData ReliableQuicStream::WriteDataInternal(
     if (fin && consumed_data.fin_consumed) {
       fin_sent_ = true;
       CloseWriteSide();
-    } else if (fin && !consumed_data.fin_consumed) {
-      session_->MarkWriteBlocked(id());
     }
   } else {
     session_->MarkWriteBlocked(id());
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/reliable_quic_stream_test.cc
index 2350c7c..54f97e8 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/reliable_quic_stream_test.cc
@@ -9,7 +9,6 @@
 #include "net/quic/quic_spdy_decompressor.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/spdy_utils.h"
-#include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ -79,8 +78,6 @@ class ReliableQuicStreamTest : public ::testing::TestWithParam<bool> {
                                  stream_should_process_data));
     compressor_.reset(new QuicSpdyCompressor());
     decompressor_.reset(new QuicSpdyDecompressor);
-    write_blocked_list_ =
-        QuicSessionPeer::GetWriteblockedStreams(session_.get());
   }
 
  protected:
@@ -91,7 +88,6 @@ class ReliableQuicStreamTest : public ::testing::TestWithParam<bool> {
   scoped_ptr<QuicSpdyCompressor> compressor_;
   scoped_ptr<QuicSpdyDecompressor> decompressor_;
   SpdyHeaderBlock headers_;
-  BlockedList<QuicStreamId>* write_blocked_list_;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
@@ -99,82 +95,26 @@ TEST_F(ReliableQuicStreamTest, WriteAllData) {
 
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
-          1, PACKET_8BYTE_GUID, !kIncludeVersion,
-          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
+          1, PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP);
   // TODO(rch): figure out how to get StrEq working here.
   //EXPECT_CALL(*session_, WriteData(kStreamId, StrEq(kData1), _, _)).WillOnce(
   EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
   EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);
-  EXPECT_TRUE(write_blocked_list_->IsEmpty());
-}
-
-#if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
-TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
-  Initialize(kShouldProcessData);
-
-  // Write no data and no fin.  If we consume nothing we should not be write
-  // blocked.
-  EXPECT_DEBUG_DEATH({
-    EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
-        Return(QuicConsumedData(0, false)));
-    stream_->WriteData(StringPiece(), false);
-  EXPECT_TRUE(write_blocked_list_->IsEmpty());
-  }, "");
-}
-#endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
-
-TEST_F(ReliableQuicStreamTest, BlockIfOnlySomeDataConsumed) {
-  Initialize(kShouldProcessData);
-
-  // Write some data and no fin.  If we consume some but not all of the data,
-  // we should be write blocked a not all the data was consumed.
-  EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
-      Return(QuicConsumedData(1, false)));
-  stream_->WriteData(StringPiece(kData1, 2), false);
-  ASSERT_EQ(1, write_blocked_list_->NumObjects());
-}
-
-
-TEST_F(ReliableQuicStreamTest, BlockIfFinNotConsumedWithData) {
-  Initialize(kShouldProcessData);
-
-  // Write some data and no fin.  If we consume all the data but not the fin,
-  // we should be write blocked because the fin was not consumed.
-  // (This should never actually happen as the fin should be sent out with the
-  // last data)
-  EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
-      Return(QuicConsumedData(2, false)));
-  stream_->WriteData(StringPiece(kData1, 2), true);
-  ASSERT_EQ(1, write_blocked_list_->NumObjects());
-}
-
-TEST_F(ReliableQuicStreamTest, BlockIfSoloFinNotConsumed) {
-  Initialize(kShouldProcessData);
-
-  // Write no data and a fin.  If we consume nothing we should be write blocked,
-  // as the fin was not consumed.
-  EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
-      Return(QuicConsumedData(0, false)));
-  stream_->WriteData(StringPiece(), true);
-  ASSERT_EQ(1, write_blocked_list_->NumObjects());
 }
 
 TEST_F(ReliableQuicStreamTest, WriteData) {
   Initialize(kShouldProcessData);
 
-  EXPECT_TRUE(write_blocked_list_->IsEmpty());
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
-          1, PACKET_8BYTE_GUID, !kIncludeVersion,
-          PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
+          1, PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP);
   // TODO(rch): figure out how to get StrEq working here.
   //EXPECT_CALL(*session_, WriteData(_, StrEq(kData1), _, _)).WillOnce(
   EXPECT_CALL(*session_, WriteData(_, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen - 1, false)));
   // The return will be kDataLen, because the last byte gets buffered.
   EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);
-  EXPECT_FALSE(write_blocked_list_->IsEmpty());
 
   // Queue a bytes_consumed write.
   EXPECT_EQ(kDataLen, stream_->WriteData(kData2, false).bytes_consumed);
diff --git a/net/quic/test_tools/quic_framer_peer.cc b/net/quic/test_tools/quic_framer_peer.cc
index f31299c..49315f0 100644
--- a/net/quic/test_tools/quic_framer_peer.cc
+++ b/net/quic/test_tools/quic_framer_peer.cc
@@ -13,10 +13,8 @@ namespace test {
 // static
 QuicPacketSequenceNumber QuicFramerPeer::CalculatePacketSequenceNumberFromWire(
     QuicFramer* framer,
-    QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber packet_sequence_number) {
-  return framer->CalculatePacketSequenceNumberFromWire(sequence_number_length,
-                                                       packet_sequence_number);
+  return framer->CalculatePacketSequenceNumberFromWire(packet_sequence_number);
 }
 
 // static
diff --git a/net/quic/test_tools/quic_framer_peer.h b/net/quic/test_tools/quic_framer_peer.h
index 7a2da5c..6d4a1e1 100644
--- a/net/quic/test_tools/quic_framer_peer.h
+++ b/net/quic/test_tools/quic_framer_peer.h
@@ -17,7 +17,6 @@ class QuicFramerPeer {
  public:
   static QuicPacketSequenceNumber CalculatePacketSequenceNumberFromWire(
       QuicFramer* framer,
-      QuicSequenceNumberLength sequence_number_length,
       QuicPacketSequenceNumber packet_sequence_number);
   static void SetLastSerializedGuid(QuicFramer* framer, QuicGuid guid);
   static void SetLastSequenceNumber(
diff --git a/net/quic/test_tools/quic_session_peer.cc b/net/quic/test_tools/quic_session_peer.cc
index 66caa15..0a81ca9 100644
--- a/net/quic/test_tools/quic_session_peer.cc
+++ b/net/quic/test_tools/quic_session_peer.cc
@@ -5,7 +5,6 @@
 #include "net/quic/test_tools/quic_session_peer.h"
 
 #include "net/quic/quic_session.h"
-#include "net/quic/reliable_quic_stream.h"
 
 namespace net {
 namespace test {
@@ -21,17 +20,5 @@ void QuicSessionPeer::SetMaxOpenStreams(QuicSession* session,
   session->max_open_streams_ = max_streams;
 }
 
-// static
-ReliableQuicStream* QuicSessionPeer::CreateIncomingReliableStream(
-    QuicSession* session, QuicStreamId id) {
-  return session->CreateIncomingReliableStream(id);
-}
-
-// static
-BlockedList<QuicStreamId>* QuicSessionPeer::GetWriteblockedStreams(
-    QuicSession* session) {
-  return &session->write_blocked_streams_;
-}
-
 }  // namespace test
 }  // namespace net
diff --git a/net/quic/test_tools/quic_session_peer.h b/net/quic/test_tools/quic_session_peer.h
index 6f9a8f3..9aff659 100644
--- a/net/quic/test_tools/quic_session_peer.h
+++ b/net/quic/test_tools/quic_session_peer.h
@@ -5,13 +5,11 @@
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_SESSION_PEER_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_SESSION_PEER_H_
 
-#include "net/quic/blocked_list.h"
 #include "net/quic/quic_protocol.h"
 
 namespace net {
 
 class QuicSession;
-class ReliableQuicStream;
 
 namespace test {
 
@@ -19,10 +17,6 @@ class QuicSessionPeer {
  public:
   static void SetNextStreamId(QuicSession* session, QuicStreamId id);
   static void SetMaxOpenStreams(QuicSession* session, uint32 max_streams);
-  static ReliableQuicStream* CreateIncomingReliableStream(QuicSession* session,
-                                                          QuicStreamId id);
-  static BlockedList<QuicStreamId>* GetWriteblockedStreams(
-      QuicSession* session);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicSessionPeer);
diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index a8c67f7..0d649d3 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -386,13 +386,11 @@ size_t GetPacketLengthForOneStream(
   // TODO(wtc): the hardcoded use of NullEncrypter here seems wrong.
   size_t packet_length = NullEncrypter().GetCiphertextSize(payload) +
       QuicPacketCreator::StreamFramePacketOverhead(
-          1, PACKET_8BYTE_GUID, include_version,
-          PACKET_6BYTE_SEQUENCE_NUMBER, is_in_fec_group);
+          1, PACKET_8BYTE_GUID, include_version, is_in_fec_group);
 
   size_t ack_length = NullEncrypter().GetCiphertextSize(
       QuicFramer::GetMinAckFrameSize()) +
-      GetPacketHeaderSize(PACKET_8BYTE_GUID, include_version,
-                          PACKET_6BYTE_SEQUENCE_NUMBER, is_in_fec_group);
+      GetPacketHeaderSize(PACKET_8BYTE_GUID, include_version, is_in_fec_group);
   // Make sure that if we change the size of the packet length for one stream
   // or the ack frame; that all our test are configured correctly.
   DCHECK_GE(packet_length, ack_length);