Refactor: Inject StatisticsProvider as a dependency of DeviceCloudPolicyInitializer.

chrome/browser/chromeos/policy/device_cloud_policy_initializer.cc

 // Copyright 2014 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/device_cloud_policy_initializer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 21 matching lines @@
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/device_management_service.h"
 #include "components/prefs/pref_service.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace policy {
 
-namespace {
-
-// Gets a machine flag from StatisticsProvider, returning the given
-// |default_value| if not present.
-bool GetMachineFlag(const std::string& key, bool default_value) {
-  bool value = default_value;
-  chromeos::system::StatisticsProvider* provider =
-      chromeos::system::StatisticsProvider::GetInstance();
-  if (!provider->GetMachineFlag(key, &value))
-    return default_value;
-
-  return value;
-}
-
-}  // namespace
-
 DeviceCloudPolicyInitializer::DeviceCloudPolicyInitializer(
     PrefService* local_state,
     DeviceManagementService* enterprise_service,
     const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
     chromeos::InstallAttributes* install_attributes,
     ServerBackedStateKeysBroker* state_keys_broker,
     DeviceCloudPolicyStoreChromeOS* device_store,
     DeviceCloudPolicyManagerChromeOS* manager,
     cryptohome::AsyncMethodCaller* async_method_caller,
-    std::unique_ptr<chromeos::attestation::AttestationFlow> attestation_flow)
+    std::unique_ptr<chromeos::attestation::AttestationFlow> attestation_flow,
+    chromeos::system::StatisticsProvider* statistics_provider)
     : local_state_(local_state),
       enterprise_service_(enterprise_service),
       background_task_runner_(background_task_runner),
       install_attributes_(install_attributes),
       state_keys_broker_(state_keys_broker),
       device_store_(device_store),
       manager_(manager),
       attestation_flow_(std::move(attestation_flow)),
+      statistics_provider_(statistics_provider),
       signing_service_(base::MakeUnique<TpmEnrollmentKeySigningService>(
           async_method_caller)) {}
 
 void DeviceCloudPolicyInitializer::SetSigningServiceForTesting(
     std::unique_ptr<policy::SigningService> signing_service) {
   signing_service_ = std::move(signing_service);
 }
 
 DeviceCloudPolicyInitializer::~DeviceCloudPolicyInitializer() {
   DCHECK(!is_initialized_);
@@ skipping 72 matching lines @@
   // If OOBE is done and we are enrolled, check for need to recover enrollment.
   if (oobe_complete && install_attributes_->IsEnterpriseDevice()) {
     // Regardless what mode is applicable, the enrollment domain is fixed.
     config.management_domain = install_attributes_->GetDomain();
 
     // Enrollment has completed previously and installation-time attributes
     // are in place. Enrollment recovery is required when the server
     // registration gets lost.
     if (local_state_->GetBoolean(prefs::kEnrollmentRecoveryRequired)) {
       LOG(WARNING) << "Enrollment recovery required according to pref.";
-      if (DeviceCloudPolicyManagerChromeOS::GetMachineID().empty())
+      if (statistics_provider_->GetEnterpriseMachineID().empty())
         LOG(WARNING) << "Postponing recovery because machine id is missing.";
       else
         config.mode = EnrollmentConfig::MODE_RECOVERY;
     }
 
     return config;
   }
 
   // OOBE is still running, or it is complete but the device hasn't been
   // enrolled yet. In either case, enrollment should take place if there's a
@@ skipping 77 matching lines @@
     // was in progress. We give it a try again.
     TryToCreateClient();
   }
 
   if (!enrollment_callback.is_null())
     enrollment_callback.Run(status);
 }
 
 std::unique_ptr<CloudPolicyClient> DeviceCloudPolicyInitializer::CreateClient(
     DeviceManagementService* device_management_service) {
+  std::string machine_model;
+  statistics_provider_->GetMachineStatistic(chromeos::system::kHardwareClassKey,
+                                            &machine_model);
   return base::MakeUnique<CloudPolicyClient>(
-      DeviceCloudPolicyManagerChromeOS::GetMachineID(),
-      DeviceCloudPolicyManagerChromeOS::GetMachineModel(),
+      statistics_provider_->GetEnterpriseMachineID(), machine_model,
       kPolicyVerificationKeyHash, device_management_service,
       g_browser_process->system_request_context(), signing_service_.get());
 }
 
 void DeviceCloudPolicyInitializer::TryToCreateClient() {
   if (!device_store_->is_initialized() ||
       !device_store_->has_policy() ||
       state_keys_broker_->pending() ||
       enrollment_handler_) {
     return;
   }
   StartConnection(CreateClient(enterprise_service_));
 }
 
 void DeviceCloudPolicyInitializer::StartConnection(
     std::unique_ptr<CloudPolicyClient> client) {
   if (!manager_->core()->service())
     manager_->StartConnection(std::move(client), install_attributes_);
 }
 
+bool DeviceCloudPolicyInitializer::GetMachineFlag(const std::string& key,
+                                                  bool default_value) const {
+  bool value = default_value;
+  if (!statistics_provider_->GetMachineFlag(key, &value))
+    return default_value;
+
+  return value;
+}
+
 DeviceCloudPolicyInitializer::TpmEnrollmentKeySigningService::
     TpmEnrollmentKeySigningService(
         cryptohome::AsyncMethodCaller* async_method_caller)
     : async_method_caller_(async_method_caller), weak_ptr_factory_(this) {}
 
 DeviceCloudPolicyInitializer::TpmEnrollmentKeySigningService::
     ~TpmEnrollmentKeySigningService() {}
 
 void DeviceCloudPolicyInitializer::TpmEnrollmentKeySigningService::SignData(
     const std::string& data,
@@ skipping 22 matching lines @@
   if (success && (success = att_signed_data.ParseFromString(signed_data))) {
     em_signed_data.set_data(att_signed_data.data());
     em_signed_data.set_signature(att_signed_data.signature());
     em_signed_data.set_extra_data_bytes(att_signed_data.data().size() -
                                         data.size());
   }
   callback.Run(success, em_signed_data);
 }
 
 }  // namespace policy