Rename DataReductionProxyStatisticsPrefs to DataReductionProxyCompressionStats

components/data_reduction_proxy/core/browser/data_reduction_proxy_metrics.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_metrics.h"
 
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
-#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_statistics_prefs.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_headers.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_pref_names.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_retry_info.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
@@ skipping 166 matching lines @@
     list->AppendString(base::Int64ToString(0));
   DCHECK_EQ(length, list->GetSize());
 }
 
 // DailyContentLengthUpdate maintains a data saving pref. The pref is a list
 // of |kNumDaysInHistory| elements of daily total content lengths for the past
 // |kNumDaysInHistory| days.
 class DailyContentLengthUpdate {
  public:
   DailyContentLengthUpdate(const char* pref,
-                           DataReductionProxyStatisticsPrefs* pref_service)
-      : update_(pref_service->GetList(pref)) {
-  }
+                           DataReductionProxyCompressionStats* pref_service)
+      : update_(pref_service->GetList(pref)) {}
 
   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);
     }
   }
 
@@ skipping 46 matching lines @@
 
 // DailyDataSavingUpdate maintains a pair of data saving prefs, original_update_
 // and received_update_. pref_original is a list of |kNumDaysInHistory| elements
 // of daily total original content lengths for the past |kNumDaysInHistory|
 // days. pref_received is the corresponding list of the daily total received
 // content lengths.
 class DailyDataSavingUpdate {
  public:
   DailyDataSavingUpdate(const char* pref_original,
                         const char* pref_received,
-                        DataReductionProxyStatisticsPrefs* prefs)
-      : original_(pref_original, prefs),
-        received_(pref_received, prefs) {
-  }
+                        DataReductionProxyCompressionStats* compression_stats)
+      : original_(pref_original, compression_stats),
+        received_(pref_received, compression_stats) {}
 
   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(int original_content_length, int received_content_length) {
     original_.Add(original_content_length);
     received_.Add(received_content_length);
@@ skipping 68 matching lines @@
   }
   return original_content_length;
 }
 
 void UpdateContentLengthPrefsForDataReductionProxy(
     int received_content_length,
     int original_content_length,
     bool with_data_reduction_proxy_enabled,
     DataReductionProxyRequestType request_type,
     base::Time now,
-    DataReductionProxyStatisticsPrefs* prefs) {
+    DataReductionProxyCompressionStats* compression_stats) {
   // 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 = prefs->GetInt64(
+  int64 then_internal = compression_stats->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();
 
   int days_since_last_update = (midnight - then_midnight).InDays();
 
   // Each day, we calculate the total number of bytes received and the total
   // size of all corresponding resources before any data-reducing recompression
   // is applied. These values are used to compute the data savings realized
   // by applying our compression techniques. Totals for the last
   // |kNumDaysInHistory| days are maintained.
   DailyDataSavingUpdate total(
       data_reduction_proxy::prefs::kDailyHttpOriginalContentLength,
       data_reduction_proxy::prefs::kDailyHttpReceivedContentLength,
-      prefs);
+      compression_stats);
   total.UpdateForDataChange(days_since_last_update);
 
   DailyDataSavingUpdate proxy_enabled(
       data_reduction_proxy::prefs::
           kDailyOriginalContentLengthWithDataReductionProxyEnabled,
       data_reduction_proxy::prefs::
           kDailyContentLengthWithDataReductionProxyEnabled,
-      prefs);
+      compression_stats);
   proxy_enabled.UpdateForDataChange(days_since_last_update);
 
   DailyDataSavingUpdate via_proxy(
       data_reduction_proxy::prefs::
           kDailyOriginalContentLengthViaDataReductionProxy,
       data_reduction_proxy::prefs::
           kDailyContentLengthViaDataReductionProxy,
-      prefs);
+      compression_stats);
   via_proxy.UpdateForDataChange(days_since_last_update);
 
   DailyContentLengthUpdate https(
       data_reduction_proxy::prefs::
           kDailyContentLengthHttpsWithDataReductionProxyEnabled,
-      prefs);
+      compression_stats);
   https.UpdateForDataChange(days_since_last_update);
 
   DailyContentLengthUpdate short_bypass(
       data_reduction_proxy::prefs::
           kDailyContentLengthShortBypassWithDataReductionProxyEnabled,
-      prefs);
+      compression_stats);
   short_bypass.UpdateForDataChange(days_since_last_update);
 
   DailyContentLengthUpdate long_bypass(
       data_reduction_proxy::prefs::
           kDailyContentLengthLongBypassWithDataReductionProxyEnabled,
-      prefs);
+      compression_stats);
   long_bypass.UpdateForDataChange(days_since_last_update);
 
   DailyContentLengthUpdate unknown(
       data_reduction_proxy::prefs::
           kDailyContentLengthUnknownWithDataReductionProxyEnabled,
-      prefs);
+      compression_stats);
   unknown.UpdateForDataChange(days_since_last_update);
 
   total.Add(original_content_length, received_content_length);
   if (with_data_reduction_proxy_enabled) {
     proxy_enabled.Add(original_content_length, received_content_length);
     // Ignore data source cases, if exist, when
     // "with_data_reduction_proxy_enabled == false"
     switch (request_type) {
       case VIA_DATA_REDUCTION_PROXY:
         via_proxy.Add(original_content_length, received_content_length);
         break;
       case HTTPS:
         https.Add(received_content_length);
         break;
       case SHORT_BYPASS:
         short_bypass.Add(received_content_length);
         break;
       case LONG_BYPASS:
         long_bypass.Add(received_content_length);
         break;
       case UNKNOWN_TYPE:
         unknown.Add(received_content_length);
         break;
     }
   }
 
   if (days_since_last_update) {
     // Record the last update time in microseconds in UTC.
-    prefs->SetInt64(
+    compression_stats->SetInt64(
         data_reduction_proxy::prefs::kDailyHttpContentLengthLastUpdateDate,
         midnight.ToInternalValue());
 
     // A new day. Report the previous day's data if exists. We'll lose usage
     // data if the last time Chrome was run was more than a day ago.
     // Here, we prefer collecting less data but the collected data is
     // associated with an accurate date.
     if (days_since_last_update == 1) {
       // The previous day's data point is the second one from the tail.
       // Therefore (kNumDaysInHistory - 2) below.
       RecordDailyContentLengthHistograms(
           total.GetOriginalListPrefValue(kNumDaysInHistory - 2),
           total.GetReceivedListPrefValue(kNumDaysInHistory - 2),
           proxy_enabled.GetOriginalListPrefValue(kNumDaysInHistory - 2),
           proxy_enabled.GetReceivedListPrefValue(kNumDaysInHistory - 2),
           via_proxy.GetOriginalListPrefValue(kNumDaysInHistory - 2),
           via_proxy.GetReceivedListPrefValue(kNumDaysInHistory - 2),
           https.GetListPrefValue(kNumDaysInHistory - 2),
           short_bypass.GetListPrefValue(kNumDaysInHistory - 2),
           long_bypass.GetListPrefValue(kNumDaysInHistory - 2),
           unknown.GetListPrefValue(kNumDaysInHistory - 2));
     }
   }
 }
 
 }  // namespace data_reduction_proxy