Add RESTORE_MODE_DISABLED to RestoreMode

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 100 matching lines @@
                                                          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,
-      scoped_ptr<std::string> device_disabled_message) {
+      const 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);
-    }
+    state_response->mutable_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 14 matching lines @@
         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,
-      scoped_ptr<std::string> expected_disabled_message) {
+      const 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);
 
     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));
-    }
+    std::string actual_disabled_message;
+    EXPECT_TRUE(state_dict->GetString(kDeviceStateDisabledMessage,
+                                      &actual_disabled_message));
+    EXPECT_EQ(expected_disabled_message, actual_disabled_message);
   }
 
   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 54 matching lines @@
   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,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentEnforced,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          kDisabledMessage);
 }
 
 TEST_F(AutoEnrollmentClientTest, AskForSame) {
   InSequence sequence;
   ServerWillReply(16, false, false);
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentEnforced,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          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 32 matching lines @@
   // the server.
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 }
 
 TEST_F(AutoEnrollmentClientTest, ForcedReEnrollment) {
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
-      nullptr);
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentEnforced,
-                          nullptr);
+                          kDisabledMessage);
 
   // 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);
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentRequested,
-                          nullptr);
+                          kDisabledMessage);
 }
 
 TEST_F(AutoEnrollmentClientTest, DeviceDisabled) {
   ServerWillReply(-1, true, true);
   ServerWillSendState(
       "example.com",
-      em::DeviceStateRetrievalResponse::RESTORE_MODE_NONE,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      em::DeviceStateRetrievalResponse::RESTORE_MODE_DISABLED,
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
   VerifyCachedResult(true, 8);
   VerifyServerBackedState("example.com",
-                          "",
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          kDeviceStateRestoreModeDisabled,
+                          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());
 }
 
@@ skipping 28 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,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyCachedResult(true, 37);
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentEnforced,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          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,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentEnforced,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          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,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentEnforced,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          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,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      kDisabledMessage);
   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   EXPECT_TRUE(HasCachedDecision());
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentEnforced,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          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,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          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 38 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,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      kDisabledMessage);
   client_->Start();
   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
   VerifyServerBackedState("example.com",
                           kDeviceStateRestoreModeReEnrollmentEnforced,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          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 24 matching lines @@
   // 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,
-      make_scoped_ptr(new std::string(kDisabledMessage)));
+      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,
-                          make_scoped_ptr(new std::string(kDisabledMessage)));
+                          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