[Cleanup] Remove the obsolete variations_seed pref.

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 <stdint.h>
 
 #include "base/base64.h"
 #include "base/macros.h"
@@ skipping 289 matching lines @@
                          server_date_fetched.ToInternalValue());
 }
 
 std::string VariationsSeedStore::GetInvalidSignature() const {
   return invalid_base64_signature_;
 }
 
 // static
 void VariationsSeedStore::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kVariationsCompressedSeed, std::string());
-  registry->RegisterStringPref(prefs::kVariationsSeed, std::string());
   registry->RegisterInt64Pref(prefs::kVariationsSeedDate,
                               base::Time().ToInternalValue());
   registry->RegisterStringPref(prefs::kVariationsSeedSignature, std::string());
   registry->RegisterStringPref(prefs::kVariationsCountry, std::string());
 }
 
 VariationsSeedStore::VerifySignatureResult
 VariationsSeedStore::VerifySeedSignature(
     const std::string& seed_bytes,
     const std::string& base64_seed_signature) {
@@ skipping 17 matching lines @@
 
   verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(seed_bytes.data()),
                         seed_bytes.size());
   if (verifier.VerifyFinal())
     return VARIATIONS_SEED_SIGNATURE_VALID;
   return VARIATIONS_SEED_SIGNATURE_INVALID_SEED;
 }
 
 void VariationsSeedStore::ClearPrefs() {
   local_state_->ClearPref(prefs::kVariationsCompressedSeed);
-  local_state_->ClearPref(prefs::kVariationsSeed);
   local_state_->ClearPref(prefs::kVariationsSeedDate);
   local_state_->ClearPref(prefs::kVariationsSeedSignature);
 }
 
 #if defined(OS_ANDROID)
 void VariationsSeedStore::ImportFirstRunJavaSeed() {
   DVLOG(1) << "Importing first run seed from Java preferences.";
 
   std::string seed_data;
   std::string seed_signature;
@@ skipping 21 matching lines @@
     LOG(WARNING) << "First run variations seed is invalid.";
     return;
   }
   RecordFirstRunResult(FIRST_RUN_SEED_IMPORT_SUCCESS);
 }
 #endif  // OS_ANDROID
 
 bool VariationsSeedStore::ReadSeedData(std::string* seed_data) {
   std::string base64_seed_data =
       local_state_->GetString(prefs::kVariationsCompressedSeed);
-  const bool is_compressed = !base64_seed_data.empty();
-  // If there's no compressed seed, fall back to the uncompressed one.
-  if (!is_compressed)
-    base64_seed_data = local_state_->GetString(prefs::kVariationsSeed);
-
   if (base64_seed_data.empty()) {
     RecordVariationSeedEmptyHistogram(VARIATIONS_SEED_EMPTY);
     return false;
   }
 
   // If the decode process fails, assume the pref value is corrupt and clear it.
   std::string decoded_data;
   if (!base::Base64Decode(base64_seed_data, &decoded_data)) {
     ClearPrefs();
     RecordVariationSeedEmptyHistogram(VARIATIONS_SEED_CORRUPT_BASE64);
     return false;
   }
 
-  if (!is_compressed) {
-    seed_data->swap(decoded_data);
-  } else if (!compression::GzipUncompress(decoded_data, seed_data)) {
+  if (!compression::GzipUncompress(decoded_data, seed_data)) {
     ClearPrefs();
     RecordVariationSeedEmptyHistogram(VARIATIONS_SEED_CORRUPT_GZIP);
     return false;
   }
 
   return true;
 }
 
 bool VariationsSeedStore::StoreSeedDataNoDelta(
     const std::string& seed_data,
@@ skipping 27 matching lines @@
   // Compress the seed before base64-encoding and storing.
   std::string compressed_seed_data;
   if (!compression::GzipCompress(seed_data, &compressed_seed_data)) {
     RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_GZIP);
     return false;
   }
 
   std::string base64_seed_data;
   base::Base64Encode(compressed_seed_data, &base64_seed_data);
 
-  // TODO(asvitkine): This pref is no longer being used. Remove it completely
-  // in M45+.
-  local_state_->ClearPref(prefs::kVariationsSeed);

[gab, 2017/06/06 14:45:03]

Since this pref was passed through master_prefs and manually copied in Local
State I'd expect it to also be found in Preferences for the Default profile as
all master_preferences are copied to Preferences on first run (or am I not
seeing code that was stripping it from master_prefs before that copy?)

[Ilya Sherman, 2017/06/06 20:22:16]

Hmm, that sounds like a bug if this and the other related prefs aren't being
stripped -- the prefs should never be read from anywhere other than Local State.
 I'm not sure how to test with master_prefs -- is there documentation for it
someswhere?

[Ilya Sherman, 2017/06/06 21:54:37]

Okay, found the docs [1] and then updated them for Mac based on the code [2]. 
You're right, all of the variations_* prefs are being copied into the Default
profile.  I filed https://crbug.com/730204

[1]
https://sites.google.com/a/chromium.org/dev/administrators/configuring-other-...
[2]
https://cs.chromium.org/chromium/src/chrome/browser/mac/master_prefs.mm?q=chr...

-
 #if defined(OS_ANDROID)
   // If currently we do not have any stored pref then we mark seed storing as
   // successful on the Java side of Chrome for Android to avoid repeated seed
   // fetches and clear preferences on the Java side.
   if (local_state_->GetString(prefs::kVariationsCompressedSeed).empty()) {
     android::MarkVariationsSeedAsStored();
     android::ClearJavaFirstRunPrefs();
   }
 #endif
 
@@ skipping 64 matching lines @@
   }
   return true;
 }
 
 void VariationsSeedStore::ReportUnsupportedSeedFormatError() {
   RecordSeedStoreHistogram(
       VARIATIONS_SEED_STORE_FAILED_UNSUPPORTED_SEED_FORMAT);
 }
 
 }  // namespace variations