Select precache resources based on field trial experiment group

components/precache/core/precache_fetcher_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/core/precache_fetcher.h"
 
 #include <stdint.h>
 
 #include <cstring>
 #include <memory>
@@ skipping 41 matching lines @@
 const char kManifestFetchFailureURL[] =
     "http://manifest-url-prefix.com/manifest-fetch-failure.com";
 const char kBadManifestURL[] =
     "http://manifest-url-prefix.com/bad-manifest.com";
 const char kGoodManifestURL[] =
     "http://manifest-url-prefix.com/good-manifest.com";
 const char kCustomGoodManifestURL[] =
     "http://custom-manifest-url-prefix.com/good-manifest.com";
 const char kResourceFetchFailureURL[] = "http://resource-fetch-failure.com";
 const char kGoodResourceURL[] = "http://good-resource.com";
+const char kGoodResourceURLA[] = "http://good-resource.com/a";
+const char kGoodResourceURLB[] = "http://good-resource.com/b";
+const char kGoodResourceURLC[] = "http://good-resource.com/c";
+const char kGoodResourceURLD[] = "http://good-resource.com/d";
 const char kForcedStartingURLManifestURL[] =
     "http://manifest-url-prefix.com/forced-starting-url.com";
+const uint32_t kExperimentID = 123;
 
 class TestURLFetcherCallback {
  public:
   TestURLFetcherCallback() : total_response_bytes_(0) {}
 
   std::unique_ptr<net::FakeURLFetcher> CreateURLFetcher(
       const GURL& url,
       net::URLFetcherDelegate* delegate,
       const std::string& response_data,
       net::HttpStatusCode response_code,
@@ skipping 310 matching lines @@
                            net::URLRequestStatus::FAILED);
   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kForcedStartingURLManifestURL),
                            PrecacheManifest().SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
