Update from https://crrev.com/306655

net/dns/dns_session.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/dns/dns_session.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
@@ skipping 21 matching lines @@
 // Target percentile in the RTT histogram used for retransmission timeout.
 const unsigned kRTOPercentile = 99;
 }  // namespace
 
 // Runtime statistics of DNS server.
 struct DnsSession::ServerStats {
   ServerStats(base::TimeDelta rtt_estimate_param, RttBuckets* buckets)
     : last_failure_count(0), rtt_estimate(rtt_estimate_param) {
     rtt_histogram.reset(new base::SampleVector(buckets));
     // Seed histogram with 2 samples at |rtt_estimate| timeout.
-    rtt_histogram->Accumulate(rtt_estimate.InMilliseconds(), 2);
+    rtt_histogram->Accumulate(
+        static_cast<base::HistogramBase::Sample>(rtt_estimate.InMilliseconds()),
+        2);
   }
 
   // Count of consecutive failures after last success.
   int last_failure_count;
 
   // Last time when server returned failure or timeout.
   base::Time last_failure;
   // Last time when server returned success.
   base::Time last_success;
 
@@ skipping 40 matching lines @@
   for (size_t i = 0; i < config_.nameservers.size(); ++i) {
     server_stats_.push_back(new ServerStats(config_.timeout,
                                             rtt_buckets_.Pointer()));
   }
 }
 
 DnsSession::~DnsSession() {
   RecordServerStats();
 }
 
-int DnsSession::NextQueryId() const { return rand_callback_.Run(); }
+uint16 DnsSession::NextQueryId() const {
+  return static_cast<uint16>(rand_callback_.Run());
+}
 
 unsigned DnsSession::NextFirstServerIndex() {
   unsigned index = NextGoodServerIndex(server_index_);
   if (config_.rotate)
     server_index_ = (server_index_ + 1) % config_.nameservers.size();
   return index;
 }
 
 unsigned DnsSession::NextGoodServerIndex(unsigned server_index) {
   unsigned index = server_index;
@@ skipping 61 matching lines @@
   // Using parameters: alpha = 1/8, delta = 1/4, beta = 4
   base::TimeDelta& estimate = server_stats_[server_index]->rtt_estimate;
   base::TimeDelta& deviation = server_stats_[server_index]->rtt_deviation;
   base::TimeDelta current_error = rtt - estimate;
   estimate += current_error / 8;  // * alpha
   base::TimeDelta abs_error = base::TimeDelta::FromInternalValue(
       std::abs(current_error.ToInternalValue()));
   deviation += (abs_error - deviation) / 4;  // * delta
 
   // Histogram-based method.
-  server_stats_[server_index]->rtt_histogram
-      ->Accumulate(rtt.InMilliseconds(), 1);
+  server_stats_[server_index]->rtt_histogram->Accumulate(
+      static_cast<base::HistogramBase::Sample>(rtt.InMilliseconds()), 1);
 }
 
 void DnsSession::RecordLostPacket(unsigned server_index, int attempt) {
   base::TimeDelta timeout_jacobson =
       NextTimeoutFromJacobson(server_index, attempt);
   base::TimeDelta timeout_histogram =
       NextTimeoutFromHistogram(server_index, attempt);
   UMA_HISTOGRAM_TIMES("AsyncDNS.TimeoutSpentJacobson", timeout_jacobson);
   UMA_HISTOGRAM_TIMES("AsyncDNS.TimeoutSpentHistogram", timeout_histogram);
 }
@@ skipping 92 matching lines @@
   timeout = std::max(timeout, base::TimeDelta::FromMilliseconds(kMinTimeoutMs));
 
   // The timeout still doubles every full round.
   unsigned num_backoffs = attempt / config_.nameservers.size();
 
   return std::min(timeout * (1 << num_backoffs),
                   base::TimeDelta::FromMilliseconds(kMaxTimeoutMs));
 }
 
 }  // namespace net