// Copyright 2014 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 "extensions/common/features/simple_feature.h"

#include <stddef.h>

#include <memory>
#include <string>
#include <vector>

#include "base/command_line.h"
#include "base/cxx17_backports.h"
#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "base/test/scoped_command_line.h"
#include "base/test/scoped_feature_list.h"
#include "base/values.h"
#include "content/public/test/test_utils.h"
#include "extensions/common/extension_builder.h"
#include "extensions/common/features/complex_feature.h"
#include "extensions/common/features/feature_channel.h"
#include "extensions/common/features/feature_flags.h"
#include "extensions/common/features/feature_session_type.h"
#include "extensions/common/manifest.h"
#include "extensions/common/manifest_handlers/background_info.h"
#include "extensions/common/switches.h"
#include "extensions/common/value_builder.h"
#include "testing/gtest/include/gtest/gtest.h"

using extensions::mojom::ManifestLocation;
using version_info::Channel;

namespace extensions {

namespace {

struct IsAvailableTestData {
  std::string extension_id;
  Manifest::Type extension_type;
  ManifestLocation location;
  Feature::Platform platform;
  int manifest_version;
  Feature::AvailabilityResult expected_result;
};

struct FeatureSessionTypeTestData {
  std::string desc;
  Feature::AvailabilityResult expected_availability;
  mojom::FeatureSessionType current_session_type;
  std::initializer_list<mojom::FeatureSessionType> feature_session_types;
};

Feature::AvailabilityResult IsAvailableInChannel(Channel channel_for_feature,
                                                 Channel channel_for_testing) {
  ScopedCurrentChannel current_channel(channel_for_testing);

  SimpleFeature feature;
  feature.set_channel(channel_for_feature);
  return feature
      .IsAvailableToManifest(
          HashedExtensionId(std::string(32, 'a')), Manifest::TYPE_UNKNOWN,
          ManifestLocation::kInvalidLocation, -1, Feature::GetCurrentPlatform())
      .result();
}

}  // namespace

class SimpleFeatureTest : public testing::Test {
 protected:
  SimpleFeatureTest() : current_channel_(Channel::UNKNOWN) {}
  bool LocationIsAvailable(SimpleFeature::Location feature_location,
                           ManifestLocation manifest_location) {
    SimpleFeature feature;
    feature.set_location(feature_location);
    Feature::AvailabilityResult availability_result =
        feature
            .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                   manifest_location, -1,
                                   Feature::UNSPECIFIED_PLATFORM)
            .result();
    return availability_result == Feature::IS_AVAILABLE;
  }

 private:
  ScopedCurrentChannel current_channel_;
  DISALLOW_COPY_AND_ASSIGN(SimpleFeatureTest);
};

TEST_F(SimpleFeatureTest, IsAvailableNullCase) {
  const IsAvailableTestData tests[] = {
      {"", Manifest::TYPE_UNKNOWN, ManifestLocation::kInvalidLocation,
       Feature::UNSPECIFIED_PLATFORM, -1, Feature::IS_AVAILABLE},
      {"random-extension", Manifest::TYPE_UNKNOWN,
       ManifestLocation::kInvalidLocation, Feature::UNSPECIFIED_PLATFORM, -1,
       Feature::IS_AVAILABLE},
      {"", Manifest::TYPE_LEGACY_PACKAGED_APP,
       ManifestLocation::kInvalidLocation, Feature::UNSPECIFIED_PLATFORM, -1,
       Feature::IS_AVAILABLE},
      {"", Manifest::TYPE_UNKNOWN, ManifestLocation::kInvalidLocation,
       Feature::UNSPECIFIED_PLATFORM, -1, Feature::IS_AVAILABLE},
      {"", Manifest::TYPE_UNKNOWN, ManifestLocation::kComponent,
       Feature::UNSPECIFIED_PLATFORM, -1, Feature::IS_AVAILABLE},
      {"", Manifest::TYPE_UNKNOWN, ManifestLocation::kInvalidLocation,
       Feature::CHROMEOS_PLATFORM, -1, Feature::IS_AVAILABLE},
      {"", Manifest::TYPE_UNKNOWN, ManifestLocation::kInvalidLocation,
       Feature::UNSPECIFIED_PLATFORM, 25, Feature::IS_AVAILABLE}};

  SimpleFeature feature;
  for (size_t i = 0; i < base::size(tests); ++i) {
    const IsAvailableTestData& test = tests[i];
    EXPECT_EQ(test.expected_result,
              feature
                  .IsAvailableToManifest(HashedExtensionId(test.extension_id),
                                         test.extension_type, test.location,
                                         test.manifest_version, test.platform)
                  .result());
  }
}

