Don't copy the QuicAckFrame into the QuicPacketGenerator. Protected by quic_dont_copy_acks.

net/quic/quic_packet_generator_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_packet_generator.h"
 
 #include <string>
 
 #include "base/macros.h"
 #include "net/quic/crypto/crypto_protocol.h"
@@ skipping 25 matching lines @@
 
 class MockDelegate : public QuicPacketGenerator::DelegateInterface {
  public:
   MockDelegate() {}
   ~MockDelegate() override {}
 
   MOCK_METHOD2(ShouldGeneratePacket,
                bool(HasRetransmittableData retransmittable,
                     IsHandshake handshake));
   MOCK_METHOD1(PopulateAckFrame, void(QuicAckFrame*));
+  MOCK_METHOD0(GetUpdatedAckFrame, const QuicFrame());
   MOCK_METHOD1(PopulateStopWaitingFrame, void(QuicStopWaitingFrame*));
   MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
   MOCK_METHOD2(OnUnrecoverableError,
                void(QuicErrorCode, ConnectionCloseSource));
 
   void SetCanWriteAnything() {
     EXPECT_CALL(*this, ShouldGeneratePacket(_, _)).WillRepeatedly(Return(true));
     EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
         .WillRepeatedly(Return(true));
   }
@@ skipping 150 matching lines @@
   }
 
   QuicFramer framer_;
   MockRandom random_;
   SimpleBufferAllocator buffer_allocator_;
   StrictMock<MockDelegate> delegate_;
   QuicPacketGenerator generator_;
   QuicPacketCreator* creator_;
   SimpleQuicFramer simple_framer_;
   vector<SerializedPacket> packets_;
+  QuicAckFrame ack_frame_;
 
  private:
   scoped_ptr<char[]> data_array_;
   struct iovec iov_;
 };
 
 class MockDebugDelegate : public QuicPacketCreator::DebugDelegate {
  public:
   MOCK_METHOD1(OnFrameAddedToPacket, void(const QuicFrame&));
 };
 
 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_NotWritable) {
   delegate_.SetCanNotWrite();
 
   generator_.SetShouldSendAck(false);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldNotFlush) {
   StrictMock<MockDebugDelegate> debug_delegate;
 
   generator_.set_debug_delegate(&debug_delegate);
   delegate_.SetCanWriteOnlyNonRetransmittable();
   generator_.StartBatchOperations();
 
-  EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  if (FLAGS_quic_dont_copy_acks) {
+    EXPECT_CALL(delegate_, GetUpdatedAckFrame())
+        .WillOnce(Return(QuicFrame(&ack_frame_)));
+  } else {
+    EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  }
   EXPECT_CALL(debug_delegate, OnFrameAddedToPacket(_)).Times(1);
 
   generator_.SetShouldSendAck(false);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldFlush) {
   delegate_.SetCanWriteOnlyNonRetransmittable();
 
-  EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  if (FLAGS_quic_dont_copy_acks) {
+    EXPECT_CALL(delegate_, GetUpdatedAckFrame())
+        .WillOnce(Return(QuicFrame(&ack_frame_)));
+  } else {
+    EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  }
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 
   generator_.SetShouldSendAck(false);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_ack_frames = 1;
   CheckPacketContains(contents, 0);
 }
 
 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_MultipleCalls) {
   // Make sure that calling SetShouldSendAck multiple times does not result in a
   // crash. Previously this would result in multiple QuicFrames queued in the
   // packet generator, with all but the last with internal pointers to freed
   // memory.
   delegate_.SetCanWriteAnything();
 
   // Only one AckFrame should be created.
-  EXPECT_CALL(delegate_, PopulateAckFrame(_)).Times(1);
+  if (FLAGS_quic_dont_copy_acks) {
+    EXPECT_CALL(delegate_, GetUpdatedAckFrame())
+        .WillOnce(Return(QuicFrame(&ack_frame_)));
+  } else {
+    EXPECT_CALL(delegate_, PopulateAckFrame(_)).Times(1);
+  }
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .Times(1)
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 
   generator_.StartBatchOperations();
   generator_.SetShouldSendAck(false);
   generator_.SetShouldSendAck(false);
   generator_.FinishBatchOperations();
 }
 
@@ skipping 207 matching lines @@
 
   generator_.SetShouldSendAck(false);
   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
   EXPECT_TRUE(generator_.HasQueuedFrames());
 
   delegate_.SetCanWriteAnything();
 
   generator_.StartBatchOperations();
 
   // When the first write operation is invoked, the ack frame will be returned.
-  EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  if (FLAGS_quic_dont_copy_acks) {
+    EXPECT_CALL(delegate_, GetUpdatedAckFrame())
+        .WillOnce(Return(QuicFrame(&ack_frame_)));
+  } else {
+    EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  }
 
   // Send some data and a control frame
   generator_.ConsumeData(3, MakeIOVector("quux"), 7, false, nullptr);
   generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
 
   // All five frames will be flushed out in a single packet.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   generator_.FinishBatchOperations();
   EXPECT_FALSE(generator_.HasQueuedFrames());
@@ skipping 11 matching lines @@
 
   generator_.SetShouldSendAck(false);
   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
   EXPECT_TRUE(generator_.HasQueuedFrames());
 
   delegate_.SetCanWriteAnything();
 
   generator_.StartBatchOperations();
 
   // When the first write operation is invoked, the ack frame will be returned.
-  EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  if (FLAGS_quic_dont_copy_acks) {
+    EXPECT_CALL(delegate_, GetUpdatedAckFrame())
+        .WillOnce(Return(QuicFrame(&ack_frame_)));
+  } else {
+    EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  }
 
   {
     InSequence dummy;
     // All five frames will be flushed out in a single packet
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   }
 
@@ skipping 268 matching lines @@
   // DFATALs are expected.
   // A 1 byte packet number length can't encode a gap of 1000.
   QuicPacketCreatorPeer::SetPacketNumber(creator_, 1000);
 
   delegate_.SetCanNotWrite();
   generator_.SetShouldSendAck(true);
   delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   // Set up frames to write into the creator when control frames are written.
-  EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  if (FLAGS_quic_dont_copy_acks) {
+    EXPECT_CALL(delegate_, GetUpdatedAckFrame())
+        .WillOnce(Return(QuicFrame(&ack_frame_)));
+  } else {
+    EXPECT_CALL(delegate_, PopulateAckFrame(_));
+  }
   EXPECT_CALL(delegate_, PopulateStopWaitingFrame(_));
   // Generator should have queued control frames, and creator should be empty.
   EXPECT_TRUE(generator_.HasQueuedFrames());
   EXPECT_FALSE(creator_->HasPendingFrames());
 
   // This will not serialize any packets, because of the invalid frame.
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
                                    ConnectionCloseSource::FROM_SELF));
   EXPECT_DFATAL(generator_.FinishBatchOperations(),
@@ skipping 25 matching lines @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   generator_.FlushAllQueuedFrames();
   EXPECT_FALSE(generator_.HasQueuedFrames());
   generator_.SetCurrentPath(kTestPathId1, 1, 0);
   EXPECT_EQ(kTestPathId1, QuicPacketCreatorPeer::GetCurrentPath(creator_));
 }
 
 }  // namespace test
 }  // namespace net