arc: Consolidate IsArcAllowedForUser logic

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 "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/scoped_feature_list.h"
+#include "components/signin/core/account_id/account_id.h"
+#include "components/user_manager/user.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace arc {
 namespace {
 
 // 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);
     }
   }
   ~ScopedArcFeature() = default;
 
  private:
   base::test::ScopedFeatureList feature_list;
   DISALLOW_COPY_AND_ASSIGN(ScopedArcFeature);
 };
 
+// Fake user that can be created with a specified type.
+class FakeUser : public user_manager::User {
+ public:
+  explicit FakeUser(user_manager::UserType user_type)
+      : User(AccountId::FromUserEmail("user@test.com")),
+        user_type_(user_type) {}
+  ~FakeUser() override = default;
+
+  // user_manager::User:
+  user_manager::UserType GetType() const override { return user_type_; }
+
+ private:
+  const user_manager::UserType user_type_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeUser);
+};
+
 using ArcUtilTest = testing::Test;
 
 TEST_F(ArcUtilTest, IsArcAvailable_None) {
   auto* command_line = base::CommandLine::ForCurrentProcess();
 
   command_line->InitFromArgv({"", "--arc-availability=none"});
   EXPECT_FALSE(IsArcAvailable());
 
   // If --arc-availability flag is set to "none", even if Finch experiment is
   // turned on, ARC cannot be used.
@@ skipping 108 matching lines @@
 
 TEST_F(ArcUtilTest, IsArcOptInVerificationDisabled) {
   auto* command_line = base::CommandLine::ForCurrentProcess();
   command_line->InitFromArgv({""});
   EXPECT_FALSE(IsArcOptInVerificationDisabled());
 
   command_line->InitFromArgv({"", "--disable-arc-opt-in-verification"});
   EXPECT_TRUE(IsArcOptInVerificationDisabled());
 }
 
+TEST_F(ArcUtilTest, IsArcAllowedForUser) {
+  struct {
+    user_manager::UserType user_type;
+    bool expected_allowed;
+  } const kTestCases[] = {
+      {user_manager::USER_TYPE_REGULAR, true},
+      {user_manager::USER_TYPE_GUEST, false},
+      {user_manager::USER_TYPE_PUBLIC_ACCOUNT, false},
+      {user_manager::USER_TYPE_SUPERVISED, false},
+      {user_manager::USER_TYPE_KIOSK_APP, false},
+      {user_manager::USER_TYPE_CHILD, true},
+      {user_manager::USER_TYPE_ARC_KIOSK_APP, false},
+      {user_manager::USER_TYPE_ACTIVE_DIRECTORY, false},
+  };
+  for (const auto& test_case : kTestCases) {
+    const FakeUser user(test_case.user_type);
+    EXPECT_EQ(test_case.expected_allowed, IsArcAllowedForUser(&user))
+        << "User type=" << test_case.user_type;
+  }
+
+  // Active directory users are allowed when ARC is supported for active
+  // directory managed devices.
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+  command_line->InitFromArgv(
+      {"", "--arc-availability=officially-supported-with-active-directory"});
+  const FakeUser active_directory_user(
+      user_manager::USER_TYPE_ACTIVE_DIRECTORY);
+  EXPECT_TRUE(IsArcAllowedForUser(&active_directory_user));
+}
+
 }  // namespace
 }  // namespace arc