Added a timeout for platform verification key generation.

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/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
@@ skipping 112 matching lines @@
         ui_thread_(content::BrowserThread::UI, &message_loop_),
         certificate_success_(true),
         sign_challenge_success_(true),
         result_(PlatformVerificationFlow::INTERNAL_ERROR) {}
 
   void SetUp() {
     // Configure a user for the mock user manager.
     mock_user_manager_.SetActiveUser(kTestEmail);
 
     // Create a verifier for tests to call.
-    verifier_.reset(new PlatformVerificationFlow(&mock_attestation_flow_,
-                                                 &mock_async_caller_,
-                                                 &fake_cryptohome_client_,
-                                                 &mock_user_manager_,
-                                                 &fake_delegate_));
+    verifier_ = new PlatformVerificationFlow(&mock_attestation_flow_,
+                                             &mock_async_caller_,
+                                             &fake_cryptohome_client_,
+                                             &mock_user_manager_,
+                                             &fake_delegate_);
 
     // Create callbacks for tests to use with verifier_.
     callback_ = base::Bind(&PlatformVerificationFlowTest::FakeChallengeCallback,
                            base::Unretained(this));
 
     // Configure the test pref service.
     pref_service_.registry()->RegisterBooleanPref(prefs::kEnableDRM, true);
     pref_service_.registry()->RegisterBooleanPref(prefs::kRAConsentFirstTime,
                                                   true);
     pref_service_.registry()->RegisterBooleanPref(prefs::kRAConsentAlways,
                                                   false);
     pref_service_.registry()->RegisterDictionaryPref(prefs::kRAConsentDomains);
     verifier_->set_testing_prefs(&pref_service_);
 
     // 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);
 
     // Configure a test URL to shortcut the dependency on WebContents.
     verifier_->set_testing_url(GURL(kTestURL));
   }
 
   void TearDown() {
-    verifier_.reset();
     // Restore the real DeviceSettingsProvider.
     CrosSettings* cros_settings = CrosSettings::Get();
     cros_settings->RemoveSettingsProvider(&stub_settings_provider_);
     cros_settings->AddSettingsProvider(device_settings_provider_);
   }
 
   void ExpectAttestationFlow() {
     // When consent is not given or the feature is disabled, it is important
     // that there are no calls to the attestation service.  Thus, a test must
     // explicitly expect these calls or the mocks will fail the test.
@@ skipping 58 matching lines @@
   StrictMock<MockAttestationFlow> mock_attestation_flow_;
   cryptohome::MockAsyncMethodCaller mock_async_caller_;
   CustomFakeCryptohomeClient fake_cryptohome_client_;
   MockUserManager mock_user_manager_;
   FakeDelegate fake_delegate_;
   TestingPrefServiceSimple pref_service_;
   CrosSettingsProvider* device_settings_provider_;
   StubCrosSettingsProvider stub_settings_provider_;
   ScopedTestDeviceSettingsService test_device_settings_service_;
   ScopedTestCrosSettings test_cros_settings_;
-  scoped_ptr<PlatformVerificationFlow> verifier_;
+  scoped_refptr<PlatformVerificationFlow> verifier_;
 
   // Controls result of FakeGetCertificate.
   bool certificate_success_;
 
   // Controls result of FakeSignChallenge.
   bool sign_challenge_success_;
 
   // Callback functions and data.
   PlatformVerificationFlow::ChallengeCallback callback_;
   PlatformVerificationFlow::Result result_;
@@ skipping 116 matching lines @@
 
 TEST_F(PlatformVerificationFlowTest, ConsentNoResponse) {
   fake_delegate_.set_response(PlatformVerificationFlow::CONSENT_RESPONSE_NONE);
   pref_service_.SetUserPref(prefs::kRAConsentAlways,
                             new base::FundamentalValue(true));
   verifier_->ChallengePlatformKey(NULL, kTestID, kTestChallenge, callback_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(PlatformVerificationFlow::USER_REJECTED, result_);
 }
 
+TEST_F(PlatformVerificationFlowTest, Timeout) {
+  verifier_->set_timeout_delay(0);
+  ExpectAttestationFlow();
+  verifier_->ChallengePlatformKey(NULL, kTestID, kTestChallenge, callback_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(PlatformVerificationFlow::TIMEOUT, result_);
+}
+
 }  // namespace attestation
 }  // namespace chromeos