Remove unused version argument from QuicFramerTest's

net/quic/quic_framer_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_framer.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 28 matching lines @@
 const QuicPacketSequenceNumber kEpoch = GG_UINT64_C(1) << 48;
 const QuicPacketSequenceNumber kMask = kEpoch - 1;
 
 // Index into the connection_id offset in the header.
 const size_t kConnectionIdOffset = kPublicFlagsSize;
 // Index into the version string in the header. (if present).
 const size_t kVersionOffset = kConnectionIdOffset + PACKET_8BYTE_CONNECTION_ID;
 
 // Size in bytes of the stream frame fields for an arbitrary StreamID and
 // offset and the last frame in a packet.
-size_t GetMinStreamFrameSize(QuicVersion version) {
+size_t GetMinStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize;
 }
 
 // Index into the sequence number offset in the header.
 size_t GetSequenceNumberOffset(QuicConnectionIdLength connection_id_length,
                                bool include_version) {
   return kConnectionIdOffset + connection_id_length +
       (include_version ? kQuicVersionSize : 0);
 }
 
@@ skipping 394 matching lines @@
   // Checks if the supplied string matches data in the supplied StreamFrame.
   void CheckStreamFrameData(string str, QuicStreamFrame* frame) {
     scoped_ptr<string> frame_data(frame->GetDataAsString());
     EXPECT_EQ(str, *frame_data);
   }
 
   void CheckStreamFrameBoundaries(unsigned char* packet,
                                   size_t stream_id_size,
                                   bool include_version) {
     // Now test framing boundaries
-    for (size_t i = kQuicFrameTypeSize;
-         i < GetMinStreamFrameSize(framer_.version()); ++i) {
+    for (size_t i = kQuicFrameTypeSize; i < GetMinStreamFrameSize(); ++i) {
       string expected_error;
       if (i < kQuicFrameTypeSize + stream_id_size) {
         expected_error = "Unable to read stream_id.";
       } else if (i < kQuicFrameTypeSize + stream_id_size +
                  kQuicMaxStreamOffsetSize) {
         expected_error = "Unable to read offset.";
       } else {
         expected_error = "Unable to read frame data.";
       }
       CheckProcessingFails(
@@ skipping 3851 matching lines @@
   EXPECT_CALL(visitor, OnPacketComplete());
   EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true));
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
 }
 
 }  // namespace test
 }  // namespace net