Move device requisition to EnterpriseEnrollmentHandlerChromeOS.

chrome/browser/chromeos/policy/enrollment_handler_chromeos.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/enrollment_handler_chromeos.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/enrollment/auto_enrollment_controller.h"
+#include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/chromeos/policy/server_backed_state_keys_broker.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
+#include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
+#include "chromeos/system/statistics_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/http/http_status_code.h"
 #include "policy/proto/device_management_backend.pb.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // Retry for InstallAttrs initialization every 500ms.
 const int kLockRetryIntervalMs = 500;
 // Maximum time to retry InstallAttrs initialization before we give up.
 const int kLockRetryTimeoutMs = 10 * 60 * 1000;  // 10 minutes.
 
 // Testing token used when the enrollment-skip-robot-auth is set to skip talking
 // to GAIA for an actual token. This is needed to be able to run against the
 // testing DMServer implementations.
 const char kTestingRobotToken[] = "test-token";
 
+// Device requisition constants.
+const char kNoRequisition[] = "none";
+const char kRemoraRequisition[] = "remora";
+const char kSharkRequisition[] = "shark";
+
+
+// Gets a machine flag from StatisticsProvider, returns 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
 
 EnrollmentHandlerChromeOS::EnrollmentHandlerChromeOS(
+    PrefService* local_state,
     DeviceCloudPolicyStoreChromeOS* store,
     EnterpriseInstallAttributes* install_attributes,
     ServerBackedStateKeysBroker* state_keys_broker,
     scoped_ptr<CloudPolicyClient> client,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,
     const std::string& auth_token,
     const std::string& client_id,
     bool is_auto_enrollment,
-    const std::string& requisition,
     const AllowedDeviceModes& allowed_device_modes,
     const EnrollmentCallback& completion_callback)
-    : store_(store),
+    : local_state_(local_state),
+      store_(store),
       install_attributes_(install_attributes),
       state_keys_broker_(state_keys_broker),
       client_(client.Pass()),
       background_task_runner_(background_task_runner),
       auth_token_(auth_token),
       client_id_(client_id),
       is_auto_enrollment_(is_auto_enrollment),
-      requisition_(requisition),
       allowed_device_modes_(allowed_device_modes),
       completion_callback_(completion_callback),
       device_mode_(DEVICE_MODE_NOT_SET),
       enrollment_step_(STEP_PENDING),
       lockbox_init_duration_(0),
       weak_ptr_factory_(this) {
   CHECK(!client_->is_registered());
   CHECK_EQ(DM_STATUS_SUCCESS, client_->status());
+  InitializeRequisition();
   store_->AddObserver(this);
   client_->AddObserver(this);
   client_->AddNamespaceToFetch(PolicyNamespaceKey(
       dm_protocol::kChromeDevicePolicyType, std::string()));
 }
 
 EnrollmentHandlerChromeOS::~EnrollmentHandlerChromeOS() {
   Stop();
   store_->RemoveObserver(this);
 }
@@ skipping 131 matching lines @@
   enrollment_step_ = STEP_LOADING_STORE;
   AttemptRegistration();
 }
 
 void EnrollmentHandlerChromeOS::AttemptRegistration() {
   CHECK_EQ(STEP_LOADING_STORE, enrollment_step_);
   if (store_->is_initialized()) {
     enrollment_step_ = STEP_REGISTRATION;
     client_->Register(em::DeviceRegisterRequest::DEVICE,
                       auth_token_, client_id_, is_auto_enrollment_,
-                      requisition_, current_state_key_);
+                      GetDeviceRequisition(), current_state_key_);
   }
 }
 
 void EnrollmentHandlerChromeOS::PolicyValidated(
     DeviceCloudPolicyValidator* validator) {
   CHECK_EQ(STEP_VALIDATION, enrollment_step_);
   if (validator->success()) {
     policy_ = validator->policy().Pass();
     username_ = validator->policy_data()->username();
     device_id_ = validator->policy_data()->device_id();
@@ skipping 175 matching lines @@
     LOG(WARNING) << "Enrollment failed: " << status.status()
                  << " " << status.client_status()
                  << " " << status.validation_status()
                  << " " << status.store_status();
   }
 
   if (!callback.is_null())
     callback.Run(status);
 }
 
