Disable precache if data_reduction_proxy enabled.

components/precache/content/precache_manager.cc

 // Copyright 2013 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/precache/content/precache_manager.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/precache/core/precache_database.h"
 #include "components/precache/core/precache_switches.h"
 #include "components/precache/core/proto/unfinished_work.pb.h"
 #include "components/prefs/pref_service.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/variations/metrics_util.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/base/network_change_notifier.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const char kPrecacheFieldTrialName[] = "Precache";
 const char kPrecacheFieldTrialEnabledGroup[] = "Enabled";
 const char kPrecacheFieldTrialControlGroup[] = "Control";
 const char kConfigURLParam[] = "config_url";
 const char kManifestURLPrefixParam[] = "manifest_url_prefix";
+const char kDataReductionProxyParam[] = "disable_if_data_reduction_proxy";
 const size_t kNumTopHosts = 100;
 
 }  // namespace
 
 namespace precache {
 
 size_t NumTopHosts() {
   return kNumTopHosts;
 }
 
 PrecacheManager::PrecacheManager(
     content::BrowserContext* browser_context,
     const syncer::SyncService* const sync_service,
     const history::HistoryService* const history_service,
+    const data_reduction_proxy::DataReductionProxySettings*
+        data_reduction_proxy_settings,
     const base::FilePath& db_path,
     std::unique_ptr<PrecacheDatabase> precache_database)
     : browser_context_(browser_context),
       sync_service_(sync_service),
       history_service_(history_service),
+      data_reduction_proxy_settings_(data_reduction_proxy_settings),
       is_precaching_(false) {
   precache_database_ = std::move(precache_database);
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&PrecacheDatabase::Init),
                  base::Unretained(precache_database_.get()), db_path));
 }
 
 PrecacheManager::~PrecacheManager() {
   // DeleteSoon posts a non-nestable task to the task runner, so any previously
@@ skipping 24 matching lines @@
          base::StartsWith(
              base::FieldTrialList::FindFullName(kPrecacheFieldTrialName),
              kPrecacheFieldTrialControlGroup, base::CompareCase::SENSITIVE);
 }
 
 bool PrecacheManager::IsPrecachingAllowed() const {
   return PrecachingAllowed() == AllowedType::ALLOWED;
 }
 
 PrecacheManager::AllowedType PrecacheManager::PrecachingAllowed() const {
+  bool disable_if_proxy = !variations::GetVariationParamValue(
+      kPrecacheFieldTrialName, kDataReductionProxyParam).empty();
+  if (disable_if_proxy &&
+      (!data_reduction_proxy_settings_ ||
+       data_reduction_proxy_settings_->IsDataReductionProxyEnabled()))
+    return AllowedType::DISALLOWED;
+
   if (!(sync_service_ && sync_service_->IsEngineInitialized()))
     return AllowedType::PENDING;
 
   // SyncService delegates to SyncPrefs, which must be called on the UI thread.
   if (history_service_ &&
       sync_service_->GetActiveDataTypes().Has(syncer::SESSIONS) &&
       !sync_service_->GetEncryptedDataTypes().Has(syncer::SESSIONS))
     return AllowedType::ALLOWED;
 
   return AllowedType::DISALLOWED;
@@ skipping 243 matching lines @@
       this));
   precache_fetcher_->Start();
 }
 
 void PrecacheManager::OnHostsReceivedThenDone(
     const history::TopHostsList& host_counts) {
   OnDone();
 }
 
 }  // namespace precache