in_process_context_factory.cc 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ui/compositor/test/in_process_context_factory.h"
  5. #include <limits>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/callback.h"
  9. #include "base/callback_helpers.h"
  10. #include "base/command_line.h"
  11. #include "base/memory/ptr_util.h"
  12. #include "base/memory/raw_ptr.h"
  13. #include "base/threading/thread.h"
  14. #include "base/time/time.h"
  15. #include "build/build_config.h"
  16. #include "cc/base/switches.h"
  17. #include "components/viz/common/features.h"
  18. #include "components/viz/common/frame_sinks/begin_frame_args.h"
  19. #include "components/viz/common/frame_sinks/begin_frame_source.h"
  20. #include "components/viz/common/frame_sinks/delay_based_time_source.h"
  21. #include "components/viz/common/gpu/context_provider.h"
  22. #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
  23. #include "components/viz/host/host_frame_sink_manager.h"
  24. #include "components/viz/service/display/display.h"
  25. #include "components/viz/service/display/display_scheduler.h"
  26. #include "components/viz/service/display/output_surface_client.h"
  27. #include "components/viz/service/display/output_surface_frame.h"
  28. #include "components/viz/service/display/overlay_processor_stub.h"
  29. #include "components/viz/service/display_embedder/skia_output_surface_dependency_impl.h"
  30. #include "components/viz/service/display_embedder/skia_output_surface_impl.h"
  31. #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h"
  32. #include "components/viz/service/gl/gpu_service_impl.h"
  33. #include "components/viz/test/test_gpu_service_holder.h"
  34. #include "gpu/command_buffer/client/context_support.h"
  35. #include "gpu/command_buffer/client/gles2_interface.h"
  36. #include "gpu/command_buffer/common/context_creation_attribs.h"
  37. #include "services/viz/privileged/mojom/compositing/display_private.mojom.h"
  38. #include "ui/compositor/compositor_switches.h"
  39. #include "ui/compositor/layer.h"
  40. #include "ui/compositor/test/direct_layer_tree_frame_sink.h"
  41. #include "ui/compositor/test/in_process_context_provider.h"
  42. #include "ui/display/display_switches.h"
  43. #include "ui/gfx/buffer_format_util.h"
  44. #include "ui/gfx/presentation_feedback.h"
  45. #include "ui/gfx/switches.h"
  46. #include "ui/gl/gl_implementation.h"
  47. #include "ui/gl/test/gl_surface_test_support.h"
  48. #if BUILDFLAG(IS_APPLE)
  49. #include "ui/accelerated_widget_mac/ca_transaction_observer.h"
  50. #endif
  51. #if !defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW)
  52. #include "gpu/ipc/common/gpu_surface_tracker.h"
  53. #endif
  54. namespace ui {
  55. namespace {
  56. // This should not conflict with ids from RenderWidgetHostImpl or WindowService.
  57. constexpr uint32_t kDefaultClientId = std::numeric_limits<uint32_t>::max() / 2;
  58. } // namespace
  59. // TODO(rivr): This class is managed heavily by InProcessTransportFactory.
  60. // Move some of the logic in here and simplify the interface.
  61. class InProcessContextFactory::PerCompositorData
  62. : public viz::mojom::DisplayPrivate {
  63. public:
  64. // viz::mojom::DisplayPrivate implementation.
  65. void SetDisplayVisible(bool visible) override {
  66. display_->SetVisible(visible);
  67. }
  68. void Resize(const gfx::Size& size) override { display_->Resize(size); }
  69. #if BUILDFLAG(IS_WIN)
  70. bool DisableSwapUntilResize() override {
  71. display_->DisableSwapUntilResize(base::OnceClosure());
  72. return true;
  73. }
  74. void DisableSwapUntilResize(
  75. DisableSwapUntilResizeCallback callback) override {
  76. display_->DisableSwapUntilResize(std::move(callback));
  77. }
  78. #endif
  79. void SetDisplayColorMatrix(const gfx::Transform& matrix) override {
  80. output_color_matrix_ = matrix.GetMatrixAsSkM44();
  81. }
  82. void SetDisplayColorSpaces(
  83. const gfx::DisplayColorSpaces& color_spaces) override {
  84. display_color_spaces_ = color_spaces;
  85. }
  86. void SetDisplayVSyncParameters(base::TimeTicks timebase,
  87. base::TimeDelta interval) override {
  88. vsync_timebase_ = timebase;
  89. vsync_interval_ = interval;
  90. }
  91. void SetOutputIsSecure(bool secure) override {}
  92. void ForceImmediateDrawAndSwapIfPossible() override {}
  93. void AddVSyncParameterObserver(
  94. mojo::PendingRemote<viz::mojom::VSyncParameterObserver> observer)
  95. override {}
  96. #if BUILDFLAG(IS_ANDROID)
  97. void SetVSyncPaused(bool paused) override {}
  98. void UpdateRefreshRate(float refresh_rate) override {}
  99. void SetSupportedRefreshRates(
  100. const std::vector<float>& refresh_rates) override {}
  101. void PreserveChildSurfaceControls() override {}
  102. void SetSwapCompletionCallbackEnabled(bool enabled) override {}
  103. #endif
  104. void SetDelegatedInkPointRenderer(
  105. mojo::PendingReceiver<gfx::mojom::DelegatedInkPointRenderer> receiver)
  106. override {}
  107. void SetStandaloneBeginFrameObserver(
  108. mojo::PendingRemote<viz::mojom::BeginFrameObserver> observer) override {}
  109. void SetSurfaceHandle(gpu::SurfaceHandle surface_handle) {
  110. surface_handle_ = surface_handle;
  111. }
  112. void SetBeginFrameSource(
  113. std::unique_ptr<viz::BeginFrameSource> begin_frame_source) {
  114. begin_frame_source_ = std::move(begin_frame_source);
  115. }
  116. void SetDisplay(std::unique_ptr<viz::Display> display) {
  117. display_ = std::move(display);
  118. }
  119. void ResetDisplayOutputParameters() {
  120. output_color_matrix_ = SkM44();
  121. display_color_spaces_ = gfx::DisplayColorSpaces();
  122. vsync_timebase_ = base::TimeTicks();
  123. vsync_interval_ = base::TimeDelta();
  124. }
  125. gpu::SurfaceHandle surface_handle() { return surface_handle_; }
  126. viz::BeginFrameSource* begin_frame_source() {
  127. return begin_frame_source_.get();
  128. }
  129. viz::Display* display() { return display_.get(); }
  130. SkM44 output_color_matrix() { return output_color_matrix_; }
  131. gfx::DisplayColorSpaces display_color_spaces() {
  132. return display_color_spaces_;
  133. }
  134. base::TimeTicks vsync_timebase() { return vsync_timebase_; }
  135. base::TimeDelta vsync_interval() { return vsync_interval_; }
  136. private:
  137. gpu::SurfaceHandle surface_handle_ = gpu::kNullSurfaceHandle;
  138. std::unique_ptr<viz::BeginFrameSource> begin_frame_source_;
  139. std::unique_ptr<viz::Display> display_;
  140. SkM44 output_color_matrix_;
  141. gfx::DisplayColorSpaces display_color_spaces_;
  142. base::TimeTicks vsync_timebase_;
  143. base::TimeDelta vsync_interval_;
  144. };
  145. InProcessContextFactory::InProcessContextFactory(
  146. viz::HostFrameSinkManager* host_frame_sink_manager,
  147. viz::FrameSinkManagerImpl* frame_sink_manager,
  148. bool output_to_window)
  149. : frame_sink_id_allocator_(kDefaultClientId),
  150. output_to_window_(output_to_window),
  151. disable_vsync_(base::CommandLine::ForCurrentProcess()->HasSwitch(
  152. switches::kDisableVsyncForTests)),
  153. host_frame_sink_manager_(host_frame_sink_manager),
  154. frame_sink_manager_(frame_sink_manager) {
  155. DCHECK(host_frame_sink_manager);
  156. DCHECK_NE(gl::GetGLImplementation(), gl::kGLImplementationNone)
  157. << "If running tests, ensure that main() is calling "
  158. << "gl::GLSurfaceTestSupport::InitializeOneOff()";
  159. #if BUILDFLAG(IS_APPLE)
  160. renderer_settings_.release_overlay_resources_after_gpu_query = true;
  161. // Ensure that tests don't wait for frames that will never come.
  162. ui::CATransactionCoordinator::Get().DisableForTesting();
  163. #endif
  164. }
  165. InProcessContextFactory::~InProcessContextFactory() {
  166. DCHECK(per_compositor_data_.empty());
  167. }
  168. void InProcessContextFactory::SetUseFastRefreshRateForTests() {
  169. refresh_rate_ = 200.0;
  170. }
  171. void InProcessContextFactory::CreateLayerTreeFrameSink(
  172. base::WeakPtr<Compositor> compositor) {
  173. // Try to reuse existing shared worker context provider.
  174. bool shared_worker_context_provider_lost = false;
  175. if (shared_worker_context_provider_) {
  176. // Note: If context is lost, delete reference after releasing the lock.
  177. base::AutoLock lock(*shared_worker_context_provider_->GetLock());
  178. if (shared_worker_context_provider_->RasterInterface()
  179. ->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
  180. shared_worker_context_provider_lost = true;
  181. }
  182. }
  183. if (!shared_worker_context_provider_ || shared_worker_context_provider_lost) {
  184. shared_worker_context_provider_ = InProcessContextProvider::CreateOffscreen(
  185. &gpu_memory_buffer_manager_, &image_factory_, /*is_worker=*/true);
  186. auto result = shared_worker_context_provider_->BindToCurrentThread();
  187. if (result != gpu::ContextResult::kSuccess)
  188. shared_worker_context_provider_ = nullptr;
  189. }
  190. PerCompositorData* data = per_compositor_data_[compositor.get()].get();
  191. if (!data)
  192. data = CreatePerCompositorData(compositor.get());
  193. auto skia_deps = std::make_unique<viz::SkiaOutputSurfaceDependencyImpl>(
  194. viz::TestGpuServiceHolder::GetInstance()->gpu_service(),
  195. output_to_window_ ? data->surface_handle() : gpu::kNullSurfaceHandle);
  196. auto display_dependency =
  197. std::make_unique<viz::DisplayCompositorMemoryAndTaskController>(
  198. std::move(skia_deps));
  199. std::unique_ptr<viz::OutputSurface> output_surface =
  200. viz::SkiaOutputSurfaceImpl::Create(display_dependency.get(),
  201. renderer_settings_, &debug_settings_);
  202. auto overlay_processor = std::make_unique<viz::OverlayProcessorStub>();
  203. std::unique_ptr<viz::BeginFrameSource> begin_frame_source;
  204. if (disable_vsync_) {
  205. begin_frame_source = std::make_unique<viz::BackToBackBeginFrameSource>(
  206. std::make_unique<viz::DelayBasedTimeSource>(
  207. compositor->task_runner().get()));
  208. } else {
  209. auto time_source = std::make_unique<viz::DelayBasedTimeSource>(
  210. compositor->task_runner().get());
  211. time_source->SetTimebaseAndInterval(
  212. base::TimeTicks(),
  213. base::Microseconds(base::Time::kMicrosecondsPerSecond / refresh_rate_));
  214. begin_frame_source = std::make_unique<viz::DelayBasedBeginFrameSource>(
  215. std::move(time_source), viz::BeginFrameSource::kNotRestartableId);
  216. }
  217. auto scheduler = std::make_unique<viz::DisplayScheduler>(
  218. begin_frame_source.get(), compositor->task_runner().get(),
  219. output_surface->capabilities().pending_swap_params,
  220. /*hint_session_factory=*/nullptr);
  221. data->SetDisplay(std::make_unique<viz::Display>(
  222. &shared_bitmap_manager_, renderer_settings_, &debug_settings_,
  223. compositor->frame_sink_id(), std::move(display_dependency),
  224. std::move(output_surface), std::move(overlay_processor),
  225. std::move(scheduler), compositor->task_runner()));
  226. frame_sink_manager_->RegisterBeginFrameSource(begin_frame_source.get(),
  227. compositor->frame_sink_id());
  228. // Note that we are careful not to destroy a prior |data->begin_frame_source|
  229. // until we have reset |data->display|.
  230. data->SetBeginFrameSource(std::move(begin_frame_source));
  231. auto layer_tree_frame_sink = std::make_unique<DirectLayerTreeFrameSink>(
  232. compositor->frame_sink_id(), frame_sink_manager_, data->display(),
  233. SharedMainThreadContextProvider(), shared_worker_context_provider_,
  234. compositor->task_runner(), &gpu_memory_buffer_manager_);
  235. compositor->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink), data);
  236. data->Resize(compositor->size());
  237. }
  238. scoped_refptr<viz::ContextProvider>
  239. InProcessContextFactory::SharedMainThreadContextProvider() {
  240. if (shared_main_thread_contexts_ &&
  241. shared_main_thread_contexts_->ContextGL()->GetGraphicsResetStatusKHR() ==
  242. GL_NO_ERROR)
  243. return shared_main_thread_contexts_;
  244. shared_main_thread_contexts_ = InProcessContextProvider::CreateOffscreen(
  245. &gpu_memory_buffer_manager_, &image_factory_, /*is_worker=*/false);
  246. auto result = shared_main_thread_contexts_->BindToCurrentThread();
  247. if (result != gpu::ContextResult::kSuccess)
  248. shared_main_thread_contexts_.reset();
  249. return shared_main_thread_contexts_;
  250. }
  251. scoped_refptr<viz::RasterContextProvider>
  252. InProcessContextFactory::SharedMainThreadRasterContextProvider() {
  253. SharedMainThreadContextProvider();
  254. DCHECK(!shared_main_thread_contexts_ ||
  255. shared_main_thread_contexts_->RasterInterface());
  256. return shared_main_thread_contexts_;
  257. }
  258. void InProcessContextFactory::RemoveCompositor(Compositor* compositor) {
  259. auto it = per_compositor_data_.find(compositor);
  260. if (it == per_compositor_data_.end())
  261. return;
  262. PerCompositorData* data = it->second.get();
  263. frame_sink_manager_->UnregisterBeginFrameSource(data->begin_frame_source());
  264. DCHECK(data);
  265. #if !defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW)
  266. if (data->surface_handle())
  267. gpu::GpuSurfaceTracker::Get()->RemoveSurface(data->surface_handle());
  268. #endif
  269. per_compositor_data_.erase(it);
  270. }
  271. gpu::GpuMemoryBufferManager*
  272. InProcessContextFactory::GetGpuMemoryBufferManager() {
  273. return &gpu_memory_buffer_manager_;
  274. }
  275. cc::TaskGraphRunner* InProcessContextFactory::GetTaskGraphRunner() {
  276. return &task_graph_runner_;
  277. }
  278. viz::FrameSinkId InProcessContextFactory::AllocateFrameSinkId() {
  279. return frame_sink_id_allocator_.NextFrameSinkId();
  280. }
  281. viz::SubtreeCaptureId InProcessContextFactory::AllocateSubtreeCaptureId() {
  282. return subtree_capture_id_allocator_.NextSubtreeCaptureId();
  283. }
  284. viz::HostFrameSinkManager* InProcessContextFactory::GetHostFrameSinkManager() {
  285. return host_frame_sink_manager_;
  286. }
  287. SkM44 InProcessContextFactory::GetOutputColorMatrix(
  288. Compositor* compositor) const {
  289. auto iter = per_compositor_data_.find(compositor);
  290. if (iter == per_compositor_data_.end())
  291. return SkM44();
  292. return iter->second->output_color_matrix();
  293. }
  294. gfx::DisplayColorSpaces InProcessContextFactory::GetDisplayColorSpaces(
  295. Compositor* compositor) const {
  296. auto iter = per_compositor_data_.find(compositor);
  297. if (iter == per_compositor_data_.end())
  298. return gfx::DisplayColorSpaces();
  299. return iter->second->display_color_spaces();
  300. }
  301. base::TimeTicks InProcessContextFactory::GetDisplayVSyncTimeBase(
  302. Compositor* compositor) const {
  303. auto iter = per_compositor_data_.find(compositor);
  304. if (iter == per_compositor_data_.end())
  305. return base::TimeTicks();
  306. return iter->second->vsync_timebase();
  307. }
  308. base::TimeDelta InProcessContextFactory::GetDisplayVSyncTimeInterval(
  309. Compositor* compositor) const {
  310. auto iter = per_compositor_data_.find(compositor);
  311. if (iter == per_compositor_data_.end())
  312. return viz::BeginFrameArgs::DefaultInterval();
  313. return iter->second->vsync_interval();
  314. }
  315. void InProcessContextFactory::ResetDisplayOutputParameters(
  316. Compositor* compositor) {
  317. auto iter = per_compositor_data_.find(compositor);
  318. if (iter == per_compositor_data_.end())
  319. return;
  320. iter->second->ResetDisplayOutputParameters();
  321. }
  322. InProcessContextFactory::PerCompositorData*
  323. InProcessContextFactory::CreatePerCompositorData(Compositor* compositor) {
  324. DCHECK(!per_compositor_data_[compositor]);
  325. gfx::AcceleratedWidget widget = compositor->widget();
  326. auto data = std::make_unique<PerCompositorData>();
  327. if (widget == gfx::kNullAcceleratedWidget) {
  328. data->SetSurfaceHandle(gpu::kNullSurfaceHandle);
  329. } else {
  330. #if defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW)
  331. data->SetSurfaceHandle(widget);
  332. #else
  333. gpu::GpuSurfaceTracker* tracker = gpu::GpuSurfaceTracker::Get();
  334. data->SetSurfaceHandle(tracker->AddSurfaceForNativeWidget(
  335. gpu::GpuSurfaceTracker::SurfaceRecord(
  336. widget
  337. #if BUILDFLAG(IS_ANDROID)
  338. // We have to provide a surface too, but we don't have one. For
  339. // now, we don't proide it, since nobody should ask anyway.
  340. // If we ever provide a valid surface here, then GpuSurfaceTracker
  341. // can be more strict about enforcing it.
  342. ,
  343. nullptr, false /* can_be_used_with_surface_control */
  344. #endif
  345. )));
  346. #endif
  347. }
  348. PerCompositorData* return_ptr = data.get();
  349. per_compositor_data_[compositor] = std::move(data);
  350. return return_ptr;
  351. }
  352. } // namespace ui