Update from https://crrev.com/316786

net/quic/quic_stream_sequencer.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 <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/metrics/sparse_histogram.h"
 #include "net/quic/reliable_quic_stream.h"
 
-using std::make_pair;
 using std::min;
 using std::numeric_limits;
 using std::string;
 
 namespace net {
 
 QuicStreamSequencer::QuicStreamSequencer(ReliableQuicStream* quic_stream)
     : stream_(quic_stream),
       num_bytes_consumed_(0),
       close_offset_(numeric_limits<QuicStreamOffset>::max()),
       blocked_(false),
       num_bytes_buffered_(0),
       num_frames_received_(0),
-      num_duplicate_frames_received_(0) {
+      num_duplicate_frames_received_(0),
+      num_early_frames_received_(0) {
 }
 
 QuicStreamSequencer::~QuicStreamSequencer() {
 }
 
 void QuicStreamSequencer::OnStreamFrame(const QuicStreamFrame& frame) {
   ++num_frames_received_;
   if (IsDuplicate(frame)) {
     ++num_duplicate_frames_received_;
     // Silently ignore duplicates.
@@ skipping 18 matching lines @@
   if (frame.fin) {
     CloseStreamAtOffset(frame.offset + data_len);
     if (data_len == 0) {
       return;
     }
   }
 
   IOVector data;
   data.AppendIovec(frame.data.iovec(), frame.data.Size());
 
+  if (byte_offset > num_bytes_consumed_) {
+    ++num_early_frames_received_;
+  }
+
   // If the frame has arrived in-order then we can process it immediately, only
   // buffering if the stream is unable to process it.
   if (!blocked_ && byte_offset == num_bytes_consumed_) {
     DVLOG(1) << "Processing byte offset " << byte_offset;
     size_t bytes_consumed = 0;
     for (size_t i = 0; i < data.Size(); ++i) {
       bytes_consumed += stream_->ProcessRawData(
           static_cast<char*>(data.iovec()[i].iov_base),
           data.iovec()[i].iov_len);
     }
@@ skipping 14 matching lines @@
       data_len -= bytes_consumed;
       data.Consume(bytes_consumed);
       byte_offset += bytes_consumed;
     }
   }
 
   // Buffer any remaining data to be consumed by the stream when ready.
   for (size_t i = 0; i < data.Size(); ++i) {
     DVLOG(1) << "Buffering stream data at offset " << byte_offset;
     const iovec& iov = data.iovec()[i];
-    buffered_frames_.insert(make_pair(
+    buffered_frames_.insert(std::make_pair(
         byte_offset, string(static_cast<char*>(iov.iov_base), iov.iov_len)));
     byte_offset += iov.iov_len;
     num_bytes_buffered_ += iov.iov_len;
   }
   return;
 }
 
 void QuicStreamSequencer::CloseStreamAtOffset(QuicStreamOffset offset) {
   const QuicStreamOffset kMaxOffset = numeric_limits<QuicStreamOffset>::max();
 
@@ skipping 71 matching lines @@
     if (it->second.size() == frame_offset) {
       // We've copied this whole frame
       RecordBytesConsumed(it->second.size());
       buffered_frames_.erase(it);
       it = buffered_frames_.begin();
       frame_offset = 0;
     }
   }
   // We've finished copying.  If we have a partial frame, update it.
   if (frame_offset != 0) {
-    buffered_frames_.insert(
-        make_pair(it->first + frame_offset, it->second.substr(frame_offset)));
+    buffered_frames_.insert(std::make_pair(it->first + frame_offset,
+                                           it->second.substr(frame_offset)));
     buffered_frames_.erase(buffered_frames_.begin());
     RecordBytesConsumed(frame_offset);
   }
   return static_cast<int>(num_bytes_consumed_ - initial_bytes_consumed);
 }
 
 bool QuicStreamSequencer::HasBytesToRead() const {
   FrameMap::const_iterator it = buffered_frames_.begin();
 
   return it != buffered_frames_.end() && it->first == num_bytes_consumed_;
@@ skipping 66 matching lines @@
     }
     if (bytes_consumed > data->size()) {
       stream_->Reset(QUIC_ERROR_PROCESSING_STREAM);  // Programming error
       return;
     } else if (bytes_consumed == data->size()) {
       buffered_frames_.erase(it);
       it = buffered_frames_.find(num_bytes_consumed_);
     } else {
       string new_data = it->second.substr(bytes_consumed);
       buffered_frames_.erase(it);
-      buffered_frames_.insert(make_pair(num_bytes_consumed_, new_data));
+      buffered_frames_.insert(std::make_pair(num_bytes_consumed_, new_data));
       return;
     }
   }
   MaybeCloseStream();
 }
 
 void QuicStreamSequencer::RecordBytesConsumed(size_t bytes_consumed) {
   num_bytes_consumed_ += bytes_consumed;
   num_bytes_buffered_ -= bytes_consumed;
 
   stream_->AddBytesConsumed(bytes_consumed);
 }
 
 }  // namespace net