Simplify QUIC's encryption path now that FEC is gone. Protected by FLAG_quic_inplace_encryption.

net/quic/quic_packet_creator.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_packet_creator.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 404 matching lines @@
                                         size_t encrypted_buffer_len) {
   DCHECK_LT(0u, encrypted_buffer_len);
   QUIC_BUG_IF(queued_frames_.empty()) << "Attempt to serialize empty packet";
   QuicPacketHeader header;
   // FillPacketHeader increments packet_number_.
   FillPacketHeader(&header);
 
   MaybeAddPadding();
 
   DCHECK_GE(max_plaintext_size_, packet_size_);
-  // ACK Frames will be truncated due to length only if they're the only frame
-  // in the packet, and if packet_size_ was set to max_plaintext_size_. If
-  // truncation due to length occurred, then GetSerializedFrameLength will have
-  // returned all bytes free.
-  bool possibly_truncated_by_length = packet_size_ == max_plaintext_size_ &&
-                                      queued_frames_.size() == 1 &&
-                                      queued_frames_.back().type == ACK_FRAME;
   // Use the packet_size_ instead of the buffer size to ensure smaller
   // packet sizes are properly used.
   size_t length = framer_->BuildDataPacket(header, queued_frames_,
                                            encrypted_buffer, packet_size_);
   if (length == 0) {
     QUIC_BUG << "Failed to serialize " << queued_frames_.size() << " frames.";
     return;
   }
 
-  // TODO(ianswett) Consider replacing QuicPacket with something else, since
-  // it's only used to provide convenience methods to FEC and encryption.
-  QuicPacket packet(
-      encrypted_buffer, length,
-      /* owns_buffer */ false, header.public_header.connection_id_length,
-      header.public_header.version_flag, header.public_header.multipath_flag,
-      header.public_header.packet_number_length);
-
+  // ACK Frames will be truncated due to length only if they're the only frame
+  // in the packet, and if packet_size_ was set to max_plaintext_size_. If
+  // truncation due to length occurred, then GetSerializedFrameLength will have
+  // returned all bytes free.
+  bool possibly_truncated_by_length = packet_size_ == max_plaintext_size_ &&
+                                      queued_frames_.size() == 1 &&
+                                      queued_frames_.back().type == ACK_FRAME;
   // Because of possible truncation, we can't be confident that our
   // packet size calculation worked correctly.
   if (!possibly_truncated_by_length) {
     DCHECK_EQ(packet_size_, length);
   }
-  // Immediately encrypt the packet, to ensure we don't encrypt the same
-  // packet number multiple times.
-  size_t encrypted_length = framer_->EncryptPayload(
-      packet_.encryption_level, packet_.path_id, packet_.packet_number, packet,
-      encrypted_buffer, encrypted_buffer_len);
+  size_t encrypted_length = 0;
+  if (FLAGS_quic_inplace_encryption2) {
+    const size_t ad_len = GetStartOfEncryptedData(header);
+    encrypted_length = framer_->EncryptInPlace(
+        packet_.encryption_level, packet_.path_id, packet_.packet_number,
+        ad_len, length, encrypted_buffer_len, encrypted_buffer);
+  } else {
+    QuicPacket packet(
+        encrypted_buffer, length,
+        /* owns_buffer */ false, header.public_header.connection_id_length,
+        header.public_header.version_flag, header.public_header.multipath_flag,
+        header.public_header.packet_number_length);
+    // Immediately encrypt the packet, to ensure we don't encrypt the same
+    // packet number multiple times.
+    encrypted_length = framer_->EncryptPayload(
+        packet_.encryption_level, packet_.path_id, packet_.packet_number,
+        packet, encrypted_buffer, encrypted_buffer_len);
+  }
   if (encrypted_length == 0) {
     QUIC_BUG << "Failed to encrypt packet number " << packet_.packet_number;
     return;
   }
 
   packet_size_ = 0;
   queued_frames_.clear();
   packet_.entropy_hash = QuicFramer::GetPacketEntropyHash(header);
   packet_.encrypted_buffer = encrypted_buffer;
   packet_.encrypted_length = encrypted_length;
@@ skipping 127 matching lines @@
   packet_.packet_number = it == multipath_packet_number_.end() ? 0 : it->second;
   packet_.path_id = path_id;
   DCHECK(packet_.path_id != kInvalidPathId);
   // Send path in packet if current path is not the default path.
   send_path_id_in_packet_ = packet_.path_id != kDefaultPathId ? true : false;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net