Update data reduction proxy statistics prefs less often on desktop

components/data_reduction_proxy/browser/data_reduction_proxy_settings.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_settings.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 75 matching lines @@
 
 namespace data_reduction_proxy {
 
 DataReductionProxySettings::DataReductionProxySettings(
     DataReductionProxyParams* params)
     : restricted_by_carrier_(false),
       enabled_by_user_(false),
       disabled_on_vpn_(false),
       unreachable_(false),
       prefs_(NULL),
-      local_state_prefs_(NULL),
       url_request_context_getter_(NULL) {
   DCHECK(params);
   params_.reset(params);
 }
 
 DataReductionProxySettings::~DataReductionProxySettings() {
   if (params_->allowed())
     spdy_proxy_auth_enabled_.Destroy();
 }
 
 void DataReductionProxySettings::InitPrefMembers() {
   DCHECK(thread_checker_.CalledOnValidThread());
   spdy_proxy_auth_enabled_.Init(
       prefs::kDataReductionProxyEnabled,
       GetOriginalProfilePrefs(),
       base::Bind(&DataReductionProxySettings::OnProxyEnabledPrefChange,
                  base::Unretained(this)));
   data_reduction_proxy_alternative_enabled_.Init(
       prefs::kDataReductionProxyAltEnabled,
       GetOriginalProfilePrefs(),
       base::Bind(
           &DataReductionProxySettings::OnProxyAlternativeEnabledPrefChange,
           base::Unretained(this)));
 }
 
 void DataReductionProxySettings::InitDataReductionProxySettings(
     PrefService* prefs,
-    PrefService* local_state_prefs,
     net::URLRequestContextGetter* url_request_context_getter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(prefs);
-  DCHECK(local_state_prefs);
   DCHECK(url_request_context_getter);
   prefs_ = prefs;
-  local_state_prefs_ = local_state_prefs;
   url_request_context_getter_ = url_request_context_getter;
   InitPrefMembers();
   RecordDataReductionInit();
 
   // Disable the proxy if it is not allowed to be used.
   if (!params_->allowed())
     return;
 
   AddDefaultProxyBypassRules();
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
 
   // We set or reset the proxy pref at startup.
   MaybeActivateDataReductionProxy(true);
 }
 
 void DataReductionProxySettings::InitDataReductionProxySettings(
     PrefService* prefs,
-    PrefService* local_state_prefs,
     net::URLRequestContextGetter* url_request_context_getter,
     scoped_ptr<DataReductionProxyConfigurator> configurator) {
   InitDataReductionProxySettings(prefs,
-                                 local_state_prefs,
                                  url_request_context_getter);
   SetProxyConfigurator(configurator.Pass());
 }
 
+
+void DataReductionProxySettings::SetDataReductionProxyDelayedPrefService(
+    base::WeakPtr<DataReductionProxyDelayedPrefService> delayed_prefs) {
+  delayed_prefs_ = delayed_prefs;
+}
+
 void DataReductionProxySettings::SetOnDataReductionEnabledCallback(
     const base::Callback<void(bool)>& on_data_reduction_proxy_enabled) {
   on_data_reduction_proxy_enabled_ = on_data_reduction_proxy_enabled;
   on_data_reduction_proxy_enabled_.Run(IsDataReductionProxyEnabled());
 }
 
 void DataReductionProxySettings::SetProxyConfigurator(
     scoped_ptr<DataReductionProxyConfigurator> configurator) {
   DCHECK(configurator);
   configurator_ = configurator.Pass();
@@ skipping 31 matching lines @@
   if (!params_->alternative_allowed())
     return;
   if (data_reduction_proxy_alternative_enabled_.GetValue() != enabled) {
     data_reduction_proxy_alternative_enabled_.SetValue(enabled);
     OnProxyAlternativeEnabledPrefChange();
   }
 }
 
 int64 DataReductionProxySettings::GetDataReductionLastUpdateTime() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  PrefService* local_state = GetLocalStatePrefs();
+  if (!delayed_prefs_) {
+    return 0;
+  }
   int64 last_update_internal =
-      local_state->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
+      delayed_prefs_->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
   base::Time last_update = base::Time::FromInternalValue(last_update_internal);
   return static_cast<int64>(last_update.ToJsTime());
 }
 
 DataReductionProxySettings::ContentLengthList
 DataReductionProxySettings::GetDailyOriginalContentLengths() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return GetDailyContentLengths(prefs::kDailyHttpOriginalContentLength);
 }
 
