Update from https://crrev.com/312398

net/quic/quic_connection_logger.cc

 // Copyright (c) 2013 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_connection_logger.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 125 matching lines @@
     base::DictionaryValue* info = new base::DictionaryValue();
     info->SetInteger("sequence_number", static_cast<int>(it->first));
     info->SetInteger("received",
                      static_cast<int>(it->second.ToDebuggingValue()));
     received->Append(info);
   }
 
   return dict;
 }
 
-base::Value* NetLogQuicCongestionFeedbackFrameCallback(
-    const QuicCongestionFeedbackFrame* frame,
-    NetLog::LogLevel /* log_level */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  switch (frame->type) {
-    case kTCP:
-      dict->SetString("type", "TCP");
-      dict->SetInteger("receive_window",
-                       static_cast<int>(frame->tcp.receive_window));
-      break;
-  }
-
-  return dict;
-}
-
 base::Value* NetLogQuicRstStreamFrameCallback(
     const QuicRstStreamFrame* frame,
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("stream_id", frame->stream_id);
   dict->SetInteger("quic_rst_stream_error", frame->error_code);
   dict->SetString("details", frame->error_details);
   return dict;
 }
 
@@ skipping 250 matching lines @@
       for (SequenceNumberSet::const_iterator it = missing_packets.begin();
            it != missing_packets.end(); ++it) {
         if (*it != last_missing + 1 && ++num_ranges >= max_ranges) {
           ++num_truncated_acks_sent_;
           break;
         }
         last_missing = *it;
       }
       break;
     }
-    case CONGESTION_FEEDBACK_FRAME:
-      net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_CONGESTION_FEEDBACK_FRAME_SENT,
-          base::Bind(&NetLogQuicCongestionFeedbackFrameCallback,
-                     frame.congestion_feedback_frame));
-      break;
     case RST_STREAM_FRAME:
       UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeClient",
                                   frame.rst_stream_frame->error_code);
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_SENT,
           base::Bind(&NetLogQuicRstStreamFrameCallback,
                      frame.rst_stream_frame));
       break;
     case CONNECTION_CLOSE_FRAME:
       net_log_.AddEvent(
@@ skipping 179 matching lines @@
     previous_missing_packet = *it;
     ++it;
   }
   if (num_consecutive_missing_packets != 0) {
     UpdatePacketGapSentHistogram(num_consecutive_missing_packets);
   }
   largest_received_missing_packet_sequence_number_ =
         *missing_packets.rbegin();
 }
 
-void QuicConnectionLogger::OnCongestionFeedbackFrame(
-    const QuicCongestionFeedbackFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_CONGESTION_FEEDBACK_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicCongestionFeedbackFrameCallback, &frame));
-}
-
 void QuicConnectionLogger::OnStopWaitingFrame(
     const QuicStopWaitingFrame& frame) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
       base::Bind(&NetLogQuicStopWaitingFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeServer",
                               frame.error_code);
@@ skipping 266 matching lines @@
       continue;
     }
     // Record some overlapping patterns, to get a better picture, since this is
     // not very expensive.
     if (i % 3 == 0)
       six_packet_histogram->Add(recent_6_mask);
   }
 }
 
 }  // namespace net