Automated rollback of internal change 130388085.

net/quic/core/quic_protocol.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 38 matching lines @@
 // QuicTag is the type of a tag in the wire protocol.
 typedef uint32_t QuicTag;
 typedef std::vector<QuicTag> QuicTagVector;
 typedef std::map<QuicTag, std::string> QuicTagValueMap;
 typedef uint16_t QuicPacketLength;
 
 // Default initial maximum size in bytes of a QUIC packet.
 const QuicByteCount kDefaultMaxPacketSize = 1350;
 // Default initial maximum size in bytes of a QUIC packet for servers.
 const QuicByteCount kDefaultServerMaxPacketSize = 1000;
-// Minimum size of a QUIC packet, used if a server receives packets from a
-// client with unusual network headers. 1280 - sizeof(eth) - sizeof(ipv6).
-const QuicByteCount kMinimumSupportedPacketSize = 1214;
 // The maximum packet size of any QUIC packet, based on ethernet's max size,
 // minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
 // additional 8 bytes.  This is a total overhead of 48 bytes.  Ethernet's
 // max packet size is 1500 bytes,  1500 - 48 = 1452.
 const QuicByteCount kMaxPacketSize = 1452;
 // Default maximum packet size used in the Linux TCP implementation.
 // Used in QUIC for congestion window computations in bytes.
 const QuicByteCount kDefaultTCPMSS = 1460;
 
 // We match SPDY's use of 32 (since we'd compete with SPDY).
@@ skipping 1241 matching lines @@
  public:
   QuicReceivedPacket(const char* buffer, size_t length, QuicTime receipt_time);
   QuicReceivedPacket(const char* buffer,
                      size_t length,
                      QuicTime receipt_time,
                      bool owns_buffer);
   QuicReceivedPacket(const char* buffer,
                      size_t length,
                      QuicTime receipt_time,
                      bool owns_buffer,
-                     bool potentially_small_mtu,
                      int ttl,
                      bool ttl_valid);
 
   // Clones the packet into a new packet which owns the buffer.
   QuicReceivedPacket* Clone() const;
 
   // Returns the time at which the packet was received.
   QuicTime receipt_time() const { return receipt_time_; }
 
   // This is the TTL of the packet, assuming ttl_vaild_ is true.
   int ttl() const { return ttl_; }
 
-  bool potentially_small_mtu() const { return potentially_small_mtu_; }
-
   // By default, gtest prints the raw bytes of an object. The bool data
   // member (in the base class QuicData) causes this object to have padding
   // bytes, which causes the default gtest object printer to read
   // uninitialize memory. So we need to teach gtest how to print this object.
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os,
       const QuicReceivedPacket& s);
 
  private:
   const QuicTime receipt_time_;
   int ttl_;
-  bool potentially_small_mtu_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicReceivedPacket);
 };
 
 // Pure virtual class to listen for packet acknowledgements.
 class NET_EXPORT_PRIVATE QuicAckListenerInterface
     : public base::RefCounted<QuicAckListenerInterface> {
  public:
   QuicAckListenerInterface() {}
 
@@ skipping 171 matching lines @@
       : iov(iov), iov_count(iov_count), total_length(total_length) {}
 
   const struct iovec* iov;
   const int iov_count;
   const size_t total_length;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_