From ae12d53884dc0d840275677e26b95a14184357b7 Mon Sep 17 00:00:00 2001 From: Aleksei Kuzmin Date: Thu, 20 Sep 2018 23:45:00 +0200 Subject: [PATCH] fix: enable back a DCHECK in viz::ServerSharedBitmapManager Fixes #14327. Backports https://chromium-review.googlesource.com/802574. --- patches/common/chromium/.patches.yaml | 11 +- .../common/chromium/backport_7167a9eac.patch | 1298 +++++++++++++++++ patches/common/chromium/dcheck.patch | 15 - 3 files changed, 1308 insertions(+), 16 deletions(-) create mode 100644 patches/common/chromium/backport_7167a9eac.patch diff --git a/patches/common/chromium/.patches.yaml b/patches/common/chromium/.patches.yaml index 70e0f03ddf3f..95f1a67d1ea2 100644 --- a/patches/common/chromium/.patches.yaml +++ b/patches/common/chromium/.patches.yaml @@ -45,7 +45,6 @@ patches: base/memory/weak_ptr.cc base/process/kill_win.cc components/viz/service/display/program_binding.h - components/viz/service/display_embedder/server_shared_bitmap_manager.cc content/browser/frame_host/navigation_controller_impl.cc content/browser/frame_host/render_frame_host_impl.cc content/browser/renderer_host/render_widget_host_view_mac.mm @@ -481,3 +480,13 @@ patches: description: | Expose URLRequestContextGetter::{Add,Remove}Observer. This patch should be removed once we switch to using the net service (cc @robo) +- + author: Aleksei Kuzmin + file: backport_7167a9eac.patch + description: | + "viz: Remove the global ServerSharedBitmapManager." + https://chromium-review.googlesource.com/802574 + Landed in 69.0.3447.0. + See https://github.com/electron/electron/issues/14327 + (Android specific changes and changes in some test files + have been removed from the diff.) diff --git a/patches/common/chromium/backport_7167a9eac.patch b/patches/common/chromium/backport_7167a9eac.patch new file mode 100644 index 000000000000..ffd1ad87ad00 --- /dev/null +++ b/patches/common/chromium/backport_7167a9eac.patch @@ -0,0 +1,1298 @@ +diff --git a/components/viz/DEPS b/components/viz/DEPS +index eba179ee3b2f..ce3033f070c1 100644 +--- a/components/viz/DEPS ++++ b/components/viz/DEPS +@@ -6,3 +6,9 @@ include_rules = [ + "+ui/base", + "+ui/gfx", + ] ++ ++specific_include_rules = { ++ ".*_(unittest|perftest|fuzzer)\.cc": [ ++ "+components/viz", ++ ], ++} +diff --git a/components/viz/client/DEPS b/components/viz/client/DEPS +index db90fed94b97..626d4d8b5f11 100644 +--- a/components/viz/client/DEPS ++++ b/components/viz/client/DEPS +@@ -14,6 +14,5 @@ include_rules = [ + specific_include_rules = { + ".*unittest\.cc": [ + "+cc/test", +- "+components/viz/test", + ], + } +diff --git a/components/viz/common/DEPS b/components/viz/common/DEPS +index 7ccd5e03c1eb..8c356af9c666 100644 +--- a/components/viz/common/DEPS ++++ b/components/viz/common/DEPS +@@ -24,7 +24,6 @@ specific_include_rules = { + ], + ".*_unittest\.cc": [ + "+cc/test", +- "+components/viz/test", + "+gpu/ipc/gl_in_process_context.h", + "+media/base", + "+ui/gl", +diff --git a/components/viz/host/DEPS b/components/viz/host/DEPS +index 83389e05a389..b9d508f19a49 100644 +--- a/components/viz/host/DEPS ++++ b/components/viz/host/DEPS +@@ -24,7 +24,4 @@ specific_include_rules = { + "+components/viz/service/frame_sinks/frame_sink_manager_impl.h", + "+components/viz/service/surfaces/surface_manager.h", + ], +- ".*_unittest\.cc": [ +- "+components/viz/test", +- ] + } +diff --git a/components/viz/host/host_frame_sink_manager_unittest.cc b/components/viz/host/host_frame_sink_manager_unittest.cc +index f957e388a5c9..0f91e10691be 100644 +--- a/components/viz/host/host_frame_sink_manager_unittest.cc ++++ b/components/viz/host/host_frame_sink_manager_unittest.cc +@@ -13,6 +13,7 @@ + #include "components/viz/common/surfaces/frame_sink_id.h" + #include "components/viz/common/surfaces/surface_id.h" + #include "components/viz/common/surfaces/surface_info.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/surfaces/surface_manager.h" +@@ -69,7 +70,8 @@ struct RootCompositorFrameSinkData { + // A mock implementation of mojom::FrameSinkManager. + class MockFrameSinkManagerImpl : public FrameSinkManagerImpl { + public: +- MockFrameSinkManagerImpl() = default; ++ explicit MockFrameSinkManagerImpl(SharedBitmapManager* shared_bitmap_manager) ++ : FrameSinkManagerImpl(shared_bitmap_manager) {} + ~MockFrameSinkManagerImpl() override = default; + + // mojom::FrameSinkManager: +@@ -148,6 +150,7 @@ class HostFrameSinkManagerTestBase : public testing::Test { + } + + protected: ++ ServerSharedBitmapManager shared_bitmap_manager_; + std::unique_ptr host_manager_; + std::unique_ptr> manager_impl_; + +@@ -171,7 +174,8 @@ class HostFrameSinkManagerLocalTest : public HostFrameSinkManagerTestBase { + // testing::Test: + void SetUp() override { + manager_impl_ = +- std::make_unique>(); ++ std::make_unique>( ++ &shared_bitmap_manager_); + host_manager_ = std::make_unique(); + + manager_impl_->SetLocalClient(host_manager_.get()); +@@ -195,7 +199,8 @@ class HostFrameSinkManagerRemoteTest : public HostFrameSinkManagerTestBase { + DCHECK(!manager_impl_); + + manager_impl_ = +- std::make_unique>(); ++ std::make_unique>( ++ &shared_bitmap_manager_); + + mojom::FrameSinkManagerPtr frame_sink_manager; + mojom::FrameSinkManagerRequest frame_sink_manager_request = +diff --git a/components/viz/service/DEPS b/components/viz/service/DEPS +index 4ec6497057fc..0f76030dfcb0 100644 +--- a/components/viz/service/DEPS ++++ b/components/viz/service/DEPS +@@ -12,9 +12,3 @@ include_rules = [ + "+ui/latency", + "+ui/ozone/public", + ] +- +-specific_include_rules = { +- ".*_unittest\.cc": [ +- "+components/viz/test", +- ] +-} +diff --git a/components/viz/service/display/display_unittest.cc b/components/viz/service/display/display_unittest.cc +index e0790451dc8a..d71831e15c53 100644 +--- a/components/viz/service/display/display_unittest.cc ++++ b/components/viz/service/display/display_unittest.cc +@@ -18,11 +18,11 @@ + #include "components/viz/common/quads/render_pass_draw_quad.h" + #include "components/viz/common/quads/solid_color_draw_quad.h" + #include "components/viz/common/quads/surface_draw_quad.h" +-#include "components/viz/common/resources/shared_bitmap_manager.h" + #include "components/viz/common/surfaces/frame_sink_id.h" + #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h" + #include "components/viz/service/display/display_client.h" + #include "components/viz/service/display/display_scheduler.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/surfaces/surface.h" +@@ -31,7 +31,6 @@ + #include "components/viz/test/fake_output_surface.h" + #include "components/viz/test/mock_compositor_frame_sink_client.h" + #include "components/viz/test/test_gles2_interface.h" +-#include "components/viz/test/test_shared_bitmap_manager.h" + #include "gpu/GLES2/gl2extchromium.h" + #include "testing/gmock/include/gmock/gmock.h" + #include "testing/gtest/include/gtest/gtest.h" +@@ -97,7 +96,8 @@ class TestDisplayScheduler : public DisplayScheduler { + class DisplayTest : public testing::Test { + public: + DisplayTest() +- : support_(std::make_unique( ++ : manager_(&shared_bitmap_manager_), ++ support_(std::make_unique( + nullptr, + &manager_, + kArbitraryFrameSinkId, +@@ -186,11 +186,11 @@ class DisplayTest : public testing::Test { + + void LatencyInfoCapTest(bool over_capacity); + ++ ServerSharedBitmapManager shared_bitmap_manager_; + FrameSinkManagerImpl manager_; + std::unique_ptr support_; + ParentLocalSurfaceIdAllocator id_allocator_; + scoped_refptr task_runner_; +- TestSharedBitmapManager shared_bitmap_manager_; + std::unique_ptr begin_frame_source_; + std::unique_ptr display_; + TestSoftwareOutputDevice* software_output_device_ = nullptr; +diff --git a/components/viz/service/display/surface_aggregator_pixeltest.cc b/components/viz/service/display/surface_aggregator_pixeltest.cc +index 549191558eaf..493ba4987a0a 100644 +--- a/components/viz/service/display/surface_aggregator_pixeltest.cc ++++ b/components/viz/service/display/surface_aggregator_pixeltest.cc +@@ -13,6 +13,7 @@ + #include "components/viz/common/quads/surface_draw_quad.h" + #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h" + #include "components/viz/service/display/surface_aggregator.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/surfaces/surface.h" +@@ -36,7 +37,8 @@ constexpr bool kNeedsSyncPoints = true; + class SurfaceAggregatorPixelTest : public cc::RendererPixelTest { + public: + SurfaceAggregatorPixelTest() +- : support_(std::make_unique( ++ : manager_(&shared_bitmap_manager_), ++ support_(std::make_unique( + nullptr, + &manager_, + kArbitraryRootFrameSinkId, +@@ -51,6 +53,7 @@ class SurfaceAggregatorPixelTest : public cc::RendererPixelTest { + } + + protected: ++ ServerSharedBitmapManager shared_bitmap_manager_; + FrameSinkManagerImpl manager_; + ParentLocalSurfaceIdAllocator allocator_; + std::unique_ptr support_; +diff --git a/components/viz/service/display_embedder/gpu_display_provider.cc b/components/viz/service/display_embedder/gpu_display_provider.cc +index 6f8d1ae7d609..27b68891ead9 100644 +--- a/components/viz/service/display_embedder/gpu_display_provider.cc ++++ b/components/viz/service/display_embedder/gpu_display_provider.cc +@@ -69,6 +69,7 @@ GpuDisplayProvider::GpuDisplayProvider( + GpuServiceImpl* gpu_service_impl, + scoped_refptr gpu_service, + gpu::GpuChannelManager* gpu_channel_manager, ++ ServerSharedBitmapManager* server_shared_bitmap_manager, + bool headless, + bool wait_for_all_pipeline_stages_before_draw) + : restart_id_(restart_id), +@@ -79,6 +80,7 @@ GpuDisplayProvider::GpuDisplayProvider( + std::make_unique( + gpu_channel_manager)), + image_factory_(GetImageFactory(gpu_channel_manager)), ++ server_shared_bitmap_manager_(server_shared_bitmap_manager), + task_runner_(base::ThreadTaskRunnerHandle::Get()), + headless_(headless), + wait_for_all_pipeline_stages_before_draw_( +@@ -195,7 +197,7 @@ std::unique_ptr GpuDisplayProvider::CreateDisplay( + *out_begin_frame_source = std::move(synthetic_begin_frame_source); + + return std::make_unique( +- ServerSharedBitmapManager::current(), renderer_settings, frame_sink_id, ++ server_shared_bitmap_manager_, renderer_settings, frame_sink_id, + std::move(output_surface), std::move(scheduler), task_runner_, + skia_output_surface); + } +diff --git a/components/viz/service/display_embedder/gpu_display_provider.h b/components/viz/service/display_embedder/gpu_display_provider.h +index f714ee18a648..69b46536d378 100644 +--- a/components/viz/service/display_embedder/gpu_display_provider.h ++++ b/components/viz/service/display_embedder/gpu_display_provider.h +@@ -32,6 +32,7 @@ namespace viz { + class Display; + class ExternalBeginFrameControllerImpl; + class GpuServiceImpl; ++class ServerSharedBitmapManager; + class SoftwareOutputDevice; + + // In-process implementation of DisplayProvider. +@@ -42,6 +43,7 @@ class VIZ_SERVICE_EXPORT GpuDisplayProvider : public DisplayProvider { + GpuServiceImpl* gpu_service_impl, + scoped_refptr gpu_service, + gpu::GpuChannelManager* gpu_channel_manager, ++ ServerSharedBitmapManager* server_shared_bitmap_manager, + bool headless, + bool wait_for_all_pipeline_stages_before_draw); + ~GpuDisplayProvider() override; +@@ -68,6 +70,7 @@ class VIZ_SERVICE_EXPORT GpuDisplayProvider : public DisplayProvider { + gpu::GpuChannelManagerDelegate* const gpu_channel_manager_delegate_; + std::unique_ptr gpu_memory_buffer_manager_; + gpu::ImageFactory* const image_factory_; ++ ServerSharedBitmapManager* const server_shared_bitmap_manager_; + + #if defined(OS_WIN) + // Used for software compositing output on Windows. +diff --git a/components/viz/service/display_embedder/server_shared_bitmap_manager.cc b/components/viz/service/display_embedder/server_shared_bitmap_manager.cc +index 5e252917bc0f..142131ce2057 100644 +--- a/components/viz/service/display_embedder/server_shared_bitmap_manager.cc ++++ b/components/viz/service/display_embedder/server_shared_bitmap_manager.cc +@@ -57,9 +57,6 @@ class ServerSharedBitmap : public SharedBitmap { + + } // namespace + +-base::LazyInstance::DestructorAtExit +- g_shared_memory_manager = LAZY_INSTANCE_INITIALIZER; +- + ServerSharedBitmapManager::ServerSharedBitmapManager() = default; + + ServerSharedBitmapManager::~ServerSharedBitmapManager() { +@@ -68,10 +65,6 @@ ServerSharedBitmapManager::~ServerSharedBitmapManager() { + DCHECK(handle_map_.empty()); + } + +-ServerSharedBitmapManager* ServerSharedBitmapManager::current() { +- return g_shared_memory_manager.Pointer(); +-} +- + std::unique_ptr ServerSharedBitmapManager::GetSharedBitmapFromId( + const gfx::Size& size, + ResourceFormat format, +diff --git a/components/viz/service/display_embedder/server_shared_bitmap_manager.h b/components/viz/service/display_embedder/server_shared_bitmap_manager.h +index 578107358506..6055c3875d80 100644 +--- a/components/viz/service/display_embedder/server_shared_bitmap_manager.h ++++ b/components/viz/service/display_embedder/server_shared_bitmap_manager.h +@@ -33,8 +33,6 @@ class VIZ_SERVICE_EXPORT ServerSharedBitmapManager + ServerSharedBitmapManager(); + ~ServerSharedBitmapManager() override; + +- static ServerSharedBitmapManager* current(); +- + // SharedBitmapManager implementation. + std::unique_ptr GetSharedBitmapFromId( + const gfx::Size& size, +diff --git a/components/viz/service/frame_sinks/compositor_frame_sink_support.cc b/components/viz/service/frame_sinks/compositor_frame_sink_support.cc +index a40382267238..fae027adc21a 100644 +--- a/components/viz/service/frame_sinks/compositor_frame_sink_support.cc ++++ b/components/viz/service/frame_sinks/compositor_frame_sink_support.cc +@@ -9,9 +9,9 @@ + + #include "components/viz/common/frame_sinks/begin_frame_source.h" + #include "components/viz/common/quads/compositor_frame.h" ++#include "components/viz/common/resources/shared_bitmap_manager.h" + #include "components/viz/common/surfaces/surface_info.h" + #include "components/viz/service/display/display.h" +-#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/surfaces/surface.h" + #include "components/viz/service/surfaces/surface_reference.h" +@@ -65,7 +65,7 @@ CompositorFrameSinkSupport::~CompositorFrameSinkSupport() { + // SharedBitmapId that has been reported from the client. Since the client is + // gone that memory can be freed. If we don't then it would leak. + for (const auto& id : owned_bitmaps_) +- ServerSharedBitmapManager::current()->ChildDeletedSharedBitmap(id); ++ frame_sink_manager_->shared_bitmap_manager()->ChildDeletedSharedBitmap(id); + + // No video capture clients should remain after calling + // UnregisterCompositorFrameSinkSupport(). +@@ -254,7 +254,7 @@ void CompositorFrameSinkSupport::SubmitCompositorFrame( + bool CompositorFrameSinkSupport::DidAllocateSharedBitmap( + mojo::ScopedSharedBufferHandle buffer, + const SharedBitmapId& id) { +- if (!ServerSharedBitmapManager::current()->ChildAllocatedSharedBitmap( ++ if (!frame_sink_manager_->shared_bitmap_manager()->ChildAllocatedSharedBitmap( + std::move(buffer), id)) + return false; + +@@ -264,7 +264,7 @@ bool CompositorFrameSinkSupport::DidAllocateSharedBitmap( + + void CompositorFrameSinkSupport::DidDeleteSharedBitmap( + const SharedBitmapId& id) { +- ServerSharedBitmapManager::current()->ChildDeletedSharedBitmap(id); ++ frame_sink_manager_->shared_bitmap_manager()->ChildDeletedSharedBitmap(id); + owned_bitmaps_.erase(id); + } + +diff --git a/components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc b/components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc +index 9852c9b2f180..c1a68ede915e 100644 +--- a/components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc ++++ b/components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc +@@ -11,6 +11,7 @@ + #include "components/viz/common/surfaces/frame_sink_id.h" + #include "components/viz/common/surfaces/surface_id.h" + #include "components/viz/common/surfaces/surface_info.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/test/begin_frame_args_test.h" + #include "components/viz/test/compositor_frame_helpers.h" +@@ -81,7 +82,8 @@ class MockFrameSinkManagerClient : public mojom::FrameSinkManagerClient { + class CompositorFrameSinkSupportTest : public testing::Test { + public: + CompositorFrameSinkSupportTest() +- : begin_frame_source_(0.f, false), ++ : manager_(&shared_bitmap_manager_), ++ begin_frame_source_(0.f, false), + local_surface_id_(3, kArbitraryToken), + frame_sync_token_(GenTestSyncToken(4)), + consumer_sync_token_(GenTestSyncToken(5)) { +@@ -181,6 +183,7 @@ class CompositorFrameSinkSupportTest : public testing::Test { + } + + protected: ++ ServerSharedBitmapManager shared_bitmap_manager_; + FrameSinkManagerImpl manager_; + MockFrameSinkManagerClient frame_sink_manager_client_; + FakeCompositorFrameSinkClient fake_support_client_; +diff --git a/components/viz/service/frame_sinks/direct_layer_tree_frame_sink_unittest.cc b/components/viz/service/frame_sinks/direct_layer_tree_frame_sink_unittest.cc +index 26f1c30b4842..4b742b4a1f93 100644 +--- a/components/viz/service/frame_sinks/direct_layer_tree_frame_sink_unittest.cc ++++ b/components/viz/service/frame_sinks/direct_layer_tree_frame_sink_unittest.cc +@@ -68,6 +68,7 @@ class DirectLayerTreeFrameSinkTest : public testing::Test { + task_runner_(new cc::OrderedSimpleTaskRunner(now_src_.get(), true)), + display_size_(1920, 1080), + display_rect_(display_size_), ++ frame_sink_manager_(&bitmap_manager_), + support_manager_(&frame_sink_manager_), + context_provider_(TestContextProvider::Create()) { + auto display_output_surface = FakeOutputSurface::Create3d(); +@@ -130,9 +131,9 @@ class DirectLayerTreeFrameSinkTest : public testing::Test { + + const gfx::Size display_size_; + const gfx::Rect display_rect_; ++ TestSharedBitmapManager bitmap_manager_; + FrameSinkManagerImpl frame_sink_manager_; + TestCompositorFrameSinkSupportManager support_manager_; +- TestSharedBitmapManager bitmap_manager_; + TestGpuMemoryBufferManager gpu_memory_buffer_manager_; + + scoped_refptr context_provider_; +diff --git a/components/viz/service/frame_sinks/frame_sink_manager_impl.cc b/components/viz/service/frame_sinks/frame_sink_manager_impl.cc +index d01557f46949..bad389a1e18a 100644 +--- a/components/viz/service/frame_sinks/frame_sink_manager_impl.cc ++++ b/components/viz/service/frame_sinks/frame_sink_manager_impl.cc +@@ -9,6 +9,7 @@ + + #include "base/logging.h" + #include "base/metrics/histogram_functions.h" ++#include "components/viz/common/resources/shared_bitmap_manager.h" + #include "components/viz/service/display/display.h" + #include "components/viz/service/display_embedder/display_provider.h" + #include "components/viz/service/display_embedder/external_begin_frame_controller_impl.h" +@@ -39,9 +40,11 @@ FrameSinkManagerImpl::FrameSinkSourceMapping::operator=( + FrameSinkSourceMapping&& other) = default; + + FrameSinkManagerImpl::FrameSinkManagerImpl( ++ SharedBitmapManager* shared_bitmap_manager, + base::Optional activation_deadline_in_frames, + DisplayProvider* display_provider) +- : display_provider_(display_provider), ++ : shared_bitmap_manager_(shared_bitmap_manager), ++ display_provider_(display_provider), + surface_manager_(activation_deadline_in_frames), + hit_test_manager_(surface_manager()), + binding_(this) { +diff --git a/components/viz/service/frame_sinks/frame_sink_manager_impl.h b/components/viz/service/frame_sinks/frame_sink_manager_impl.h +index 7f2352e93677..edf6b35827d8 100644 +--- a/components/viz/service/frame_sinks/frame_sink_manager_impl.h ++++ b/components/viz/service/frame_sinks/frame_sink_manager_impl.h +@@ -37,10 +37,10 @@ + #include "services/viz/public/interfaces/compositing/video_detector_observer.mojom.h" + + namespace viz { +- + class CapturableFrameSink; + class CompositorFrameSinkSupport; + class DisplayProvider; ++class SharedBitmapManager; + + // FrameSinkManagerImpl manages BeginFrame hierarchy. This is the implementation + // detail for FrameSinkManagerImpl. +@@ -50,9 +50,11 @@ class VIZ_SERVICE_EXPORT FrameSinkManagerImpl + public mojom::FrameSinkManager, + public HitTestAggregatorDelegate { + public: +- FrameSinkManagerImpl(base::Optional activation_deadline_in_frames = +- kDefaultActivationDeadlineInFrames, +- DisplayProvider* display_provider = nullptr); ++ explicit FrameSinkManagerImpl( ++ SharedBitmapManager* shared_bitmap_manager, ++ base::Optional activation_deadline_in_frames = ++ kDefaultActivationDeadlineInFrames, ++ DisplayProvider* display_provider = nullptr); + ~FrameSinkManagerImpl() override; + + // Binds |this| as a FrameSinkManagerImpl for |request| on |task_runner|. On +@@ -142,8 +144,10 @@ class VIZ_SERVICE_EXPORT FrameSinkManagerImpl + BeginFrameSource* GetPrimaryBeginFrameSource(); + + SurfaceManager* surface_manager() { return &surface_manager_; } +- + const HitTestManager* hit_test_manager() { return &hit_test_manager_; } ++ SharedBitmapManager* shared_bitmap_manager() { ++ return shared_bitmap_manager_; ++ } + + void SubmitHitTestRegionList( + const SurfaceId& surface_id, +@@ -210,6 +214,9 @@ class VIZ_SERVICE_EXPORT FrameSinkManagerImpl + bool ChildContains(const FrameSinkId& child_frame_sink_id, + const FrameSinkId& search_frame_sink_id) const; + ++ // SharedBitmapManager for the viz display service for receiving software ++ // resources in CompositorFrameSinks. ++ SharedBitmapManager* const shared_bitmap_manager_; + // Provides a Display for CreateRootCompositorFrameSink(). + DisplayProvider* const display_provider_; + +diff --git a/components/viz/service/frame_sinks/frame_sink_manager_unittest.cc b/components/viz/service/frame_sinks/frame_sink_manager_unittest.cc +index 3f17acac088a..1fdbc3fb35e6 100644 +--- a/components/viz/service/frame_sinks/frame_sink_manager_unittest.cc ++++ b/components/viz/service/frame_sinks/frame_sink_manager_unittest.cc +@@ -12,6 +12,7 @@ + #include "components/viz/common/constants.h" + #include "components/viz/common/frame_sinks/begin_frame_source.h" + #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/test/begin_frame_source_test.h" + #include "components/viz/test/compositor_frame_helpers.h" +@@ -55,7 +56,9 @@ struct RootCompositorFrameSinkData { + class FrameSinkManagerTest : public testing::Test { + public: + FrameSinkManagerTest() +- : manager_(kDefaultActivationDeadlineInFrames, &display_provider_) {} ++ : manager_(&shared_bitmap_manager_, ++ kDefaultActivationDeadlineInFrames, ++ &display_provider_) {} + ~FrameSinkManagerTest() override = default; + + std::unique_ptr CreateCompositorFrameSinkSupport( +@@ -84,6 +87,7 @@ class FrameSinkManagerTest : public testing::Test { + } + + protected: ++ ServerSharedBitmapManager shared_bitmap_manager_; + TestDisplayProvider display_provider_; + FrameSinkManagerImpl manager_; + }; +diff --git a/components/viz/service/frame_sinks/surface_references_unittest.cc b/components/viz/service/frame_sinks/surface_references_unittest.cc +index eb69755a3177..e5df8b486541 100644 +--- a/components/viz/service/frame_sinks/surface_references_unittest.cc ++++ b/components/viz/service/frame_sinks/surface_references_unittest.cc +@@ -10,6 +10,7 @@ + #include "base/containers/flat_set.h" + #include "base/test/test_mock_time_task_runner.h" + #include "components/viz/common/surfaces/surface_id.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/surfaces/surface.h" +@@ -126,7 +127,7 @@ class SurfaceReferencesTest : public testing::Test { + // testing::Test: + void SetUp() override { + // Start each test with a fresh SurfaceManager instance. +- manager_ = std::make_unique(); ++ manager_ = std::make_unique(&shared_bitmap_manager_); + frame_sink_manager_client_ = + std::make_unique(manager_.get()); + manager_->SetLocalClient(frame_sink_manager_client_.get()); +@@ -140,12 +141,13 @@ class SurfaceReferencesTest : public testing::Test { + scoped_refptr task_runner_; + base::TestMockTimeTaskRunner::ScopedContext scoped_context_; + ++ ServerSharedBitmapManager shared_bitmap_manager_; ++ std::unique_ptr manager_; ++ std::unique_ptr frame_sink_manager_client_; + std::unordered_map, + FrameSinkIdHash> + supports_; +- std::unique_ptr manager_; +- std::unique_ptr frame_sink_manager_client_; + }; + + TEST_F(SurfaceReferencesTest, AddReference) { +diff --git a/components/viz/service/frame_sinks/surface_synchronization_unittest.cc b/components/viz/service/frame_sinks/surface_synchronization_unittest.cc +index 8b83cea05dd3..36eb4787a071 100644 +--- a/components/viz/service/frame_sinks/surface_synchronization_unittest.cc ++++ b/components/viz/service/frame_sinks/surface_synchronization_unittest.cc +@@ -5,6 +5,7 @@ + #include "base/containers/flat_set.h" + #include "base/test/simple_test_tick_clock.h" + #include "components/viz/common/surfaces/surface_id.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/test/begin_frame_args_test.h" +@@ -87,7 +88,8 @@ class FakeExternalBeginFrameSourceClient + class SurfaceSynchronizationTest : public testing::Test { + public: + SurfaceSynchronizationTest() +- : frame_sink_manager_client_(&frame_sink_manager_), ++ : frame_sink_manager_(&shared_bitmap_manager_), ++ frame_sink_manager_client_(&frame_sink_manager_), + surface_observer_(false) {} + ~SurfaceSynchronizationTest() override {} + +@@ -258,6 +260,7 @@ class SurfaceSynchronizationTest : public testing::Test { + + private: + std::unique_ptr now_src_; ++ ServerSharedBitmapManager shared_bitmap_manager_; + FrameSinkManagerImpl frame_sink_manager_; + TestFrameSinkManagerClient frame_sink_manager_client_; + FakeSurfaceObserver surface_observer_; +diff --git a/components/viz/service/frame_sinks/video_detector_unittest.cc b/components/viz/service/frame_sinks/video_detector_unittest.cc +index c56d8d49f82a..d7f76b72c88a 100644 +--- a/components/viz/service/frame_sinks/video_detector_unittest.cc ++++ b/components/viz/service/frame_sinks/video_detector_unittest.cc +@@ -13,6 +13,7 @@ + #include "components/viz/common/quads/surface_draw_quad.h" + #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h" + #include "components/viz/service/display/surface_aggregator.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/frame_sinks/video_detector.h" +@@ -74,7 +75,8 @@ class TestObserver : public mojom::VideoDetectorObserver { + class VideoDetectorTest : public testing::Test { + public: + VideoDetectorTest() +- : surface_aggregator_(frame_sink_manager_.surface_manager(), ++ : frame_sink_manager_(&shared_bitmap_manager_), ++ surface_aggregator_(frame_sink_manager_.surface_manager(), + nullptr, + false) {} + +@@ -192,6 +194,7 @@ class VideoDetectorTest : public testing::Test { + .Build(); + } + ++ ServerSharedBitmapManager shared_bitmap_manager_; + FrameSinkManagerImpl frame_sink_manager_; + FakeCompositorFrameSinkClient frame_sink_client_; + ParentLocalSurfaceIdAllocator parent_local_surface_id_allocator_; +diff --git a/components/viz/service/hit_test/hit_test_aggregator_unittest.cc b/components/viz/service/hit_test/hit_test_aggregator_unittest.cc +index d59985209db2..7e8a966240bd 100644 +--- a/components/viz/service/hit_test/hit_test_aggregator_unittest.cc ++++ b/components/viz/service/hit_test/hit_test_aggregator_unittest.cc +@@ -11,6 +11,7 @@ + #include "components/viz/common/surfaces/frame_sink_id.h" + #include "components/viz/common/surfaces/surface_id.h" + #include "components/viz/host/host_frame_sink_manager.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/hit_test/hit_test_aggregator_delegate.h" +@@ -59,7 +60,8 @@ class TestHostFrameSinkManager : public HostFrameSinkManager { + + class TestFrameSinkManagerImpl : public FrameSinkManagerImpl { + public: +- TestFrameSinkManagerImpl() = default; ++ explicit TestFrameSinkManagerImpl(SharedBitmapManager* shared_bitmap_manager) ++ : FrameSinkManagerImpl(shared_bitmap_manager) {} + ~TestFrameSinkManagerImpl() override = default; + + void SetLocalClient(TestHostFrameSinkManager* client) { +@@ -112,7 +114,8 @@ class HitTestAggregatorTest : public testing::Test { + + // testing::Test: + void SetUp() override { +- frame_sink_manager_ = std::make_unique(); ++ frame_sink_manager_ = ++ std::make_unique(&shared_bitmap_manager_); + host_frame_sink_manager_ = std::make_unique(); + local_surface_id_lookup_delegate_ = + std::make_unique(); +@@ -208,6 +211,7 @@ class HitTestAggregatorTest : public testing::Test { + } + + private: ++ ServerSharedBitmapManager shared_bitmap_manager_; + std::unique_ptr hit_test_aggregator_; + std::unique_ptr frame_sink_manager_; + std::unique_ptr host_frame_sink_manager_; +diff --git a/components/viz/service/hit_test/hit_test_manager_fuzzer.cc b/components/viz/service/hit_test/hit_test_manager_fuzzer.cc +index 734d626750d8..9b6001433292 100644 +--- a/components/viz/service/hit_test/hit_test_manager_fuzzer.cc ++++ b/components/viz/service/hit_test/hit_test_manager_fuzzer.cc +@@ -8,6 +8,7 @@ + + #include "base/command_line.h" + #include "base/test/fuzzed_data_provider.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/hit_test/hit_test_aggregator.h" +@@ -134,7 +135,8 @@ void SubmitHitTestRegionList( + + extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t num_bytes) { + base::FuzzedDataProvider fuzz(data, num_bytes); +- viz::FrameSinkManagerImpl frame_sink_manager; ++ viz::ServerSharedBitmapManager shared_bitmap_manager; ++ viz::FrameSinkManagerImpl frame_sink_manager(&shared_bitmap_manager); + viz::TestLatestLocalSurfaceIdLookupDelegate delegate; + viz::TestLatestLocalSurfaceIdLookupDelegate* lsi_delegate = + fuzz.ConsumeBool() ? &delegate : nullptr; +diff --git a/components/viz/service/main/viz_main_impl.cc b/components/viz/service/main/viz_main_impl.cc +index 72b26afce32d..662034906499 100644 +--- a/components/viz/service/main/viz_main_impl.cc ++++ b/components/viz/service/main/viz_main_impl.cc +@@ -12,9 +12,11 @@ + #include "base/power_monitor/power_monitor_device_source.h" + #include "base/single_thread_task_runner.h" + #include "base/threading/sequenced_task_runner_handle.h" ++#include "base/trace_event/memory_dump_manager.h" + #include "build/build_config.h" + #include "components/viz/common/switches.h" + #include "components/viz/service/display_embedder/gpu_display_provider.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/gl/gpu_service_impl.h" + #include "gpu/command_buffer/common/activity_flags.h" +@@ -279,9 +281,14 @@ void VizMainImpl::CreateFrameSinkManagerOnCompositorThread( + + base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); + ++ server_shared_bitmap_manager_ = std::make_unique(); ++ base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( ++ server_shared_bitmap_manager_.get(), "viz::ServerSharedBitmapManager", ++ base::ThreadTaskRunnerHandle::Get()); ++ + display_provider_ = std::make_unique( + params->restart_id, gpu_service_.get(), gpu_command_service_, +- gpu_service_->gpu_channel_manager(), ++ gpu_service_->gpu_channel_manager(), server_shared_bitmap_manager_.get(), + command_line->HasSwitch(switches::kHeadless), + command_line->HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)); + +@@ -291,14 +298,20 @@ void VizMainImpl::CreateFrameSinkManagerOnCompositorThread( + if (params->use_activation_deadline) + activation_deadline_in_frames = params->activation_deadline_in_frames; + frame_sink_manager_ = std::make_unique( +- activation_deadline_in_frames, display_provider_.get()); ++ server_shared_bitmap_manager_.get(), activation_deadline_in_frames, ++ display_provider_.get()); + frame_sink_manager_->BindAndSetClient(std::move(params->frame_sink_manager), + nullptr, std::move(client)); + } + + void VizMainImpl::TearDownOnCompositorThread() { ++ base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( ++ server_shared_bitmap_manager_.get()); ++ + frame_sink_manager_.reset(); + display_provider_.reset(); ++ ++ server_shared_bitmap_manager_.reset(); + } + + void VizMainImpl::PreSandboxStartup() { +diff --git a/components/viz/service/main/viz_main_impl.h b/components/viz/service/main/viz_main_impl.h +index 8bb8e2be1643..48e12c66da18 100644 +--- a/components/viz/service/main/viz_main_impl.h ++++ b/components/viz/service/main/viz_main_impl.h +@@ -33,6 +33,7 @@ namespace viz { + class DisplayProvider; + class FrameSinkManagerImpl; + class GpuServiceImpl; ++class ServerSharedBitmapManager; + + class VizMainImpl : public gpu::GpuSandboxHelper, public mojom::VizMain { + public: +@@ -149,8 +150,9 @@ class VizMainImpl : public gpu::GpuSandboxHelper, public mojom::VizMain { + + // Provides mojo interfaces for creating and managing FrameSinks. These live + // on the compositor thread. +- std::unique_ptr frame_sink_manager_; ++ std::unique_ptr server_shared_bitmap_manager_; + std::unique_ptr display_provider_; ++ std::unique_ptr frame_sink_manager_; + + const scoped_refptr gpu_thread_task_runner_; + +diff --git a/components/viz/service/surfaces/surface_hittest_unittest.cc b/components/viz/service/surfaces/surface_hittest_unittest.cc +index ea2e4788e7d8..d9cd05c3d9e4 100644 +--- a/components/viz/service/surfaces/surface_hittest_unittest.cc ++++ b/components/viz/service/surfaces/surface_hittest_unittest.cc +@@ -6,6 +6,7 @@ + + #include "components/viz/common/quads/compositor_frame.h" + #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/surfaces/surface.h" +@@ -70,7 +71,7 @@ using namespace test; + + class SurfaceHittestTest : public testing::Test { + public: +- SurfaceHittestTest() = default; ++ SurfaceHittestTest() : frame_sink_manager_(&shared_bitmap_manager_) {} + ~SurfaceHittestTest() override = default; + + CompositorFrameSinkSupport& root_support() { return *supports_[0]; } +@@ -96,6 +97,7 @@ class SurfaceHittestTest : public testing::Test { + void TearDown() override { supports_.clear(); } + + private: ++ ServerSharedBitmapManager shared_bitmap_manager_; + FrameSinkManagerImpl frame_sink_manager_; + std::vector> supports_; + FakeCompositorFrameSinkClient client_; +diff --git a/components/viz/service/surfaces/surface_unittest.cc b/components/viz/service/surfaces/surface_unittest.cc +index fb4bb3cd7777..c1d55fdfa622 100644 +--- a/components/viz/service/surfaces/surface_unittest.cc ++++ b/components/viz/service/surfaces/surface_unittest.cc +@@ -6,6 +6,7 @@ + #include "cc/test/scheduler_test_common.h" + #include "components/viz/common/frame_sinks/copy_output_result.h" + #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/service/surfaces/surface_dependency_tracker.h" +@@ -28,7 +29,8 @@ TEST(SurfaceTest, PresentationCallback) { + constexpr gfx::Rect kDamageRect(0, 0); + const LocalSurfaceId local_surface_id(6, base::UnguessableToken::Create()); + +- FrameSinkManagerImpl frame_sink_manager; ++ ServerSharedBitmapManager shared_bitmap_manager; ++ FrameSinkManagerImpl frame_sink_manager(&shared_bitmap_manager); + MockCompositorFrameSinkClient client; + auto support = std::make_unique( + &client, &frame_sink_manager, kArbitraryFrameSinkId, kIsRoot, +@@ -78,7 +80,8 @@ void TestCopyResultCallback(bool* called, + // Test that CopyOutputRequests can outlive the current frame and be + // aggregated on the next frame. + TEST(SurfaceTest, CopyRequestLifetime) { +- FrameSinkManagerImpl frame_sink_manager; ++ ServerSharedBitmapManager shared_bitmap_manager; ++ FrameSinkManagerImpl frame_sink_manager(&shared_bitmap_manager); + SurfaceManager* surface_manager = frame_sink_manager.surface_manager(); + auto support = std::make_unique( + nullptr, &frame_sink_manager, kArbitraryFrameSinkId, kIsRoot, +diff --git a/components/viz/test/test_layer_tree_frame_sink.cc b/components/viz/test/test_layer_tree_frame_sink.cc +index 14e1c74a9e88..932cfb499826 100644 +--- a/components/viz/test/test_layer_tree_frame_sink.cc ++++ b/components/viz/test/test_layer_tree_frame_sink.cc +@@ -73,7 +73,8 @@ bool TestLayerTreeFrameSink::BindToClient( + if (!LayerTreeFrameSink::BindToClient(client)) + return false; + +- frame_sink_manager_ = std::make_unique(); ++ frame_sink_manager_ = ++ std::make_unique(&shared_bitmap_manager_); + + std::unique_ptr display_output_surface = + test_client_->CreateDisplayOutputSurface(context_provider()); +diff --git a/content/browser/browser_main_loop.cc b/content/browser/browser_main_loop.cc +index c17b467f2140..6ac229f6ba79 100644 +--- a/content/browser/browser_main_loop.cc ++++ b/content/browser/browser_main_loop.cc +@@ -750,9 +750,13 @@ void BrowserMainLoop::PostMainMessageLoopStart() { + + // Enable memory-infra dump providers. + InitSkiaEventTracer(); +- base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( +- viz::ServerSharedBitmapManager::current(), +- "viz::ServerSharedBitmapManager", nullptr); ++#if !defined(OS_ANDROID) ++ if (server_shared_bitmap_manager_) { ++ base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( ++ server_shared_bitmap_manager_.get(), "viz::ServerSharedBitmapManager", ++ nullptr); ++ } ++#endif + base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( + skia::SkiaMemoryDumpProvider::GetInstance(), "Skia", nullptr); + base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( +@@ -1055,6 +1059,7 @@ void BrowserMainLoop::ShutdownThreadsAndCleanUp() { + host_frame_sink_manager_.reset(); + frame_sink_manager_impl_.reset(); + compositing_mode_reporter_impl_.reset(); ++ server_shared_bitmap_manager_.reset(); + #endif + + // The device monitors are using |system_monitor_| as dependency, so delete +@@ -1150,6 +1155,11 @@ base::SequencedTaskRunner* BrowserMainLoop::audio_service_runner() { + viz::FrameSinkManagerImpl* BrowserMainLoop::GetFrameSinkManager() const { + return frame_sink_manager_impl_.get(); + } ++ ++viz::ServerSharedBitmapManager* BrowserMainLoop::GetServerSharedBitmapManager() ++ const { ++ return server_shared_bitmap_manager_.get(); ++} + #endif + + void BrowserMainLoop::GetCompositingModeReporter( +@@ -1267,17 +1277,20 @@ int BrowserMainLoop::BrowserThreadsStarted() { + transport_factory->ConnectHostFrameSinkManager(); + ImageTransportFactory::SetFactory(std::move(transport_factory)); + } else { ++ server_shared_bitmap_manager_ = ++ std::make_unique(); + frame_sink_manager_impl_ = std::make_unique( ++ server_shared_bitmap_manager_.get(), + switches::GetDeadlineToSynchronizeSurfaces()); + + surface_utils::ConnectWithLocalFrameSinkManager( + host_frame_sink_manager_.get(), frame_sink_manager_impl_.get()); + +- + ImageTransportFactory::SetFactory( + std::make_unique( + BrowserGpuChannelHostFactory::instance(), +- compositing_mode_reporter_impl_.get(), GetResizeTaskRunner())); ++ compositing_mode_reporter_impl_.get(), ++ server_shared_bitmap_manager_.get(), GetResizeTaskRunner())); + } + } + +diff --git a/content/browser/browser_main_loop.h b/content/browser/browser_main_loop.h +index f117bf39fa7b..572bfdcda6ab 100644 +--- a/content/browser/browser_main_loop.h ++++ b/content/browser/browser_main_loop.h +@@ -91,6 +91,7 @@ namespace viz { + class CompositingModeReporterImpl; + class FrameSinkManagerImpl; + class HostFrameSinkManager; ++class ServerSharedBitmapManager; + } + + namespace content { +@@ -217,6 +218,9 @@ class CONTENT_EXPORT BrowserMainLoop { + // TODO(crbug.com/657959): This will be removed once there are no users, as + // SurfaceManager is being moved out of process. + viz::FrameSinkManagerImpl* GetFrameSinkManager() const; ++ ++ // This returns null when the display compositor is out of process. ++ viz::ServerSharedBitmapManager* GetServerSharedBitmapManager() const; + #endif + + // Fulfills a mojo pointer to the singleton CompositingModeReporter. +@@ -384,6 +388,11 @@ class CONTENT_EXPORT BrowserMainLoop { + scoped_refptr save_file_manager_; + std::unique_ptr tracing_controller_; + #if !defined(OS_ANDROID) ++ // A SharedBitmapManager used to sharing and mapping IDs to shared memory ++ // between processes for software compositing. When the display compositor is ++ // in the browser process, then |server_shared_bitmap_manager_| is set, and ++ // when it is in the viz process, then it is null. ++ std::unique_ptr server_shared_bitmap_manager_; + std::unique_ptr host_frame_sink_manager_; + // This is owned here so that SurfaceManager will be accessible in process + // when display is in the same process. Other than using SurfaceManager, +diff --git a/content/browser/compositor/gpu_process_transport_factory.cc b/content/browser/compositor/gpu_process_transport_factory.cc +index d90a276fc0e1..f0db9d11ce10 100644 +--- a/content/browser/compositor/gpu_process_transport_factory.cc ++++ b/content/browser/compositor/gpu_process_transport_factory.cc +@@ -178,6 +178,7 @@ struct GpuProcessTransportFactory::PerCompositorData { + GpuProcessTransportFactory::GpuProcessTransportFactory( + gpu::GpuChannelEstablishFactory* gpu_channel_factory, + viz::CompositingModeReporterImpl* compositing_mode_reporter, ++ viz::ServerSharedBitmapManager* server_shared_bitmap_manager, + scoped_refptr resize_task_runner) + : frame_sink_id_allocator_(kDefaultClientId), + renderer_settings_(viz::CreateRendererSettings()), +@@ -185,6 +186,7 @@ GpuProcessTransportFactory::GpuProcessTransportFactory( + task_graph_runner_(new cc::SingleThreadTaskGraphRunner), + gpu_channel_factory_(gpu_channel_factory), + compositing_mode_reporter_(compositing_mode_reporter), ++ server_shared_bitmap_manager_(server_shared_bitmap_manager), + callback_factory_(this) { + DCHECK(gpu_channel_factory_); + cc::SetClientNameForMetrics("Browser"); +@@ -641,7 +643,7 @@ void GpuProcessTransportFactory::EstablishedGpuChannel( + + // The Display owns and uses the |display_output_surface| created above. + data->display = std::make_unique( +- viz::ServerSharedBitmapManager::current(), renderer_settings_, ++ server_shared_bitmap_manager_, renderer_settings_, + compositor->frame_sink_id(), std::move(display_output_surface), + std::move(scheduler), compositor->task_runner()); + data->display_client = +diff --git a/content/browser/compositor/gpu_process_transport_factory.h b/content/browser/compositor/gpu_process_transport_factory.h +index 02c1ec0d59bd..2ea8c9f4162e 100644 +--- a/content/browser/compositor/gpu_process_transport_factory.h ++++ b/content/browser/compositor/gpu_process_transport_factory.h +@@ -47,6 +47,7 @@ class ContextProviderCommandBuffer; + namespace viz { + class CompositingModeReporterImpl; + class OutputDeviceBacking; ++class ServerSharedBitmapManager; + class SoftwareOutputDevice; + class VulkanInProcessContextProvider; + class RasterContextProvider; +@@ -62,6 +63,7 @@ class GpuProcessTransportFactory : public ui::ContextFactory, + GpuProcessTransportFactory( + gpu::GpuChannelEstablishFactory* gpu_channel_factory, + viz::CompositingModeReporterImpl* compositing_mode_reporter, ++ viz::ServerSharedBitmapManager* server_shared_bitmap_manager, + scoped_refptr resize_task_runner); + + ~GpuProcessTransportFactory() override; +@@ -180,6 +182,8 @@ class GpuProcessTransportFactory : public ui::ContextFactory, + // Service-side impl that controls the compositing mode based on what mode the + // display compositors are using. + viz::CompositingModeReporterImpl* const compositing_mode_reporter_; ++ // Manages a mapping of SharedBitmapId to shared memory objects. ++ viz::ServerSharedBitmapManager* const server_shared_bitmap_manager_; + + base::WeakPtrFactory callback_factory_; + +diff --git a/content/browser/compositor/test/test_image_transport_factory.cc b/content/browser/compositor/test/test_image_transport_factory.cc +index 037a51961140..cb6f07bdc3e0 100644 +--- a/content/browser/compositor/test/test_image_transport_factory.cc ++++ b/content/browser/compositor/test/test_image_transport_factory.cc +@@ -9,6 +9,7 @@ + + #include "components/viz/common/features.h" + #include "components/viz/common/gl_helper.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/test/test_frame_sink_manager.h" + #include "content/browser/compositor/surface_utils.h" +@@ -61,7 +62,9 @@ TestImageTransportFactory::TestImageTransportFactory() + std::move(frame_sink_manager_request), + std::move(frame_sink_manager_client)); + } else { +- frame_sink_manager_impl_ = std::make_unique(); ++ shared_bitmap_manager_ = std::make_unique(); ++ frame_sink_manager_impl_ = std::make_unique( ++ shared_bitmap_manager_.get()); + surface_utils::ConnectWithLocalFrameSinkManager( + &host_frame_sink_manager_, frame_sink_manager_impl_.get()); + } +diff --git a/content/browser/compositor/test/test_image_transport_factory.h b/content/browser/compositor/test/test_image_transport_factory.h +index 76196cee2e27..1cd245d0a01a 100644 +--- a/content/browser/compositor/test/test_image_transport_factory.h ++++ b/content/browser/compositor/test/test_image_transport_factory.h +@@ -23,6 +23,7 @@ + namespace viz { + class GLHelper; + class FrameSinkManagerImpl; ++class ServerSharedBitmapManager; + class TestFrameSinkManagerImpl; + } // namespace viz + +@@ -98,6 +99,7 @@ class TestImageTransportFactory : public ui::ContextFactory, + viz::HostFrameSinkManager host_frame_sink_manager_; + + // Objects that exist if |enable_viz_| is false. ++ std::unique_ptr shared_bitmap_manager_; + std::unique_ptr frame_sink_manager_impl_; + std::unique_ptr gl_helper_; + +diff --git a/content/browser/renderer_host/compositor_impl_android.cc b/content/browser/renderer_host/compositor_impl_android.cc +index d2f18a562af3..85e4d4b5c1df 100644 +--- a/content/browser/renderer_host/compositor_impl_android.cc ++++ b/content/browser/renderer_host/compositor_impl_android.cc +@@ -174,7 +174,10 @@ class CompositorDependencies { + bool enable_viz = + base::FeatureList::IsEnabled(features::kVizDisplayCompositor); + if (!enable_viz) { +- frame_sink_manager_impl = std::make_unique(); ++ // The SharedBitmapManager can be null as software compositing is not ++ // supported or used on Android. ++ frame_sink_manager_impl = std::make_unique( ++ /*shared_bitmap_manager=*/nullptr); + surface_utils::ConnectWithLocalFrameSinkManager( + &host_frame_sink_manager, frame_sink_manager_impl.get()); + } +@@ -1008,9 +1011,8 @@ void CompositorImpl::InitializeDisplay( + const bool should_register_begin_frame_source = !display_; + + display_ = std::make_unique( +- viz::ServerSharedBitmapManager::current(), renderer_settings, +- frame_sink_id_, std::move(display_output_surface), std::move(scheduler), +- task_runner); ++ nullptr, renderer_settings, frame_sink_id_, ++ std::move(display_output_surface), std::move(scheduler), task_runner); + + auto layer_tree_frame_sink = std::make_unique( + frame_sink_id_, GetHostFrameSinkManager(), manager, display_.get(), +diff --git a/content/browser/renderer_host/embedded_frame_sink_provider_impl_unittest.cc b/content/browser/renderer_host/embedded_frame_sink_provider_impl_unittest.cc +index 02999045b0b3..71073a5ff02d 100644 +--- a/content/browser/renderer_host/embedded_frame_sink_provider_impl_unittest.cc ++++ b/content/browser/renderer_host/embedded_frame_sink_provider_impl_unittest.cc +@@ -13,6 +13,7 @@ + #include "build/build_config.h" + #include "components/viz/common/quads/compositor_frame.h" + #include "components/viz/host/host_frame_sink_manager.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "components/viz/test/compositor_frame_helpers.h" + #include "components/viz/test/fake_host_frame_sink_client.h" +@@ -119,7 +120,8 @@ class EmbeddedFrameSinkProviderImplTest : public testing::Test { + host_frame_sink_manager_ = std::make_unique(); + + // The FrameSinkManagerImpl implementation is in-process here for tests. +- frame_sink_manager_ = std::make_unique(); ++ frame_sink_manager_ = ++ std::make_unique(&shared_bitmap_manager_); + surface_utils::ConnectWithLocalFrameSinkManager( + host_frame_sink_manager_.get(), frame_sink_manager_.get()); + +@@ -140,6 +142,7 @@ class EmbeddedFrameSinkProviderImplTest : public testing::Test { + // A MessageLoop is required for mojo bindings which are used to + // connect to graphics services. + base::MessageLoop message_loop_; ++ viz::ServerSharedBitmapManager shared_bitmap_manager_; + viz::FakeHostFrameSinkClient host_frame_sink_client_; + std::unique_ptr host_frame_sink_manager_; + std::unique_ptr frame_sink_manager_; +diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc +index 2efe7a5c7de9..856dc18181f1 100644 +--- a/content/browser/renderer_host/render_widget_host_impl.cc ++++ b/content/browser/renderer_host/render_widget_host_impl.cc +@@ -421,6 +421,17 @@ RenderWidgetHostImpl::RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate, + enable_surface_synchronization_ = features::IsSurfaceSynchronizationEnabled(); + enable_viz_ = base::FeatureList::IsEnabled(features::kVizDisplayCompositor); + ++ if (!enable_viz_) { ++#if !defined(OS_ANDROID) ++ // Software compositing is not supported or used on Android. ++ // ++ // The BrowserMainLoop is null in unit tests, but they do not use ++ // compositing and report SharedBitmapIds. ++ if (BrowserMainLoop* main_loop = BrowserMainLoop::GetInstance()) ++ shared_bitmap_manager_ = main_loop->GetServerSharedBitmapManager(); ++#endif ++ } ++ + delegate_->RenderWidgetCreated(this); + render_frame_metadata_provider_.AddObserver(this); + } +@@ -1991,8 +2002,15 @@ void RenderWidgetHostImpl::Destroy(bool also_delete) { + // The display compositor has ownership of shared memory for each + // SharedBitmapId that has been reported from the client. Since the client is + // gone that memory can be freed. If we don't then it would leak. +- for (const auto& id : owned_bitmaps_) +- viz::ServerSharedBitmapManager::current()->ChildDeletedSharedBitmap(id); ++ if (shared_bitmap_manager_) { ++ for (const auto& id : owned_bitmaps_) ++ shared_bitmap_manager_->ChildDeletedSharedBitmap(id); ++ } else { ++ // If the display compositor is not in the browser process, then the ++ // |bitmap_manager| is not present in the process either, and no bitmaps ++ // should have been registered with this class. ++ DCHECK(owned_bitmaps_.empty()); ++ } + + process_->RemoveWidget(this); + process_->RemoveRoute(routing_id_); +@@ -2150,8 +2168,8 @@ void RenderWidgetHostImpl::DidNotProduceFrame(const viz::BeginFrameAck& ack) { + void RenderWidgetHostImpl::DidAllocateSharedBitmap( + mojo::ScopedSharedBufferHandle buffer, + const viz::SharedBitmapId& id) { +- if (!viz::ServerSharedBitmapManager::current()->ChildAllocatedSharedBitmap( +- std::move(buffer), id)) { ++ if (!shared_bitmap_manager_->ChildAllocatedSharedBitmap(std::move(buffer), ++ id)) { + bad_message::ReceivedBadMessage(GetProcess(), + bad_message::RWH_SHARED_BITMAP); + } +@@ -2160,7 +2178,7 @@ void RenderWidgetHostImpl::DidAllocateSharedBitmap( + + void RenderWidgetHostImpl::DidDeleteSharedBitmap( + const viz::SharedBitmapId& id) { +- viz::ServerSharedBitmapManager::current()->ChildDeletedSharedBitmap(id); ++ shared_bitmap_manager_->ChildDeletedSharedBitmap(id); + owned_bitmaps_.erase(id); + } + +diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h +index 7328c615c87d..05f539cddbd3 100644 +--- a/content/browser/renderer_host/render_widget_host_impl.h ++++ b/content/browser/renderer_host/render_widget_host_impl.h +@@ -96,6 +96,10 @@ namespace ui { + enum class DomCode; + } + ++namespace viz { ++class ServerSharedBitmapManager; ++} ++ + namespace content { + + class BrowserAccessibilityManager; +@@ -1170,9 +1174,15 @@ class CONTENT_EXPORT RenderWidgetHostImpl + base::Optional screen_orientation_angle_for_testing_; + base::Optional screen_orientation_type_for_testing_; + ++ // When the viz display compositor is in the browser process, this is used to ++ // register and unregister the bitmaps (stored in |owned_bitmaps_| reported to ++ // this class from the renderer. ++ viz::ServerSharedBitmapManager* shared_bitmap_manager_ = nullptr; + // The set of SharedBitmapIds that have been reported as allocated to this + // interface. On closing this interface, the display compositor should drop +- // ownership of the bitmaps with these ids to avoid leaking them. ++ // ownership of the bitmaps with these ids to avoid leaking them. This is only ++ // used when SharedBitmaps are reported to this class because the display ++ // compositor is in the browser process. + std::set owned_bitmaps_; + + bool force_enable_zoom_ = false; +diff --git a/third_party/blink/renderer/platform/graphics/offscreen_canvas_resource_provider.cc b/third_party/blink/renderer/platform/graphics/offscreen_canvas_resource_provider.cc +index 8c140158bfd4..6d2fe1f74f78 100644 +--- a/third_party/blink/renderer/platform/graphics/offscreen_canvas_resource_provider.cc ++++ b/third_party/blink/renderer/platform/graphics/offscreen_canvas_resource_provider.cc +@@ -181,8 +181,10 @@ void OffscreenCanvasResourceProvider::ReclaimResourceInternal( + } + + OffscreenCanvasResourceProvider::FrameResource::~FrameResource() { +- provider->frame_dispatcher_->DidDeleteSharedBitmap( +- SharedBitmapIdToGpuMailboxPtr(shared_bitmap_id)); ++ if (!shared_bitmap_id.IsZero()) { ++ provider->frame_dispatcher_->DidDeleteSharedBitmap( ++ SharedBitmapIdToGpuMailboxPtr(shared_bitmap_id)); ++ } + } + + } // namespace blink +diff --git a/ui/aura/BUILD.gn b/ui/aura/BUILD.gn +index c5eb719ef5d8..6f6a0534e8c9 100644 +--- a/ui/aura/BUILD.gn ++++ b/ui/aura/BUILD.gn +@@ -344,6 +344,7 @@ executable("demo") { + "//build/config:exe_and_shlib_deps", + "//build/win:default_exe_manifest", + "//components/viz/host", ++ "//components/viz/service", + "//skia", + "//third_party/icu", + "//ui/base", +diff --git a/ui/aura/demo/DEPS b/ui/aura/demo/DEPS +index 4026dbd84623..608c21f85e51 100644 +--- a/ui/aura/demo/DEPS ++++ b/ui/aura/demo/DEPS +@@ -1,5 +1,6 @@ + include_rules = [ + "+components/viz/host", ++ "+components/viz/service", # In-process viz service. + "+ui/display", # Windows DPI Initialization. + "+ui/gl/init/gl_factory.h", # To initialize GL bindings. + ] +diff --git a/ui/aura/demo/demo_main.cc b/ui/aura/demo/demo_main.cc +index 7c7c6da576b2..c44a9f8bf1fb 100644 +--- a/ui/aura/demo/demo_main.cc ++++ b/ui/aura/demo/demo_main.cc +@@ -16,6 +16,8 @@ + #include "base/task_scheduler/task_scheduler.h" + #include "build/build_config.h" + #include "components/viz/host/host_frame_sink_manager.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" ++#include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "third_party/skia/include/core/SkBlendMode.h" + #include "ui/aura/client/default_capture_client.h" + #include "ui/aura/client/window_parenting_client.h" +@@ -147,7 +149,8 @@ int DemoMain() { + + // The ContextFactory must exist before any Compositors are created. + viz::HostFrameSinkManager host_frame_sink_manager; +- viz::FrameSinkManagerImpl frame_sink_manager; ++ viz::ServerSharedBitmapManager server_shared_bitmap_manager; ++ viz::FrameSinkManagerImpl frame_sink_manager(&server_shared_bitmap_manager); + host_frame_sink_manager.SetLocalManager(&frame_sink_manager); + frame_sink_manager.SetLocalClient(&host_frame_sink_manager); + auto context_factory = std::make_unique( +diff --git a/ui/compositor/test/context_factories_for_test.cc b/ui/compositor/test/context_factories_for_test.cc +index ece65c0bddc0..aa1eb1807135 100644 +--- a/ui/compositor/test/context_factories_for_test.cc ++++ b/ui/compositor/test/context_factories_for_test.cc +@@ -7,6 +7,7 @@ + #include "base/command_line.h" + #include "base/sys_info.h" + #include "components/viz/host/host_frame_sink_manager.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" + #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "ui/compositor/compositor.h" + #include "ui/compositor/compositor_switches.h" +@@ -16,6 +17,7 @@ + namespace { + + static viz::HostFrameSinkManager* g_host_frame_sink_manager = nullptr; ++static viz::ServerSharedBitmapManager* g_shared_bitmap_manager = nullptr; + static viz::FrameSinkManagerImpl* g_frame_sink_manager = nullptr; + static ui::InProcessContextFactory* g_implicit_factory = nullptr; + static gl::DisableNullDrawGLBindings* g_disable_null_draw = nullptr; +@@ -44,7 +46,8 @@ void InitializeContextFactoryForTests( + if (enable_pixel_output) + g_disable_null_draw = new gl::DisableNullDrawGLBindings; + g_host_frame_sink_manager = new viz::HostFrameSinkManager; +- g_frame_sink_manager = new viz::FrameSinkManagerImpl; ++ g_shared_bitmap_manager = new viz::ServerSharedBitmapManager; ++ g_frame_sink_manager = new viz::FrameSinkManagerImpl(g_shared_bitmap_manager); + g_implicit_factory = new InProcessContextFactory(g_host_frame_sink_manager, + g_frame_sink_manager); + g_implicit_factory->SetUseFastRefreshRateForTests(); +@@ -64,6 +67,8 @@ void TerminateContextFactoryForTests() { + g_host_frame_sink_manager = nullptr; + delete g_frame_sink_manager; + g_frame_sink_manager = nullptr; ++ delete g_shared_bitmap_manager; ++ g_shared_bitmap_manager = nullptr; + delete g_disable_null_draw; + g_disable_null_draw = nullptr; + } +diff --git a/ui/views/examples/BUILD.gn b/ui/views/examples/BUILD.gn +index 661329c2482e..aec5cf1466b3 100644 +--- a/ui/views/examples/BUILD.gn ++++ b/ui/views/examples/BUILD.gn +@@ -114,6 +114,7 @@ executable("views_examples_exe") { + "//build/config:exe_and_shlib_deps", + "//build/win:default_exe_manifest", + "//components/viz/host", ++ "//components/viz/service", + "//ui/base", + "//ui/compositor", + "//ui/compositor:test_support", +diff --git a/ui/views/examples/DEPS b/ui/views/examples/DEPS +index c55d1e8778f1..38ff08c5007e 100644 +--- a/ui/views/examples/DEPS ++++ b/ui/views/examples/DEPS +@@ -1,5 +1,6 @@ + include_rules = [ + "+components/viz/host", ++ "+components/viz/service", # In-process viz service. + "+content/public", + "+content/shell", + "+sandbox", +diff --git a/ui/views/examples/examples_main.cc b/ui/views/examples/examples_main.cc +index 9ddb537f8c52..4dd22a71197b 100644 +--- a/ui/views/examples/examples_main.cc ++++ b/ui/views/examples/examples_main.cc +@@ -17,6 +17,8 @@ + #include "base/test/test_discardable_memory_allocator.h" + #include "build/build_config.h" + #include "components/viz/host/host_frame_sink_manager.h" ++#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h" ++#include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" + #include "ui/base/ime/input_method_initializer.h" + #include "ui/base/material_design/material_design_controller.h" + #include "ui/base/resource/resource_bundle.h" +@@ -68,7 +70,8 @@ int main(int argc, char** argv) { + + // The ContextFactory must exist before any Compositors are created. + viz::HostFrameSinkManager host_frame_sink_manager; +- viz::FrameSinkManagerImpl frame_sink_manager; ++ viz::ServerSharedBitmapManager shared_bitmap_manager; ++ viz::FrameSinkManagerImpl frame_sink_manager(&shared_bitmap_manager); + host_frame_sink_manager.SetLocalManager(&frame_sink_manager); + frame_sink_manager.SetLocalClient(&host_frame_sink_manager); + auto context_factory = std::make_unique( diff --git a/patches/common/chromium/dcheck.patch b/patches/common/chromium/dcheck.patch index 9dad73f74ae0..8c7ef57bcf69 100644 --- a/patches/common/chromium/dcheck.patch +++ b/patches/common/chromium/dcheck.patch @@ -79,21 +79,6 @@ index 8b28c57f854e..a0e7056af23f 100644 return; } -diff --git a/components/viz/service/display_embedder/server_shared_bitmap_manager.cc b/components/viz/service/display_embedder/server_shared_bitmap_manager.cc -index 9d84f91109a3..5e252917bc0f 100644 ---- a/components/viz/service/display_embedder/server_shared_bitmap_manager.cc -+++ b/components/viz/service/display_embedder/server_shared_bitmap_manager.cc -@@ -63,7 +63,9 @@ base::LazyInstance::DestructorAtExit - ServerSharedBitmapManager::ServerSharedBitmapManager() = default; - - ServerSharedBitmapManager::~ServerSharedBitmapManager() { -- DCHECK(handle_map_.empty()); -+ // FIXME(alexeykuzmin): Gets constantly triggered on Windows CI. -+ // Backporting https://chromium-review.googlesource.com/802574 should help. -+ // DCHECK(handle_map_.empty()); - } - - ServerSharedBitmapManager* ServerSharedBitmapManager::current() { diff --git a/content/browser/frame_host/navigation_controller_impl.cc b/content/browser/frame_host/navigation_controller_impl.cc index 74ff6b4286c2..02bf1c55d86f 100644 --- a/content/browser/frame_host/navigation_controller_impl.cc