Add support for public account policy to CloudPolicyClient.

chrome/browser/policy/cloud_policy_client.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/cloud_policy_client.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "chrome/browser/policy/device_management_service.h"
@@ skipping 21 matching lines @@
 
 }  // namespace
 
 CloudPolicyClient::Observer::~Observer() {}
 
 CloudPolicyClient::StatusProvider::~StatusProvider() {}
 
 CloudPolicyClient::CloudPolicyClient(const std::string& machine_id,
                                      const std::string& machine_model,
                                      UserAffiliation user_affiliation,
-                                     PolicyScope scope,
+                                     PolicyType type,
                                      StatusProvider* status_provider,
                                      DeviceManagementService* service)
     : machine_id_(machine_id),
       machine_model_(machine_model),
       user_affiliation_(user_affiliation),
-      scope_(scope),
+      type_(type),
       device_mode_(DEVICE_MODE_NOT_SET),
       submit_machine_id_(false),
       public_key_version_(-1),
       public_key_version_valid_(false),
       service_(service),                  // Can be NULL for unit tests.
       status_provider_(status_provider),  // Can be NULL for unit tests.
       status_(DM_STATUS_SUCCESS) {
 }
 
 CloudPolicyClient::~CloudPolicyClient() {}
@@ skipping 56 matching lines @@
   policy_request->set_signature_type(em::PolicyFetchRequest::SHA1_RSA);
   SetPolicyType(policy_request);
   if (!last_policy_timestamp_.is_null()) {
     base::TimeDelta timestamp(last_policy_timestamp_ - base::Time::UnixEpoch());
     policy_request->set_timestamp(timestamp.InMilliseconds());
   }
   if (submit_machine_id_ && !machine_id_.empty())
     policy_request->set_machine_id(machine_id_);
   if (public_key_version_valid_)
     policy_request->set_public_key_version(public_key_version_);
+  if (!entity_id_.empty())
+    policy_request->set_settings_entity_id(entity_id_);
 
   // Add status data.
   if (status_provider_) {
     if (!status_provider_->GetDeviceStatus(
             request->mutable_device_status_report_request())) {
       request->clear_device_status_report_request();
     }
     if (!status_provider_->GetSessionStatus(
             request->mutable_session_status_report_request())) {
       request->clear_session_status_report_request();
@@ skipping 19 matching lines @@
 void CloudPolicyClient::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void CloudPolicyClient::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void CloudPolicyClient::SetRegistrationType(
     em::DeviceRegisterRequest* request) const {
-  switch (scope_) {
-    case POLICY_SCOPE_USER:
+  switch (type_) {
+    case POLICY_TYPE_USER:
       request->set_type(em::DeviceRegisterRequest::USER);
       return;
-    case POLICY_SCOPE_MACHINE:
+    case POLICY_TYPE_DEVICE:
       request->set_type(em::DeviceRegisterRequest::DEVICE);
       return;
+    case POLICY_TYPE_PUBLIC_ACCOUNT:
+      LOG(FATAL) << "Cannot register for public account policy.";
+      return;
   }
-  NOTREACHED() << "Invalid policy scope " << scope_;
+  NOTREACHED() << "Invalid policy type " << type_;
 }
 
 void CloudPolicyClient::SetPolicyType(em::PolicyFetchRequest* request) const {
-  switch (scope_) {
-    case POLICY_SCOPE_USER:
+  switch (type_) {
+    case POLICY_TYPE_USER:
       request->set_policy_type(dm_protocol::kChromeUserPolicyType);
       return;
-    case POLICY_SCOPE_MACHINE:
+    case POLICY_TYPE_DEVICE:
       request->set_policy_type(dm_protocol::kChromeDevicePolicyType);
       return;
+    case POLICY_TYPE_PUBLIC_ACCOUNT:
+      request->set_policy_type(dm_protocol::kChromePublicAccountPolicyType);
+      return;
   }
-  NOTREACHED() << "Invalid policy scope " << scope_;
+  NOTREACHED() << "Invalid policy type " << type_;
 }
 
 void CloudPolicyClient::OnRegisterCompleted(
     DeviceManagementStatus status,
     const em::DeviceManagementResponse& response) {
   if (status == DM_STATUS_SUCCESS &&
       (!response.has_register_response() ||
        !response.register_response().has_device_management_token())) {
     LOG(WARNING) << "Invalid registration response.";
     status = DM_STATUS_RESPONSE_DECODING_ERROR;
@@ skipping 65 matching lines @@
 
 void CloudPolicyClient::NotifyRegistrationStateChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRegistrationStateChanged(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy