Support gzip-compressed seed data from the variations server.

components/variations/service/variations_service_unittest.cc

 // Copyright (c) 2012 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/variations/service/variations_service.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/feature_list.h"
@@ skipping 65 matching lines @@
   TestVariationsService(
       scoped_ptr<web_resource::TestRequestAllowedNotifier> test_notifier,
       PrefService* local_state)
       : VariationsService(make_scoped_ptr(new TestVariationsServiceClient()),
                           test_notifier.Pass(),
                           local_state,
                           NULL,
                           UIStringOverrider()),
         intercepts_fetch_(true),
         fetch_attempted_(false),
-        seed_stored_(false) {
+        seed_stored_(false),
+        delta_compressed_seed_(false),
+        gzip_compressed_seed_(false) {
     // Set this so StartRepeatedVariationsSeedFetch can be called in tests.
     SetCreateTrialsFromSeedCalledForTesting(true);
   }
 
   ~TestVariationsService() override {}
 
   void set_intercepts_fetch(bool value) {
     intercepts_fetch_ = value;
   }
 
   bool fetch_attempted() const { return fetch_attempted_; }
   bool seed_stored() const { return seed_stored_; }
   const std::string& stored_country() const { return stored_country_; }
+  bool delta_compressed_seed() const { return delta_compressed_seed_; }
+  bool gzip_compressed_seed() const { return gzip_compressed_seed_; }
 
   void DoActualFetch() override {
     if (intercepts_fetch_) {
       fetch_attempted_ = true;
       return;
     }
 
     VariationsService::DoActualFetch();
   }
 
   bool StoreSeed(const std::string& seed_data,
                  const std::string& seed_signature,
                  const std::string& country_code,
                  const base::Time& date_fetched,
-                 bool is_delta_compressed) override {
+                 bool is_delta_compressed,
+                 bool is_gzip_compressed) override {
     seed_stored_ = true;
     stored_seed_data_ = seed_data;
     stored_country_ = country_code;
+    delta_compressed_seed_ = is_delta_compressed;
+    gzip_compressed_seed_ = is_gzip_compressed;
     return true;
   }
 
  private:
   bool LoadSeed(VariationsSeed* seed) override {
     if (!seed_stored_)
       return false;
     return seed->ParseFromString(stored_seed_data_);
   }
 
   bool intercepts_fetch_;
   bool fetch_attempted_;
   bool seed_stored_;
   std::string stored_seed_data_;
   std::string stored_country_;
+  bool delta_compressed_seed_;
+  bool gzip_compressed_seed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestVariationsService);
 };
 
 class TestVariationsServiceObserver : public VariationsService::Observer {
  public:
   TestVariationsServiceObserver()
       : best_effort_changes_notified_(0),
         crticial_changes_notified_(0) {
   }
@@ skipping 51 matching lines @@
 }
 
 // Serializes |seed| to protobuf binary format.
 std::string SerializeSeed(const variations::VariationsSeed& seed) {
   std::string serialized_seed;
   seed.SerializeToString(&serialized_seed);
   return serialized_seed;
 }
 
 // Simulates a variations service response by setting a date header and the
-// specified HTTP |response_code| on |fetcher|.
+// specified HTTP |response_code| on |fetcher|. Sets additional header |header|
+// if it is not NULL.
 scoped_refptr<net::HttpResponseHeaders> SimulateServerResponse(
     int response_code,
-    net::TestURLFetcher* fetcher) {
+    net::TestURLFetcher* fetcher,
+    const std::string* header = NULL) {

[Alexei Svitkine (slow), 2015/10/15 15:50:44]

Default values for params are not allowed by our style guide.

[veranika, 2015/10/15 20:02:57]

But this doesn't apply for functions in unnamed namespaces, does it?
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Default_Argum...

[Alexei Svitkine (slow), 2015/10/15 20:30:26]

Looks like you're right, however we don't use it in metrics code and I'd prefer
if we keep it consistent.

Suggest adding an overload:

SimulateServerResponseWithHeader()

Then, the original function can just call the above with nullptr as param for
the header.

[veranika, 2015/10/15 22:10:37]

Done.

   EXPECT_TRUE(fetcher);
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders("date:Wed, 13 Feb 2013 00:25:24 GMT\0\0"));
+  if (header)
+    headers->AddHeader(*header);
   fetcher->set_response_headers(headers);
   fetcher->set_response_code(response_code);
   return headers;
 }
 
 // Converts |list_value| to a string, to make it easier for debugging.
 std::string ListValueToString(const base::ListValue& list_value) {
   std::string json;
   JSONStringValueSerializer serializer(&json);
   serializer.set_pretty_print(true);
@@ skipping 25 matching lines @@
   // this test.
   base::FieldTrialList field_trial_list(nullptr);
 
   // Create a variations service.
   TestVariationsService service(
       make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
       &prefs);
 
   // Store a seed.
   service.StoreSeed(SerializeSeed(CreateTestSeed()), std::string(),
-                    std::string(), base::Time::Now(), false);
+                    std::string(), base::Time::Now(), false, false);
   prefs.SetInt64(prefs::kVariationsLastFetchTime,
                  base::Time::Now().ToInternalValue());
 
   // Check that field trials are created from the seed. Since the test study has
   // only 1 experiment with 100% probability weight, we must be part of it.
   EXPECT_TRUE(service.CreateTrialsFromSeed(base::FeatureList::GetInstance()));
   EXPECT_EQ(base::FieldTrialList::FindFullName(kTestSeedStudyName),
             kTestSeedExperimentName);
 }
 
