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

components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.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_compression_stats.h"
 
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 10 matching lines @@
 
 namespace {
 
 #define CONCAT(a, b) a##b
 // CONCAT1 provides extra level of indirection so that __LINE__ macro expands.
 #define CONCAT1(a, b) CONCAT(a, b)
 #define UNIQUE_VARNAME CONCAT1(var_, __LINE__)
 // We need to use a macro instead of a method because UMA_HISTOGRAM_COUNTS
 // requires its first argument to be an inline string and not a variable.
 #define RECORD_INT64PREF_TO_HISTOGRAM(pref, uma)     \
-  int64 UNIQUE_VARNAME = GetInt64(pref);             \
+  int64_t UNIQUE_VARNAME = GetInt64(pref);           \
   if (UNIQUE_VARNAME > 0) {                          \
     UMA_HISTOGRAM_COUNTS(uma, UNIQUE_VARNAME >> 10); \
   }
 
-// Returns the value at |index| of |list_value| as an int64.
-int64 GetInt64PrefValue(const base::ListValue& list_value, size_t index) {
-  int64 val = 0;
+// Returns the value at |index| of |list_value| as an int64_t.
+int64_t GetInt64PrefValue(const base::ListValue& list_value, size_t index) {
+  int64_t val = 0;
   std::string pref_value;
   bool rv = list_value.GetString(index, &pref_value);
   DCHECK(rv);
   if (rv) {
     rv = base::StringToInt64(pref_value, &val);
     DCHECK(rv);
   }
   return val;
 }
 
 // Ensure list has exactly |length| elements, either by truncating at the
 // front, or appending "0"'s to the back.
 void MaintainContentLengthPrefsWindow(base::ListValue* list, size_t length) {
   // Remove data for old days from the front.
   while (list->GetSize() > length)
     list->Remove(0, NULL);
   // Newly added lists are empty. Add entries to back to fill the window,
   // each initialized to zero.
   while (list->GetSize() < length)
     list->AppendString(base::Int64ToString(0));
   DCHECK_EQ(length, list->GetSize());
 }
 
-// Increments an int64, stored as a string, in a ListPref at the specified
+// Increments an int64_t, stored as a string, in a ListPref at the specified
 // index.  The value must already exist and be a string representation of a
 // number.
 void AddInt64ToListPref(size_t index,
-                        int64 length,
+                        int64_t length,
                         base::ListValue* list_update) {
-  int64 value = 0;
+  int64_t value = 0;
   std::string old_string_value;
   bool rv = list_update->GetString(index, &old_string_value);
   DCHECK(rv);
   if (rv) {
     rv = base::StringToInt64(old_string_value, &value);
     DCHECK(rv);
   }
   value += length;
   list_update->Set(index, new base::StringValue(base::Int64ToString(value)));
 }
 
-int64 ListPrefInt64Value(const base::ListValue& list_update, size_t index) {
+int64_t ListPrefInt64Value(const base::ListValue& list_update, size_t index) {
   std::string string_value;
   if (!list_update.GetString(index, &string_value)) {
     NOTREACHED();
     return 0;
   }
 
-  int64 value = 0;
+  int64_t value = 0;
   bool rv = base::StringToInt64(string_value, &value);
   DCHECK(rv);
   return value;
 }
 
 // DailyContentLengthUpdate maintains a data saving pref. The pref is a list
 // of |kNumDaysInHistory| elements of daily total content lengths for the past
 // |kNumDaysInHistory| days.
 void RecordDailyContentLengthHistograms(
-    int64 original_length,
-    int64 received_length,
-    int64 original_length_with_data_reduction_enabled,
-    int64 received_length_with_data_reduction_enabled,
-    int64 original_length_via_data_reduction_proxy,
-    int64 received_length_via_data_reduction_proxy,
-    int64 https_length_with_data_reduction_enabled,
-    int64 short_bypass_length_with_data_reduction_enabled,
-    int64 long_bypass_length_with_data_reduction_enabled,
-    int64 unknown_length_with_data_reduction_enabled) {
+    int64_t original_length,
+    int64_t received_length,
+    int64_t original_length_with_data_reduction_enabled,
+    int64_t received_length_with_data_reduction_enabled,
+    int64_t original_length_via_data_reduction_proxy,
+    int64_t received_length_via_data_reduction_proxy,
+    int64_t https_length_with_data_reduction_enabled,
+    int64_t short_bypass_length_with_data_reduction_enabled,
+    int64_t long_bypass_length_with_data_reduction_enabled,
+    int64_t unknown_length_with_data_reduction_enabled) {
   // Report daily UMA only for days having received content.
   if (original_length <= 0 || received_length <= 0)
     return;
 
   // Record metrics in KB.
   UMA_HISTOGRAM_COUNTS(
       "Net.DailyOriginalContentLength", original_length >> 10);
   UMA_HISTOGRAM_COUNTS(
       "Net.DailyContentLength", received_length >> 10);
 
@@ skipping 127 matching lines @@
   void UpdateForDataChange(int days_since_last_update) {
     // New empty lists may have been created. Maintain the invariant that
     // there should be exactly |kNumDaysInHistory| days in the histories.
     MaintainContentLengthPrefsWindow(update_, kNumDaysInHistory);
     if (days_since_last_update) {
       MaintainContentLengthPrefForDateChange(days_since_last_update);
     }
   }
 
   // Update the lengths for the current day.
-  void Add(int64 content_length) {
+  void Add(int64_t content_length) {
     AddInt64ToListPref(kNumDaysInHistory - 1, content_length, update_);
   }
 
-  int64 GetListPrefValue(size_t index) {
+  int64_t GetListPrefValue(size_t index) {
     return ListPrefInt64Value(*update_, index);
   }
 
  private:
   // Update the list for date change and ensure the list has exactly |length|
   // elements. The last entry in the list will be for the current day after
   // the update.
   void MaintainContentLengthPrefForDateChange(int days_since_last_update) {
     if (days_since_last_update == -1) {
       // The system may go backwards in time by up to a day for legitimate
@@ skipping 39 matching lines @@
                         base::ListValue* received)
       : original_(original),
         received_(received) {}
 
   void UpdateForDataChange(int days_since_last_update) {
     original_.UpdateForDataChange(days_since_last_update);
     received_.UpdateForDataChange(days_since_last_update);
   }
 
   // Update the lengths for the current day.
-  void Add(int64 original_content_length, int64 received_content_length) {
+  void Add(int64_t original_content_length, int64_t received_content_length) {
     original_.Add(original_content_length);
     received_.Add(received_content_length);
   }
 
-  int64 GetOriginalListPrefValue(size_t index) {
+  int64_t GetOriginalListPrefValue(size_t index) {
     return original_.GetListPrefValue(index);
   }
-  int64 GetReceivedListPrefValue(size_t index) {
+  int64_t GetReceivedListPrefValue(size_t index) {
     return received_.GetListPrefValue(index);
   }
 
  private:
   DailyContentLengthUpdate original_;
   DailyContentLengthUpdate received_;
 };
 
 // Report UMA metrics for daily data reductions.
 }  // namespace
@@ skipping 42 matching lines @@
         weak_factory_.GetWeakPtr()));
   }
 
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   connection_type_ =
       StoredConnectionType(net::NetworkChangeNotifier::GetConnectionType());
 
   if (delay_ == base::TimeDelta())
     return;
 
-  // Init all int64 prefs.
+  // Init all int64_t prefs.
   InitInt64Pref(prefs::kDailyHttpContentLengthLastUpdateDate);
   InitInt64Pref(prefs::kHttpReceivedContentLength);
   InitInt64Pref(prefs::kHttpOriginalContentLength);
 
   InitInt64Pref(prefs::kDailyHttpOriginalContentLengthApplication);
   InitInt64Pref(prefs::kDailyHttpOriginalContentLengthVideo);
   InitInt64Pref(prefs::kDailyHttpOriginalContentLengthUnknown);
   InitInt64Pref(prefs::kDailyHttpReceivedContentLengthApplication);
   InitInt64Pref(prefs::kDailyHttpReceivedContentLengthVideo);
   InitInt64Pref(prefs::kDailyHttpReceivedContentLengthUnknown);
@@ skipping 46 matching lines @@
 void DataReductionProxyCompressionStats::OnUpdateContentLengths() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!pref_service_->GetBoolean(prefs::kUpdateDailyReceivedContentLengths))
     return;
 
   WritePrefs();
   pref_service_->SetBoolean(prefs::kUpdateDailyReceivedContentLengths, false);
 }
 
 void DataReductionProxyCompressionStats::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(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("loader",
                "DataReductionProxyCompressionStats::UpdateContentLengths")
-  int64 total_received = GetInt64(
-      data_reduction_proxy::prefs::kHttpReceivedContentLength);
-  int64 total_original = GetInt64(
-      data_reduction_proxy::prefs::kHttpOriginalContentLength);
+  int64_t total_received =
+      GetInt64(data_reduction_proxy::prefs::kHttpReceivedContentLength);
+  int64_t total_original =
+      GetInt64(data_reduction_proxy::prefs::kHttpOriginalContentLength);
   total_received += data_used;
   total_original += original_size;
   SetInt64(data_reduction_proxy::prefs::kHttpReceivedContentLength,
            total_received);
   SetInt64(data_reduction_proxy::prefs::kHttpOriginalContentLength,
            total_original);
 
   RecordDataUsage(data_usage_host, data_used, original_size, base::Time::Now());
   RecordRequestSizePrefs(data_used, original_size, data_reduction_proxy_enabled,
                          request_type, mime_type, base::Time::Now());
 }
 
 void DataReductionProxyCompressionStats::InitInt64Pref(const char* pref) {
-  int64 pref_value = pref_service_->GetInt64(pref);
+  int64_t pref_value = pref_service_->GetInt64(pref);
   pref_map_[pref] = pref_value;
 }
 
 void DataReductionProxyCompressionStats::InitListPref(const char* pref) {
   scoped_ptr<base::ListValue> pref_value = scoped_ptr<base::ListValue>(
       pref_service_->GetList(pref)->DeepCopy());
   list_pref_map_.add(pref, pref_value.Pass());
 }
 
-int64 DataReductionProxyCompressionStats::GetInt64(const char* pref_path) {
+int64_t DataReductionProxyCompressionStats::GetInt64(const char* pref_path) {
   if (delay_ == base::TimeDelta())
     return pref_service_->GetInt64(pref_path);
 
   DataReductionProxyPrefMap::iterator iter = pref_map_.find(pref_path);
   return iter->second;
 }
 
 void DataReductionProxyCompressionStats::SetInt64(const char* pref_path,
-                                                  int64 pref_value) {
+                                                  int64_t pref_value) {
   if (delay_ == base::TimeDelta()) {
     pref_service_->SetInt64(pref_path, pref_value);
     return;
   }
 
   DelayedWritePrefs();
   pref_map_[pref_path] = pref_value;
 }
 
 void DataReductionProxyCompressionStats::IncrementInt64Pref(
@@ skipping 24 matching lines @@
   for (DataReductionProxyListPrefMap::iterator iter = list_pref_map_.begin();
        iter != list_pref_map_.end(); ++iter) {
     TransferList(*(iter->second),
                  ListPrefUpdate(pref_service_, iter->first).Get());
   }
 }
 
 base::Value*
 DataReductionProxyCompressionStats::HistoricNetworkStatsInfoToValue() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  int64 total_received = GetInt64(prefs::kHttpReceivedContentLength);
-  int64 total_original = GetInt64(prefs::kHttpOriginalContentLength);
+  int64_t total_received = GetInt64(prefs::kHttpReceivedContentLength);
+  int64_t total_original = GetInt64(prefs::kHttpOriginalContentLength);
 
   base::DictionaryValue* dict = new base::DictionaryValue();
   // Use strings to avoid overflow. base::Value only supports 32-bit integers.
   dict->SetString("historic_received_content_length",
                   base::Int64ToString(total_received));
   dict->SetString("historic_original_content_length",
                   base::Int64ToString(total_original));
   return dict;
 }
 
-int64 DataReductionProxyCompressionStats::GetLastUpdateTime() {
-  int64 last_update_internal = GetInt64(
-      prefs::kDailyHttpContentLengthLastUpdateDate);
+int64_t DataReductionProxyCompressionStats::GetLastUpdateTime() {
+  int64_t last_update_internal =
+      GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
   base::Time last_update = base::Time::FromInternalValue(last_update_internal);
-  return static_cast<int64>(last_update.ToJsTime());
+  return static_cast<int64_t>(last_update.ToJsTime());
 }
 
 void DataReductionProxyCompressionStats::ResetStatistics() {
   base::ListValue* original_update =
       GetList(prefs::kDailyHttpOriginalContentLength);
   base::ListValue* received_update =
       GetList(prefs::kDailyHttpReceivedContentLength);
   original_update->Clear();
   received_update->Clear();
   for (size_t i = 0; i < kNumDaysInHistory; ++i) {
     original_update->AppendString(base::Int64ToString(0));
     received_update->AppendString(base::Int64ToString(0));
   }
 }
 
 ContentLengthList DataReductionProxyCompressionStats::GetDailyContentLengths(
     const char* pref_name) {
   ContentLengthList content_lengths;
   const base::ListValue* list_value = GetList(pref_name);
   if (list_value->GetSize() == kNumDaysInHistory) {
     for (size_t i = 0; i < kNumDaysInHistory; ++i)
       content_lengths.push_back(GetInt64PrefValue(*list_value, i));
   }
   return content_lengths;
 }
 
 void DataReductionProxyCompressionStats::GetContentLengths(
     unsigned int days,
-    int64* original_content_length,
-    int64* received_content_length,
-    int64* last_update_time) {
+    int64_t* original_content_length,
+    int64_t* received_content_length,
+    int64_t* last_update_time) {
   DCHECK_LE(days, kNumDaysInHistory);
 
   const base::ListValue* original_list =
       GetList(prefs::kDailyHttpOriginalContentLength);
   const base::ListValue* received_list =
       GetList(prefs::kDailyHttpReceivedContentLength);
 
   if (original_list->GetSize() != kNumDaysInHistory ||
       received_list->GetSize() != kNumDaysInHistory) {
     *original_content_length = 0L;
     *received_content_length = 0L;
     *last_update_time = 0L;
     return;
   }
 
-  int64 orig = 0L;
-  int64 recv = 0L;
+  int64_t orig = 0L;
+  int64_t recv = 0L;
   // Include days from the end of the list going backwards.
   for (size_t i = kNumDaysInHistory - days;
        i < kNumDaysInHistory; ++i) {
     orig += GetInt64PrefValue(*original_list, i);
     recv += GetInt64PrefValue(*received_list, i);
   }
   *original_content_length = orig;
   *received_content_length = recv;
   *last_update_time = GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
 }
@@ skipping 94 matching lines @@
 void DataReductionProxyCompressionStats::TransferList(
     const base::ListValue& from_list,
     base::ListValue* to_list) {
   to_list->Clear();
   for (size_t i = 0; i < from_list.GetSize(); ++i) {
     to_list->Set(i, new base::StringValue(base::Int64ToString(
         GetListPrefInt64Value(from_list, i))));
   }
 }
 
-int64 DataReductionProxyCompressionStats::GetListPrefInt64Value(
+int64_t DataReductionProxyCompressionStats::GetListPrefInt64Value(
     const base::ListValue& list,
     size_t index) {
   std::string string_value;
   if (!list.GetString(index, &string_value)) {
     NOTREACHED();
     return 0;
   }
 
-  int64 value = 0;
+  int64_t value = 0;
   bool rv = base::StringToInt64(string_value, &value);
   DCHECK(rv);
   return value;
 }
 
 void DataReductionProxyCompressionStats::RecordRequestSizePrefs(
-    int64 data_used,
-    int64 original_size,
+    int64_t data_used,
+    int64_t original_size,
     bool with_data_reduction_proxy_enabled,
     DataReductionProxyRequestType request_type,
     const std::string& mime_type,
     const base::Time& now) {
   // TODO(bengr): Remove this check once the underlying cause of
   // http://crbug.com/287821 is fixed. For now, only continue if the current
   // year is reported as being between 1972 and 2970.
   base::TimeDelta time_since_unix_epoch = now - base::Time::UnixEpoch();
   const int kMinDaysSinceUnixEpoch = 365 * 2;  // 2 years.
   const int kMaxDaysSinceUnixEpoch = 365 * 1000;  // 1000 years.
   if (time_since_unix_epoch.InDays() < kMinDaysSinceUnixEpoch ||
       time_since_unix_epoch.InDays() > kMaxDaysSinceUnixEpoch) {
     return;
   }
 
   // Determine how many days it has been since the last update.
-  int64 then_internal = GetInt64(
+  int64_t then_internal = GetInt64(
       data_reduction_proxy::prefs::kDailyHttpContentLengthLastUpdateDate);
 
   // Local midnight could have been shifted due to time zone change.
   // If time is null then don't care if midnight will be wrong shifted due to
   // time zone change because it's still too much time ago.
   base::Time then_midnight = base::Time::FromInternalValue(then_internal);
   if (!then_midnight.is_null()) {
     then_midnight = then_midnight.LocalMidnight();
   }
   base::Time midnight = now.LocalMidnight();
@@ skipping 310 matching lines @@
     IncrementInt64Pref(recevied_size_with_proxy_enabled_pref, received_size);
   }
 
   if (via_data_reduction_proxy) {
     IncrementInt64Pref(original_size_via_proxy_pref, original_size);
     IncrementInt64Pref(received_size_via_proxy_pref, received_size);
   }
 }
 
 void DataReductionProxyCompressionStats::RecordUserVisibleDataSavings() {
-  int64 original_content_length;
-  int64 received_content_length;
-  int64 last_update_internal;
+  int64_t original_content_length;
+  int64_t received_content_length;
+  int64_t last_update_internal;
   GetContentLengths(kNumDaysInHistorySummary, &original_content_length,
                     &received_content_length, &last_update_internal);
 
   if (original_content_length == 0)
     return;
 
-  int64 user_visible_savings_bytes =
+  int64_t user_visible_savings_bytes =
       original_content_length - received_content_length;
   int user_visible_savings_percent =
       user_visible_savings_bytes * 100 / original_content_length;
   UMA_HISTOGRAM_PERCENTAGE(
       "Net.DailyUserVisibleSavingsPercent_DataReductionProxyEnabled",
       user_visible_savings_percent);
   UMA_HISTOGRAM_COUNTS(
       "Net.DailyUserVisibleSavingsSize_DataReductionProxyEnabled",
       user_visible_savings_bytes >> 10);
 }
 
 void DataReductionProxyCompressionStats::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) {
   if (current_data_usage_load_status_ != LOADED)
     return;
 
   DCHECK(data_usage_reporting_enabled_.GetValue());
 
   if (!DataUsageStore::AreInSameInterval(data_usage_map_last_updated_, time)) {
     PersistDataUsage();
     data_usage_map_.clear();
     data_usage_map_last_updated_ = base::Time();
@@ skipping 96 matching lines @@
 std::string DataReductionProxyCompressionStats::NormalizeHostname(
     const std::string& host) {
   size_t pos = host.find("://");
   if (pos != std::string::npos)
     return host.substr(pos + 3);
 
   return host;
 }
 
 }  // namespace data_reduction_proxy