Variations seed is pulled from the Java application on the first launch of Chrome

components/variations/variations_seed_store.h

 // 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.
 
 #ifndef COMPONENTS_VARIATIONS_VARIATIONS_SEED_STORE_H_
 #define COMPONENTS_VARIATIONS_VARIATIONS_SEED_STORE_H_
 
 #include <string>
 
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/time/time.h"
 
 class PrefService;
 class PrefRegistrySimple;
 
 namespace variations {
 class VariationsSeed;
 }
@@ skipping 48 matching lines @@
     return seed_has_country_code_;
   }
 
   // Returns the invalid signature in base64 format, or an empty string if the
   // signature was valid, missing, or if signature verification is disabled.
   std::string GetInvalidSignature() const;
 
   // Registers Local State prefs used by this class.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
+#if defined(OS_ANDROID)
+  void SetVariationsFirstRunSeedCallback(
+      const base::Callback<void(std::string*, std::string*, std::string*)>&

[Bernhard Bauer, 2015/10/30 09:56:08]

Hm... instead of a single callback that returns three values (where in the
actual implementation the three values seems to be pretty much independent), it
might be cleaner to just make an interface with three methods out of this.

[Steven Holte, 2015/11/02 19:05:40]

They are not really independent, since they all come from a single variations
seed fetch.  A previous version of the CL had them independent as calls of 1
function, and I think this version is a bit cleaner.

[Bernhard Bauer, 2015/11/02 19:10:07]

What I meant was that it looks like doing this with independent methods would
not require much duplication of code – it's just three different calls to read
preferences. Alternatively, if these three values are really meant to be used
together, would it make sense to put them into a struct?

[Alexei Svitkine (slow), 2015/11/02 20:39:21]

They are meant to be used together. I think a struct sounds good, but we'd need
to find a place for it given right now the prefs bridge code doesn't depend on
the variations code. I suggest adding a TODO for this but leaving it as-is for
this CL. And then address in a follow-up CL.

(Bernhard, for context we're trying hard to get this in before the M48 branch
since the data compression folks are planning to use this for a rollout they
have targeted for M48. So I'd rather this code start landing sooner and being
tested by the waterfall, etc. Some minor parts like this can be cleaned post the
initial commit. More important things I think it still makes sense to get right
in this first CL, but in my opinion this can wait for a follow-up CL).

+        callback) {
+    get_variations_first_run_seed_ = callback;
+  }
+#endif  // OS_ANDROID
+
  protected:
   // Note: UMA histogram enum - don't re-order or remove entries.
   enum VerifySignatureResult {
     VARIATIONS_SEED_SIGNATURE_MISSING,
     VARIATIONS_SEED_SIGNATURE_DECODE_FAILED,
     VARIATIONS_SEED_SIGNATURE_INVALID_SIGNATURE,
     VARIATIONS_SEED_SIGNATURE_INVALID_SEED,
     VARIATIONS_SEED_SIGNATURE_VALID,
     VARIATIONS_SEED_SIGNATURE_ENUM_SIZE,
   };
 
   // Verifies a variations seed (the serialized proto bytes) with the specified
   // base-64 encoded signature that was received from the server and returns the
   // result. The signature is assumed to be an "ECDSA with SHA-256" signature
   // (see kECDSAWithSHA256AlgorithmID in the .cc file). Returns the result of
   // signature verification or VARIATIONS_SEED_SIGNATURE_ENUM_SIZE if signature
   // verification is not enabled.
   virtual VariationsSeedStore::VerifySignatureResult VerifySeedSignature(
       const std::string& seed_bytes,
       const std::string& base64_seed_signature);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(VariationsSeedStoreTest, VerifySeedSignature);
   FRIEND_TEST_ALL_PREFIXES(VariationsSeedStoreTest, ApplyDeltaPatch);
 
   // Clears all prefs related to variations seed storage.
   void ClearPrefs();
 
+  // Imports the variations seed data from Java side during the first
+  // Chrome for Android run.
+  void ImportFirstRunJavaSeed();
+
   // Reads the variations seed data from prefs; returns true on success.
   bool ReadSeedData(std::string* seed_data);
 
   // Internal version of |StoreSeedData()| that assumes |seed_data| is not delta
   // compressed.
   bool StoreSeedDataNoDelta(
       const std::string& seed_data,
       const std::string& base64_seed_signature,
       const std::string& country_code,
       const base::Time& date_fetched,
@@ skipping 11 matching lines @@
   // Cached serial number from the most recently fetched variations seed.
   std::string variations_serial_number_;
 
   // Whether the most recently fetched variations seed has the country code
   // field set.
   bool seed_has_country_code_;
 
   // Keeps track of an invalid signature.
   std::string invalid_base64_signature_;
 
+  base::Callback<void(std::string*, std::string*, std::string*)>
+    get_variations_first_run_seed_;
+
   DISALLOW_COPY_AND_ASSIGN(VariationsSeedStore);
 };
 
 }  // namespace variations
 
 #endif  // COMPONENTS_VARIATIONS_VARIATIONS_SEED_STORE_H_