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

components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats_unittest.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 <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_prefs.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_pref_names.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const int kWriteDelayMinutes = 60;
 
 // Each bucket holds data usage for a 15 minute interval. History is maintained
 // for 60 days.
 const int kNumExpectedBuckets = 60 * 24 * 60 / 15;
 
-int64 GetListPrefInt64Value(
-    const base::ListValue& list_update, size_t index) {
+int64_t GetListPrefInt64Value(const base::ListValue& list_update,
+                              size_t index) {
   std::string string_value;
   EXPECT_TRUE(list_update.GetString(index, &string_value));
 
-  int64 value = 0;
+  int64_t value = 0;
   EXPECT_TRUE(base::StringToInt64(string_value, &value));
   return value;
 }
 
 class DataUsageLoadVerifier {
  public:
   DataUsageLoadVerifier(
       scoped_ptr<std::vector<data_reduction_proxy::DataUsageBucket>> expected) {
     expected_ = expected.Pass();
   }
@@ skipping 84 matching lines @@
   }
 
   DataReductionProxyCompressionStats::SiteUsageMap* DataUsageMap() {
     return &compression_stats_->data_usage_map_;
   }
 
   void SetUpPrefs() {
     CreatePrefList(prefs::kDailyHttpOriginalContentLength);
     CreatePrefList(prefs::kDailyHttpReceivedContentLength);
 
-    const int64 kOriginalLength = 150;
-    const int64 kReceivedLength = 100;
+    const int64_t kOriginalLength = 150;
+    const int64_t kReceivedLength = 100;
 
     compression_stats_->SetInt64(
         prefs::kHttpOriginalContentLength, kOriginalLength);
     compression_stats_->SetInt64(
         prefs::kHttpReceivedContentLength, kReceivedLength);
 
     base::ListValue* original_daily_content_length_list =
         compression_stats_->GetList(prefs::kDailyHttpOriginalContentLength);
     base::ListValue* received_daily_content_length_list =
         compression_stats_->GetList(prefs::kDailyHttpReceivedContentLength);
@@ skipping 29 matching lines @@
 
     for (size_t i = 0; i < count; ++i) {
       EXPECT_EQ(GetListPrefInt64Value(*delayed_list, i),
                 GetListPrefInt64Value(*written_list, i));
     }
   }
 
   // Verify the pref value in |pref_service_| are equal to that in
   // |simple_pref_service|.
   void VerifyPrefWasWritten(const char* pref) {
-    int64 delayed_pref = compression_stats_->GetInt64(pref);
-    int64 written_pref = pref_service()->GetInt64(pref);
+    int64_t delayed_pref = compression_stats_->GetInt64(pref);
+    int64_t written_pref = pref_service()->GetInt64(pref);
     EXPECT_EQ(delayed_pref, written_pref);
   }
 
   // Verify the pref values in |dict| are equal to that in |compression_stats_|.
   void VerifyPrefs(base::DictionaryValue* dict) {
     base::string16 dict_pref_string;
-    int64 dict_pref;
-    int64 service_pref;
+    int64_t dict_pref;
+    int64_t service_pref;
 
     dict->GetString("historic_original_content_length", &dict_pref_string);
     base::StringToInt64(dict_pref_string, &dict_pref);
     service_pref =
         compression_stats_->GetInt64(prefs::kHttpOriginalContentLength);
     EXPECT_EQ(service_pref, dict_pref);
 
     dict->GetString("historic_received_content_length", &dict_pref_string);
     base::StringToInt64(dict_pref_string, &dict_pref);
     service_pref =
         compression_stats_->GetInt64(prefs::kHttpReceivedContentLength);
     EXPECT_EQ(service_pref, dict_pref);
   }
 
   // Verify the pref list values are equal to the given values.
   // If the count of values is less than kNumDaysInHistory, zeros are assumed
   // at the beginning.
-  void VerifyPrefList(const char* pref, const int64* values, size_t count) {
+  void VerifyPrefList(const char* pref, const int64_t* values, size_t count) {
     ASSERT_GE(kNumDaysInHistory, count);
     base::ListValue* update = compression_stats_->GetList(pref);
     ASSERT_EQ(kNumDaysInHistory, update->GetSize()) << "Pref: " << pref;
 
     for (size_t i = 0; i < count; ++i) {
       EXPECT_EQ(values[i],
                 GetListPrefInt64Value(*update, kNumDaysInHistory - count + i))
           << pref << "; index=" << (kNumDaysInHistory - count + i);
     }
     for (size_t i = 0; i < kNumDaysInHistory - count; ++i) {
       EXPECT_EQ(0, GetListPrefInt64Value(*update, i)) << "index=" << i;
     }
   }
 
   // Verify that the pref value is equal to given value.
-  void VerifyPrefInt64(const char* pref, const int64 value) {
+  void VerifyPrefInt64(const char* pref, const int64_t value) {
     EXPECT_EQ(value, compression_stats_->GetInt64(pref));
   }
 
   // Verify all daily data saving pref list values.
   void VerifyDailyDataSavingContentLengthPrefLists(
-      const int64* original_values, size_t original_count,
-      const int64* received_values, size_t received_count,
-      const int64* original_with_data_reduction_proxy_enabled_values,
+      const int64_t* original_values,
+      size_t original_count,
+      const int64_t* received_values,
+      size_t received_count,
+      const int64_t* original_with_data_reduction_proxy_enabled_values,
       size_t original_with_data_reduction_proxy_enabled_count,
-      const int64* received_with_data_reduction_proxy_enabled_values,
+      const int64_t* received_with_data_reduction_proxy_enabled_values,
       size_t received_with_data_reduction_proxy_count,
-      const int64* original_via_data_reduction_proxy_values,
+      const int64_t* original_via_data_reduction_proxy_values,
       size_t original_via_data_reduction_proxy_count,
-      const int64* received_via_data_reduction_proxy_values,
+      const int64_t* received_via_data_reduction_proxy_values,
       size_t received_via_data_reduction_proxy_count) {
     VerifyPrefList(data_reduction_proxy::prefs::kDailyHttpOriginalContentLength,
                    original_values, original_count);
     VerifyPrefList(data_reduction_proxy::prefs::kDailyHttpReceivedContentLength,
                    received_values, received_count);
     VerifyPrefList(
         data_reduction_proxy::prefs::
             kDailyOriginalContentLengthWithDataReductionProxyEnabled,
         original_with_data_reduction_proxy_enabled_values,
         original_with_data_reduction_proxy_enabled_count);
@@ skipping 45 matching lines @@
     VerifyPrefInt64(data_reduction_proxy::prefs::
                         kDailyContentLengthViaDataReductionProxyApplication,
                     received_via_data_reduction_proxy_values
                         ? received_via_data_reduction_proxy_values
                               [received_via_data_reduction_proxy_count - 1]
                         : 0);
   }
 
   // Verify daily data saving pref for request types.
   void VerifyDailyRequestTypeContentLengthPrefLists(
-      const int64* original_values, size_t original_count,
-      const int64* received_values, size_t received_count,
-      const int64* original_with_data_reduction_proxy_enabled_values,
+      const int64_t* original_values,
+      size_t original_count,
+      const int64_t* received_values,
+      size_t received_count,
+      const int64_t* original_with_data_reduction_proxy_enabled_values,
       size_t original_with_data_reduction_proxy_enabled_count,
-      const int64* received_with_data_reduction_proxy_enabled_values,
+      const int64_t* received_with_data_reduction_proxy_enabled_values,
       size_t received_with_data_reduction_proxy_count,
-      const int64* https_with_data_reduction_proxy_enabled_values,
+      const int64_t* https_with_data_reduction_proxy_enabled_values,
       size_t https_with_data_reduction_proxy_enabled_count,
-      const int64* short_bypass_with_data_reduction_proxy_enabled_values,
+      const int64_t* short_bypass_with_data_reduction_proxy_enabled_values,
       size_t short_bypass_with_data_reduction_proxy_enabled_count,
-      const int64* long_bypass_with_data_reduction_proxy_enabled_values,
+      const int64_t* long_bypass_with_data_reduction_proxy_enabled_values,
       size_t long_bypass_with_data_reduction_proxy_enabled_count,
-      const int64* unknown_with_data_reduction_proxy_enabled_values,
+      const int64_t* unknown_with_data_reduction_proxy_enabled_values,
       size_t unknown_with_data_reduction_proxy_enabled_count) {
     VerifyPrefList(data_reduction_proxy::prefs::kDailyHttpOriginalContentLength,
                    original_values, original_count);
     VerifyPrefList(data_reduction_proxy::prefs::kDailyHttpReceivedContentLength,
                    received_values, received_count);
     VerifyPrefList(
         data_reduction_proxy::prefs::
             kDailyOriginalContentLengthWithDataReductionProxyEnabled,
         original_with_data_reduction_proxy_enabled_values,
         original_with_data_reduction_proxy_enabled_count);
@@ skipping 17 matching lines @@
             kDailyContentLengthLongBypassWithDataReductionProxyEnabled,
         long_bypass_with_data_reduction_proxy_enabled_values,
         long_bypass_with_data_reduction_proxy_enabled_count);
     VerifyPrefList(
         data_reduction_proxy::prefs::
             kDailyContentLengthUnknownWithDataReductionProxyEnabled,
         unknown_with_data_reduction_proxy_enabled_values,
         unknown_with_data_reduction_proxy_enabled_count);
   }
 
-  int64 GetInt64(const char* pref_path) {
+  int64_t GetInt64(const char* pref_path) {
     return compression_stats_->GetInt64(pref_path);
   }
 
-  void SetInt64(const char* pref_path, int64 pref_value) {
+  void SetInt64(const char* pref_path, int64_t pref_value) {
     compression_stats_->SetInt64(pref_path, pref_value);
   }
 
   std::string NormalizeHostname(const std::string& hostname) {
     return DataReductionProxyCompressionStats::NormalizeHostname(hostname);
   }
 
-  void RecordContentLengthPrefs(int64 received_content_length,
-                                int64 original_content_length,
+  void RecordContentLengthPrefs(int64_t received_content_length,
+                                int64_t original_content_length,
                                 bool with_data_reduction_proxy_enabled,
                                 DataReductionProxyRequestType request_type,
                                 const std::string& mime_type,
                                 base::Time now) {
     compression_stats_->RecordRequestSizePrefs(
         received_content_length, original_content_length,
         with_data_reduction_proxy_enabled, request_type, mime_type, now);
   }
 
-  void RecordContentLengthPrefs(int64 received_content_length,
-                                int64 original_content_length,
+  void RecordContentLengthPrefs(int64_t received_content_length,
+                                int64_t original_content_length,
                                 bool with_data_reduction_proxy_enabled,
                                 DataReductionProxyRequestType request_type,
                                 base::Time now) {
     RecordContentLengthPrefs(received_content_length, original_content_length,
                              with_data_reduction_proxy_enabled, request_type,
                              "application/octet-stream", now);
   }
 
   void RecordDataUsage(const std::string& data_usage_host,
-                       int64 data_used,
-                       int64 original_size,
+                       int64_t data_used,
+                       int64_t original_size,
                        const base::Time& time) {
     compression_stats_->RecordDataUsage(data_usage_host, data_used,
                                         original_size, time);
   }
 
   void GetHistoricalDataUsage(
       const HistoricalDataUsageCallback& onLoadDataUsage,
       const base::Time& now) {
     compression_stats_->GetHistoricalDataUsageImpl(onLoadDataUsage, now);
   }
@@ skipping 86 matching lines @@
       prefs::kUpdateDailyReceivedContentLengths, true);
 
   VerifyPrefWasWritten(prefs::kHttpOriginalContentLength);
   VerifyPrefWasWritten(prefs::kHttpReceivedContentLength);
   VerifyPrefListWasWritten(prefs::kDailyHttpOriginalContentLength);
   VerifyPrefListWasWritten(prefs::kDailyHttpReceivedContentLength);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest,
        HistoricNetworkStatsInfoToValue) {
-  const int64 kOriginalLength = 150;
-  const int64 kReceivedLength = 100;
+  const int64_t kOriginalLength = 150;
+  const int64_t kReceivedLength = 100;
   ResetCompressionStatsWithDelay(
       base::TimeDelta::FromMinutes(kWriteDelayMinutes));
 
   base::DictionaryValue* dict = nullptr;
   scoped_ptr<base::Value> stats_value(
       compression_stats()->HistoricNetworkStatsInfoToValue());
   EXPECT_TRUE(stats_value->GetAsDictionary(&dict));
   VerifyPrefs(dict);
 
   SetInt64(prefs::kHttpOriginalContentLength, kOriginalLength);
   SetInt64(prefs::kHttpReceivedContentLength, kReceivedLength);
 
   stats_value.reset(compression_stats()->HistoricNetworkStatsInfoToValue());
   EXPECT_TRUE(stats_value->GetAsDictionary(&dict));
   VerifyPrefs(dict);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest,
        HistoricNetworkStatsInfoToValueDirect) {
-  const int64 kOriginalLength = 150;
-  const int64 kReceivedLength = 100;
+  const int64_t kOriginalLength = 150;
+  const int64_t kReceivedLength = 100;
 
   base::DictionaryValue* dict = nullptr;
   scoped_ptr<base::Value> stats_value(
       compression_stats()->HistoricNetworkStatsInfoToValue());
   EXPECT_TRUE(stats_value->GetAsDictionary(&dict));
   VerifyPrefs(dict);
 
   SetInt64(prefs::kHttpOriginalContentLength, kOriginalLength);
   SetInt64(prefs::kHttpReceivedContentLength, kReceivedLength);
 
@@ skipping 30 matching lines @@
       base::TimeDelta::FromMinutes(kWriteDelayMinutes));
 
   const base::ListValue* value = pref_service()->GetList(
       prefs::kDailyHttpOriginalContentLength);
   std::string string_value;
   value->GetString(0, &string_value);
   EXPECT_EQ("1234", string_value);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, TotalLengths) {
-  const int64 kOriginalLength = 200;
-  const int64 kReceivedLength = 100;
+  const int64_t kOriginalLength = 200;
+  const int64_t kReceivedLength = 100;
 
   compression_stats()->UpdateContentLengths(
       kReceivedLength, kOriginalLength, IsDataReductionProxyEnabled(),
       UNKNOWN_TYPE, std::string(), std::string());
 
   EXPECT_EQ(kReceivedLength,
             GetInt64(data_reduction_proxy::prefs::kHttpReceivedContentLength));
   EXPECT_FALSE(IsDataReductionProxyEnabled());
   EXPECT_EQ(kOriginalLength,
             GetInt64(data_reduction_proxy::prefs::kHttpOriginalContentLength));
 
   // Record the same numbers again, and total lengths should be doubled.
   compression_stats()->UpdateContentLengths(
       kReceivedLength, kOriginalLength, IsDataReductionProxyEnabled(),
       UNKNOWN_TYPE, std::string(), std::string());
 
   EXPECT_EQ(kReceivedLength * 2,
             GetInt64(data_reduction_proxy::prefs::kHttpReceivedContentLength));
   EXPECT_FALSE(IsDataReductionProxyEnabled());
   EXPECT_EQ(kOriginalLength * 2,
             GetInt64(data_reduction_proxy::prefs::kHttpOriginalContentLength));
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, OneResponse) {
-  const int64 kOriginalLength = 200;
-  const int64 kReceivedLength = 100;
-  int64 original[] = {kOriginalLength};
-  int64 received[] = {kReceivedLength};
+  const int64_t kOriginalLength = 200;
+  const int64_t kReceivedLength = 100;
+  int64_t original[] = {kOriginalLength};
+  int64_t received[] = {kReceivedLength};
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
 
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 1, received, 1,
       original, 1, received, 1,
       original, 1, received, 1);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, MultipleResponses) {
-  const int64 kOriginalLength = 150;
-  const int64 kReceivedLength = 100;
-  int64 original[] = {kOriginalLength};
-  int64 received[] = {kReceivedLength};
+  const int64_t kOriginalLength = 150;
+  const int64_t kReceivedLength = 100;
+  int64_t original[] = {kOriginalLength};
+  int64_t received[] = {kReceivedLength};
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, false, UNKNOWN_TYPE, FakeNow());
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 1, received, 1,
       NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, UNKNOWN_TYPE, FakeNow());
   original[0] += kOriginalLength;
   received[0] += kReceivedLength;
-  int64 original_proxy_enabled[] = {kOriginalLength};
-  int64 received_proxy_enabled[] = {kReceivedLength};
+  int64_t original_proxy_enabled[] = {kOriginalLength};
+  int64_t received_proxy_enabled[] = {kReceivedLength};
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 1, received, 1,
       original_proxy_enabled, 1, received_proxy_enabled, 1,
       NULL, 0, NULL, 0);
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
   original[0] += kOriginalLength;
   received[0] += kReceivedLength;
   original_proxy_enabled[0] += kOriginalLength;
   received_proxy_enabled[0] += kReceivedLength;
