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

components/data_reduction_proxy/core/common/data_reduction_proxy_event_creator.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/common/data_reduction_proxy_event_creator.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
@@ skipping 11 matching lines @@
   base::TimeTicks ticks_now = base::TimeTicks::Now();
   net::NetLog::EntryData entry_data(type, source, phase, ticks_now,
                                     &parameters_callback);
   net::NetLog::Entry entry(&entry_data,
                            net::NetLogCaptureMode::IncludeSocketBytes());
   scoped_ptr<base::Value> entry_value(entry.ToValue());
 
   return entry_value;
 }
 
-int64 GetExpirationTicks(int bypass_seconds) {
+int64_t GetExpirationTicks(int bypass_seconds) {
   base::TimeTicks expiration_ticks =
       base::TimeTicks::Now() + base::TimeDelta::FromSeconds(bypass_seconds);
   return (expiration_ticks - base::TimeTicks()).InMilliseconds();
 }
 
 // A callback which creates a base::Value containing information about enabling
 // the Data Reduction Proxy.
 scoped_ptr<base::Value> EnableDataReductionProxyCallback(
     bool secure_transport_restricted,
     const std::vector<net::ProxyServer>& proxies_for_http,
@@ skipping 26 matching lines @@
 }
 
 // A callback which creates a base::Value containing information about bypassing
 // the Data Reduction Proxy.
 scoped_ptr<base::Value> UrlBypassActionCallback(
     DataReductionProxyBypassAction action,
     const std::string& request_method,
     const GURL& url,
     bool should_retry,
     int bypass_seconds,
-    int64 expiration_ticks,
+    int64_t expiration_ticks,
     net::NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("bypass_action_type", action);
   dict->SetString("method", request_method);
   dict->SetString("url", url.spec());
   dict->SetBoolean("should_retry", should_retry);
   dict->SetString("bypass_duration_seconds",
                   base::Int64ToString(bypass_seconds));
   dict->SetString("expiration", base::Int64ToString(expiration_ticks));
   return dict.Pass();
 }
 
 // A callback which creates a base::Value containing information about bypassing
 // the Data Reduction Proxy.
 scoped_ptr<base::Value> UrlBypassTypeCallback(
     DataReductionProxyBypassType bypass_type,
     const std::string& request_method,
     const GURL& url,
     bool should_retry,
     int bypass_seconds,
-    int64 expiration_ticks,
+    int64_t expiration_ticks,
     net::NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("bypass_type", bypass_type);
   dict->SetString("method", request_method);
   dict->SetString("url", url.spec());
   dict->SetBoolean("should_retry", should_retry);
   dict->SetString("bypass_duration_seconds",
                   base::Int64ToString(bypass_seconds));
   dict->SetString("expiration", base::Int64ToString(expiration_ticks));
   return dict.Pass();
@@ skipping 25 matching lines @@
   return dict.Pass();
 }
 
 // A callback that creates a base::Value containing information about
 // completing the Data Reduction Proxy configuration request.
 scoped_ptr<base::Value> EndConfigRequestCallback(
     int net_error,
     int http_response_code,
     int failure_count,
     const std::vector<net::ProxyServer>& proxies_for_http,
-    int64 refresh_duration_minutes,
-    int64 expiration_ticks,
+    int64_t refresh_duration_minutes,
+    int64_t expiration_ticks,
     net::NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::ListValue> http_proxy_list(new base::ListValue());
   for (const auto& proxy : proxies_for_http)
     http_proxy_list->AppendString(proxy.ToURI());
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("net_error", net_error);
   dict->SetInteger("http_response_code", http_response_code);
   dict->SetInteger("failure_count", failure_count);
   dict->Set("http_proxy_list_in_config", http_proxy_list.Pass());
   dict->SetString("refresh_duration",
@@ skipping 38 matching lines @@
 }
 
 void DataReductionProxyEventCreator::AddBypassActionEvent(
     const net::BoundNetLog& net_log,
     DataReductionProxyBypassAction bypass_action,
     const std::string& request_method,
     const GURL& url,
     bool should_retry,
     const base::TimeDelta& bypass_duration) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  int64 expiration_ticks = GetExpirationTicks(bypass_duration.InSeconds());
+  int64_t expiration_ticks = GetExpirationTicks(bypass_duration.InSeconds());
   const net::NetLog::ParametersCallback& parameters_callback =
       base::Bind(&UrlBypassActionCallback, bypass_action, request_method, url,
                  should_retry, bypass_duration.InSeconds(), expiration_ticks);
   PostBoundNetLogBypassEvent(
       net_log, net::NetLog::TYPE_DATA_REDUCTION_PROXY_BYPASS_REQUESTED,
       net::NetLog::PHASE_NONE, expiration_ticks, parameters_callback);
 }
 
 void DataReductionProxyEventCreator::AddBypassTypeEvent(
     const net::BoundNetLog& net_log,
     DataReductionProxyBypassType bypass_type,
     const std::string& request_method,
     const GURL& url,
     bool should_retry,
     const base::TimeDelta& bypass_duration) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  int64 expiration_ticks = GetExpirationTicks(bypass_duration.InSeconds());
+  int64_t expiration_ticks = GetExpirationTicks(bypass_duration.InSeconds());
   const net::NetLog::ParametersCallback& parameters_callback =
       base::Bind(&UrlBypassTypeCallback, bypass_type, request_method, url,
                  should_retry, bypass_duration.InSeconds(), expiration_ticks);
   PostBoundNetLogBypassEvent(
       net_log, net::NetLog::TYPE_DATA_REDUCTION_PROXY_BYPASS_REQUESTED,
       net::NetLog::PHASE_NONE, expiration_ticks, parameters_callback);
 }
 
 void DataReductionProxyEventCreator::AddProxyFallbackEvent(
     net::NetLog* net_log,
@@ skipping 48 matching lines @@
 }
 
 void DataReductionProxyEventCreator::EndConfigRequest(
     const net::BoundNetLog& net_log,
     int net_error,
     int http_response_code,
     int failure_count,
     const std::vector<net::ProxyServer>& proxies_for_http,
     const base::TimeDelta& refresh_duration,
     const base::TimeDelta& retry_delay) {
-  int64 refresh_duration_minutes = refresh_duration.InMinutes();
-  int64 expiration_ticks = GetExpirationTicks(retry_delay.InSeconds());
+  int64_t refresh_duration_minutes = refresh_duration.InMinutes();
+  int64_t expiration_ticks = GetExpirationTicks(retry_delay.InSeconds());
   const net::NetLog::ParametersCallback& parameters_callback = base::Bind(
       &EndConfigRequestCallback, net_error, http_response_code, failure_count,
       proxies_for_http, refresh_duration_minutes, expiration_ticks);
   PostBoundNetLogConfigRequestEvent(
       net_log, net::NetLog::TYPE_DATA_REDUCTION_PROXY_CONFIG_REQUEST,
       net::NetLog::PHASE_END, parameters_callback);
 }
 
 void DataReductionProxyEventCreator::PostEvent(
     net::NetLog* net_log,
@@ skipping 19 matching lines @@
     storage_delegate_->AddEnabledEvent(event.Pass(), enabled);
 
   if (net_log)
     net_log->AddGlobalEntry(type, callback);
 }
 
 void DataReductionProxyEventCreator::PostBoundNetLogBypassEvent(
     const net::BoundNetLog& net_log,
     net::NetLog::EventType type,
     net::NetLog::EventPhase phase,
-    int64 expiration_ticks,
+    int64_t expiration_ticks,
     const net::NetLog::ParametersCallback& callback) {
   scoped_ptr<base::Value> event =
       BuildDataReductionProxyEvent(type, net_log.source(), phase, callback);
   if (event)
     storage_delegate_->AddAndSetLastBypassEvent(event.Pass(), expiration_ticks);
   net_log.AddEntry(type, phase, callback);
 }
 
 void DataReductionProxyEventCreator::PostBoundNetLogSecureProxyCheckEvent(
     const net::BoundNetLog& net_log,
@@ skipping 15 matching lines @@
     const net::NetLog::ParametersCallback& callback) {
   scoped_ptr<base::Value> event(
       BuildDataReductionProxyEvent(type, net_log.source(), phase, callback));
   if (event) {
     storage_delegate_->AddEvent(event.Pass());
     net_log.AddEntry(type, phase, callback);
   }
 }
 
 }  // namespace data_reduction_proxy