Restructured PlatformVerificationFlow testing.

chrome/browser/chromeos/attestation/platform_verification_flow.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 "platform_verification_flow.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
@@ skipping 58 matching lines @@
   DefaultDelegate() {}
   virtual ~DefaultDelegate() {}
 
   virtual void ShowConsentPrompt(
       content::WebContents* web_contents,
       const PlatformVerificationFlow::Delegate::ConsentCallback& callback)
       OVERRIDE {
     PlatformVerificationDialog::ShowDialog(web_contents, callback);
   }
 
+  virtual PrefService* GetPrefs(content::WebContents* web_contents) OVERRIDE {
+    return user_prefs::UserPrefs::Get(web_contents->GetBrowserContext());
+  }
+
+  virtual const GURL& GetURL(content::WebContents* web_contents) OVERRIDE {
+    const GURL& url = web_contents->GetLastCommittedURL();
+    if (!url.is_valid())
+      return web_contents->GetVisibleURL();
+    return url;
+  }
+
+  virtual User* GetUser(content::WebContents* web_contents) OVERRIDE {
+    return UserManager::Get()->GetUserByProfile(
+        Profile::FromBrowserContext(web_contents->GetBrowserContext()));
+  }
+
+  virtual HostContentSettingsMap* GetContentSettings(
+      content::WebContents* web_contents) OVERRIDE {
+    return Profile::FromBrowserContext(web_contents->GetBrowserContext())->
+        GetHostContentSettingsMap();
+  }
+
+  virtual bool IsGuestOrIncognito(content::WebContents* web_contents) OVERRIDE {
+    Profile* profile =
+        Profile::FromBrowserContext(web_contents->GetBrowserContext());
+    return (profile->IsOffTheRecord() || profile->IsGuestSession());
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultDelegate);
 };
 
 PlatformVerificationFlow::ChallengeContext::ChallengeContext(
     content::WebContents* web_contents,
     const std::string& service_id,
     const std::string& challenge,
     const ChallengeCallback& callback)
     : web_contents(web_contents),
       service_id(service_id),
       challenge(challenge),
       callback(callback) {}
 
 PlatformVerificationFlow::ChallengeContext::~ChallengeContext() {}
 
 PlatformVerificationFlow::PlatformVerificationFlow()
     : attestation_flow_(NULL),
       async_caller_(cryptohome::AsyncMethodCaller::GetInstance()),
       cryptohome_client_(DBusThreadManager::Get()->GetCryptohomeClient()),
-      user_manager_(UserManager::Get()),
       delegate_(NULL),
-      testing_prefs_(NULL),
-      testing_content_settings_(NULL),
       timeout_delay_(base::TimeDelta::FromSeconds(kTimeoutInSeconds)) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   scoped_ptr<ServerProxy> attestation_ca_client(new AttestationCAClient());
   default_attestation_flow_.reset(new AttestationFlow(
       async_caller_,
       cryptohome_client_,
       attestation_ca_client.Pass()));
   attestation_flow_ = default_attestation_flow_.get();
   default_delegate_.reset(new DefaultDelegate());
   delegate_ = default_delegate_.get();
 }
 
 PlatformVerificationFlow::PlatformVerificationFlow(
     AttestationFlow* attestation_flow,
     cryptohome::AsyncMethodCaller* async_caller,
     CryptohomeClient* cryptohome_client,
-    UserManager* user_manager,
     Delegate* delegate)
     : attestation_flow_(attestation_flow),
       async_caller_(async_caller),
       cryptohome_client_(cryptohome_client),
-      user_manager_(user_manager),
       delegate_(delegate),
