Update from https://crrev.com/306655

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 40 matching lines @@
     TransmissionType transmission_type,
     size_t packet_size,
     QuicTime sent_time,
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("encryption_level", level);
   dict->SetInteger("transmission_type", transmission_type);
   dict->SetString("packet_sequence_number",
                   base::Uint64ToString(serialized_packet.sequence_number));
   dict->SetInteger("size", packet_size);
-  dict->SetInteger("sent_time_us", sent_time.ToDebuggingValue());
+  dict->SetInteger("sent_time_us",
+                   static_cast<int>(sent_time.ToDebuggingValue()));
   return dict;
 }
 
 base::Value* NetLogQuicPacketRetransmittedCallback(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number,
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("old_packet_sequence_number",
                   base::Uint64ToString(old_sequence_number));
   dict->SetString("new_packet_sequence_number",
                   base::Uint64ToString(new_sequence_number));
   return dict;
 }
 
 base::Value* NetLogQuicPacketHeaderCallback(const QuicPacketHeader* header,
                                             NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("connection_id",
                   base::Uint64ToString(header->public_header.connection_id));
   dict->SetInteger("reset_flag", header->public_header.reset_flag);
   dict->SetInteger("version_flag", header->public_header.version_flag);
   dict->SetString("packet_sequence_number",
                   base::Uint64ToString(header->packet_sequence_number));
   dict->SetInteger("entropy_flag", header->entropy_flag);
   dict->SetInteger("fec_flag", header->fec_flag);
-  dict->SetInteger("fec_group", header->fec_group);
+  dict->SetInteger("fec_group", static_cast<int>(header->fec_group));
   return dict;
 }
 
 base::Value* NetLogQuicStreamFrameCallback(const QuicStreamFrame* frame,
                                            NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("stream_id", frame->stream_id);
   dict->SetBoolean("fin", frame->fin);
   dict->SetString("offset", base::Uint64ToString(frame->offset));
   dict->SetInteger("length", frame->data.TotalBufferSize());
   return dict;
 }
 
 base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame,
                                         NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("largest_observed",
                   base::Uint64ToString(frame->largest_observed));
-  dict->SetInteger("delta_time_largest_observed_us",
-                   frame->delta_time_largest_observed.ToMicroseconds());
+  dict->SetInteger(
+      "delta_time_largest_observed_us",
+      static_cast<int>(frame->delta_time_largest_observed.ToMicroseconds()));
   dict->SetInteger("entropy_hash",
                    frame->entropy_hash);
   dict->SetBoolean("truncated", frame->is_truncated);
 
   base::ListValue* missing = new base::ListValue();
   dict->Set("missing_packets", missing);
   const SequenceNumberSet& missing_packets = frame->missing_packets;
   for (SequenceNumberSet::const_iterator it = missing_packets.begin();
        it != missing_packets.end(); ++it) {
     missing->AppendString(base::Uint64ToString(*it));
   }
 
   base::ListValue* revived = new base::ListValue();
   dict->Set("revived_packets", revived);
   const SequenceNumberSet& revived_packets = frame->revived_packets;
   for (SequenceNumberSet::const_iterator it = revived_packets.begin();
        it != revived_packets.end(); ++it) {
     revived->AppendString(base::Uint64ToString(*it));
   }
 
   base::ListValue* received = new base::ListValue();
   dict->Set("received_packet_times", received);
   const PacketTimeList& received_times = frame->received_packet_times;
   for (PacketTimeList::const_iterator it = received_times.begin();
        it != received_times.end(); ++it) {
     base::DictionaryValue* info = new base::DictionaryValue();
-    info->SetInteger("sequence_number", it->first);
-    info->SetInteger("received", it->second.ToDebuggingValue());
+    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", frame->tcp.receive_window);
+      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();
@@ skipping 384 matching lines @@
       base::Bind(&NetLogQuicPacketHeaderCallback, &header));
   ++num_packets_received_;
   if (largest_received_packet_sequence_number_ <
       header.packet_sequence_number) {
     QuicPacketSequenceNumber delta = header.packet_sequence_number -
         largest_received_packet_sequence_number_;
     if (delta > 1) {
       // There is a gap between the largest packet previously received and
       // the current packet.  This indicates either loss, or out-of-order
       // delivery.
-      UMA_HISTOGRAM_COUNTS("Net.QuicSession.PacketGapReceived", delta - 1);
+      UMA_HISTOGRAM_COUNTS("Net.QuicSession.PacketGapReceived",
+                           static_cast<base::HistogramBase::Sample>(delta - 1));
     }
     largest_received_packet_sequence_number_ = header.packet_sequence_number;
   }
-  if (header.packet_sequence_number < received_packets_.size())
-    received_packets_[header.packet_sequence_number] = true;
+  if (header.packet_sequence_number < received_packets_.size()) {
+    received_packets_[static_cast<size_t>(header.packet_sequence_number)] =
+        true;
+  }
   if (header.packet_sequence_number < last_received_packet_sequence_number_) {
     ++num_out_of_order_received_packets_;
-    UMA_HISTOGRAM_COUNTS("Net.QuicSession.OutOfOrderGapReceived",
-                         last_received_packet_sequence_number_ -
-                             header.packet_sequence_number);
+    UMA_HISTOGRAM_COUNTS(
+        "Net.QuicSession.OutOfOrderGapReceived",
+        static_cast<base::HistogramBase::Sample>(
+            last_received_packet_sequence_number_ -
+            header.packet_sequence_number));
   }
   last_received_packet_sequence_number_ = header.packet_sequence_number;
 }
 
 void QuicConnectionLogger::OnStreamFrame(const QuicStreamFrame& frame) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
       base::Bind(&NetLogQuicStreamFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED,
       base::Bind(&NetLogQuicAckFrameCallback, &frame));
 
   const size_t kApproximateLargestSoloAckBytes = 100;
   if (last_received_packet_sequence_number_ < received_acks_.size() &&
-      last_received_packet_size_ < kApproximateLargestSoloAckBytes)
-    received_acks_[last_received_packet_sequence_number_] = true;
+      last_received_packet_size_ < kApproximateLargestSoloAckBytes) {
+    received_acks_[static_cast<size_t>(last_received_packet_sequence_number_)] =
+        true;
+  }
 
   if (frame.is_truncated)
     ++num_truncated_acks_received_;
 
   if (frame.missing_packets.empty())
     return;
 
   SequenceNumberSet missing_packets = frame.missing_packets;
   SequenceNumberSet::const_iterator it = missing_packets.lower_bound(
       largest_received_missing_packet_sequence_number_);
@@ skipping 237 matching lines @@
   QuicPacketSequenceNumber divisor = largest_received_packet_sequence_number_;
   QuicPacketSequenceNumber numerator = divisor - num_packets_received_;
   if (divisor < 100000)
     numerator *= 1000;
   else
     divisor /= 1000;
   string prefix("Net.QuicSession.PacketLossRate_");
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       prefix + connection_description_, 1, 1000, 75,
       base::HistogramBase::kUmaTargetedHistogramFlag);
-  histogram->Add(numerator / divisor);
+  histogram->Add(static_cast<base::HistogramBase::Sample>(numerator / divisor));
 }
 
 void QuicConnectionLogger::RecordLossHistograms() const {
   if (largest_received_packet_sequence_number_ == 0)
     return;  // Connection was never used.
   RecordAggregatePacketLossRate();
 
   base::HistogramBase* is_not_ack_histogram =
       GetPacketSequenceNumberHistogram("IsNotAck_");
   base::HistogramBase* is_an_ack_histogram =
@@ skipping 55 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