golden_playground_test_mac.cc

Go to the documentation of this file.

// Copyright 2013 The Flutter 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 <dlfcn.h>
#include <filesystem>
#include <memory>
 
#include "display_list/display_list.h"
#include "flutter/impeller/golden_tests/golden_playground_test.h"
 
#include "flutter/impeller/golden_tests/golden_digest.h"
#include "flutter/impeller/golden_tests/metal_screenshotter.h"
#include "flutter/impeller/golden_tests/vulkan_screenshotter.h"
#include "fml/closure.h"
#include "impeller/display_list/aiks_context.h"
#include "impeller/display_list/dl_dispatcher.h"
#include "impeller/display_list/dl_image_impeller.h"
#include "impeller/renderer/command_buffer.h"
#include "impeller/renderer/command_queue.h"
#include "impeller/renderer/render_pass.h"
#include "impeller/renderer/render_target.h"
#include "impeller/typographer/backends/skia/typographer_context_skia.h"
#include "impeller/typographer/typographer_context.h"
#include "third_party/abseil-cpp/absl/base/no_destructor.h"
 
#define GLFW_INCLUDE_NONE
#include "third_party/glfw/include/GLFW/glfw3.h"
 
namespace impeller {
 
namespace {
std::unique_ptr<PlaygroundImpl> MakeVulkanPlayground(bool enable_validations) {
  FML_CHECK(::glfwInit() == GLFW_TRUE);
  PlaygroundSwitches playground_switches;
  playground_switches.enable_vulkan_validation = enable_validations;
  return PlaygroundImpl::Create(PlaygroundBackend::kVulkan,
                                playground_switches);
}
 
// Returns a static instance to a playground that can be used across tests.
const std::unique_ptr<PlaygroundImpl>& GetSharedVulkanPlayground(
    bool enable_validations) {
  if (enable_validations) {
    static absl::NoDestructor<std::unique_ptr<PlaygroundImpl>>
        vulkan_validation_playground(
            MakeVulkanPlayground(/*enable_validations=*/true));
    // TODO(142237): This can be removed when the thread local storage is
    // removed.
    static fml::ScopedCleanupClosure context_cleanup(
        [&] { (*vulkan_validation_playground)->GetContext()->Shutdown(); });
    return *vulkan_validation_playground;
  } else {
    static absl::NoDestructor<std::unique_ptr<PlaygroundImpl>>
        vulkan_playground(MakeVulkanPlayground(/*enable_validations=*/false));
    // TODO(142237): This can be removed when the thread local storage is
    // removed.
    static fml::ScopedCleanupClosure context_cleanup(
        [&] { (*vulkan_playground)->GetContext()->Shutdown(); });
    return *vulkan_playground;
  }
}
 
std::unique_ptr<PlaygroundImpl> MakeOpenGLESPlayground(bool use_sdfs = false) {
  FML_CHECK(::glfwInit() == GLFW_TRUE);
  PlaygroundSwitches playground_switches;
  playground_switches.use_angle = true;
  playground_switches.flags.use_sdfs = use_sdfs;
  return PlaygroundImpl::Create(
      use_sdfs ? PlaygroundBackend::kOpenGLESSDF : PlaygroundBackend::kOpenGLES,
      playground_switches);
}
 
// Returns a static instance to an OpenGL ES playground that can be used across
// tests.
const std::unique_ptr<PlaygroundImpl>& GetSharedOpenGLESPlayground(
    bool use_sdfs) {
  if (use_sdfs) {
    static absl::NoDestructor<std::unique_ptr<PlaygroundImpl>>
        opengl_playground(MakeOpenGLESPlayground(/*use_sdfs=*/true));
    static fml::ScopedCleanupClosure context_cleanup(
        [&] { (*opengl_playground)->GetContext()->Shutdown(); });
    return *opengl_playground;
  } else {
    static absl::NoDestructor<std::unique_ptr<PlaygroundImpl>>
        opengl_playground(MakeOpenGLESPlayground(/*use_sdfs=*/false));
    // TODO(142237): This can be removed when the thread local storage is
    // removed.
    static fml::ScopedCleanupClosure context_cleanup(
        [&] { (*opengl_playground)->GetContext()->Shutdown(); });
    return *opengl_playground;
  }
}
 
}  // namespace
 
#define IMP_AIKSTEST(name)                         \
  "impeller_Play_AiksTest_" #name "_Metal",        \
      "impeller_Play_AiksTest_" #name "_OpenGLES", \
      "impeller_Play_AiksTest_" #name "_Vulkan"
 
// If you add a new playground test to the aiks unittests and you do not want it
// to also be a golden test, then add the test name here.
static const std::vector<std::string> kSkipTests = {
    // TextRotated is flakey and we can't seem to get it to stabilize on Skia
    // Gold.
    IMP_AIKSTEST(TextRotated),
    // Runtime stage based tests get confused with a Metal context.
    "impeller_Play_AiksTest_CanRenderClippedRuntimeEffects_Vulkan",
};
 
namespace {
std::string GetTestName() {
  std::string suite_name =
      ::testing::UnitTest::GetInstance()->current_test_suite()->name();
  std::string test_name =
      ::testing::UnitTest::GetInstance()->current_test_info()->name();
  std::stringstream ss;
  ss << "impeller_" << suite_name << "_" << test_name;
  std::string result = ss.str();
  // Make sure there are no slashes in the test name.
  std::replace(result.begin(), result.end(), '/', '_');
  return result;
}
 
std::string GetGoldenFilename(const std::string& postfix) {
  return GetTestName() + postfix + ".png";
}
}  // namespace
 
bool GoldenPlaygroundTest::SaveScreenshot(
    std::unique_ptr<testing::Screenshot> screenshot,
    const std::string& postfix) {
  if (!screenshot || !screenshot->GetBytes()) {
    FML_LOG(ERROR) << "Failed to collect screenshot for test " << GetTestName();
    return false;
  }
  std::string test_name = GetTestName();
  std::string filename = GetGoldenFilename(postfix);
  testing::GoldenDigest::Instance()->AddImage(
      test_name, filename, screenshot->GetWidth(), screenshot->GetHeight());
  if (!screenshot->WriteToPNG(
          testing::WorkingDirectory::Instance()->GetFilenamePath(filename))) {
    FML_LOG(ERROR) << "Failed to write screenshot to " << filename;
    return false;
  }
  return true;
}
 
struct GoldenPlaygroundTest::GoldenPlaygroundTestImpl {
  std::unique_ptr<PlaygroundImpl> test_vulkan_playground;
  std::unique_ptr<PlaygroundImpl> test_opengl_playground;
  std::unique_ptr<testing::Screenshotter> screenshotter;
  ISize window_size = ISize{1024, 768};
};
 
GoldenPlaygroundTest::GoldenPlaygroundTest()
    : typographer_context_(TypographerContextSkia::Make()),
      pimpl_(new GoldenPlaygroundTest::GoldenPlaygroundTestImpl()) {}
 
GoldenPlaygroundTest::~GoldenPlaygroundTest() = default;
 
void GoldenPlaygroundTest::SetTypographerContext(
    std::shared_ptr<TypographerContext> typographer_context) {
  typographer_context_ = std::move(typographer_context);
};
 
void GoldenPlaygroundTest::TearDown() {
  ASSERT_FALSE(dlopen("/usr/local/lib/libMoltenVK.dylib", RTLD_NOLOAD));
 
  auto context = GetContext();
  if (context) {
    context->DisposeThreadLocalCachedResources();
  }
}
 
namespace {
bool DoesSupportWideGamutTests() {
#ifdef __arm64__
  return true;
#else
  return false;
#endif
}
}  // namespace
 
void GoldenPlaygroundTest::SetUp() {
  std::filesystem::path testing_assets_path =
      flutter::testing::GetTestingAssetsPath();
  std::filesystem::path target_path = testing_assets_path.parent_path()
                                          .parent_path()
                                          .parent_path()
                                          .parent_path();
  std::filesystem::path icd_path = target_path / "vk_swiftshader_icd.json";
  setenv("VK_ICD_FILENAMES", icd_path.c_str(), 1);
 
  std::string test_name = GetTestName();
  PlaygroundSwitches switches;
  switches.enable_wide_gamut =
      test_name.find("WideGamut_") != std::string::npos;
  switches.flags.antialiased_lines =
      test_name.find("ExperimentAntialiasLines_") != std::string::npos;
  switch (GetParam()) {
    case PlaygroundBackend::kMetalSDF:
      switches.flags.use_sdfs = true;
      [[fallthrough]];
    case PlaygroundBackend::kMetal:
      if (!DoesSupportWideGamutTests()) {
        GTEST_SKIP()
            << "This metal device doesn't support wide gamut golden tests.";
      }
      pimpl_->screenshotter =
          std::make_unique<testing::MetalScreenshotter>(switches);
      break;
    case PlaygroundBackend::kVulkan: {
      if (switches.enable_wide_gamut) {
        GTEST_SKIP() << "Vulkan doesn't support wide gamut golden tests.";
      }
      if (switches.flags.antialiased_lines) {
        GTEST_SKIP()
            << "Vulkan doesn't support antialiased lines golden tests.";
      }
      const std::unique_ptr<PlaygroundImpl>& playground =
          GetSharedVulkanPlayground(/*enable_validations=*/true);
      pimpl_->screenshotter =
          std::make_unique<testing::VulkanScreenshotter>(playground);
      break;
    }
    case PlaygroundBackend::kOpenGLESSDF:
      switches.flags.use_sdfs = true;
      [[fallthrough]];
    case PlaygroundBackend::kOpenGLES: {
      if (switches.enable_wide_gamut) {
        GTEST_SKIP() << "OpenGLES doesn't support wide gamut golden tests.";
      }
      if (switches.flags.antialiased_lines) {
        GTEST_SKIP()
            << "OpenGLES doesn't support antialiased lines golden tests.";
      }
      const std::unique_ptr<PlaygroundImpl>& playground =
          GetSharedOpenGLESPlayground(switches.flags.use_sdfs);
      ::glfwMakeContextCurrent(
          reinterpret_cast<GLFWwindow*>(playground->GetWindowHandle()));
      pimpl_->screenshotter =
          std::make_unique<testing::VulkanScreenshotter>(playground);
      break;
    }
  }
 
  if (std::find(kSkipTests.begin(), kSkipTests.end(), test_name) !=
      kSkipTests.end()) {
    GTEST_SKIP()
        << "GoldenPlaygroundTest doesn't support interactive playground tests "
           "yet.";
  }
 
  testing::GoldenDigest::Instance()->AddDimension(
      "gpu_string", GetContext()->DescribeGpuModel());
}
 
PlaygroundBackend GoldenPlaygroundTest::GetBackend() const {
  return GetParam();
}
 
bool GoldenPlaygroundTest::OpenPlaygroundHere(
    const AiksDlPlaygroundCallback& callback) {
  AiksContext renderer(GetContext(), typographer_context_);
 
  std::unique_ptr<testing::Screenshot> screenshot;
  Point content_scale =
      pimpl_->screenshotter->GetPlayground().GetContentScale();
 
  ISize physical_window_size(
      std::round(pimpl_->window_size.width * content_scale.x),
      std::round(pimpl_->window_size.height * content_scale.y));
  for (int i = 0; i < 2; ++i) {
    auto display_list = callback();
    auto texture =
        DisplayListToTexture(display_list, physical_window_size, renderer);
    screenshot = pimpl_->screenshotter->MakeScreenshot(renderer, texture);
  }
  return SaveScreenshot(std::move(screenshot));
}
 
bool GoldenPlaygroundTest::OpenPlaygroundHere(
    const sk_sp<flutter::DisplayList>& list) {
  return OpenPlaygroundHere([&list]() { return list; });
}
 
bool GoldenPlaygroundTest::OpenPlaygroundHere(
    const Playground::SinglePassCallback& callback) {
  AiksContext renderer(GetContext(), typographer_context_);
  std::shared_ptr<Context> context = GetContext();
  Point content_scale =
      pimpl_->screenshotter->GetPlayground().GetContentScale();
  ISize size(std::round(pimpl_->window_size.width * content_scale.x),
             std::round(pimpl_->window_size.height * content_scale.y));
 
  std::unique_ptr<testing::Screenshot> screenshot;
  // Render twice so the second pass observes warmed pipeline and resource
  // caches, matching the display list path above.
  for (int i = 0; i < 2; ++i) {
    RenderTargetAllocator render_target_allocator(
        context->GetResourceAllocator());
    RenderTarget render_target = render_target_allocator.CreateOffscreen(
        *context, size, /*mip_count=*/1, "Golden Render Pass",
        RenderTarget::kDefaultColorAttachmentConfig,
        /*stencil_attachment_config=*/std::nullopt);
    if (!render_target.IsValid()) {
      return false;
    }
    std::shared_ptr<CommandBuffer> command_buffer =
        context->CreateCommandBuffer();
    if (!command_buffer) {
      return false;
    }
    std::shared_ptr<RenderPass> render_pass =
        command_buffer->CreateRenderPass(render_target);
    if (!render_pass) {
      return false;
    }
    if (!callback(*render_pass)) {
      return false;
    }
    if (!render_pass->EncodeCommands()) {
      return false;
    }
    if (!context->GetCommandQueue()->Submit({command_buffer}).ok()) {
      return false;
    }
    screenshot = pimpl_->screenshotter->MakeScreenshot(
        renderer, render_target.GetRenderTargetTexture());
  }
  return SaveScreenshot(std::move(screenshot));
}
 
bool GoldenPlaygroundTest::ImGuiBegin(const char* name,
                                      bool* p_open,
                                      ImGuiWindowFlags flags) {
  return false;
}
 
std::shared_ptr<Texture> GoldenPlaygroundTest::CreateTextureForFixture(
    const char* fixture_name,
    bool enable_mipmapping) const {
  std::shared_ptr<fml::Mapping> mapping =
      flutter::testing::OpenFixtureAsMapping(fixture_name);
  auto result = Playground::CreateTextureForMapping(GetContext(), mapping,
                                                    enable_mipmapping);
  if (result) {
    result->SetLabel(fixture_name);
  }
  return result;
}
 
sk_sp<flutter::DlImage> GoldenPlaygroundTest::CreateDlImageForFixture(
    const char* fixture_name,
    bool enable_mipmapping) const {
  std::shared_ptr<Texture> texture =
      CreateTextureForFixture(fixture_name, enable_mipmapping);
  return DlImageImpeller::Make(texture);
}
 
absl::StatusOr<RuntimeStage::Map> GoldenPlaygroundTest::OpenAssetAsRuntimeStage(
    const char* asset_name) const {
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping(asset_name);
  if (!fixture || fixture->GetSize() == 0) {
    return absl::NotFoundError("Asset not found or empty.");
  }
  return RuntimeStage::DecodeRuntimeStages(fixture);
}
 
std::shared_ptr<Context> GoldenPlaygroundTest::GetContext() const {
  if (!pimpl_->screenshotter) {
    return nullptr;
  }
  return pimpl_->screenshotter->GetPlayground().GetContext();
}
 
std::shared_ptr<Context> GoldenPlaygroundTest::MakeContext() const {
  if (GetParam() == PlaygroundBackend::kMetal ||
      GetParam() == PlaygroundBackend::kMetalSDF) {
    /// On Metal we create a context for each test.
    return GetContext();
  } else if (GetParam() == PlaygroundBackend::kVulkan) {
    bool enable_vulkan_validations = true;
    FML_CHECK(!pimpl_->test_vulkan_playground)
        << "We don't support creating multiple contexts for one test";
    pimpl_->test_vulkan_playground =
        MakeVulkanPlayground(enable_vulkan_validations);
    pimpl_->screenshotter = std::make_unique<testing::VulkanScreenshotter>(
        pimpl_->test_vulkan_playground);
    return pimpl_->test_vulkan_playground->GetContext();
  } else if (GetParam() == PlaygroundBackend::kOpenGLES ||
             GetParam() == PlaygroundBackend::kOpenGLESSDF) {
    FML_CHECK(!pimpl_->test_opengl_playground)
        << "We don't support creating multiple contexts for one test";
    bool use_sdfs = (GetParam() == PlaygroundBackend::kOpenGLESSDF);
    pimpl_->test_opengl_playground = MakeOpenGLESPlayground(use_sdfs);
    pimpl_->screenshotter = std::make_unique<testing::VulkanScreenshotter>(
        pimpl_->test_opengl_playground);
    return pimpl_->test_opengl_playground->GetContext();
  } else {
    FML_CHECK(false);
    return nullptr;
  }
}
 
Point GoldenPlaygroundTest::GetContentScale() const {
  return pimpl_->screenshotter->GetPlayground().GetContentScale();
}
 
Scalar GoldenPlaygroundTest::GetSecondsElapsed() const {
  return 0.0f;
}
 
ISize GoldenPlaygroundTest::GetWindowSize() const {
  return pimpl_->window_size;
}
 
IRect GoldenPlaygroundTest::GetWindowBounds() const {
  return IRect::MakeSize(pimpl_->window_size);
}
 
void GoldenPlaygroundTest::GoldenPlaygroundTest::SetWindowSize(ISize size) {
  pimpl_->window_size = size;
}
 
fml::Status GoldenPlaygroundTest::SetCapabilities(
    const std::shared_ptr<Capabilities>& capabilities) {
  return pimpl_->screenshotter->GetPlayground().SetCapabilities(capabilities);
}
 
std::unique_ptr<testing::Screenshot> GoldenPlaygroundTest::MakeScreenshot(
    const sk_sp<flutter::DisplayList>& list) {
  AiksContext renderer(GetContext(), typographer_context_);
  Point content_scale =
      pimpl_->screenshotter->GetPlayground().GetContentScale();
 
  ISize physical_window_size(
      std::round(pimpl_->window_size.width * content_scale.x),
      std::round(pimpl_->window_size.height * content_scale.y));
  return pimpl_->screenshotter->MakeScreenshot(
      renderer, DisplayListToTexture(list, physical_window_size, renderer));
}
 
RuntimeStageBackend GoldenPlaygroundTest::GetRuntimeStageBackend() const {
  return pimpl_->screenshotter->GetPlayground().GetRuntimeStageBackend();
}
 
}  // namespace impeller