-      testing_prefs_(NULL),
-      testing_content_settings_(NULL),
       timeout_delay_(base::TimeDelta::FromSeconds(kTimeoutInSeconds)) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!delegate_) {
+    default_delegate_.reset(new DefaultDelegate());
+    delegate_ = default_delegate_.get();
+  }
 }
 
 PlatformVerificationFlow::~PlatformVerificationFlow() {
 }
 
 void PlatformVerificationFlow::ChallengePlatformKey(
     content::WebContents* web_contents,
     const std::string& service_id,
     const std::string& challenge,
     const ChallengeCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (!GetURL(web_contents).is_valid()) {
+  if (!delegate_->GetURL(web_contents).is_valid()) {
     LOG(WARNING) << "PlatformVerificationFlow: Invalid URL.";
     ReportError(callback, INTERNAL_ERROR);
     return;
   }
   if (!IsAttestationEnabled(web_contents)) {
     ReportError(callback, POLICY_REJECTED);
     return;
   }
   // A platform key must be bound to a user.  They are not allowed in incognito
   // or guest mode.
-  if (IsGuestOrIncognito(web_contents)) {
+  if (delegate_->IsGuestOrIncognito(web_contents)) {
     ReportError(callback, PLATFORM_NOT_VERIFIED);
     return;
   }
   ChallengeContext context(web_contents, service_id, challenge, callback);
   BoolDBusMethodCallback dbus_callback = base::Bind(
       &DBusCallback,
       base::Bind(&PlatformVerificationFlow::CheckConsent, this, context),
       base::Bind(&ReportError, callback, INTERNAL_ERROR));
   cryptohome_client_->TpmAttestationIsEnrolled(dbus_callback);
 }
 
 void PlatformVerificationFlow::CheckConsent(const ChallengeContext& context,
                                             bool attestation_enrolled) {
-  PrefService* pref_service = GetPrefs(context.web_contents);
+  PrefService* pref_service = delegate_->GetPrefs(context.web_contents);
   if (!pref_service) {
     LOG(ERROR) << "Failed to get user prefs.";
     ReportError(context.callback, INTERNAL_ERROR);
     return;
   }
   bool consent_required = (
       // Consent required if attestation has never been enrolled on this device.
       !attestation_enrolled ||
       // Consent required if this is the first use of attestation for content
       // protection on this device.
       !pref_service->GetBoolean(prefs::kRAConsentFirstTime) ||
       // Consent required if consent has never been given for this domain.
-      !GetDomainPref(GetContentSettings(context.web_contents),
-                     GetURL(context.web_contents),
+      !GetDomainPref(delegate_->GetContentSettings(context.web_contents),
+                     delegate_->GetURL(context.web_contents),
                      NULL));
-
   Delegate::ConsentCallback consent_callback = base::Bind(
       &PlatformVerificationFlow::OnConsentResponse,
       this,
       context,
       consent_required);
   if (consent_required)
     delegate_->ShowConsentPrompt(context.web_contents, consent_callback);
   else
     consent_callback.Run(CONSENT_RESPONSE_NONE);
 }
@@ skipping 26 matching lines @@
       ReportError(context.callback, USER_REJECTED);
       return;
     } else if (consent_response == CONSENT_RESPONSE_ALLOW) {
       content::RecordAction(
           content::UserMetricsAction("PlatformVerificationAccepted"));
     }
   }
 
   // At this point all user interaction is complete and we can proceed with the
   // certificate request.
-  chromeos::User* user = GetUser(context.web_contents);
+  chromeos::User* user = delegate_->GetUser(context.web_contents);
   if (!user) {
     ReportError(context.callback, INTERNAL_ERROR);
     LOG(ERROR) << "Profile does not map to a valid user.";
     return;
   }
 
   GetCertificate(context, user->email(), false /* Don't force a new key */);
 }
 
 void PlatformVerificationFlow::GetCertificate(const ChallengeContext& context,
@@ skipping 81 matching lines @@
     LOG(ERROR) << "PlatformVerificationFlow: Failed to parse response data.";
     ReportError(context.callback, INTERNAL_ERROR);
     return;
   }
   context.callback.Run(SUCCESS,
                        signed_data_pb.data(),
                        signed_data_pb.signature(),
                        certificate);
 }
 
