123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399 |
- // 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 "ui/compositor/test/in_process_context_factory.h"
- #include <limits>
- #include <utility>
- #include "base/bind.h"
- #include "base/callback.h"
- #include "base/callback_helpers.h"
- #include "base/command_line.h"
- #include "base/memory/ptr_util.h"
- #include "base/memory/raw_ptr.h"
- #include "base/threading/thread.h"
- #include "base/time/time.h"
- #include "build/build_config.h"
- #include "cc/base/switches.h"
- #include "components/viz/common/features.h"
- #include "components/viz/common/frame_sinks/begin_frame_args.h"
- #include "components/viz/common/frame_sinks/begin_frame_source.h"
- #include "components/viz/common/frame_sinks/delay_based_time_source.h"
- #include "components/viz/common/gpu/context_provider.h"
- #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
- #include "components/viz/host/host_frame_sink_manager.h"
- #include "components/viz/service/display/display.h"
- #include "components/viz/service/display/display_scheduler.h"
- #include "components/viz/service/display/output_surface_client.h"
- #include "components/viz/service/display/output_surface_frame.h"
- #include "components/viz/service/display/overlay_processor_stub.h"
- #include "components/viz/service/display_embedder/skia_output_surface_dependency_impl.h"
- #include "components/viz/service/display_embedder/skia_output_surface_impl.h"
- #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h"
- #include "components/viz/service/gl/gpu_service_impl.h"
- #include "components/viz/test/test_gpu_service_holder.h"
- #include "gpu/command_buffer/client/context_support.h"
- #include "gpu/command_buffer/client/gles2_interface.h"
- #include "gpu/command_buffer/common/context_creation_attribs.h"
- #include "services/viz/privileged/mojom/compositing/display_private.mojom.h"
- #include "ui/compositor/compositor_switches.h"
- #include "ui/compositor/layer.h"
- #include "ui/compositor/test/direct_layer_tree_frame_sink.h"
- #include "ui/compositor/test/in_process_context_provider.h"
- #include "ui/display/display_switches.h"
- #include "ui/gfx/buffer_format_util.h"
- #include "ui/gfx/presentation_feedback.h"
- #include "ui/gfx/switches.h"
- #include "ui/gl/gl_implementation.h"
- #include "ui/gl/test/gl_surface_test_support.h"
- #if BUILDFLAG(IS_APPLE)
- #include "ui/accelerated_widget_mac/ca_transaction_observer.h"
- #endif
- #if !defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW)
- #include "gpu/ipc/common/gpu_surface_tracker.h"
- #endif
- namespace ui {
- namespace {
- // This should not conflict with ids from RenderWidgetHostImpl or WindowService.
- constexpr uint32_t kDefaultClientId = std::numeric_limits<uint32_t>::max() / 2;
- } // namespace
- // TODO(rivr): This class is managed heavily by InProcessTransportFactory.
- // Move some of the logic in here and simplify the interface.
- class InProcessContextFactory::PerCompositorData
- : public viz::mojom::DisplayPrivate {
- public:
- // viz::mojom::DisplayPrivate implementation.
- void SetDisplayVisible(bool visible) override {
- display_->SetVisible(visible);
- }
- void Resize(const gfx::Size& size) override { display_->Resize(size); }
- #if BUILDFLAG(IS_WIN)
- bool DisableSwapUntilResize() override {
- display_->DisableSwapUntilResize(base::OnceClosure());
- return true;
- }
- void DisableSwapUntilResize(
- DisableSwapUntilResizeCallback callback) override {
- display_->DisableSwapUntilResize(std::move(callback));
- }
- #endif
- void SetDisplayColorMatrix(const gfx::Transform& matrix) override {
- output_color_matrix_ = matrix.GetMatrixAsSkM44();
- }
- void SetDisplayColorSpaces(
- const gfx::DisplayColorSpaces& color_spaces) override {
- display_color_spaces_ = color_spaces;
- }
- void SetDisplayVSyncParameters(base::TimeTicks timebase,
- base::TimeDelta interval) override {
- vsync_timebase_ = timebase;
- vsync_interval_ = interval;
- }
- void SetOutputIsSecure(bool secure) override {}
- void ForceImmediateDrawAndSwapIfPossible() override {}
- void AddVSyncParameterObserver(
- mojo::PendingRemote<viz::mojom::VSyncParameterObserver> observer)
- override {}
- #if BUILDFLAG(IS_ANDROID)
- void SetVSyncPaused(bool paused) override {}
- void UpdateRefreshRate(float refresh_rate) override {}
- void SetSupportedRefreshRates(
- const std::vector<float>& refresh_rates) override {}
- void PreserveChildSurfaceControls() override {}
- void SetSwapCompletionCallbackEnabled(bool enabled) override {}
- #endif
- void SetDelegatedInkPointRenderer(
- mojo::PendingReceiver<gfx::mojom::DelegatedInkPointRenderer> receiver)
- override {}
- void SetStandaloneBeginFrameObserver(
- mojo::PendingRemote<viz::mojom::BeginFrameObserver> observer) override {}
- void SetSurfaceHandle(gpu::SurfaceHandle surface_handle) {
- surface_handle_ = surface_handle;
- }
- void SetBeginFrameSource(
- std::unique_ptr<viz::BeginFrameSource> begin_frame_source) {
- begin_frame_source_ = std::move(begin_frame_source);
- }
- void SetDisplay(std::unique_ptr<viz::Display> display) {
- display_ = std::move(display);
- }
- void ResetDisplayOutputParameters() {
- output_color_matrix_ = SkM44();
- display_color_spaces_ = gfx::DisplayColorSpaces();
- vsync_timebase_ = base::TimeTicks();
- vsync_interval_ = base::TimeDelta();
- }
- gpu::SurfaceHandle surface_handle() { return surface_handle_; }
- viz::BeginFrameSource* begin_frame_source() {
- return begin_frame_source_.get();
- }
- viz::Display* display() { return display_.get(); }
- SkM44 output_color_matrix() { return output_color_matrix_; }
- gfx::DisplayColorSpaces display_color_spaces() {
- return display_color_spaces_;
- }
- base::TimeTicks vsync_timebase() { return vsync_timebase_; }
- base::TimeDelta vsync_interval() { return vsync_interval_; }
- private:
- gpu::SurfaceHandle surface_handle_ = gpu::kNullSurfaceHandle;
- std::unique_ptr<viz::BeginFrameSource> begin_frame_source_;
- std::unique_ptr<viz::Display> display_;
- SkM44 output_color_matrix_;
- gfx::DisplayColorSpaces display_color_spaces_;
- base::TimeTicks vsync_timebase_;
- base::TimeDelta vsync_interval_;
- };
- InProcessContextFactory::InProcessContextFactory(
- viz::HostFrameSinkManager* host_frame_sink_manager,
- viz::FrameSinkManagerImpl* frame_sink_manager,
- bool output_to_window)
- : frame_sink_id_allocator_(kDefaultClientId),
- output_to_window_(output_to_window),
- disable_vsync_(base::CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kDisableVsyncForTests)),
- host_frame_sink_manager_(host_frame_sink_manager),
- frame_sink_manager_(frame_sink_manager) {
- DCHECK(host_frame_sink_manager);
- DCHECK_NE(gl::GetGLImplementation(), gl::kGLImplementationNone)
- << "If running tests, ensure that main() is calling "
- << "gl::GLSurfaceTestSupport::InitializeOneOff()";
- #if BUILDFLAG(IS_APPLE)
- renderer_settings_.release_overlay_resources_after_gpu_query = true;
- // Ensure that tests don't wait for frames that will never come.
- ui::CATransactionCoordinator::Get().DisableForTesting();
- #endif
- }
- InProcessContextFactory::~InProcessContextFactory() {
- DCHECK(per_compositor_data_.empty());
- }
- void InProcessContextFactory::SetUseFastRefreshRateForTests() {
- refresh_rate_ = 200.0;
- }
- void InProcessContextFactory::CreateLayerTreeFrameSink(
- base::WeakPtr<Compositor> compositor) {
- // Try to reuse existing shared worker context provider.
- bool shared_worker_context_provider_lost = false;
- if (shared_worker_context_provider_) {
- // Note: If context is lost, delete reference after releasing the lock.
- base::AutoLock lock(*shared_worker_context_provider_->GetLock());
- if (shared_worker_context_provider_->RasterInterface()
- ->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
- shared_worker_context_provider_lost = true;
- }
- }
- if (!shared_worker_context_provider_ || shared_worker_context_provider_lost) {
- shared_worker_context_provider_ = InProcessContextProvider::CreateOffscreen(
- &gpu_memory_buffer_manager_, &image_factory_, /*is_worker=*/true);
- auto result = shared_worker_context_provider_->BindToCurrentThread();
- if (result != gpu::ContextResult::kSuccess)
- shared_worker_context_provider_ = nullptr;
- }
- PerCompositorData* data = per_compositor_data_[compositor.get()].get();
- if (!data)
- data = CreatePerCompositorData(compositor.get());
- auto skia_deps = std::make_unique<viz::SkiaOutputSurfaceDependencyImpl>(
- viz::TestGpuServiceHolder::GetInstance()->gpu_service(),
- output_to_window_ ? data->surface_handle() : gpu::kNullSurfaceHandle);
- auto display_dependency =
- std::make_unique<viz::DisplayCompositorMemoryAndTaskController>(
- std::move(skia_deps));
- std::unique_ptr<viz::OutputSurface> output_surface =
- viz::SkiaOutputSurfaceImpl::Create(display_dependency.get(),
- renderer_settings_, &debug_settings_);
- auto overlay_processor = std::make_unique<viz::OverlayProcessorStub>();
- std::unique_ptr<viz::BeginFrameSource> begin_frame_source;
- if (disable_vsync_) {
- begin_frame_source = std::make_unique<viz::BackToBackBeginFrameSource>(
- std::make_unique<viz::DelayBasedTimeSource>(
- compositor->task_runner().get()));
- } else {
- auto time_source = std::make_unique<viz::DelayBasedTimeSource>(
- compositor->task_runner().get());
- time_source->SetTimebaseAndInterval(
- base::TimeTicks(),
- base::Microseconds(base::Time::kMicrosecondsPerSecond / refresh_rate_));
- begin_frame_source = std::make_unique<viz::DelayBasedBeginFrameSource>(
- std::move(time_source), viz::BeginFrameSource::kNotRestartableId);
- }
- auto scheduler = std::make_unique<viz::DisplayScheduler>(
- begin_frame_source.get(), compositor->task_runner().get(),
- output_surface->capabilities().pending_swap_params,
- /*hint_session_factory=*/nullptr);
- data->SetDisplay(std::make_unique<viz::Display>(
- &shared_bitmap_manager_, renderer_settings_, &debug_settings_,
- compositor->frame_sink_id(), std::move(display_dependency),
- std::move(output_surface), std::move(overlay_processor),
- std::move(scheduler), compositor->task_runner()));
- frame_sink_manager_->RegisterBeginFrameSource(begin_frame_source.get(),
- compositor->frame_sink_id());
- // Note that we are careful not to destroy a prior |data->begin_frame_source|
- // until we have reset |data->display|.
- data->SetBeginFrameSource(std::move(begin_frame_source));
- auto layer_tree_frame_sink = std::make_unique<DirectLayerTreeFrameSink>(
- compositor->frame_sink_id(), frame_sink_manager_, data->display(),
- SharedMainThreadContextProvider(), shared_worker_context_provider_,
- compositor->task_runner(), &gpu_memory_buffer_manager_);
- compositor->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink), data);
- data->Resize(compositor->size());
- }
- scoped_refptr<viz::ContextProvider>
- InProcessContextFactory::SharedMainThreadContextProvider() {
- if (shared_main_thread_contexts_ &&
- shared_main_thread_contexts_->ContextGL()->GetGraphicsResetStatusKHR() ==
- GL_NO_ERROR)
- return shared_main_thread_contexts_;
- shared_main_thread_contexts_ = InProcessContextProvider::CreateOffscreen(
- &gpu_memory_buffer_manager_, &image_factory_, /*is_worker=*/false);
- auto result = shared_main_thread_contexts_->BindToCurrentThread();
- if (result != gpu::ContextResult::kSuccess)
- shared_main_thread_contexts_.reset();
- return shared_main_thread_contexts_;
- }
- scoped_refptr<viz::RasterContextProvider>
- InProcessContextFactory::SharedMainThreadRasterContextProvider() {
- SharedMainThreadContextProvider();
- DCHECK(!shared_main_thread_contexts_ ||
- shared_main_thread_contexts_->RasterInterface());
- return shared_main_thread_contexts_;
- }
- void InProcessContextFactory::RemoveCompositor(Compositor* compositor) {
- auto it = per_compositor_data_.find(compositor);
- if (it == per_compositor_data_.end())
- return;
- PerCompositorData* data = it->second.get();
- frame_sink_manager_->UnregisterBeginFrameSource(data->begin_frame_source());
- DCHECK(data);
- #if !defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW)
- if (data->surface_handle())
- gpu::GpuSurfaceTracker::Get()->RemoveSurface(data->surface_handle());
- #endif
- per_compositor_data_.erase(it);
- }
- gpu::GpuMemoryBufferManager*
- InProcessContextFactory::GetGpuMemoryBufferManager() {
- return &gpu_memory_buffer_manager_;
- }
- cc::TaskGraphRunner* InProcessContextFactory::GetTaskGraphRunner() {
- return &task_graph_runner_;
- }
- viz::FrameSinkId InProcessContextFactory::AllocateFrameSinkId() {
- return frame_sink_id_allocator_.NextFrameSinkId();
- }
- viz::SubtreeCaptureId InProcessContextFactory::AllocateSubtreeCaptureId() {
- return subtree_capture_id_allocator_.NextSubtreeCaptureId();
- }
- viz::HostFrameSinkManager* InProcessContextFactory::GetHostFrameSinkManager() {
- return host_frame_sink_manager_;
- }
- SkM44 InProcessContextFactory::GetOutputColorMatrix(
- Compositor* compositor) const {
- auto iter = per_compositor_data_.find(compositor);
- if (iter == per_compositor_data_.end())
- return SkM44();
- return iter->second->output_color_matrix();
- }
- gfx::DisplayColorSpaces InProcessContextFactory::GetDisplayColorSpaces(
- Compositor* compositor) const {
- auto iter = per_compositor_data_.find(compositor);
- if (iter == per_compositor_data_.end())
- return gfx::DisplayColorSpaces();
- return iter->second->display_color_spaces();
- }
- base::TimeTicks InProcessContextFactory::GetDisplayVSyncTimeBase(
- Compositor* compositor) const {
- auto iter = per_compositor_data_.find(compositor);
- if (iter == per_compositor_data_.end())
- return base::TimeTicks();
- return iter->second->vsync_timebase();
- }
- base::TimeDelta InProcessContextFactory::GetDisplayVSyncTimeInterval(
- Compositor* compositor) const {
- auto iter = per_compositor_data_.find(compositor);
- if (iter == per_compositor_data_.end())
- return viz::BeginFrameArgs::DefaultInterval();
- return iter->second->vsync_interval();
- }
- void InProcessContextFactory::ResetDisplayOutputParameters(
- Compositor* compositor) {
- auto iter = per_compositor_data_.find(compositor);
- if (iter == per_compositor_data_.end())
- return;
- iter->second->ResetDisplayOutputParameters();
- }
- InProcessContextFactory::PerCompositorData*
- InProcessContextFactory::CreatePerCompositorData(Compositor* compositor) {
- DCHECK(!per_compositor_data_[compositor]);
- gfx::AcceleratedWidget widget = compositor->widget();
- auto data = std::make_unique<PerCompositorData>();
- if (widget == gfx::kNullAcceleratedWidget) {
- data->SetSurfaceHandle(gpu::kNullSurfaceHandle);
- } else {
- #if defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW)
- data->SetSurfaceHandle(widget);
- #else
- gpu::GpuSurfaceTracker* tracker = gpu::GpuSurfaceTracker::Get();
- data->SetSurfaceHandle(tracker->AddSurfaceForNativeWidget(
- gpu::GpuSurfaceTracker::SurfaceRecord(
- widget
- #if BUILDFLAG(IS_ANDROID)
- // We have to provide a surface too, but we don't have one. For
- // now, we don't proide it, since nobody should ask anyway.
- // If we ever provide a valid surface here, then GpuSurfaceTracker
- // can be more strict about enforcing it.
- ,
- nullptr, false /* can_be_used_with_surface_control */
- #endif
- )));
- #endif
- }
- PerCompositorData* return_ptr = data.get();
- per_compositor_data_[compositor] = std::move(data);
- return return_ptr;
- }
- } // namespace ui
|