-  int64 original_via_proxy[] = {kOriginalLength};
-  int64 received_via_proxy[] = {kReceivedLength};
+  int64_t original_via_proxy[] = {kOriginalLength};
+  int64_t received_via_proxy[] = {kReceivedLength};
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 1, received, 1,
       original_proxy_enabled, 1, received_proxy_enabled, 1,
       original_via_proxy, 1, received_via_proxy, 1);
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, UNKNOWN_TYPE, FakeNow());
   original[0] += kOriginalLength;
   received[0] += kReceivedLength;
   original_proxy_enabled[0] += kOriginalLength;
   received_proxy_enabled[0] += kReceivedLength;
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 1, received, 1,
       original_proxy_enabled, 1, received_proxy_enabled, 1,
       original_via_proxy, 1, received_via_proxy, 1);
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, false, UNKNOWN_TYPE, FakeNow());
   original[0] += kOriginalLength;
   received[0] += kReceivedLength;
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 1, received, 1,
       original_proxy_enabled, 1, received_proxy_enabled, 1,
       original_via_proxy, 1, received_via_proxy, 1);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, RequestType) {
-  const int64 kContentLength = 200;
-  int64 received[] = {0};
-  int64 https_received[] = {0};
-  int64 total_received[] = {0};
-  int64 proxy_enabled_received[] = {0};
+  const int64_t kContentLength = 200;
+  int64_t received[] = {0};
+  int64_t https_received[] = {0};
+  int64_t total_received[] = {0};
+  int64_t proxy_enabled_received[] = {0};
 
   RecordContentLengthPrefs(
       kContentLength, kContentLength, true, HTTPS, FakeNow());
   total_received[0] += kContentLength;
   proxy_enabled_received[0] += kContentLength;
   https_received[0] += kContentLength;
   VerifyDailyRequestTypeContentLengthPrefLists(
       total_received, 1, total_received, 1,
       proxy_enabled_received, 1, proxy_enabled_received, 1,
       https_received, 1,
@@ skipping 58 matching lines @@
   VerifyDailyRequestTypeContentLengthPrefLists(
       total_received, 1, total_received, 1,
       proxy_enabled_received, 1, proxy_enabled_received, 1,
       https_received, 1,
       received, 1,  // short bypass
       received, 1,  // long bypass
       received, 1);  // unknown
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, ForwardOneDay) {
-  const int64 kOriginalLength = 200;
-  const int64 kReceivedLength = 100;
+  const int64_t kOriginalLength = 200;
+  const int64_t kReceivedLength = 100;
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
 
   // Forward one day.
   SetFakeTimeDeltaInHours(24);
 
   // Proxy not enabled. Not via proxy.
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, false, UNKNOWN_TYPE, FakeNow());
 
-  int64 original[] = {kOriginalLength, kOriginalLength};
-  int64 received[] = {kReceivedLength, kReceivedLength};
-  int64 original_with_data_reduction_proxy_enabled[] = {kOriginalLength, 0};
-  int64 received_with_data_reduction_proxy_enabled[] = {kReceivedLength, 0};
-  int64 original_via_data_reduction_proxy[] = {kOriginalLength, 0};
-  int64 received_via_data_reduction_proxy[] = {kReceivedLength, 0};
+  int64_t original[] = {kOriginalLength, kOriginalLength};
+  int64_t received[] = {kReceivedLength, kReceivedLength};
+  int64_t original_with_data_reduction_proxy_enabled[] = {kOriginalLength, 0};
+  int64_t received_with_data_reduction_proxy_enabled[] = {kReceivedLength, 0};
+  int64_t original_via_data_reduction_proxy[] = {kOriginalLength, 0};
+  int64_t received_via_data_reduction_proxy[] = {kReceivedLength, 0};
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 2,
       received, 2,
       original_with_data_reduction_proxy_enabled, 2,
       received_with_data_reduction_proxy_enabled, 2,
       original_via_data_reduction_proxy, 2,
       received_via_data_reduction_proxy, 2);
 
   // Proxy enabled. Not via proxy.
   RecordContentLengthPrefs(
@@ skipping 21 matching lines @@
   original_via_data_reduction_proxy[1] += kOriginalLength;
   received_via_data_reduction_proxy[1] += kReceivedLength;
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 2,
       received, 2,
       original_with_data_reduction_proxy_enabled, 2,
       received_with_data_reduction_proxy_enabled, 2,
       original_via_data_reduction_proxy, 2,
       received_via_data_reduction_proxy, 2);
 
