tree 2016b3642351996e9c5c00ca8c6831afb13a57eb
parent ce814837221c4a4d385fd92094b7673bf4601c9f
author Kazuhiro Inaba <kinaba@chromium.org> 1489028438 +0900
committer chrome-bot <chrome-bot@chromium.org> 1489398853 -0700

cryptohome: Add a new flag and an error code for forcing new encryption.

New encryption scheme is required for running ARC for Android N,
so we want to force it, and in case of an error we navigate the user
to migration UI. Some other cases (including when the user chose
"do it later"), we are not forcing it. In addition, if for any reason
the migration step is aborted in the middle and the user tried to
re-login, we cannot let "do it later" and do need to force migration.
An additional error code for this state is also necessary.

This CL adds a flag and an error code for that purpose.
Actual code using them will follow later.

BUG=chromium:699436
TEST=manually checked log-in to new/existing accounts.

Change-Id: Ibf5e40815fb50f74badfc95808c9c401a0b35a05
Reviewed-on: https://chromium-review.googlesource.com/452097
Commit-Ready: Kazuhiro Inaba <kinaba@chromium.org>
Tested-by: Kazuhiro Inaba <kinaba@chromium.org>
Reviewed-by: Dan Erat <derat@chromium.org>
Reviewed-by: Ryo Hashimoto <hashimoto@chromium.org>