+// static
+void EnrollmentHandlerChromeOS::RegisterPrefs(
+    PrefRegistrySimple* registry) {
+  registry->RegisterStringPref(prefs::kDeviceEnrollmentRequisition,
+                               std::string());
+  registry->RegisterBooleanPref(prefs::kDeviceEnrollmentAutoStart, false);
+  registry->RegisterBooleanPref(prefs::kDeviceEnrollmentCanExit, true);
+  registry->RegisterDictionaryPref(prefs::kServerBackedDeviceState);
+}
+
+void Foo(PersistentPrefStore::PrefReadError) {}
+
+void EnrollmentHandlerChromeOS::InitializeRequisition() {
+  // OEM statistics are only loaded when OOBE is not completed.
+  if (chromeos::StartupUtils::IsOobeCompleted())
+    return;
+
+  const PrefService::Preference* pref = local_state_->FindPreference(
+      prefs::kDeviceEnrollmentRequisition);
+  if (pref->IsDefaultValue()) {
+    std::string requisition;
+    chromeos::system::StatisticsProvider::GetInstance()->GetMachineStatistic(
+        chromeos::system::kOemDeviceRequisitionKey, &requisition);
+
+    if (!requisition.empty()) {
+      local_state_->SetString(prefs::kDeviceEnrollmentRequisition,
+                             requisition);
+      if (requisition == kRemoraRequisition ||
+          requisition == kSharkRequisition) {
+        local_state_->SetBoolean(prefs::kDeviceEnrollmentAutoStart, true);
+        local_state_->SetBoolean(prefs::kDeviceEnrollmentCanExit, false);
+      } else {
+        local_state_->SetBoolean(
+            prefs::kDeviceEnrollmentAutoStart,
+            GetMachineFlag(chromeos::system::kOemIsEnterpriseManagedKey,
+                           false));
+        local_state_->SetBoolean(
+            prefs::kDeviceEnrollmentCanExit,
+            GetMachineFlag(chromeos::system::kOemCanExitEnterpriseEnrollmentKey,
+                           false));
+      }
+    }
+  }
+}
+
+std::string EnrollmentHandlerChromeOS::GetDeviceRequisition() const {
+  std::string requisition;
+  const PrefService::Preference* pref = local_state_->FindPreference(
+      prefs::kDeviceEnrollmentRequisition);
+  if (!pref->IsDefaultValue())
+    pref->GetValue()->GetAsString(&requisition);
+
+  if (requisition == kNoRequisition)
+    requisition.clear();
+
+  return requisition;
+}
+
+void EnrollmentHandlerChromeOS::SetDeviceRequisition(
+    const std::string& requisition) {
+  VLOG(1) << "SetDeviceRequisition " << requisition;
+  if (local_state_) {
+    if (requisition.empty()) {
+      local_state_->ClearPref(prefs::kDeviceEnrollmentRequisition);
+      local_state_->ClearPref(prefs::kDeviceEnrollmentAutoStart);
+      local_state_->ClearPref(prefs::kDeviceEnrollmentCanExit);
+    } else {
+      local_state_->SetString(prefs::kDeviceEnrollmentRequisition, requisition);
+      if (requisition == kNoRequisition) {
+        local_state_->ClearPref(prefs::kDeviceEnrollmentAutoStart);
+        local_state_->ClearPref(prefs::kDeviceEnrollmentCanExit);
+      } else {
+        local_state_->SetBoolean(prefs::kDeviceEnrollmentAutoStart, true);
+        local_state_->SetBoolean(prefs::kDeviceEnrollmentCanExit, false);
+      }
+    }
+  }
+}
+
+bool EnrollmentHandlerChromeOS::IsRemoraRequisition() const {
+  return GetDeviceRequisition() == kRemoraRequisition;
+}
+
+bool EnrollmentHandlerChromeOS::IsSharkRequisition() const {
+  return GetDeviceRequisition() == kSharkRequisition;
+}
+
 }  // namespace policy