[Cleanup] Clean up the VariationsSeedStore's histograms.

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/macros.h"
+#include "base/test/histogram_tester.h"
 #include "build/build_config.h"
 #include "components/prefs/testing_pref_service.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"
 #include "third_party/zlib/google/compression_utils.h"
 
 #if defined(OS_ANDROID)
 #include "components/variations/android/variations_seed_bridge.h"
 #endif  // OS_ANDROID
 
 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, false, nullptr);
   }
 
-  VariationsSeedStore::VerifySignatureResult VerifySeedSignature(
-      const std::string& seed_bytes,
-      const std::string& base64_seed_signature) override {
-    return VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_ENUM_SIZE;
-  }
+  bool SignatureVerificationEnabled() override { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestVariationsSeedStore);
 };
 
+// Signature verification is disabled on Android and iOS for performance
+// reasons. This class re-enables it for tests, which don't mind the (small)
+// performance penalty.
+class SignatureVerifyingVariationsSeedStore : public VariationsSeedStore {
+ public:
+  explicit SignatureVerifyingVariationsSeedStore(PrefService* local_state)
+      : VariationsSeedStore(local_state) {}
+  ~SignatureVerifyingVariationsSeedStore() override {}
+
+  bool SignatureVerificationEnabled() override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SignatureVerifyingVariationsSeedStore);
+};
 
 // Populates |seed| with simple test data. The resulting seed will contain one
 // study called "test", which contains one experiment called "abc" with
 // probability weight 100. |seed|'s study field will be cleared before adding
 // the new study.
 VariationsSeed CreateTestSeed() {
   VariationsSeed seed;
   Study* study = seed.add_study();
   study->set_name("test");
   study->set_default_experiment_name("abc");
@@ skipping 96 matching lines @@
   base::Base64Encode(Compress(uncompressed_seed_data),
                      &compressed_base64_seed_data);
 
   // Set seed and valid signature in prefs.
   prefs.SetString(prefs::kVariationsCompressedSeed,
                   compressed_base64_seed_data);
   prefs.SetString(prefs::kVariationsSeedSignature, base64_seed_signature);
 
   VariationsSeedStore seed_store(&prefs);
   VariationsSeed loaded_seed;
-  seed_store.LoadSeed(&loaded_seed);
+  EXPECT_TRUE(seed_store.LoadSeed(&loaded_seed));
   std::string invalid_signature = seed_store.GetInvalidSignature();
   // Valid signature so we get an empty string.
   EXPECT_EQ(std::string(), invalid_signature);
 
   prefs.SetString(prefs::kVariationsSeedSignature,
                   base64_seed_signature_invalid);
-  seed_store.LoadSeed(&loaded_seed);
+#if defined(OS_IOS) || defined(OS_ANDROID)
+  EXPECT_TRUE(seed_store.LoadSeed(&loaded_seed));
+#else
+  EXPECT_FALSE(seed_store.LoadSeed(&loaded_seed));
+#endif
   // Invalid signature, so we should get the signature itself, except on mobile
   // where we should get an empty string because verification is not enabled.
   invalid_signature = seed_store.GetInvalidSignature();
 #if defined(OS_IOS) || defined(OS_ANDROID)
   EXPECT_EQ(std::string(), invalid_signature);
 #else
   EXPECT_EQ(base64_seed_signature_invalid, invalid_signature);
 #endif
 
   prefs.SetString(prefs::kVariationsSeedSignature, std::string());
-  seed_store.LoadSeed(&loaded_seed);
+#if defined(OS_IOS) || defined(OS_ANDROID)
+  EXPECT_TRUE(seed_store.LoadSeed(&loaded_seed));
+#else
+  EXPECT_FALSE(seed_store.LoadSeed(&loaded_seed));
+#endif
   invalid_signature = seed_store.GetInvalidSignature();
   // Empty signature, not considered invalid.
   EXPECT_EQ(std::string(), invalid_signature);
 }
 
 TEST(VariationsSeedStoreTest, StoreSeedData) {
   const VariationsSeed seed = CreateTestSeed();
   const std::string serialized_seed = SerializeSeed(seed);
 
   TestingPrefServiceSimple prefs;
@@ skipping 81 matching lines @@
 
   VariationsSeed parsed_seed;
   EXPECT_FALSE(seed_store.StoreSeedData(compressed_seed, std::string(),
                                        std::string(), base::Time::Now(), false,
                                        true, &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 =
+  const std::string uncompressed_base64_seed_data =
       "CigxZDI5NDY0ZmIzZDc4ZmYxNTU2ZTViNTUxYzY0NDdjYmM3NGU1ZmQwEr0BCh9VTUEtVW5p"
       "Zm9ybWl0eS1UcmlhbC0xMC1QZXJjZW50GICckqUFOAFCB2RlZmF1bHRKCwoHZGVmYXVsdBAB"
       "SgwKCGdyb3VwXzAxEAFKDAoIZ3JvdXBfMDIQAUoMCghncm91cF8wMxABSgwKCGdyb3VwXzA0"
       "EAFKDAoIZ3JvdXBfMDUQAUoMCghncm91cF8wNhABSgwKCGdyb3VwXzA3EAFKDAoIZ3JvdXBf"
       "MDgQAUoMCghncm91cF8wORAB";
   const std::string base64_seed_signature =
       "MEQCIDD1IVxjzWYncun+9IGzqYjZvqxxujQEayJULTlbTGA/AiAr0oVmEgVUQZBYq5VLOSvy"
       "96JkMYgzTkHPwbv7K/CmgA==";
 
   std::string seed_data;
-  EXPECT_TRUE(base::Base64Decode(base64_seed_data, &seed_data));
+  ASSERT_TRUE(base::Base64Decode(uncompressed_base64_seed_data, &seed_data));
+  VariationsSeed seed;
+  ASSERT_TRUE(seed.ParseFromString(seed_data));
+  std::string base64_seed_data = SerializeSeedBase64(seed);
 
-  VariationsSeedStore seed_store(NULL);
-
-#if defined(OS_IOS) || defined(OS_ANDROID)
-  // Signature verification is not enabled on mobile.
-  if (seed_store.VerifySeedSignature(seed_data, base64_seed_signature) ==
-      VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_ENUM_SIZE) {
-    return;
-  }
-#endif
+  TestingPrefServiceSimple prefs;
+  VariationsSeedStore::RegisterPrefs(prefs.registry());
 
   // The above inputs should be valid.
-  EXPECT_EQ(VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_VALID,
-            seed_store.VerifySeedSignature(seed_data, base64_seed_signature));
+  {
+    prefs.SetString(prefs::kVariationsCompressedSeed, base64_seed_data);
+    prefs.SetString(prefs::kVariationsSeedSignature, base64_seed_signature);
+    SignatureVerifyingVariationsSeedStore seed_store(&prefs);
+
+    base::HistogramTester histogram_tester;
+    VariationsSeed seed;
+    EXPECT_TRUE(seed_store.LoadSeed(&seed));
+    histogram_tester.ExpectUniqueSample(
+        "Variations.LoadSeedSignature",
+        static_cast<base::HistogramBase::Sample>(
+            VerifySignatureResult::VALID_SIGNATURE),
+        1);
+  }
 
   // If there's no signature, the corresponding result should be returned.
-  EXPECT_EQ(VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_MISSING,
-            seed_store.VerifySeedSignature(seed_data, std::string()));
+  {
+    prefs.SetString(prefs::kVariationsCompressedSeed, base64_seed_data);
+    prefs.SetString(prefs::kVariationsSeedSignature, std::string());
+    SignatureVerifyingVariationsSeedStore seed_store(&prefs);
 
-  // Using non-base64 encoded value as signature (e.g. seed data) should fail.
-  EXPECT_EQ(VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_DECODE_FAILED,
-            seed_store.VerifySeedSignature(seed_data, seed_data));
+    base::HistogramTester histogram_tester;
+    VariationsSeed seed;
+    EXPECT_FALSE(seed_store.LoadSeed(&seed));
+    histogram_tester.ExpectUniqueSample(
+        "Variations.LoadSeedSignature",
+        static_cast<base::HistogramBase::Sample>(
+            VerifySignatureResult::MISSING_SIGNATURE),
+        1);
+  }
+
+  // Using non-base64 encoded value as signature should fail.
+  {
+    prefs.SetString(prefs::kVariationsCompressedSeed, base64_seed_data);
+    prefs.SetString(prefs::kVariationsSeedSignature,
+                    "not a base64-encoded string");
+    SignatureVerifyingVariationsSeedStore seed_store(&prefs);
+
+    base::HistogramTester histogram_tester;
+    VariationsSeed seed;
+    EXPECT_FALSE(seed_store.LoadSeed(&seed));
+    histogram_tester.ExpectUniqueSample(
+        "Variations.LoadSeedSignature",
+        static_cast<base::HistogramBase::Sample>(
+            VerifySignatureResult::DECODE_FAILED),
+        1);
+  }
 
   // Using a different signature (e.g. the base64 seed data) should fail.
   // OpenSSL doesn't distinguish signature decode failure from the
   // signature not matching.
-  EXPECT_EQ(VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_INVALID_SEED,
-            seed_store.VerifySeedSignature(seed_data, base64_seed_data));
+  {
+    prefs.SetString(prefs::kVariationsCompressedSeed, base64_seed_data);
+    prefs.SetString(prefs::kVariationsSeedSignature, base64_seed_data);
+    SignatureVerifyingVariationsSeedStore seed_store(&prefs);
+
+    base::HistogramTester histogram_tester;
+    VariationsSeed seed;
+    EXPECT_FALSE(seed_store.LoadSeed(&seed));
+    histogram_tester.ExpectUniqueSample(
+        "Variations.LoadSeedSignature",
+        static_cast<base::HistogramBase::Sample>(
+            VerifySignatureResult::INVALID_SEED),
+        1);
+  }
 
   // Using a different seed should not match the signature.
-  seed_data[0] = 'x';
-  EXPECT_EQ(VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_INVALID_SEED,
-            seed_store.VerifySeedSignature(seed_data, base64_seed_signature));
+  {
+    VariationsSeed wrong_seed;
+    ASSERT_TRUE(wrong_seed.ParseFromString(seed_data));
+    (*wrong_seed.mutable_study(0)->mutable_name())[0] = 'x';
+    std::string base64_wrong_seed_data = SerializeSeedBase64(wrong_seed);
+
+    prefs.SetString(prefs::kVariationsCompressedSeed, base64_wrong_seed_data);
+    prefs.SetString(prefs::kVariationsSeedSignature, base64_seed_signature);
+    SignatureVerifyingVariationsSeedStore seed_store(&prefs);
+
+    base::HistogramTester histogram_tester;
+    VariationsSeed seed;
+    EXPECT_FALSE(seed_store.LoadSeed(&seed));
+    histogram_tester.ExpectUniqueSample(
+        "Variations.LoadSeedSignature",
+        static_cast<base::HistogramBase::Sample>(
+            VerifySignatureResult::INVALID_SEED),
+        1);
+  }
 }
 
 TEST(VariationsSeedStoreTest, ApplyDeltaPatch) {
   // Sample seeds and the server produced delta between them to verify that the
   // client code is able to decode the deltas produced by the server.
   const std::string base64_before_seed_data =
       "CigxN2E4ZGJiOTI4ODI0ZGU3ZDU2MGUyODRlODY1ZDllYzg2NzU1MTE0ElgKDFVNQVN0YWJp"
       "bGl0eRjEyomgBTgBQgtTZXBhcmF0ZUxvZ0oLCgdEZWZhdWx0EABKDwoLU2VwYXJhdGVMb2cQ"
       "ZFIVEgszNC4wLjE4MDEuMCAAIAEgAiADEkQKIFVNQS1Vbmlmb3JtaXR5LVRyaWFsLTEwMC1Q"
       "ZXJjZW50GIDjhcAFOAFCCGdyb3VwXzAxSgwKCGdyb3VwXzAxEAFgARJPCh9VTUEtVW5pZm9y"
@@ skipping 57 matching lines @@
                                      &response_date, &is_gzip_compressed);
   EXPECT_EQ("", seed_data);
   EXPECT_EQ("", seed_signature);
   EXPECT_EQ("", seed_country);
   EXPECT_EQ("", response_date);
   EXPECT_FALSE(is_gzip_compressed);
 }
 #endif  // OS_ANDROID
 
 }  // namespace variations