Policy implementation for encryptfs to ext4 migration strategy

components/arc/arc_util_unittest.cc

 // Copyright 2017 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 "components/arc/arc_util.h"
 
 #include <memory>
 #include <string>
 
 #include "ash/shared/app_types.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/scoped_feature_list.h"
+#include "chrome/common/pref_names.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/pref_service.h"
+#include "components/prefs/pref_service_factory.h"
+#include "components/prefs/testing_pref_store.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/fake_user_manager.h"
 #include "components/user_manager/user.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 
 namespace arc {
 namespace {
 
+// The constants matching the values from DeviceEcryptfsMigrationStrategy
+// policy.
+constexpr int kMigrationAllowedPolicyUnset = 0;
+constexpr int kMigrationAllowedPolicyDisabled = 1;
+constexpr int kMigrationAllowedPolicyEnabled = 2;
+
 // If an instance is created, based on the value passed to the consturctor,
 // EnableARC feature is enabled/disabled in the scope.
 class ScopedArcFeature {
  public:
   explicit ScopedArcFeature(bool enabled) {
     constexpr char kArcFeatureName[] = "EnableARC";
     if (enabled) {
       feature_list.InitFromCommandLine(kArcFeatureName, std::string());
     } else {
       feature_list.InitFromCommandLine(std::string(), kArcFeatureName);
@@ skipping 196 matching lines @@
                                  "test@test.com-hash", false);
   const user_manager::User* ephemeral_user = fake_user_manager.GetActiveUser();
   ASSERT_TRUE(ephemeral_user);
   ASSERT_TRUE(fake_user_manager.IsUserCryptohomeDataEphemeral(
       ephemeral_user->GetAccountId()));
 
   // Ephemeral user is not allowed for ARC.
   EXPECT_FALSE(IsArcAllowedForUser(ephemeral_user));
 }
 
+TEST_F(ArcUtilTest, IsMigrationAllowedDeviceOwned) {
+  ResetGlobalDataForTesting();
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+  command_line->InitFromArgv({"", "--initial-encryption-ecryptfs"});
+  SetHasDeviceOwner();
+  EXPECT_TRUE(IsArcAvailable());
+}
+
+TEST_F(ArcUtilTest, IsMigrationAllowedUserNotInitialized) {
+  ResetGlobalDataForTesting();
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+  command_line->InitFromArgv({"", "--initial-encryption-ecryptfs"});
+  EXPECT_FALSE(IsArcAvailable());
+}
+
+TEST_F(ArcUtilTest, IsMigrationAllowedNoPolicy) {
+  ResetGlobalDataForTesting();
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+  command_line->InitFromArgv({"", "--initial-encryption-ecryptfs"});
+  user_manager::FakeUserManager fake_user_manager;
+
+  PrefServiceFactory pref_service_factory;
+  scoped_refptr<TestingPrefStore> pref_store(new TestingPrefStore);
+  pref_service_factory.set_user_prefs(pref_store.get());
+  scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple);
+  std::unique_ptr<PrefService> pref_service(
+      pref_service_factory.Create(registry.get()));
+
+  fake_user_manager.SetLocalState(pref_service.get());
+  ScopedUserManager scoped_user_manager(&fake_user_manager);
+  EXPECT_FALSE(IsArcAvailable());
+}
+
+TEST_F(ArcUtilTest, IsMigrationAllowedPolicyAllowed) {
+  ResetGlobalDataForTesting();
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+  command_line->InitFromArgv({"", "--initial-encryption-ecryptfs"});
+  user_manager::FakeUserManager fake_user_manager;
+
+  PrefServiceFactory pref_service_factory;
+  scoped_refptr<TestingPrefStore> managed_pref_store(new TestingPrefStore);
+  scoped_refptr<TestingPrefStore> user_pref_store(new TestingPrefStore);
+  managed_pref_store->SetInteger(prefs::kDeviceEcryptfsMigrationStrategy,
+                                 kMigrationAllowedPolicyEnabled);
+  pref_service_factory.set_managed_prefs(managed_pref_store.get());
+  pref_service_factory.set_user_prefs(user_pref_store.get());
+  scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple);
+  registry->RegisterIntegerPref(prefs::kDeviceEcryptfsMigrationStrategy,
+                                kMigrationAllowedPolicyUnset);
+  std::unique_ptr<PrefService> pref_service(
+      pref_service_factory.Create(registry.get()));
+  pref_service->SetInteger(prefs::kDeviceEcryptfsMigrationStrategy,
+                           kMigrationAllowedPolicyEnabled);
+
+  fake_user_manager.SetLocalState(pref_service.get());
+  ScopedUserManager scoped_user_manager(&fake_user_manager);
+  EXPECT_TRUE(IsArcAvailable());
+}
+
+TEST_F(ArcUtilTest, IsMigrationAllowedPolicyDisabled) {
+  ResetGlobalDataForTesting();
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+  command_line->InitFromArgv({"", "--initial-encryption-ecryptfs"});
+  user_manager::FakeUserManager fake_user_manager;
+
+  PrefServiceFactory pref_service_factory;
+  scoped_refptr<TestingPrefStore> managed_pref_store(new TestingPrefStore);
+  scoped_refptr<TestingPrefStore> user_pref_store(new TestingPrefStore);
+  managed_pref_store->SetInteger(prefs::kDeviceEcryptfsMigrationStrategy,
+                                 kMigrationAllowedPolicyDisabled);
+  pref_service_factory.set_managed_prefs(managed_pref_store.get());
+  pref_service_factory.set_user_prefs(user_pref_store.get());
+  scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple);
+  registry->RegisterIntegerPref(prefs::kDeviceEcryptfsMigrationStrategy,
+                                kMigrationAllowedPolicyUnset);
+  std::unique_ptr<PrefService> pref_service(
+      pref_service_factory.Create(registry.get()));
+  pref_service->SetInteger(prefs::kDeviceEcryptfsMigrationStrategy,
+                           kMigrationAllowedPolicyDisabled);
+
+  fake_user_manager.SetLocalState(pref_service.get());
+  ScopedUserManager scoped_user_manager(&fake_user_manager);
+  EXPECT_FALSE(IsArcAvailable());
+}
+
 }  // namespace
 }  // namespace arc