net: Change auto to not deduce raw pointers.

net/quic/quic_stream_sequencer_buffer_test.cc

 // Copyright (c) 2015 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_stream_sequencer_buffer.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 202 matching lines @@
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(800, source, t, &written, &error_details_));
   BufferBlock* block_ptr = helper_->GetBlock(0);
   for (size_t i = 0; i < source.size(); ++i) {
     ASSERT_EQ('a', block_ptr->buffer[helper_->GetInBlockOffset(800) + i]);
   }
   EXPECT_EQ(2, helper_->GapSize());
   std::list<Gap> gaps = helper_->GetGaps();
   EXPECT_EQ(800u, gaps.front().end_offset);
   EXPECT_EQ(1824u, gaps.back().begin_offset);
-  auto frame_map = helper_->frame_arrival_time_map();
+  auto* frame_map = helper_->frame_arrival_time_map();
   EXPECT_EQ(1u, frame_map->size());
   EXPECT_EQ(800u, frame_map->begin()->first);
   EXPECT_EQ(t, (*frame_map)[800].timestamp);
   EXPECT_TRUE(helper_->CheckBufferInvariants());
 }
 
 TEST_F(QuicStreamSequencerBufferTest, OnStreamDataWithOverlap) {
   string source(1024, 'a');
   // Write something into [800, 1824)
   size_t written;
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   QuicTime t1 = clock_.ApproximateNow();
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(800, source, t1, &written, &error_details_));
   // Try to write to [0, 1024) and [1024, 2048).
   // But no byte will be written since overlap.
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   QuicTime t2 = clock_.ApproximateNow();
   EXPECT_EQ(QUIC_OVERLAPPING_STREAM_DATA,
             buffer_->OnStreamData(0, source, t2, &written, &error_details_));
   EXPECT_EQ(QUIC_OVERLAPPING_STREAM_DATA,
             buffer_->OnStreamData(1024, source, t2, &written, &error_details_));
-  auto frame_map = helper_->frame_arrival_time_map();
+  auto* frame_map = helper_->frame_arrival_time_map();
   EXPECT_EQ(1u, frame_map->size());
   EXPECT_EQ(t1, (*frame_map)[800].timestamp);
 }
 
 TEST_F(QuicStreamSequencerBufferTest,
        OnStreamDataOverlapAndDuplicateCornerCases) {
   string source(1024, 'a');
   // Write something into [800, 1824)
   size_t written;
   buffer_->OnStreamData(800, source, clock_.ApproximateNow(), &written,
@@ skipping 10 matching lines @@
   // Try to write one byte to [1823, 1824), but should count as duplicate
   string one_byte = "c";
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(1823, one_byte, clock_.ApproximateNow(),
                                   &written, &error_details_));
   EXPECT_EQ(0u, written);
   // write one byte to [1824, 1825)
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(1824, one_byte, clock_.ApproximateNow(),
                                   &written, &error_details_));
-  auto frame_map = helper_->frame_arrival_time_map();
+  auto* frame_map = helper_->frame_arrival_time_map();
   EXPECT_EQ(3u, frame_map->size());
   EXPECT_TRUE(helper_->CheckBufferInvariants());
 }
 
 TEST_F(QuicStreamSequencerBufferTest, OnStreamDataWithoutOverlap) {
   string source(1024, 'a');
   // Write something into [800, 1824).
   size_t written;
   EXPECT_EQ(QUIC_NO_ERROR,
             buffer_->OnStreamData(800, source, clock_.ApproximateNow(),
@@ skipping 763 matching lines @@
   EXPECT_LE(bytes_to_buffer_, total_bytes_read_) << "iterations: "
                                                  << iterations;
   EXPECT_LE(bytes_to_buffer_, total_bytes_written_);
 }
 
 }  // anonymous namespace
 
 }  // namespace test
 
 }  // namespace net