[EasyUnlock] Serialize and store BeaconSeeds along as cryptohome key metadata.

chrome/browser/signin/easy_unlock_service_regular.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 "chrome/browser/signin/easy_unlock_service_regular.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/cryptauth/chrome_cryptauth_service_factory.h"
 #include "chrome/browser/gcm/gcm_profile_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 104 matching lines @@
                           &b64_psk);
 
     dict->SetString("name", device.name);
     dict->SetString("psk", b64_psk);
     dict->SetString("bluetoothAddress", device.bluetooth_address);
     dict->SetString("permitId", "permit://google.com/easyunlock/v1/" +
                                     proximity_auth_client()->GetAccountId());
     dict->SetString("permitRecord.id", b64_public_key);
     dict->SetString("permitRecord.type", "license");
     dict->SetString("permitRecord.data", b64_public_key);
+
+    // TODO(tengs): Retrieve the actual BeaconSeeds from the RemoteDevice.
+    std::vector<cryptauth::BeaconSeed> beacon_seeds;
+    std::unique_ptr<base::ListValue> beacon_seed_list(new base::ListValue());
+    for (const auto& beacon_seed : beacon_seeds) {
+      std::string b64_beacon_seed;
+      base::Base64UrlEncode(beacon_seed.SerializeAsString(),
+                            base::Base64UrlEncodePolicy::INCLUDE_PADDING,
+                            &b64_beacon_seed);
+      beacon_seed_list->AppendString(b64_beacon_seed);
+    }
+
+    std::string serialized_beacon_seeds;
+    JSONStringValueSerializer serializer(&serialized_beacon_seeds);
+    serializer.Serialize(*beacon_seed_list);
+    dict->SetString("serializedBeaconSeeds", serialized_beacon_seeds);
+
     device_list->Append(std::move(dict));
   }
 
   // TODO(tengs): Rename this function after the easy_unlock app is replaced.
   SetRemoteDevices(*device_list);
 #endif
 }
 
 EasyUnlockService::Type EasyUnlockServiceRegular::GetType() const {
   return EasyUnlockService::TYPE_REGULAR;
@@ skipping 100 matching lines @@
   const base::DictionaryValue* pairing_dict =
       profile()->GetPrefs()->GetDictionary(prefs::kEasyUnlockPairing);
   const base::ListValue* devices = NULL;
   if (pairing_dict && pairing_dict->GetList(kKeyDevices, &devices))
     return devices;
   return NULL;
 }
 
 void EasyUnlockServiceRegular::SetRemoteDevices(
     const base::ListValue& devices) {
+  std::string remote_devices_json;
+  JSONStringValueSerializer serializer(&remote_devices_json);
+  serializer.Serialize(devices);
+  PA_LOG(INFO) << "Setting RemoteDevices:\n  " << remote_devices_json;
+
   DictionaryPrefUpdate pairing_update(profile()->GetPrefs(),
                                       prefs::kEasyUnlockPairing);
   if (devices.empty())
     pairing_update->RemoveWithoutPathExpansion(kKeyDevices, NULL);
   else
     pairing_update->SetWithoutPathExpansion(
         kKeyDevices, base::MakeUnique<base::Value>(devices));
 
 #if defined(OS_CHROMEOS)
   // TODO(tengs): Investigate if we can determine if the remote devices were set
@@ skipping 325 matching lines @@
 
 cryptauth::CryptAuthDeviceManager*
 EasyUnlockServiceRegular::GetCryptAuthDeviceManager() {
   cryptauth::CryptAuthDeviceManager* manager =
       ChromeCryptAuthServiceFactory::GetInstance()
           ->GetForBrowserContext(profile())
           ->GetCryptAuthDeviceManager();
   DCHECK(manager);
   return manager;
 }