Use the exact-width integer types defined in <stdint.h> rather than

net/base/network_change_notifier.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/base/network_change_notifier.h"
 
 #include <limits>
 
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 90 matching lines @@
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "NCN.ConnectionTypeChangeToIPAddressChange",
         last_ip_address_change_ - last_connection_change_);
   }
 
   // NetworkChangeNotifier::ConnectionTypeObserver implementation.
   void OnConnectionTypeChanged(
       NetworkChangeNotifier::ConnectionType type) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     base::TimeTicks now = base::TimeTicks::Now();
-    int32 kilobytes_read = bytes_read_since_last_connection_change_ / 1000;
+    int32_t kilobytes_read = bytes_read_since_last_connection_change_ / 1000;
     base::TimeDelta state_duration = SinceLast(&last_connection_change_);
     if (bytes_read_since_last_connection_change_) {
       switch (last_connection_type_) {
         case NetworkChangeNotifier::CONNECTION_UNKNOWN:
           UMA_HISTOGRAM_TIMES("NCN.CM.FirstReadOnUnknown",
                               first_byte_after_connection_change_);
           UMA_HISTOGRAM_TIMES("NCN.CM.FastestRTTOnUnknown",
                               fastest_RTT_since_last_connection_change_);
           break;
         case NetworkChangeNotifier::CONNECTION_ETHERNET:
@@ skipping 177 matching lines @@
       fastest_RTT_since_last_connection_change_ = request_duration;
     }
     bytes_read_since_last_connection_change_ += bytes_read;
     if (request_duration < fastest_RTT_since_last_connection_change_)
       fastest_RTT_since_last_connection_change_ = request_duration;
     // Ignore tiny transfers which will not produce accurate rates.
     // Ignore zero duration transfers which might cause divide by zero.
     if (bytes_read > 10000 &&
         request_duration > base::TimeDelta::FromMilliseconds(1) &&
         request.creation_time() > last_connection_change_) {
-      int32 kbps = static_cast<int32>(
-          bytes_read * 8 / request_duration.InMilliseconds());
+      int32_t kbps = static_cast<int32_t>(bytes_read * 8 /
+                                          request_duration.InMilliseconds());
       if (kbps > peak_kbps_since_last_connection_change_)
         peak_kbps_since_last_connection_change_ = kbps;
     }
 
     if (last_connection_type_ != NetworkChangeNotifier::CONNECTION_NONE)
       return;
 
     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineDataRecv",
                                now - last_connection_change_);
     offline_packets_received_++;
@@ skipping 33 matching lines @@
   // state.
   base::TimeDelta polling_interval_;
   // |last_connection_type_| is the last value passed to
   // |OnConnectionTypeChanged|.
   NetworkChangeNotifier::ConnectionType last_connection_type_;
   // |last_polled_connection_type_| is last result from calling
   // |NetworkChangeNotifier::GetConnectionType| in |NotifyDataReceived|.
   NetworkChangeNotifier::ConnectionType last_polled_connection_type_;
   // Count of how many times NotifyDataReceived() has been called while the
   // NetworkChangeNotifier thought network connection was offline.
-  int32 offline_packets_received_;
+  int32_t offline_packets_received_;
   // Number of bytes of network data received since last connectivity change.
-  int32 bytes_read_since_last_connection_change_;
+  int32_t bytes_read_since_last_connection_change_;
   // Fastest round-trip-time (RTT) since last connectivity change. RTT measured
   // from URLRequest creation until first byte received.
   base::TimeDelta fastest_RTT_since_last_connection_change_;
   // Time between connectivity change and first network data byte received.
   base::TimeDelta first_byte_after_connection_change_;
   // Rough measurement of peak KB/s witnessed since last connectivity change.
   // The accuracy is decreased by ignoring these factors:
   // 1) Multiple URLRequests can occur concurrently.
   // 2) NotifyDataReceived() may be called repeatedly for one URLRequest.
   // 3) The transfer time includes at least one RTT while no bytes are read.
   // Erring on the conservative side is hopefully offset by taking the maximum.
-  int32 peak_kbps_since_last_connection_change_;
+  int32_t peak_kbps_since_last_connection_change_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(HistogramWatcher);
 };
 
 // NetworkState is thread safe.
 class NetworkChangeNotifier::NetworkState {
  public:
   NetworkState() {}
@@ skipping 637 matching lines @@
 
 NetworkChangeNotifier::DisableForTest::~DisableForTest() {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = network_change_notifier_;
 }
 
 void NetworkChangeNotifier::DNSObserver::OnInitialDNSConfigRead() {
 }
 
 }  // namespace net