Implement Chrome OS device enrollment on the new cloud policy stack.

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"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
+namespace {
+
+// Translates the DeviceRegisterResponse::DeviceMode |mode| to the enum used
+// internally to represent different device modes.
+DeviceMode TranslateProtobufDeviceMode(
+    em::DeviceRegisterResponse::DeviceMode mode) {
+  switch (mode) {
+    case em::DeviceRegisterResponse::ENTERPRISE:
+      return DEVICE_MODE_ENTERPRISE;
+    case em::DeviceRegisterResponse::RETAIL:
+      return DEVICE_MODE_KIOSK;
+  }
+  LOG(ERROR) << "Unknown enrollment mode in registration response: " << mode;
+  return  DEVICE_MODE_NOT_SET;

[Joao da Silva, 2012/09/07 14:01:42]

nit: one space after return

[Mattias Nissler (ping if slow), 2012/10/23 15:30:41]

Done.

+}
+
+}  // namespace
+
 CloudPolicyClient::Observer::~Observer() {}
 
 CloudPolicyClient::StatusProvider::~StatusProvider() {}
 
 CloudPolicyClient::CloudPolicyClient(const std::string& machine_id,
                                      const std::string& machine_model,
                                      UserAffiliation user_affiliation,
                                      PolicyScope scope,
                                      StatusProvider* status_provider,
                                      DeviceManagementService* service)
     : machine_id_(machine_id),
       machine_model_(machine_model),
       user_affiliation_(user_affiliation),
       scope_(scope),
+      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 120 matching lines @@
     case POLICY_SCOPE_MACHINE:
       request->set_policy_type(dm_protocol::kChromeDevicePolicyType);
       return;
   }
   NOTREACHED() << "Invalid policy scope " << scope_;
 }
 
 void CloudPolicyClient::OnRegisterCompleted(
     DeviceManagementStatus status,
     const em::DeviceManagementResponse& response) {
+  device_mode_ = TranslateProtobufDeviceMode(
+      response.register_response().enrollment_type());
   if (status == DM_STATUS_SUCCESS &&
       (!response.has_register_response() ||
-       !response.register_response().has_device_management_token())) {
-    LOG(WARNING) << "Empty registration response.";
+       !response.register_response().has_device_management_token() ||
+       (device_mode_ != DEVICE_MODE_ENTERPRISE &&
+        device_mode_ != DEVICE_MODE_KIOSK))) {

[pastarmovj, 2012/09/07 12:16:27]

I know that this check is happening only once but I think it might improve
readability and maintainability if you extract it in a function. something along
the lines ValidateResponse(const em::DeviceManagementResponse& response)...

[Joao da Silva, 2012/09/07 14:01:42]

Please add a comment explaining what the device_mode_ tests mean for user
policy, as discussed offline.

[Mattias Nissler (ping if slow), 2012/10/23 15:30:41]

Done.

[Mattias Nissler (ping if slow), 2012/10/23 15:30:41]

I thought about this some more and ended up re-structuring the code.

+    LOG(WARNING) << "Invalid registration response.";
     status = DM_STATUS_RESPONSE_DECODING_ERROR;
   }
 
   status_ = status;
   if (status == DM_STATUS_SUCCESS) {
     dm_token_ = response.register_response().device_management_token();
     NotifyRegistrationStateChanged();
   } else {
     NotifyClientError();
   }
@@ skipping 47 matching lines @@
 
 void CloudPolicyClient::NotifyRegistrationStateChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRegistrationStateChanged(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy