DeviceCloudPolicyStore should load consumer policies so that other classes may function normally.

chrome/browser/chromeos/policy/device_cloud_policy_store_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_store_chromeos.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/policy/enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/test/base/scoped_testing_local_state.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chromeos/cryptohome/cryptohome_util.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
+#include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "content/public/test/test_utils.h"
 #include "policy/policy_constants.h"
+#include "policy/proto/device_management_backend.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace em = enterprise_management;
+
 namespace policy {
 
 namespace {
 
 void CopyLockResult(base::RunLoop* loop,
                     EnterpriseInstallAttributes::LockResult* out,
                     EnterpriseInstallAttributes::LockResult result) {
   *out = result;
   loop->Quit();
 }
@@ skipping 24 matching lines @@
     EnterpriseInstallAttributes::LockResult result;
     install_attributes_->LockDevice(
         PolicyBuilder::kFakeUsername,
         DEVICE_MODE_ENTERPRISE,
         PolicyBuilder::kFakeDeviceId,
         base::Bind(&CopyLockResult, &loop, &result));
     loop.Run();
     ASSERT_EQ(EnterpriseInstallAttributes::LOCK_SUCCESS, result);
   }
 
+  void SetManagementModeAndLoad(em::PolicyData::ManagementMode mode) {
+    device_policy_.policy_data().set_management_mode(mode);
+    device_policy_.Build();
+    scoped_ptr<em::PolicyFetchResponse> policy(new em::PolicyFetchResponse);
+    policy->MergeFrom(device_policy_.policy());
+    device_settings_service_.Store(policy.Pass(), base::Bind(&base::DoNothing));

[Mattias Nissler (ping if slow), 2014/12/05 12:28:37]

If the intention here is to test a load (and the function name suggests that),
then this shouldn't call Store(), but just stage the policy to be loaded, i.e.
  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
device_settings_service_.Load();
FlushDeviceSettings();

[davidyu, 2014/12/05 13:54:10]

Done.

+    FlushDeviceSettings();
+    EXPECT_EQ(chromeos::DeviceSettingsService::STORE_SUCCESS,
+              device_settings_service_.status());
+  }
+
   void ExpectFailure(CloudPolicyStore::Status expected_status) {
     EXPECT_EQ(expected_status, store_->status());
     EXPECT_TRUE(store_->is_initialized());
     EXPECT_FALSE(store_->has_policy());
     EXPECT_FALSE(store_->is_managed());
   }
 
+  void ExpectSuccessWithManagementMode(ManagementMode mode) {
+    EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status());
+    EXPECT_TRUE(store_->is_initialized());
+    EXPECT_TRUE(store_->has_policy());
+    EXPECT_TRUE(store_->is_managed());
+    EXPECT_TRUE(store_->policy());
+    EXPECT_TRUE(store_->policy_map().empty());
+    if (store_->policy())
+      EXPECT_EQ(mode, GetManagementMode(*store_->policy()));
+  }
+
   void ExpectSuccess() {
     EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status());
     EXPECT_TRUE(store_->is_initialized());
     EXPECT_TRUE(store_->has_policy());
     EXPECT_TRUE(store_->is_managed());
     EXPECT_TRUE(store_->policy());
     base::FundamentalValue expected(false);
     EXPECT_TRUE(
         base::Value::Equals(&expected,
                             store_->policy_map().GetValue(
@@ skipping 58 matching lines @@
   FlushDeviceSettings();
   ExpectFailure(CloudPolicyStore::STATUS_BAD_STATE);
 }
 
 TEST_F(DeviceCloudPolicyStoreChromeOSTest, LoadSuccess) {
   store_->Load();
   FlushDeviceSettings();
   ExpectSuccess();
 }
 
+TEST_F(DeviceCloudPolicyStoreChromeOSTest, UpdateFromServiceOnConsumerDevices) {
+  ResetToNonEnterprise();
+
+  SetManagementModeAndLoad(em::PolicyData::CONSUMER_MANAGED);
+  ExpectSuccessWithManagementMode(MANAGEMENT_MODE_CONSUMER_MANAGED);
+
+  // Unenroll from consumer management.
+  SetManagementModeAndLoad(em::PolicyData::LOCAL_OWNER);
+  ExpectSuccessWithManagementMode(MANAGEMENT_MODE_LOCAL_OWNER);
+}
+
 TEST_F(DeviceCloudPolicyStoreChromeOSTest, StoreSuccess) {
   PrepareExistingPolicy();
   store_->Store(device_policy_.policy());
   FlushDeviceSettings();
   ExpectSuccess();
 }
 
 TEST_F(DeviceCloudPolicyStoreChromeOSTest, StoreNoSignature) {
   PrepareExistingPolicy();
   device_policy_.policy().clear_policy_data_signature();
@@ skipping 106 matching lines @@
 
 TEST_F(DeviceCloudPolicyStoreChromeOSTest, InstallInitialPolicyNotEnterprise) {
   PrepareNewSigningKey();
   ResetToNonEnterprise();
   store_->InstallInitialPolicy(device_policy_.policy());
   FlushDeviceSettings();
   ExpectFailure(CloudPolicyStore::STATUS_BAD_STATE);
 }
 
 }  // namespace policy