Add device disabling to OOBE flow

chrome/browser/chromeos/policy/auto_enrollment_client_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/auto_enrollment_client.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
@@ skipping 17 matching lines @@
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 const char kStateKey[] = "state_key";
 const char kStateKeyHash[] =
     "\xde\x74\xcd\xf0\x03\x36\x8c\x21\x79\xba\xb1\x5a\xc4\x32\xee\xd6"
     "\xb3\x4a\x5e\xff\x73\x7e\x92\xd9\xf8\x6e\x72\x44\xd0\x97\xc3\xe6";
+const char kDisabledMessage[] = "This device has been disabled.";
 
 using ::testing::InSequence;
 using ::testing::Mock;
 using ::testing::SaveArg;
 using ::testing::_;
 
 class AutoEnrollmentClientTest : public testing::Test {
  protected:
   AutoEnrollmentClientTest()
       : scoped_testing_local_state_(
@@ skipping 61 matching lines @@
       enrollment_response->mutable_hash()->Add()->assign(kStateKeyHash,
                                                          crypto::kSHA256Length);
     }
     EXPECT_CALL(*service_,
                 CreateJob(DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT, _))
         .WillOnce(service_->SucceedJob(response));
   }
 
   void ServerWillSendState(
       const std::string& management_domain,
-      em::DeviceStateRetrievalResponse::RestoreMode restore_mode) {
+      em::DeviceStateRetrievalResponse::RestoreMode restore_mode,
+      scoped_ptr<std::string> device_disabled_message) {
     em::DeviceManagementResponse response;
     em::DeviceStateRetrievalResponse* state_response =
         response.mutable_device_state_retrieval_response();
     state_response->set_restore_mode(restore_mode);
     state_response->set_management_domain(management_domain);
+    if (device_disabled_message) {
+      em::DisabledState* disabled_state =
+          state_response->mutable_disabled_state();
+      disabled_state->set_message(*device_disabled_message);
+    }
     EXPECT_CALL(
         *service_,
         CreateJob(DeviceManagementRequestJob::TYPE_DEVICE_STATE_RETRIEVAL, _))
         .WillOnce(service_->SucceedJob(response));
   }
 
   void ServerWillReplyAsync(MockDeviceManagementJob** job) {
     EXPECT_CALL(*service_,
                 CreateJob(DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT, _))
         .WillOnce(service_->CreateAsyncJob(job));
@@ skipping 11 matching lines @@
         local_state_->GetUserPref(prefs::kShouldAutoEnroll)));
     EXPECT_TRUE(base::Value::Equals(
         &value_power_limit,
         local_state_->GetUserPref(prefs::kAutoEnrollmentPowerLimit)));
   }
 
   bool HasServerBackedState() {
     return local_state_->GetUserPref(prefs::kServerBackedDeviceState);
   }
 