TEST_F(SimpleFeatureTest, Allowlist) {
  const HashedExtensionId kIdFoo("fooabbbbccccddddeeeeffffgggghhhh");
  const HashedExtensionId kIdBar("barabbbbccccddddeeeeffffgggghhhh");
  const HashedExtensionId kIdBaz("bazabbbbccccddddeeeeffffgggghhhh");
  SimpleFeature feature;
  feature.set_allowlist({kIdFoo.value().c_str(), kIdBar.value().c_str()});

  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToManifest(kIdFoo, Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToManifest(kIdBar, Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());

  EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST,
            feature
                .IsAvailableToManifest(kIdBaz, Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_EQ(
      Feature::NOT_FOUND_IN_WHITELIST,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, -1,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());

  feature.set_extension_types({Manifest::TYPE_LEGACY_PACKAGED_APP});
  EXPECT_EQ(
      Feature::NOT_FOUND_IN_WHITELIST,
      feature
          .IsAvailableToManifest(kIdBaz, Manifest::TYPE_LEGACY_PACKAGED_APP,
                                 ManifestLocation::kInvalidLocation, -1,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
}

TEST_F(SimpleFeatureTest, HashedIdAllowlist) {
  // echo -n "fooabbbbccccddddeeeeffffgggghhhh" |
  //   sha1sum | tr '[:lower:]' '[:upper:]'
  const std::string kIdFoo("fooabbbbccccddddeeeeffffgggghhhh");
  const std::string kIdFooHashed("55BC7228A0D502A2A48C9BB16B07062A01E62897");
  SimpleFeature feature;

  feature.set_allowlist({kIdFooHashed.c_str()});

  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToManifest(HashedExtensionId(kIdFoo),
                                       Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_NE(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToManifest(HashedExtensionId(kIdFooHashed),
                                       Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST,
            feature
                .IsAvailableToManifest(
                    HashedExtensionId("slightlytoooolongforanextensionid"),
                    Manifest::TYPE_UNKNOWN, ManifestLocation::kInvalidLocation,
                    -1, Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST,
            feature
                .IsAvailableToManifest(
                    HashedExtensionId("tooshortforanextensionid"),
                    Manifest::TYPE_UNKNOWN, ManifestLocation::kInvalidLocation,
                    -1, Feature::UNSPECIFIED_PLATFORM)
                .result());
}

TEST_F(SimpleFeatureTest, Blocklist) {
  const HashedExtensionId kIdFoo("fooabbbbccccddddeeeeffffgggghhhh");
  const HashedExtensionId kIdBar("barabbbbccccddddeeeeffffgggghhhh");
  const HashedExtensionId kIdBaz("bazabbbbccccddddeeeeffffgggghhhh");
  SimpleFeature feature;
  feature.set_blocklist({kIdFoo.value().c_str(), kIdBar.value().c_str()});

  EXPECT_EQ(Feature::FOUND_IN_BLACKLIST,
            feature
                .IsAvailableToManifest(kIdFoo, Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_EQ(Feature::FOUND_IN_BLACKLIST,
            feature
                .IsAvailableToManifest(kIdBar, Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());

  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToManifest(kIdBaz, Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_EQ(
      Feature::IS_AVAILABLE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, -1,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
}

TEST_F(SimpleFeatureTest, HashedIdBlocklist) {
  // echo -n "fooabbbbccccddddeeeeffffgggghhhh" |
  //   sha1sum | tr '[:lower:]' '[:upper:]'
  const std::string kIdFoo("fooabbbbccccddddeeeeffffgggghhhh");
  const std::string kIdFooHashed("55BC7228A0D502A2A48C9BB16B07062A01E62897");
  SimpleFeature feature;

  feature.set_blocklist({kIdFooHashed.c_str()});

  EXPECT_EQ(Feature::FOUND_IN_BLACKLIST,
            feature
                .IsAvailableToManifest(HashedExtensionId(kIdFoo),
                                       Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_NE(Feature::FOUND_IN_BLACKLIST,
            feature
                .IsAvailableToManifest(HashedExtensionId(kIdFooHashed),
                                       Manifest::TYPE_UNKNOWN,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToManifest(
                    HashedExtensionId("slightlytoooolongforanextensionid"),
                    Manifest::TYPE_UNKNOWN, ManifestLocation::kInvalidLocation,
                    -1, Feature::UNSPECIFIED_PLATFORM)
                .result());
  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToManifest(
                    HashedExtensionId("tooshortforanextensionid"),
                    Manifest::TYPE_UNKNOWN, ManifestLocation::kInvalidLocation,
                    -1, Feature::UNSPECIFIED_PLATFORM)
                .result());
}

TEST_F(SimpleFeatureTest, PackageType) {
  SimpleFeature feature;
  feature.set_extension_types(
      {Manifest::TYPE_EXTENSION, Manifest::TYPE_LEGACY_PACKAGED_APP});

  EXPECT_EQ(
      Feature::IS_AVAILABLE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_EXTENSION,
                                 ManifestLocation::kInvalidLocation, -1,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToManifest(HashedExtensionId(),
                                       Manifest::TYPE_LEGACY_PACKAGED_APP,
                                       ManifestLocation::kInvalidLocation, -1,
                                       Feature::UNSPECIFIED_PLATFORM)
                .result());

  EXPECT_EQ(
      Feature::INVALID_TYPE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, -1,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
  EXPECT_EQ(
      Feature::INVALID_TYPE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_THEME,
                                 ManifestLocation::kInvalidLocation, -1,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
}

TEST_F(SimpleFeatureTest, Context) {
  SimpleFeature feature;
  feature.set_name("somefeature");
  feature.set_contexts({Feature::BLESSED_EXTENSION_CONTEXT});
  feature.set_extension_types({Manifest::TYPE_LEGACY_PACKAGED_APP});
  feature.set_platforms({Feature::CHROMEOS_PLATFORM});
  feature.set_min_manifest_version(21);
  feature.set_max_manifest_version(25);

  base::DictionaryValue manifest;
  manifest.SetString("name", "test");
  manifest.SetString("version", "1");
  manifest.SetInteger("manifest_version", 21);
  manifest.SetString("app.launch.local_path", "foo.html");

  std::string error;
  scoped_refptr<const Extension> extension(
      Extension::Create(base::FilePath(), ManifestLocation::kInternal, manifest,
                        Extension::NO_FLAGS, &error));
  EXPECT_EQ("", error);
  ASSERT_TRUE(extension.get());

  feature.set_allowlist({"monkey"});
  EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToContext(
      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
      Feature::CHROMEOS_PLATFORM).result());
  feature.set_allowlist({});

  feature.set_extension_types({Manifest::TYPE_THEME});
  {
    Feature::Availability availability = feature.IsAvailableToContext(
        extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
        Feature::CHROMEOS_PLATFORM);
    EXPECT_EQ(Feature::INVALID_TYPE, availability.result());
    EXPECT_EQ("'somefeature' is only allowed for themes, "
              "but this is a legacy packaged app.",
              availability.message());
  }

  feature.set_extension_types({Manifest::TYPE_LEGACY_PACKAGED_APP});
  feature.set_contexts(
      {Feature::UNBLESSED_EXTENSION_CONTEXT, Feature::CONTENT_SCRIPT_CONTEXT});
  {
    Feature::Availability availability = feature.IsAvailableToContext(
        extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
        Feature::CHROMEOS_PLATFORM);
    EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
    EXPECT_EQ("'somefeature' is only allowed to run in extension iframes and "
              "content scripts, but this is a privileged page",
              availability.message());
  }

  feature.set_contexts({Feature::UNBLESSED_EXTENSION_CONTEXT,
                        Feature::CONTENT_SCRIPT_CONTEXT,
                        Feature::WEB_PAGE_CONTEXT});
  {
    Feature::Availability availability = feature.IsAvailableToContext(
        extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
        Feature::CHROMEOS_PLATFORM);
    EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
    EXPECT_EQ("'somefeature' is only allowed to run in extension iframes, "
              "content scripts, and web pages, but this is a privileged page",
              availability.message());
  }

  {
    SimpleFeature other_feature;
    other_feature.set_location(SimpleFeature::COMPONENT_LOCATION);
    EXPECT_EQ(Feature::INVALID_LOCATION,
              other_feature
                  .IsAvailableToContext(extension.get(),
                                        Feature::BLESSED_EXTENSION_CONTEXT,
                                        Feature::CHROMEOS_PLATFORM)
                  .result());
  }

  feature.set_contexts({Feature::BLESSED_EXTENSION_CONTEXT});
  EXPECT_EQ(Feature::INVALID_PLATFORM, feature.IsAvailableToContext(
      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
      Feature::UNSPECIFIED_PLATFORM).result());

  {
    Feature::Availability availability = feature.IsAvailableToContext(
        extension.get(), Feature::LOCK_SCREEN_EXTENSION_CONTEXT,
        Feature::CHROMEOS_PLATFORM);
    EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
    EXPECT_EQ(
        "'somefeature' is only allowed to run in privileged pages, "
        "but this is a lock screen app",
        availability.message());
  }

  feature.set_contexts({Feature::LOCK_SCREEN_EXTENSION_CONTEXT});

  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToContext(extension.get(),
                                      Feature::LOCK_SCREEN_EXTENSION_CONTEXT,
                                      Feature::CHROMEOS_PLATFORM)
                .result());

  feature.set_min_manifest_version(22);
  EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION, feature.IsAvailableToContext(
      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
      Feature::CHROMEOS_PLATFORM).result());
  feature.set_min_manifest_version(21);

  feature.set_max_manifest_version(18);
  EXPECT_EQ(Feature::INVALID_MAX_MANIFEST_VERSION, feature.IsAvailableToContext(
      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
      Feature::CHROMEOS_PLATFORM).result());
  feature.set_max_manifest_version(25);
}

TEST_F(SimpleFeatureTest, SessionType) {
  base::DictionaryValue manifest;
  manifest.SetString("name", "test");
  manifest.SetString("version", "1");
  manifest.SetInteger("manifest_version", 2);
  manifest.SetString("app.launch.local_path", "foo.html");

  std::string error;
  scoped_refptr<const Extension> extension(
      Extension::Create(base::FilePath(), ManifestLocation::kInternal, manifest,
                        Extension::NO_FLAGS, &error));
  EXPECT_EQ("", error);
  ASSERT_TRUE(extension.get());

  const FeatureSessionTypeTestData kTestData[] = {
      {"kiosk_feature in kiosk session",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kKiosk,
       {mojom::FeatureSessionType::kKiosk}},
      {"kiosk feature in regular session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kRegular,
       {mojom::FeatureSessionType::kKiosk}},
      {"kiosk feature in unknown session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kUnknown,
       {mojom::FeatureSessionType::kKiosk}},
      {"kiosk feature in initial session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kInitial,
       {mojom::FeatureSessionType::kKiosk}},
      {"non kiosk feature in kiosk session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kKiosk,
       {mojom::FeatureSessionType::kRegular}},
      {"non kiosk feature in regular session",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kRegular,
       {mojom::FeatureSessionType::kRegular}},
      {"non kiosk feature in unknown session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kUnknown,
       {mojom::FeatureSessionType::kRegular}},
      {"non kiosk feature in initial session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kInitial,
       {mojom::FeatureSessionType::kRegular}},
      {"session agnostic feature in kiosk session",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kKiosk,
       {}},
      {"session agnostic feature in auto-launched kiosk session",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kAutolaunchedKiosk,
       {}},
      {"session agnostic feature in regular session",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kRegular,
       {}},
      {"session agnostic feature in unknown session",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kUnknown,
       {}},
      {"feature with multiple session types",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kRegular,
       {mojom::FeatureSessionType::kRegular,
        mojom::FeatureSessionType::kKiosk}},
      {"feature with multiple session types in unknown session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kUnknown,
       {mojom::FeatureSessionType::kRegular,
        mojom::FeatureSessionType::kKiosk}},
      {"feature with multiple session types in initial session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kInitial,
       {mojom::FeatureSessionType::kRegular,
        mojom::FeatureSessionType::kKiosk}},
      {"feature with auto-launched kiosk session type in regular session",
       Feature::INVALID_SESSION_TYPE,
       mojom::FeatureSessionType::kAutolaunchedKiosk,
       {mojom::FeatureSessionType::kRegular}},
      {"feature with auto-launched kiosk session type in auto-launched kiosk",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kAutolaunchedKiosk,
       {mojom::FeatureSessionType::kAutolaunchedKiosk}},
      {"feature with kiosk session type in auto-launched kiosk session",
       Feature::IS_AVAILABLE,
       mojom::FeatureSessionType::kAutolaunchedKiosk,
       {mojom::FeatureSessionType::kKiosk}}};

  for (size_t i = 0; i < base::size(kTestData); ++i) {
    std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> current_session(
        ScopedCurrentFeatureSessionType(kTestData[i].current_session_type));

    SimpleFeature feature;
    feature.set_session_types(kTestData[i].feature_session_types);

    EXPECT_EQ(kTestData[i].expected_availability,
              feature
                  .IsAvailableToContext(extension.get(),
                                        Feature::BLESSED_EXTENSION_CONTEXT,
                                        Feature::CHROMEOS_PLATFORM)
                  .result())
        << "Failed test '" << kTestData[i].desc << "'.";

    EXPECT_EQ(kTestData[i].expected_availability,
              feature
                  .IsAvailableToManifest(extension->hashed_id(),
                                         Manifest::TYPE_UNKNOWN,
                                         ManifestLocation::kInvalidLocation, -1,
                                         Feature::CHROMEOS_PLATFORM)
                  .result())
        << "Failed test '" << kTestData[i].desc << "'.";
  }
}

TEST_F(SimpleFeatureTest, Location) {
  // Component extensions can access any location.
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,
                                  ManifestLocation::kComponent));
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::EXTERNAL_COMPONENT_LOCATION,
                                  ManifestLocation::kComponent));
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::POLICY_LOCATION,
                                  ManifestLocation::kComponent));
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::UNPACKED_LOCATION,
                                  ManifestLocation::kComponent));

  // Only component extensions can access the "component" location.
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,
                                   ManifestLocation::kInvalidLocation));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,
                                   ManifestLocation::kUnpacked));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,
                                   ManifestLocation::kExternalComponent));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,
                                   ManifestLocation::kExternalPrefDownload));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,
                                   ManifestLocation::kExternalPolicy));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,
                                   ManifestLocation::kExternalPolicyDownload));

  // Policy extensions can access the "policy" location.
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::POLICY_LOCATION,
                                  ManifestLocation::kExternalPolicy));
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::POLICY_LOCATION,
                                  ManifestLocation::kExternalPolicyDownload));

  // Non-policy (except component) extensions cannot access policy.
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::POLICY_LOCATION,
                                   ManifestLocation::kExternalComponent));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::POLICY_LOCATION,
                                   ManifestLocation::kInvalidLocation));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::POLICY_LOCATION,
                                   ManifestLocation::kUnpacked));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::POLICY_LOCATION,
                                   ManifestLocation::kExternalPrefDownload));

  // External component extensions can access the "external_component"
  // location.
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::EXTERNAL_COMPONENT_LOCATION,
                                  ManifestLocation::kExternalComponent));

  // Only unpacked and command line extensions can access the "unpacked"
  // location.
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::UNPACKED_LOCATION,
                                  ManifestLocation::kUnpacked));
  EXPECT_TRUE(LocationIsAvailable(SimpleFeature::UNPACKED_LOCATION,
                                  ManifestLocation::kCommandLine));
  EXPECT_FALSE(LocationIsAvailable(SimpleFeature::UNPACKED_LOCATION,
                                   ManifestLocation::kInternal));
}