@@ skipping 74 matching lines @@
     }
   }
   restricted_by_carrier_ = true;
 }
 
 PrefService* DataReductionProxySettings::GetOriginalProfilePrefs() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return prefs_;
 }
 
-PrefService* DataReductionProxySettings::GetLocalStatePrefs() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return local_state_prefs_;
-}
-
 void DataReductionProxySettings::AddDefaultProxyBypassRules() {
   // localhost
   DCHECK(configurator_);
   configurator_->AddHostPatternToBypass("<local>");
   // RFC1918 private addresses.
   configurator_->AddHostPatternToBypass("10.0.0.0/8");
   configurator_->AddHostPatternToBypass("172.16.0.0/12");
   configurator_->AddHostPatternToBypass("192.168.0.0/16");
   // RFC4193 private addresses.
   configurator_->AddHostPatternToBypass("fc00::/7");
@@ skipping 43 matching lines @@
 
 void DataReductionProxySettings::OnProxyAlternativeEnabledPrefChange() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!params_->alternative_allowed())
     return;
   MaybeActivateDataReductionProxy(false);
 }
 
 void DataReductionProxySettings::ResetDataReductionStatistics() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  PrefService* prefs = GetLocalStatePrefs();
-  if (!prefs)
+  if (!delayed_prefs_)
     return;
-  ListPrefUpdate original_update(prefs, prefs::kDailyHttpOriginalContentLength);
-  ListPrefUpdate received_update(prefs, prefs::kDailyHttpReceivedContentLength);
+  base::ListValue* original_update =
+      delayed_prefs_->GetList(prefs::kDailyHttpOriginalContentLength);
+  base::ListValue* received_update =
+      delayed_prefs_->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));
   }
 }
 
 void DataReductionProxySettings::MaybeActivateDataReductionProxy(
     bool at_startup) {
@@ skipping 84 matching lines @@
 
 void DataReductionProxySettings::ResetParamsForTest(
     DataReductionProxyParams* params) {
   params_.reset(params);
 }
 
 DataReductionProxySettings::ContentLengthList
 DataReductionProxySettings::GetDailyContentLengths(const char* pref_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DataReductionProxySettings::ContentLengthList content_lengths;
-  const base::ListValue* list_value = GetLocalStatePrefs()->GetList(pref_name);
+  if (!delayed_prefs_) {
+    return content_lengths;
+  }
+  const base::ListValue* list_value = delayed_prefs_->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 DataReductionProxySettings::GetContentLengths(
     unsigned int days,
     int64* original_content_length,
     int64* received_content_length,
     int64* last_update_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_LE(days, kNumDaysInHistory);
-  PrefService* local_state = GetLocalStatePrefs();
-  if (!local_state) {
+  if (!delayed_prefs_) {
     *original_content_length = 0L;
     *received_content_length = 0L;
     *last_update_time = 0L;
     return;
   }
 
   const base::ListValue* original_list =
-      local_state->GetList(prefs::kDailyHttpOriginalContentLength);
+      delayed_prefs_->GetList(prefs::kDailyHttpOriginalContentLength);
   const base::ListValue* received_list =
-      local_state->GetList(prefs::kDailyHttpReceivedContentLength);
+      delayed_prefs_->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;
   // 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 =
-      local_state->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
+      delayed_prefs_->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
 }
 
 net::URLFetcher* DataReductionProxySettings::GetBaseURLFetcher(
     const GURL& gurl,
     int load_flags) {
 
   net::URLFetcher* fetcher = net::URLFetcher::Create(gurl,
                                                      net::URLFetcher::GET,
                                                      this);
   fetcher->SetLoadFlags(load_flags);
@@ skipping 60 matching lines @@
     SetProxyConfigs(enabled_by_user_,
                     IsDataReductionProxyAlternativeEnabled(),
                     restricted_by_carrier_,
                     false);
   }
   disabled_on_vpn_ = false;
   return false;
 }
 
 }  // namespace data_reduction_proxy