-  void VerifyServerBackedState(const std::string& expected_management_domain,
-                               const std::string& expected_restore_mode) {
+  void VerifyServerBackedState(
+      const std::string& expected_management_domain,
+      const std::string& expected_restore_mode,
+      scoped_ptr<std::string> expected_disabled_message) {
     const base::Value* state =
         local_state_->GetUserPref(prefs::kServerBackedDeviceState);
     ASSERT_TRUE(state);
     const base::DictionaryValue* state_dict = nullptr;
     ASSERT_TRUE(state->GetAsDictionary(&state_dict));
 
     std::string actual_management_domain;
     EXPECT_TRUE(state_dict->GetString(kDeviceStateManagementDomain,
                                       &actual_management_domain));
     EXPECT_EQ(expected_management_domain, actual_management_domain);
 
-    std::string actual_restore_mode;
-    EXPECT_TRUE(state_dict->GetString(kDeviceStateRestoreMode,
-                                      &actual_restore_mode));
-    EXPECT_EQ(expected_restore_mode, actual_restore_mode);
+    if (!expected_restore_mode.empty()) {
+      std::string actual_restore_mode;
+      EXPECT_TRUE(state_dict->GetString(kDeviceStateRestoreMode,
+                                        &actual_restore_mode));
+      EXPECT_EQ(expected_restore_mode, actual_restore_mode);
+    } else {
+      EXPECT_FALSE(state_dict->HasKey(kDeviceStateRestoreMode));
+    }
+
+    const bool expected_disabled_state = expected_disabled_message;
+    bool actual_disabled_state = false;
+    EXPECT_TRUE(state_dict->GetBoolean(kDeviceStateDisabled,
+                                       &actual_disabled_state));
+    EXPECT_EQ(expected_disabled_state, actual_disabled_state);
+
+    if (expected_disabled_message) {
+      std::string actual_disabled_message;
+      EXPECT_TRUE(state_dict->GetString(kDeviceStateDisabledMessage,
+                                        &actual_disabled_message));
+      EXPECT_EQ(*expected_disabled_message, actual_disabled_message);
+    } else {
+      EXPECT_FALSE(state_dict->HasKey(kDeviceStateDisabledMessage));
+    }
   }
 
   const em::DeviceAutoEnrollmentRequest& auto_enrollment_request() {
     return last_request_.auto_enrollment_request();
   }
 
   content::TestBrowserThreadBundle browser_threads_;
   ScopedTestingLocalState scoped_testing_local_state_;
   TestingPrefServiceSimple* local_state_;
   scoped_ptr<MockDeviceManagementService> service_;
@@ skipping 53 matching lines @@
   EXPECT_FALSE(HasCachedDecision());
   EXPECT_FALSE(HasServerBackedState());
 }
 
 TEST_F(AutoEnrollmentClientTest, AskForLess) {
   InSequence sequence;
   ServerWillReply(8, false, false);
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
 }
 
 TEST_F(AutoEnrollmentClientTest, AskForSame) {
   InSequence sequence;
   ServerWillReply(16, false, false);
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
 }
 
 TEST_F(AutoEnrollmentClientTest, AskForSameTwice) {
   InSequence sequence;
   ServerWillReply(16, false, false);
   ServerWillReply(16, false, false);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
   EXPECT_FALSE(HasCachedDecision());
   EXPECT_FALSE(HasServerBackedState());
@@ skipping 27 matching lines @@
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
   VerifyCachedResult(false, 8);
   EXPECT_FALSE(HasServerBackedState());
 
   // Network changes don't trigger retries after obtaining a response from
   // the server.
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 }
 
-TEST_F(AutoEnrollmentClientTest, EnterpriseDevice) {
+TEST_F(AutoEnrollmentClientTest, ForcedReEnrollment) {
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      nullptr);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          nullptr);
 
   // Network changes don't trigger retries after obtaining a response from
   // the server.
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 }
 
