Refactoring: group CloudPolicyClient::Register parameters

Over time we have to introduce new parameters for Register/
RegisterWithCertificate requests, and this list is growing
unmanageable. We need to add one more parameter, so this CL
just groups such parameters into a single struct with reasonable
values for defaults.

Change-Id: I362ffda59f0b78cc25541953f8afb3e2df11b1c3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1625124
Commit-Queue: Denis Kuznetsov <antrim@chromium.org>
Reviewed-by: Sergey Poromov <poromov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#666297}

chrome/browser/chromeos/policy/enrollment_handler_chromeos.cc

@@ -186,7 +186,6 @@ EnrollmentHandlerChromeOS::EnrollmentHandlerChromeOS(
       ad_join_delegate_(ad_join_delegate),
       enrollment_config_(enrollment_config),
       client_id_(client_id),
-      requisition_(requisition),
       sub_organization_(sub_organization),
       completion_callback_(completion_callback),
       enrollment_step_(STEP_PENDING),
@@ -206,6 +205,14 @@ EnrollmentHandlerChromeOS::EnrollmentHandlerChromeOS(
   CHECK(enrollment_config_.auth_mechanism !=
             EnrollmentConfig::AUTH_MECHANISM_ATTESTATION ||
         attestation_flow_);
+  if (enrollment_config.mode != EnrollmentConfig::MODE_OFFLINE_DEMO) {
+    register_params_ =
+        std::make_unique<CloudPolicyClient::RegistrationParameters>(
+            em::DeviceRegisterRequest::DEVICE,
+            EnrollmentModeToRegistrationFlavor(enrollment_config.mode));
+    register_params_->requisition = requisition;
+  }
+
   store_->AddObserver(this);
   client_->AddObserver(this);
   client_->AddPolicyTypeToFetch(dm_protocol::kChromeDevicePolicyType,
@@ -257,13 +264,13 @@ void EnrollmentHandlerChromeOS::StartEnrollmentWithLicense(
   CHECK_NE(license_type, ::policy::LicenseType::UNKNOWN);
   switch (license_type) {
     case LicenseType::PERPETUAL:
-      license_type_ = ::em::LicenseType::CDM_PERPETUAL;
+      register_params_->license_type = ::em::LicenseType::CDM_PERPETUAL;
       break;
     case LicenseType::ANNUAL:
-      license_type_ = ::em::LicenseType::CDM_ANNUAL;
+      register_params_->license_type = ::em::LicenseType::CDM_ANNUAL;
       break;
     case LicenseType::KIOSK:
-      license_type_ = ::em::LicenseType::KIOSK;
+      register_params_->license_type = ::em::LicenseType::KIOSK;
       break;
     case LicenseType::UNKNOWN:
       NOTREACHED();
@@ -413,8 +420,9 @@ void EnrollmentHandlerChromeOS::HandleStateKeysResult(
   // Make sure state keys are available if forced re-enrollment is on.
   if (chromeos::AutoEnrollmentController::IsFREEnabled()) {
     client_->SetStateKeysToUpload(state_keys);
-    current_state_key_ = state_keys_broker_->current_state_key();
-    if (state_keys.empty() || current_state_key_.empty()) {
+    register_params_->current_state_key =
+        state_keys_broker_->current_state_key();
+    if (state_keys.empty() || register_params_->current_state_key.empty()) {
       ReportResult(
           EnrollmentStatus::ForStatus(EnrollmentStatus::NO_STATE_KEYS));
       return;
@@ -438,11 +446,7 @@ void EnrollmentHandlerChromeOS::StartRegistration() {
   } else if (enrollment_config_.mode == EnrollmentConfig::MODE_OFFLINE_DEMO) {
     StartOfflineDemoEnrollmentFlow();
   } else {
-    client_->Register(
-        em::DeviceRegisterRequest::DEVICE,
-        EnrollmentModeToRegistrationFlavor(enrollment_config_.mode),
-        em::DeviceRegisterRequest::LIFETIME_INDEFINITE, license_type_,
-        dm_auth_->oauth_token(), client_id_, requisition_, current_state_key_);
+    client_->Register(*register_params_, client_id_, dm_auth_->oauth_token());
   }
 }
 
@@ -461,12 +465,9 @@ void EnrollmentHandlerChromeOS::HandleRegistrationCertificateResult(
     chromeos::attestation::AttestationStatus status,
     const std::string& pem_certificate_chain) {
   if (status == chromeos::attestation::ATTESTATION_SUCCESS) {
-    client_->RegisterWithCertificate(
-        em::DeviceRegisterRequest::DEVICE,
-        EnrollmentModeToRegistrationFlavor(enrollment_config_.mode),
-        em::DeviceRegisterRequest::LIFETIME_INDEFINITE, license_type_,
-        dm_auth_->Clone(), pem_certificate_chain, client_id_, requisition_,
-        current_state_key_, sub_organization_);
+    client_->RegisterWithCertificate(*register_params_, client_id_,
+                                     dm_auth_->Clone(), pem_certificate_chain,
+                                     sub_organization_);
   } else {
     ReportResult(EnrollmentStatus::ForStatus(
         EnrollmentStatus::REGISTRATION_CERT_FETCH_FAILED));

chrome/browser/chromeos/policy/enrollment_handler_chromeos.h

@@ -236,15 +236,10 @@ class EnrollmentHandlerChromeOS : public CloudPolicyClient::Observer,
   EnrollmentConfig enrollment_config_;
   std::unique_ptr<policy::DMAuth> dm_auth_;
   std::string client_id_;
-  std::string requisition_;
   std::string sub_organization_;
+  std::unique_ptr<CloudPolicyClient::RegistrationParameters> register_params_;
   EnrollmentCallback completion_callback_;
   AvailableLicensesCallback available_licenses_callback_;
-  enterprise_management::LicenseType::LicenseTypeEnum license_type_ =
-      enterprise_management::LicenseType::UNDEFINED;
-
-  // The current state key provided by |state_keys_broker_|.
-  std::string current_state_key_;
 
   // The device mode as received in the registration request.
   DeviceMode device_mode_ = DEVICE_MODE_NOT_SET;

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.cc

@@ -631,18 +631,16 @@ void UserCloudPolicyManagerChromeOS::OnOAuth2PolicyTokenFetched(
 
     // Start client registration. Either OnRegistrationStateChanged() or
     // OnClientError() will be called back.
-    const auto lifetime =
-        user_manager::UserManager::Get()->IsCurrentUserCryptohomeDataEphemeral()
-            ? em::DeviceRegisterRequest::LIFETIME_EPHEMERAL_USER
-            : em::DeviceRegisterRequest::LIFETIME_INDEFINITE;
+    CloudPolicyClient::RegistrationParameters parameters(
+        em::DeviceRegisterRequest::USER,
+        em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
+    if (user_manager::UserManager::Get()
+            ->IsCurrentUserCryptohomeDataEphemeral())
+      parameters.lifetime = em::DeviceRegisterRequest::LIFETIME_EPHEMERAL_USER;
     std::string client_id;
     if (client()->requires_reregistration())
       client_id = client()->client_id();
-    client()->Register(em::DeviceRegisterRequest::USER,
-                       em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-                       lifetime, em::LicenseType::UNDEFINED, policy_token,
-                       client_id, std::string() /* requisition */,
-                       std::string() /* current_state_key */);
+    client()->Register(parameters, client_id, policy_token);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kUMAInitialFetchOAuth2Error, error.state(),
                               GoogleServiceAuthError::NUM_STATES);

chrome/browser/chromeos/policy/user_policy_test_helper.cc

@@ -53,15 +53,12 @@ void UserPolicyTestHelper::WaitForInitialPolicy(Profile* profile) {
   // Give a bogus OAuth token to the |policy_manager|. This should make its
   // CloudPolicyClient fetch the DMToken.
   ASSERT_FALSE(policy_manager->core()->client()->is_registered());
-  const enterprise_management::DeviceRegisterRequest::Type registration_type =
-      enterprise_management::DeviceRegisterRequest::USER;
+  CloudPolicyClient::RegistrationParameters user_registration(
+      enterprise_management::DeviceRegisterRequest::USER,
+      enterprise_management::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
   policy_manager->core()->client()->Register(
-      registration_type,
-      enterprise_management::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-      enterprise_management::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-      enterprise_management::LicenseType::UNDEFINED,
-      "oauth_token_unused" /* oauth_token */, std::string() /* client_id */,
-      std::string() /* requisition */, std::string() /* current_state_key */);
+      user_registration, std::string() /* client_id */,
+      "oauth_token_unused" /* oauth_token */);
 
   policy::ProfilePolicyConnector* const profile_connector =
       profile->GetProfilePolicyConnector();

chrome/browser/policy/cloud/cloud_policy_browsertest.cc

@@ -251,18 +251,16 @@ class CloudPolicyTest : public InProcessBrowserTest,
     // Give a bogus OAuth token to the |policy_manager|. This should make its
     // CloudPolicyClient fetch the DMToken.
     ASSERT_FALSE(policy_manager->core()->client()->is_registered());
-    em::DeviceRegisterRequest::Type registration_type =
+    CloudPolicyClient::RegistrationParameters parameters(
 #if defined(OS_CHROMEOS)
-        em::DeviceRegisterRequest::USER;
+        em::DeviceRegisterRequest::USER,
 #else
-        em::DeviceRegisterRequest::BROWSER;
+        em::DeviceRegisterRequest::BROWSER,
 #endif
+        em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
     policy_manager->core()->client()->Register(
-        registration_type, em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-        em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-        em::LicenseType::UNDEFINED, "oauth_token_unused" /* oauth_token */,
-        std::string() /* client_id */, std::string() /* requisition */,
-        std::string() /* current_state_key */);
+        parameters, std::string() /* client_id */,
+        "oauth_token_unused" /* oauth_token */);
     run_loop.Run();
     Mock::VerifyAndClearExpectations(&observer);
     policy_manager->core()->client()->RemoveObserver(&observer);

chrome/browser/policy/cloud/cloud_policy_manager_browsertest.cc

@@ -219,18 +219,16 @@ class CloudPolicyManagerTest : public InProcessBrowserTest {
 
     // Give a bogus OAuth token to the |policy_manager|. This should make its
     // CloudPolicyClient fetch the DMToken.
-    em::DeviceRegisterRequest::Type registration_type =
+    CloudPolicyClient::RegistrationParameters parameters(
 #if defined(OS_CHROMEOS)
-        em::DeviceRegisterRequest::USER;
+        em::DeviceRegisterRequest::USER,
 #else
-        em::DeviceRegisterRequest::BROWSER;
+        em::DeviceRegisterRequest::BROWSER,
 #endif
+        em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
     policy_manager()->core()->client()->Register(
-        registration_type, em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-        em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-        em::LicenseType::UNDEFINED, "oauth_token_unused" /* oauth_token */,
-        std::string() /* client_id */, std::string() /* requisition */,
-        std::string() /* current_state_key */);
+        parameters, std::string() /* client_id */,
+        "oauth_token_unused" /* oauth_token */);
     run_loop.Run();
     Mock::VerifyAndClearExpectations(&observer);
     policy_manager()->core()->client()->RemoveObserver(&observer);

components/policy/core/common/cloud/cloud_policy_client.cc

@@ -151,6 +151,13 @@ TranslatePolicyValidationResultSeverity(
 
 }  // namespace
 
+CloudPolicyClient::RegistrationParameters::RegistrationParameters(
+    em::DeviceRegisterRequest::Type registration_type,
+    em::DeviceRegisterRequest::Flavor flavor)
+    : registration_type(registration_type), flavor(flavor) {}
+
+CloudPolicyClient::RegistrationParameters::~RegistrationParameters() = default;
+
 CloudPolicyClient::Observer::~Observer() {}
 
 CloudPolicyClient::CloudPolicyClient(
@@ -208,14 +215,9 @@ void CloudPolicyClient::SetClientId(const std::string& client_id) {
   client_id_ = client_id.empty() ?  base::GenerateGUID() : client_id;
 }
 
-void CloudPolicyClient::Register(em::DeviceRegisterRequest::Type type,
-                                 em::DeviceRegisterRequest::Flavor flavor,
-                                 em::DeviceRegisterRequest::Lifetime lifetime,
-                                 em::LicenseType::LicenseTypeEnum license_type,
-                                 const std::string& oauth_token,
+void CloudPolicyClient::Register(const RegistrationParameters& parameters,
                                  const std::string& client_id,
-                                 const std::string& requisition,
-                                 const std::string& current_state_key) {
+                                 const std::string& oauth_token) {
   DCHECK(service_);
   DCHECK(!oauth_token.empty());
   DCHECK(!is_registered());
@@ -231,8 +233,8 @@ void CloudPolicyClient::Register(em::DeviceRegisterRequest::Type type,
 
   em::DeviceRegisterRequest* request =
       config->request()->mutable_register_request();
-  CreateDeviceRegisterRequest(type, flavor, lifetime, license_type, client_id,
-                              requisition, current_state_key, request);
+  CreateDeviceRegisterRequest(parameters, client_id, request);
+
   if (requires_reregistration())
     request->set_reregistration_dm_token(reregistration_dm_token_);
 
@@ -240,15 +242,10 @@ void CloudPolicyClient::Register(em::DeviceRegisterRequest::Type type,
 }
 
 void CloudPolicyClient::RegisterWithCertificate(
-    em::DeviceRegisterRequest::Type type,
-    em::DeviceRegisterRequest::Flavor flavor,
-    em::DeviceRegisterRequest::Lifetime lifetime,
-    em::LicenseType::LicenseTypeEnum license_type,
+    const RegistrationParameters& parameters,
+    const std::string& client_id,
     std::unique_ptr<DMAuth> auth,
     const std::string& pem_certificate_chain,
-    const std::string& client_id,
-    const std::string& requisition,
-    const std::string& current_state_key,
     const std::string& sub_organization) {
   DCHECK(signing_service_);
   DCHECK(service_);
@@ -262,8 +259,7 @@ void CloudPolicyClient::RegisterWithCertificate(
   data.set_device_certificate(pem_certificate_chain);
 
   em::DeviceRegisterRequest* request = data.mutable_device_register_request();
-  CreateDeviceRegisterRequest(type, flavor, lifetime, license_type, client_id,
-                              requisition, current_state_key, request);
+  CreateDeviceRegisterRequest(parameters, client_id, request);
   if (!sub_organization.empty()) {
     em::DeviceRegisterConfiguration* configuration =
         data.mutable_device_register_configuration();
@@ -1166,17 +1162,14 @@ void CloudPolicyClient::NotifyClientError() {
 }
 
 void CloudPolicyClient::CreateDeviceRegisterRequest(
-    em::DeviceRegisterRequest::Type type,
-    em::DeviceRegisterRequest::Flavor flavor,
-    em::DeviceRegisterRequest::Lifetime lifetime,
-    em::LicenseType::LicenseTypeEnum license_type,
+    const RegistrationParameters& params,
     const std::string& client_id,
-    const std::string& requisition,
-    const std::string& current_state_key,
     em::DeviceRegisterRequest* request) {
   if (!client_id.empty())
     request->set_reregister(true);
-  request->set_type(type);
+  request->set_type(params.registration_type);
+  request->set_flavor(params.flavor);
+  request->set_lifetime(params.lifetime);
   if (!machine_id_.empty())
     request->set_machine_id(machine_id_);
   if (!machine_model_.empty())
@@ -1189,14 +1182,12 @@ void CloudPolicyClient::CreateDeviceRegisterRequest(
     request->set_dock_mac_address(dock_mac_address_);
   if (!manufacture_date_.empty())
     request->set_manufacture_date(manufacture_date_);
-  if (!requisition.empty())
-    request->set_requisition(requisition);
-  if (!current_state_key.empty())
-    request->set_server_backed_state_key(current_state_key);
-  request->set_flavor(flavor);
-  if (license_type != em::LicenseType::UNDEFINED)
-    request->mutable_license_type()->set_license_type(license_type);
-  request->set_lifetime(lifetime);
+  if (!params.requisition.empty())
+    request->set_requisition(params.requisition);
+  if (!params.current_state_key.empty())
+    request->set_server_backed_state_key(params.current_state_key);
+  if (params.license_type != em::LicenseType::UNDEFINED)
+    request->mutable_license_type()->set_license_type(params.license_type);
 }
 
 }  // namespace policy

components/policy/core/common/cloud/cloud_policy_client.h

@@ -98,6 +98,32 @@ class POLICY_EXPORT CloudPolicyClient {
     virtual void OnClientError(CloudPolicyClient* client) = 0;
   };
 
+  struct POLICY_EXPORT RegistrationParameters {
+   public:
+    RegistrationParameters(
+        enterprise_management::DeviceRegisterRequest::Type registration_type,
+        enterprise_management::DeviceRegisterRequest::Flavor flavor);
+    ~RegistrationParameters();
+
+    enterprise_management::DeviceRegisterRequest::Type registration_type;
+    enterprise_management::DeviceRegisterRequest::Flavor flavor;
+
+    // Lifetime of registration. Used for easier clean up of ephemeral session
+    // registrations.
+    enterprise_management::DeviceRegisterRequest::Lifetime lifetime =
+        enterprise_management::DeviceRegisterRequest::LIFETIME_INDEFINITE;
+
+    // Selected license type if user is allowed to select it.
+    enterprise_management::LicenseType::LicenseTypeEnum license_type =
+        enterprise_management::LicenseType::UNDEFINED;
+
+    // Device requisition.
+    std::string requisition;
+
+    // Server-backed state keys (used for forced enrollment check).
+    std::string current_state_key;
+  };
+
   // If non-empty, |machine_id|, |machine_model|, |brand_code|,
   // |ethernet_mac_address|, |dock_mac_address| and |manufacture_date| are
   // passed to the server verbatim. As these reveal machine identity, they must
@@ -132,33 +158,24 @@ class POLICY_EXPORT CloudPolicyClient {
 
   // Attempts to register with the device management service. Results in a
   // registration change or error notification.
-  virtual void Register(
-      enterprise_management::DeviceRegisterRequest::Type registration_type,
-      enterprise_management::DeviceRegisterRequest::Flavor flavor,
-      enterprise_management::DeviceRegisterRequest::Lifetime lifetime,
-      enterprise_management::LicenseType::LicenseTypeEnum license_type,
-      const std::string& oauth_token,
-      const std::string& client_id,
-      const std::string& requisition,
-      const std::string& current_state_key);
+  virtual void Register(const RegistrationParameters& parameters,
+                        const std::string& client_id,
+                        const std::string& oauth_token);
 
   // Attempts to register with the device management service using a
   // registration certificate. Results in a registration change or
   // error notification.
-  virtual void RegisterWithCertificate(
-      enterprise_management::DeviceRegisterRequest::Type registration_type,
-      enterprise_management::DeviceRegisterRequest::Flavor flavor,
-      enterprise_management::DeviceRegisterRequest::Lifetime lifetime,
-      enterprise_management::LicenseType::LicenseTypeEnum license_type,
-      std::unique_ptr<DMAuth> auth,
-      const std::string& pem_certificate_chain,
-      const std::string& client_id,
-      const std::string& requisition,
-      const std::string& current_state_key,
-      const std::string& sub_organization);
+  virtual void RegisterWithCertificate(const RegistrationParameters& parameters,
+                                       const std::string& client_id,
+                                       std::unique_ptr<DMAuth> auth,
+                                       const std::string& pem_certificate_chain,
+                                       const std::string& sub_organization);
 
   // Attempts to enroll with the device management service using an enrollment
   // token. Results in a registration change or error notification.
+  // This method is used to register browser (e.g. for machine-level policies).
+  // Device registration with enrollment token should be performed using
+  // RegisterWithCertificate method.
   virtual void RegisterWithToken(const std::string& token,
                                  const std::string& client_id);
 
@@ -584,13 +601,8 @@ class POLICY_EXPORT CloudPolicyClient {
   // Fills in the common fields of a DeviceRegisterRequest for |Register| and
   // |RegisterWithCertificate|.
   void CreateDeviceRegisterRequest(
-      enterprise_management::DeviceRegisterRequest::Type registration_type,
-      enterprise_management::DeviceRegisterRequest::Flavor flavor,
-      enterprise_management::DeviceRegisterRequest::Lifetime lifetime,
-      enterprise_management::LicenseType::LicenseTypeEnum license_type,
+      const RegistrationParameters& params,
       const std::string& client_id,
-      const std::string& requisition,
-      const std::string& current_state_key,
       enterprise_management::DeviceRegisterRequest* request);
 
   // Prepare the certificate upload request field for uploading a certificate.

components/policy/core/common/cloud/cloud_policy_client_registration_helper.cc

@@ -266,12 +266,10 @@ void CloudPolicyClientRegistrationHelper::OnGetUserInfoSuccess(
   // Kick off registration of the CloudPolicyClient with our newly minted
   // oauth_access_token_.
   client_->Register(
-      registration_type_,
-      enterprise_management::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-      enterprise_management::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-      enterprise_management::LicenseType::UNDEFINED, oauth_access_token_,
-      std::string() /* client_id */, std::string() /* requisition */,
-      std::string() /* current_state_key */);
+      CloudPolicyClient::RegistrationParameters(
+          registration_type_, enterprise_management::DeviceRegisterRequest::
+                                  FLAVOR_USER_REGISTRATION),
+      std::string() /* client_id */, oauth_access_token_);
 }
 
 void CloudPolicyClientRegistrationHelper::OnPolicyFetched(

components/policy/core/common/cloud/cloud_policy_client_unittest.cc

@@ -681,11 +681,11 @@ TEST_F(CloudPolicyClientTest, RegistrationAndPolicyFetch) {
   EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
   EXPECT_CALL(device_dmtoken_callback_observer_, OnDeviceDMTokenRequested(_))
       .WillOnce(Return(kDeviceDMToken));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-                    em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-                    em::LicenseType::UNDEFINED, kOAuthToken, std::string(),
-                    std::string(), std::string());
+  CloudPolicyClient::RegistrationParameters register_user(
+      em::DeviceRegisterRequest::USER,
+      em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
+  client_->Register(register_user, std::string() /* no client_id*/,
+                    kOAuthToken);
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_REGISTRATION,
             job_type_);
   EXPECT_EQ(job_request_.SerializePartialAsString(),
@@ -710,11 +710,11 @@ TEST_F(CloudPolicyClientTest, RegistrationAndPolicyFetchWithOAuthToken) {
   EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
   EXPECT_CALL(device_dmtoken_callback_observer_, OnDeviceDMTokenRequested(_))
       .WillOnce(Return(kDeviceDMToken));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-                    em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-                    em::LicenseType::UNDEFINED, kOAuthToken, std::string(),
-                    std::string(), std::string());
+  CloudPolicyClient::RegistrationParameters register_user(
+      em::DeviceRegisterRequest::USER,
+      em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
+  client_->Register(register_user, std::string() /* no client_id*/,
+                    kOAuthToken);
   client_->SetOAuthTokenAsAdditionalAuth(kOAuthToken);
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_REGISTRATION,
             job_type_);
@@ -739,12 +739,12 @@ TEST_F(CloudPolicyClientTest, RegistrationWithCertificateAndPolicyFetch) {
   ExpectCertBasedRegistration();
   fake_signing_service_.set_success(true);
   EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
-  client_->RegisterWithCertificate(
+  CloudPolicyClient::RegistrationParameters device_attestation(
       em::DeviceRegisterRequest::DEVICE,
-      em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_ATTESTATION,
-      em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-      em::LicenseType::UNDEFINED, DMAuth::NoAuth(), kEnrollmentCertificate,
-      std::string(), std::string(), std::string(), std::string());
+      em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_ATTESTATION);
+  client_->RegisterWithCertificate(
+      device_attestation, std::string() /* client_id */, DMAuth::NoAuth(),
+      kEnrollmentCertificate, std::string() /* sub_organization */);
   EXPECT_EQ(
       DeviceManagementService::JobConfiguration::TYPE_CERT_BASED_REGISTRATION,
       job_type_);
@@ -768,12 +768,12 @@ TEST_F(CloudPolicyClientTest, RegistrationWithCertificateAndPolicyFetch) {
 TEST_F(CloudPolicyClientTest, RegistrationWithCertificateFailToSignRequest) {
   fake_signing_service_.set_success(false);
   EXPECT_CALL(observer_, OnClientError(_));
-  client_->RegisterWithCertificate(
+  CloudPolicyClient::RegistrationParameters device_attestation(
       em::DeviceRegisterRequest::DEVICE,
-      em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_ATTESTATION,
-      em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-      em::LicenseType::UNDEFINED, DMAuth::NoAuth(), kEnrollmentCertificate,
-      std::string(), std::string(), std::string(), std::string());
+      em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_ATTESTATION);
+  client_->RegisterWithCertificate(
+      device_attestation, std::string() /* client_id */, DMAuth::NoAuth(),
+      kEnrollmentCertificate, std::string() /* sub_organization */);
   EXPECT_FALSE(client_->is_registered());
   EXPECT_EQ(DM_STATUS_CANNOT_SIGN_REQUEST, client_->status());
 }
@@ -790,11 +790,15 @@ TEST_F(CloudPolicyClientTest, RegistrationParametersPassedThrough) {
   EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
   EXPECT_CALL(device_dmtoken_callback_observer_, OnDeviceDMTokenRequested(_))
       .WillOnce(Return(kDeviceDMToken));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_MANUAL,
-                    em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-                    em::LicenseType::UNDEFINED, kOAuthToken, kClientID,
-                    kRequisition, kStateKey);
+
+  CloudPolicyClient::RegistrationParameters register_parameters(
+      em::DeviceRegisterRequest::USER,
+      em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_MANUAL);
+  register_parameters.requisition = kRequisition;
+  register_parameters.current_state_key = kStateKey;
+
+  client_->Register(register_parameters, kClientID, kOAuthToken);
+
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_REGISTRATION,
             job_type_);
   EXPECT_EQ(job_request_.SerializePartialAsString(),
@@ -807,11 +811,11 @@ TEST_F(CloudPolicyClientTest, RegistrationNoToken) {
       clear_device_management_token();
   ExpectRegistration(kOAuthToken);
   EXPECT_CALL(observer_, OnClientError(_));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-                    em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-                    em::LicenseType::UNDEFINED, kOAuthToken, std::string(),
-                    std::string(), std::string());
+  CloudPolicyClient::RegistrationParameters register_user(
+      em::DeviceRegisterRequest::USER,
+      em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
+  client_->Register(register_user, std::string() /* no client_id*/,
+                    kOAuthToken);
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_REGISTRATION,
             job_type_);
   EXPECT_EQ(job_request_.SerializePartialAsString(),
@@ -829,11 +833,11 @@ TEST_F(CloudPolicyClientTest, RegistrationFailure) {
           service_.StartJobSync(net::ERR_FAILED,
                                 DeviceManagementService::kInvalidArgument)));
   EXPECT_CALL(observer_, OnClientError(_));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-                    em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-                    em::LicenseType::UNDEFINED, kOAuthToken, std::string(),
-                    std::string(), std::string());
+  CloudPolicyClient::RegistrationParameters register_user(
+      em::DeviceRegisterRequest::USER,
+      em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
+  client_->Register(register_user, std::string() /* no client_id*/,
+                    kOAuthToken);
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_REGISTRATION,
             job_type);
   EXPECT_FALSE(client_->is_registered());
@@ -852,11 +856,11 @@ TEST_F(CloudPolicyClientTest, RetryRegistration) {
                       service_.StartJobAsync(net::ERR_NETWORK_CHANGED,
                                              DeviceManagementService::kSuccess,
                                              dummy_response)));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION,
-                    em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-                    em::LicenseType::UNDEFINED, kOAuthToken, std::string(),
-                    std::string(), std::string());
+  CloudPolicyClient::RegistrationParameters register_user(
+      em::DeviceRegisterRequest::USER,
+      em::DeviceRegisterRequest::FLAVOR_USER_REGISTRATION);
+  client_->Register(register_user, std::string() /* no client_id*/,
+                    kOAuthToken);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_REGISTRATION,
             job_type);
@@ -1774,11 +1778,10 @@ TEST_F(CloudPolicyClientTest, PolicyReregistration) {
   EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
   EXPECT_CALL(device_dmtoken_callback_observer_, OnDeviceDMTokenRequested(_))
       .WillOnce(Return(kDeviceDMToken));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_RECOVERY,
-                    em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-                    em::LicenseType::UNDEFINED, kOAuthToken, client_id_,
-                    std::string(), std::string());
+  CloudPolicyClient::RegistrationParameters user_recovery(
+      em::DeviceRegisterRequest::USER,
+      em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_RECOVERY);
+  client_->Register(user_recovery, client_id_, kOAuthToken);
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_POLICY_FETCH,
             upload_type);
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_REGISTRATION,
@@ -1813,11 +1816,10 @@ TEST_F(CloudPolicyClientTest, PolicyReregistrationFailsWithNonMatchingDMToken) {
   // Re-register (server sends wrong DMToken).
   ExpectFailedReregistration(kOAuthToken);
   EXPECT_CALL(observer_, OnClientError(_));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_RECOVERY,
-                    em::DeviceRegisterRequest::LIFETIME_INDEFINITE,
-                    em::LicenseType::UNDEFINED, kOAuthToken, client_id_,
-                    std::string(), std::string());
+  CloudPolicyClient::RegistrationParameters user_recovery(
+      em::DeviceRegisterRequest::USER,
+      em::DeviceRegisterRequest::FLAVOR_ENROLLMENT_RECOVERY);
+  client_->Register(user_recovery, client_id_, kOAuthToken);
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_POLICY_FETCH,
             upload_type);
   EXPECT_EQ(DeviceManagementService::JobConfiguration::TYPE_REGISTRATION,

components/policy/core/common/cloud/mock_cloud_policy_client.h

@@ -36,16 +36,10 @@ class MockCloudPolicyClient : public CloudPolicyClient {
                void(const std::string&,
                     const std::string&,
                     const std::vector<std::string>&));
-  MOCK_METHOD8(
-      Register,
-      void(enterprise_management::DeviceRegisterRequest::Type type,
-           enterprise_management::DeviceRegisterRequest::Flavor flavor,
-           enterprise_management::DeviceRegisterRequest::Lifetime lifetime,
-           enterprise_management::LicenseType::LicenseTypeEnum license_type,
-           const std::string&,
-           const std::string&,
-           const std::string&,
-           const std::string&));
+  MOCK_METHOD3(Register,
+               void(const RegistrationParameters&,
+                    const std::string&,
+                    const std::string&));
   MOCK_METHOD0(FetchPolicy, void(void));
   MOCK_METHOD0(Unregister, void(void));
   MOCK_METHOD2(UploadEnterpriseMachineCertificate,