TEST_F(SimpleFeatureTest, Platform) {
  SimpleFeature feature;
  feature.set_platforms({Feature::CHROMEOS_PLATFORM});
  EXPECT_EQ(
      Feature::IS_AVAILABLE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, -1,
                                 Feature::CHROMEOS_PLATFORM)
          .result());
  EXPECT_EQ(
      Feature::INVALID_PLATFORM,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, -1,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
}

TEST_F(SimpleFeatureTest, ManifestVersion) {
  SimpleFeature feature;
  feature.set_min_manifest_version(5);

  EXPECT_EQ(
      Feature::INVALID_MIN_MANIFEST_VERSION,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, 0,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
  EXPECT_EQ(
      Feature::INVALID_MIN_MANIFEST_VERSION,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, 4,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());

  EXPECT_EQ(
      Feature::IS_AVAILABLE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, 5,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
  EXPECT_EQ(
      Feature::IS_AVAILABLE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, 10,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());

  feature.set_max_manifest_version(8);

  EXPECT_EQ(
      Feature::INVALID_MAX_MANIFEST_VERSION,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, 10,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
  EXPECT_EQ(
      Feature::IS_AVAILABLE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, 8,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
  EXPECT_EQ(
      Feature::IS_AVAILABLE,
      feature
          .IsAvailableToManifest(HashedExtensionId(), Manifest::TYPE_UNKNOWN,
                                 ManifestLocation::kInvalidLocation, 7,
                                 Feature::UNSPECIFIED_PLATFORM)
          .result());
}

TEST_F(SimpleFeatureTest, CommandLineSwitch) {
  SimpleFeature feature;
  feature.set_command_line_switch("laser-beams");
  {
    EXPECT_EQ(Feature::MISSING_COMMAND_LINE_SWITCH,
              feature.IsAvailableToEnvironment().result());
  }
  {
    base::test::ScopedCommandLine scoped_command_line;
    scoped_command_line.GetProcessCommandLine()->AppendSwitch("laser-beams");
    EXPECT_EQ(Feature::MISSING_COMMAND_LINE_SWITCH,
              feature.IsAvailableToEnvironment().result());
  }
  {
    base::test::ScopedCommandLine scoped_command_line;
    scoped_command_line.GetProcessCommandLine()->AppendSwitch(
        "enable-laser-beams");
    EXPECT_EQ(Feature::IS_AVAILABLE,
              feature.IsAvailableToEnvironment().result());
  }
  {
    base::test::ScopedCommandLine scoped_command_line;
    scoped_command_line.GetProcessCommandLine()->AppendSwitch(
        "disable-laser-beams");
    EXPECT_EQ(Feature::MISSING_COMMAND_LINE_SWITCH,
              feature.IsAvailableToEnvironment().result());
  }
  {
    base::test::ScopedCommandLine scoped_command_line;
    scoped_command_line.GetProcessCommandLine()->AppendSwitch("laser-beams=1");
    EXPECT_EQ(Feature::IS_AVAILABLE,
              feature.IsAvailableToEnvironment().result());
  }
  {
    base::test::ScopedCommandLine scoped_command_line;
    scoped_command_line.GetProcessCommandLine()->AppendSwitch("laser-beams=0");
    EXPECT_EQ(Feature::MISSING_COMMAND_LINE_SWITCH,
              feature.IsAvailableToEnvironment().result());
  }
}

TEST_F(SimpleFeatureTest, FeatureFlags) {
  const std::vector<base::Feature> features(
      {{"stub_feature_1", base::FEATURE_ENABLED_BY_DEFAULT},
       {"stub_feature_2", base::FEATURE_DISABLED_BY_DEFAULT}});
  auto scoped_feature_override =
      CreateScopedFeatureFlagsOverrideForTesting(&features);

  SimpleFeature simple_feature_1;
  simple_feature_1.set_feature_flag(features[0].name);
  EXPECT_EQ(Feature::IS_AVAILABLE,
            simple_feature_1.IsAvailableToEnvironment().result());

  SimpleFeature simple_feature_2;
  simple_feature_2.set_feature_flag(features[1].name);
  EXPECT_EQ(Feature::FEATURE_FLAG_DISABLED,
            simple_feature_2.IsAvailableToEnvironment().result());

  // Ensure we take any base::Feature overrides into account.
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures({features[1]} /* enabled_features */,
                                       {features[0]} /* disabled_features */);
  EXPECT_EQ(Feature::FEATURE_FLAG_DISABLED,
            simple_feature_1.IsAvailableToEnvironment().result());
  EXPECT_EQ(Feature::IS_AVAILABLE,
            simple_feature_2.IsAvailableToEnvironment().result());
}

TEST_F(SimpleFeatureTest, IsIdInArray) {
  EXPECT_FALSE(SimpleFeature::IsIdInArray("", {}, 0));
  EXPECT_FALSE(SimpleFeature::IsIdInArray(
      "bbbbccccdddddddddeeeeeeffffgghhh", {}, 0));

  const char* const kIdArray[] = {
    "bbbbccccdddddddddeeeeeeffffgghhh",
    // aaaabbbbccccddddeeeeffffgggghhhh
    "9A0417016F345C934A1A88F55CA17C05014EEEBA"
  };
  EXPECT_FALSE(SimpleFeature::IsIdInArray("", kIdArray, base::size(kIdArray)));
  EXPECT_FALSE(SimpleFeature::IsIdInArray("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                          kIdArray, base::size(kIdArray)));
  EXPECT_TRUE(SimpleFeature::IsIdInArray("bbbbccccdddddddddeeeeeeffffgghhh",
                                         kIdArray, base::size(kIdArray)));
  EXPECT_TRUE(SimpleFeature::IsIdInArray("aaaabbbbccccddddeeeeffffgggghhhh",
                                         kIdArray, base::size(kIdArray)));
}

// Tests that all combinations of feature channel and Chrome channel correctly
// compute feature availability.
TEST_F(SimpleFeatureTest, SupportedChannel) {
  // stable supported.
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::STABLE, Channel::UNKNOWN));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::STABLE, Channel::CANARY));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::STABLE, Channel::DEV));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::STABLE, Channel::BETA));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::STABLE, Channel::STABLE));

  // beta supported.
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::BETA, Channel::UNKNOWN));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::BETA, Channel::CANARY));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::BETA, Channel::DEV));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::BETA, Channel::BETA));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::BETA, Channel::STABLE));

  // dev supported.
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::DEV, Channel::UNKNOWN));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::DEV, Channel::CANARY));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::DEV, Channel::DEV));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::DEV, Channel::BETA));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::DEV, Channel::STABLE));

  // canary supported.
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::CANARY, Channel::UNKNOWN));
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::CANARY, Channel::CANARY));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::CANARY, Channel::DEV));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::CANARY, Channel::BETA));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::CANARY, Channel::STABLE));

  // trunk supported.
  EXPECT_EQ(Feature::IS_AVAILABLE,
            IsAvailableInChannel(Channel::UNKNOWN, Channel::UNKNOWN));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::UNKNOWN, Channel::CANARY));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::UNKNOWN, Channel::DEV));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::UNKNOWN, Channel::BETA));
  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
            IsAvailableInChannel(Channel::UNKNOWN, Channel::STABLE));
}

