tree 99273067d879c6216d236e2a742b08f9942c3dd3
parent 530ae37a2300e6b4706f5442eb24a62c26f278ce
author Prabhu Kaliamoorthi <kaliamoorthi@chromium.org> 1396266910 +0200
committer chrome-internal-fetch <chrome-internal-fetch@google.com> 1397214085 +0000

Removes the need for additional reboot in Lucas

This CL is a fix for the Issue 273264. 

An enumeration of the state table is provided below.

TPM     OK      IA     Behaviour
Clear   Exists  Exists  Not possible, since OK is in statefull partition which cannot be accessed when TPM is cleared.
Clear   !Exists Exists  Reenrollment scenario -> serial key created
Clear   !Exists !Exists Enrollment scenario   -> serial key created
Clear   Exists  !Exists Not possible, since OK is in statefull partition which cannot be accessed when TPM is cleared.
!Clear  Exists  Exists  Regular use scenario -> serial key not created
!Clear  !Exists Exists  Reenrollment scenario -> serial key created
!Clear  Exists  !Exists Not Possible, OK only gets created after we take TPM ownership, which creates IA
!Clear  !Exists !Exists Reenrollment scenario -> serial key created


BUG=chromium:273264
TEST=Verified the change on Lucas

Change-Id: I7e59adbf9b50971caba527958f5d59cb64df8cd9
Reviewed-on: https://chromium-review.googlesource.com/192300
Tested-by: Prabhu Kaliamoorthi <kaliamoorthi@chromium.org>
Reviewed-by: Mattias Nissler <mnissler@chromium.org>
Tested-by: Prabhu Kaliamoorthi <kaliamoorthi@google.com>
Commit-Queue: Mattias Nissler <mnissler@chromium.org>
