0

slim: Add UIResourceLayer AppendQuads

Add UI resource paths to get resource info, upload resources.

Mark all resources for deletion in FrameSinkImpl destructor to avoid
DCHECKs.

Bug: 1408128
Change-Id: Icd3488fc3c46932036a10596c541d3a4d67973c1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4261401
Reviewed-by: Kyle Charbonneau <kylechar@chromium.org>
Commit-Queue: Bo Liu <boliu@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1107776}
This commit is contained in:
Bo Liu
2023-02-21 16:33:37 +00:00
committed by Chromium LUCI CQ
parent 5538b81795
commit 84fe45dbed
8 changed files with 155 additions and 1 deletions

@ -53,6 +53,10 @@ FrameSinkImpl::FrameSinkImpl(
io_thread_id_(io_thread_id) {}
FrameSinkImpl::~FrameSinkImpl() {
for (const auto& uploaded_resource_pair : uploaded_resources_) {
resource_provider_.RemoveImportedResource(
uploaded_resource_pair.second.viz_resource_id);
}
resource_provider_.ShutdownAndReleaseAllResources();
}

@ -231,6 +231,17 @@ void LayerTreeImpl::NotifyPropertyChanged() {
SetNeedsDraw();
}
viz::ResourceId LayerTreeImpl::GetVizResourceId(cc::UIResourceId id) {
if (!frame_sink_) {
return viz::kInvalidResourceId;
}
return frame_sink_->GetVizResourceId(id);
}
bool LayerTreeImpl::IsUIResourceOpaque(int resource_id) {
return !frame_sink_ || frame_sink_->IsUIResourceOpaque(resource_id);
}
void LayerTreeImpl::AddSurfaceRange(const viz::SurfaceRange& range) {
DCHECK(range.IsValid());
DCHECK(!referenced_surfaces_.contains(range));
@ -292,6 +303,20 @@ void LayerTreeImpl::GenerateCompositorFrame(
// * Surface embedding fields (referenced surfaces, activation dependency,
// deadline)
TRACE_EVENT0("cc", "slim::LayerTreeImpl::ProduceFrame");
for (auto& resource_request :
ui_resource_manager_.TakeUIResourcesRequests()) {
switch (resource_request.GetType()) {
case cc::UIResourceRequest::UI_RESOURCE_CREATE:
frame_sink_->UploadUIResource(resource_request.GetId(),
resource_request.GetBitmap());
break;
case cc::UIResourceRequest::UI_RESOURCE_DELETE:
frame_sink_->MarkUIResourceForDeletion(resource_request.GetId());
break;
}
}
auto render_pass = viz::CompositorRenderPass::Create();
render_pass->SetNew(viz::CompositorRenderPassId(root_->id()),
/*output_rect=*/device_viewport_rect_,

@ -87,6 +87,8 @@ class COMPONENT_EXPORT(CC_SLIM) LayerTreeImpl : public LayerTree,
// Internal methods called by Layers.
void NotifyTreeChanged();
void NotifyPropertyChanged();
viz::ResourceId GetVizResourceId(cc::UIResourceId id);
bool IsUIResourceOpaque(int resource_id);
void AddSurfaceRange(const viz::SurfaceRange& range);
void RemoveSurfaceRange(const viz::SurfaceRange& range);

@ -15,12 +15,16 @@
#include "cc/slim/test_frame_sink_impl.h"
#include "cc/slim/test_layer_tree_client.h"
#include "cc/slim/test_layer_tree_impl.h"
#include "cc/slim/ui_resource_layer.h"
#include "components/viz/common/frame_sinks/begin_frame_args.h"
#include "components/viz/common/quads/compositor_frame.h"
#include "components/viz/common/quads/solid_color_draw_quad.h"
#include "components/viz/common/quads/texture_draw_quad.h"
#include "components/viz/common/resources/transferable_resource.h"
#include "components/viz/common/surfaces/local_surface_id.h"
#include "components/viz/test/draw_quad_matchers.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/gfx/geometry/rect.h"
namespace cc::slim {
@ -305,6 +309,85 @@ TEST_F(SlimLayerTreeCompositorFrameTest, AxisAlignedClip) {
}
}
TEST_F(SlimLayerTreeCompositorFrameTest, UIResourceLayerAppendQuads) {
auto ui_resource_layer = UIResourceLayer::Create();
ui_resource_layer->SetBounds(viewport_.size());
ui_resource_layer->SetIsDrawable(true);
layer_tree_->SetRoot(ui_resource_layer);
viz::ResourceId first_resource_id = viz::kInvalidResourceId;
{
auto image_info =
SkImageInfo::Make(1, 1, kN32_SkColorType, kPremul_SkAlphaType);
SkBitmap bitmap;
bitmap.allocPixels(image_info);
bitmap.setImmutable();
ui_resource_layer->SetBitmap(bitmap);
viz::CompositorFrame frame = ProduceFrame();
ASSERT_EQ(frame.render_pass_list.size(), 1u);
auto& pass = frame.render_pass_list.back();
ASSERT_THAT(pass->quad_list,
ElementsAre(AllOf(viz::IsTextureQuad(), viz::HasRect(viewport_),
viz::HasVisibleRect(viewport_),
viz::HasTransform(gfx::Transform()))));
const viz::TextureDrawQuad* texture_quad =
viz::TextureDrawQuad::MaterialCast(pass->quad_list.front());
EXPECT_TRUE(texture_quad->needs_blending);
EXPECT_NE(viz::kInvalidResourceId, texture_quad->resource_id());
EXPECT_EQ(gfx::PointF(0.0f, 0.0f), texture_quad->uv_top_left);
EXPECT_EQ(gfx::PointF(1.0f, 1.0f), texture_quad->uv_bottom_right);
EXPECT_EQ(1.0f, texture_quad->vertex_opacity[0]);
EXPECT_EQ(1.0f, texture_quad->vertex_opacity[1]);
EXPECT_EQ(1.0f, texture_quad->vertex_opacity[2]);
EXPECT_EQ(1.0f, texture_quad->vertex_opacity[3]);
ASSERT_EQ(frame.resource_list.size(), 1u);
EXPECT_EQ(frame.resource_list[0].id, texture_quad->resource_id());
EXPECT_EQ(frame.resource_list[0].size, gfx::Size(1, 1));
first_resource_id = texture_quad->resource_id();
ASSERT_EQ(frame_sink_->uploaded_resources().size(), 1u);
EXPECT_EQ(frame_sink_->uploaded_resources().begin()->second.viz_resource_id,
texture_quad->resource_id());
}
ui_resource_layer->SetUV(gfx::PointF(0.25f, 0.25f),
gfx::PointF(0.75f, 0.75f));
ui_resource_layer->SetVertexOpacity(0.1f, 0.2f, 0.3f, 0.4f);
{
auto image_info =
SkImageInfo::Make(2, 2, kN32_SkColorType, kPremul_SkAlphaType);
SkBitmap bitmap;
bitmap.allocPixels(image_info);
bitmap.setImmutable();
ui_resource_layer->SetBitmap(bitmap);
viz::CompositorFrame frame = ProduceFrame();
ASSERT_EQ(frame.render_pass_list.size(), 1u);
auto& pass = frame.render_pass_list.back();
ASSERT_THAT(pass->quad_list,
ElementsAre(AllOf(viz::IsTextureQuad(), viz::HasRect(viewport_),
viz::HasVisibleRect(viewport_),
viz::HasTransform(gfx::Transform()))));
const viz::TextureDrawQuad* texture_quad =
viz::TextureDrawQuad::MaterialCast(pass->quad_list.front());
EXPECT_TRUE(texture_quad->needs_blending);
EXPECT_NE(viz::kInvalidResourceId, texture_quad->resource_id());
EXPECT_EQ(gfx::PointF(0.25f, 0.25f), texture_quad->uv_top_left);
EXPECT_EQ(gfx::PointF(0.75f, 0.75f), texture_quad->uv_bottom_right);
EXPECT_EQ(0.1f, texture_quad->vertex_opacity[0]);
EXPECT_EQ(0.2f, texture_quad->vertex_opacity[1]);
EXPECT_EQ(0.3f, texture_quad->vertex_opacity[2]);
EXPECT_EQ(0.4f, texture_quad->vertex_opacity[3]);
ASSERT_EQ(frame.resource_list.size(), 1u);
EXPECT_EQ(frame.resource_list[0].id, texture_quad->resource_id());
EXPECT_EQ(frame.resource_list[0].size, gfx::Size(2, 2));
EXPECT_NE(first_resource_id, texture_quad->resource_id());
}
}
} // namespace
} // namespace cc::slim

@ -95,6 +95,9 @@ bool TestFrameSinkImpl::BindToClient(FrameSinkImplClient* client) {
client_ = client;
frame_sink_ = mojo_sink_.get();
bind_to_client_called_ = true;
if (bind_to_client_result_) {
context_provider_->BindToCurrentSequence();
}
return bind_to_client_result_;
}

@ -32,6 +32,12 @@ class TestFrameSinkImpl : public FrameSinkImpl {
bool BindToClient(FrameSinkImplClient* client) override;
void SetNeedsBeginFrame(bool needs_begin_frame) override;
using FrameSinkImpl::UploadedResourceMap;
using FrameSinkImpl::UploadedUIResource;
const UploadedResourceMap& uploaded_resources() const {
return uploaded_resources_;
}
private:
class TestMojoCompositorFrameSink;
TestFrameSinkImpl(

@ -10,8 +10,8 @@
#include "cc/slim/features.h"
#include "cc/slim/layer_tree_impl.h"
#include "components/viz/common/quads/compositor_render_pass.h"
#include "components/viz/common/quads/solid_color_draw_quad.h"
#include "components/viz/common/quads/texture_draw_quad.h"
#include "components/viz/common/resources/resource_id.h"
namespace cc::slim {
@ -137,4 +137,32 @@ void UIResourceLayer::SetUIResourceIdInternal(cc::UIResourceId resource_id) {
NotifyPropertyChanged();
}
void UIResourceLayer::AppendQuads(viz::CompositorRenderPass& render_pass,
const gfx::Transform& transform,
const gfx::Rect* clip) {
viz::ResourceId viz_resource_id =
static_cast<LayerTreeImpl*>(layer_tree())->GetVizResourceId(resource_id_);
if (viz_resource_id == viz::kInvalidResourceId) {
return;
}
viz::SharedQuadState* quad_state =
CreateAndAppendSharedQuadState(render_pass, transform, clip);
viz::TextureDrawQuad* quad =
render_pass.CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
constexpr bool kFlipped = false;
constexpr bool kNearest = false;
constexpr bool kPremultiplied = true;
constexpr bool kSecureOutputOnly = false;
constexpr auto kVideoType = gfx::ProtectedVideoType::kClear;
const bool needs_blending = !static_cast<LayerTreeImpl*>(layer_tree())
->IsUIResourceOpaque(resource_id_);
quad->SetNew(quad_state, quad_state->quad_layer_rect,
quad_state->visible_quad_layer_rect, needs_blending,
viz_resource_id, kPremultiplied, uv_top_left(),
uv_bottom_right(), SkColors::kTransparent, vertex_opacity_,
kFlipped, kNearest, kSecureOutputOnly, kVideoType);
}
} // namespace cc::slim

@ -59,6 +59,9 @@ class COMPONENT_EXPORT(CC_SLIM) UIResourceLayer : public Layer {
const auto& vertex_opacity() const { return vertex_opacity_; }
bool HasDrawableContent() const override;
void AppendQuads(viz::CompositorRenderPass& render_pass,
const gfx::Transform& transform,
const gfx::Rect* clip) override;
private:
cc::UIResourceLayer* cc_layer() const;