// Tests simple feature availability across channels.
TEST_F(SimpleFeatureTest, SimpleFeatureAvailability) {
  std::unique_ptr<ComplexFeature> complex_feature;
  {
    std::unique_ptr<SimpleFeature> feature1(new SimpleFeature());
    feature1->set_channel(Channel::BETA);
    feature1->set_extension_types({Manifest::TYPE_EXTENSION});
    std::unique_ptr<SimpleFeature> feature2(new SimpleFeature());
    feature2->set_channel(Channel::BETA);
    feature2->set_extension_types({Manifest::TYPE_LEGACY_PACKAGED_APP});
    std::vector<Feature*> list;
    list.push_back(feature1.release());
    list.push_back(feature2.release());
    complex_feature = std::make_unique<ComplexFeature>(&list);
  }

  Feature* feature = static_cast<Feature*>(complex_feature.get());
  // Make sure both rules are applied correctly.

  const HashedExtensionId kId1(std::string(32, 'a'));
  const HashedExtensionId kId2(std::string(32, 'b'));
  {
    ScopedCurrentChannel current_channel(Channel::BETA);
    EXPECT_EQ(Feature::IS_AVAILABLE,
              feature
                  ->IsAvailableToManifest(kId1, Manifest::TYPE_EXTENSION,
                                          ManifestLocation::kInvalidLocation,
                                          Feature::UNSPECIFIED_PLATFORM)
                  .result());
    EXPECT_EQ(
        Feature::IS_AVAILABLE,
        feature
            ->IsAvailableToManifest(kId2, Manifest::TYPE_LEGACY_PACKAGED_APP,
                                    ManifestLocation::kInvalidLocation,
                                    Feature::UNSPECIFIED_PLATFORM)
            .result());
  }
  {
    ScopedCurrentChannel current_channel(Channel::STABLE);
    EXPECT_NE(Feature::IS_AVAILABLE,
              feature
                  ->IsAvailableToManifest(kId1, Manifest::TYPE_EXTENSION,
                                          ManifestLocation::kInvalidLocation,
                                          Feature::UNSPECIFIED_PLATFORM)
                  .result());
    EXPECT_NE(
        Feature::IS_AVAILABLE,
        feature
            ->IsAvailableToManifest(kId2, Manifest::TYPE_LEGACY_PACKAGED_APP,
                                    ManifestLocation::kInvalidLocation,
                                    Feature::UNSPECIFIED_PLATFORM)
            .result());
  }
}

