Enforce variations signature verification.

chrome/browser/metrics/variations/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 "chrome/browser/metrics/variations/variations_service.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/prefs/testing_pref_service.h"
@@ skipping 22 matching lines @@
 namespace chrome_variations {
 
 namespace {
 
 // A test class used to validate expected functionality in VariationsService.
 class TestVariationsService : public VariationsService {
  public:
   TestVariationsService(TestRequestAllowedNotifier* test_notifier,
                         PrefService* local_state)
       : VariationsService(test_notifier, local_state),
-        fetch_attempted_(false) {
+        intercepts_fetch_(true),
+        fetch_attempted_(false),
+        seed_stored_(false) {
     // Set this so StartRepeatedVariationsSeedFetch can be called in tests.
     SetCreateTrialsFromSeedCalledForTesting(true);
   }
 
   virtual ~TestVariationsService() {
   }
 
+  void set_intercepts_fetch(bool value) {
+    intercepts_fetch_ = value;
+  }
+
   bool fetch_attempted() const { return fetch_attempted_; }
 
+  bool seed_stored() const { return seed_stored_; }
+
+  virtual void DoActualFetch() OVERRIDE {
+    if (intercepts_fetch_) {
+      fetch_attempted_ = true;
+      return;
+    }
+
+    VariationsService::DoActualFetch();
+  }
+
  protected:
-  virtual void DoActualFetch() OVERRIDE {
-    fetch_attempted_ = true;
+  virtual void StoreSeed(const std::string& seed_data,
+                         const std::string& seed_signature,
+                         const base::Time& date_fetched) OVERRIDE {
+    seed_stored_ = true;
   }
 
  private:
+  bool intercepts_fetch_;
   bool fetch_attempted_;
+  bool seed_stored_;
 
   DISALLOW_COPY_AND_ASSIGN(TestVariationsService);
 };
 
 // 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");
   Study_Experiment* experiment = study->add_experiment();
   experiment->set_name("abc");
   experiment->set_probability_weight(100);
   seed.set_serial_number("123");
   return seed;
 }
 
 // Serializes |seed| to protobuf binary format.
 std::string SerializeSeed(const VariationsSeed& seed) {
   std::string serialized_seed;
   seed.SerializeToString(&serialized_seed);
   return serialized_seed;
 }
 
-// Serializes |seed| to base64-encoded protobuf binary format.
-std::string SerializeSeedBase64(const VariationsSeed& seed, std::string* hash) {
-  std::string serialized_seed = SerializeSeed(seed);
-  if (hash != NULL) {
-    std::string sha1 = base::SHA1HashString(serialized_seed);
-    *hash = base::HexEncode(sha1.data(), sha1.size());
-  }
-  std::string base64_serialized_seed;
-  base::Base64Encode(serialized_seed, &base64_serialized_seed);
-  return base64_serialized_seed;
-}
-
 // Simulates a variations service response by setting a date header and the
 // specified HTTP |response_code| on |fetcher|.
 void SimulateServerResponse(int response_code, net::TestURLFetcher* fetcher) {
   ASSERT_TRUE(fetcher);
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders("date:Wed, 13 Feb 2013 00:25:24 GMT\0\0"));
   fetcher->set_response_headers(headers);
   fetcher->set_response_code(response_code);
 }
 
@@ skipping 141 matching lines @@
   EXPECT_TRUE(test_service.fetch_attempted());
 }
 
 TEST_F(VariationsServiceTest, SeedStoredWhenOKStatus) {
   base::MessageLoop message_loop;
   content::TestBrowserThread io_thread(content::BrowserThread::IO,
                                        &message_loop);
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
-  VariationsService variations_service(new TestRequestAllowedNotifier, &prefs);
+  TestVariationsService service(new TestRequestAllowedNotifier, &prefs);
+  service.set_intercepts_fetch(false);
 
   net::TestURLFetcherFactory factory;
-  variations_service.DoActualFetch();
+  service.DoActualFetch();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   SimulateServerResponse(net::HTTP_OK, fetcher);
-  const VariationsSeed seed = CreateTestSeed();
-  fetcher->SetResponseString(SerializeSeed(seed));
+  fetcher->SetResponseString(SerializeSeed(CreateTestSeed()));
 
-  EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
-  variations_service.OnURLFetchComplete(fetcher);
-  EXPECT_FALSE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
-  const std::string expected_base64 = SerializeSeedBase64(seed, NULL);
-  EXPECT_EQ(expected_base64, prefs.GetString(prefs::kVariationsSeed));
+  EXPECT_FALSE(service.seed_stored());
+  service.OnURLFetchComplete(fetcher);
+  EXPECT_TRUE(service.seed_stored());
 }
 
 TEST_F(VariationsServiceTest, SeedNotStoredWhenNonOKStatus) {
   const int non_ok_status_codes[] = {
     net::HTTP_NO_CONTENT,
     net::HTTP_NOT_MODIFIED,
     net::HTTP_NOT_FOUND,
     net::HTTP_INTERNAL_SERVER_ERROR,
     net::HTTP_SERVICE_UNAVAILABLE,
   };
@@ skipping 32 matching lines @@
       prefs.FindPreference(prefs::kVariationsSeedDate)->IsDefaultValue());
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   SimulateServerResponse(net::HTTP_NOT_MODIFIED, fetcher);
   variations_service.OnURLFetchComplete(fetcher);
   EXPECT_FALSE(
       prefs.FindPreference(prefs::kVariationsSeedDate)->IsDefaultValue());
 }
 
 }  // namespace chrome_variations