chromeos: Avoid cryptohome D-Bus log spam at boot.

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 <stddef.h>
 
 #include <utility>
 
@@ skipping 61 matching lines @@
       consistency_check_running_(false),
       device_lock_running_(false),
       registration_mode_(DEVICE_MODE_PENDING),
       cryptohome_client_(cryptohome_client),
       weak_ptr_factory_(this) {
 }
 
 EnterpriseInstallAttributes::~EnterpriseInstallAttributes() {}
 
 void EnterpriseInstallAttributes::Init(const base::FilePath& cache_file) {
-  DCHECK_EQ(false, device_locked_);
+  DCHECK(!device_locked_);
 
-  // The actual check happens asynchronously, thus it is ok to trigger it before
-  // Init() has completed.
-  TriggerConsistencyCheck(kDbusRetryCount * kDbusRetryIntervalInSeconds);
+  // Mark the consistency check as running to ensure that LockDevice() is
+  // blocked, but wait for the cryptohome service to be available before
+  // actually calling TriggerConsistencyCheck().
+  consistency_check_running_ = true;
+  cryptohome_client_->WaitForServiceToBeAvailable(base::Bind(
+      &EnterpriseInstallAttributes::OnCryptohomeServiceInitiallyAvailable,
+      weak_ptr_factory_.GetWeakPtr()));
 
   if (!base::PathExists(cache_file))
     return;
 
   device_locked_ = true;
 
   char buf[16384];
   int len = base::ReadFile(cache_file, buf, sizeof(buf));
   if (len == -1 || len >= static_cast<int>(sizeof(buf))) {
     PLOG(ERROR) << "Failed to read " << cache_file.value();
     return;
   }
 
   cryptohome::SerializedInstallAttributes install_attrs_proto;
   if (!install_attrs_proto.ParseFromArray(buf, len)) {
-    LOG(ERROR) << "Failed to parse install attributes cache";
+    LOG(ERROR) << "Failed to parse install attributes cache.";
     return;
   }
 
   google::protobuf::RepeatedPtrField<
       const cryptohome::SerializedInstallAttributes::Attribute>::iterator entry;
   std::map<std::string, std::string> attr_map;
   for (entry = install_attrs_proto.attributes().begin();
        entry != install_attrs_proto.attributes().end();
        ++entry) {
     // The protobuf values unfortunately contain terminating null characters, so
@@ skipping 236 matching lines @@
     return std::string();
 
   return registration_device_id_;
 }
 
 DeviceMode EnterpriseInstallAttributes::GetMode() {
   return registration_mode_;
 }
 
 void EnterpriseInstallAttributes::TriggerConsistencyCheck(int dbus_retries) {
-  consistency_check_running_ = true;
   cryptohome_client_->TpmIsOwned(
       base::Bind(&EnterpriseInstallAttributes::OnTpmOwnerCheckCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  dbus_retries));
 }
 
 void EnterpriseInstallAttributes::OnTpmOwnerCheckCompleted(
     int dbus_retries_remaining,
     chromeos::DBusMethodCallStatus call_status,
     bool result) {
@@ skipping 41 matching lines @@
     "enterprise.domain";
 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";
 
+void EnterpriseInstallAttributes::OnCryptohomeServiceInitiallyAvailable(
+    bool service_is_ready) {
+  if (!service_is_ready)
+    LOG(ERROR) << "Failed waiting for cryptohome D-Bus service availability.";
+
+  // Start the consistency check even if we failed to wait for availability;
+  // hopefully the service will become available eventually.
+  TriggerConsistencyCheck(kDbusRetryCount);
+}
+
 std::string EnterpriseInstallAttributes::GetDeviceModeString(DeviceMode mode) {
   switch (mode) {
     case DEVICE_MODE_CONSUMER:
       return EnterpriseInstallAttributes::kConsumerDeviceMode;
     case DEVICE_MODE_ENTERPRISE:
       return EnterpriseInstallAttributes::kEnterpriseDeviceMode;
     case DEVICE_MODE_LEGACY_RETAIL_MODE:
       return EnterpriseInstallAttributes::kLegacyRetailDeviceMode;
     case DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH:
       return EnterpriseInstallAttributes::kConsumerKioskDeviceMode;
@@ skipping 60 matching lines @@
 }
 
 std::string EnterpriseInstallAttributes::GetRegistrationUser() const {
   if (!device_locked_)
     return std::string();
 
   return registration_user_;
 }
 
 }  // namespace policy