Remove stl_util's deletion functions from:

net/quic/core/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/core/quic_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "net/quic/core/crypto/null_decrypter.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 
 using base::StringPiece;
@@ skipping 164 matching lines @@
  public:
   TestQuicVisitor()
       : error_count_(0),
         version_mismatch_(0),
         packet_count_(0),
         frame_count_(0),
         complete_packets_(0),
         accept_packet_(true),
         accept_public_header_(true) {}
 
-  ~TestQuicVisitor() override {
-    base::STLDeleteElements(&stream_frames_);
-    base::STLDeleteElements(&ack_frames_);
-    base::STLDeleteElements(&stop_waiting_frames_);
-    base::STLDeleteElements(&padding_frames_);
-    base::STLDeleteElements(&ping_frames_);
-    base::STLDeleteElements(&stream_data_);
-  }
+  ~TestQuicVisitor() override {}
 
   void OnError(QuicFramer* f) override {
     DVLOG(1) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
              << " (" << f->error() << ")";
     ++error_count_;
   }
 
   void OnPacket() override {}
 
   void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
@@ skipping 28 matching lines @@
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
   bool OnStreamFrame(const QuicStreamFrame& frame) override {
     ++frame_count_;
     // Save a copy of the data so it is valid after the packet is processed.
     string* string_data = new string();
     StringPiece(frame.data_buffer, frame.data_length)
         .AppendToString(string_data);
-    stream_data_.push_back(string_data);
-    stream_frames_.push_back(new QuicStreamFrame(frame.stream_id, frame.fin,
-                                                 frame.offset, *string_data));
+    stream_data_.push_back(base::WrapUnique(string_data));
+    stream_frames_.push_back(base::MakeUnique<QuicStreamFrame>(
+        frame.stream_id, frame.fin, frame.offset, *string_data));
     return true;
   }
 
   bool OnAckFrame(const QuicAckFrame& frame) override {
     ++frame_count_;
-    ack_frames_.push_back(new QuicAckFrame(frame));
+    ack_frames_.push_back(base::MakeUnique<QuicAckFrame>(frame));
     return true;
   }
 
   bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
     ++frame_count_;
-    stop_waiting_frames_.push_back(new QuicStopWaitingFrame(frame));
+    stop_waiting_frames_.push_back(
+        base::MakeUnique<QuicStopWaitingFrame>(frame));
     return true;
   }
 
   bool OnPaddingFrame(const QuicPaddingFrame& frame) override {
-    padding_frames_.push_back(new QuicPaddingFrame(frame));
+    padding_frames_.push_back(base::MakeUnique<QuicPaddingFrame>(frame));
     return true;
   }
 
   bool OnPingFrame(const QuicPingFrame& frame) override {
     ++frame_count_;
-    ping_frames_.push_back(new QuicPingFrame(frame));
+    ping_frames_.push_back(base::MakeUnique<QuicPingFrame>(frame));
     return true;
   }
 
   void OnPacketComplete() override { ++complete_packets_; }
 
   bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
     rst_stream_frame_ = frame;
     return true;
   }
 
@@ skipping 28 matching lines @@
   int packet_count_;
   int frame_count_;
   int complete_packets_;
   bool accept_packet_;
   bool accept_public_header_;
 
   std::unique_ptr<QuicPacketHeader> header_;
   std::unique_ptr<QuicPacketPublicHeader> public_header_;
   std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
   std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
-  vector<QuicStreamFrame*> stream_frames_;
-  vector<QuicAckFrame*> ack_frames_;
-  vector<QuicStopWaitingFrame*> stop_waiting_frames_;
-  vector<QuicPaddingFrame*> padding_frames_;
-  vector<QuicPingFrame*> ping_frames_;
+  vector<std::unique_ptr<QuicStreamFrame>> stream_frames_;
+  vector<std::unique_ptr<QuicAckFrame>> ack_frames_;
+  vector<std::unique_ptr<QuicStopWaitingFrame>> stop_waiting_frames_;
+  vector<std::unique_ptr<QuicPaddingFrame>> padding_frames_;
+  vector<std::unique_ptr<QuicPingFrame>> ping_frames_;
   QuicRstStreamFrame rst_stream_frame_;
   QuicConnectionCloseFrame connection_close_frame_;
   QuicGoAwayFrame goaway_frame_;
   QuicWindowUpdateFrame window_update_frame_;
   QuicBlockedFrame blocked_frame_;
   QuicPathCloseFrame path_close_frame_;
