Simplify PlatformVerificationFlow::CheckConsent() logic.

chrome/browser/chromeos/attestation/platform_verification_flow_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/attestation/attestation_signed_data.pb.h"
@@ skipping 189 matching lines @@
 
     // Configure the global cros_settings.
     CrosSettings* cros_settings = CrosSettings::Get();
     device_settings_provider_ =
         cros_settings->GetProvider(kAttestationForContentProtectionEnabled);
     cros_settings->RemoveSettingsProvider(device_settings_provider_);
     cros_settings->AddSettingsProvider(&stub_settings_provider_);
     cros_settings->SetBoolean(kAttestationForContentProtectionEnabled, true);
 
     // Start with the first-time setting set since most tests want this.
-    fake_delegate_.pref_service().SetUserPref(prefs::kRAConsentFirstTime,
+    fake_delegate_.pref_service().SetUserPref(prefs::kRAConsentGranted,
                                               new base::FundamentalValue(true));
-
   }
 
   void TearDown() {
     // Restore the real DeviceSettingsProvider.
     CrosSettings* cros_settings = CrosSettings::Get();
     cros_settings->RemoveSettingsProvider(&stub_settings_provider_);
     cros_settings->AddSettingsProvider(device_settings_provider_);
     fake_delegate_.TearDown();
   }
 
@@ skipping 14 matching lines @@
                                     std::string(kTestID);
     EXPECT_CALL(mock_async_caller_,
                 TpmAttestationSignSimpleChallenge(KEY_USER, kTestEmail,
                                                   expected_key_name,
                                                   kTestChallenge, _))
         .WillRepeatedly(WithArgs<4>(Invoke(
             this, &PlatformVerificationFlowTest::FakeSignChallenge)));
   }
 
   void SetUserConsent(const GURL& url, bool allow) {
-    verifier_->RecordDomainConsent(fake_delegate_.GetContentSettings(NULL),
-                                   url,
+    verifier_->RecordOriginConsent(fake_delegate_.GetContentSettings(NULL), url,
                                    allow);
   }
 
   void FakeGetCertificate(
       const AttestationFlow::CertificateCallback& callback) {
     std::string certificate =
         (fake_certificate_index_ < fake_certificate_list_.size()) ?
             fake_certificate_list_[fake_certificate_index_] : kTestCertificate;
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback,
@@ skipping 66 matching lines @@
   ExpectAttestationFlow();
   verifier_->ChallengePlatformKey(NULL, kTestID, kTestChallenge, callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(PlatformVerificationFlow::SUCCESS, result_);
   EXPECT_EQ(kTestSignedData, challenge_salt_);
   EXPECT_EQ(kTestSignature, challenge_signature_);
   EXPECT_EQ(kTestCertificate, certificate_);
   EXPECT_EQ(0, fake_delegate_.num_consent_calls());
 }
 
-TEST_F(PlatformVerificationFlowTest, SuccessWithAttestationConsent) {
+TEST_F(PlatformVerificationFlowTest, SuccessWithConsent) {
   SetUserConsent(GURL(kTestURL), true);
-  fake_cryptohome_client_.set_attestation_enrolled(false);
-  ExpectAttestationFlow();
-  verifier_->ChallengePlatformKey(NULL, kTestID, kTestChallenge, callback_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(PlatformVerificationFlow::SUCCESS, result_);
-  EXPECT_EQ(kTestSignedData, challenge_salt_);
-  EXPECT_EQ(kTestSignature, challenge_signature_);
-  EXPECT_EQ(kTestCertificate, certificate_);
-  EXPECT_EQ(1, fake_delegate_.num_consent_calls());
-}
-
-TEST_F(PlatformVerificationFlowTest, SuccessWithFirstTimeConsent) {
-  SetUserConsent(GURL(kTestURL), true);
-  fake_delegate_.pref_service().SetUserPref(prefs::kRAConsentFirstTime,
+  fake_delegate_.pref_service().SetUserPref(prefs::kRAConsentGranted,
                                             new base::FundamentalValue(false));
   ExpectAttestationFlow();
   verifier_->ChallengePlatformKey(NULL, kTestID, kTestChallenge, callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(PlatformVerificationFlow::SUCCESS, result_);
   EXPECT_EQ(kTestSignedData, challenge_salt_);
   EXPECT_EQ(kTestSignature, challenge_signature_);
   EXPECT_EQ(kTestCertificate, certificate_);
   EXPECT_EQ(1, fake_delegate_.num_consent_calls());
 }
@@ skipping 120 matching lines @@
   fake_delegate_.set_response(PlatformVerificationFlow::CONSENT_RESPONSE_DENY);
   fake_cryptohome_client_.set_attestation_enrolled(false);
   fake_cryptohome_client_.set_attestation_prepared(false);
   verifier_->ChallengePlatformKey(NULL, kTestID, kTestChallenge, callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(PlatformVerificationFlow::PLATFORM_NOT_VERIFIED, result_);
 }
 
 }  // namespace attestation
 }  // namespace chromeos