Disable precache if data_reduction_proxy enabled.

components/precache/content/precache_manager_unittest.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 <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 109 matching lines @@
   bool was_on_done_called() const {
     return was_on_done_called_;
   }
 
  private:
   bool was_on_done_called_;
 };
 
 class PrecacheManagerUnderTest : public PrecacheManager {
  public:
-  PrecacheManagerUnderTest(content::BrowserContext* browser_context,
-                           const syncer::SyncService* const sync_service,
-                           const history::HistoryService* const history_service,
-                           const base::FilePath& db_path,
-                           std::unique_ptr<PrecacheDatabase> precache_database)
+  PrecacheManagerUnderTest(
+      content::BrowserContext* browser_context,
+      const syncer::SyncService* sync_service,
+      const history::HistoryService* history_service,
+      const data_reduction_proxy::DataReductionProxySettings*
+          data_reduction_proxy_settings,
+      const base::FilePath& db_path,
+      std::unique_ptr<PrecacheDatabase> precache_database)
       : PrecacheManager(browser_context,
                         sync_service,
                         history_service,
+                        data_reduction_proxy_settings,
                         db_path,
                         std::move(precache_database)),
         control_group_(false) {}
   bool IsInExperimentGroup() const override { return !control_group_; }
   bool IsInControlGroup() const override { return control_group_; }
   bool IsPrecachingAllowed() const override { return true; }
   void SetInControlGroup(bool in_control_group) {
     control_group_ = in_control_group;
   }
 
@@ skipping 31 matching lines @@
 
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     base::FilePath db_path = scoped_temp_dir_.GetPath().Append(
         base::FilePath(FILE_PATH_LITERAL("precache_database")));
 
     // Make the fetch of the precache configuration settings fail. Precaching
     // should still complete normally in this case.
     factory_.SetFakeResponse(GURL(kConfigURL), "",
                              net::HTTP_INTERNAL_SERVER_ERROR,
                              net::URLRequestStatus::FAILED);
-    precache_manager_.reset(
-        new PrecacheManagerUnderTest(
-            &browser_context_, nullptr /* sync_service */,
-            &history_service_, db_path, std::move(precache_database)));
+    precache_manager_.reset(new PrecacheManagerUnderTest(
+        &browser_context_, nullptr /* sync_service */, &history_service_,
+        nullptr /* data_reduction_proxy_settings */, db_path,
+        std::move(precache_database)));
     base::RunLoop().RunUntilIdle();
 
     info_.headers = new net::HttpResponseHeaders("");
   }
 
   void RecordStatsForPrecacheFetch(const GURL& url,
                                    const std::string& referrer_host,
                                    const base::TimeDelta& latency,
                                    const base::Time& fetch_time,
                                    const net::HttpResponseInfo& info,
@@ skipping 360 matching lines @@
   expected_histogram_count_map["Precache.Saved"] += 2;
   expected_histogram_count_map["Precache.TimeSinceLastPrecache"] += 2;
   expected_histogram_count_map["Precache.Saved.Freshness"] = 2;
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ContainerEq(expected_histogram_count_map));
 }
 
 }  // namespace precache