Support gzip-compressed seed data from the variations server.

components/variations/variations_seed_store_unittest.cc

 // Copyright 2014 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/variations_seed_store.h"
 
 #include "base/base64.h"
 #include "base/prefs/testing_pref_service.h"
 #include "components/compression/compression_utils.h"
 #include "components/variations/pref_names.h"
 #include "components/variations/proto/study.pb.h"
 #include "components/variations/proto/variations_seed.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace variations {
 
 namespace {
 
 class TestVariationsSeedStore : public VariationsSeedStore {
  public:
   explicit TestVariationsSeedStore(PrefService* local_state)
       : VariationsSeedStore(local_state) {}
   ~TestVariationsSeedStore() override {}
 
   bool StoreSeedForTesting(const std::string& seed_data) {
     return StoreSeedData(seed_data, std::string(), std::string(),
-                         base::Time::Now(), false, nullptr);
+                         base::Time::Now(), false, false, nullptr);
   }
 
   VariationsSeedStore::VerifySignatureResult VerifySeedSignature(
       const std::string& seed_bytes,
       const std::string& base64_seed_signature) override {
     return VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_ENUM_SIZE;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestVariationsSeedStore);
@@ skipping 166 matching lines @@
   const variations::VariationsSeed seed = CreateTestSeed();
   const std::string serialized_seed = SerializeSeed(seed);
 
   TestingPrefServiceSimple prefs;
   VariationsSeedStore::RegisterPrefs(prefs.registry());
   TestVariationsSeedStore seed_store(&prefs);
 
   variations::VariationsSeed parsed_seed;
   EXPECT_TRUE(seed_store.StoreSeedData(serialized_seed, std::string(),
                                        std::string(), base::Time::Now(), false,
-                                       &parsed_seed));
+                                       false, &parsed_seed));
   EXPECT_EQ(serialized_seed, SerializeSeed(parsed_seed));
 }
 
 TEST(VariationsSeedStoreTest, StoreSeedData_CountryCode) {
   TestingPrefServiceSimple prefs;
   VariationsSeedStore::RegisterPrefs(prefs.registry());
   TestVariationsSeedStore seed_store(&prefs);
 
   // Test with a seed country code and no header value.
   variations::VariationsSeed seed = CreateTestSeed();
   seed.set_country_code("test_country");
   EXPECT_TRUE(seed_store.StoreSeedData(SerializeSeed(seed), std::string(),
                                        std::string(), base::Time::Now(), false,
-                                       nullptr));
+                                       false, nullptr));
   EXPECT_EQ("test_country", prefs.GetString(prefs::kVariationsCountry));
 
   // Test with a header value and no seed country.
   prefs.ClearPref(prefs::kVariationsCountry);
   seed.clear_country_code();
   EXPECT_TRUE(seed_store.StoreSeedData(SerializeSeed(seed), std::string(),
                                        "test_country2", base::Time::Now(),
-                                       false,  nullptr));
+                                       false, false,  nullptr));
   EXPECT_EQ("test_country2", prefs.GetString(prefs::kVariationsCountry));
 
   // Test with a seed country code and header value.
   prefs.ClearPref(prefs::kVariationsCountry);
   seed.set_country_code("test_country3");
   EXPECT_TRUE(seed_store.StoreSeedData(SerializeSeed(seed), std::string(),
                                        "test_country4", base::Time::Now(),
-                                       false, nullptr));
+                                       false, false, nullptr));
   EXPECT_EQ("test_country4", prefs.GetString(prefs::kVariationsCountry));
 
   // Test with no country code specified - which should preserve the old value.
   seed.clear_country_code();
   EXPECT_TRUE(seed_store.StoreSeedData(SerializeSeed(seed), std::string(),
                                        std::string(), base::Time::Now(), false,
-                                       nullptr));
+                                       false, nullptr));
   EXPECT_EQ("test_country4", prefs.GetString(prefs::kVariationsCountry));
 }
 
+TEST(VariationsSeedStoreTest, StoreSeedData_GzippedSeed) {
+  const variations::VariationsSeed seed = CreateTestSeed();
+  const std::string serialized_seed = SerializeSeed(seed);
+  std::string compressed_seed;
+  ASSERT_TRUE(compression::GzipCompress(serialized_seed, &compressed_seed));
+
+  TestingPrefServiceSimple prefs;
+  VariationsSeedStore::RegisterPrefs(prefs.registry());
+  TestVariationsSeedStore seed_store(&prefs);
+
+  variations::VariationsSeed parsed_seed;
+  EXPECT_TRUE(seed_store.StoreSeedData(compressed_seed, std::string(),
+                                       std::string(), base::Time::Now(), false,
+                                       true, &parsed_seed));
+  EXPECT_EQ(serialized_seed, SerializeSeed(parsed_seed));
+}
+
 TEST(VariationsSeedStoreTest, VerifySeedSignature) {
   // The below seed and signature pair were generated using the server's
   // private key.
   const std::string base64_seed_data =
       "CigxZDI5NDY0ZmIzZDc4ZmYxNTU2ZTViNTUxYzY0NDdjYmM3NGU1ZmQwEr0BCh9VTUEtVW5p"
       "Zm9ybWl0eS1UcmlhbC0xMC1QZXJjZW50GICckqUFOAFCB2RlZmF1bHRKCwoHZGVmYXVsdBAB"
       "SgwKCGdyb3VwXzAxEAFKDAoIZ3JvdXBfMDIQAUoMCghncm91cF8wMxABSgwKCGdyb3VwXzA0"
       "EAFKDAoIZ3JvdXBfMDUQAUoMCghncm91cF8wNhABSgwKCGdyb3VwXzA3EAFKDAoIZ3JvdXBf"
       "MDgQAUoMCghncm91cF8wORAB";
   const std::string base64_seed_signature =
@@ skipping 75 matching lines @@
   EXPECT_TRUE(base::Base64Decode(base64_after_seed_data, &after_seed_data));
   EXPECT_TRUE(base::Base64Decode(base64_delta_data, &delta_data));
 
   std::string output;
   EXPECT_TRUE(VariationsSeedStore::ApplyDeltaPatch(before_seed_data, delta_data,
                                                    &output));
   EXPECT_EQ(after_seed_data, output);
 }
 
 }  // namespace variations