Remove a number of public static methods from QuicFramer.

Merge internal change: 58384533

R=rch@chromium.org

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

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

3 files changed, 28 insertions, 81 deletions

diff --git a/net/quic/quic_framer.cc b/net/quic/quic_framer.cc
index 610dc57..9ca8a3d 100644
--- a/net/quic/quic_framer.cc
+++ b/net/quic/quic_framer.cc
@@ -108,6 +108,34 @@ QuicPacketSequenceNumber ClosestTo(QuicPacketSequenceNumber target,
   return (Delta(target, a) < Delta(target, b)) ? a : b;
 }
 
+QuicSequenceNumberLength ReadSequenceNumberLength(uint8 flags) {
+  switch (flags & PACKET_FLAGS_6BYTE_SEQUENCE) {
+    case PACKET_FLAGS_6BYTE_SEQUENCE:
+      return PACKET_6BYTE_SEQUENCE_NUMBER;
+    case PACKET_FLAGS_4BYTE_SEQUENCE:
+      return PACKET_4BYTE_SEQUENCE_NUMBER;
+    case PACKET_FLAGS_2BYTE_SEQUENCE:
+      return PACKET_2BYTE_SEQUENCE_NUMBER;
+    case PACKET_FLAGS_1BYTE_SEQUENCE:
+      return PACKET_1BYTE_SEQUENCE_NUMBER;
+    default:
+      LOG(DFATAL) << "Unreachable case statement.";
+      return PACKET_6BYTE_SEQUENCE_NUMBER;
+  }
+}
+
+bool CanTruncate(
+    QuicVersion version, const QuicFrame& frame, size_t free_bytes) {
+  if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) &&
+      free_bytes >=
+          QuicFramer::GetMinAckFrameSize(version,
+                                         PACKET_6BYTE_SEQUENCE_NUMBER,
+                                         PACKET_6BYTE_SEQUENCE_NUMBER)) {
+    return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 QuicFramer::QuicFramer(const QuicVersionVector& supported_versions,
@@ -206,18 +234,6 @@ size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
       number_versions * kQuicVersionSize;
 }
 
-// static
-bool QuicFramer::CanTruncate(
-    QuicVersion version, const QuicFrame& frame, size_t free_bytes) {
-  if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) &&
-      free_bytes >= GetMinAckFrameSize(version,
-                                       PACKET_6BYTE_SEQUENCE_NUMBER,
-                                       PACKET_6BYTE_SEQUENCE_NUMBER)) {
-    return true;
-  }
-  return false;
-}
-
 bool QuicFramer::IsSupportedVersion(const QuicVersion version) const {
   for (size_t i = 0; i < supported_versions_.size(); ++i) {
     if (version == supported_versions_[i]) {
@@ -814,23 +830,6 @@ bool QuicFramer::ReadGuidFromPacket(const QuicEncryptedPacket& packet,
 }
 
 // static
-QuicSequenceNumberLength QuicFramer::ReadSequenceNumberLength(uint8 flags) {
-  switch (flags & PACKET_FLAGS_6BYTE_SEQUENCE) {
-    case PACKET_FLAGS_6BYTE_SEQUENCE:
-      return PACKET_6BYTE_SEQUENCE_NUMBER;
-    case PACKET_FLAGS_4BYTE_SEQUENCE:
-      return PACKET_4BYTE_SEQUENCE_NUMBER;
-    case PACKET_FLAGS_2BYTE_SEQUENCE:
-      return PACKET_2BYTE_SEQUENCE_NUMBER;
-    case PACKET_FLAGS_1BYTE_SEQUENCE:
-      return PACKET_1BYTE_SEQUENCE_NUMBER;
-    default:
-      LOG(DFATAL) << "Unreachable case statement.";
-      return PACKET_6BYTE_SEQUENCE_NUMBER;
-  }
-}
-
-// static
 QuicSequenceNumberLength QuicFramer::GetMinSequenceNumberLength(
     QuicPacketSequenceNumber sequence_number) {
   if (sequence_number < 1 << (PACKET_1BYTE_SEQUENCE_NUMBER * 8)) {
@@ -1774,24 +1773,6 @@ bool QuicFramer::HasVersionFlag(const QuicEncryptedPacket& packet) {
       (packet.data()[0] & PACKET_PUBLIC_FLAGS_VERSION) != 0;
 }
 
-// static
-QuicPacketSequenceNumber QuicFramer::CalculateLargestObserved(
-    const SequenceNumberSet& missing_packets,
-    SequenceNumberSet::const_iterator largest_written) {
-  SequenceNumberSet::const_iterator it = largest_written;
-  QuicPacketSequenceNumber previous_missing = *it;
-  ++it;
-
-  // See if the next thing is a gap in the missing packets: if it's a
-  // non-missing packet we can return it.
-  if (it != missing_packets.end() && previous_missing + 1 != *it) {
-    return *it - 1;
-  }
-
-  // Otherwise return the largest missing packet, as indirectly observed.
-  return *largest_written;
-}
-
 void QuicFramer::set_version(const QuicVersion version) {
   DCHECK(IsSupportedVersion(version));
   quic_version_ = version;
diff --git a/net/quic/quic_framer.h b/net/quic/quic_framer.h
index 01280f7..4e68159 100644
--- a/net/quic/quic_framer.h
+++ b/net/quic/quic_framer.h
@@ -170,13 +170,6 @@ class NET_EXPORT_PRIVATE QuicFramer {
   // Returns true if the version flag is set in the public flags.
   static bool HasVersionFlag(const QuicEncryptedPacket& packet);
 
-  // Calculates the largest observed packet to advertise in the case an Ack
-  // Frame was truncated.  last_written in this case is the iterator for the
-  // last missing packet which fit in the outgoing ack.
-  static QuicPacketSequenceNumber CalculateLargestObserved(
-      const SequenceNumberSet& missing_packets,
-      SequenceNumberSet::const_iterator last_written);
-
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
@@ -262,10 +255,6 @@ class NET_EXPORT_PRIVATE QuicFramer {
   // Size in bytes required for a serialized version negotiation packet
   static size_t GetVersionNegotiationPacketSize(size_t number_versions);
 
-
-  static bool CanTruncate(
-      QuicVersion version, const QuicFrame& frame, size_t free_bytes);
-
   // Returns the number of bytes added to the packet for the specified frame,
   // and 0 if the frame doesn't fit.  Includes the header size for the first
   // frame.
@@ -355,8 +344,6 @@ class NET_EXPORT_PRIVATE QuicFramer {
   static bool ReadGuidFromPacket(const QuicEncryptedPacket& packet,
                                  QuicGuid* guid);
 
-  static QuicSequenceNumberLength ReadSequenceNumberLength(uint8 flags);
-
   // The minimum sequence number length required to represent |sequence_number|.
   static QuicSequenceNumberLength GetMinSequenceNumberLength(
       QuicPacketSequenceNumber sequence_number);
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index eef4a58..6fa07e0 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -3253,27 +3253,6 @@ TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) {
   EXPECT_TRUE(CheckEncryption(sequence_number, raw.get()));
 }
 
-// TODO(rch): re-enable after https://codereview.chromium.org/11820005/
-// lands.  Currently this is causing valgrind problems, but it should be
-// fixed in the followup CL.
-TEST_P(QuicFramerTest, DISABLED_CalculateLargestReceived) {
-  SequenceNumberSet missing;
-  missing.insert(1);
-  missing.insert(5);
-  missing.insert(7);
-
-  // These two we just walk to the next gap, and return the largest seen.
-  EXPECT_EQ(4u, QuicFramer::CalculateLargestObserved(missing, missing.find(1)));
-  EXPECT_EQ(6u, QuicFramer::CalculateLargestObserved(missing, missing.find(5)));
-
-  missing.insert(2);
-  // For 1, we can't go forward as 2 would be implicitly acked so we return the
-  // largest missing packet.
-  EXPECT_EQ(1u, QuicFramer::CalculateLargestObserved(missing, missing.find(1)));
-  // For 2, we've seen 3 and 4, so can admit to a largest observed.
-  EXPECT_EQ(4u, QuicFramer::CalculateLargestObserved(missing, missing.find(2)));
-}
-
 // TODO(rch) enable after landing the revised truncation CL.
 TEST_P(QuicFramerTest, DISABLED_Truncation) {
   QuicPacketHeader header;