@@ skipping 10 matching lines @@
   base::FieldTrialList field_trial_list(nullptr);
 
   // Create a variations service
   TestVariationsService service(
       make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
       &prefs);
 
   // Store a seed. To simulate a first run, |prefs::kVariationsLastFetchTime|
   // is left empty.
   service.StoreSeed(SerializeSeed(CreateTestSeed()), std::string(),
-                    std::string(), base::Time::Now(), false);
+                    std::string(), base::Time::Now(), false, false);
   EXPECT_EQ(0, prefs.GetInt64(prefs::kVariationsLastFetchTime));
 
   // Check that field trials are created from the seed. Since the test study has
   // only 1 experiment with 100% probability weight, we must be part of it.
   EXPECT_TRUE(service.CreateTrialsFromSeed(base::FeatureList::GetInstance()));
   EXPECT_EQ(base::FieldTrialList::FindFullName(kTestSeedStudyName),
             kTestSeedExperimentName);
 }
 
 TEST_F(VariationsServiceTest, CreateTrialsFromOutdatedSeed) {
@@ skipping 10 matching lines @@
 
   // Create a variations service.
   TestVariationsService service(
       make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
       &prefs);
 
   // Store a seed, with a fetch time 31 days in the past.
   const base::Time seed_date =
       base::Time::Now() - base::TimeDelta::FromDays(31);
   service.StoreSeed(SerializeSeed(CreateTestSeed()), std::string(),
-                    std::string(), seed_date, false);
+                    std::string(), seed_date, false, false);
   prefs.SetInt64(prefs::kVariationsLastFetchTime, seed_date.ToInternalValue());
 
   // Check that field trials are not created from the seed.
   EXPECT_FALSE(service.CreateTrialsFromSeed(base::FeatureList::GetInstance()));
   EXPECT_TRUE(base::FieldTrialList::FindFullName(kTestSeedStudyName).empty());
 }
 
 TEST_F(VariationsServiceTest, GetVariationsServerURL) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
@@ skipping 133 matching lines @@
     EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 
     net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
     SimulateServerResponse(non_ok_status_codes[i], fetcher);
     service.OnURLFetchComplete(fetcher);
 
     EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
   }
 }
 
+TEST_F(VariationsServiceTest, RequestGzipCompressedSeed) {
+  TestingPrefServiceSimple prefs;
+  VariationsService::RegisterPrefs(prefs.registry());
+  net::TestURLFetcherFactory factory;
+
+  TestVariationsService service(
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      &prefs);
+  service.variations_server_url_ =
+      service.GetVariationsServerURL(&prefs, std::string());

[Alexei Svitkine (slow), 2015/10/15 15:50:44]

Could this line of code be moved into the TestVariationsService ctor, so it
isn't duplicated in all the tests?

[veranika, 2015/10/15 20:02:57]

VariationsService::variations_server_url_ is a private field and
TestVariationsService is in an anonymous namespace, so it's not possible to set
it as a friend of VariationsService. I could make variations_server_url_ a
protected field, but I'm not entirely sure it's the right thing to do.

[Alexei Svitkine (slow), 2015/10/15 20:30:26]

I suggest providing a protected setter for it.

[veranika, 2015/10/15 22:10:37]

Good idea, thanks.

+  service.set_intercepts_fetch(false);
+  service.DoActualFetch();
+
+  net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+  net::HttpRequestHeaders headers;
+  fetcher->GetExtraRequestHeaders(&headers);
+  std::string field;
+  ASSERT_TRUE(headers.GetHeader("A-IM", &field));
+  EXPECT_EQ("gzip", field);
+}
+
+TEST_F(VariationsServiceTest, InstanceManipulations) {
+  struct  {
+    std::string im;
+    bool delta_compressed;
+    bool gzip_compressed;
+    bool seed_stored;
+  } cases[] = {
+    {"", false, false, true},
+    {"IM:gzip", false, true, true},
+    {"IM:x-bm", true, false, true},
+    {"IM:x-bm,gzip", true, true, true},
+    {"IM: x-bm, gzip", true, true, true},
+    {"IM:gzip,x-bm", false, false, false},
+    {"IM:deflate,x-bm,gzip", false, false, false},
+  };
+
+  TestingPrefServiceSimple prefs;
+  VariationsService::RegisterPrefs(prefs.registry());
+  std::string serialized_seed = SerializeSeed(CreateTestSeed());
+  net::TestURLFetcherFactory factory;
+
+  for (size_t i = 0; i < arraysize(cases); ++i) {
+    TestVariationsService service(
+        make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        &prefs);
+    service.variations_server_url_ =
+        service.GetVariationsServerURL(&prefs, std::string());
+    service.set_intercepts_fetch(false);
+    service.DoActualFetch();
+    net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+
+    if (cases[i].im.empty())
+      SimulateServerResponse(net::HTTP_OK, fetcher);
+    else
+      SimulateServerResponse(net::HTTP_OK, fetcher, &cases[i].im);
+    fetcher->SetResponseString(serialized_seed);
+    service.OnURLFetchComplete(fetcher);
+
+    EXPECT_EQ(cases[i].seed_stored, service.seed_stored());
+    EXPECT_EQ(cases[i].delta_compressed, service.delta_compressed_seed());
+    EXPECT_EQ(cases[i].gzip_compressed, service.gzip_compressed_seed());
+  }
+}
+
 TEST_F(VariationsServiceTest, CountryHeader) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
       make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
       &prefs);
   service.variations_server_url_ =
       service.GetVariationsServerURL(&prefs, std::string());
   service.set_intercepts_fetch(false);
@@ skipping 156 matching lines @@
         << test.pref_value_before << ", " << test.version << ", "
         << test.latest_country_code;
 
     histogram_tester.ExpectUniqueSample(
         "Variations.LoadPermanentConsistencyCountryResult",
         test.expected_result, 1);
   }
 }
 
 }  // namespace variations