Delete dead consumer enrollment code.

chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos_unittest.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 <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 160 matching lines @@
         base::Bind(&CopyLockResult, &loop, &result));
     loop.Run();
     ASSERT_EQ(EnterpriseInstallAttributes::LOCK_SUCCESS, result);
   }
 
   void ConnectManager() {
     manager_->Initialize(&local_state_);
     manager_->AddDeviceCloudPolicyManagerObserver(this);
     initializer_.reset(new DeviceCloudPolicyInitializer(
         &local_state_, &device_management_service_,
-        &consumer_device_management_service_,
         base::ThreadTaskRunnerHandle::Get(), install_attributes_.get(),
         &state_keys_broker_, store_, manager_.get()));
     initializer_->Init();
   }
 
   void VerifyPolicyPopulated() {
     PolicyBundle bundle;
     bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .Set(key::kDeviceMetricsReportingEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
@@ skipping 19 matching lines @@
   MOCK_METHOD0(OnDeviceCloudPolicyManagerDisconnected, void());
 
   std::unique_ptr<EnterpriseInstallAttributes> install_attributes_;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   net::TestURLFetcherFactory url_fetcher_factory_;
   int url_fetcher_response_code_;
   std::string url_fetcher_response_string_;
   TestingPrefServiceSimple local_state_;
   MockDeviceManagementService device_management_service_;
-  MockDeviceManagementService consumer_device_management_service_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   chromeos::FakeSessionManagerClient fake_session_manager_client_;
   chromeos::FakeCryptohomeClient* fake_cryptohome_client_;
   ServerBackedStateKeysBroker state_keys_broker_;
 
   DeviceCloudPolicyStoreChromeOS* store_;
   SchemaRegistry schema_registry_;
   std::unique_ptr<TestingDeviceCloudPolicyManagerChromeOS> manager_;
@@ skipping 138 matching lines @@
  public:
   void Done(EnrollmentStatus status) {
     status_ = status;
     done_ = true;
   }
 
   MOCK_METHOD1(OnUnregistered, void(bool));
 
  protected:
   DeviceCloudPolicyManagerChromeOSEnrollmentTest()
-      : management_mode_(MANAGEMENT_MODE_ENTERPRISE_MANAGED),
-        register_status_(DM_STATUS_SUCCESS),
+      : register_status_(DM_STATUS_SUCCESS),
         policy_fetch_status_(DM_STATUS_SUCCESS),
         robot_auth_fetch_status_(DM_STATUS_SUCCESS),
         store_result_(true),
         status_(EnrollmentStatus::ForStatus(EnrollmentStatus::STATUS_SUCCESS)),
         done_(false) {}
 
   void SetUp() override {
     DeviceCloudPolicyManagerChromeOSTest::SetUp();
 
     // Set up test data.
@@ skipping 26 matching lines @@
     EXPECT_EQ(status, status_.status());
     EXPECT_FALSE(store_->is_managed());
     PolicyBundle empty_bundle;
     EXPECT_TRUE(manager_->policies().Equals(empty_bundle));
   }
 
   void ExpectSuccessfulEnrollment() {
     EXPECT_EQ(EnrollmentStatus::STATUS_SUCCESS, status_.status());
     ASSERT_TRUE(manager_->core()->client());
     EXPECT_TRUE(manager_->core()->client()->is_registered());
-
-    if (management_mode_ != MANAGEMENT_MODE_CONSUMER_MANAGED) {
-      EXPECT_EQ(DEVICE_MODE_ENTERPRISE, install_attributes_->GetMode());
-      EXPECT_TRUE(store_->has_policy());
-      EXPECT_TRUE(store_->is_managed());
-      VerifyPolicyPopulated();
-    }
+    EXPECT_EQ(DEVICE_MODE_ENTERPRISE, install_attributes_->GetMode());
+    EXPECT_TRUE(store_->has_policy());
+    EXPECT_TRUE(store_->is_managed());
+    VerifyPolicyPopulated();
   }
 
   void RunTest() {
     // Trigger enrollment.
     MockDeviceManagementJob* register_job = NULL;
     EXPECT_CALL(device_management_service_,
                 CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION, _))
         .Times(AtMost(1))
         .WillOnce(device_management_service_.CreateAsyncJob(&register_job));
     EXPECT_CALL(device_management_service_,
                 StartJob(dm_protocol::kValueRequestRegister, _, _, _, _, _))
         .Times(AtMost(1))
         .WillOnce(
             DoAll(SaveArg<4>(&client_id_), SaveArg<5>(&register_request_)));
     DeviceCloudPolicyInitializer::AllowedDeviceModes modes;
     modes[DEVICE_MODE_ENTERPRISE] = true;
 
     chromeos::OwnerSettingsServiceChromeOS* owner_settings_service =
         chromeos::OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
             profile_.get());
     ASSERT_TRUE(owner_settings_service);
 
     EnrollmentConfig enrollment_config;
     enrollment_config.mode = EnrollmentConfig::MODE_MANUAL;
     initializer_->StartEnrollment(
-        management_mode_, &device_management_service_, owner_settings_service,
-        enrollment_config, "auth token", modes,
+        &device_management_service_, enrollment_config, "auth token", modes,
         base::Bind(&DeviceCloudPolicyManagerChromeOSEnrollmentTest::Done,
                    base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
     Mock::VerifyAndClearExpectations(&device_management_service_);
     AllowUninterestingRemoteCommandFetches();
 
     if (done_)
       return;
 
     // Process registration.
@@ skipping 58 matching lines @@
       net::TestURLFetcher* url_fetcher = url_fetcher_factory_.GetFetcherByID(
           gaia::GaiaOAuthClient::kUrlFetcherId);
       ASSERT_TRUE(url_fetcher);
       url_fetcher->SetMaxRetriesOn5xx(0);
       url_fetcher->set_status(net::URLRequestStatus());
       url_fetcher->set_response_code(url_fetcher_response_code_);
       url_fetcher->SetResponseString(url_fetcher_response_string_);
       url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
     }
 
-    if (management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED)
-      FlushDeviceSettings();
-    else
-      base::RunLoop().RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     if (done_)
       return;
 
     // Process robot refresh token store.
     chromeos::DeviceOAuth2TokenService* token_service =
         chromeos::DeviceOAuth2TokenServiceFactory::Get();
     EXPECT_TRUE(token_service->RefreshTokenIsAvailable(
         token_service->GetRobotAccountId()));
 
     // Process policy store.
     device_settings_test_helper_.set_store_result(store_result_);
     device_settings_test_helper_.FlushStore();
     EXPECT_EQ(device_policy_.GetBlob(),
               device_settings_test_helper_.policy_blob());
 
     if (done_)
       return;
 
     // Key installation and policy load.
     device_settings_test_helper_.set_policy_blob(loaded_blob_);
     owner_key_util_->SetPublicKeyFromPrivateKey(
         *device_policy_.GetNewSigningKey());
     ReloadDeviceSettings();
   }
 
-  ManagementMode management_mode_;
-
   DeviceManagementStatus register_status_;
   em::DeviceManagementResponse register_response_;
 
   DeviceManagementStatus policy_fetch_status_;
   em::DeviceManagementResponse policy_fetch_response_;
 
   DeviceManagementStatus robot_auth_fetch_status_;
   em::DeviceManagementResponse robot_auth_fetch_response_;
 
   bool store_result_;
@@ skipping 91 matching lines @@
 }
 
 TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentTest, LoadError) {
   loaded_blob_.clear();
   RunTest();
   ExpectFailedEnrollment(EnrollmentStatus::STATUS_STORE_ERROR);
   EXPECT_EQ(CloudPolicyStore::STATUS_LOAD_ERROR,
             status_.store_status());
 }
 
-TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentTest,
-       SuccessfulConsumerManagementEnrollment) {
-  management_mode_ = MANAGEMENT_MODE_CONSUMER_MANAGED;
-  owner_key_util_->SetPrivateKey(device_policy_.GetNewSigningKey());
-  InitOwner(AccountId::FromUserEmail(device_policy_.policy_data().username()),
-            true);
-  FlushDeviceSettings();
-
-  device_policy_.policy_data().set_management_mode(em::PolicyData::LOCAL_OWNER);
-  device_policy_.Build();
-  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
-  ReloadDeviceSettings();
-
-  RunTest();
-  ExpectSuccessfulEnrollment();
-}
-
 TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentTest, UnregisterSucceeds) {
   // Enroll first.
   RunTest();
   ExpectSuccessfulEnrollment();
 
   // Set up mock objects for the upcoming unregistration job.
   em::DeviceManagementResponse response;
   response.mutable_unregister_response();
   EXPECT_CALL(device_management_service_,
               CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION, _))
@@ skipping 37 matching lines @@
 
 TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentBlankSystemSaltTest,
        RobotRefreshSaveFailed) {
   // Without the system salt, the robot token can't be stored.
   RunTest();
   ExpectFailedEnrollment(EnrollmentStatus::STATUS_ROBOT_REFRESH_STORE_FAILED);
 }
 
 }  // namespace
 }  // namespace policy