predictors: Pass manifests from Bork to store in ResourcePrefetchPredictor.

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>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/history/core/browser/history_constants.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/precache/core/precache_database.h"
+#include "components/precache/core/precache_manifest_delegate.h"
 #include "components/precache/core/precache_switches.h"
 #include "components/precache/core/proto/unfinished_work.pb.h"
 #include "components/variations/variations_params_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 #include "net/http/http_response_headers.h"
@@ skipping 61 matching lines @@
   }
 
   MOCK_CONST_METHOD2(TopHosts,
                      void(size_t num_hosts, const TopHostsCallback& callback));
 
   MOCK_CONST_METHOD2(HostRankIfAvailable,
                      void(const GURL& url,
                           const base::Callback<void(int)>& callback));
 };
 
+class MockPrecacheManifestDelegate : public PrecacheManifestDelegate {
+ public:
+  MOCK_METHOD2(OnManifestFetched,
+               void(const std::string& host, const PrecacheManifest& manifest));
+};
+
 ACTION_P(ReturnHosts, starting_hosts) {
   arg1.Run(starting_hosts);
 }
 
 class TestPrecacheCompletionCallback {
  public:
   TestPrecacheCompletionCallback() : was_on_done_called_(false) {}
 
   void OnDone(bool precaching_started) { was_on_done_called_ = true; }
 
@@ skipping 11 matching lines @@
 };
 
 class PrecacheManagerUnderTest : public PrecacheManager {
  public:
   PrecacheManagerUnderTest(
       content::BrowserContext* browser_context,
       const syncer::SyncService* sync_service,
       const history::HistoryService* history_service,
       const data_reduction_proxy::DataReductionProxySettings*
           data_reduction_proxy_settings,
+      PrecacheManifestDelegate* precache_manifest_delegate_,
       const base::FilePath& db_path,
       std::unique_ptr<PrecacheDatabase> precache_database)
       : PrecacheManager(browser_context,
                         sync_service,
                         history_service,
                         data_reduction_proxy_settings,
+                        precache_manifest_delegate_,
                         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 38 matching lines @@
                              net::URLRequestStatus::FAILED);
     info_.headers = new net::HttpResponseHeaders("");
   }
 
   // precache_manager_ assumes ownership of precache_database.
   void Reset(PrecacheDatabase* precache_database) {
     base::FilePath db_path = scoped_temp_dir_.GetPath().Append(
         base::FilePath(FILE_PATH_LITERAL("precache_database")));
     precache_manager_.reset(new PrecacheManagerUnderTest(
         &browser_context_, nullptr /* sync_service */, &history_service_,
-        nullptr /* data_reduction_proxy_settings */, db_path,
+        nullptr /* data_reduction_proxy_settings */,
+        &precache_manifest_delegate_, db_path,
         base::WrapUnique(precache_database)));
   }
 
   void Flush() { precache_database_->Flush(); }
 
   void RecordStatsForFetch(const GURL& url,
                            const std::string& referrer_host,
                            const base::Time& fetch_time,
                            const net::HttpResponseInfo& info,
                            int64_t size,
@@ skipping 23 matching lines @@
   // Must be declared first so that it is destroyed last.
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
   base::ScopedTempDir scoped_temp_dir_;
   PrecacheDatabase* precache_database_;
   content::TestBrowserContext browser_context_;
   std::unique_ptr<PrecacheManagerUnderTest> precache_manager_;
   TestURLFetcherCallback url_callback_;
   net::FakeURLFetcherFactory factory_;
   TestPrecacheCompletionCallback precache_callback_;
   testing::NiceMock<MockHistoryService> history_service_;
+  testing::NiceMock<MockPrecacheManifestDelegate> precache_manifest_delegate_;
   base::HistogramTester histograms_;
   net::HttpResponseInfo info_;
   variations::testing::VariationParamsManager variation_params_;
 };
 
 TEST_F(PrecacheManagerTest, StartAndFinishPrecaching) {
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   MockHistoryService::TopHostsCallback top_hosts_callback;
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
@@ skipping 414 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