-  // Proxy enabled and via proxy, with content length greater than max int32.
-  const int64 kBigOriginalLength = 0x300000000LL;  // 12G.
-  const int64 kBigReceivedLength = 0x200000000LL;  // 8G.
+  // Proxy enabled and via proxy, with content length greater than max int32_t.
+  const int64_t kBigOriginalLength = 0x300000000LL;  // 12G.
+  const int64_t kBigReceivedLength = 0x200000000LL;  // 8G.
   RecordContentLengthPrefs(kBigReceivedLength, kBigOriginalLength, true,
                            VIA_DATA_REDUCTION_PROXY, FakeNow());
   original[1] += kBigOriginalLength;
   received[1] += kBigReceivedLength;
   original_with_data_reduction_proxy_enabled[1] += kBigOriginalLength;
   received_with_data_reduction_proxy_enabled[1] += kBigReceivedLength;
   original_via_data_reduction_proxy[1] += kBigOriginalLength;
   received_via_data_reduction_proxy[1] += kBigReceivedLength;
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 2, received, 2, original_with_data_reduction_proxy_enabled, 2,
       received_with_data_reduction_proxy_enabled, 2,
       original_via_data_reduction_proxy, 2, received_via_data_reduction_proxy,
       2);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, PartialDayTimeChange) {
-  const int64 kOriginalLength = 200;
-  const int64 kReceivedLength = 100;
-  int64 original[] = {0, kOriginalLength};
-  int64 received[] = {0, kReceivedLength};
+  const int64_t kOriginalLength = 200;
+  const int64_t kReceivedLength = 100;
+  int64_t original[] = {0, kOriginalLength};
+  int64_t received[] = {0, kReceivedLength};
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 2, received, 2,
       original, 2, received, 2,
       original, 2, received, 2);
 
   // Forward 10 hours, stay in the same day.
   // See kLastUpdateTime: "Now" in test is 03:45am.
   SetFakeTimeDeltaInHours(10);
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
   original[1] += kOriginalLength;
   received[1] += kReceivedLength;
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 2, received, 2,
       original, 2, received, 2,
       original, 2, received, 2);
 
   // Forward 11 more hours, comes to tomorrow.
   AddFakeTimeDeltaInHours(11);
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
-  int64 original2[] = {kOriginalLength * 2, kOriginalLength};
-  int64 received2[] = {kReceivedLength * 2, kReceivedLength};
+  int64_t original2[] = {kOriginalLength * 2, kOriginalLength};
+  int64_t received2[] = {kReceivedLength * 2, kReceivedLength};
   VerifyDailyDataSavingContentLengthPrefLists(
       original2, 2, received2, 2,
       original2, 2, received2, 2,
       original2, 2, received2, 2);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, ForwardMultipleDays) {
-  const int64 kOriginalLength = 200;
-  const int64 kReceivedLength = 100;
+  const int64_t kOriginalLength = 200;
+  const int64_t kReceivedLength = 100;
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
 
   // Forward three days.
   SetFakeTimeDeltaInHours(3 * 24);
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
 
-  int64 original[] = {kOriginalLength, 0, 0, kOriginalLength};
-  int64 received[] = {kReceivedLength, 0, 0, kReceivedLength};
+  int64_t original[] = {kOriginalLength, 0, 0, kOriginalLength};
+  int64_t received[] = {kReceivedLength, 0, 0, kReceivedLength};
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 4, received, 4,
       original, 4, received, 4,
       original, 4, received, 4);
 
   // Forward four more days.
   AddFakeTimeDeltaInHours(4 * 24);
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
-  int64 original2[] = {
-    kOriginalLength, 0, 0, kOriginalLength, 0, 0, 0, kOriginalLength,
+  int64_t original2[] = {
+      kOriginalLength, 0, 0, kOriginalLength, 0, 0, 0, kOriginalLength,
   };
-  int64 received2[] = {
-    kReceivedLength, 0, 0, kReceivedLength, 0, 0, 0, kReceivedLength,
+  int64_t received2[] = {
+      kReceivedLength, 0, 0, kReceivedLength, 0, 0, 0, kReceivedLength,
   };
   VerifyDailyDataSavingContentLengthPrefLists(
       original2, 8, received2, 8,
       original2, 8, received2, 8,
       original2, 8, received2, 8);
 
   // Forward |kNumDaysInHistory| more days.
   AddFakeTimeDeltaInHours(kNumDaysInHistory * 24);
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
-  int64 original3[] = {kOriginalLength};
-  int64 received3[] = {kReceivedLength};
+  int64_t original3[] = {kOriginalLength};
+  int64_t received3[] = {kReceivedLength};
   VerifyDailyDataSavingContentLengthPrefLists(
       original3, 1, received3, 1,
       original3, 1, received3, 1,
       original3, 1, received3, 1);
 
   // Forward |kNumDaysInHistory| + 1 more days.
   AddFakeTimeDeltaInHours((kNumDaysInHistory + 1)* 24);
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
   VerifyDailyDataSavingContentLengthPrefLists(
       original3, 1, received3, 1,
       original3, 1, received3, 1,
       original3, 1, received3, 1);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, BackwardAndForwardOneDay) {
-  const int64 kOriginalLength = 200;
-  const int64 kReceivedLength = 100;
-  int64 original[] = {kOriginalLength};
-  int64 received[] = {kReceivedLength};
+  const int64_t kOriginalLength = 200;
+  const int64_t kReceivedLength = 100;
+  int64_t original[] = {kOriginalLength};
+  int64_t received[] = {kReceivedLength};
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
 
   // Backward one day.
   SetFakeTimeDeltaInHours(-24);
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
   original[0] += kOriginalLength;
   received[0] += kReceivedLength;
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 1, received, 1,
       original, 1, received, 1,
       original, 1, received, 1);
 
   // Then, Forward one day
   AddFakeTimeDeltaInHours(24);
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
-  int64 original2[] = {kOriginalLength * 2, kOriginalLength};
-  int64 received2[] = {kReceivedLength * 2, kReceivedLength};
+  int64_t original2[] = {kOriginalLength * 2, kOriginalLength};
+  int64_t received2[] = {kReceivedLength * 2, kReceivedLength};
   VerifyDailyDataSavingContentLengthPrefLists(
       original2, 2, received2, 2,
       original2, 2, received2, 2,
       original2, 2, received2, 2);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, BackwardTwoDays) {
-  const int64 kOriginalLength = 200;
-  const int64 kReceivedLength = 100;
-  int64 original[] = {kOriginalLength};
-  int64 received[] = {kReceivedLength};
+  const int64_t kOriginalLength = 200;
+  const int64_t kReceivedLength = 100;
+  int64_t original[] = {kOriginalLength};
+  int64_t received[] = {kReceivedLength};
 
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
   // Backward two days.
   SetFakeTimeDeltaInHours(-2 * 24);
   RecordContentLengthPrefs(
       kReceivedLength, kOriginalLength, true, VIA_DATA_REDUCTION_PROXY,
       FakeNow());
   VerifyDailyDataSavingContentLengthPrefLists(
       original, 1, received, 1,
       original, 1, received, 1,
       original, 1, received, 1);
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, NormalizeHostname) {
   EXPECT_EQ("www.foo.com", NormalizeHostname("http://www.foo.com"));
   EXPECT_EQ("foo.com", NormalizeHostname("https://foo.com"));
   EXPECT_EQ("bar.co.uk", NormalizeHostname("http://bar.co.uk"));
   EXPECT_EQ("http.www.co.in", NormalizeHostname("http://http.www.co.in"));
 }
 
 TEST_F(DataReductionProxyCompressionStatsTest, RecordUma) {
-  const int64 kOriginalLength = 15000;
-  const int64 kReceivedLength = 10000;
+  const int64_t kOriginalLength = 15000;
+  const int64_t kReceivedLength = 10000;
   base::HistogramTester tester;
 
   RecordContentLengthPrefs(kReceivedLength, kOriginalLength, true,
                            VIA_DATA_REDUCTION_PROXY, FakeNow());
 
   // Forward one day.
   SetFakeTimeDeltaInHours(24);
 
   // Proxy not enabled. Not via proxy.
   RecordContentLengthPrefs(kReceivedLength, kOriginalLength, false,
@@ skipping 269 matching lines @@
   expected_data_usage =
       make_scoped_ptr(new std::vector<data_reduction_proxy::DataUsageBucket>(
           kNumExpectedBuckets));
   DataUsageLoadVerifier verifier2(expected_data_usage.Pass());
   LoadHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
                                      base::Unretained(&verifier2)));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace data_reduction_proxy