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

components/data_reduction_proxy/core/browser/data_reduction_proxy_service.cc

 // Copyright 2015 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_service.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 79 matching lines @@
     const base::TimeDelta& commit_delay) {
   DCHECK(CalledOnValidThread());
   DCHECK(!compression_stats_);
   DCHECK(!prefs_);
   prefs_ = prefs;
   compression_stats_.reset(
       new DataReductionProxyCompressionStats(this, prefs_, commit_delay));
 }
 
 void DataReductionProxyService::UpdateContentLengths(
-    int64 data_used,
-    int64 original_size,
+    int64_t data_used,
+    int64_t original_size,
     bool data_reduction_proxy_enabled,
     DataReductionProxyRequestType request_type,
     const std::string& data_usage_host,
     const std::string& mime_type) {
   DCHECK(CalledOnValidThread());
   if (compression_stats_) {
     compression_stats_->UpdateContentLengths(
         data_used, original_size, data_reduction_proxy_enabled, request_type,
         data_usage_host, mime_type);
   }
@@ skipping 12 matching lines @@
 
 void DataReductionProxyService::AddEventAndSecureProxyCheckState(
     scoped_ptr<base::Value> event,
     SecureProxyCheckState state) {
   DCHECK(CalledOnValidThread());
   event_store_->AddEventAndSecureProxyCheckState(event.Pass(), state);
 }
 
 void DataReductionProxyService::AddAndSetLastBypassEvent(
     scoped_ptr<base::Value> event,
-    int64 expiration_ticks) {
+    int64_t expiration_ticks) {
   DCHECK(CalledOnValidThread());
   event_store_->AddAndSetLastBypassEvent(event.Pass(), expiration_ticks);
 }
 
 void DataReductionProxyService::SetUnreachable(bool unreachable) {
   DCHECK(CalledOnValidThread());
   settings_->SetUnreachable(unreachable);
 }
 
 void DataReductionProxyService::SetLoFiModeActiveOnMainFrame(
@@ skipping 82 matching lines @@
   prefs_->SetInteger(prefs::kLoFiSnackbarsShownPerSession, 0);
   prefs_->SetBoolean(prefs::kLoFiWasUsedThisSession, false);
 }
 
 void DataReductionProxyService::RecordLoFiSessionState(LoFiSessionState state) {
   UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.LoFi.SessionState", state,
                             LO_FI_SESSION_STATE_INDEX_BOUNDARY);
 }
 
 void DataReductionProxyService::SetInt64Pref(const std::string& pref_path,
-                                             int64 value) {
+                                             int64_t value) {
   if (prefs_)
     prefs_->SetInt64(pref_path, value);
 }
 
 void DataReductionProxyService::SetStringPref(const std::string& pref_path,
                                               const std::string& value) {
   if (prefs_)
     prefs_->SetString(pref_path, value);
 }
 
@@ skipping 70 matching lines @@
   return initialized_;
 }
 
 base::WeakPtr<DataReductionProxyService>
 DataReductionProxyService::GetWeakPtr() {
   DCHECK(CalledOnValidThread());
   return weak_factory_.GetWeakPtr();
 }
 
 }  // namespace data_reduction_proxy