Support delta-compressed variations server responses.

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/json/json_string_value_serializer.h"
@@ skipping 41 matching lines @@
     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_; }
 
   void DoActualFetch() override {
     if (intercepts_fetch_) {
       fetch_attempted_ = true;
       return;
     }
 
     VariationsService::DoActualFetch();
   }
 
  protected:
-  void StoreSeed(const std::string& seed_data,
+  bool StoreSeed(const std::string& seed_data,
                  const std::string& seed_signature,
-                 const base::Time& date_fetched) override {
+                 const std::string& country_code,
+                 const base::Time& date_fetched,
+                 bool is_delta_compressed) override {
     seed_stored_ = true;
+    stored_country_ = country_code;
+    return true;
   }
 
  private:
   bool intercepts_fetch_;
   bool fetch_attempted_;
   bool seed_stored_;
+  std::string stored_country_;
 
   DISALLOW_COPY_AND_ASSIGN(TestVariationsService);
 };
 
 class TestVariationsServiceObserver : public VariationsService::Observer {
  public:
   TestVariationsServiceObserver()
       : best_effort_changes_notified_(0),
         crticial_changes_notified_(0) {
   }
@@ skipping 46 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|.
-void SimulateServerResponse(int response_code, net::TestURLFetcher* fetcher) {
-  ASSERT_TRUE(fetcher);
+scoped_refptr<net::HttpResponseHeaders> SimulateServerResponse(
+    int response_code,
+    net::TestURLFetcher* fetcher) {
+  EXPECT_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);
+  return headers;
 }
 
 // Helper class that abstracts away platform-specific details relating to the
 // pref store used for the "restrict" param policy.
 class TestVariationsPrefsStore {
  public:
   TestVariationsPrefsStore() {
 #if defined(OS_ANDROID)
     // Android uses profile prefs as the PrefService to generate the URL.
     VariationsService::RegisterProfilePrefs(prefs_.registry());
@@ skipping 194 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, SeedDateUpdatedOn304Status) {
+TEST_F(VariationsServiceTest, CountryHeader) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
-  net::TestURLFetcherFactory factory;
-  VariationsService service(
-      new web_resource::TestRequestAllowedNotifier(&prefs), &prefs, NULL);
+  TestVariationsService service(
+      new web_resource::TestRequestAllowedNotifier(&prefs), &prefs);
   service.variations_server_url_ =
       VariationsService::GetVariationsServerURL(&prefs, std::string());
+  service.set_intercepts_fetch(false);
+
+  net::TestURLFetcherFactory factory;
   service.DoActualFetch();
-  EXPECT_TRUE(
-      prefs.FindPreference(prefs::kVariationsSeedDate)->IsDefaultValue());
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
-  SimulateServerResponse(net::HTTP_NOT_MODIFIED, fetcher);
+  scoped_refptr<net::HttpResponseHeaders> headers =
+      SimulateServerResponse(net::HTTP_OK, fetcher);
+  headers->AddHeader("X-Country: test");
+  fetcher->SetResponseString(SerializeSeed(CreateTestSeed()));
+
+  EXPECT_FALSE(service.seed_stored());
   service.OnURLFetchComplete(fetcher);
-  EXPECT_FALSE(
-      prefs.FindPreference(prefs::kVariationsSeedDate)->IsDefaultValue());
+  EXPECT_TRUE(service.seed_stored());
+  EXPECT_EQ("test", service.stored_country());
 }
 
 TEST_F(VariationsServiceTest, Observer) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   VariationsService service(
       new web_resource::TestRequestAllowedNotifier(&prefs), &prefs, NULL);
 
   struct {
     int normal_count;
@@ skipping 128 matching lines @@
         << test.pref_value_before << ", " << test.version << ", "
         << test.latest_country_code;
 
     histogram_tester.ExpectUniqueSample(
         "Variations.LoadPermanentConsistencyCountryResult",
         test.expected_result, 1);
   }
 }
 
 }  // namespace chrome_variations