chrome: Use base::MessageLoop. (Part 3)

chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.cc

 // Copyright (c) 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 "chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/callback.h"
@@ skipping 52 matching lines @@
     case chromeos::CrosSettingsProvider::TEMPORARILY_UNTRUSTED:
       // Do nothing. This function will be called again when the values are
       // ready.
       return;
     case chromeos::CrosSettingsProvider::PERMANENTLY_UNTRUSTED:
       // If the value cannot be trusted, we assume that the device attestation
       // is false to be on the safe side.
       break;
   }
 
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, value));
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback, value));
 }
 
 bool EPKPChallengeKeyBase::IsEnterpriseDevice() const {
   return install_attributes_->IsEnterpriseDevice();
 }
 
 std::string EPKPChallengeKeyBase::GetEnterpriseDomain() const {
   return install_attributes_->GetDomain();
 }
 
@@ skipping 146 matching lines @@
     const std::string& domain,
     bool enabled) {
   if (!enabled) {
     SetError("Remote attestation is not enabled for your device.");
     SendResponse(false);
     return;
   }
 
   // If remote attestation is enabled at the device level, we don't need to
   // ask for user consent.
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&EPKPChallengeUserKey::UserConsentCallback, this,
-                 challenge, register_key, domain, true));
+      base::Bind(&EPKPChallengeUserKey::UserConsentCallback,

[brettw, 2013/04/28 04:26:27]

Old wrapping was fine.

+                 this,
+                 challenge,
+                 register_key,
+                 domain,
+                 true));
 }
 
 void EPKPChallengeUserKey::UserConsentCallback(const std::string& challenge,
                                                bool register_key,
                                                const std::string& domain,
                                                bool action) {
   if (!action) {
       SetError("User rejects the action.");
       SendResponse(false);
       return;
@@ skipping 20 matching lines @@
     SendResponse(false);
     return;
   }
 
   if (register_key) {
     async_caller_->TpmAttestationRegisterKey(
         chromeos::CryptohomeClient::USER_KEY,
         kKeyName,
         base::Bind(&EPKPChallengeUserKey::RegisterKeyCallback, this, response));
   } else {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&EPKPChallengeUserKey::RegisterKeyCallback, this,
-                   response, true, cryptohome::MOUNT_ERROR_NONE));
+        base::Bind(&EPKPChallengeUserKey::RegisterKeyCallback,
+                   this,

[brettw, 2013/04/28 04:26:27]

Ditto

+                   response,
+                   true,
+                   cryptohome::MOUNT_ERROR_NONE));
   }
 }
 
 void EPKPChallengeUserKey::RegisterKeyCallback(
     const std::string& response,
     bool success,
     cryptohome::MountError return_code) {
   if (!success || return_code != cryptohome::MOUNT_ERROR_NONE) {
     SetError("Key registration failed.");
     SendResponse(false);
     return;
   }
 
   std::string encoded_response;
   if (!base::Base64Encode(response, &encoded_response)) {
     SetError("Response cannot be encoded in base64.");
     SendResponse(false);
     return;
   }
 
   results_ = api_epkp::ChallengeUserKey::Results::Create(encoded_response);
   SendResponse(true);
 }
 
 void EPKPChallengeUserKey::AskForUserConsent(
     const base::Callback<void(bool)>& callback) {
   // TODO(davidyu): right now we just simply reject the request before we have
   // a way to ask for user consent.
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, false));
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback, false));
 }
 
 bool EPKPChallengeUserKey::IsExtensionWhitelisted() const {
   const base::ListValue* list =
       profile()->GetPrefs()->GetList(prefs::kAttestationExtensionWhitelist);
   StringValue value(extension_->id());
   return list->Find(value) != list->end();
 }
 
 bool EPKPChallengeUserKey::IsRemoteAttestationEnabledForUser() const {
   return profile()->GetPrefs()->GetBoolean(prefs::kAttestationEnabled);
 }
 
 std::string EPKPChallengeUserKey::GetUserDomain() const {
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile());
   if (!signin_manager)
     return std::string();
 
   return gaia::ExtractDomainName(
       gaia::CanonicalizeEmail(signin_manager->GetAuthenticatedUsername()));
 }
 
 }  // namespace extensions