// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "extensions/common/features/complex_feature.h"

#include <array>
#include <string>
#include <string_view>
#include <utility>

#include "base/test/bind.h"
#include "content/public/common/content_features.h"
#include "extensions/common/features/feature.h"
#include "extensions/common/features/simple_feature.h"
#include "extensions/common/features/simple_feature_test_constants.h"
#include "extensions/common/manifest.h"
#include "extensions/common/mojom/context_type.mojom.h"
#include "extensions/test/test_context_data.h"
#include "testing/gtest/include/gtest/gtest.h"

using extensions::mojom::ManifestLocation;

namespace extensions {

namespace {

// Single-element backing arrays for the StaticSpan setters, which bind only to
// static storage.
constexpr auto kPrivilegedExtensionOnly = std::to_array<mojom::ContextType>(
    {mojom::ContextType::kPrivilegedExtension});
constexpr auto kExtensionOnly =
    std::to_array<Manifest::Type>({Manifest::Type::kExtension});
constexpr auto kLegacyPackagedAppOnly =
    std::to_array<Manifest::Type>({Manifest::Type::kLegacyPackagedApp});

}  // namespace

TEST(ComplexFeatureTest, MultipleRulesAllowlist) {
  const HashedExtensionId kIdFoo{ExtensionId(kFooId)};
  const HashedExtensionId kIdBar{ExtensionId(kBarId)};
  static constexpr auto kFooAllowlist =
      std::to_array<std::string_view>({kHashedFooId});
  static constexpr auto kBarAllowlist =
      std::to_array<std::string_view>({kHashedBarId});
  std::vector<Feature*> features;

  {
    // Rule: "extension", allowlist "foo".
    std::unique_ptr<SimpleFeature> simple_feature(new SimpleFeature());
    simple_feature->set_allowlist(StaticSpan(kFooAllowlist));
    simple_feature->set_extension_types(StaticSpan(kExtensionOnly));
    features.push_back(simple_feature.release());
  }

  {
    // Rule: "legacy_packaged_app", allowlist "bar".
    std::unique_ptr<SimpleFeature> simple_feature(new SimpleFeature());
    simple_feature->set_allowlist(StaticSpan(kBarAllowlist));
    simple_feature->set_extension_types(StaticSpan(kLegacyPackagedAppOnly));
    features.push_back(simple_feature.release());
  }

  std::unique_ptr<ComplexFeature> feature(new ComplexFeature(&features));

  // Test match 1st rule.
  EXPECT_EQ(Feature::AvailabilityResult::kIsAvailable,
            feature
                ->IsAvailableToManifest(kIdFoo, Manifest::Type::kExtension,
                                        ManifestLocation::kInvalidLocation,
                                        Feature::UNSPECIFIED_PLATFORM,
                                        Feature::GetCurrentPlatform(),
                                        kUnspecifiedContextId)
                .result());

  // Test match 2nd rule.
  EXPECT_EQ(
      Feature::AvailabilityResult::kIsAvailable,
      feature
          ->IsAvailableToManifest(
              kIdBar, Manifest::Type::kLegacyPackagedApp,
              ManifestLocation::kInvalidLocation, Feature::UNSPECIFIED_PLATFORM,
              Feature::GetCurrentPlatform(), kUnspecifiedContextId)
          .result());

  // Test allowlist with wrong extension type.
  EXPECT_NE(Feature::AvailabilityResult::kIsAvailable,
            feature
                ->IsAvailableToManifest(kIdBar, Manifest::Type::kExtension,
                                        ManifestLocation::kInvalidLocation,
                                        Feature::UNSPECIFIED_PLATFORM,
                                        Feature::GetCurrentPlatform(),
                                        kUnspecifiedContextId)
                .result());
  EXPECT_NE(
      Feature::AvailabilityResult::kIsAvailable,
      feature
          ->IsAvailableToManifest(
              kIdFoo, Manifest::Type::kLegacyPackagedApp,
              ManifestLocation::kInvalidLocation, Feature::UNSPECIFIED_PLATFORM,
              Feature::GetCurrentPlatform(), kUnspecifiedContextId)
          .result());
}

// Tests that dependencies are correctly checked.
TEST(ComplexFeatureTest, Dependencies) {
  std::vector<Feature*> features;

  {
    // Rule which depends on an extension-only feature
    // (content_security_policy).
    std::unique_ptr<SimpleFeature> simple_feature(new SimpleFeature());
    static constexpr auto kCspDependency =
        std::to_array<std::string_view>({"manifest:content_security_policy"});
    simple_feature->set_dependencies(StaticSpan(kCspDependency));
    features.push_back(simple_feature.release());
  }

  {
    // Rule which depends on an platform-app-only feature (videoCapture).
    std::unique_ptr<SimpleFeature> simple_feature(new SimpleFeature());
    static constexpr auto kVideoCaptureDependency =
        std::to_array<std::string_view>({"permission:videoCapture"});
    simple_feature->set_dependencies(StaticSpan(kVideoCaptureDependency));
    features.push_back(simple_feature.release());
  }

  std::unique_ptr<ComplexFeature> feature(new ComplexFeature(&features));

  // Available to extensions because of the content_security_policy rule.
  EXPECT_EQ(Feature::AvailabilityResult::kIsAvailable,
            feature
                ->IsAvailableToManifest(HashedExtensionId(std::string(32, 'a')),
                                        Manifest::Type::kExtension,
                                        ManifestLocation::kInvalidLocation,
                                        Feature::UNSPECIFIED_PLATFORM,
                                        Feature::GetCurrentPlatform(),
                                        kUnspecifiedContextId)
                .result());

  // Available to platform apps because of the videoCapture rule.
  EXPECT_EQ(Feature::AvailabilityResult::kIsAvailable,
            feature
                ->IsAvailableToManifest(HashedExtensionId(std::string(32, 'b')),
                                        Manifest::Type::kPlatformApp,
                                        ManifestLocation::kInvalidLocation,
                                        Feature::UNSPECIFIED_PLATFORM,
                                        Feature::GetCurrentPlatform(),
                                        kUnspecifiedContextId)
                .result());

  // Not available to hosted apps.
  EXPECT_EQ(Feature::AvailabilityResult::kInvalidType,
            feature
                ->IsAvailableToManifest(HashedExtensionId(std::string(32, 'c')),
                                        Manifest::Type::kHostedApp,
                                        ManifestLocation::kInvalidLocation,
                                        Feature::UNSPECIFIED_PLATFORM,
                                        Feature::GetCurrentPlatform(),
                                        kUnspecifiedContextId)
                .result());
}

TEST(ComplexFeatureTest, RequiresDelegatedAvailabilityCheck) {
  std::vector<Feature*> features;

  // Test a complex feature where |requires_delegated_availability_check| hasn't
  // been set on any of its simple features.
  {
    {
      // Feature which doesn't set |requires_delegated_availability_check|.
      auto simple_feature = std::make_unique<SimpleFeature>();
      features.push_back(simple_feature.release());
    }
    {
      // Feature which doesn't set |requires_delegated_availability_check|.
      auto simple_feature = std::make_unique<SimpleFeature>();
      features.push_back(simple_feature.release());
    }

    ComplexFeature complex_feature(&features);
    EXPECT_FALSE(complex_feature.RequiresDelegatedAvailabilityCheck());
    EXPECT_FALSE(complex_feature.HasDelegatedAvailabilityCheckHandler());
  }

  uint32_t delegated_availability_check_call_count = 0;
  uint32_t success_call_count = 2;
  auto delegated_availability_check =
      [&](const std::string& api_full_name, const Extension* extension,
          mojom::ContextType context, const GURL& url,
          Feature::Platform platform, int context_id, bool check_developer_mode,
          const ContextData& context_data) {
        ++delegated_availability_check_call_count;
        return delegated_availability_check_call_count == success_call_count;
      };

  // Test a complex feature where |requires_delegated_availability_check| is set
  // on multiple sub-features. The first sub-feature that requires the
  // availability check should fail, while the second sub-feature should pass.
  // In this case, the delegated availability check handler should be called
  // twice.
  {
    {
      // Feature which doesn't set |requires_delegated_availability_check|.
      auto simple_feature = std::make_unique<SimpleFeature>();
      simple_feature->set_contexts(StaticSpan(kPrivilegedExtensionOnly));
      features.push_back(simple_feature.release());
    }
    // Two features which set |requires_delegated_availability_check| to true.
    {
      auto simple_feature = std::make_unique<SimpleFeature>();
      simple_feature->set_requires_delegated_availability_check(true);
      features.push_back(simple_feature.release());
    }
    {
      auto simple_feature = std::make_unique<SimpleFeature>();
      simple_feature->set_requires_delegated_availability_check(true);
      features.push_back(simple_feature.release());
    }

    ComplexFeature complex_feature(&features);
    EXPECT_TRUE(complex_feature.RequiresDelegatedAvailabilityCheck());
    EXPECT_FALSE(complex_feature.HasDelegatedAvailabilityCheckHandler());

    // A call to SetDelegatedAvailabilityCheckHandler() should set the
    // handler to the sub-features that require it.
    complex_feature.SetDelegatedAvailabilityCheckHandler(
        base::BindLambdaForTesting(delegated_availability_check));
    EXPECT_TRUE(complex_feature.HasDelegatedAvailabilityCheckHandler());

    // This feature should be available the second time that the delegated
    // availability check is called.
    EXPECT_EQ(Feature::AvailabilityResult::kIsAvailable,
              complex_feature
                  .IsAvailableToContext(
                      /*extension=*/nullptr, mojom::ContextType::kUnspecified,
                      GURL(), kUnspecifiedContextId, TestContextData())
                  .result());
    EXPECT_EQ(2u, delegated_availability_check_call_count);
  }
}

}  // namespace extensions