Allow re-enrollment to the same domain in case of policy data loss.

chrome/browser/policy/device_policy_cache.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/policy/device_policy_cache.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/signed_settings_helper.h"
 #include "chrome/browser/policy/app_pack_updater.h"
 #include "chrome/browser/policy/cloud_policy_data_store.h"
 #include "chrome/browser/policy/enterprise_install_attributes.h"
 #include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_map.h"
@@ skipping 133 matching lines @@
 void DevicePolicyCache::Load() {
   signed_settings_helper_->StartRetrievePolicyOp(
       base::Bind(&DevicePolicyCache::OnRetrievePolicyCompleted,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 bool DevicePolicyCache::SetPolicy(const em::PolicyFetchResponse& policy) {
   DCHECK(IsReady());
 
   // Make sure we have an enterprise device.
-  std::string registration_user(install_attributes_->GetRegistrationUser());
-  if (registration_user.empty()) {
+  std::string registration_domain(
+      chromeos::Authenticator::ExtractDomainName(
+          install_attributes_->GetRegistrationUser()));

[Mattias Nissler (ping if slow), 2012/06/08 15:24:36]

I though GetRegistrationUser() is meant to go away eventually?

[pastarmovj, 2012/06/18 14:57:27]

Done.

+  if (registration_domain.empty()) {
     LOG(WARNING) << "Refusing to accept policy on non-enterprise device.";
     UMA_HISTOGRAM_ENUMERATION(kMetricPolicy,
                               kMetricPolicyFetchNonEnterpriseDevice,
                               kMetricPolicySize);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return false;
   }
 
   // Check the user this policy is for against the device-locked name.
   em::PolicyData policy_data;
   if (!policy_data.ParseFromString(policy.policy_data())) {
     LOG(WARNING) << "Invalid policy protobuf";
     UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchInvalidPolicy,
                               kMetricPolicySize);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return false;
   }
 
   // Existing installations may not have a canonicalized version of the
-  // registration user name in install attributes, so re-canonicalize here.
-  if (chromeos::Authenticator::Canonicalize(registration_user) !=
-      chromeos::Authenticator::Canonicalize(policy_data.username())) {
+  // registration domain in install attributes, so lower-case the data here.
+  if (registration_domain !=
+      chromeos::Authenticator::ExtractDomainName(policy_data.username())) {
     LOG(WARNING) << "Refusing policy blob for " << policy_data.username()
-                 << " which doesn't match " << registration_user;
+                 << " which doesn't match domain " << registration_domain;
     UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchUserMismatch,
                               kMetricPolicySize);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return false;
   }
 
   set_last_policy_refresh_time(base::Time::NowFromSystemTime());
 
   // Start a store operation.
@@ skipping 510 matching lines @@
       }
       policies->Set(key::kDeviceStartUpUrls,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     urls);
     }
   }
 }
 
 }  // namespace policy