+TEST_F(AutoEnrollmentClientTest, RequestedReEnrollment) {
+  ServerWillReply(-1, true, true);
+  ServerWillSendState(
+      "example.com",
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_REQUESTED,
+      nullptr);
+  client_->Start();
+  EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
+  VerifyCachedResult(true, 8);
+  VerifyServerBackedState("example.com",
+                          kDeviceStateRestoreModeReEnrollmentRequested,
+                          nullptr);
+}
+
+TEST_F(AutoEnrollmentClientTest, DeviceDisabled) {
+  ServerWillReply(-1, true, true);
+  ServerWillSendState(
+      "example.com",
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_NONE,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
+  client_->Start();
+  EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
+  VerifyCachedResult(true, 8);
+  VerifyServerBackedState("example.com",
+                          "",
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
+}
+
 TEST_F(AutoEnrollmentClientTest, NoSerial) {
   CreateClient("", true, 4, 8);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
   EXPECT_FALSE(HasCachedDecision());
   EXPECT_FALSE(HasServerBackedState());
 }
 
 TEST_F(AutoEnrollmentClientTest, NoBitsUploaded) {
   CreateClient(kStateKey, true, 0, 0);
@@ skipping 25 matching lines @@
   }
 }
 
 TEST_F(AutoEnrollmentClientTest, MoreThan32BitsUploaded) {
   CreateClient(kStateKey, true, 10, 37);
   InSequence sequence;
   ServerWillReply(GG_INT64_C(1) << 37, false, false);
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 37);
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
 }
 
 TEST_F(AutoEnrollmentClientTest, ReuseCachedDecision) {
   EXPECT_CALL(*service_, CreateJob(_, _)).Times(0);
   local_state_->SetUserPref(prefs::kShouldAutoEnroll,
                             new base::FundamentalValue(true));
   local_state_->SetUserPref(prefs::kAutoEnrollmentPowerLimit,
                             new base::FundamentalValue(8));
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
   AutoEnrollmentClient::CancelAutoEnrollment();
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
   EXPECT_FALSE(HasServerBackedState());
 }
 
 TEST_F(AutoEnrollmentClientTest, RetryIfPowerLargerThanCached) {
   local_state_->SetUserPref(prefs::kShouldAutoEnroll,
                             new base::FundamentalValue(false));
   local_state_->SetUserPref(prefs::kAutoEnrollmentPowerLimit,
                             new base::FundamentalValue(8));
   CreateClient(kStateKey, true, 5, 10);
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
 }
 
 TEST_F(AutoEnrollmentClientTest, NetworkChangeRetryAfterErrors) {
   ServerWillFail(DM_STATUS_TEMPORARY_UNAVAILABLE);
   client_->Start();
   // Don't invoke the callback if there was a network failure.
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
   EXPECT_FALSE(HasCachedDecision());
   EXPECT_FALSE(HasServerBackedState());
 
   // The client doesn't retry if no new connection became available.
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
   EXPECT_FALSE(HasCachedDecision());
   EXPECT_FALSE(HasServerBackedState());
 
   // Retry once the network is back.
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   EXPECT_TRUE(HasCachedDecision());
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
 
   // Subsequent network changes don't trigger retries.
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_NONE);
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   EXPECT_TRUE(HasCachedDecision());
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
 }
 
 TEST_F(AutoEnrollmentClientTest, CancelAndDeleteSoonWithPendingRequest) {
   MockDeviceManagementJob* job = NULL;
   ServerWillReplyAsync(&job);
   EXPECT_FALSE(job);
   client_->Start();
   ASSERT_TRUE(job);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_PENDING, state_);
 
@@ skipping 37 matching lines @@
 
   // Network changes that have been posted before are also ignored:
   client->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_PENDING, state_);
 }
 
 TEST_F(AutoEnrollmentClientTest, CancelAndDeleteSoonAfterCompletion) {
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
 
   // The client will delete itself immediately if there are no pending
   // requests.
   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
   client_.release()->CancelAndDeleteSoon();
   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 }
 
 TEST_F(AutoEnrollmentClientTest, CancelAndDeleteSoonAfterNetworkFailure) {
   ServerWillFail(DM_STATUS_TEMPORARY_UNAVAILABLE);
@@ skipping 23 matching lines @@
   InSequence sequence;
   // The default client uploads 4 bits. Make the server ask for 5.
   ServerWillReply(1 << 5, false, false);
   EXPECT_CALL(*service_, StartJob(_, _, _, _, _, _, _));
   // Then reply with a valid response and include the hash.
   ServerWillReply(-1, true, true);
   EXPECT_CALL(*service_, StartJob(_, _, _, _, _, _, _));
   // State download triggers.
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED);
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
+      make_scoped_ptr(new std::string(kDisabledMessage)));
   EXPECT_CALL(*service_, StartJob(_, _, _, _, _, _, _));
 
   // Trigger a network change event.
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   EXPECT_TRUE(HasCachedDecision());
   VerifyServerBackedState("example.com",
-                          kDeviceStateRestoreModeReEnrollmentEnforced);
+                          kDeviceStateRestoreModeReEnrollmentEnforced,
+                          make_scoped_ptr(new std::string(kDisabledMessage)));
   Mock::VerifyAndClearExpectations(service_.get());
 }
 
 TEST_F(AutoEnrollmentClientTest, NoDeviceStateRetrieval) {
   CreateClient(kStateKey, false, 4, 8);
   ServerWillReply(-1, true, true);
   EXPECT_CALL(*service_,
               CreateJob(DeviceManagementRequestJob::TYPE_DEVICE_STATE_RETRIEVAL,
                         _)).Times(0);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   EXPECT_FALSE(HasServerBackedState());
 }
 
 }  // namespace
 }  // namespace policy