Revert of Collect data reduction proxy UMA on all platforms

components/data_reduction_proxy/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/browser/data_reduction_proxy_metrics.h"
 
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_pref_names.h"
 #include "net/base/host_port_pair.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_retry_info.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 
 namespace data_reduction_proxy {
 
 namespace {
 
 // A bypass delay more than this is treated as a long delay.
 const int kLongBypassDelayInSeconds = 30 * 60;
 
+#if defined(OS_ANDROID) || defined(OS_IOS)
+
 // Increments an int64, 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,
                         base::ListValue* list_update) {
   int64 value = 0;
   std::string old_string_value;
   bool rv = list_update->GetString(index, &old_string_value);
   DCHECK(rv);
@@ skipping 252 matching lines @@
   }
   int64 GetReceivedListPrefValue(size_t index) {
     return received_.GetListPrefValue(index);
   }
 
  private:
   DailyContentLengthUpdate original_;
   DailyContentLengthUpdate received_;
 };
 
+#endif  // defined(OS_ANDROID) || defined(OS_IOS)
+
 // Returns true if the request is bypassed by all configured data reduction
 // proxies. It returns the bypass delay in delay_seconds (if not NULL). If
 // the request is bypassed by more than one proxy, delay_seconds returns
 // shortest delay.
 bool IsBypassRequest(const net::URLRequest* request, int64* delay_seconds) {
+#if defined(OS_ANDROID) || defined(OS_IOS)
   DataReductionProxySettings::DataReductionProxyList proxies =
       DataReductionProxySettings::GetDataReductionProxies();
   if (proxies.size() == 0)
     return false;
 
   if (request == NULL || request->context() == NULL ||
       request->context()->proxy_service() == NULL) {
     return false;
   }
 
@@ skipping 14 matching lines @@
     if (found == retry_map.end())
       return false;
     if (shortest_delay == 0 ||
         shortest_delay > found->second.current_delay.InSeconds()) {
       shortest_delay = found->second.current_delay.InSeconds();
     }
   }
   if (delay_seconds != NULL)
     *delay_seconds = shortest_delay;
   return true;
+#else
+  return false;
+#endif  // defined(OS_ANDROID) || defined(OS_IOS)
 }
 
 }  // namespace
 
 DataReductionProxyRequestType GetDataReductionProxyRequestType(
     const net::URLRequest* request) {
   if (request->url().SchemeIs("https"))
     return HTTPS;
   if (!request->url().SchemeIs("http")) {
     NOTREACHED();
     return UNKNOWN_TYPE;
   }
   int64 bypass_delay = 0;
   if (IsBypassRequest(request, &bypass_delay)) {
     return (bypass_delay > kLongBypassDelayInSeconds) ?
       LONG_BYPASS : SHORT_BYPASS;
   }
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
   if (request->response_info().headers &&
       request->response_info().headers->IsDataReductionProxyResponse()) {
     return VIA_DATA_REDUCTION_PROXY;
   }
+#endif
   return UNKNOWN_TYPE;
 }
 
 int64 GetAdjustedOriginalContentLength(
     DataReductionProxyRequestType request_type,
     int64 original_content_length,
     int64 received_content_length) {
   // Since there was no indication of the original content length, presume
   // it is no different from the number of bytes read.
   if (original_content_length == -1 ||
       request_type != VIA_DATA_REDUCTION_PROXY) {
     return received_content_length;
   }
   return original_content_length;
 }
 
+#if defined(OS_ANDROID) || defined(OS_IOS)
 void UpdateContentLengthPrefsForDataReductionProxy(
     int received_content_length,
     int original_content_length,
     bool with_data_reduction_proxy_enabled,
     DataReductionProxyRequestType request_type,
     base::Time now, PrefService* prefs) {
   // 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(
       data_reduction_proxy::prefs::kDailyHttpContentLengthLastUpdateDate);
-
-#if defined(OS_WIN)
-  base::Time then_midnight = base::Time::FromInternalValue(then_internal);
-  base::Time midnight =
-      base::Time::FromInternalValue(
-          (now.ToInternalValue() / base::Time::kMicrosecondsPerDay) *
-              base::Time::kMicrosecondsPerDay);
-#else
   // Local midnight could have been shifted due to time zone change.
   base::Time then_midnight =
       base::Time::FromInternalValue(then_internal).LocalMidnight();
   base::Time midnight = now.LocalMidnight();
-#endif
-
   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,
@@ skipping 84 matching lines @@
           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));
     }
   }
 }
+#endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
 void UpdateContentLengthPrefs(
     int received_content_length,
     int original_content_length,
     bool with_data_reduction_proxy_enabled,
     DataReductionProxyRequestType request_type,
     PrefService* prefs) {
   int64 total_received = prefs->GetInt64(
       data_reduction_proxy::prefs::kHttpReceivedContentLength);
   int64 total_original = prefs->GetInt64(
       data_reduction_proxy::prefs::kHttpOriginalContentLength);
   total_received += received_content_length;
   total_original += original_content_length;
   prefs->SetInt64(data_reduction_proxy::prefs::kHttpReceivedContentLength,
                   total_received);
   prefs->SetInt64(data_reduction_proxy::prefs::kHttpOriginalContentLength,
                   total_original);
 
+#if defined(OS_ANDROID) || defined(OS_IOS)
   UpdateContentLengthPrefsForDataReductionProxy(
       received_content_length,
       original_content_length,
       with_data_reduction_proxy_enabled,
       request_type,
       base::Time::Now(),
       prefs);
+#endif  // defined(OS_ANDROID) || defined(OS_IOS)
+
 }
 
 }  // namespace data_reduction_proxy