| // Copyright 2017 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 "cc/mojo_embedder/async_layer_tree_frame_sink.h" |
| |
| #include <memory> |
| |
| #include "base/bind.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "base/run_loop.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/test/test_mock_time_task_runner.h" |
| #include "base/threading/thread.h" |
| #include "cc/test/fake_layer_tree_frame_sink_client.h" |
| #include "components/viz/client/hit_test_data_provider_draw_quad.h" |
| #include "components/viz/client/local_surface_id_provider.h" |
| #include "components/viz/common/quads/render_pass_draw_quad.h" |
| #include "components/viz/common/quads/solid_color_draw_quad.h" |
| #include "components/viz/common/quads/surface_draw_quad.h" |
| #include "components/viz/common/surfaces/surface_range.h" |
| #include "components/viz/test/compositor_frame_helpers.h" |
| #include "components/viz/test/test_context_provider.h" |
| #include "components/viz/test/test_gpu_memory_buffer_manager.h" |
| #include "mojo/public/cpp/bindings/interface_request.h" |
| #include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace cc { |
| namespace mojo_embedder { |
| namespace { |
| |
| // Used to track the thread DidLoseLayerTreeFrameSink() is called on (and quit |
| // a RunLoop). |
| class ThreadTrackingLayerTreeFrameSinkClient |
| : public FakeLayerTreeFrameSinkClient { |
| public: |
| ThreadTrackingLayerTreeFrameSinkClient( |
| base::PlatformThreadId* called_thread_id, |
| base::RunLoop* run_loop) |
| : called_thread_id_(called_thread_id), run_loop_(run_loop) {} |
| ThreadTrackingLayerTreeFrameSinkClient( |
| const ThreadTrackingLayerTreeFrameSinkClient&) = delete; |
| ~ThreadTrackingLayerTreeFrameSinkClient() override = default; |
| |
| ThreadTrackingLayerTreeFrameSinkClient& operator=( |
| const ThreadTrackingLayerTreeFrameSinkClient&) = delete; |
| |
| // FakeLayerTreeFrameSinkClient: |
| void DidLoseLayerTreeFrameSink() override { |
| EXPECT_FALSE(did_lose_layer_tree_frame_sink_called()); |
| FakeLayerTreeFrameSinkClient::DidLoseLayerTreeFrameSink(); |
| *called_thread_id_ = base::PlatformThread::CurrentId(); |
| run_loop_->Quit(); |
| } |
| |
| private: |
| base::PlatformThreadId* called_thread_id_; |
| base::RunLoop* run_loop_; |
| }; |
| |
| TEST(AsyncLayerTreeFrameSinkTest, |
| DidLoseLayerTreeFrameSinkCalledOnConnectionError) { |
| base::Thread bg_thread("BG Thread"); |
| bg_thread.Start(); |
| |
| scoped_refptr<viz::TestContextProvider> provider = |
| viz::TestContextProvider::Create(); |
| viz::TestGpuMemoryBufferManager test_gpu_memory_buffer_manager; |
| |
| viz::mojom::CompositorFrameSinkPtrInfo sink_info; |
| viz::mojom::CompositorFrameSinkRequest sink_request = |
| mojo::MakeRequest(&sink_info); |
| viz::mojom::CompositorFrameSinkClientPtr client; |
| viz::mojom::CompositorFrameSinkClientRequest client_request = |
| mojo::MakeRequest(&client); |
| |
| AsyncLayerTreeFrameSink::InitParams init_params; |
| init_params.compositor_task_runner = bg_thread.task_runner(); |
| init_params.gpu_memory_buffer_manager = &test_gpu_memory_buffer_manager; |
| init_params.pipes.compositor_frame_sink_info = std::move(sink_info); |
| init_params.pipes.client_request = std::move(client_request); |
| init_params.enable_surface_synchronization = true; |
| auto layer_tree_frame_sink = std::make_unique<AsyncLayerTreeFrameSink>( |
| std::move(provider), nullptr, &init_params); |
| |
| base::PlatformThreadId called_thread_id = base::kInvalidThreadId; |
| base::RunLoop close_run_loop; |
| ThreadTrackingLayerTreeFrameSinkClient frame_sink_client(&called_thread_id, |
| &close_run_loop); |
| |
| auto bind_in_background = |
| [](AsyncLayerTreeFrameSink* layer_tree_frame_sink, |
| ThreadTrackingLayerTreeFrameSinkClient* frame_sink_client) { |
| layer_tree_frame_sink->BindToClient(frame_sink_client); |
| }; |
| bg_thread.task_runner()->PostTask( |
| FROM_HERE, base::BindOnce(bind_in_background, |
| base::Unretained(layer_tree_frame_sink.get()), |
| base::Unretained(&frame_sink_client))); |
| // Closes the pipe, which should trigger calling DidLoseLayerTreeFrameSink() |
| // (and quitting the RunLoop). There is no need to wait for BindToClient() |
| // to complete as mojo::Binding error callbacks are processed asynchronously. |
| sink_request = viz::mojom::CompositorFrameSinkRequest(); |
| close_run_loop.Run(); |
| |
| EXPECT_NE(base::kInvalidThreadId, called_thread_id); |
| EXPECT_EQ(called_thread_id, bg_thread.GetThreadId()); |
| |
| // DetachFromClient() has to be called on the background thread. |
| base::RunLoop detach_run_loop; |
| auto detach_in_background = |
| [](std::unique_ptr<AsyncLayerTreeFrameSink> layer_tree_frame_sink, |
| base::RunLoop* detach_run_loop) { |
| layer_tree_frame_sink->DetachFromClient(); |
| detach_run_loop->Quit(); |
| }; |
| bg_thread.task_runner()->PostTask( |
| FROM_HERE, |
| base::BindOnce(detach_in_background, std::move(layer_tree_frame_sink), |
| base::Unretained(&detach_run_loop))); |
| detach_run_loop.Run(); |
| } |
| |
| } // namespace |
| |
| // Boilerplate code for simple AsyncLayerTreeFrameSink. Friend of |
| // AsyncLayerTreeFrameSink. |
| class AsyncLayerTreeFrameSinkSimpleTest : public testing::Test { |
| public: |
| AsyncLayerTreeFrameSinkSimpleTest() |
| : task_runner_(base::MakeRefCounted<base::TestMockTimeTaskRunner>( |
| base::TestMockTimeTaskRunner::Type::kStandalone)), |
| display_rect_(1, 1) { |
| auto context_provider = viz::TestContextProvider::Create(); |
| |
| viz::mojom::CompositorFrameSinkPtrInfo sink_info; |
| viz::mojom::CompositorFrameSinkRequest sink_request = |
| mojo::MakeRequest(&sink_info); |
| viz::mojom::CompositorFrameSinkClientPtr client; |
| viz::mojom::CompositorFrameSinkClientRequest client_request = |
| mojo::MakeRequest(&client); |
| |
| init_params_.compositor_task_runner = task_runner_; |
| init_params_.gpu_memory_buffer_manager = &test_gpu_memory_buffer_manager_; |
| init_params_.pipes.compositor_frame_sink_info = std::move(sink_info); |
| init_params_.pipes.client_request = std::move(client_request); |
| init_params_.enable_surface_synchronization = true; |
| init_params_.hit_test_data_provider = |
| std::make_unique<viz::HitTestDataProviderDrawQuad>( |
| /*should_ask_for_child_region=*/true, /*root_accepts_events=*/true); |
| |
| layer_tree_frame_sink_ = std::make_unique<AsyncLayerTreeFrameSink>( |
| std::move(context_provider), nullptr, &init_params_); |
| |
| viz::LocalSurfaceId local_surface_id(1, base::UnguessableToken::Create()); |
| layer_tree_frame_sink_->SetLocalSurfaceId(local_surface_id); |
| layer_tree_frame_sink_->BindToClient(&layer_tree_frame_sink_client_); |
| } |
| |
| void SendRenderPassList(viz::RenderPassList* pass_list, |
| bool hit_test_data_changed) { |
| auto frame = viz::CompositorFrameBuilder() |
| .SetRenderPassList(std::move(*pass_list)) |
| .Build(); |
| pass_list->clear(); |
| layer_tree_frame_sink_->SubmitCompositorFrame( |
| std::move(frame), hit_test_data_changed, |
| /*show_hit_test_borders=*/false); |
| } |
| |
| const viz::HitTestRegionList& GetHitTestData() const { |
| return layer_tree_frame_sink_->get_last_hit_test_data_for_testing(); |
| } |
| |
| AsyncLayerTreeFrameSink::InitParams init_params_; |
| |
| scoped_refptr<base::TestMockTimeTaskRunner> task_runner_; |
| viz::TestGpuMemoryBufferManager test_gpu_memory_buffer_manager_; |
| gfx::Rect display_rect_; |
| std::unique_ptr<AsyncLayerTreeFrameSink> layer_tree_frame_sink_; |
| FakeLayerTreeFrameSinkClient layer_tree_frame_sink_client_; |
| }; |
| |
| TEST_F(AsyncLayerTreeFrameSinkSimpleTest, HitTestRegionListDuplicate) { |
| viz::RenderPassList pass_list; |
| |
| // Initial submission. |
| auto pass1 = viz::RenderPass::Create(); |
| pass1->id = 1; |
| pass1->output_rect = display_rect_; |
| auto* shared_quad_state1 = pass1->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect1(display_rect_); |
| shared_quad_state1->SetAll( |
| gfx::Transform(), /*quad_layer_rect=*/rect1, |
| /*visible_quad_layer_rect=*/rect1, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect1, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad1 = |
| pass1->quad_list.AllocateAndConstruct<viz::SolidColorDrawQuad>(); |
| quad1->SetNew(shared_quad_state1, /*rect=*/rect1, |
| /*visible_rect=*/rect1, SK_ColorBLACK, |
| /*force_anti_aliasing_off=*/false); |
| pass_list.push_back(move(pass1)); |
| SendRenderPassList(&pass_list, /*hit_test_data_changed=*/false); |
| task_runner_->RunUntilIdle(); |
| const viz::HitTestRegionList hit_test_region_list = GetHitTestData(); |
| |
| // Identical submission. |
| auto pass2 = viz::RenderPass::Create(); |
| pass2->id = 2; |
| pass2->output_rect = display_rect_; |
| auto* shared_quad_state2 = pass2->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect2(display_rect_); |
| shared_quad_state2->SetAll( |
| gfx::Transform(), /*quad_layer_rect=*/rect2, |
| /*visible_quad_layer_rect=*/rect2, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect2, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad2 = |
| pass2->quad_list.AllocateAndConstruct<viz::SolidColorDrawQuad>(); |
| quad2->SetNew(shared_quad_state2, /*rect=*/rect2, |
| /*visible_rect=*/rect2, SK_ColorBLACK, |
| /*force_anti_aliasing_off=*/false); |
| pass_list.push_back(move(pass2)); |
| SendRenderPassList(&pass_list, /*hit_test_data_changed=*/false); |
| task_runner_->RunUntilIdle(); |
| |
| EXPECT_TRUE( |
| viz::HitTestRegionList::IsEqual(hit_test_region_list, GetHitTestData())); |
| |
| // Different submission. |
| const viz::SurfaceId child_surface_id( |
| viz::FrameSinkId(1, 1), |
| viz::LocalSurfaceId(2, base::UnguessableToken::Create())); |
| auto pass3_0 = viz::RenderPass::Create(); |
| pass3_0->output_rect = display_rect_; |
| pass3_0->id = 3; |
| auto* shared_quad_state3_0 = pass3_0->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect3_0(display_rect_); |
| gfx::Transform transform3_0; |
| transform3_0.Translate(-200, -100); |
| shared_quad_state3_0->SetAll( |
| transform3_0, /*quad_layer_rect=*/rect3_0, |
| /*visible_quad_layer_rect=*/rect3_0, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect3_0, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad3_0 = |
| pass3_0->quad_list.AllocateAndConstruct<viz::SurfaceDrawQuad>(); |
| quad3_0->SetNew(shared_quad_state3_0, /*rect=*/rect3_0, |
| /*visible_rect=*/rect3_0, |
| viz::SurfaceRange(base::nullopt, child_surface_id), |
| SK_ColorBLACK, |
| /*stretch_content_to_fill_bounds=*/false, |
| /*ignores_input_event=*/false); |
| pass_list.push_back(std::move(pass3_0)); |
| |
| auto pass3_1 = viz::RenderPass::Create(); |
| pass3_1->output_rect = display_rect_; |
| pass3_1->id = 4; |
| auto* shared_quad_state3_1 = pass3_1->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect3_1(display_rect_); |
| shared_quad_state3_1->SetAll( |
| gfx::Transform(), /*quad_layer_rect=*/rect3_1, |
| /*visible_quad_layer_rect=*/rect3_1, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect3_1, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad3_1 = |
| pass3_1->quad_list.AllocateAndConstruct<viz::SolidColorDrawQuad>(); |
| quad3_1->SetNew(shared_quad_state3_1, /*rect=*/rect3_1, |
| /*visible_rect=*/rect3_1, SK_ColorBLACK, |
| /*force_anti_aliasing_off=*/false); |
| pass_list.push_back(std::move(pass3_1)); |
| |
| auto pass3_root = viz::RenderPass::Create(); |
| pass3_root->output_rect = display_rect_; |
| pass3_root->id = 5; |
| auto* shared_quad_state3_root = pass3_root->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect3_root(display_rect_); |
| shared_quad_state3_root->SetAll( |
| gfx::Transform(), /*quad_layer_rect=*/rect3_root, |
| /*visible_quad_layer_rect=*/rect3_root, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect3_root, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad3_root_1 = |
| pass3_root->quad_list.AllocateAndConstruct<viz::RenderPassDrawQuad>(); |
| quad3_root_1->SetNew(shared_quad_state3_root, /*rect=*/rect3_root, |
| /*visible_rect=*/rect3_root, /*render_pass_id=*/3, |
| /*mask_resource_id=*/0, gfx::RectF(), gfx::Size(), |
| gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF(), false, |
| 1.0f); |
| auto* quad3_root_2 = |
| pass3_root->quad_list.AllocateAndConstruct<viz::RenderPassDrawQuad>(); |
| quad3_root_2->SetNew(shared_quad_state3_root, /*rect=*/rect3_root, |
| /*visible_rect=*/rect3_root, /*render_pass_id=*/4, |
| /*mask_resource_id=*/0, gfx::RectF(), gfx::Size(), |
| gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF(), false, |
| 1.0f); |
| pass_list.push_back(std::move(pass3_root)); |
| |
| SendRenderPassList(&pass_list, /*hit_test_data_changed=*/false); |
| task_runner_->RunUntilIdle(); |
| EXPECT_FALSE( |
| viz::HitTestRegionList::IsEqual(hit_test_region_list, GetHitTestData())); |
| } |
| |
| TEST_F(AsyncLayerTreeFrameSinkSimpleTest, |
| HitTestRegionListDuplicateChangedFlip) { |
| viz::RenderPassList pass_list; |
| |
| // Initial submission. |
| auto pass1 = viz::RenderPass::Create(); |
| pass1->id = 1; |
| pass1->output_rect = display_rect_; |
| auto* shared_quad_state1 = pass1->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect1(display_rect_); |
| shared_quad_state1->SetAll( |
| gfx::Transform(), /*quad_layer_rect=*/rect1, |
| /*visible_quad_layer_rect=*/rect1, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect1, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad1 = |
| pass1->quad_list.AllocateAndConstruct<viz::SolidColorDrawQuad>(); |
| quad1->SetNew(shared_quad_state1, /*rect=*/rect1, |
| /*visible_rect=*/rect1, SK_ColorBLACK, |
| /*force_anti_aliasing_off=*/false); |
| pass_list.push_back(move(pass1)); |
| SendRenderPassList(&pass_list, /*hit_test_data_changed=*/false); |
| task_runner_->RunUntilIdle(); |
| viz::HitTestRegionList hit_test_region_list = GetHitTestData(); |
| |
| // Different submission with |hit_test_data_changed| set to true. |
| const viz::SurfaceId child_surface_id( |
| viz::FrameSinkId(1, 1), |
| viz::LocalSurfaceId(2, base::UnguessableToken::Create())); |
| auto pass2_0 = viz::RenderPass::Create(); |
| pass2_0->output_rect = display_rect_; |
| pass2_0->id = 2; |
| auto* shared_quad_state2_0 = pass2_0->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect2_0(display_rect_); |
| gfx::Transform transform2_0; |
| transform2_0.Translate(-200, -100); |
| shared_quad_state2_0->SetAll( |
| transform2_0, /*quad_layer_rect=*/rect2_0, |
| /*visible_quad_layer_rect=*/rect2_0, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect2_0, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad2_0 = |
| pass2_0->quad_list.AllocateAndConstruct<viz::SurfaceDrawQuad>(); |
| quad2_0->SetNew(shared_quad_state2_0, /*rect=*/rect2_0, |
| /*visible_rect=*/rect2_0, |
| viz::SurfaceRange(base::nullopt, child_surface_id), |
| SK_ColorBLACK, |
| /*stretch_content_to_fill_bounds=*/false, |
| /*ignores_input_event=*/false); |
| pass_list.push_back(std::move(pass2_0)); |
| |
| auto pass2_1 = viz::RenderPass::Create(); |
| pass2_1->output_rect = display_rect_; |
| pass2_1->id = 3; |
| auto* shared_quad_state2_1 = pass2_1->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect2_1(display_rect_); |
| shared_quad_state2_1->SetAll( |
| gfx::Transform(), /*quad_layer_rect=*/rect2_1, |
| /*visible_quad_layer_rect=*/rect2_1, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect2_1, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad2_1 = |
| pass2_1->quad_list.AllocateAndConstruct<viz::SolidColorDrawQuad>(); |
| quad2_1->SetNew(shared_quad_state2_1, /*rect=*/rect2_1, |
| /*visible_rect=*/rect2_1, SK_ColorBLACK, |
| /*force_anti_aliasing_off=*/false); |
| pass_list.push_back(std::move(pass2_1)); |
| |
| auto pass2_root = viz::RenderPass::Create(); |
| pass2_root->output_rect = display_rect_; |
| pass2_root->id = 4; |
| auto* shared_quad_state2_root = pass2_root->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect2_root(display_rect_); |
| shared_quad_state2_root->SetAll( |
| gfx::Transform(), /*quad_layer_rect=*/rect2_root, |
| /*visible_quad_layer_rect=*/rect2_root, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect2_root, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad2_root_1 = |
| pass2_root->quad_list.AllocateAndConstruct<viz::RenderPassDrawQuad>(); |
| quad2_root_1->SetNew(shared_quad_state2_root, /*rect=*/rect2_root, |
| /*visible_rect=*/rect2_root, /*render_pass_id=*/2, |
| /*mask_resource_id=*/0, gfx::RectF(), gfx::Size(), |
| gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF(), false, |
| 1.0f); |
| auto* quad2_root_2 = |
| pass2_root->quad_list.AllocateAndConstruct<viz::RenderPassDrawQuad>(); |
| quad2_root_2->SetNew(shared_quad_state2_root, /*rect=*/rect2_root, |
| /*visible_rect=*/rect2_root, /*render_pass_id=*/3, |
| /*mask_resource_id=*/0, gfx::RectF(), gfx::Size(), |
| gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF(), false, |
| 1.0f); |
| pass_list.push_back(std::move(pass2_root)); |
| |
| SendRenderPassList(&pass_list, /*hit_test_data_changed=*/true); |
| task_runner_->RunUntilIdle(); |
| |
| EXPECT_FALSE( |
| viz::HitTestRegionList::IsEqual(hit_test_region_list, GetHitTestData())); |
| hit_test_region_list = GetHitTestData(); |
| |
| // Identical submission with |hit_test_data_changed| set back to false. We |
| // expect the hit-data to still have been sent. |
| auto pass3 = viz::RenderPass::Create(); |
| pass3->id = 4; |
| pass3->output_rect = display_rect_; |
| auto* shared_quad_state3 = pass3->CreateAndAppendSharedQuadState(); |
| gfx::Rect rect3(display_rect_); |
| shared_quad_state3->SetAll( |
| gfx::Transform(), /*quad_layer_rect=*/rect3, |
| /*visible_quad_layer_rect=*/rect3, |
| /*rounded_corner_bounds=*/gfx::RRectF(), /*clip_rect=*/rect3, |
| /*is_clipped=*/false, /*are_contents_opaque=*/false, |
| /*opacity=*/0.5f, SkBlendMode::kSrcOver, /*sorting_context_id=*/0); |
| auto* quad3 = |
| pass3->quad_list.AllocateAndConstruct<viz::SolidColorDrawQuad>(); |
| quad3->SetNew(shared_quad_state3, /*rect=*/rect3, |
| /*visible_rect=*/rect3, SK_ColorBLACK, |
| /*force_anti_aliasing_off=*/false); |
| pass_list.push_back(move(pass3)); |
| SendRenderPassList(&pass_list, /*hit_test_data_changed=*/false); |
| task_runner_->RunUntilIdle(); |
| |
| EXPECT_FALSE( |
| viz::HitTestRegionList::IsEqual(hit_test_region_list, GetHitTestData())); |
| } |
| |
| } // namespace mojo_embedder |
| } // namespace cc |
