android/libwvdrmengine/test/unit/WVDrmFactory_hal_test.cpp

/*
 * Copyright 2022 Google LLC. All Rights Reserved. This file and proprietary
 * source code may only be used and distributed under the Widevine License
 * Agreement.
 */

#include "WVDrmFactory.h"
#include "android-base/properties.h"
#include "cutils/properties.h"
#include "gtest/gtest.h"

namespace wvdrm {
namespace hardware {
namespace drm {
namespace widevine {

using ::aidl::android::hardware::drm::CryptoSchemes;
using ::aidl::android::hardware::drm::SecurityLevel;
using ::aidl::android::hardware::drm::SupportedContentType;
using ::aidl::android::hardware::drm::Uuid;
using ::wvdrm::hardware::drm::widevine::WVDrmFactory;

const Uuid kWidevineUUID = {0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
                            0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED};

const Uuid kOldNetflixWidevineUUID = {0x29, 0x70, 0x1F, 0xE4, 0x3C, 0xC7,
                                      0x4A, 0x34, 0x8C, 0x5B, 0xAE, 0x90,
                                      0xC7, 0x43, 0x9A, 0x47};

const Uuid kUnknownUUID = {0x6A, 0x7F, 0xAA, 0xB0, 0x83, 0xC7, 0x9E, 0x20,
                           0x08, 0xBC, 0xEF, 0x32, 0x34, 0x1A, 0x9A, 0x26};

const std::vector<std::string> supportedMimeTypes = {
    "audio/mp4", "audio/webm", "cenc", "hls", "video/mp4", "video/webm", "webm",
};

const std::vector<std::string> unSupportedMimeTypes = {
    "application/x-mpegURL", "video/3gpp",
    "video/x-flv",           "video/MP2T",
    "video/quicktime",       "video/x-matroska",
    "video/x-msvideo",       "video/x-ms-wmv",
};

class WVDrmFactoryTestPeer : public WVDrmFactory {
public:
  using WVDrmFactory::areSpoidsEnabled;
  using WVDrmFactory::isBlankAppPackageNameAllowed;
};

TEST(WVDrmFactoryTest, SupportsSupportedCryptoSchemes) {
  std::shared_ptr<WVDrmFactory> factory =
      ::ndk::SharedRefBase::make<WVDrmFactory>();

  EXPECT_TRUE(factory->isCryptoSchemeSupported(kWidevineUUID))
      << "WVPluginFactory does not support Widevine's UUID";

  EXPECT_TRUE(factory->isCryptoSchemeSupported(kOldNetflixWidevineUUID))
      << "WVPluginFactory does not support the old Netflix Widevine UUID";
}

TEST(WVDrmFactoryTest, DoesNotSupportUnsupportedCryptoSchemes) {
  std::shared_ptr<WVDrmFactory> factory =
      ::ndk::SharedRefBase::make<WVDrmFactory>();

  EXPECT_FALSE(factory->isCryptoSchemeSupported(kUnknownUUID))
      << "WVPluginFactory incorrectly claims to support an unknown UUID";
}

TEST(WVDrmFactoryTest, SupportsSupportedContainerFormats) {
  std::shared_ptr<WVDrmFactory> factory =
      ::ndk::SharedRefBase::make<WVDrmFactory>();

  CryptoSchemes schemes{};
  auto ret = factory->getSupportedCryptoSchemes(&schemes);
  EXPECT_TRUE(ret.isOk());

  for (auto mimeType : schemes.mimeTypes) {
    std::string mime = mimeType.mime;
    EXPECT_TRUE(std::find(supportedMimeTypes.begin(), supportedMimeTypes.end(),
                          mime) != supportedMimeTypes.end())
        << "WVPluginFactory does not support " << mime;
  }
}

TEST(WVDrmFactoryTest, DoesNotSupportUnsupportedContainerFormats) {
  std::shared_ptr<WVDrmFactory> factory =
      ::ndk::SharedRefBase::make<WVDrmFactory>();

  CryptoSchemes schemes{};
  auto ret = factory->getSupportedCryptoSchemes(&schemes);
  EXPECT_TRUE(ret.isOk());

  for (auto mimeType : schemes.mimeTypes) {
    std::string mime = mimeType.mime;
    EXPECT_FALSE(std::find(unSupportedMimeTypes.begin(),
                           unSupportedMimeTypes.end(),
                           mime) != unSupportedMimeTypes.end())
        << "WVPluginFactory incorrectly claims to support " << mime;
  }
}

TEST(WVDrmFactoryTest, CalculatesSpoidUseCorrectly) {
  std::shared_ptr<WVDrmFactory> factory =
      ::ndk::SharedRefBase::make<WVDrmFactory>();

  int32_t firstApiLevel =
      android::base::GetIntProperty<int32_t>("ro.product.first_api_level", 0);
  if (firstApiLevel == 0) {
    // First API Level is 0 on factory->ROMs, but we can assume the current SDK
    // version is the first if it's a factory->ROM.
    firstApiLevel =
        android::base::GetIntProperty<int32_t>("ro.build.version.sdk", 0);
  }
  bool shouldUseSpoids = (firstApiLevel >= 26); // Android O

  EXPECT_EQ(shouldUseSpoids, WVDrmFactoryTestPeer::areSpoidsEnabled())
      << "WVDrmFactory calculated a different SPOID state than expected.";
}

TEST(WVDrmFactoryTest, CalculatesBlankAppPackageNamePermissibilityCorrectly) {
  std::shared_ptr<WVDrmFactory> factory =
      ::ndk::SharedRefBase::make<WVDrmFactory>();

  int32_t firstApiLevel =
      android::base::GetIntProperty<int32_t>("ro.product.first_api_level", 0);
  if (firstApiLevel == 0) {
    // First API Level is 0 on factory->ROMs, but we can assume the current SDK
    // version is the first if it's a factory->ROM.
    firstApiLevel =
        android::base::GetIntProperty<int32_t>("ro.build.version.sdk", 0);
  }
  bool shouldAllow = (firstApiLevel < 29); // Android Q

  EXPECT_EQ(shouldAllow, WVDrmFactoryTestPeer::isBlankAppPackageNameAllowed())
      << "WVDrmFactory calculated a different Blank App Package Name state "
         "than expected.";
}

} // namespace widevine
} // namespace drm
} // namespace hardware
} // namespace wvdrm