-    PrecacheFetcher precache_fetcher(request_context_.get(),
-                                     GURL(), std::string(),
-                                     std::move(unfinished_work),
-                                     &precache_delegate_);
+    PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                     std::string(), std::move(unfinished_work),
+                                     kExperimentID, &precache_delegate_);
     precache_fetcher.Start();
 
     loop_.RunUntilIdle();
 
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kManifestFetchFailureURL));
   expected_requested_urls.insert(GURL(kBadManifestURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   expected_requested_urls.insert(GURL(kResourceFetchFailureURL));
   expected_requested_urls.insert(GURL(kGoodResourceURL));
   expected_requested_urls.insert(GURL(kForcedStartingURLManifestURL));
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 100, 1);
   histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total",
                                url_callback_.total_response_bytes(), 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
+TEST_F(PrecacheFetcherTest, PrecacheResourceSelection) {
+  SetDefaultFlags();
+
+  std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
+      new PrecacheUnfinishedWork());
+  unfinished_work->add_top_host()->set_hostname("good-manifest.com");
+  unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
+
+  PrecacheConfigurationSettings config;
+
+  PrecacheManifest good_manifest;
+  PrecacheResourceSelection resource_selection;
+  good_manifest.add_resource()->set_url(kGoodResourceURL);
+  good_manifest.add_resource()->set_url(kGoodResourceURLA);
+  good_manifest.add_resource()->set_url(kGoodResourceURLB);
+  good_manifest.add_resource()->set_url(kGoodResourceURLC);
+  good_manifest.add_resource()->set_url(kGoodResourceURLD);
+
+  // Set bits for kGoodResourceURL, kGoodResourceURLB and kGoodResourceURLD.
+  resource_selection.set_bitset(0x15);

[twifkak, 2016/06/02 22:28:24]

How about 0b10101 ?

[Raj, 2016/06/04 19:09:52]

Done.

+  (*good_manifest.mutable_experiments()
+        ->mutable_resources_by_experiment_group())[kExperimentID] =
+      resource_selection;
+
+  factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
+                           net::HTTP_OK, net::URLRequestStatus::SUCCESS);
+  factory_.SetFakeResponse(GURL(kGoodManifestURL),
+                           good_manifest.SerializeAsString(), net::HTTP_OK,
+                           net::URLRequestStatus::SUCCESS);
+  factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
+                           net::URLRequestStatus::SUCCESS);
+  factory_.SetFakeResponse(GURL(kGoodResourceURLB), "good URL B", net::HTTP_OK,
+                           net::URLRequestStatus::SUCCESS);
+  factory_.SetFakeResponse(GURL(kGoodResourceURLD), "good URL D", net::HTTP_OK,
+                           net::URLRequestStatus::SUCCESS);
+
+  base::HistogramTester histogram;
+
+  {
+    PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                     std::string(), std::move(unfinished_work),
+                                     kExperimentID, &precache_delegate_);
+    precache_fetcher.Start();
+
+    loop_.RunUntilIdle();
+
+    // Destroy the PrecacheFetcher after it has finished, to record metrics.
+  }
+
+  std::multiset<GURL> expected_requested_urls;
+  expected_requested_urls.insert(GURL(kConfigURL));
+  expected_requested_urls.insert(GURL(kGoodManifestURL));
+  expected_requested_urls.insert(GURL(kGoodResourceURL));
+  expected_requested_urls.insert(GURL(kGoodResourceURLB));
+  expected_requested_urls.insert(GURL(kGoodResourceURLD));
+
+  EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+
+  EXPECT_TRUE(precache_delegate_.was_on_done_called());
+
+  histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 100, 1);
+  histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total",
+                               url_callback_.total_response_bytes(), 1);
+  histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
+}
+
 TEST_F(PrecacheFetcherTest, PrecachePauseResume) {
   SetDefaultFlags();
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(3);
 
   std::unique_ptr<PrecacheUnfinishedWork> initial_work(
       new PrecacheUnfinishedWork());
   initial_work->add_manifest()->set_url(
       "http://manifest-url-prefix.com/manifest1.com");
   initial_work->add_manifest()->set_url(
       "http://manifest-url-prefix.com/manifest2.com");
   initial_work->add_resource()->set_url(kGoodResourceURL);
   initial_work->set_start_time(
       (base::Time::Now() - base::TimeDelta::FromHours(1)).ToInternalValue());
 
-  PrecacheFetcher first_fetcher(request_context_.get(),
-                                GURL(), std::string(),
-                                std::move(initial_work),
+  PrecacheFetcher first_fetcher(request_context_.get(), GURL(), std::string(),
+                                std::move(initial_work), kExperimentID,
                                 &precache_delegate_);
 
   loop_.RunUntilIdle();
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work =
       first_fetcher.CancelPrecaching();
 
   std::multiset<GURL> expected_requested_urls;
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kBadManifestURL), "bad protobuf", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL("http://manifest-url-prefix.com/manifest1.com"),
                            "bad protobuf", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL("http://manifest-url-prefix.com/manifest2.com"),
                            "bad protobuf", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   // Starting hosts should not be fetched.
   unfinished_work->add_top_host()->set_hostname("bad-manifest.com");
-  PrecacheFetcher second_fetcher(request_context_.get(),
-                                 GURL(), std::string(),
-                                 std::move(unfinished_work),
+  PrecacheFetcher second_fetcher(request_context_.get(), GURL(), std::string(),
+                                 std::move(unfinished_work), kExperimentID,
                                  &precache_delegate_);
   second_fetcher.Start();
   loop_.RunUntilIdle();
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(
       GURL("http://manifest-url-prefix.com/manifest1.com"));
   expected_requested_urls.insert(
       GURL("http://manifest-url-prefix.com/manifest2.com"));
   expected_requested_urls.insert(GURL(kGoodResourceURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, ResumeWithConfigOnly) {
   SetDefaultFlags();
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->mutable_config_settings()->add_forced_site(
       "good-manifest.com");
   unfinished_work->set_start_time(base::Time::Now().ToInternalValue());
   PrecacheManifest good_manifest;
   good_manifest.add_resource()->set_url(kGoodResourceURL);
 
   factory_.SetFakeResponse(GURL(kGoodManifestURL),
                            good_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   {
-    PrecacheFetcher precache_fetcher(request_context_.get(),
-                                     GURL(), std::string(),
-                                     std::move(unfinished_work),
-                                     &precache_delegate_);
+    PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                     std::string(), std::move(unfinished_work),
+                                     kExperimentID, &precache_delegate_);
     precache_fetcher.Start();
 
     loop_.RunUntilIdle();
   }
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   expected_requested_urls.insert(GURL(kGoodResourceURL));
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
@@ skipping 16 matching lines @@
 
   factory_.SetFakeResponse(GURL(kCustomConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kCustomGoodManifestURL),
                            good_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(
-      request_context_.get(), GURL(kCustomConfigURL),
-      kCustomManifestURLPrefix, std::move(unfinished_work),
-      &precache_delegate_);
+      request_context_.get(), GURL(kCustomConfigURL), kCustomManifestURLPrefix,
+      std::move(unfinished_work), kExperimentID, &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kCustomConfigURL));
   expected_requested_urls.insert(GURL(kCustomGoodManifestURL));
   expected_requested_urls.insert(GURL(kGoodResourceURL));
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, ConfigFetchFailure) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("good-manifest.com");
 
   factory_.SetFakeResponse(GURL(kConfigURL), "",
                            net::HTTP_INTERNAL_SERVER_ERROR,
                            net::URLRequestStatus::FAILED);
   factory_.SetFakeResponse(GURL(kGoodManifestURL), "", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
-  PrecacheFetcher precache_fetcher(request_context_.get(),
-                                   GURL(), std::string(),
-                                   std::move(unfinished_work),
-                                   &precache_delegate_);
+  PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                   std::string(), std::move(unfinished_work),
+                                   kExperimentID, &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, BadConfig) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("good-manifest.com");
 
   factory_.SetFakeResponse(GURL(kConfigURL), "bad protobuf", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodManifestURL), "", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
-  PrecacheFetcher precache_fetcher(request_context_.get(),
-                                   GURL(), std::string(),
-                                   std::move(unfinished_work),
-                                   &precache_delegate_);
+  PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                   std::string(), std::move(unfinished_work),
+                                   kExperimentID, &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, Cancel) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("starting-url.com");
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(1);
 
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
-    PrecacheFetcher precache_fetcher(request_context_.get(),
-                                     GURL(), std::string(),
-                                     std::move(unfinished_work),
-                                     &precache_delegate_);
+    PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                     std::string(), std::move(unfinished_work),
+                                     kExperimentID, &precache_delegate_);
     precache_fetcher.Start();
 
     // Destroy the PrecacheFetcher, to cancel precaching. No metrics
     // should be recorded because this should not cause OnDone to be
     // called on the precache delegate.
   }
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
@@ skipping 14 matching lines @@
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("starting-url.com");
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(0);
 
   factory_.SetFakeResponse(GURL(PRECACHE_CONFIG_SETTINGS_URL),
                            config.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
-  PrecacheFetcher precache_fetcher(request_context_.get(),
-                                   GURL(), std::string(),
-                                   std::move(unfinished_work),
-                                   &precache_delegate_);
+  PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                   std::string(), std::move(unfinished_work),
+                                   kExperimentID, &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(PRECACHE_CONFIG_SETTINGS_URL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
@@ skipping 15 matching lines @@
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(1);
 
   GURL manifest_url(PRECACHE_MANIFEST_URL_PREFIX "starting-url.com");
 
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(manifest_url, PrecacheManifest().SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
-  PrecacheFetcher precache_fetcher(request_context_.get(),
-                                   GURL(), std::string(),
-                                   std::move(unfinished_work),
-                                   &precache_delegate_);
+  PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                   std::string(), std::move(unfinished_work),
+                                   kExperimentID, &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(manifest_url);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
@@ skipping 23 matching lines @@
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodManifestURL),
                            good_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL("http://good-manifest.com/retrieved"), "good",
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
-    PrecacheFetcher precache_fetcher(request_context_.get(),
-                                     GURL(), std::string(),
-                                     std::move(unfinished_work),
-                                     &precache_delegate_);
+    PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                     std::string(), std::move(unfinished_work),
+                                     kExperimentID, &precache_delegate_);
     precache_fetcher.Start();
 
     loop_.RunUntilIdle();
 
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
@@ skipping 55 matching lines @@
   }
 
   factory_.SetFakeResponse(GURL(kGoodManifestURL),
                            good_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
-                                     std::string(),
-                                     std::move(unfinished_work),
-                                     &precache_delegate_);
+                                     std::string(), std::move(unfinished_work),
+                                     kExperimentID, &precache_delegate_);
     precache_fetcher.Start();
 
     loop_.RunUntilIdle();
   }
 
   // We don't know which will make it and which won't due to the parallelism in
   // the pool of Fetchers.
   EXPECT_GT(kNumResources, url_callback_.requested_urls().size());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   // good-manifest.com will not have been completed.
   EXPECT_THAT(histogram.GetAllSamples("Precache.Fetch.PercentCompleted"),
               ElementsAre(base::Bucket(0, 1)));
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 }  // namespace
 
 }  // namespace precache