Support gzip-compressed seed data from the variations server.

components/variations/variations_seed_store.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/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 73 matching lines @@
   VARIATIONS_SEED_STORE_FAILED_PARSE,
   VARIATIONS_SEED_STORE_FAILED_SIGNATURE,
   VARIATIONS_SEED_STORE_FAILED_GZIP,
   // DELTA_COUNT is not so much a result of the seed store, but rather counting
   // the number of delta-compressed seeds the SeedStore() function saw. Kept in
   // the same histogram for convenience of comparing against the other values.
   VARIATIONS_SEED_STORE_DELTA_COUNT,
   VARIATIONS_SEED_STORE_FAILED_DELTA_READ_SEED,
   VARIATIONS_SEED_STORE_FAILED_DELTA_APPLY,
   VARIATIONS_SEED_STORE_FAILED_DELTA_STORE,
+  VARIATIONS_SEED_STORE_FAILED_UNGZIP,
+  VARIATIONS_SEED_STORE_FAILED_EMPTY_GZIP_CONTENTS,
+  VARIATIONS_SEED_STORE_FAILED_UNSUPPORTED_SEED_FORMAT,
   VARIATIONS_SEED_STORE_RESULT_ENUM_SIZE,
 };
 
 void RecordSeedStoreHistogram(VariationsSeedStoreResult result) {
   UMA_HISTOGRAM_ENUMERATION("Variations.SeedStoreResult", result,
                             VARIATIONS_SEED_STORE_RESULT_ENUM_SIZE);
 }
 
 // Note: UMA histogram enum - don't re-order or remove entries.
 enum VariationsSeedDateChangeState {
@@ skipping 83 matching lines @@
   RecordVariationSeedEmptyHistogram(VARIATIONS_SEED_NOT_EMPTY);
   return true;
 }
 
 bool VariationsSeedStore::StoreSeedData(
     const std::string& data,
     const std::string& base64_seed_signature,
     const std::string& country_code,
     const base::Time& date_fetched,
     bool is_delta_compressed,
+    bool is_gzip_compressed,
     variations::VariationsSeed* parsed_seed) {
+  // If the data is gzip compressed, first uncompress it.
+  std::string ungzipped_data;
+  if (is_gzip_compressed) {
+    if (compression::GzipUncompress(data, &ungzipped_data)) {
+      if (ungzipped_data.empty()) {
+        RecordSeedStoreHistogram(
+            VARIATIONS_SEED_STORE_FAILED_EMPTY_GZIP_CONTENTS);
+        return false;
+      }
+
+      int size_reduction = ungzipped_data.length() - data.length();
+      UMA_HISTOGRAM_PERCENTAGE("Variations.StoreSeed.GzipSize.ReductionPercent",
+                               100 * size_reduction / ungzipped_data.length());
+      UMA_HISTOGRAM_COUNTS_1000("Variations.StoreSeed.GzipSize",
+                                data.length() / 1024);
+    } else {
+      RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_UNGZIP);
+      return false;
+    }
+  } else {
+    ungzipped_data = data;
+  }
+
   if (!is_delta_compressed) {
     const bool result =
-        StoreSeedDataNoDelta(data, base64_seed_signature, country_code,
-                             date_fetched, parsed_seed);
+        StoreSeedDataNoDelta(ungzipped_data, base64_seed_signature,
+                             country_code, date_fetched, parsed_seed);
     if (result) {
       UMA_HISTOGRAM_COUNTS_1000("Variations.StoreSeed.Size",
-                                data.length() / 1024);
+                                ungzipped_data.length() / 1024);
     }
     return result;
   }
 
   // If the data is delta compressed, first decode it.
   DCHECK(invalid_base64_signature_.empty());
   RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_DELTA_COUNT);
 
   std::string existing_seed_data;
   std::string updated_seed_data;
   if (!ReadSeedData(&existing_seed_data)) {
     RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_DELTA_READ_SEED);
     return false;
   }
-  if (!ApplyDeltaPatch(existing_seed_data, data, &updated_seed_data)) {
+  if (!ApplyDeltaPatch(existing_seed_data, ungzipped_data,
+                       &updated_seed_data)) {
     RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_DELTA_APPLY);
     return false;
   }
 
   const bool result =
       StoreSeedDataNoDelta(updated_seed_data, base64_seed_signature,
                            country_code, date_fetched, parsed_seed);
   if (result) {
     // Note: |updated_seed_data.length()| is guaranteed to be non-zero, else
     // result would be false.
-    int size_reduction = updated_seed_data.length() - data.length();
+    int size_reduction = updated_seed_data.length() - ungzipped_data.length();
     UMA_HISTOGRAM_PERCENTAGE("Variations.StoreSeed.DeltaSize.ReductionPercent",
                              100 * size_reduction / updated_seed_data.length());
     UMA_HISTOGRAM_COUNTS_1000("Variations.StoreSeed.DeltaSize",
-                              data.length() / 1024);
+                              ungzipped_data.length() / 1024);
   } else {
     RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_DELTA_STORE);
   }
   return result;
 }
 
 void VariationsSeedStore::UpdateSeedDateAndLogDayChange(
     const base::Time& server_date_fetched) {
   VariationsSeedDateChangeState date_change = SEED_DATE_NO_OLD_DATE;
 
@@ skipping 95 matching lines @@
   return true;
 }
 
 bool VariationsSeedStore::StoreSeedDataNoDelta(
     const std::string& seed_data,
     const std::string& base64_seed_signature,
     const std::string& country_code,
     const base::Time& date_fetched,
     variations::VariationsSeed* parsed_seed) {
   if (seed_data.empty()) {
-    RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_EMPTY);
+    RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_EMPTY_GZIP_CONTENTS);
     return false;
   }
 
   // Only store the seed data if it parses correctly.
   variations::VariationsSeed seed;
   if (!seed.ParseFromString(seed_data)) {
     RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_PARSE);
     return false;
   }
 
@@ skipping 82 matching lines @@
       base::CheckedNumeric<uint32> end_offset(offset);
       end_offset += length;
       if (!end_offset.IsValid() || end_offset.ValueOrDie() > existing_data_size)
         return false;
       output->append(existing_data, offset, length);
     }
   }
   return true;
 }
 
+void VariationsSeedStore::ReportUnsupportedSeedFormatError() {
+  RecordSeedStoreHistogram(
+      VARIATIONS_SEED_STORE_FAILED_UNSUPPORTED_SEED_FORMAT);
+}
+
 }  // namespace variations