// Tests complex feature availability across channels.
TEST_F(SimpleFeatureTest, ComplexFeatureAvailability) {
  std::unique_ptr<ComplexFeature> complex_feature;
  {
    // Rule: "extension", channel trunk.
    std::unique_ptr<SimpleFeature> feature1(new SimpleFeature());
    feature1->set_channel(Channel::UNKNOWN);
    feature1->set_extension_types({Manifest::TYPE_EXTENSION});
    std::unique_ptr<SimpleFeature> feature2(new SimpleFeature());
    // Rule: "legacy_packaged_app", channel stable.
    feature2->set_channel(Channel::STABLE);
    feature2->set_extension_types({Manifest::TYPE_LEGACY_PACKAGED_APP});
    std::vector<Feature*> list;
    list.push_back(feature1.release());
    list.push_back(feature2.release());
    complex_feature = std::make_unique<ComplexFeature>(&list);
  }

  const HashedExtensionId kId1(std::string(32, 'a'));
  const HashedExtensionId kId2(std::string(32, 'b'));
  Feature* feature = static_cast<Feature*>(complex_feature.get());
  {
    ScopedCurrentChannel current_channel(Channel::UNKNOWN);
    EXPECT_EQ(Feature::IS_AVAILABLE,
              feature
                  ->IsAvailableToManifest(kId1, Manifest::TYPE_EXTENSION,
                                          ManifestLocation::kInvalidLocation,
                                          Feature::UNSPECIFIED_PLATFORM)
                  .result());
  }
  {
    ScopedCurrentChannel current_channel(Channel::BETA);
    EXPECT_EQ(
        Feature::IS_AVAILABLE,
        feature
            ->IsAvailableToManifest(kId2, Manifest::TYPE_LEGACY_PACKAGED_APP,
                                    ManifestLocation::kInvalidLocation,
                                    Feature::UNSPECIFIED_PLATFORM)
            .result());
  }
  {
    ScopedCurrentChannel current_channel(Channel::BETA);
    EXPECT_NE(Feature::IS_AVAILABLE,
              feature
                  ->IsAvailableToManifest(kId1, Manifest::TYPE_EXTENSION,
                                          ManifestLocation::kInvalidLocation,
                                          Feature::UNSPECIFIED_PLATFORM)
                  .result());
  }
}

