Update from https://crrev.com/316786

net/quic/quic_framer.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_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 283 matching lines @@
       QuicSequenceNumberLength sequence_number_length);
 
   // Returns the associated data from the encrypted packet |encrypted| as a
   // stringpiece.
   static base::StringPiece GetAssociatedDataFromEncryptedPacket(
       const QuicEncryptedPacket& encrypted,
       QuicConnectionIdLength connection_id_length,
       bool includes_version,
       QuicSequenceNumberLength sequence_number_length);
 
-  // Returns a SerializedPacket whose |packet| member is owned by the caller,
-  // is created from the first |num_frames| frames, or is nullptr if the packet
-  // could not be created.  The packet must be of size |packet_size|.
-  SerializedPacket BuildDataPacket(const QuicPacketHeader& header,
-                                   const QuicFrames& frames,
-                                   size_t packet_size);
+  // Returns a QuicPacket* that is owned by the caller, is created from
+  // |frames|.  Returns nullptr if the packet could not be created.
+  // The packet must be of size |packet_size|.
+  QuicPacket* BuildDataPacket(const QuicPacketHeader& header,
+                              const QuicFrames& frames,
+                              char* buffer,
+                              size_t packet_length);
 
-  // Returns a SerializedPacket whose |packet| member is owned by the caller,
-  // and is populated with the fields in |header| and |fec|, or is nullptr if
-  // the packet could not be created.
-  SerializedPacket BuildFecPacket(const QuicPacketHeader& header,
-                                  const QuicFecData& fec);
+  // Returns a QuicPacket* that is owned by the caller, and is populated with
+  // the fields in |header| and |fec|.  Returns nullptr if the packet could
+  // not be created.
+  QuicPacket* BuildFecPacket(const QuicPacketHeader& header,
+                             const QuicFecData& fec);
 
   // Returns a new public reset packet, owned by the caller.
   static QuicEncryptedPacket* BuildPublicResetPacket(
       const QuicPublicResetPacket& packet);
 
   QuicEncryptedPacket* BuildVersionNegotiationPacket(
       const QuicPacketPublicHeader& header,
       const QuicVersionVector& supported_versions);
 
   // SetDecrypter sets the primary decrypter, replacing any that already exists,
@@ skipping 38 matching lines @@
 
   void SetSupportedVersions(const QuicVersionVector& versions) {
     supported_versions_ = versions;
     quic_version_ = versions[0];
   }
 
   void set_validate_flags(bool value) { validate_flags_ = value; }
 
   bool is_server() const { return is_server_; }
 
+  static QuicPacketEntropyHash GetPacketEntropyHash(
+      const QuicPacketHeader& header);
+
  private:
   friend class test::QuicFramerPeer;
 
   typedef std::map<QuicPacketSequenceNumber, uint8> NackRangeMap;
 
   struct AckFrameInfo {
     AckFrameInfo();
     ~AckFrameInfo();
 
     // The maximum delta between ranges.
     QuicPacketSequenceNumber max_delta;
     // Nack ranges starting with start sequence numbers and lengths.
     NackRangeMap nack_ranges;
   };
 
-  QuicPacketEntropyHash GetPacketEntropyHash(
-      const QuicPacketHeader& header) const;
-
   bool ProcessDataPacket(const QuicPacketPublicHeader& public_header,
-                         const QuicEncryptedPacket& packet);
+                         const QuicEncryptedPacket& packet,
+                         char* decrypted_buffer,
+                         size_t buffer_length);
 
   bool ProcessPublicResetPacket(const QuicPacketPublicHeader& public_header);
 
   bool ProcessVersionNegotiationPacket(QuicPacketPublicHeader* public_header);
 
   bool ProcessPublicHeader(QuicPacketPublicHeader* header);
 
+  // |decrypted_buffer| must be allocated to be large enough to hold the
+  // unencrypted contents of |packet|.
   bool ProcessPacketHeader(QuicPacketHeader* header,
-                           const QuicEncryptedPacket& packet);
+                           const QuicEncryptedPacket& packet,
+                           char* decrypted_buffer,
+                           size_t buffer_length);
 
   bool ProcessPacketSequenceNumber(
       QuicSequenceNumberLength sequence_number_length,
       QuicPacketSequenceNumber* sequence_number);
   bool ProcessFrameData(const QuicPacketHeader& header);
   bool ProcessStreamFrame(uint8 frame_type, QuicStreamFrame* frame);
   bool ProcessAckFrame(uint8 frame_type, QuicAckFrame* frame);
   bool ProcessTimestampsInAckFrame(QuicAckFrame* frame);
   bool ProcessStopWaitingFrame(const QuicPacketHeader& public_header,
                                QuicStopWaitingFrame* stop_waiting);
   bool ProcessRstStreamFrame(QuicRstStreamFrame* frame);
   bool ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame);
   bool ProcessGoAwayFrame(QuicGoAwayFrame* frame);
   bool ProcessWindowUpdateFrame(QuicWindowUpdateFrame* frame);
   bool ProcessBlockedFrame(QuicBlockedFrame* frame);
 
   bool DecryptPayload(const QuicPacketHeader& header,
-                      const QuicEncryptedPacket& packet);
+                      const QuicEncryptedPacket& packet,
+                      char* decrypted_buffer,
+                      size_t buffer_length);
 
   // 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;
 
   // Returns the QuicTime::Delta corresponding to the time from when the framer
   // was created.
   const QuicTime::Delta CalculateTimestampFromWire(uint32 time_delta_us);
@@ skipping 59 matching lines @@
   std::string detailed_error_;
   scoped_ptr<QuicDataReader> reader_;
   QuicFramerVisitorInterface* visitor_;
   QuicFecBuilderInterface* fec_builder_;
   QuicReceivedEntropyHashCalculatorInterface* entropy_calculator_;
   QuicErrorCode error_;
   // Updated by ProcessPacketHeader when it succeeds.
   QuicPacketSequenceNumber last_sequence_number_;
   // Updated by WritePacketHeader.
   QuicConnectionId last_serialized_connection_id_;
-  // Buffer containing decrypted payload data during parsing.
-  scoped_ptr<QuicData> decrypted_;
   // Version of the protocol being used.
   QuicVersion quic_version_;
   // This vector contains QUIC versions which we currently support.
   // This should be ordered such that the highest supported version is the first
   // element, with subsequent elements in descending order (versions can be
   // skipped as necessary).
   QuicVersionVector supported_versions_;
   // Primary decrypter used to decrypt packets during parsing.
   scoped_ptr<QuicDecrypter> decrypter_;
   // Alternative decrypter that can also be used to decrypt packets.
@@ skipping 19 matching lines @@
   // The time delta computed for the last timestamp frame. This is relative to
   // the creation_time.
   QuicTime::Delta last_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_