Add ManagementMode enum and GetManagementMode().

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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "chromeos/dbus/dbus_client_implementation_type.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "chromeos/system/fake_statistics_provider.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
+#include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/mock_device_management_service.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/schema_registry.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "policy/policy_constants.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 274 matching lines @@
     : public DeviceCloudPolicyManagerChromeOSTest {
  public:
   void Done(EnrollmentStatus status) {
     status_ = status;
     done_ = true;
   }
 
  protected:
   DeviceCloudPolicyManagerChromeOSEnrollmentTest()
       : is_auto_enrollment_(false),
-        management_mode_(em::PolicyData::ENTERPRISE_MANAGED),
+        management_mode_(MANAGEMENT_MODE_ENTERPRISE_MANAGED),
         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) {}
 
   virtual void SetUp() override {
     DeviceCloudPolicyManagerChromeOSTest::SetUp();
 
@@ skipping 28 matching lines @@
     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_ != em::PolicyData::CONSUMER_MANAGED) {
+    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();
     }
   }
 
   void RunTest() {
     // Trigger enrollment.
     MockDeviceManagementJob* register_job = NULL;
@@ skipping 75 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_ == em::PolicyData::CONSUMER_MANAGED)
+    if (management_mode_ == MANAGEMENT_MODE_CONSUMER_MANAGED)
       FlushDeviceSettings();
     else
       base::RunLoop().RunUntilIdle();
 
     if (done_)
       return;
 
     // Process robot refresh token store.
     chromeos::DeviceOAuth2TokenService* token_service =
         chromeos::DeviceOAuth2TokenServiceFactory::Get();
@@ skipping 10 matching lines @@
       return;
 
     // Key installation and policy load.
     device_settings_test_helper_.set_policy_blob(loaded_blob_);
     owner_key_util_->SetPublicKeyFromPrivateKey(
         *device_policy_.GetNewSigningKey());
     ReloadDeviceSettings();
   }
 
   bool is_auto_enrollment_;
-  em::PolicyData::ManagementMode management_mode_;
+  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_;
 
@@ skipping 101 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_ = em::PolicyData::CONSUMER_MANAGED;
+  management_mode_ = MANAGEMENT_MODE_CONSUMER_MANAGED;
   owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
   InitOwner(device_policy_.policy_data().username(), true);
   FlushDeviceSettings();
 
   RunTest();
   ExpectSuccessfulEnrollment();
 }
 
 // A subclass that runs with a blank system salt.
 class DeviceCloudPolicyManagerChromeOSEnrollmentBlankSystemSaltTest
     : public DeviceCloudPolicyManagerChromeOSEnrollmentTest {
  protected:
   DeviceCloudPolicyManagerChromeOSEnrollmentBlankSystemSaltTest() {
     // Set up a FakeCryptohomeClient with a blank system salt.
     fake_cryptohome_client_->set_system_salt(std::vector<uint8>());
   }
 };
 
 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