Merge 254685 "Fixed handling of 'oem_device_requisition' VPD value."

chrome/browser/chromeos/policy/device_cloud_policy_manager_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/device_cloud_policy_manager_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
@@ skipping 16 matching lines @@
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
+// Overridden no requisition value.
+const char kNoRequisition[] = "none";
+
+// Overridden no requisition value.
+const char kRemoraRequisition[] = "remora";
+
 // MachineInfo key names.
 const char kMachineInfoSystemHwqual[] = "hardware_class";
 
 // These are the machine serial number keys that we check in order until we
 // find a non-empty serial number. The VPD spec says the serial number should be
 // in the "serial_number" key for v2+ VPDs. However, legacy devices used a
 // different keys to report their serial number, which we fall back to if
 // "serial_number" is not present.
 //
 // Product_S/N is still special-cased due to inconsistencies with serial
@@ skipping 64 matching lines @@
     DeviceManagementService* device_management_service,
     scoped_ptr<CloudPolicyClient::StatusProvider> device_status_provider) {
   CHECK(!device_management_service_);
   CHECK(device_management_service);
   CHECK(local_state);
 
   local_state_ = local_state;
   device_management_service_ = device_management_service;
   device_status_provider_ = device_status_provider.Pass();
 
+  InitalizeRequisition();
   StartIfManaged();
 }
 
 void DeviceCloudPolicyManagerChromeOS::StartEnrollment(
     const std::string& auth_token,
     bool is_auto_enrollment,
     const AllowedDeviceModes& allowed_device_modes,
     const EnrollmentCallback& callback) {
   CHECK(device_management_service_);
   core()->Disconnect();
@@ skipping 13 matching lines @@
   if (enrollment_handler_.get()) {
     enrollment_handler_.reset();
     StartIfManaged();
   }
 }
 
 std::string DeviceCloudPolicyManagerChromeOS::GetDeviceRequisition() const {
   std::string requisition;
   const PrefService::Preference* pref = local_state_->FindPreference(
       prefs::kDeviceEnrollmentRequisition);
-  if (pref->IsDefaultValue() && !chromeos::StartupUtils::IsOobeCompleted()) {
-    // OEM statistics are only loaded when OOBE is not completed.
-    requisition =
-        GetMachineStatistic(chromeos::system::kOemDeviceRequisitionKey);
-  } else {
+  if (!pref->IsDefaultValue())
     pref->GetValue()->GetAsString(&requisition);
-  }
+
+  if (requisition == kNoRequisition)
+    requisition.clear();
 
   return requisition;
 }
 
 void DeviceCloudPolicyManagerChromeOS::SetDeviceRequisition(
     const std::string& 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);
-      local_state_->SetBoolean(prefs::kDeviceEnrollmentAutoStart, true);
-      local_state_->SetBoolean(prefs::kDeviceEnrollmentCanExit, false);
+      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 DeviceCloudPolicyManagerChromeOS::ShouldAutoStartEnrollment() const {
   if (local_state_->HasPrefPath(prefs::kDeviceEnrollmentAutoStart))
     return local_state_->GetBoolean(prefs::kDeviceEnrollmentAutoStart);
 
   return GetMachineFlag(chromeos::system::kOemIsEnterpriseManagedKey, false);
 }
@@ skipping 99 matching lines @@
       !service()) {
     core()->Connect(CreateClient());
     core()->StartRefreshScheduler();
     core()->TrackRefreshDelayPref(local_state_,
                                   prefs::kDevicePolicyRefreshRate);
     attestation_policy_observer_.reset(
         new chromeos::attestation::AttestationPolicyObserver(client()));
   }
 }
 
+void DeviceCloudPolicyManagerChromeOS::InitalizeRequisition() {
+  // 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 =
+        GetMachineStatistic(chromeos::system::kOemDeviceRequisitionKey);
+
+    if (!requisition.empty()) {
+      local_state_->SetString(prefs::kDeviceEnrollmentRequisition,
+                              requisition);
+      if (requisition == kRemoraRequisition) {
+        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));
+      }
+    }
+  }
+}
+
 }  // namespace policy