Update from https://crrev.com/316786

net/quic/quic_stream_sequencer_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_stream_sequencer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 208 matching lines @@
   EXPECT_EQ("c", buffered_frames_->find(2)->second);
 }
 
 TEST_F(QuicStreamSequencerTest, NextxFrameNotConsumed) {
   EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(0));
 
   OnFrame(0, "abc");
   EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
   EXPECT_EQ("abc", buffered_frames_->find(0)->second);
+  EXPECT_EQ(0, sequencer_->num_early_frames_received());
 }
 
 TEST_F(QuicStreamSequencerTest, FutureFrameNotProcessed) {
   OnFrame(3, "abc");
   EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
   EXPECT_EQ("abc", buffered_frames_->find(3)->second);
+  EXPECT_EQ(1, sequencer_->num_early_frames_received());
 }
 
 TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) {
   // Buffer the first
   OnFrame(6, "ghi");
   EXPECT_EQ(1u, buffered_frames_->size());
   EXPECT_EQ(0u, sequencer_->num_bytes_consumed());
   EXPECT_EQ(3u, sequencer_->num_bytes_buffered());
   // Buffer the second
   OnFrame(3, "def");
@@ skipping 83 matching lines @@
  public:
   typedef pair<int, string> Frame;
   typedef vector<Frame> FrameList;
 
   void CreateFrames() {
     int payload_size = arraysize(kPayload) - 1;
     int remaining_payload = payload_size;
     while (remaining_payload != 0) {
       int size = min(OneToN(6), remaining_payload);
       int index = payload_size - remaining_payload;
-      list_.push_back(make_pair(index, string(kPayload + index, size)));
+      list_.push_back(std::make_pair(index, string(kPayload + index, size)));
       remaining_payload -= size;
     }
   }
 
   QuicSequencerRandomTest() {
     CreateFrames();
   }
 
   int OneToN(int n) {
     return base::RandInt(1, n);
@@ skipping 43 matching lines @@
   const int kNewDataLength = 3;
   IOVector data = MakeIOVector(string(kNewDataLength, '.'));
 
   // No overlap if no buffered frames.
   EXPECT_TRUE(buffered_frames_->empty());
   EXPECT_FALSE(sequencer_->FrameOverlapsBufferedData(
       QuicStreamFrame(1, false, kBufferedOffset - 1, data)));
 
   // Add a buffered frame.
   buffered_frames->insert(
-      make_pair(kBufferedOffset, string(kBufferedDataLength, '.')));
+      std::make_pair(kBufferedOffset, string(kBufferedDataLength, '.')));
 
   // New byte range partially overlaps with buffered frame, start offset
   // preceeding buffered frame.
   EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(
       QuicStreamFrame(1, false, kBufferedOffset - 1, data)));
   EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(
       QuicStreamFrame(1, false, kBufferedOffset - kNewDataLength + 1, data)));
 
   // New byte range partially overlaps with buffered frame, start offset
   // inside existing buffered frame.
@@ skipping 23 matching lines @@
   QuicStreamFrame frame2(kClientDataStreamId1, false, 2, MakeIOVector("hello"));
   EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(frame2));
   EXPECT_CALL(stream_, CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _))
       .Times(1);
   sequencer_->OnStreamFrame(frame2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net