cryptohome: Move stateless wrapper functions out of CryptohomeLibrary

chrome/browser/chromeos/policy/enterprise_install_attributes.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 "chrome/browser/chromeos/policy/enterprise_install_attributes.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/policy/proto/chromeos/install_attributes.pb.h"
 #include "chromeos/cryptohome/cryptohome_library.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 
 namespace policy {
 
+namespace cryptohome_util = chromeos::cryptohome_util;
+
 namespace {
 
 // Translates DeviceMode constants to strings used in the lockbox.
 std::string GetDeviceModeString(DeviceMode mode) {
   switch (mode) {
     case DEVICE_MODE_CONSUMER:
       return EnterpriseInstallAttributes::kConsumerDeviceMode;
     case DEVICE_MODE_ENTERPRISE:
       return EnterpriseInstallAttributes::kEnterpiseDeviceMode;
     case DEVICE_MODE_RETAIL_KIOSK:
@@ skipping 50 matching lines @@
 const char EnterpriseInstallAttributes::kAttrEnterpriseMode[] =
     "enterprise.mode";
 const char EnterpriseInstallAttributes::kAttrEnterpriseOwned[] =
     "enterprise.owned";
 const char EnterpriseInstallAttributes::kAttrEnterpriseUser[] =
     "enterprise.user";
 const char EnterpriseInstallAttributes::kAttrConsumerKioskEnabled[] =
     "consumer.app_kiosk_enabled";
 
 EnterpriseInstallAttributes::EnterpriseInstallAttributes(
-    chromeos::CryptohomeLibrary* cryptohome,
     chromeos::CryptohomeClient* cryptohome_client)
     : device_locked_(false),
       registration_mode_(DEVICE_MODE_PENDING),
-      cryptohome_(cryptohome),
       cryptohome_client_(cryptohome_client),
       weak_ptr_factory_(this) {}
 
 EnterpriseInstallAttributes::~EnterpriseInstallAttributes() {}
 
 void EnterpriseInstallAttributes::ReadCacheFile(
     const base::FilePath& cache_file) {
   if (device_locked_ || !base::PathExists(cache_file))
     return;
 
@@ skipping 39 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void EnterpriseInstallAttributes::ReadAttributesIfReady(
     const base::Closure& callback,
     chromeos::DBusMethodCallStatus call_status,
     bool result) {
   if (call_status == chromeos::DBUS_METHOD_CALL_SUCCESS && result) {
     registration_mode_ = DEVICE_MODE_NOT_SET;
-    if (!cryptohome_->InstallAttributesIsInvalid() &&
-        !cryptohome_->InstallAttributesIsFirstInstall()) {
+    if (!cryptohome_util::InstallAttributesIsInvalid() &&
+        !cryptohome_util::InstallAttributesIsFirstInstall()) {
       device_locked_ = true;
 
       static const char* kEnterpriseAttributes[] = {
         kAttrEnterpriseDeviceId,
         kAttrEnterpriseDomain,
         kAttrEnterpriseMode,
         kAttrEnterpriseOwned,
         kAttrEnterpriseUser,
         kAttrConsumerKioskEnabled,
       };
       std::map<std::string, std::string> attr_map;
       for (size_t i = 0; i < arraysize(kEnterpriseAttributes); ++i) {
         std::string value;
-        if (cryptohome_->InstallAttributesGet(kEnterpriseAttributes[i], &value))
+        if (cryptohome_util::InstallAttributesGet(kEnterpriseAttributes[i],
+                                                  &value))
           attr_map[kEnterpriseAttributes[i]] = value;
       }
 
       DecodeInstallAttributes(attr_map);
     }
   }
   callback.Run();
 }
 
 void EnterpriseInstallAttributes::LockDevice(
@@ skipping 34 matching lines @@
     const std::string& device_id,
     const LockResultCallback& callback,
     chromeos::DBusMethodCallStatus call_status,
     bool result) {
   if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS || !result) {
     callback.Run(LOCK_NOT_READY);
     return;
   }
 
   // Clearing the TPM password seems to be always a good deal.
-  if (cryptohome_->TpmIsEnabled() &&
-      !cryptohome_->TpmIsBeingOwned() &&
-      cryptohome_->TpmIsOwned()) {
+  if (cryptohome_util::TpmIsEnabled() &&
+      !cryptohome_util::TpmIsBeingOwned() &&
+      cryptohome_util::TpmIsOwned()) {
     cryptohome_client_->CallTpmClearStoredPasswordAndBlock();
   }
 
   // Make sure we really have a working InstallAttrs.
-  if (cryptohome_->InstallAttributesIsInvalid()) {
+  if (cryptohome_util::InstallAttributesIsInvalid()) {
     LOG(ERROR) << "Install attributes invalid.";
     callback.Run(LOCK_BACKEND_ERROR);
     return;
   }
 
-  if (!cryptohome_->InstallAttributesIsFirstInstall()) {
+  if (!cryptohome_util::InstallAttributesIsFirstInstall()) {
     callback.Run(LOCK_WRONG_USER);
     return;
   }
 
   std::string mode = GetDeviceModeString(device_mode);
   std::string registration_user;
   if (!user.empty())
     registration_user = gaia::CanonicalizeEmail(user);
 
   if (device_mode == DEVICE_MODE_CONSUMER_KIOSK) {
     // Set values in the InstallAttrs and lock it.
-    if (!cryptohome_->InstallAttributesSet(kAttrConsumerKioskEnabled, "true")) {
+    if (!cryptohome_util::InstallAttributesSet(kAttrConsumerKioskEnabled,
+                                               "true")) {
       LOG(ERROR) << "Failed writing attributes";
       callback.Run(LOCK_BACKEND_ERROR);
       return;
     }
   } else {
     std::string domain = gaia::ExtractDomainName(registration_user);
     // Set values in the InstallAttrs and lock it.
-    if (!cryptohome_->InstallAttributesSet(kAttrEnterpriseOwned, "true") ||
-        !cryptohome_->InstallAttributesSet(kAttrEnterpriseUser,
-                                           registration_user) ||
-        !cryptohome_->InstallAttributesSet(kAttrEnterpriseDomain, domain) ||
-        !cryptohome_->InstallAttributesSet(kAttrEnterpriseMode, mode) ||
-        !cryptohome_->InstallAttributesSet(kAttrEnterpriseDeviceId,
-                                           device_id)) {
+    if (!cryptohome_util::InstallAttributesSet(kAttrEnterpriseOwned, "true") ||
+        !cryptohome_util::InstallAttributesSet(kAttrEnterpriseUser,
+                                               registration_user) ||
+        !cryptohome_util::InstallAttributesSet(kAttrEnterpriseDomain,
+                                               domain) ||
+        !cryptohome_util::InstallAttributesSet(kAttrEnterpriseMode, mode) ||
+        !cryptohome_util::InstallAttributesSet(kAttrEnterpriseDeviceId,
+                                               device_id)) {
       LOG(ERROR) << "Failed writing attributes";
       callback.Run(LOCK_BACKEND_ERROR);
       return;
     }
   }
 
-  if (!cryptohome_->InstallAttributesFinalize() ||
-      cryptohome_->InstallAttributesIsFirstInstall()) {
+  if (!cryptohome_util::InstallAttributesFinalize() ||
+      cryptohome_util::InstallAttributesIsFirstInstall()) {
     LOG(ERROR) << "Failed locking.";
     callback.Run(LOCK_BACKEND_ERROR);
     return;
   }
 
   ReadImmutableAttributes(
       base::Bind(&EnterpriseInstallAttributes::OnReadImmutableAttributes,
                  weak_ptr_factory_.GetWeakPtr(),
                  registration_user,
                  callback));
@@ skipping 79 matching lines @@
                         &consumer_kiosk_enabled) &&
              consumer_kiosk_enabled == "true") {
     registration_mode_ = DEVICE_MODE_CONSUMER_KIOSK;
   } else if (enterprise_user.empty() && enterprise_owned != "true") {
     // |registration_user_| is empty on consumer devices.
     registration_mode_ = DEVICE_MODE_CONSUMER;
   }
 }
 
 }  // namespace policy