TEST(SimpleFeatureUnitTest, TestChannelsWithoutExtension) {
  // Create a webui feature available on trunk.
  SimpleFeature feature;
  feature.set_contexts({Feature::WEBUI_CONTEXT});
  feature.set_matches({content::GetWebUIURLString("settings/*").c_str()});
  feature.set_channel(version_info::Channel::UNKNOWN);

  const GURL kAllowlistedUrl(content::GetWebUIURL("settings/foo"));
  const GURL kOtherUrl("https://example.com");

  {
    // It should be available on trunk.
    ScopedCurrentChannel current_channel(Channel::UNKNOWN);
    EXPECT_EQ(Feature::IS_AVAILABLE,
              feature
                  .IsAvailableToContext(nullptr, Feature::WEBUI_CONTEXT,
                                        kAllowlistedUrl)
                  .result());
  }
  {
    // It should be unavailable on beta.
    ScopedCurrentChannel current_channel(Channel::BETA);
    EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
              feature
                  .IsAvailableToContext(nullptr, Feature::WEBUI_CONTEXT,
                                        kAllowlistedUrl)
                  .result());
  }
}

TEST(SimpleFeatureUnitTest, TestAvailableToEnvironment) {
  {
    // Test with no environment restrictions, but with other restrictions. The
    // result should always be available.
    SimpleFeature feature;
    feature.set_min_manifest_version(2);
    feature.set_extension_types({Manifest::TYPE_EXTENSION});
    feature.set_contexts({Feature::BLESSED_EXTENSION_CONTEXT});
    EXPECT_EQ(Feature::IS_AVAILABLE,
              feature.IsAvailableToEnvironment().result());
  }

  {
    // Test with channel restrictions.
    SimpleFeature feature;
    feature.set_channel(Channel::BETA);
    {
      ScopedCurrentChannel current_channel(Channel::BETA);
      EXPECT_EQ(Feature::IS_AVAILABLE,
                feature.IsAvailableToEnvironment().result());
    }
    {
      ScopedCurrentChannel current_channel(Channel::STABLE);
      EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
                feature.IsAvailableToEnvironment().result());
    }
  }

  {
    // Test with command-line restrictions.
    const char kFakeSwitch[] = "some-fake-switch";
    SimpleFeature feature;
    feature.set_command_line_switch(kFakeSwitch);

    EXPECT_EQ(Feature::MISSING_COMMAND_LINE_SWITCH,
              feature.IsAvailableToEnvironment().result());
    {
      base::test::ScopedCommandLine command_line;
      command_line.GetProcessCommandLine()->AppendSwitch(
          base::StringPrintf("enable-%s", kFakeSwitch));
      EXPECT_EQ(Feature::IS_AVAILABLE,
                feature.IsAvailableToEnvironment().result());
    }
  }

  // Note: if we wanted, we could add a ScopedCurrentPlatform() and add
  // platform-test restrictions?
}

