From cde8e4c393b5518ec2acd2b2c15dd5dfa8f3b94a Mon Sep 17 00:00:00 2001 From: danakj Date: Mon, 25 Sep 2017 18:33:47 +0000 Subject: [PATCH] Remove cc::BlockingTaskRunner and cc::ReleaseCallbackImpl BlockingTaskRunner was introduced in order for resources released by a commit to be returned from the impl thread back to the main thread (ie have the main thread ReleaseCallback run) before the commit ended. This allowed cc clients to reuse textures immediately upon commit ending, allowing for less buffering. With the implementation of delgated compositing, the value of BlockingTaskRunner disppeared. Now the cases where the impl thread has a reference to return to the main thread during commit are very few. The only one that appeared in cc unittests was: - Make a layer undrawable (sized 0x0) - Set a mailbox, commit - Remove the layer from the tree, dropping the impl thread ref. - Expect to see mailbox returned inside the commit that removes the layer from the tree. Another case would be a texture layer which is not part of the on-screen frame. But as soon as the layer became visible, committing a mailbox would mean by the time the next commit happend, the mailbox has been sent to the display compositor and *can't* be returned. If unused in the next frame, the display compositor will return it async outside of commit, and we'll forward it to the main thread. So the main thread always needs extra buffering for on-screen texture layers now. By removing the complexity introduced by BlockingTaskRunner we will make a cc client animating a texture layer outside the viewport require extra an extra texture of buffering, just as it would need once it's in the viewport. So the memory overhead shouldn't be impactful - offscreen clients shouldn't be animating textures, and we'd need to allocate another texture as soon as they became visible anyway. Another concern is that on shutdown/removal from the tree, the resources should all be returned before the commit ends, so the client can destroy its own structures immediately. This is no longer the case with delegated rendering and any clients depending on this have already been leaking in the common case (layer on screen, and can be drawn). Removing this class will greatly simplify the effort to split ResourceProvider into two classes - to service the layer and the display compositors separately, as there's no BlockingTaskRunner in DisplayResourceProvider anymoore, which was a layer-tree concept. R=piman@chromium.org Bug: 738190 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I5d9ffe70e245cdc763f6672c0e8c561f9992de0c Reviewed-on: https://chromium-review.googlesource.com/679481 Commit-Queue: danakj Reviewed-by: Antoine Labour Cr-Commit-Position: refs/heads/master@{#504110} --- cc/BUILD.gn | 5 - cc/layers/texture_layer.cc | 23 +- cc/layers/texture_layer.h | 10 +- cc/layers/texture_layer_impl.cc | 12 +- cc/layers/texture_layer_impl.h | 9 +- cc/layers/texture_layer_impl_unittest.cc | 17 +- cc/layers/texture_layer_unittest.cc | 236 +++++------------ cc/layers/video_layer_impl.cc | 9 +- cc/layers/video_layer_impl.h | 4 +- cc/resources/display_resource_provider.cc | 8 +- cc/resources/display_resource_provider.h | 2 - cc/resources/layer_tree_resource_provider.cc | 2 - cc/resources/layer_tree_resource_provider.h | 2 - cc/resources/release_callback_impl.h | 24 -- cc/resources/resource_provider.cc | 27 +- cc/resources/resource_provider.h | 15 +- cc/resources/resource_provider_unittest.cc | 238 +++++++----------- cc/resources/return_callback.h | 6 +- cc/resources/single_release_callback_impl.cc | 34 --- cc/resources/single_release_callback_impl.h | 37 --- cc/resources/video_resource_updater.cc | 6 +- cc/resources/video_resource_updater.h | 12 +- .../video_resource_updater_unittest.cc | 13 +- cc/test/fake_resource_provider.h | 17 +- cc/test/pixel_test.cc | 13 +- cc/test/pixel_test.h | 1 - cc/test/render_pass_test_utils.cc | 17 +- cc/trees/blocking_task_runner.cc | 76 ------ cc/trees/blocking_task_runner.h | 98 -------- cc/trees/blocking_task_runner_unittest.cc | 45 ---- cc/trees/layer_tree_host_impl.cc | 1 - cc/trees/proxy_main.cc | 7 - cc/trees/single_thread_proxy.cc | 15 -- cc/trees/single_thread_proxy.h | 3 - cc/trees/task_runner_provider.cc | 8 +- cc/trees/task_runner_provider.h | 6 - components/viz/service/display/display.cc | 2 +- .../service/display/gl_renderer_unittest.cc | 13 +- .../viz/service/display/overlay_unittest.cc | 13 +- .../viz/service/display/renderer_pixeltest.cc | 10 +- .../viz/service/display/surface_aggregator.cc | 3 +- .../viz/service/display/surface_aggregator.h | 4 +- 42 files changed, 270 insertions(+), 833 deletions(-) delete mode 100644 cc/resources/release_callback_impl.h delete mode 100644 cc/resources/single_release_callback_impl.cc delete mode 100644 cc/resources/single_release_callback_impl.h delete mode 100644 cc/trees/blocking_task_runner.cc delete mode 100644 cc/trees/blocking_task_runner.h delete mode 100644 cc/trees/blocking_task_runner_unittest.cc diff --git a/cc/BUILD.gn b/cc/BUILD.gn index ea2179899f9d16..4f69bb4f17bcec 100644 --- a/cc/BUILD.gn +++ b/cc/BUILD.gn @@ -187,8 +187,6 @@ cc_component("cc") { "resources/scoped_resource.h", "resources/scoped_ui_resource.cc", "resources/scoped_ui_resource.h", - "resources/single_release_callback_impl.cc", - "resources/single_release_callback_impl.h", "resources/ui_resource_bitmap.cc", "resources/ui_resource_bitmap.h", "resources/ui_resource_client.h", @@ -258,8 +256,6 @@ cc_component("cc") { "tiles/tiling_set_raster_queue_all.h", "tiles/tiling_set_raster_queue_required.cc", "tiles/tiling_set_raster_queue_required.h", - "trees/blocking_task_runner.cc", - "trees/blocking_task_runner.h", "trees/clip_expander.cc", "trees/clip_expander.h", "trees/clip_node.cc", @@ -640,7 +636,6 @@ cc_test("cc_unittests") { "tiles/software_image_decode_cache_unittest.cc", "tiles/tile_manager_unittest.cc", "tiles/tile_priority_unittest.cc", - "trees/blocking_task_runner_unittest.cc", "trees/damage_tracker_unittest.cc", "trees/image_animation_controller_unittest.cc", "trees/layer_tree_frame_sink_unittest.cc", diff --git a/cc/layers/texture_layer.cc b/cc/layers/texture_layer.cc index df6e6c1189bed5..da5cae72ef6acb 100644 --- a/cc/layers/texture_layer.cc +++ b/cc/layers/texture_layer.cc @@ -13,8 +13,6 @@ #include "cc/base/simple_enclosed_region.h" #include "cc/layers/texture_layer_client.h" #include "cc/layers/texture_layer_impl.h" -#include "cc/resources/single_release_callback_impl.h" -#include "cc/trees/blocking_task_runner.h" #include "cc/trees/layer_tree_host.h" #include "components/viz/common/quads/single_release_callback.h" @@ -219,14 +217,15 @@ void TextureLayer::PushPropertiesTo(LayerImpl* layer) { texture_layer->SetBlendBackgroundColor(blend_background_color_); if (needs_set_mailbox_) { viz::TextureMailbox texture_mailbox; - std::unique_ptr release_callback_impl; + std::unique_ptr release_callback; if (holder_ref_) { TextureMailboxHolder* holder = holder_ref_->holder(); texture_mailbox = holder->mailbox(); - release_callback_impl = holder->GetCallbackForImplThread(); + release_callback = holder->GetCallbackForImplThread( + layer_tree_host()->GetTaskRunnerProvider()->MainThreadTaskRunner()); } texture_layer->SetTextureMailbox(texture_mailbox, - std::move(release_callback_impl)); + std::move(release_callback)); needs_set_mailbox_ = false; } } @@ -271,14 +270,16 @@ void TextureLayer::TextureMailboxHolder::Return( is_lost_ = is_lost; } -std::unique_ptr -TextureLayer::TextureMailboxHolder::GetCallbackForImplThread() { +std::unique_ptr +TextureLayer::TextureMailboxHolder::GetCallbackForImplThread( + scoped_refptr main_thread_task_runner) { // We can't call GetCallbackForImplThread if we released the main thread // reference. DCHECK_GT(internal_references_, 0u); InternalAddRef(); - return SingleReleaseCallbackImpl::Create( - base::Bind(&TextureMailboxHolder::ReturnAndReleaseOnImplThread, this)); + return viz::SingleReleaseCallback::Create( + base::Bind(&TextureMailboxHolder::ReturnAndReleaseOnImplThread, this, + std::move(main_thread_task_runner))); } void TextureLayer::TextureMailboxHolder::InternalAddRef() { @@ -295,9 +296,9 @@ void TextureLayer::TextureMailboxHolder::InternalRelease() { } void TextureLayer::TextureMailboxHolder::ReturnAndReleaseOnImplThread( + const scoped_refptr& main_thread_task_runner, const gpu::SyncToken& sync_token, - bool is_lost, - BlockingTaskRunner* main_thread_task_runner) { + bool is_lost) { Return(sync_token, is_lost); main_thread_task_runner->PostTask( FROM_HERE, base::Bind(&TextureMailboxHolder::InternalRelease, this)); diff --git a/cc/layers/texture_layer.h b/cc/layers/texture_layer.h index c13f47b6c25d68..5fe35c202acb26 100644 --- a/cc/layers/texture_layer.h +++ b/cc/layers/texture_layer.h @@ -24,8 +24,7 @@ class SingleReleaseCallback; } namespace cc { -class BlockingTaskRunner; -class SingleReleaseCallbackImpl; +class SingleReleaseCallback; class TextureLayerClient; // A Layer containing a the rendered output of a plugin instance. @@ -50,7 +49,8 @@ class CC_EXPORT TextureLayer : public Layer { // Gets a viz::ReleaseCallback that can be called from another thread. Note: // the caller must ensure the callback is called. - std::unique_ptr GetCallbackForImplThread(); + std::unique_ptr GetCallbackForImplThread( + scoped_refptr main_thread_task_runner); protected: friend class TextureLayer; @@ -71,9 +71,9 @@ class CC_EXPORT TextureLayer : public Layer { void InternalAddRef(); void InternalRelease(); void ReturnAndReleaseOnImplThread( + const scoped_refptr& main_thread_task_runner, const gpu::SyncToken& sync_token, - bool is_lost, - BlockingTaskRunner* main_thread_task_runner); + bool is_lost); // These members are only accessed on the main thread, or on the impl thread // during commit where the main thread is blocked. diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc index 3ee05055735b5b..ee7e4f93856610 100644 --- a/cc/layers/texture_layer_impl.cc +++ b/cc/layers/texture_layer_impl.cc @@ -11,9 +11,9 @@ #include "base/strings/stringprintf.h" #include "cc/resources/scoped_resource.h" -#include "cc/resources/single_release_callback_impl.h" #include "cc/trees/layer_tree_impl.h" #include "cc/trees/occlusion.h" +#include "components/viz/common/quads/single_release_callback.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/platform_color.h" @@ -41,7 +41,7 @@ TextureLayerImpl::~TextureLayerImpl() { FreeTextureMailbox(); } void TextureLayerImpl::SetTextureMailbox( const viz::TextureMailbox& mailbox, - std::unique_ptr release_callback) { + std::unique_ptr release_callback) { DCHECK_EQ(mailbox.IsValid(), !!release_callback); FreeTextureMailbox(); texture_mailbox_ = mailbox; @@ -248,12 +248,8 @@ const char* TextureLayerImpl::LayerTypeAsString() const { void TextureLayerImpl::FreeTextureMailbox() { if (own_mailbox_) { DCHECK(!external_texture_resource_); - if (release_callback_) { - release_callback_->Run(texture_mailbox_.sync_token(), false, - layer_tree_impl() - ->task_runner_provider() - ->blocking_main_thread_task_runner()); - } + if (release_callback_) + release_callback_->Run(texture_mailbox_.sync_token(), false); texture_mailbox_ = viz::TextureMailbox(); release_callback_ = nullptr; } else if (external_texture_resource_) { diff --git a/cc/layers/texture_layer_impl.h b/cc/layers/texture_layer_impl.h index da51a1f0ce9241..0f942c57687af5 100644 --- a/cc/layers/texture_layer_impl.h +++ b/cc/layers/texture_layer_impl.h @@ -13,8 +13,11 @@ #include "cc/cc_export.h" #include "cc/layers/layer_impl.h" +namespace viz { +class SingleReleaseCallback; +} + namespace cc { -class SingleReleaseCallbackImpl; class ScopedResource; class CC_EXPORT TextureLayerImpl : public LayerImpl { @@ -55,7 +58,7 @@ class CC_EXPORT TextureLayerImpl : public LayerImpl { void SetTextureMailbox( const viz::TextureMailbox& mailbox, - std::unique_ptr release_callback); + std::unique_ptr release_callback); private: TextureLayerImpl(LayerTreeImpl* tree_impl, int id); @@ -75,7 +78,7 @@ class CC_EXPORT TextureLayerImpl : public LayerImpl { std::unique_ptr texture_copy_; viz::TextureMailbox texture_mailbox_; - std::unique_ptr release_callback_; + std::unique_ptr release_callback_; bool own_mailbox_; bool valid_texture_copy_; diff --git a/cc/layers/texture_layer_impl_unittest.cc b/cc/layers/texture_layer_impl_unittest.cc index 7fcc1f9016aba5..b1f0e5b586e5c7 100644 --- a/cc/layers/texture_layer_impl_unittest.cc +++ b/cc/layers/texture_layer_impl_unittest.cc @@ -18,9 +18,7 @@ namespace cc { namespace { -void IgnoreCallback(const gpu::SyncToken& sync_token, - bool lost, - BlockingTaskRunner* main_thread_task_runner) {} +void IgnoreCallback(const gpu::SyncToken& sync_token, bool lost) {} TEST(TextureLayerImplTest, VisibleOpaqueRegion) { const gfx::Size layer_bounds(100, 100); @@ -71,7 +69,7 @@ TEST(TextureLayerImplTest, Occlusion) { texture_layer_impl->SetDrawsContent(true); texture_layer_impl->SetTextureMailbox( texture_mailbox, - SingleReleaseCallbackImpl::Create(base::Bind(&IgnoreCallback))); + viz::SingleReleaseCallback::Create(base::Bind(&IgnoreCallback))); impl.CalcDrawProps(viewport_size); @@ -131,7 +129,7 @@ TEST(TextureLayerImplTest, OutputIsSecure) { texture_layer_impl->SetDrawsContent(true); texture_layer_impl->SetTextureMailbox( texture_mailbox, - SingleReleaseCallbackImpl::Create(base::Bind(&IgnoreCallback))); + viz::SingleReleaseCallback::Create(base::Bind(&IgnoreCallback))); impl.CalcDrawProps(viewport_size); @@ -173,11 +171,10 @@ TEST(TextureLayerImplTest, ResourceNotFreedOnGpuRasterToggle) { texture_layer_impl->SetBounds(layer_size); texture_layer_impl->SetDrawsContent(true); texture_layer_impl->SetTextureMailbox( - texture_mailbox, - SingleReleaseCallbackImpl::Create(base::Bind( - [](bool* released, const gpu::SyncToken& sync_token, bool lost, - BlockingTaskRunner* main_thread_task_runner) { *released = true; }, - base::Unretained(&released)))); + texture_mailbox, viz::SingleReleaseCallback::Create(base::Bind( + [](bool* released, const gpu::SyncToken& sync_token, + bool lost) { *released = true; }, + base::Unretained(&released)))); impl.CalcDrawProps(viewport_size); diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc index ed4de24d94601a..78262ddc3348ec 100644 --- a/cc/layers/texture_layer_unittest.cc +++ b/cc/layers/texture_layer_unittest.cc @@ -34,7 +34,6 @@ #include "cc/test/stub_layer_tree_host_single_thread_client.h" #include "cc/test/test_task_graph_runner.h" #include "cc/test/test_web_graphics_context_3d.h" -#include "cc/trees/blocking_task_runner.h" #include "cc/trees/layer_tree_host.h" #include "cc/trees/layer_tree_impl.h" #include "cc/trees/single_thread_proxy.h" @@ -81,7 +80,6 @@ class MockLayerTreeHost : public LayerTreeHost { } MOCK_METHOD0(SetNeedsCommit, void()); - MOCK_METHOD0(SetNeedsUpdateLayers, void()); MOCK_METHOD0(StartRateLimiter, void()); MOCK_METHOD0(StopRateLimiter, void()); @@ -136,16 +134,6 @@ class MockMailboxCallback { void(viz::SharedBitmap* shared_bitmap, const gpu::SyncToken& sync_token, bool lost_resource)); - MOCK_METHOD4(ReleaseImpl, - void(const gpu::Mailbox& mailbox, - const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner)); - MOCK_METHOD4(ReleaseImpl2, - void(viz::SharedBitmap* shared_bitmap, - const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner)); }; struct CommonMailboxObjects { @@ -166,12 +154,6 @@ struct CommonMailboxObjects { release_mailbox2_ = base::Bind(&MockMailboxCallback::Release, base::Unretained(&mock_callback_), mailbox_name2_); - release_mailbox1_impl_ = base::Bind(&MockMailboxCallback::ReleaseImpl, - base::Unretained(&mock_callback_), - mailbox_name1_); - release_mailbox2_impl_ = base::Bind(&MockMailboxCallback::ReleaseImpl, - base::Unretained(&mock_callback_), - mailbox_name2_); const uint32_t arbitrary_target1 = GL_TEXTURE_2D; const uint32_t arbitrary_target2 = GL_TEXTURE_EXTERNAL_OES; mailbox1_ = @@ -184,9 +166,6 @@ struct CommonMailboxObjects { release_mailbox3_ = base::Bind(&MockMailboxCallback::Release2, base::Unretained(&mock_callback_), shared_bitmap_.get()); - release_mailbox3_impl_ = - base::Bind(&MockMailboxCallback::ReleaseImpl2, - base::Unretained(&mock_callback_), shared_bitmap_.get()); mailbox3_ = viz::TextureMailbox(shared_bitmap_.get(), size); } @@ -196,9 +175,6 @@ struct CommonMailboxObjects { viz::ReleaseCallback release_mailbox1_; viz::ReleaseCallback release_mailbox2_; viz::ReleaseCallback release_mailbox3_; - ReleaseCallbackImpl release_mailbox1_impl_; - ReleaseCallbackImpl release_mailbox2_impl_; - ReleaseCallbackImpl release_mailbox3_impl_; viz::TextureMailbox mailbox1_; viz::TextureMailbox mailbox2_; viz::TextureMailbox mailbox3_; @@ -344,11 +320,6 @@ class TextureLayerMailboxHolderTest : public TextureLayerTest { TextureLayerMailboxHolderTest() : main_thread_("MAIN") { main_thread_.Start(); - main_thread_.task_runner()->PostTask( - FROM_HERE, - base::BindOnce(&TextureLayerMailboxHolderTest::InitializeOnMain, - base::Unretained(this))); - Wait(main_thread_); } void Wait(const base::Thread& thread) { @@ -368,29 +339,16 @@ class TextureLayerMailboxHolderTest : public TextureLayerTest { void ReleaseMainRef() { main_ref_ = nullptr; } - void CreateImplRef(std::unique_ptr* impl_ref) { - *impl_ref = main_ref_->holder()->GetCallbackForImplThread(); - } - - void CapturePostTasksAndWait(base::WaitableEvent* begin_capture, - base::WaitableEvent* wait_for_capture, - base::WaitableEvent* stop_capture) { - begin_capture->Wait(); - BlockingTaskRunner::CapturePostTasks capture( - main_thread_task_runner_.get()); - wait_for_capture->Signal(); - stop_capture->Wait(); + void CreateImplRef( + std::unique_ptr* impl_ref, + scoped_refptr main_thread_task_runner) { + *impl_ref = main_ref_->holder()->GetCallbackForImplThread( + std::move(main_thread_task_runner)); } protected: - void InitializeOnMain() { - main_thread_task_runner_ = - BlockingTaskRunner::Create(main_thread_.task_runner()); - } - std::unique_ptr main_ref_; base::Thread main_thread_; - std::unique_ptr main_thread_task_runner_; }; TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_BothReleaseThenMain) { @@ -406,27 +364,27 @@ TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_BothReleaseThenMain) { // The texture layer is attached to compositor1, and passes a reference to its // impl tree. - std::unique_ptr compositor1; + std::unique_ptr compositor1; main_thread_.task_runner()->PostTask( FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateImplRef, - base::Unretained(this), &compositor1)); + base::Unretained(this), &compositor1, + main_thread_.task_runner())); // Then the texture layer is removed and attached to compositor2, and passes a // reference to its impl tree. - std::unique_ptr compositor2; + std::unique_ptr compositor2; main_thread_.task_runner()->PostTask( FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateImplRef, - base::Unretained(this), &compositor2)); + base::Unretained(this), &compositor2, + main_thread_.task_runner())); Wait(main_thread_); Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); // The compositors both destroy their impl trees before the main thread layer // is destroyed. - compositor1->Run(SyncTokenFromUInt(100), false, - main_thread_task_runner_.get()); - compositor2->Run(SyncTokenFromUInt(200), false, - main_thread_task_runner_.get()); + compositor1->Run(SyncTokenFromUInt(100), false); + compositor2->Run(SyncTokenFromUInt(200), false); Wait(main_thread_); @@ -459,24 +417,25 @@ TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleaseBetween) { // The texture layer is attached to compositor1, and passes a reference to its // impl tree. - std::unique_ptr compositor1; + std::unique_ptr compositor1; main_thread_.task_runner()->PostTask( FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateImplRef, - base::Unretained(this), &compositor1)); + base::Unretained(this), &compositor1, + main_thread_.task_runner())); // Then the texture layer is removed and attached to compositor2, and passes a // reference to its impl tree. - std::unique_ptr compositor2; + std::unique_ptr compositor2; main_thread_.task_runner()->PostTask( FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateImplRef, - base::Unretained(this), &compositor2)); + base::Unretained(this), &compositor2, + main_thread_.task_runner())); Wait(main_thread_); Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); // One compositor destroys their impl tree. - compositor1->Run(SyncTokenFromUInt(100), false, - main_thread_task_runner_.get()); + compositor1->Run(SyncTokenFromUInt(100), false); // Then the main thread reference is destroyed. main_thread_.task_runner()->PostTask( @@ -494,8 +453,7 @@ TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleaseBetween) { Release(test_data_.mailbox_name1_, SyncTokenFromUInt(200), true)) .Times(1); - compositor2->Run(SyncTokenFromUInt(200), true, - main_thread_task_runner_.get()); + compositor2->Run(SyncTokenFromUInt(200), true); Wait(main_thread_); Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); } @@ -513,17 +471,19 @@ TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleasedFirst) { // The texture layer is attached to compositor1, and passes a reference to its // impl tree. - std::unique_ptr compositor1; + std::unique_ptr compositor1; main_thread_.task_runner()->PostTask( FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateImplRef, - base::Unretained(this), &compositor1)); + base::Unretained(this), &compositor1, + main_thread_.task_runner())); // Then the texture layer is removed and attached to compositor2, and passes a // reference to its impl tree. - std::unique_ptr compositor2; + std::unique_ptr compositor2; main_thread_.task_runner()->PostTask( FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateImplRef, - base::Unretained(this), &compositor2)); + base::Unretained(this), &compositor2, + main_thread_.task_runner())); Wait(main_thread_); Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); @@ -534,8 +494,7 @@ TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleasedFirst) { base::Unretained(this))); // One compositor destroys their impl tree. - compositor2->Run(SyncTokenFromUInt(200), false, - main_thread_task_runner_.get()); + compositor2->Run(SyncTokenFromUInt(200), false); Wait(main_thread_); @@ -548,88 +507,8 @@ TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleasedFirst) { Release(test_data_.mailbox_name1_, SyncTokenFromUInt(100), true)) .Times(1); - compositor1->Run(SyncTokenFromUInt(100), true, - main_thread_task_runner_.get()); - Wait(main_thread_); - Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); -} - -TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_SecondImplRefShortcut) { - scoped_refptr test_layer = - TextureLayer::CreateForMailbox(nullptr); - ASSERT_TRUE(test_layer.get()); - - main_thread_.task_runner()->PostTask( - FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateMainRef, - base::Unretained(this))); - - Wait(main_thread_); - - // The texture layer is attached to compositor1, and passes a reference to its - // impl tree. - std::unique_ptr compositor1; - main_thread_.task_runner()->PostTask( - FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateImplRef, - base::Unretained(this), &compositor1)); - - // Then the texture layer is removed and attached to compositor2, and passes a - // reference to its impl tree. - std::unique_ptr compositor2; - main_thread_.task_runner()->PostTask( - FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::CreateImplRef, - base::Unretained(this), &compositor2)); - - Wait(main_thread_); - Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); - - // The main thread reference is destroyed first. - main_thread_.task_runner()->PostTask( - FROM_HERE, base::BindOnce(&TextureLayerMailboxHolderTest::ReleaseMainRef, - base::Unretained(this))); - - EXPECT_CALL(test_data_.mock_callback_, - Release(test_data_.mailbox_name1_, SyncTokenFromUInt(200), true)) - .Times(1); - - base::WaitableEvent begin_capture( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); - base::WaitableEvent wait_for_capture( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); - base::WaitableEvent stop_capture( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); - - // Post a task to start capturing tasks on the main thread. This will block - // the main thread until we signal the |stop_capture| event. - main_thread_.task_runner()->PostTask( - FROM_HERE, - base::BindOnce(&TextureLayerMailboxHolderTest::CapturePostTasksAndWait, - base::Unretained(this), &begin_capture, &wait_for_capture, - &stop_capture)); - - // Before the main thread capturing starts, one compositor destroys their - // impl reference. Since capturing did not start, this gets post-tasked to - // the main thread. - compositor1->Run(SyncTokenFromUInt(100), false, - main_thread_task_runner_.get()); - - // Start capturing on the main thread. - begin_capture.Signal(); - wait_for_capture.Wait(); - - // Meanwhile, the second compositor released its impl reference, but this task - // gets shortcutted directly to the main thread. This means the reference is - // released before compositor1, whose reference will be released later when - // the post-task is serviced. But since it was destroyed _on the impl thread_ - // last, its sync point values should be used. - compositor2->Run(SyncTokenFromUInt(200), true, - main_thread_task_runner_.get()); - - stop_capture.Signal(); + compositor1->Run(SyncTokenFromUInt(100), true); Wait(main_thread_); - Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); } @@ -705,8 +584,16 @@ class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest { break; case 7: EXPECT_EQ(4, callback_count_); - // Resetting the mailbox will call the callback now. + // Resetting the mailbox will call the callback now, before another + // commit is needed, as the ReleaseCallback is already in flight from + // RemoveFromParent(). layer_->SetTextureMailbox(viz::TextureMailbox(), nullptr); + pending_callback_ = true; + frame_number_ = layer_tree_host()->SourceFrameNumber(); + break; + case 8: + // A commit wasn't needed, the ReleaseCallback was already in flight. + EXPECT_EQ(frame_number_, layer_tree_host()->SourceFrameNumber()); EXPECT_EQ(5, callback_count_); EndTest(); break; @@ -779,6 +666,7 @@ class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest { base::ThreadChecker main_thread_; int callback_count_ = 0; int test_case_ = 0; + int frame_number_ = 0; // Whether we are waiting on a callback to advance the test case. bool pending_callback_ = false; scoped_refptr root_; @@ -913,11 +801,11 @@ class TextureLayerImplWithMailboxTest : public TextureLayerTest { TEST_F(TextureLayerImplWithMailboxTest, TestWillDraw) { EXPECT_CALL( test_data_.mock_callback_, - ReleaseImpl(test_data_.mailbox_name1_, test_data_.sync_token1_, false, _)) + Release(test_data_.mailbox_name1_, test_data_.sync_token1_, false)) .Times(AnyNumber()); EXPECT_CALL( test_data_.mock_callback_, - ReleaseImpl2(test_data_.shared_bitmap_.get(), gpu::SyncToken(), false, _)) + Release2(test_data_.shared_bitmap_.get(), gpu::SyncToken(), false)) .Times(AnyNumber()); // Hardware mode. { @@ -925,7 +813,7 @@ TEST_F(TextureLayerImplWithMailboxTest, TestWillDraw) { TextureLayerImpl::Create(host_impl_.active_tree(), 1); impl_layer->SetTextureMailbox( test_data_.mailbox1_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox1_)); EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE)); } @@ -942,7 +830,7 @@ TEST_F(TextureLayerImplWithMailboxTest, TestWillDraw) { TextureLayerImpl::Create(host_impl_.active_tree(), 1); impl_layer->SetTextureMailbox( test_data_.mailbox3_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox3_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox3_)); EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE)); } @@ -952,7 +840,7 @@ TEST_F(TextureLayerImplWithMailboxTest, TestWillDraw) { TextureLayerImpl::Create(host_impl_.active_tree(), 1); impl_layer->SetTextureMailbox( test_data_.mailbox1_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox1_)); EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE)); } @@ -969,7 +857,7 @@ TEST_F(TextureLayerImplWithMailboxTest, TestWillDraw) { TextureLayerImpl::Create(host_impl_.active_tree(), 1); impl_layer->SetTextureMailbox( test_data_.mailbox3_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox3_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox3_)); EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE)); } @@ -979,7 +867,7 @@ TEST_F(TextureLayerImplWithMailboxTest, TestWillDraw) { TextureLayerImpl::Create(host_impl_.active_tree(), 1); impl_layer->SetTextureMailbox( test_data_.mailbox1_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox1_)); EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_RESOURCELESS_SOFTWARE)); } } @@ -996,37 +884,39 @@ TEST_F(TextureLayerImplWithMailboxTest, TestImplLayerCallbacks) { pending_layer->SetTextureMailbox( test_data_.mailbox1_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox1_)); // Test multiple commits without an activation. EXPECT_CALL( test_data_.mock_callback_, - ReleaseImpl(test_data_.mailbox_name1_, test_data_.sync_token1_, false, _)) + Release(test_data_.mailbox_name1_, test_data_.sync_token1_, false)) .Times(1); pending_layer->SetTextureMailbox( test_data_.mailbox2_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox2_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox2_)); Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); // Test callback after activation. pending_layer->PushPropertiesTo(active_layer.get()); active_layer->DidBecomeActive(); - EXPECT_CALL(test_data_.mock_callback_, ReleaseImpl(_, _, _, _)).Times(0); + EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0); pending_layer->SetTextureMailbox( test_data_.mailbox1_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox1_)); Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); EXPECT_CALL(test_data_.mock_callback_, - ReleaseImpl(test_data_.mailbox_name2_, _, false, _)).Times(1); + Release(test_data_.mailbox_name2_, _, false)) + .Times(1); pending_layer->PushPropertiesTo(active_layer.get()); active_layer->DidBecomeActive(); Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); // Test resetting the mailbox. EXPECT_CALL(test_data_.mock_callback_, - ReleaseImpl(test_data_.mailbox_name1_, _, false, _)).Times(1); + Release(test_data_.mailbox_name1_, _, false)) + .Times(1); pending_layer->SetTextureMailbox(viz::TextureMailbox(), nullptr); pending_layer->PushPropertiesTo(active_layer.get()); active_layer->DidBecomeActive(); @@ -1035,11 +925,11 @@ TEST_F(TextureLayerImplWithMailboxTest, TestImplLayerCallbacks) { // Test destructor. EXPECT_CALL( test_data_.mock_callback_, - ReleaseImpl(test_data_.mailbox_name1_, test_data_.sync_token1_, false, _)) + Release(test_data_.mailbox_name1_, test_data_.sync_token1_, false)) .Times(1); pending_layer->SetTextureMailbox( test_data_.mailbox1_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox1_)); } TEST_F(TextureLayerImplWithMailboxTest, @@ -1049,10 +939,11 @@ TEST_F(TextureLayerImplWithMailboxTest, ASSERT_TRUE(impl_layer); EXPECT_CALL(test_data_.mock_callback_, - ReleaseImpl(test_data_.mailbox_name1_, _, false, _)).Times(1); + Release(test_data_.mailbox_name1_, _, false)) + .Times(1); impl_layer->SetTextureMailbox( test_data_.mailbox1_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox1_)); impl_layer->DidBecomeActive(); EXPECT_TRUE(impl_layer->WillDraw( DRAW_MODE_HARDWARE, host_impl_.active_tree()->resource_provider())); @@ -1065,7 +956,7 @@ TEST_F(TextureLayerImplWithMailboxTest, TestCallbackOnInUseResource) { host_impl_.active_tree()->resource_provider(); viz::ResourceId id = provider->CreateResourceFromTextureMailbox( test_data_.mailbox1_, - SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_)); + viz::SingleReleaseCallback::Create(test_data_.release_mailbox1_)); provider->AllocateForTesting(id); // Transfer some resources to the parent. @@ -1074,11 +965,12 @@ TEST_F(TextureLayerImplWithMailboxTest, TestCallbackOnInUseResource) { std::vector list; provider->PrepareSendToParent(resource_ids_to_transfer, &list); EXPECT_TRUE(provider->InUseByConsumer(id)); - EXPECT_CALL(test_data_.mock_callback_, ReleaseImpl(_, _, _, _)).Times(0); + EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0); provider->DeleteResource(id); Mock::VerifyAndClearExpectations(&test_data_.mock_callback_); EXPECT_CALL(test_data_.mock_callback_, - ReleaseImpl(test_data_.mailbox_name1_, _, false, _)).Times(1); + Release(test_data_.mailbox_name1_, _, false)) + .Times(1); std::vector returned = viz::TransferableResource::ReturnResources(list); provider->ReceiveReturnsFromParent(returned); diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc index 618c718da72c97..7d84abf66e7f58 100644 --- a/cc/layers/video_layer_impl.cc +++ b/cc/layers/video_layer_impl.cc @@ -11,10 +11,10 @@ #include "base/memory/ptr_util.h" #include "cc/layers/video_frame_provider_client_impl.h" #include "cc/resources/resource_provider.h" -#include "cc/resources/single_release_callback_impl.h" #include "cc/trees/layer_tree_impl.h" #include "cc/trees/occlusion.h" #include "cc/trees/task_runner_provider.h" +#include "components/viz/common/quads/single_release_callback.h" #include "components/viz/common/quads/stream_video_draw_quad.h" #include "components/viz/common/quads/texture_draw_quad.h" #include "components/viz/common/quads/yuv_video_draw_quad.h" @@ -129,7 +129,7 @@ bool VideoLayerImpl::WillDraw(DrawMode draw_mode, for (size_t i = 0; i < external_resources.mailboxes.size(); ++i) { unsigned resource_id = resource_provider->CreateResourceFromTextureMailbox( external_resources.mailboxes[i], - SingleReleaseCallbackImpl::Create( + viz::SingleReleaseCallback::Create( external_resources.release_callbacks[i]), external_resources.read_lock_fences_enabled, external_resources.buffer_format); @@ -337,10 +337,7 @@ void VideoLayerImpl::DidDraw(ResourceProvider* resource_provider) { if (frame_resource_type_ == VideoFrameExternalResources::SOFTWARE_RESOURCE) { for (size_t i = 0; i < software_resources_.size(); ++i) { - software_release_callback_.Run(gpu::SyncToken(), false, - layer_tree_impl() - ->task_runner_provider() - ->blocking_main_thread_task_runner()); + software_release_callback_.Run(gpu::SyncToken(), false); } software_resources_.clear(); diff --git a/cc/layers/video_layer_impl.h b/cc/layers/video_layer_impl.h index 8e4a1a3e1fb2f3..0bf9a2da4509f8 100644 --- a/cc/layers/video_layer_impl.h +++ b/cc/layers/video_layer_impl.h @@ -10,8 +10,8 @@ #include "base/macros.h" #include "cc/cc_export.h" #include "cc/layers/layer_impl.h" -#include "cc/resources/release_callback_impl.h" #include "cc/resources/video_resource_updater.h" +#include "components/viz/common/quads/release_callback.h" #include "media/base/video_rotation.h" namespace media { @@ -85,7 +85,7 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl { // ExternalResource (aka TextureMailbox) classes. std::vector software_resources_; // Called once for each software resource. - ReleaseCallbackImpl software_release_callback_; + viz::ReleaseCallback software_release_callback_; DISALLOW_COPY_AND_ASSIGN(VideoLayerImpl); }; diff --git a/cc/resources/display_resource_provider.cc b/cc/resources/display_resource_provider.cc index cb31b65a08d159..19dafce434139c 100644 --- a/cc/resources/display_resource_provider.cc +++ b/cc/resources/display_resource_provider.cc @@ -18,14 +18,12 @@ DisplayResourceProvider::DisplayResourceProvider( viz::ContextProvider* compositor_context_provider, viz::SharedBitmapManager* shared_bitmap_manager, gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, - BlockingTaskRunner* blocking_main_thread_task_runner, bool delegated_sync_points_required, bool enable_color_correct_rasterization, const viz::ResourceSettings& resource_settings) : ResourceProvider(compositor_context_provider, shared_bitmap_manager, gpu_memory_buffer_manager, - blocking_main_thread_task_runner, delegated_sync_points_required, enable_color_correct_rasterization, resource_settings) {} @@ -252,8 +250,7 @@ void DisplayResourceProvider::DeleteAndReturnUnusedResourcesToChild( returned->sync_token = new_sync_token; if (!to_return.empty()) - child_info->return_callback.Run(to_return, - blocking_main_thread_task_runner_); + child_info->return_callback.Run(to_return); if (child_info->marked_for_deletion && child_info->child_to_parent_map.empty()) { @@ -286,8 +283,7 @@ void DisplayResourceProvider::ReceiveFromChild( "cc", "DisplayResourceProvider::ReceiveFromChild dropping invalid"); std::vector to_return; to_return.push_back(it->ToReturnedResource()); - child_info.return_callback.Run(to_return, - blocking_main_thread_task_runner_); + child_info.return_callback.Run(to_return); continue; } diff --git a/cc/resources/display_resource_provider.h b/cc/resources/display_resource_provider.h index 33ecbb11233e65..66a64b9900afd9 100644 --- a/cc/resources/display_resource_provider.h +++ b/cc/resources/display_resource_provider.h @@ -14,7 +14,6 @@ class SharedBitmapManager; } // namespace viz namespace cc { -class BlockingTaskRunner; // This class is not thread-safe and can only be called from the thread it was // created on. @@ -24,7 +23,6 @@ class CC_EXPORT DisplayResourceProvider : public ResourceProvider { viz::ContextProvider* compositor_context_provider, viz::SharedBitmapManager* shared_bitmap_manager, gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, - BlockingTaskRunner* blocking_main_thread_task_runner, bool delegated_sync_points_required, bool enable_color_correct_rasterization, const viz::ResourceSettings& resource_settings); diff --git a/cc/resources/layer_tree_resource_provider.cc b/cc/resources/layer_tree_resource_provider.cc index c37f56abad1e33..d82b0546dac324 100644 --- a/cc/resources/layer_tree_resource_provider.cc +++ b/cc/resources/layer_tree_resource_provider.cc @@ -18,14 +18,12 @@ LayerTreeResourceProvider::LayerTreeResourceProvider( viz::ContextProvider* compositor_context_provider, viz::SharedBitmapManager* shared_bitmap_manager, gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, - BlockingTaskRunner* blocking_main_thread_task_runner, bool delegated_sync_points_required, bool enable_color_correct_rasterization, const viz::ResourceSettings& resource_settings) : ResourceProvider(compositor_context_provider, shared_bitmap_manager, gpu_memory_buffer_manager, - blocking_main_thread_task_runner, delegated_sync_points_required, enable_color_correct_rasterization, resource_settings) {} diff --git a/cc/resources/layer_tree_resource_provider.h b/cc/resources/layer_tree_resource_provider.h index 95c1f397ddc4d6..25603c36416787 100644 --- a/cc/resources/layer_tree_resource_provider.h +++ b/cc/resources/layer_tree_resource_provider.h @@ -12,7 +12,6 @@ class SharedBitmapManager; } // namespace viz namespace cc { -class BlockingTaskRunner; // This class is not thread-safe and can only be called from the thread it was // created on (in practice, the impl thread). @@ -22,7 +21,6 @@ class CC_EXPORT LayerTreeResourceProvider : public ResourceProvider { viz::ContextProvider* compositor_context_provider, viz::SharedBitmapManager* shared_bitmap_manager, gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, - BlockingTaskRunner* blocking_main_thread_task_runner, bool delegated_sync_points_required, bool enable_color_correct_rasterization, const viz::ResourceSettings& resource_settings); diff --git a/cc/resources/release_callback_impl.h b/cc/resources/release_callback_impl.h deleted file mode 100644 index c5dffb57ab04f5..00000000000000 --- a/cc/resources/release_callback_impl.h +++ /dev/null @@ -1,24 +0,0 @@ -// Copyright 2014 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. - -#ifndef CC_RESOURCES_RELEASE_CALLBACK_IMPL_H_ -#define CC_RESOURCES_RELEASE_CALLBACK_IMPL_H_ - -#include "base/callback.h" - -namespace gpu { -struct SyncToken; -} - -namespace cc { -class BlockingTaskRunner; - -typedef base::Callback - ReleaseCallbackImpl; - -} // namespace cc - -#endif // CC_RESOURCES_RELEASE_CALLBACK_IMPL_H_ diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc index 64264cd03ec8a7..9be259bf057e92 100644 --- a/cc/resources/resource_provider.cc +++ b/cc/resources/resource_provider.cc @@ -384,7 +384,6 @@ ResourceProvider::ResourceProvider( viz::ContextProvider* compositor_context_provider, viz::SharedBitmapManager* shared_bitmap_manager, gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, - BlockingTaskRunner* blocking_main_thread_task_runner, bool delegated_sync_points_required, bool enable_color_correct_rasterization, const viz::ResourceSettings& resource_settings) @@ -395,7 +394,6 @@ ResourceProvider::ResourceProvider( compositor_context_provider_(compositor_context_provider), shared_bitmap_manager_(shared_bitmap_manager), gpu_memory_buffer_manager_(gpu_memory_buffer_manager), - blocking_main_thread_task_runner_(blocking_main_thread_task_runner), next_id_(1), next_child_(1), lost_context_provider_(false), @@ -638,7 +636,7 @@ viz::ResourceId ResourceProvider::CreateBitmapResource( viz::ResourceId ResourceProvider::CreateResourceFromTextureMailbox( const viz::TextureMailbox& mailbox, - std::unique_ptr release_callback_impl, + std::unique_ptr release_callback, bool read_lock_fences_enabled, gfx::BufferFormat buffer_format) { DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); @@ -666,9 +664,9 @@ viz::ResourceId ResourceProvider::CreateResourceFromTextureMailbox( resource->allocated = true; resource->SetMailbox(mailbox); resource->color_space = mailbox.color_space(); - resource->release_callback_impl = - base::Bind(&SingleReleaseCallbackImpl::Run, - base::Owned(release_callback_impl.release())); + resource->release_callback = + base::Bind(&viz::SingleReleaseCallback::Run, + base::Owned(release_callback.release())); resource->read_lock_fences_enabled = read_lock_fences_enabled; resource->buffer_format = buffer_format; resource->is_overlay_candidate = mailbox.is_overlay_candidate(); @@ -686,18 +684,18 @@ viz::ResourceId ResourceProvider::CreateResourceFromTextureMailbox( viz::ResourceId ResourceProvider::CreateResourceFromTextureMailbox( const viz::TextureMailbox& mailbox, - std::unique_ptr release_callback_impl, + std::unique_ptr release_callback, bool read_lock_fences_enabled) { - return CreateResourceFromTextureMailbox( - mailbox, std::move(release_callback_impl), read_lock_fences_enabled, - gfx::BufferFormat::RGBA_8888); + return CreateResourceFromTextureMailbox(mailbox, std::move(release_callback), + read_lock_fences_enabled, + gfx::BufferFormat::RGBA_8888); } viz::ResourceId ResourceProvider::CreateResourceFromTextureMailbox( const viz::TextureMailbox& mailbox, - std::unique_ptr release_callback_impl) { - return CreateResourceFromTextureMailbox( - mailbox, std::move(release_callback_impl), false); + std::unique_ptr release_callback) { + return CreateResourceFromTextureMailbox(mailbox, std::move(release_callback), + false); } void ResourceProvider::DeleteResource(viz::ResourceId id) { @@ -773,8 +771,7 @@ void ResourceProvider::DeleteResourceInternal(ResourceMap::iterator it, resource->shared_bitmap = nullptr; resource->pixels = nullptr; } - resource->release_callback_impl.Run(sync_token, lost_resource, - blocking_main_thread_task_runner_); + resource->release_callback.Run(sync_token, lost_resource); } if (resource->gl_id) { diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h index e4f0b6aa264ecf..82578b4d349c19 100644 --- a/cc/resources/resource_provider.h +++ b/cc/resources/resource_provider.h @@ -25,12 +25,12 @@ #include "base/trace_event/memory_allocator_dump.h" #include "base/trace_event/memory_dump_provider.h" #include "cc/cc_export.h" -#include "cc/resources/release_callback_impl.h" #include "cc/resources/return_callback.h" -#include "cc/resources/single_release_callback_impl.h" #include "components/viz/common/display/renderer_settings.h" #include "components/viz/common/gpu/context_provider.h" +#include "components/viz/common/quads/release_callback.h" #include "components/viz/common/quads/shared_bitmap.h" +#include "components/viz/common/quads/single_release_callback.h" #include "components/viz/common/quads/texture_mailbox.h" #include "components/viz/common/resources/resource_format.h" #include "components/viz/common/resources/resource_id.h" @@ -58,7 +58,6 @@ class SharedBitmapManager; } // namespace viz namespace cc { -class BlockingTaskRunner; class TextureIdAllocator; // This class is not thread-safe and can only be called from the thread it was @@ -90,7 +89,6 @@ class CC_EXPORT ResourceProvider ResourceProvider(viz::ContextProvider* compositor_context_provider, viz::SharedBitmapManager* shared_bitmap_manager, gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, - BlockingTaskRunner* blocking_main_thread_task_runner, bool delegated_sync_points_required, bool enable_color_correct_rasterization, const viz::ResourceSettings& resource_settings); @@ -160,16 +158,16 @@ class CC_EXPORT ResourceProvider // Wraps an external texture mailbox into a GL resource. viz::ResourceId CreateResourceFromTextureMailbox( const viz::TextureMailbox& mailbox, - std::unique_ptr release_callback_impl); + std::unique_ptr release_callback); viz::ResourceId CreateResourceFromTextureMailbox( const viz::TextureMailbox& mailbox, - std::unique_ptr release_callback_impl, + std::unique_ptr release_callback, bool read_lock_fences_enabled); viz::ResourceId CreateResourceFromTextureMailbox( const viz::TextureMailbox& mailbox, - std::unique_ptr release_callback_impl, + std::unique_ptr release_callback, bool read_lock_fences_enabled, gfx::BufferFormat buffer_format); @@ -465,7 +463,7 @@ class CC_EXPORT ResourceProvider int child_id; viz::ResourceId id_in_child; GLuint gl_id; - ReleaseCallbackImpl release_callback_impl; + viz::ReleaseCallback release_callback; uint8_t* pixels; int lock_for_read_count; int imported_count; @@ -598,7 +596,6 @@ class CC_EXPORT ResourceProvider viz::ContextProvider* compositor_context_provider_; viz::SharedBitmapManager* shared_bitmap_manager_; gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_; - BlockingTaskRunner* blocking_main_thread_task_runner_; viz::ResourceId next_id_; int next_child_; diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc index 151fac7e94f44a..a7b82cb6dfc9fb 100644 --- a/cc/resources/resource_provider_unittest.cc +++ b/cc/resources/resource_provider_unittest.cc @@ -23,7 +23,6 @@ #include "cc/test/test_shared_bitmap_manager.h" #include "cc/test/test_texture.h" #include "cc/test/test_web_graphics_context_3d.h" -#include "cc/trees/blocking_task_runner.h" #include "components/viz/common/quads/single_release_callback.h" #include "components/viz/common/resources/buffer_to_texture_target_map.h" #include "components/viz/common/resources/resource_format_utils.h" @@ -59,26 +58,20 @@ MATCHER_P(MatchesSyncToken, sync_token, "") { } static void EmptyReleaseCallback(const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner) {} + bool lost_resource) {} -static void ReleaseCallback( - gpu::SyncToken* release_sync_token, - bool* release_lost_resource, - BlockingTaskRunner** release_main_thread_task_runner, - const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner) { +static void ReleaseCallback(gpu::SyncToken* release_sync_token, + bool* release_lost_resource, + const gpu::SyncToken& sync_token, + bool lost_resource) { *release_sync_token = sync_token; *release_lost_resource = lost_resource; - *release_main_thread_task_runner = main_thread_task_runner; } static void SharedBitmapReleaseCallback( std::unique_ptr bitmap, const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner) {} + bool lost_resource) {} static void ReleaseSharedBitmapCallback( std::unique_ptr shared_bitmap, @@ -86,8 +79,7 @@ static void ReleaseSharedBitmapCallback( gpu::SyncToken* release_sync_token, bool* lost_resource_result, const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner) { + bool lost_resource) { *release_called = true; *release_sync_token = sync_token; *lost_resource_result = lost_resource; @@ -436,8 +428,7 @@ class ResourceProviderTest explicit ResourceProviderTest(bool child_needs_sync_token) : shared_data_(ContextSharedData::Create()), context3d_(NULL), - child_context_(NULL), - main_thread_task_runner_(BlockingTaskRunner::Create(NULL)) { + child_context_(NULL) { switch (GetParam()) { case ResourceProvider::RESOURCE_TYPE_GPU_MEMORY_BUFFER: case ResourceProvider::RESOURCE_TYPE_GL_TEXTURE: { @@ -468,22 +459,19 @@ class ResourceProviderTest viz::ResourceSettings resource_settings = CreateResourceSettings(); resource_provider_ = std::make_unique( context_provider_.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - resource_settings); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, resource_settings); child_resource_provider_ = std::make_unique( child_context_provider_.get(), shared_bitmap_manager_.get(), - child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), - child_needs_sync_token, kEnableColorCorrectRendering, - resource_settings); + child_gpu_memory_buffer_manager_.get(), child_needs_sync_token, + kEnableColorCorrectRendering, resource_settings); } ResourceProviderTest() : ResourceProviderTest(true) {} static void CollectResources( std::vector* array, - const std::vector& returned, - BlockingTaskRunner* main_thread_task_runner) { + const std::vector& returned) { array->insert(array->end(), returned.begin(), returned.end()); } @@ -516,8 +504,8 @@ class ResourceProviderTest EXPECT_TRUE(sync_token->HasData()); std::unique_ptr shared_bitmap; - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create(base::Bind( + std::unique_ptr callback = + viz::SingleReleaseCallback::Create(base::Bind( ReleaseSharedBitmapCallback, base::Passed(&shared_bitmap), release_called, release_sync_token, lost_resource)); return child_resource_provider_->CreateResourceFromTextureMailbox( @@ -529,8 +517,8 @@ class ResourceProviderTest CreateAndFillSharedBitmap(shared_bitmap_manager_.get(), size, 0)); viz::SharedBitmap* shared_bitmap_ptr = shared_bitmap.get(); - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create(base::Bind( + std::unique_ptr callback = + viz::SingleReleaseCallback::Create(base::Bind( ReleaseSharedBitmapCallback, base::Passed(&shared_bitmap), release_called, release_sync_token, lost_resource)); return child_resource_provider_->CreateResourceFromTextureMailbox( @@ -544,7 +532,6 @@ class ResourceProviderTest ResourceProviderContext* child_context_; scoped_refptr context_provider_; scoped_refptr child_context_provider_; - std::unique_ptr main_thread_task_runner_; std::unique_ptr gpu_memory_buffer_manager_; std::unique_ptr resource_provider_; std::unique_ptr @@ -668,8 +655,8 @@ TEST_P(ResourceProviderTest, TransferGLResources) { id4_mailbox.set_color_space(color_space4); viz::ResourceId id4 = child_resource_provider_->CreateResourceFromTextureMailbox( - id4_mailbox, - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback))); + id4_mailbox, viz::SingleReleaseCallback::Create( + base::Bind(&EmptyReleaseCallback))); std::vector returned_to_child; int child_id = @@ -917,8 +904,8 @@ TEST_P(ResourceProviderTest, OverlayPromotionHint) { id1_mailbox.set_is_backed_by_surface_texture(true); viz::ResourceId id1 = child_resource_provider_->CreateResourceFromTextureMailbox( - id1_mailbox, - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback))); + id1_mailbox, viz::SingleReleaseCallback::Create( + base::Bind(&EmptyReleaseCallback))); viz::TextureMailbox id2_mailbox(external_mailbox, external_sync_token, GL_TEXTURE_EXTERNAL_OES); @@ -927,8 +914,8 @@ TEST_P(ResourceProviderTest, OverlayPromotionHint) { id2_mailbox.set_is_backed_by_surface_texture(false); viz::ResourceId id2 = child_resource_provider_->CreateResourceFromTextureMailbox( - id2_mailbox, - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback))); + id2_mailbox, viz::SingleReleaseCallback::Create( + base::Bind(&EmptyReleaseCallback))); std::vector returned_to_child; int child_id = @@ -1037,7 +1024,8 @@ TEST_P(ResourceProviderTestNoSyncToken, TransferGLResources) { child_resource_provider_->CreateResourceFromTextureMailbox( viz::TextureMailbox(external_mailbox, external_sync_token, GL_TEXTURE_EXTERNAL_OES), - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback))); + viz::SingleReleaseCallback::Create( + base::Bind(&EmptyReleaseCallback))); std::vector returned_to_child; int child_id = @@ -1435,7 +1423,7 @@ TEST_P(ResourceProviderTest, TransferSoftwareResources) { viz::ResourceId id3 = child_resource_provider_->CreateResourceFromTextureMailbox( viz::TextureMailbox(shared_bitmap_ptr, gfx::Size(1, 1)), - SingleReleaseCallbackImpl::Create(base::Bind( + viz::SingleReleaseCallback::Create(base::Bind( &SharedBitmapReleaseCallback, base::Passed(&shared_bitmap)))); std::vector returned_to_child; @@ -1617,9 +1605,8 @@ TEST_P(ResourceProviderTest, TransferGLToSoftware) { std::unique_ptr child_resource_provider( std::make_unique( child_context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gfx::Size size(1, 1); viz::ResourceFormat format = viz::RGBA_8888; @@ -1898,7 +1885,7 @@ class ResourceProviderTestTextureFilters : public ResourceProviderTest { std::unique_ptr child_resource_provider( std::make_unique( child_context_provider.get(), shared_bitmap_manager.get(), nullptr, - nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, + kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, resource_settings)); std::unique_ptr parent_context_owned( @@ -1912,7 +1899,7 @@ class ResourceProviderTestTextureFilters : public ResourceProviderTest { std::unique_ptr parent_resource_provider( std::make_unique( parent_context_provider.get(), shared_bitmap_manager.get(), nullptr, - nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, + kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, resource_settings)); gfx::Size size(1, 1); @@ -2053,14 +2040,12 @@ TEST_P(ResourceProviderTest, TransferMailboxResources) { gpu::SyncToken release_sync_token; bool lost_resource = false; - BlockingTaskRunner* main_thread_task_runner = nullptr; - ReleaseCallbackImpl callback = - base::Bind(ReleaseCallback, &release_sync_token, &lost_resource, - &main_thread_task_runner); + viz::ReleaseCallback callback = + base::Bind(ReleaseCallback, &release_sync_token, &lost_resource); viz::ResourceId resource = child_resource_provider_->CreateResourceFromTextureMailbox( viz::TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D), - SingleReleaseCallbackImpl::Create(callback)); + viz::SingleReleaseCallback::Create(callback)); EXPECT_EQ(1u, context()->NumTextures()); EXPECT_FALSE(release_sync_token.HasData()); { @@ -2105,7 +2090,6 @@ TEST_P(ResourceProviderTest, TransferMailboxResources) { EXPECT_LE(list[0].mailbox_holder.sync_token.release_count(), release_sync_token.release_count()); EXPECT_FALSE(lost_resource); - EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner); } // We're going to do the same thing as above, but testing the case where we @@ -2115,7 +2099,7 @@ TEST_P(ResourceProviderTest, TransferMailboxResources) { release_sync_token.Clear(); resource = child_resource_provider_->CreateResourceFromTextureMailbox( viz::TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D), - SingleReleaseCallbackImpl::Create(callback)); + viz::SingleReleaseCallback::Create(callback)); EXPECT_EQ(1u, context()->NumTextures()); EXPECT_FALSE(release_sync_token.HasData()); { @@ -2161,7 +2145,6 @@ TEST_P(ResourceProviderTest, TransferMailboxResources) { EXPECT_LE(list[0].mailbox_holder.sync_token.release_count(), release_sync_token.release_count()); EXPECT_FALSE(lost_resource); - EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner); } context()->waitSyncToken(release_sync_token.GetConstData()); @@ -2340,25 +2323,21 @@ TEST_P(ResourceProviderTest, LostContext) { gpu::SyncToken release_sync_token; bool lost_resource = false; - BlockingTaskRunner* main_thread_task_runner = nullptr; - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create( - base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource, - &main_thread_task_runner)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create( + base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource)); resource_provider_->CreateResourceFromTextureMailbox( viz::TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D), std::move(callback)); EXPECT_FALSE(release_sync_token.HasData()); EXPECT_FALSE(lost_resource); - EXPECT_FALSE(main_thread_task_runner); resource_provider_->DidLoseVulkanContextProvider(); resource_provider_ = nullptr; EXPECT_LE(sync_token.release_count(), release_sync_token.release_count()); EXPECT_TRUE(lost_resource); - EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner); } TEST_P(ResourceProviderTest, ScopedSampler) { @@ -2375,9 +2354,8 @@ TEST_P(ResourceProviderTest, ScopedSampler) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gfx::Size size(1, 1); viz::ResourceFormat format = viz::RGBA_8888; @@ -2454,9 +2432,8 @@ TEST_P(ResourceProviderTest, ManagedResource) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gfx::Size size(1, 1); viz::ResourceFormat format = viz::RGBA_8888; @@ -2497,9 +2474,8 @@ TEST_P(ResourceProviderTest, TextureWrapMode) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gfx::Size size(1, 1); viz::ResourceFormat format = viz::RGBA_8888; @@ -2541,9 +2517,8 @@ TEST_P(ResourceProviderTest, TextureHint) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gfx::Size size(1, 1); viz::ResourceFormat format = viz::RGBA_8888; @@ -2596,17 +2571,14 @@ TEST_P(ResourceProviderTest, TextureMailbox_SharedMemory) { std::unique_ptr resource_provider( std::make_unique( nullptr, shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gpu::SyncToken release_sync_token; bool lost_resource = false; - BlockingTaskRunner* main_thread_task_runner = nullptr; - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create( - base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource, - &main_thread_task_runner)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create( + base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource)); viz::TextureMailbox mailbox(shared_bitmap.get(), size); viz::ResourceId id = resource_provider->CreateResourceFromTextureMailbox( @@ -2625,7 +2597,6 @@ TEST_P(ResourceProviderTest, TextureMailbox_SharedMemory) { resource_provider->DeleteResource(id); EXPECT_FALSE(release_sync_token.HasData()); EXPECT_FALSE(lost_resource); - EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner); } class ResourceProviderTestTextureMailboxGLFilters @@ -2634,7 +2605,6 @@ class ResourceProviderTestTextureMailboxGLFilters static void RunTest( TestSharedBitmapManager* shared_bitmap_manager, viz::TestGpuMemoryBufferManager* gpu_memory_buffer_manager, - BlockingTaskRunner* main_thread_task_runner, bool mailbox_nearest_neighbor, GLenum sampler_filter) { std::unique_ptr context_owned( @@ -2647,9 +2617,8 @@ class ResourceProviderTestTextureMailboxGLFilters std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager, - gpu_memory_buffer_manager, main_thread_task_runner, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager, kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); unsigned texture_id = 1; gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, @@ -2667,11 +2636,9 @@ class ResourceProviderTestTextureMailboxGLFilters memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); gpu::SyncToken release_sync_token; bool lost_resource = false; - BlockingTaskRunner* mailbox_task_runner = nullptr; - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create( - base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource, - &mailbox_task_runner)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create( + base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource)); viz::TextureMailbox mailbox(gpu_mailbox, sync_token, target); mailbox.set_nearest_neighbor(mailbox_nearest_neighbor); @@ -2721,7 +2688,6 @@ class ResourceProviderTestTextureMailboxGLFilters resource_provider->DeleteResource(id); EXPECT_TRUE(release_sync_token.HasData()); EXPECT_FALSE(lost_resource); - EXPECT_EQ(main_thread_task_runner, mailbox_task_runner); } }; @@ -2733,7 +2699,6 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_LinearToLinear) { ResourceProviderTestTextureMailboxGLFilters::RunTest( shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(), - main_thread_task_runner_.get(), false, GL_LINEAR); } @@ -2746,7 +2711,6 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_NearestToNearest) { ResourceProviderTestTextureMailboxGLFilters::RunTest( shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(), - main_thread_task_runner_.get(), true, GL_NEAREST); } @@ -2759,7 +2723,6 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_NearestToLinear) { ResourceProviderTestTextureMailboxGLFilters::RunTest( shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(), - main_thread_task_runner_.get(), true, GL_LINEAR); } @@ -2772,7 +2735,6 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_LinearToNearest) { ResourceProviderTestTextureMailboxGLFilters::RunTest( shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(), - main_thread_task_runner_.get(), false, GL_NEAREST); } @@ -2791,9 +2753,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34); @@ -2807,8 +2768,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) { gpu::Mailbox gpu_mailbox; memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback)); viz::TextureMailbox mailbox(gpu_mailbox, sync_token, target); @@ -2860,9 +2821,8 @@ TEST_P(ResourceProviderTest, std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34); @@ -2876,8 +2836,8 @@ TEST_P(ResourceProviderTest, gpu::Mailbox gpu_mailbox; memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback)); viz::TextureMailbox mailbox(gpu_mailbox, sync_token, target); @@ -2915,9 +2875,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncTokenIfNeeded_NoSyncToken) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gpu::SyncToken sync_token; const GLuint64 current_fence_sync = context->GetNextFenceSync(); @@ -2930,8 +2889,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncTokenIfNeeded_NoSyncToken) { gpu::Mailbox gpu_mailbox; memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback)); viz::TextureMailbox mailbox(gpu_mailbox, sync_token, target); @@ -2964,9 +2923,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_PrepareSendToParent_NoSyncToken) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); EXPECT_CALL(*context, bindTexture(_, _)).Times(0); EXPECT_CALL(*context, waitSyncToken(_)).Times(0); @@ -2976,8 +2934,8 @@ TEST_P(ResourceProviderTest, TextureMailbox_PrepareSendToParent_NoSyncToken) { viz::TextureMailbox mailbox(gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_2D); - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback)); viz::ResourceId id = resource_provider->CreateResourceFromTextureMailbox( mailbox, std::move(callback)); @@ -3078,9 +3036,8 @@ TEST_P(ResourceProviderTest, TextureAllocation) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gfx::Size size(2, 2); gfx::Vector2d offset(0, 0); @@ -3135,9 +3092,8 @@ TEST_P(ResourceProviderTest, TextureAllocationHint) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gfx::Size size(2, 2); @@ -3191,9 +3147,8 @@ TEST_P(ResourceProviderTest, TextureAllocationHint_BGRA) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); gfx::Size size(2, 2); const viz::ResourceFormat formats[2] = {viz::RGBA_8888, viz::BGRA_8888}; @@ -3247,9 +3202,8 @@ TEST_P(ResourceProviderTest, Image_GLTexture) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); viz::ResourceId id = resource_provider->CreateGpuMemoryBufferResource( gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE, @@ -3303,9 +3257,8 @@ TEST_P(ResourceProviderTest, CompressedTextureETC1Allocate) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); int texture_id = 123; viz::ResourceId id = resource_provider->CreateResource( @@ -3335,9 +3288,8 @@ TEST_P(ResourceProviderTest, CompressedTextureETC1Upload) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); int texture_id = 123; uint8_t pixels[8]; @@ -3391,7 +3343,7 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager.get(), nullptr, - nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, + kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, CreateResourceSettings(kTextureAllocationChunkSize))); viz::ResourceId id = resource_provider->CreateResource( @@ -3409,7 +3361,7 @@ TEST(ResourceProviderTest, TextureAllocationChunkSize) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager.get(), nullptr, - nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, + kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, CreateResourceSettings(kTextureAllocationChunkSize))); viz::ResourceId id = resource_provider->CreateResource( @@ -3470,9 +3422,8 @@ TEST_P(ResourceProviderTest, ScopedWriteLockGL) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); viz::ResourceId id = resource_provider->CreateResource( gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE, @@ -3520,9 +3471,8 @@ TEST_P(ResourceProviderTest, ScopedWriteLockGL_GpuMemoryBuffer) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); viz::ResourceId id = resource_provider->CreateGpuMemoryBufferResource( gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE, @@ -3573,9 +3523,8 @@ TEST_P(ResourceProviderTest, ScopedWriteLockGL_Mailbox) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); viz::ResourceId id = resource_provider->CreateResource( gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE, @@ -3658,9 +3607,8 @@ TEST_P(ResourceProviderTest, ScopedWriteLockGL_GpuMemoryBuffer_Mailbox) { std::unique_ptr resource_provider( std::make_unique( context_provider.get(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), nullptr, - kDelegatedSyncPointsRequired, kEnableColorCorrectRendering, - CreateResourceSettings())); + gpu_memory_buffer_manager_.get(), kDelegatedSyncPointsRequired, + kEnableColorCorrectRendering, CreateResourceSettings())); viz::ResourceId id = resource_provider->CreateGpuMemoryBufferResource( gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE, diff --git a/cc/resources/return_callback.h b/cc/resources/return_callback.h index 30f0cf9ac5d487..a8d5c3a181968a 100644 --- a/cc/resources/return_callback.h +++ b/cc/resources/return_callback.h @@ -9,11 +9,9 @@ #include "components/viz/common/resources/returned_resource.h" namespace cc { -class BlockingTaskRunner; -typedef base::Callback&, - BlockingTaskRunner* main_thread_task_runner)> - ReturnCallback; +using ReturnCallback = + base::Callback&)>; } // namespace cc diff --git a/cc/resources/single_release_callback_impl.cc b/cc/resources/single_release_callback_impl.cc deleted file mode 100644 index bab9dd462d8ed5..00000000000000 --- a/cc/resources/single_release_callback_impl.cc +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright 2014 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/resources/single_release_callback_impl.h" - -#include "base/callback_helpers.h" -#include "base/logging.h" -#include "cc/trees/blocking_task_runner.h" - -namespace cc { - -SingleReleaseCallbackImpl::SingleReleaseCallbackImpl( - const ReleaseCallbackImpl& callback) - : callback_(callback) { - DCHECK(!callback_.is_null()) - << "Use a NULL SingleReleaseCallbackImpl for an empty callback."; -} - -SingleReleaseCallbackImpl::~SingleReleaseCallbackImpl() { - DCHECK(callback_.is_null()) << "SingleReleaseCallbackImpl was never run."; -} - -void SingleReleaseCallbackImpl::Run( - const gpu::SyncToken& sync_token, - bool is_lost, - BlockingTaskRunner* main_thread_task_runner) { - DCHECK(!callback_.is_null()) - << "SingleReleaseCallbackImpl was run more than once."; - base::ResetAndReturn(&callback_) - .Run(sync_token, is_lost, main_thread_task_runner); -} - -} // namespace cc diff --git a/cc/resources/single_release_callback_impl.h b/cc/resources/single_release_callback_impl.h deleted file mode 100644 index f5a8af05645d34..00000000000000 --- a/cc/resources/single_release_callback_impl.h +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright 2014 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. - -#ifndef CC_RESOURCES_SINGLE_RELEASE_CALLBACK_IMPL_H_ -#define CC_RESOURCES_SINGLE_RELEASE_CALLBACK_IMPL_H_ - -#include - -#include "base/memory/ptr_util.h" -#include "cc/cc_export.h" -#include "cc/resources/release_callback_impl.h" - -namespace cc { - -class CC_EXPORT SingleReleaseCallbackImpl { - public: - static std::unique_ptr Create( - const ReleaseCallbackImpl& cb) { - return base::WrapUnique(new SingleReleaseCallbackImpl(cb)); - } - - ~SingleReleaseCallbackImpl(); - - void Run(const gpu::SyncToken& sync_token, - bool is_lost, - BlockingTaskRunner* main_thread_task_runner); - - private: - explicit SingleReleaseCallbackImpl(const ReleaseCallbackImpl& callback); - - ReleaseCallbackImpl callback_; -}; - -} // namespace cc - -#endif // CC_RESOURCES_SINGLE_RELEASE_CALLBACK_IMPL_H_ diff --git a/cc/resources/video_resource_updater.cc b/cc/resources/video_resource_updater.cc index 014e2332e55778..faeba2f1dc24d9 100644 --- a/cc/resources/video_resource_updater.cc +++ b/cc/resources/video_resource_updater.cc @@ -600,8 +600,7 @@ void VideoResourceUpdater::ReturnTexture( base::WeakPtr updater, const scoped_refptr& video_frame, const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner) { + bool lost_resource) { // TODO(dshwang) this case should be forwarded to the decoder as lost // resource. if (lost_resource || !updater.get()) @@ -727,8 +726,7 @@ void VideoResourceUpdater::RecycleResource( base::WeakPtr updater, viz::ResourceId resource_id, const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner) { + bool lost_resource) { if (!updater.get()) { // Resource was already deleted. return; diff --git a/cc/resources/video_resource_updater.h b/cc/resources/video_resource_updater.h index 50ec17ceecc81c..8333f43f6ca0f9 100644 --- a/cc/resources/video_resource_updater.h +++ b/cc/resources/video_resource_updater.h @@ -17,7 +17,7 @@ #include "base/memory/weak_ptr.h" #include "base/time/time.h" #include "cc/cc_export.h" -#include "cc/resources/release_callback_impl.h" +#include "components/viz/common/quads/release_callback.h" #include "components/viz/common/quads/texture_mailbox.h" #include "components/viz/common/resources/resource_format.h" #include "ui/gfx/buffer_types.h" @@ -54,14 +54,14 @@ class CC_EXPORT VideoFrameExternalResources { ResourceType type; std::vector mailboxes; - std::vector release_callbacks; + std::vector release_callbacks; bool read_lock_fences_enabled; // Format of the storage of the resource, if known. gfx::BufferFormat buffer_format; // TODO(danakj): Remove these too. std::vector software_resources; - ReleaseCallbackImpl software_release_callback; + viz::ReleaseCallback software_release_callback; // Used by hardware textures which do not return values in the 0-1 range. // After a lookup, subtract offset and multiply by multiplier. @@ -175,13 +175,11 @@ class CC_EXPORT VideoResourceUpdater { static void RecycleResource(base::WeakPtr updater, unsigned resource_id, const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner); + bool lost_resource); static void ReturnTexture(base::WeakPtr updater, const scoped_refptr& video_frame, const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner); + bool lost_resource); viz::ContextProvider* context_provider_; ResourceProvider* resource_provider_; diff --git a/cc/resources/video_resource_updater_unittest.cc b/cc/resources/video_resource_updater_unittest.cc index d811f73ca6ec27..f5600d038f871f 100644 --- a/cc/resources/video_resource_updater_unittest.cc +++ b/cc/resources/video_resource_updater_unittest.cc @@ -15,7 +15,6 @@ #include "cc/test/fake_resource_provider.h" #include "cc/test/test_shared_bitmap_manager.h" #include "cc/test/test_web_graphics_context_3d.h" -#include "cc/trees/blocking_task_runner.h" #include "gpu/GLES2/gl2extchromium.h" #include "media/base/video_frame.h" #include "testing/gtest/include/gtest/gtest.h" @@ -402,8 +401,8 @@ TEST_F(VideoResourceUpdaterTest, ReuseResource) { // Simulate the ResourceProvider releasing the resources back to the video // updater. - for (ReleaseCallbackImpl& release_callback : resources.release_callbacks) - release_callback.Run(gpu::SyncToken(), false, nullptr); + for (auto& release_callback : resources.release_callbacks) + release_callback.Run(gpu::SyncToken(), false); // Allocate resources for the same frame. context3d_->ResetUploadCount(); @@ -475,7 +474,7 @@ TEST_F(VideoResourceUpdaterTest, ReuseResourceSoftwareCompositor) { // Simulate the ResourceProvider releasing the resource back to the video // updater. - resources.software_release_callback.Run(gpu::SyncToken(), false, nullptr); + resources.software_release_callback.Run(gpu::SyncToken(), false); // Allocate resources for the same frame. shared_bitmap_manager_->ResetAllocationCount(); @@ -633,7 +632,7 @@ TEST_F(VideoResourceUpdaterTest, PassReleaseSyncToken) { updater.CreateExternalResourcesFromVideoFrame(video_frame); ASSERT_EQ(resources.release_callbacks.size(), 1u); - resources.release_callbacks[0].Run(sync_token, false, nullptr); + resources.release_callbacks[0].Run(sync_token, false); } EXPECT_EQ(release_sync_token_, sync_token); @@ -661,8 +660,8 @@ TEST_F(VideoResourceUpdaterTest, GenerateReleaseSyncToken) { updater.CreateExternalResourcesFromVideoFrame(video_frame); ASSERT_EQ(resources.release_callbacks.size(), 1u); - resources.release_callbacks[0].Run(sync_token1, false, nullptr); - resources.release_callbacks[0].Run(sync_token2, false, nullptr); + resources.release_callbacks[0].Run(sync_token1, false); + resources.release_callbacks[0].Run(sync_token2, false); } EXPECT_TRUE(release_sync_token_.HasData()); diff --git a/cc/test/fake_resource_provider.h b/cc/test/fake_resource_provider.h index 07e7638ad745b3..7d032f196a87c3 100644 --- a/cc/test/fake_resource_provider.h +++ b/cc/test/fake_resource_provider.h @@ -25,9 +25,9 @@ class FakeResourceProvider : public ResourceProvider { resource_settings.buffer_to_texture_target_map = viz::DefaultBufferToTextureTargetMapForTesting(); resource_settings.high_bit_for_testing = high_bit_for_testing; - return base::WrapUnique(new FakeResourceProvider( - context_provider, shared_bitmap_manager, nullptr, nullptr, true, false, - resource_settings)); + return base::WrapUnique( + new FakeResourceProvider(context_provider, shared_bitmap_manager, + nullptr, true, false, resource_settings)); } template @@ -39,8 +39,7 @@ class FakeResourceProvider : public ResourceProvider { resource_settings.buffer_to_texture_target_map = viz::DefaultBufferToTextureTargetMapForTesting(); return base::WrapUnique(new T(context_provider, shared_bitmap_manager, - nullptr, nullptr, true, false, - resource_settings)); + nullptr, true, false, resource_settings)); } static std::unique_ptr Create( @@ -55,7 +54,7 @@ class FakeResourceProvider : public ResourceProvider { resource_settings.high_bit_for_testing = high_bit_for_testing; return base::WrapUnique(new FakeResourceProvider( context_provider, shared_bitmap_manager, gpu_memory_buffer_manager, - nullptr, true, false, resource_settings)); + true, false, resource_settings)); } template @@ -68,22 +67,20 @@ class FakeResourceProvider : public ResourceProvider { resource_settings.buffer_to_texture_target_map = viz::DefaultBufferToTextureTargetMapForTesting(); return base::WrapUnique(new T(context_provider, shared_bitmap_manager, - gpu_memory_buffer_manager, nullptr, true, - false, resource_settings)); + gpu_memory_buffer_manager, true, false, + resource_settings)); } private: FakeResourceProvider(viz::ContextProvider* context_provider, viz::SharedBitmapManager* shared_bitmap_manager, gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, - BlockingTaskRunner* blocking_main_thread_task_runner, bool delegated_sync_points_required, bool enable_color_corect_rasterization, const viz::ResourceSettings resource_settings) : ResourceProvider(context_provider, shared_bitmap_manager, gpu_memory_buffer_manager, - blocking_main_thread_task_runner, delegated_sync_points_required, enable_color_corect_rasterization, resource_settings) {} diff --git a/cc/test/pixel_test.cc b/cc/test/pixel_test.cc index 0dcb9918e4e91f..9234a90f17497c 100644 --- a/cc/test/pixel_test.cc +++ b/cc/test/pixel_test.cc @@ -17,7 +17,6 @@ #include "cc/test/pixel_test_utils.h" #include "cc/test/test_in_process_context_provider.h" #include "cc/test/test_shared_bitmap_manager.h" -#include "cc/trees/blocking_task_runner.h" #include "components/viz/common/frame_sinks/begin_frame_source.h" #include "components/viz/common/quads/compositor_frame_metadata.h" #include "components/viz/common/quads/copy_output_request.h" @@ -37,10 +36,9 @@ namespace cc { PixelTest::PixelTest() : device_viewport_size_(gfx::Size(200, 200)), disable_picture_quad_image_filtering_(false), - output_surface_client_(new FakeOutputSurfaceClient), - main_thread_task_runner_( - BlockingTaskRunner::Create(base::ThreadTaskRunnerHandle::Get())) {} -PixelTest::~PixelTest() {} + output_surface_client_(new FakeOutputSurfaceClient) {} + +PixelTest::~PixelTest() = default; bool PixelTest::RunPixelTest(viz::RenderPassList* pass_list, const base::FilePath& ref_file, @@ -173,8 +171,7 @@ void PixelTest::SetUpGLRenderer(bool flipped_output_surface) { constexpr bool delegated_sync_points_required = false; resource_provider_ = std::make_unique( output_surface_->context_provider(), shared_bitmap_manager_.get(), - gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), - delegated_sync_points_required, + gpu_memory_buffer_manager_.get(), delegated_sync_points_required, settings_.enable_color_correct_rasterization, settings_.resource_settings); @@ -202,7 +199,7 @@ void PixelTest::SetUpSoftwareRenderer() { false; // Meaningless for software. resource_provider_ = std::make_unique( nullptr, shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(), - main_thread_task_runner_.get(), delegated_sync_points_required, + delegated_sync_points_required, settings_.enable_color_correct_rasterization, settings_.resource_settings); auto renderer = std::make_unique( diff --git a/cc/test/pixel_test.h b/cc/test/pixel_test.h index 75daf31d688161..33a0437f982779 100644 --- a/cc/test/pixel_test.h +++ b/cc/test/pixel_test.h @@ -65,7 +65,6 @@ class PixelTest : public testing::Test { std::unique_ptr output_surface_; std::unique_ptr shared_bitmap_manager_; std::unique_ptr gpu_memory_buffer_manager_; - std::unique_ptr main_thread_task_runner_; std::unique_ptr resource_provider_; std::unique_ptr texture_mailbox_deleter_; std::unique_ptr renderer_; diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc index 965b5bea7d327b..5a73192b7cc2b1 100644 --- a/cc/test/render_pass_test_utils.cc +++ b/cc/test/render_pass_test_utils.cc @@ -102,8 +102,7 @@ void AddRenderPassQuad(viz::RenderPass* to_pass, } static void EmptyReleaseCallback(const gpu::SyncToken& sync_token, - bool lost_resource, - BlockingTaskRunner* main_thread_task_runner) {} + bool lost_resource) {} void AddOneOfEveryQuadType(viz::RenderPass* to_pass, ResourceProvider* resource_provider, @@ -152,8 +151,8 @@ void AddOneOfEveryQuadType(viz::RenderPass* to_pass, unsigned target = GL_TEXTURE_2D; gpu::Mailbox gpu_mailbox; memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback)); viz::TextureMailbox mailbox(gpu_mailbox, kSyncTokenForMailboxTextureQuad, target); viz::ResourceId resource8 = @@ -249,9 +248,9 @@ void AddOneOfEveryQuadType(viz::RenderPass* to_pass, gfx::ColorSpace::CreateREC601(), 0.0, 1.0, 8); } -static void CollectResources(std::vector* array, - const std::vector& returned, - BlockingTaskRunner* main_thread_task_runner) {} +static void CollectResources( + std::vector* array, + const std::vector& returned) {} void AddOneOfEveryQuadTypeInDisplayResourceProvider( viz::RenderPass* to_pass, @@ -309,8 +308,8 @@ void AddOneOfEveryQuadTypeInDisplayResourceProvider( unsigned target = GL_TEXTURE_2D; gpu::Mailbox gpu_mailbox; memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); - std::unique_ptr callback = - SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); + std::unique_ptr callback = + viz::SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback)); viz::TextureMailbox mailbox(gpu_mailbox, kSyncTokenForMailboxTextureQuad, target); viz::ResourceId resource8 = diff --git a/cc/trees/blocking_task_runner.cc b/cc/trees/blocking_task_runner.cc deleted file mode 100644 index 0b87f3bb73bd6d..00000000000000 --- a/cc/trees/blocking_task_runner.cc +++ /dev/null @@ -1,76 +0,0 @@ -// Copyright 2013 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/trees/blocking_task_runner.h" - -#include - -#include - -#include "base/callback.h" -#include "base/logging.h" -#include "base/memory/ptr_util.h" - -namespace cc { - -// static -std::unique_ptr BlockingTaskRunner::Create( - scoped_refptr task_runner) { - return base::WrapUnique(new BlockingTaskRunner(task_runner)); -} - -BlockingTaskRunner::BlockingTaskRunner( - scoped_refptr task_runner) - : thread_id_(base::PlatformThread::CurrentId()), - task_runner_(task_runner), - capture_(0) { -} - -BlockingTaskRunner::~BlockingTaskRunner() {} - -bool BlockingTaskRunner::BelongsToCurrentThread() { - return base::PlatformThread::CurrentId() == thread_id_; -} - -bool BlockingTaskRunner::PostTask(const base::Location& from_here, - base::OnceClosure task) { - base::AutoLock lock(lock_); - DCHECK(task_runner_.get() || capture_); - if (!capture_) - return task_runner_->PostTask(from_here, std::move(task)); - captured_tasks_.push_back(std::move(task)); - return true; -} - -void BlockingTaskRunner::SetCapture(bool capture) { - DCHECK(BelongsToCurrentThread()); - - std::vector tasks; - - { - base::AutoLock lock(lock_); - capture_ += capture ? 1 : -1; - DCHECK_GE(capture_, 0); - - if (capture_) - return; - - // We're done capturing, so grab all the captured tasks and run them. - tasks.swap(captured_tasks_); - } - for (size_t i = 0; i < tasks.size(); ++i) - std::move(tasks[i]).Run(); -} - -BlockingTaskRunner::CapturePostTasks::CapturePostTasks( - BlockingTaskRunner* blocking_runner) - : blocking_runner_(blocking_runner) { - blocking_runner_->SetCapture(true); -} - -BlockingTaskRunner::CapturePostTasks::~CapturePostTasks() { - blocking_runner_->SetCapture(false); -} - -} // namespace cc diff --git a/cc/trees/blocking_task_runner.h b/cc/trees/blocking_task_runner.h deleted file mode 100644 index c4c111cc26f5f9..00000000000000 --- a/cc/trees/blocking_task_runner.h +++ /dev/null @@ -1,98 +0,0 @@ -// Copyright 2013 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. - -#ifndef CC_TREES_BLOCKING_TASK_RUNNER_H_ -#define CC_TREES_BLOCKING_TASK_RUNNER_H_ - -#include -#include - -#include "base/location.h" -#include "base/macros.h" -#include "base/single_thread_task_runner.h" -#include "base/synchronization/lock.h" -#include "base/threading/platform_thread.h" -#include "cc/cc_export.h" - -namespace cc { - -// This class wraps a SingleThreadTaskRunner but allows posted tasks to be -// run without a round trip through the message loop. This shortcutting -// removes guarantees about ordering. Tasks posted while the -// BlockingTaskRunner is in a capturing state will run in order, and tasks -// posted while the BlockingTaskRunner is /not/ in a capturing state will -// run in order, but the two sets of tasks will *not* run in order relative -// to when they were posted. -// -// To use this class, post tasks to the task runner returned by -// BlockingTaskRunner::Create(). The thread it is created on identifies the -// thread you want the tasks to run on. The SingleThreadTaskRunner which is -// passed into Create() is used to run tasks that are posted when not in a -// capturing state. -// -// Then, on the thread that the given task runner belongs to, you may -// instantiate a BlockingTaskRunner::CapturePostTasks. While this object -// exists, the task runner will collect any PostTasks called on it, posting -// tasks to that thread from anywhere. This CapturePostTasks object provides -// a window in time where tasks can shortcut past the MessageLoop. As soon -// as the CapturePostTasks object is destroyed (goes out of scope), all -// tasks that had been posted to the thread during the window will be executed -// immediately. -// -// Beware of re-entrancy, make sure the CapturePostTasks object is destroyed at -// a time when it makes sense for the embedder to call arbitrary things. -class CC_EXPORT BlockingTaskRunner { - public: - // Creates a BlockingTaskRunner for a given SingleThreadTaskRunner. - // |task_runner| will be used to run the tasks which are posted while we are - // not capturing. |task_runner| should belong to same the thread on which - // capturing is done. - static std::unique_ptr Create( - scoped_refptr task_runner); - - ~BlockingTaskRunner(); - - // While an object of this type is held alive on a thread, any tasks - // posted to the thread will be captured and run as soon as the object - // is destroyed, shortcutting past the task runner. - class CC_EXPORT CapturePostTasks { - public: - explicit CapturePostTasks(BlockingTaskRunner* blocking_runner); - ~CapturePostTasks(); - - private: - BlockingTaskRunner* blocking_runner_; - - DISALLOW_COPY_AND_ASSIGN(CapturePostTasks); - }; - - // True if tasks posted to the BlockingTaskRunner will run on the current - // thread. - bool BelongsToCurrentThread(); - - // Posts a task using the contained SingleThreadTaskRunner unless |capture_| - // is true. When |capture_| is true, tasks posted will be caught and stored - // until the capturing stops. At that time the tasks will be run directly - // instead of being posted to the SingleThreadTaskRunner. - bool PostTask(const base::Location& from_here, base::OnceClosure task); - - private: - explicit BlockingTaskRunner( - scoped_refptr task_runner); - - void SetCapture(bool capture); - - base::PlatformThreadId thread_id_; - scoped_refptr task_runner_; - - base::Lock lock_; - int capture_; - std::vector captured_tasks_; - - DISALLOW_COPY_AND_ASSIGN(BlockingTaskRunner); -}; - -} // namespace cc - -#endif // CC_TREES_BLOCKING_TASK_RUNNER_H_ diff --git a/cc/trees/blocking_task_runner_unittest.cc b/cc/trees/blocking_task_runner_unittest.cc deleted file mode 100644 index 78a3707ba16e8c..00000000000000 --- a/cc/trees/blocking_task_runner_unittest.cc +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright 2014 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/trees/blocking_task_runner.h" - -#include "base/bind.h" -#include "base/location.h" -#include "base/run_loop.h" -#include "base/single_thread_task_runner.h" -#include "base/threading/thread_task_runner_handle.h" -#include "components/viz/test/ordered_simple_task_runner.h" -#include "testing/gtest/include/gtest/gtest.h" - -namespace cc { -namespace { - -void TestTask(bool* result) { - *result = true; -} - -TEST(BlockingTaskRunnerTest, NoCapture) { - bool did_run = false; - std::unique_ptr runner( - BlockingTaskRunner::Create(base::ThreadTaskRunnerHandle::Get())); - runner->PostTask(FROM_HERE, base::Bind(&TestTask, &did_run)); - EXPECT_FALSE(did_run); - base::RunLoop().RunUntilIdle(); - EXPECT_TRUE(did_run); -} - -TEST(BlockingTaskRunnerTest, Capture) { - bool did_run = false; - std::unique_ptr runner( - BlockingTaskRunner::Create(base::ThreadTaskRunnerHandle::Get())); - { - BlockingTaskRunner::CapturePostTasks capture(runner.get()); - runner->PostTask(FROM_HERE, base::Bind(&TestTask, &did_run)); - EXPECT_FALSE(did_run); - } - EXPECT_TRUE(did_run); -} - -} // namespace -} // namespace cc diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc index 76533af6f105ca..1af4bd95705ed2 100644 --- a/cc/trees/layer_tree_host_impl.cc +++ b/cc/trees/layer_tree_host_impl.cc @@ -2610,7 +2610,6 @@ bool LayerTreeHostImpl::InitializeRenderer( layer_tree_frame_sink_->context_provider(), layer_tree_frame_sink_->shared_bitmap_manager(), layer_tree_frame_sink_->gpu_memory_buffer_manager(), - task_runner_provider_->blocking_main_thread_task_runner(), layer_tree_frame_sink_->capabilities().delegated_sync_points_required, settings_.enable_color_correct_rasterization, settings_.resource_settings); diff --git a/cc/trees/proxy_main.cc b/cc/trees/proxy_main.cc index cff9b41c178ae7..4893971b52a258 100644 --- a/cc/trees/proxy_main.cc +++ b/cc/trees/proxy_main.cc @@ -14,7 +14,6 @@ #include "cc/base/devtools_instrumentation.h" #include "cc/benchmarks/benchmark_instrumentation.h" #include "cc/resources/ui_resource_manager.h" -#include "cc/trees/blocking_task_runner.h" #include "cc/trees/layer_tree_frame_sink.h" #include "cc/trees/layer_tree_host.h" #include "cc/trees/mutator_host.h" @@ -279,12 +278,6 @@ void ProxyMain::BeginMainFrame( DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); - // This CapturePostTasks should be destroyed before CommitComplete() is - // called since that goes out to the embedder, and we want the embedder - // to receive its callbacks before that. - BlockingTaskRunner::CapturePostTasks blocked( - task_runner_provider_->blocking_main_thread_task_runner()); - bool hold_commit_for_activation = commit_waits_for_activation_; commit_waits_for_activation_ = false; CompletionEvent completion; diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc index bc0f6c2b6206ab..ded82a70c97824 100644 --- a/cc/trees/single_thread_proxy.cc +++ b/cc/trees/single_thread_proxy.cc @@ -188,12 +188,6 @@ void SingleThreadProxy::DoCommit() { DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); DebugScopedSetImplThread impl(task_runner_provider_); - // This CapturePostTasks should be destroyed before CommitComplete() is - // called since that goes out to the embedder, and we want the embedder - // to receive its callbacks before that. - commit_blocking_task_runner_.reset(new BlockingTaskRunner::CapturePostTasks( - task_runner_provider_->blocking_main_thread_task_runner())); - host_impl_->ReadyToCommit(); host_impl_->BeginCommit(); @@ -231,10 +225,8 @@ void SingleThreadProxy::CommitComplete() { // SetNextCommitWaitsForActivation calls. DCHECK(!host_impl_->pending_tree()) << "Activation is expected to have synchronously occurred by now."; - DCHECK(commit_blocking_task_runner_); DebugScopedSetMainThread main(task_runner_provider_); - commit_blocking_task_runner_.reset(); layer_tree_host_->CommitComplete(); layer_tree_host_->DidBeginMainFrame(); @@ -383,9 +375,6 @@ bool SingleThreadProxy::IsInsideDraw() { } void SingleThreadProxy::DidActivateSyncTree() { - // Synchronously call to CommitComplete. Resetting - // |commit_blocking_task_runner| would make sure all tasks posted during - // commit/activation before CommitComplete. CommitComplete(); } @@ -581,8 +570,6 @@ DrawResult SingleThreadProxy::DoComposite(LayerTreeHostImpl::FrameData* frame) { // there as the main thread is not blocked, so any posted tasks inside // the swap buffers will execute first. DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); - BlockingTaskRunner::CapturePostTasks blocked( - task_runner_provider_->blocking_main_thread_task_runner()); draw_result = host_impl_->PrepareToDraw(frame); draw_frame = draw_result == DRAW_SUCCESS; @@ -800,8 +787,6 @@ void SingleThreadProxy::ScheduledActionPerformImplSideInvalidation() { DCHECK(scheduler_on_impl_thread_); DebugScopedSetImplThread impl(task_runner_provider_); - commit_blocking_task_runner_.reset(new BlockingTaskRunner::CapturePostTasks( - task_runner_provider_->blocking_main_thread_task_runner())); host_impl_->InvalidateContentOnImplSide(); // Invalidations go directly to the active tree, so we synchronously call diff --git a/cc/trees/single_thread_proxy.h b/cc/trees/single_thread_proxy.h index 5843ed24bd07ad..99414cdba656cc 100644 --- a/cc/trees/single_thread_proxy.h +++ b/cc/trees/single_thread_proxy.h @@ -11,7 +11,6 @@ #include "base/macros.h" #include "base/time/time.h" #include "cc/scheduler/scheduler.h" -#include "cc/trees/blocking_task_runner.h" #include "cc/trees/layer_tree_host_impl.h" #include "cc/trees/proxy.h" #include "cc/trees/task_runner_provider.h" @@ -147,8 +146,6 @@ class CC_EXPORT SingleThreadProxy : public Proxy, // Accessed from both threads. std::unique_ptr scheduler_on_impl_thread_; - std::unique_ptr - commit_blocking_task_runner_; bool next_frame_is_newly_committed_frame_; #if DCHECK_IS_ON() diff --git a/cc/trees/task_runner_provider.cc b/cc/trees/task_runner_provider.cc index 053b047385fa02..ebe7dd0c55f8f7 100644 --- a/cc/trees/task_runner_provider.cc +++ b/cc/trees/task_runner_provider.cc @@ -3,7 +3,6 @@ // found in the LICENSE file. #include "base/single_thread_task_runner.h" -#include "cc/trees/blocking_task_runner.h" #include "cc/trees/task_runner_provider.h" namespace cc { @@ -71,15 +70,10 @@ TaskRunnerProvider::TaskRunnerProvider( scoped_refptr main_task_runner, scoped_refptr impl_task_runner) #if !DCHECK_IS_ON() - : main_task_runner_(main_task_runner), - impl_task_runner_(impl_task_runner), - blocking_main_thread_task_runner_( - BlockingTaskRunner::Create(main_task_runner)) { + : main_task_runner_(main_task_runner), impl_task_runner_(impl_task_runner) { #else : main_task_runner_(main_task_runner), impl_task_runner_(impl_task_runner), - blocking_main_thread_task_runner_( - BlockingTaskRunner::Create(main_task_runner)), main_thread_id_(base::PlatformThread::CurrentId()), impl_thread_is_overridden_(false), is_main_thread_blocked_(false) { diff --git a/cc/trees/task_runner_provider.h b/cc/trees/task_runner_provider.h index 1a7ebf5adca3d2..42b0ed80a3112f 100644 --- a/cc/trees/task_runner_provider.h +++ b/cc/trees/task_runner_provider.h @@ -23,7 +23,6 @@ class SingleThreadTaskRunner; } namespace cc { -class BlockingTaskRunner; // Class responsible for controlling access to the main and impl task runners. // Useful for assertion checks. @@ -53,10 +52,6 @@ class CC_EXPORT TaskRunnerProvider { virtual ~TaskRunnerProvider(); - BlockingTaskRunner* blocking_main_thread_task_runner() const { - return blocking_main_thread_task_runner_.get(); - } - protected: TaskRunnerProvider( scoped_refptr main_task_runner, @@ -69,7 +64,6 @@ class CC_EXPORT TaskRunnerProvider { private: scoped_refptr main_task_runner_; scoped_refptr impl_task_runner_; - std::unique_ptr blocking_main_thread_task_runner_; #if DCHECK_IS_ON() const base::PlatformThreadId main_thread_id_; diff --git a/components/viz/service/display/display.cc b/components/viz/service/display/display.cc index 7c3bb374cfde0b..8b990a9df1b749 100644 --- a/components/viz/service/display/display.cc +++ b/components/viz/service/display/display.cc @@ -184,7 +184,7 @@ void Display::InitializeRenderer() { constexpr bool delegated_sync_points_required = false; resource_provider_ = base::MakeUnique( output_surface_->context_provider(), bitmap_manager_, - gpu_memory_buffer_manager_, nullptr, delegated_sync_points_required, + gpu_memory_buffer_manager_, delegated_sync_points_required, settings_.enable_color_correct_rendering, settings_.resource_settings); if (output_surface_->context_provider()) { diff --git a/components/viz/service/display/gl_renderer_unittest.cc b/components/viz/service/display/gl_renderer_unittest.cc index dc5bc54ae98b03..5ce07fbc60beb4 100644 --- a/components/viz/service/display/gl_renderer_unittest.cc +++ b/components/viz/service/display/gl_renderer_unittest.cc @@ -1928,13 +1928,10 @@ class TestOverlayProcessor : public OverlayProcessor { Strategy* strategy_; }; -void MailboxReleased(const gpu::SyncToken& sync_token, - bool lost_resource, - cc::BlockingTaskRunner* main_thread_task_runner) {} +void MailboxReleased(const gpu::SyncToken& sync_token, bool lost_resource) {} static void CollectResources(std::vector* array, - const std::vector& returned, - cc::BlockingTaskRunner* main_thread_task_runner) { + const std::vector& returned) { array->insert(array->end(), returned.begin(), returned.end()); } @@ -1961,7 +1958,7 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) { TextureMailbox mailbox(gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_2D, gfx::Size(256, 256), true, false); auto release_callback = - cc::SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased)); + SingleReleaseCallback::Create(base::Bind(&MailboxReleased)); ResourceId resource_id = child_resource_provider->CreateResourceFromTextureMailbox( mailbox, std::move(release_callback)); @@ -2153,7 +2150,7 @@ TEST_F(GLRendererTest, OverlaySyncTokensAreProcessed) { TextureMailbox mailbox(gpu::Mailbox::Generate(), sync_token, GL_TEXTURE_2D, gfx::Size(256, 256), true, false); auto release_callback = - cc::SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased)); + SingleReleaseCallback::Create(base::Bind(&MailboxReleased)); ResourceId resource_id = child_resource_provider->CreateResourceFromTextureMailbox( mailbox, std::move(release_callback)); @@ -2388,7 +2385,7 @@ TEST_F(GLRendererTest, DCLayerOverlaySwitch) { TextureMailbox mailbox(gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_2D, gfx::Size(256, 256), true, false); auto release_callback = - cc::SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased)); + SingleReleaseCallback::Create(base::Bind(&MailboxReleased)); ResourceId resource_id = child_resource_provider->CreateResourceFromTextureMailbox( mailbox, std::move(release_callback)); diff --git a/components/viz/service/display/overlay_unittest.cc b/components/viz/service/display/overlay_unittest.cc index 9c386d418c1105..af79ba2af19494 100644 --- a/components/viz/service/display/overlay_unittest.cc +++ b/components/viz/service/display/overlay_unittest.cc @@ -65,9 +65,10 @@ const gfx::Transform kBothMirrorTransform = const gfx::Transform kSwapTransform = gfx::Transform(0, 1, 1, 0, 0, 0); // x,y -> y,x. -void MailboxReleased(const gpu::SyncToken& sync_token, - bool lost_resource, - cc::BlockingTaskRunner* main_thread_task_runner) {} +void MailboxReleased(const gpu::SyncToken& sync_token, bool lost_resource) {} + +void CollectResources(std::vector* array, + const std::vector& returned) {} class FullscreenOverlayValidator : public OverlayCandidateValidator { public: @@ -259,10 +260,6 @@ std::unique_ptr CreateRenderPassWithTransform( return pass; } -static void CollectResources(std::vector* array, - const std::vector& returned, - cc::BlockingTaskRunner* main_thread_task_runner) {} - ResourceId CreateResource( cc::DisplayResourceProvider* parent_resource_provider, cc::LayerTreeResourceProvider* child_resource_provider, @@ -271,7 +268,7 @@ ResourceId CreateResource( TextureMailbox mailbox(gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_2D, size, is_overlay_candidate, false); auto release_callback = - cc::SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased)); + SingleReleaseCallback::Create(base::Bind(&MailboxReleased)); ResourceId resource_id = child_resource_provider->CreateResourceFromTextureMailbox( diff --git a/components/viz/service/display/renderer_pixeltest.cc b/components/viz/service/display/renderer_pixeltest.cc index fe17eb3beb5297..d0c4cd789f6071 100644 --- a/components/viz/service/display/renderer_pixeltest.cc +++ b/components/viz/service/display/renderer_pixeltest.cc @@ -251,21 +251,21 @@ void CreateTestYUVVideoDrawQuad_FromVideoFrame( ResourceId y_resource = resource_provider->CreateResourceFromTextureMailbox( resources.mailboxes[media::VideoFrame::kYPlane], - cc::SingleReleaseCallbackImpl::Create( + SingleReleaseCallback::Create( resources.release_callbacks[media::VideoFrame::kYPlane])); ResourceId u_resource = resource_provider->CreateResourceFromTextureMailbox( resources.mailboxes[media::VideoFrame::kUPlane], - cc::SingleReleaseCallbackImpl::Create( + SingleReleaseCallback::Create( resources.release_callbacks[media::VideoFrame::kUPlane])); ResourceId v_resource = resource_provider->CreateResourceFromTextureMailbox( resources.mailboxes[media::VideoFrame::kVPlane], - cc::SingleReleaseCallbackImpl::Create( + SingleReleaseCallback::Create( resources.release_callbacks[media::VideoFrame::kVPlane])); ResourceId a_resource = 0; if (with_alpha) { a_resource = resource_provider->CreateResourceFromTextureMailbox( resources.mailboxes[media::VideoFrame::kAPlane], - cc::SingleReleaseCallbackImpl::Create( + SingleReleaseCallback::Create( resources.release_callbacks[media::VideoFrame::kAPlane])); } @@ -337,7 +337,7 @@ void CreateTestY16TextureDrawQuad_FromVideoFrame( ResourceId y_resource = resource_provider->CreateResourceFromTextureMailbox( resources.mailboxes[0], - cc::SingleReleaseCallbackImpl::Create(resources.release_callbacks[0])); + SingleReleaseCallback::Create(resources.release_callbacks[0])); auto* quad = render_pass->CreateAndAppendDrawQuad(); bool needs_blending = true; diff --git a/components/viz/service/display/surface_aggregator.cc b/components/viz/service/display/surface_aggregator.cc index 95967bc6a466de..9a71aad6bc70a6 100644 --- a/components/viz/service/display/surface_aggregator.cc +++ b/components/viz/service/display/surface_aggregator.cc @@ -177,8 +177,7 @@ gfx::Rect SurfaceAggregator::DamageRectForSurface( // static void SurfaceAggregator::UnrefResources( base::WeakPtr surface_client, - const std::vector& resources, - cc::BlockingTaskRunner* main_thread_task_runner) { + const std::vector& resources) { if (surface_client) surface_client->UnrefResources(resources); } diff --git a/components/viz/service/display/surface_aggregator.h b/components/viz/service/display/surface_aggregator.h index 570db5bf9a9407..34abb432383de1 100644 --- a/components/viz/service/display/surface_aggregator.h +++ b/components/viz/service/display/surface_aggregator.h @@ -20,7 +20,6 @@ #include "ui/gfx/color_space.h" namespace cc { -class BlockingTaskRunner; class DisplayResourceProvider; } // namespace cc @@ -144,8 +143,7 @@ class VIZ_SERVICE_EXPORT SurfaceAggregator { const gfx::Rect& full_rect) const; static void UnrefResources(base::WeakPtr surface_client, - const std::vector& resources, - cc::BlockingTaskRunner* main_thread_task_runner); + const std::vector& resources); SurfaceManager* manager_; cc::DisplayResourceProvider* provider_;