Switch to standard integer types in components/, part 1 of 4.

components/data_reduction_proxy/core/browser/data_reduction_proxy_tamper_detection.cc

 // Copyright 2014 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 "components/data_reduction_proxy/core/browser/data_reduction_proxy_tamper_detection.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <cstring>
 
 #include "base/base64.h"
+#include "base/macros.h"
 #include "base/md5.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "build/build_config.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_headers.h"
 #include "net/base/mime_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 
 #if defined(OS_ANDROID)
 #include "net/android/network_library.h"
 #endif
 
 // Macro for UMA reporting of tamper detection. HTTP response first reports to
@@ skipping 48 matching lines @@
           histogram_compression_ratio, compression_ratio); \
     } \
   } while (0)
 
 namespace data_reduction_proxy {
 
 // static
 bool DataReductionProxyTamperDetection::DetectAndReport(
     const net::HttpResponseHeaders* headers,
     bool scheme_is_https,
-    int64 content_length) {
+    int64_t content_length) {
   if (headers == nullptr) {
     return false;
   }
 
   // Abort tamper detection, if the fingerprint of the Chrome-Proxy header is
   // absent.
   std::string chrome_proxy_fingerprint;
   if (!GetDataReductionProxyActionFingerprintChromeProxy(
       headers, &chrome_proxy_fingerprint))
     return false;
 
   // Get carrier ID.
   unsigned carrier_id = 0;
 #if defined(OS_ANDROID)
   base::StringToUint(net::android::GetTelephonyNetworkOperator(), &carrier_id);
 #endif
 
   DataReductionProxyTamperDetection tamper_detection(
       headers, scheme_is_https, carrier_id);
 
   // Checks if the Chrome-Proxy header has been tampered with.
   if (tamper_detection.ValidateChromeProxyHeader(chrome_proxy_fingerprint)) {
     tamper_detection.ReportUMAForChromeProxyHeaderValidation();
     return true;
   }
 
   // Chrome-Proxy header has not been tampered with, and thus other
   // fingerprints are valid.
   bool tampered = false;
-  int64 original_content_length = -1;
+  int64_t original_content_length = -1;
   std::string fingerprint;
 
   if (GetDataReductionProxyActionFingerprintVia(headers, &fingerprint)) {
     bool has_chrome_proxy_via_header;
     if (tamper_detection.ValidateViaHeader(
         fingerprint, &has_chrome_proxy_via_header)) {
       tamper_detection.ReportUMAForViaHeaderValidation(
           has_chrome_proxy_via_header);
       tampered = true;
     }
@@ skipping 40 matching lines @@
     const unsigned carrier_id)
     : response_headers_(headers),
       scheme_is_https_(is_secure),
       carrier_id_(carrier_id) {
   DCHECK(headers);
 }
 
 DataReductionProxyTamperDetection::~DataReductionProxyTamperDetection() {};
 
 void DataReductionProxyTamperDetection::ReportUMAForTamperDetectionCount(
-    int64 original_content_length) const {
+    int64_t original_content_length) const {
   REPORT_TAMPER_DETECTION_UMA(
       scheme_is_https_, "DataReductionProxy.HeaderTamperDetectionHTTPS",
       "DataReductionProxy.HeaderTamperDetectionHTTP", carrier_id_);
 
   std::string mime_type;
   response_headers_->GetMimeType(&mime_type);
 
   if (net::MatchesMimeType("text/javascript", mime_type) ||
       net::MatchesMimeType("application/x-javascript", mime_type) ||
       net::MatchesMimeType("application/javascript", mime_type)) {
@@ skipping 195 matching lines @@
     ReportUMAForOtherHeadersValidation() const {
   REPORT_TAMPER_DETECTION_UMA(
       scheme_is_https_,
       "DataReductionProxy.HeaderTamperedHTTPS_OtherHeaders",
       "DataReductionProxy.HeaderTamperedHTTP_OtherHeaders",
       carrier_id_);
 }
 
 bool DataReductionProxyTamperDetection::ValidateContentLength(
     const std::string& fingerprint,
-    int64 content_length,
-    int64* original_content_length) const {
+    int64_t content_length,
+    int64_t* original_content_length) const {
   DCHECK(original_content_length);
   // Abort, if Content-Length value from the Data Reduction Proxy does not
   // exist or it cannot be converted to an integer.
   if (!base::StringToInt64(fingerprint, original_content_length))
     return false;
 
   return *original_content_length != content_length;
 }
 
 void DataReductionProxyTamperDetection::ReportUMAForContentLength(
-    int64 content_length,
-    int64 original_content_length) const {
+    int64_t content_length,
+    int64_t original_content_length) const {
   // Gets MIME type of the response and reports to UMA histograms separately.
   // Divides MIME types into 4 groups: JavaScript, CSS, Images, and others.
   REPORT_TAMPER_DETECTION_UMA(
       scheme_is_https_,
       "DataReductionProxy.HeaderTamperedHTTPS_ContentLength",
       "DataReductionProxy.HeaderTamperedHTTP_ContentLength",
       carrier_id_);
 
   // Gets MIME type.
   std::string mime_type;
@@ skipping 126 matching lines @@
   std::vector<std::string> values;
   std::string value;
   void* iter = NULL;
   while (headers->EnumerateHeader(&iter, header_name, &value)) {
     values.push_back(value);
   }
   return values;
 }
 
 }  // namespace data_reduction_proxy