-  vector<string*> stream_data_;
+  vector<std::unique_ptr<string>> stream_data_;
 };
 
 class QuicFramerTest : public ::testing::TestWithParam<QuicVersion> {
  public:
   QuicFramerTest()
       : encrypter_(new test::TestEncrypter()),
         decrypter_(new test::TestDecrypter()),
         start_(QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(0x10)),
         framer_(AllSupportedVersions(), start_, Perspective::IS_SERVER) {
     version_ = GetParam();
@@ skipping 1451 matching lines @@
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
-  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
+  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   CheckStreamFrameBoundaries(
       framer_.version() <= QUIC_VERSION_33 ? packet : packet_34,
       kQuicMaxStreamIdSize, !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, MissingDiversificationNonce) {
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   framer_.SetDecrypter(ENCRYPTION_NONE, new NullDecrypter());
@@ skipping 137 matching lines @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   // Stream ID should be the last 3 bytes of kStreamId.
   EXPECT_EQ(0x00FFFFFF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
-  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
+  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   const size_t stream_id_size = 3;
   CheckStreamFrameBoundaries(
       framer_.version() <= QUIC_VERSION_33 ? packet : packet_34, stream_id_size,
       !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) {
   // clang-format off
@@ skipping 60 matching lines @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   // Stream ID should be the last 2 bytes of kStreamId.
   EXPECT_EQ(0x0000FFFF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
-  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
+  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   const size_t stream_id_size = 2;
   CheckStreamFrameBoundaries(
       framer_.version() <= QUIC_VERSION_33 ? packet : packet_34, stream_id_size,
       !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) {
   // clang-format off
@@ skipping 60 matching lines @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   // Stream ID should be the last byte of kStreamId.
   EXPECT_EQ(0x000000FF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
-  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
+  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   const size_t stream_id_size = 1;
   CheckStreamFrameBoundaries(
       framer_.version() <= QUIC_VERSION_33 ? packet : packet_34, stream_id_size,
       !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, StreamFrameWithVersion) {
   // clang-format off
@@ skipping 65 matching lines @@
   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
   EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
-  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
+  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   CheckStreamFrameBoundaries(
       framer_.version() <= QUIC_VERSION_33 ? packet : packet_34,
       kQuicMaxStreamIdSize, kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, RejectPacket) {
   visitor_.accept_packet_ = false;
 
@@ skipping 134 matching lines @@
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
+  const QuicAckFrame& frame = *visitor_.ack_frames_[0].get();
   EXPECT_EQ(0xBA, frame.entropy_hash);
   EXPECT_EQ(kLargestObserved, frame.largest_observed);
   ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
   ASSERT_EQ(2u, frame.received_packet_times.size());
   EXPECT_EQ(kMissingPacket, frame.packets.Min());
 
   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
   const size_t kLargestObservedOffset =
       kReceivedEntropyOffset + kQuicEntropyHashSize;
   const size_t kMissingDeltaTimeOffset =
@@ skipping 91 matching lines @@
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
+  const QuicAckFrame& frame = *visitor_.ack_frames_[0].get();
   EXPECT_EQ(0xBA, frame.entropy_hash);
   EXPECT_EQ(kLargestObserved, frame.largest_observed);
   ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
   ASSERT_EQ(1u, frame.received_packet_times.size());
   EXPECT_EQ(kMissingPacket, frame.packets.Min());
 
   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
   const size_t kLargestObservedOffset =
       kReceivedEntropyOffset + kQuicEntropyHashSize;
   const size_t kMissingDeltaTimeOffset =
@@ skipping 69 matching lines @@
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
+  const QuicAckFrame& frame = *visitor_.ack_frames_[0].get();
   EXPECT_EQ(kSmallLargestObserved, frame.largest_observed);
   EXPECT_FALSE(frame.missing);
   ASSERT_EQ(4660u, frame.packets.NumPacketsSlow());
 
   const size_t kLargestAckedOffset = kQuicFrameTypeSize;
   const size_t kLargestAckedDeltaTimeOffset =
       kLargestAckedOffset + PACKET_2BYTE_PACKET_NUMBER;
   const size_t kFirstAckBlockLengthOffset =
       kLargestAckedDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
   const size_t kNumTimestampsOffset =
@@ skipping 79 matching lines @@
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
+  const QuicAckFrame& frame = *visitor_.ack_frames_[0].get();
   EXPECT_EQ(kSmallLargestObserved, frame.largest_observed);
   EXPECT_FALSE(frame.missing);
   ASSERT_EQ(4254u, frame.packets.NumPacketsSlow());
 
   const size_t kLargestAckedOffset = kQuicFrameTypeSize;
   const size_t kLargestAckedDeltaTimeOffset =
       kLargestAckedOffset + PACKET_2BYTE_PACKET_NUMBER;
   const size_t kNumberOfAckBlocksOffset =
       kLargestAckedDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
   const size_t kFirstAckBlockLengthOffset =
@@ skipping 112 matching lines @@
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
+  const QuicAckFrame& frame = *visitor_.ack_frames_[0].get();
   EXPECT_EQ(0xBA, frame.entropy_hash);
   EXPECT_EQ(kLargestObserved, frame.largest_observed);
   ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
   EXPECT_EQ(kMissingPacket, frame.packets.Min());
 
   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
   const size_t kLargestObservedOffset =
       kReceivedEntropyOffset + kQuicEntropyHashSize;
   const size_t kMissingDeltaTimeOffset =
       kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
@@ skipping 76 matching lines @@
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  QuicAckFrame* frame = visitor_.ack_frames_[0];
+  QuicAckFrame* frame = visitor_.ack_frames_[0].get();
   EXPECT_EQ(0xBA, frame->entropy_hash);
   EXPECT_EQ(kLargestObserved, frame->largest_observed);
   ASSERT_EQ(500u, frame->packets.NumPacketsSlow());
   EXPECT_EQ(kMissingPacket - 499, frame->packets.Min());
   EXPECT_EQ(kMissingPacket, frame->packets.Max());
 
   // Verify that the packet re-serializes identically.
   QuicFrames frames;
   frames.push_back(QuicFrame(frame));
   std::unique_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
@@ skipping 35 matching lines @@
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size());
-  const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0];
+  const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0].get();
   EXPECT_EQ(0xAB, frame.entropy_hash);
   EXPECT_EQ(kLeastUnacked, frame.least_unacked);
 
   const size_t kSentEntropyOffset = kQuicFrameTypeSize;
   const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize;
   const size_t frame_size = 7;
   for (size_t i = kQuicFrameTypeSize; i < frame_size; ++i) {
     string expected_error;
     if (i < kLeastUnackedOffset) {
       expected_error = "Unable to read entropy hash for sent packets.";
@@ skipping 35 matching lines @@
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size());
-  const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0];
+  const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0].get();
   EXPECT_EQ(kLeastUnacked, frame.least_unacked);
 
   const size_t frame_size = 7;
   for (size_t i = kQuicFrameTypeSize; i < frame_size; ++i) {
     string expected_error;
     expected_error = "Unable to read least unacked delta.";
     CheckProcessingFails(
         packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludePathId,
@@ skipping 3032 matching lines @@
   ASSERT_TRUE(raw_ack_packet != nullptr);
   char buffer[kMaxPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
       ENCRYPTION_NONE, kDefaultPathId, header.packet_number, *raw_ack_packet,
       buffer, kMaxPacketSize);
   ASSERT_NE(0u, encrypted_length);
   // Now make sure we can turn our ack packet back into an ack frame.
   ASSERT_TRUE(framer_.ProcessPacket(
       QuicEncryptedPacket(buffer, encrypted_length, false)));
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0];
+  QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0].get();
   if (framer_.version() <= QUIC_VERSION_33) {
     EXPECT_TRUE(processed_ack_frame.is_truncated);
     EXPECT_EQ(510u, processed_ack_frame.largest_observed);
     EXPECT_TRUE(processed_ack_frame.missing);
     ASSERT_EQ(255u, processed_ack_frame.packets.NumPacketsSlow());
     EXPECT_EQ(1u, processed_ack_frame.packets.Min());
     EXPECT_EQ(509u, processed_ack_frame.packets.Max());
   } else {
     EXPECT_FALSE(processed_ack_frame.is_truncated);
     EXPECT_FALSE(processed_ack_frame.missing);
@@ skipping 31 matching lines @@
   ASSERT_TRUE(raw_ack_packet != nullptr);
   char buffer[kMaxPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
       ENCRYPTION_NONE, kDefaultPathId, header.packet_number, *raw_ack_packet,
       buffer, kMaxPacketSize);
   ASSERT_NE(0u, encrypted_length);
   // Now make sure we can turn our ack packet back into an ack frame.
   ASSERT_TRUE(framer_.ProcessPacket(
       QuicEncryptedPacket(buffer, encrypted_length, false)));
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0];
+  QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0].get();
   if (framer_.version() <= QUIC_VERSION_33) {
     EXPECT_TRUE(processed_ack_frame.is_truncated);
     EXPECT_EQ(476u, processed_ack_frame.largest_observed);
     EXPECT_TRUE(processed_ack_frame.missing);
     ASSERT_EQ(238u, processed_ack_frame.packets.NumPacketsSlow());
     EXPECT_EQ(1u, processed_ack_frame.packets.Min());
     EXPECT_EQ(475u, processed_ack_frame.packets.Max());
   } else {
     EXPECT_FALSE(processed_ack_frame.is_truncated);
     EXPECT_EQ(600u, processed_ack_frame.largest_observed);
@@ skipping 33 matching lines @@
   ASSERT_NE(0u, encrypted_length);
 
   // Now make sure we can turn our ack packet back into an ack frame.
   ASSERT_TRUE(framer_.ProcessPacket(
       QuicEncryptedPacket(buffer, encrypted_length, false)));
 
   // Test for clean truncation of the ack by comparing the length of the
   // original packets to the re-serialized packets.
   frames.clear();
   frame.type = ACK_FRAME;
-  frame.ack_frame = visitor_.ack_frames_[0];
+  frame.ack_frame = visitor_.ack_frames_[0].get();
   frames.push_back(frame);
 
   size_t original_raw_length = raw_ack_packet->length();
   raw_ack_packet.reset(BuildDataPacket(header, frames));
   ASSERT_TRUE(raw_ack_packet != nullptr);
   EXPECT_EQ(original_raw_length, raw_ack_packet->length());
   ASSERT_TRUE(raw_ack_packet != nullptr);
 }
 
 TEST_P(QuicFramerTest, EntropyFlagTest) {
@@ skipping 290 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicFramerFuzzFunc(packet, arraysize(packet));
 }
 
 }  // namespace test
 }  // namespace net