-PrefService* PlatformVerificationFlow::GetPrefs(
-    content::WebContents* web_contents) {
-  if (testing_prefs_)
-    return testing_prefs_;
-  return user_prefs::UserPrefs::Get(web_contents->GetBrowserContext());
-}
-
-const GURL& PlatformVerificationFlow::GetURL(
-    content::WebContents* web_contents) {
-  if (!testing_url_.is_empty())
-    return testing_url_;
-  const GURL& url = web_contents->GetLastCommittedURL();
-  if (!url.is_valid())
-    return web_contents->GetVisibleURL();
-  return url;
-}
-
-User* PlatformVerificationFlow::GetUser(content::WebContents* web_contents) {
-  if (!web_contents)
-    return user_manager_->GetActiveUser();
-  return user_manager_->GetUserByProfile(
-      Profile::FromBrowserContext(web_contents->GetBrowserContext()));
-}
-
-HostContentSettingsMap* PlatformVerificationFlow::GetContentSettings(
-    content::WebContents* web_contents) {
-  if (testing_content_settings_)
-    return testing_content_settings_;
-  return Profile::FromBrowserContext(web_contents->GetBrowserContext())->
-      GetHostContentSettingsMap();
-}
-
 bool PlatformVerificationFlow::IsAttestationEnabled(
     content::WebContents* web_contents) {
   // Check the device policy for the feature.
   bool enabled_for_device = false;
   if (!CrosSettings::Get()->GetBoolean(kAttestationForContentProtectionEnabled,
                                        &enabled_for_device)) {
     LOG(ERROR) << "Failed to get device setting.";
     return false;
   }
   if (!enabled_for_device)
     return false;
 
   // Check the user preference for the feature.
-  PrefService* pref_service = GetPrefs(web_contents);
+  PrefService* pref_service = delegate_->GetPrefs(web_contents);
   if (!pref_service) {
     LOG(ERROR) << "Failed to get user prefs.";
     return false;
   }
   if (!pref_service->GetBoolean(prefs::kEnableDRM))
     return false;
 
   // Check the user preference for this domain.
   bool enabled_for_domain = false;
-  bool found = GetDomainPref(GetContentSettings(web_contents),
-                             GetURL(web_contents),
+  bool found = GetDomainPref(delegate_->GetContentSettings(web_contents),
+                             delegate_->GetURL(web_contents),
                              &enabled_for_domain);
   return (!found || enabled_for_domain);
 }
 
 bool PlatformVerificationFlow::UpdateSettings(
     content::WebContents* web_contents,
     ConsentResponse consent_response) {
-  PrefService* pref_service = GetPrefs(web_contents);
+  PrefService* pref_service = delegate_->GetPrefs(web_contents);
   if (!pref_service) {
     LOG(ERROR) << "Failed to get user prefs.";
     return false;
   }
   pref_service->SetBoolean(prefs::kRAConsentFirstTime, true);
-  RecordDomainConsent(GetContentSettings(web_contents),
-                      GetURL(web_contents),
+  RecordDomainConsent(delegate_->GetContentSettings(web_contents),
+                      delegate_->GetURL(web_contents),
                       (consent_response == CONSENT_RESPONSE_ALLOW));
   return true;
 }
 
 bool PlatformVerificationFlow::GetDomainPref(
     HostContentSettingsMap* content_settings,
     const GURL& url,
     bool* pref_value) {
   CHECK(content_settings);
   CHECK(url.is_valid());
@@ skipping 47 matching lines @@
   scoped_refptr<net::X509Certificate> x509(
       net::X509Certificate::CreateFromBytes(certificate.data(),
                                             certificate.length()));
   if (!x509.get() || x509->valid_expiry().is_null()) {
     LOG(WARNING) << "Failed to parse certificate, cannot check expiry.";
     return false;
   }
   return (base::Time::Now() > x509->valid_expiry());
 }
 
-bool PlatformVerificationFlow::IsGuestOrIncognito(
-    content::WebContents* web_contents) {
-  if (!web_contents)
-    return false;
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  return profile->IsOffTheRecord() || profile->IsGuestSession();
-}
-
 }  // namespace attestation
 }  // namespace chromeos