chromeos: Use base::MessageLoop.

chromeos/dbus/cryptohome_client.cc

 // Copyright (c) 2012 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 "chromeos/dbus/cryptohome_client.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/blocking_method_caller.h"
@@ skipping 795 matching lines @@
   }
 
   // CryptohomeClient override.
   virtual void ResetAsyncCallStatusHandlers() OVERRIDE {
     async_call_status_handler_.Reset();
     async_call_status_data_handler_.Reset();
   }
 
   // CryptohomeClient override.
   virtual void IsMounted(const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual bool Unmount(bool* success) OVERRIDE {
     *success = true;
     return true;
   }
 
   // CryptohomeClient override.
@@ skipping 25 matching lines @@
     return true;
   }
 
   // CryptohomeClient override.
   virtual void GetSanitizedUsername(
       const std::string& username,
       const StringDBusMethodCallback& callback) OVERRIDE {
     // Even for stub implementation we have to return different values
     // so that multi-profiles would work.
     std::string sanitized_username = GetStubSanitizedUsername(username);
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, sanitized_username));
   }
 
   // CryptohomeClient override.
   virtual void AsyncMount(const std::string& username,
                           const std::string& key,
                           int flags,
                           const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, false);
   }
 
   // CryptohomeClient override.
   virtual void AsyncMountGuest(const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, false);
   }
 
   // CryptohomeClient override.
   virtual void TpmIsReady(const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual void TpmIsEnabled(const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual bool CallTpmIsEnabledAndBlock(bool* enabled) OVERRIDE {
     *enabled = true;
     return true;
   }
 
   // CryptohomeClient override.
   virtual void TpmGetPassword(
       const StringDBusMethodCallback& callback) OVERRIDE {
     const char kStubTpmPassword[] = "Stub-TPM-password";
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, kStubTpmPassword));
   }
 
   // CryptohomeClient override.
   virtual void TpmIsOwned(const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual bool CallTpmIsOwnedAndBlock(bool* owned) OVERRIDE {
     *owned = true;
     return true;
   }
 
   // CryptohomeClient override.
   virtual void TpmIsBeingOwned(const BoolDBusMethodCallback& callback)
       OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual bool CallTpmIsBeingOwnedAndBlock(bool* owning) OVERRIDE {
     *owning = true;
     return true;
   }
 
   // CryptohomeClient override.
   virtual void TpmCanAttemptOwnership(
       const VoidDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS));
   }
 
   // CryptohomeClient override.
   virtual void TpmClearStoredPassword(const VoidDBusMethodCallback& callback)
       OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS));
   }
 
   // CryptohomeClient override.
   virtual bool CallTpmClearStoredPasswordAndBlock() OVERRIDE { return true; }
 
   // CryptohomeClient override.
   virtual void Pkcs11IsTpmTokenReady(
       const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual void Pkcs11GetTpmTokenInfo(
       const Pkcs11GetTpmTokenInfoCallback& callback) OVERRIDE {
     const char kStubLabel[] = "Stub TPM Token";
     const char kStubUserPin[] = "012345";
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, kStubLabel,
                               kStubUserPin));
   }
 
   // CryptohomeClient override.
   virtual bool InstallAttributesGet(const std::string& name,
                                     std::vector<uint8>* value,
                                     bool* successful) OVERRIDE {
     if (install_attrs_.find(name) != install_attrs_.end()) {
       *value = install_attrs_[name];
@@ skipping 17 matching lines @@
   // CryptohomeClient override.
   virtual bool InstallAttributesFinalize(bool* successful) OVERRIDE {
     locked_ = true;
     *successful = true;
     return true;
   }
 
   // CryptohomeClient override.
   virtual void InstallAttributesIsReady(const BoolDBusMethodCallback& callback)
       OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual bool InstallAttributesIsInvalid(bool* is_invalid) OVERRIDE {
     *is_invalid = false;
     return true;
   }
 
   // CryptohomeClient override.
   virtual bool InstallAttributesIsFirstInstall(
       bool* is_first_install) OVERRIDE {
     *is_first_install = !locked_;
     return true;
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationIsPrepared(
         const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationIsEnrolled(
         const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
   }
 
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationCreateEnrollRequest(
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
   // CryptohomeClient override.
@@ skipping 17 matching lines @@
       const std::string& key_name,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationDoesKeyExist(
       attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetCertificate(
       attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetPublicKey(
       attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationRegisterKey(
       attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
@@ skipping 17 matching lines @@
       const std::string& key_name,
       const std::string& challenge,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
   virtual void TpmAttestationGetKeyPayload(
       attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
   }
 
   virtual void TpmAttestationSetKeyPayload(
       attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& payload,
       const BoolDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
   }
 
 
  private:
   // Posts tasks which return fake results to the UI thread.
   void ReturnAsyncMethodResult(const AsyncMethodCallback& callback,
                                bool returns_data) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&CryptohomeClientStubImpl::ReturnAsyncMethodResultInternal,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    returns_data));
   }
 
   // This method is used to implement ReturnAsyncMethodResult.
   void ReturnAsyncMethodResultInternal(const AsyncMethodCallback& callback,
                                        bool returns_data) {
     callback.Run(async_call_id_);
     if (!returns_data && !async_call_status_handler_.is_null()) {
-      MessageLoop::current()->PostTask(
+      base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(async_call_status_handler_,
                      async_call_id_,
                      true,
                      cryptohome::MOUNT_ERROR_NONE));
     } else if (returns_data && !async_call_status_data_handler_.is_null()) {
-      MessageLoop::current()->PostTask(
+      base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(async_call_status_data_handler_,
                      async_call_id_,
                      true,
                      std::string()));
     }
     ++async_call_id_;
   }
 
   int async_call_id_;
@@ skipping 25 matching lines @@
   return new CryptohomeClientStubImpl();
 }
 
 // static
 std::string CryptohomeClient::GetStubSanitizedUsername(
     const std::string& username) {
   return username + kUserIdStubHashSuffix;
 }
 
 }  // namespace chromeos