TEST(SimpleFeatureUnitTest, TestExperimentalExtensionApisSwitch) {
  ScopedCurrentChannel current_channel(Channel::STABLE);

  auto test_feature = []() {
    SimpleFeature feature;
    feature.set_channel(version_info::Channel::UNKNOWN);
    return feature.IsAvailableToEnvironment().result();
  };

  {
    base::test::ScopedCommandLine scoped_command_line;
    EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, test_feature());
  }

  {
    base::test::ScopedCommandLine scoped_command_line;
    scoped_command_line.GetProcessCommandLine()->AppendSwitch(
        switches::kEnableExperimentalExtensionApis);
    EXPECT_EQ(Feature::IS_AVAILABLE, test_feature());
  }
}

TEST(SimpleFeatureUnitTest, DisallowForServiceWorkers) {
  SimpleFeature feature;
  feature.set_name("somefeature");
  feature.set_contexts({Feature::BLESSED_EXTENSION_CONTEXT});
  feature.set_extension_types({Manifest::TYPE_EXTENSION});

  auto extension = ExtensionBuilder("test")
                       .SetBackgroundContext(
                           ExtensionBuilder::BackgroundContext::SERVICE_WORKER)
                       .Build();
  ASSERT_TRUE(extension.get());
  EXPECT_TRUE(BackgroundInfo::IsServiceWorkerBased(extension.get()));

  // Expect the feature is allowed, since the default is to allow.
  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToContext(
                    extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
                    extension->GetResourceURL(
                        ExtensionBuilder::kServiceWorkerScriptFile),
                    Feature::CHROMEOS_PLATFORM)
                .result());

  // Check with a different script file, which should return available,
  // since it's not a service worker context.
  EXPECT_EQ(Feature::IS_AVAILABLE,
            feature
                .IsAvailableToContext(extension.get(),
                                      Feature::BLESSED_EXTENSION_CONTEXT,
                                      extension->GetResourceURL("other.js"),
                                      Feature::CHROMEOS_PLATFORM)
                .result());

  // Disable the feature for service workers. The feature should be disallowed.
  feature.set_disallow_for_service_workers(true);
  EXPECT_EQ(Feature::INVALID_CONTEXT,
            feature
                .IsAvailableToContext(
                    extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
                    extension->GetResourceURL(
                        ExtensionBuilder::kServiceWorkerScriptFile),
                    Feature::CHROMEOS_PLATFORM)
                .result());
}

}  // namespace extensions