hardware_renderer_viz.cc 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529
  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 "android_webview/browser/gfx/hardware_renderer_viz.h"
  5. #include <algorithm>
  6. #include <iterator>
  7. #include <memory>
  8. #include <utility>
  9. #include "android_webview/browser/gfx/aw_gl_surface.h"
  10. #include "android_webview/browser/gfx/display_scheduler_webview.h"
  11. #include "android_webview/browser/gfx/display_webview.h"
  12. #include "android_webview/browser/gfx/gpu_service_webview.h"
  13. #include "android_webview/browser/gfx/overlay_processor_webview.h"
  14. #include "android_webview/browser/gfx/parent_compositor_draw_constraints.h"
  15. #include "android_webview/browser/gfx/render_thread_manager.h"
  16. #include "android_webview/browser/gfx/root_frame_sink.h"
  17. #include "android_webview/browser/gfx/skia_output_surface_dependency_webview.h"
  18. #include "android_webview/browser/gfx/task_queue_webview.h"
  19. #include "android_webview/browser/gfx/viz_compositor_thread_runner_webview.h"
  20. #include "android_webview/common/aw_switches.h"
  21. #include "base/command_line.h"
  22. #include "base/logging.h"
  23. #include "base/memory/raw_ptr.h"
  24. #include "base/notreached.h"
  25. #include "base/trace_event/trace_event.h"
  26. #include "components/viz/common/display/renderer_settings.h"
  27. #include "components/viz/common/features.h"
  28. #include "components/viz/common/frame_sinks/begin_frame_source.h"
  29. #include "components/viz/common/frame_timing_details_map.h"
  30. #include "components/viz/common/quads/compositor_frame.h"
  31. #include "components/viz/common/quads/solid_color_draw_quad.h"
  32. #include "components/viz/common/quads/surface_draw_quad.h"
  33. #include "components/viz/common/surfaces/local_surface_id.h"
  34. #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
  35. #include "components/viz/service/display/display_client.h"
  36. #include "components/viz/service/display/display_scheduler.h"
  37. #include "components/viz/service/display/overlay_processor_stub.h"
  38. #include "components/viz/service/display_embedder/skia_output_surface_dependency.h"
  39. #include "components/viz/service/display_embedder/skia_output_surface_impl.h"
  40. #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h"
  41. #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h"
  42. #include "gpu/config/gpu_finch_features.h"
  43. #include "ui/gfx/geometry/transform.h"
  44. #include "ui/gl/gl_context.h"
  45. #include "ui/gl/gl_share_group.h"
  46. #include "ui/gl/gl_surface_egl.h"
  47. #include "ui/gl/init/gl_factory.h"
  48. namespace android_webview {
  49. namespace {
  50. class ContextReleaser {
  51. public:
  52. explicit ContextReleaser(gpu::SharedContextState* state) : state_(state) {}
  53. ~ContextReleaser() { state_->ReleaseCurrent(nullptr); }
  54. private:
  55. const raw_ptr<gpu::SharedContextState> state_;
  56. };
  57. } // namespace
  58. class HardwareRendererViz::OnViz : public viz::DisplayClient {
  59. public:
  60. OnViz(OutputSurfaceProviderWebView* output_surface_provider,
  61. const scoped_refptr<RootFrameSink>& root_frame_sink);
  62. OnViz(const OnViz&) = delete;
  63. OnViz& operator=(const OnViz&) = delete;
  64. ~OnViz() override;
  65. void DrawAndSwapOnViz(const gfx::Size& viewport,
  66. const gfx::Rect& clip,
  67. const gfx::Transform& transform,
  68. const viz::SurfaceId& child_id,
  69. float device_scale_factor,
  70. const gfx::ColorSpace& color_space,
  71. bool overlays_enabled_by_hwui,
  72. ChildFrame* child_frame);
  73. void PostDrawOnViz(viz::FrameTimingDetailsMap* timing_details);
  74. void RemoveOverlaysOnViz();
  75. void MarkExpectContextLossOnViz();
  76. OverlayProcessorWebView* overlay_processor() {
  77. return overlay_processor_webview_;
  78. }
  79. // viz::DisplayClient overrides.
  80. void DisplayOutputSurfaceLost() override;
  81. void DisplayWillDrawAndSwap(
  82. bool will_draw_and_swap,
  83. viz::AggregatedRenderPassList* render_passes) override;
  84. void DisplayDidDrawAndSwap() override {}
  85. void DisplayDidReceiveCALayerParams(
  86. const gfx::CALayerParams& ca_layer_params) override {}
  87. void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) override {}
  88. void SetWideColorEnabled(bool enabled) override {}
  89. void SetPreferredFrameInterval(base::TimeDelta interval) override {}
  90. base::TimeDelta GetPreferredFrameIntervalForFrameSinkId(
  91. const viz::FrameSinkId& id,
  92. viz::mojom::CompositorFrameSinkType* type) override;
  93. private:
  94. viz::FrameSinkManagerImpl* GetFrameSinkManager();
  95. scoped_refptr<RootFrameSink> without_gpu_;
  96. const viz::FrameSinkId frame_sink_id_;
  97. viz::LocalSurfaceId root_local_surface_id_;
  98. std::unique_ptr<viz::BeginFrameSource> stub_begin_frame_source_;
  99. std::unique_ptr<DisplayWebView> display_;
  100. std::unique_ptr<viz::HitTestAggregator> hit_test_aggregator_;
  101. viz::SurfaceId child_surface_id_;
  102. const bool viz_frame_submission_;
  103. const bool use_new_invalidate_heuristic_;
  104. bool expect_context_loss_ = false;
  105. // Initialized in ctor and never changes, so it's safe to access from both
  106. // threads. Can be null, if overlays are disabled.
  107. raw_ptr<OverlayProcessorWebView> overlay_processor_webview_ = nullptr;
  108. THREAD_CHECKER(viz_thread_checker_);
  109. };
  110. HardwareRendererViz::OnViz::OnViz(
  111. OutputSurfaceProviderWebView* output_surface_provider,
  112. const scoped_refptr<RootFrameSink>& root_frame_sink)
  113. : without_gpu_(root_frame_sink),
  114. frame_sink_id_(without_gpu_->root_frame_sink_id()),
  115. viz_frame_submission_(features::IsUsingVizFrameSubmissionForWebView()),
  116. use_new_invalidate_heuristic_(base::FeatureList::IsEnabled(
  117. features::kWebViewNewInvalidateHeuristic)) {
  118. DCHECK_CALLED_ON_VALID_THREAD(viz_thread_checker_);
  119. std::unique_ptr<viz::DisplayCompositorMemoryAndTaskController>
  120. display_controller = output_surface_provider->CreateDisplayController();
  121. std::unique_ptr<viz::OutputSurface> output_surface =
  122. output_surface_provider->CreateOutputSurface(display_controller.get());
  123. stub_begin_frame_source_ = std::make_unique<viz::StubBeginFrameSource>();
  124. display_ = DisplayWebView::Create(
  125. output_surface_provider->renderer_settings(),
  126. output_surface_provider->debug_settings(), frame_sink_id_,
  127. std::move(display_controller), std::move(output_surface),
  128. GetFrameSinkManager(), without_gpu_.get());
  129. display_->Initialize(this, GetFrameSinkManager()->surface_manager(), true);
  130. overlay_processor_webview_ = display_->overlay_processor();
  131. display_->SetVisible(true);
  132. display_->DisableGPUAccessByDefault();
  133. }
  134. HardwareRendererViz::OnViz::~OnViz() {
  135. DCHECK_CALLED_ON_VALID_THREAD(viz_thread_checker_);
  136. if (child_surface_id_.is_valid())
  137. without_gpu_->EvictChildSurface(child_surface_id_);
  138. if (root_local_surface_id_.is_valid())
  139. without_gpu_->EvictRootSurface(root_local_surface_id_);
  140. GetFrameSinkManager()->surface_manager()->GarbageCollectSurfaces();
  141. }
  142. void HardwareRendererViz::OnViz::DrawAndSwapOnViz(
  143. const gfx::Size& viewport,
  144. const gfx::Rect& clip,
  145. const gfx::Transform& transform,
  146. const viz::SurfaceId& child_id,
  147. float device_scale_factor,
  148. const gfx::ColorSpace& color_space,
  149. bool overlays_enabled_by_hwui,
  150. ChildFrame* child_frame) {
  151. TRACE_EVENT1("android_webview", "HardwareRendererViz::DrawAndSwap",
  152. "child_id", child_id.ToString());
  153. DCHECK_CALLED_ON_VALID_THREAD(viz_thread_checker_);
  154. DCHECK(child_id.is_valid());
  155. DCHECK(child_frame);
  156. if (child_frame->frame) {
  157. DCHECK(!viz_frame_submission_);
  158. without_gpu_->SubmitChildCompositorFrame(child_frame);
  159. }
  160. gfx::Size frame_size = without_gpu_->GetChildFrameSize();
  161. if (!child_frame->copy_requests.empty()) {
  162. viz::FrameSinkManagerImpl* manager = GetFrameSinkManager();
  163. CopyOutputRequestQueue requests;
  164. requests.swap(child_frame->copy_requests);
  165. for (auto& copy_request : requests) {
  166. manager->RequestCopyOfOutput(child_id, std::move(copy_request));
  167. }
  168. }
  169. if (overlay_processor_webview_) {
  170. overlay_processor_webview_->SetOverlaysEnabledByHWUI(
  171. overlays_enabled_by_hwui);
  172. }
  173. gfx::DisplayColorSpaces display_color_spaces(
  174. color_space.IsValid() ? color_space : gfx::ColorSpace::CreateSRGB());
  175. display_->SetDisplayColorSpaces(display_color_spaces);
  176. // Create a frame with a single SurfaceDrawQuad referencing the child
  177. // Surface and transformed using the given transform.
  178. auto render_pass = viz::CompositorRenderPass::Create();
  179. render_pass->SetNew(viz::CompositorRenderPassId{1}, gfx::Rect(viewport), clip,
  180. gfx::Transform());
  181. render_pass->has_transparent_background = false;
  182. viz::SharedQuadState* quad_state =
  183. render_pass->CreateAndAppendSharedQuadState();
  184. quad_state->quad_to_target_transform = transform;
  185. quad_state->quad_layer_rect = gfx::Rect(frame_size);
  186. quad_state->visible_quad_layer_rect = gfx::Rect(frame_size);
  187. quad_state->clip_rect = clip;
  188. quad_state->opacity = 1.f;
  189. viz::SurfaceDrawQuad* surface_quad =
  190. render_pass->CreateAndAppendDrawQuad<viz::SurfaceDrawQuad>();
  191. surface_quad->SetNew(quad_state, gfx::Rect(quad_state->quad_layer_rect),
  192. gfx::Rect(quad_state->quad_layer_rect),
  193. viz::SurfaceRange(absl::nullopt, child_id),
  194. SkColors::kWhite,
  195. /*stretch_content_to_fill_bounds=*/false);
  196. viz::CompositorFrame frame;
  197. // We draw synchronously, so acknowledge a manual BeginFrame.
  198. frame.metadata.begin_frame_ack =
  199. viz::BeginFrameAck::CreateManualAckWithDamage();
  200. frame.render_pass_list.push_back(std::move(render_pass));
  201. frame.metadata.device_scale_factor = device_scale_factor;
  202. if (child_surface_id_ != child_id) {
  203. if (child_surface_id_.frame_sink_id() != child_id.frame_sink_id()) {
  204. hit_test_aggregator_ = std::make_unique<viz::HitTestAggregator>(
  205. GetFrameSinkManager()->hit_test_manager(), GetFrameSinkManager(),
  206. display_.get(), child_id.frame_sink_id());
  207. }
  208. child_surface_id_ = child_id;
  209. GetFrameSinkManager()->surface_manager()->GarbageCollectSurfaces();
  210. }
  211. {
  212. std::vector<viz::SurfaceRange> child_ranges;
  213. child_ranges.emplace_back(child_surface_id_);
  214. frame.metadata.referenced_surfaces = std::move(child_ranges);
  215. }
  216. const auto& local_surface_id =
  217. without_gpu_->SubmitRootCompositorFrame(std::move(frame));
  218. if (use_new_invalidate_heuristic_) {
  219. auto root_surface_id =
  220. viz::SurfaceId(without_gpu_->root_frame_sink_id(), local_surface_id);
  221. auto commit_predicate = base::BindRepeating(
  222. [](const viz::BeginFrameId& current_frame_id,
  223. const viz::FrameSinkId& root_frame_sink_id,
  224. const viz::FrameSinkId& child_frame_sink_id,
  225. const viz::SurfaceId& surface_id,
  226. const viz::BeginFrameId& frame_id) {
  227. // Always commit frame from different begin frame sources, because we
  228. // can't order with them.
  229. if (frame_id.source_id != current_frame_id.source_id) {
  230. // We always should have single source_id except for the manual
  231. // acks.
  232. DCHECK_EQ(frame_id.source_id, viz::BeginFrameArgs::kManualSourceId);
  233. return true;
  234. }
  235. // Commit all frames that are older than current one.
  236. if (frame_id.sequence_number < current_frame_id.sequence_number)
  237. return true;
  238. // All clients except root renderer and root surface are frame behind.
  239. const bool is_frame_behind =
  240. surface_id.frame_sink_id() != root_frame_sink_id &&
  241. surface_id.frame_sink_id() != child_frame_sink_id;
  242. // If this surface is not frame behind, commit it for current frame
  243. // too.
  244. if (!is_frame_behind &&
  245. frame_id.sequence_number == current_frame_id.sequence_number)
  246. return true;
  247. return false;
  248. },
  249. child_frame->begin_frame_args.frame_id, root_surface_id.frame_sink_id(),
  250. child_surface_id_.frame_sink_id());
  251. GetFrameSinkManager()->surface_manager()->CommitFramesInRangeRecursively(
  252. viz::SurfaceRange(root_surface_id), commit_predicate);
  253. }
  254. if (root_local_surface_id_ != local_surface_id) {
  255. root_local_surface_id_ = local_surface_id;
  256. display_->SetLocalSurfaceId(local_surface_id, device_scale_factor);
  257. }
  258. display_->Resize(viewport);
  259. auto now = base::TimeTicks::Now();
  260. display_->DrawAndSwap({now, now});
  261. without_gpu_->SetContainedSurfaces(display_->GetContainedSurfaceIds());
  262. }
  263. void HardwareRendererViz::OnViz::PostDrawOnViz(
  264. viz::FrameTimingDetailsMap* timing_details) {
  265. *timing_details = without_gpu_->TakeChildFrameTimingDetailsMap();
  266. }
  267. void HardwareRendererViz::OnViz::RemoveOverlaysOnViz() {
  268. if (overlay_processor_webview_)
  269. overlay_processor_webview_->RemoveOverlays();
  270. }
  271. void HardwareRendererViz::OnViz::MarkExpectContextLossOnViz() {
  272. DCHECK_CALLED_ON_VALID_THREAD(viz_thread_checker_);
  273. expect_context_loss_ = true;
  274. }
  275. viz::FrameSinkManagerImpl* HardwareRendererViz::OnViz::GetFrameSinkManager() {
  276. DCHECK_CALLED_ON_VALID_THREAD(viz_thread_checker_);
  277. return VizCompositorThreadRunnerWebView::GetInstance()->GetFrameSinkManager();
  278. }
  279. void HardwareRendererViz::OnViz::DisplayOutputSurfaceLost() {
  280. DCHECK_CALLED_ON_VALID_THREAD(viz_thread_checker_);
  281. if (!expect_context_loss_) {
  282. // Android WebView does not handle real context loss.
  283. LOG(FATAL) << "Render thread context loss";
  284. }
  285. }
  286. void HardwareRendererViz::OnViz::DisplayWillDrawAndSwap(
  287. bool will_draw_and_swap,
  288. viz::AggregatedRenderPassList* render_passes) {
  289. DCHECK_CALLED_ON_VALID_THREAD(viz_thread_checker_);
  290. hit_test_aggregator_->Aggregate(child_surface_id_);
  291. }
  292. base::TimeDelta
  293. HardwareRendererViz::OnViz::GetPreferredFrameIntervalForFrameSinkId(
  294. const viz::FrameSinkId& id,
  295. viz::mojom::CompositorFrameSinkType* type) {
  296. DCHECK_CALLED_ON_VALID_THREAD(viz_thread_checker_);
  297. return GetFrameSinkManager()->GetPreferredFrameIntervalForFrameSinkId(id,
  298. type);
  299. }
  300. HardwareRendererViz::HardwareRendererViz(
  301. RenderThreadManager* state,
  302. RootFrameSinkGetter root_frame_sink_getter,
  303. AwVulkanContextProvider* context_provider)
  304. : HardwareRenderer(state), output_surface_provider_(context_provider) {
  305. DCHECK_CALLED_ON_VALID_THREAD(render_thread_checker_);
  306. VizCompositorThreadRunnerWebView::GetInstance()->ScheduleOnVizAndBlock(
  307. base::BindOnce(&HardwareRendererViz::InitializeOnViz,
  308. base::Unretained(this),
  309. std::move(root_frame_sink_getter)));
  310. }
  311. void HardwareRendererViz::InitializeOnViz(
  312. RootFrameSinkGetter root_frame_sink_getter) {
  313. scoped_refptr<RootFrameSink> root_frame_sink =
  314. std::move(root_frame_sink_getter).Run();
  315. if (root_frame_sink) {
  316. on_viz_ = std::make_unique<OnViz>(&output_surface_provider_,
  317. std::move(root_frame_sink));
  318. }
  319. }
  320. HardwareRendererViz::~HardwareRendererViz() {
  321. DCHECK_CALLED_ON_VALID_THREAD(render_thread_checker_);
  322. output_surface_provider_.shared_context_state()->MakeCurrent(nullptr);
  323. VizCompositorThreadRunnerWebView::GetInstance()->ScheduleOnVizAndBlock(
  324. base::BindOnce([](std::unique_ptr<OnViz>) {}, std::move(on_viz_)));
  325. }
  326. bool HardwareRendererViz::IsUsingVulkan() const {
  327. DCHECK_CALLED_ON_VALID_THREAD(render_thread_checker_);
  328. DCHECK(output_surface_provider_.shared_context_state());
  329. return output_surface_provider_.shared_context_state()->GrContextIsVulkan();
  330. }
  331. void HardwareRendererViz::DrawAndSwap(const HardwareRendererDrawParams& params,
  332. const OverlaysParams& overlays_params) {
  333. TRACE_EVENT1("android_webview", "HardwareRendererViz::Draw", "vulkan",
  334. IsUsingVulkan());
  335. DCHECK_CALLED_ON_VALID_THREAD(render_thread_checker_);
  336. // Release the context before returning, it is required for the external ANGLE
  337. // context. For non-ANGLE case, fake context and surface are used, so
  338. // releasing current context should be very cheap.
  339. ContextReleaser context_releaser(
  340. output_surface_provider_.shared_context_state().get());
  341. viz::FrameTimingDetailsMap timing_details;
  342. gfx::Transform transform(gfx::Transform::kSkipInitialization);
  343. transform.matrix().setColMajor(params.transform);
  344. transform.Translate(scroll_offset_.x(), scroll_offset_.y());
  345. gfx::Size viewport(params.width, params.height);
  346. // Need to post the new transform matrix back to child compositor
  347. // because there is no onDraw during a Render Thread animation, and child
  348. // compositor might not have the tiles rasterized as the animation goes on.
  349. ParentCompositorDrawConstraints draw_constraints =
  350. ParentCompositorDrawConstraints(viewport, transform);
  351. bool need_to_update_draw_constraints =
  352. !child_frame_.get() || draw_constraints.NeedUpdate(*child_frame_);
  353. if (child_frame_) {
  354. viz::SurfaceId child_surface_id = child_frame_->GetSurfaceId();
  355. if (child_surface_id.is_valid() && child_surface_id != surface_id_) {
  356. surface_id_ = child_surface_id;
  357. device_scale_factor_ = child_frame_->device_scale_factor;
  358. }
  359. }
  360. if (!surface_id_.is_valid()) {
  361. if (need_to_update_draw_constraints) {
  362. // FrameSinkId is used only for FrameTimingDetails and we want to update
  363. // only draw constraints here.
  364. // TODO(vasilyt): Move frame timing details delivery over to
  365. // RootFrameSink.
  366. render_thread_manager_->PostParentDrawDataToChildCompositorOnRT(
  367. draw_constraints, viz::FrameSinkId(), viz::FrameTimingDetailsMap(),
  368. 0);
  369. }
  370. return;
  371. }
  372. gfx::Rect clip(params.clip_left, params.clip_top,
  373. params.clip_right - params.clip_left,
  374. params.clip_bottom - params.clip_top);
  375. output_surface_provider_.gl_surface()->RecalculateClipAndTransform(
  376. &viewport, &clip, &transform);
  377. // ANGLE will restore GL context state for us, so we don't need to call
  378. // GrContext::resetContext().
  379. if (!gl::GLSurfaceEGL::GetGLDisplayEGL()
  380. ->IsANGLEExternalContextAndSurfaceSupported()) {
  381. DCHECK(output_surface_provider_.shared_context_state());
  382. output_surface_provider_.shared_context_state()
  383. ->PessimisticallyResetGrContext();
  384. }
  385. absl::optional<OverlayProcessorWebView::ScopedSurfaceControlAvailable>
  386. allow_surface_control;
  387. auto* overlay_processor = on_viz_->overlay_processor();
  388. const bool can_use_overlays =
  389. overlays_params.overlays_mode == OverlaysParams::Mode::Enabled &&
  390. !output_surface_provider_.gl_surface()->IsDrawingToFBO();
  391. if (can_use_overlays && overlay_processor) {
  392. DCHECK(overlays_params.get_surface_control);
  393. allow_surface_control.emplace(overlay_processor,
  394. overlays_params.get_surface_control);
  395. }
  396. VizCompositorThreadRunnerWebView::GetInstance()->ScheduleOnVizAndBlock(
  397. base::BindOnce(&HardwareRendererViz::OnViz::DrawAndSwapOnViz,
  398. base::Unretained(on_viz_.get()), viewport, clip, transform,
  399. surface_id_, device_scale_factor_, params.color_space,
  400. can_use_overlays, child_frame_.get()));
  401. MergeTransactionIfNeeded(overlays_params.merge_transaction);
  402. output_surface_provider_.gl_surface()->MaybeDidPresent(
  403. gfx::PresentationFeedback(base::TimeTicks::Now(), base::TimeDelta(),
  404. 0 /* flags */));
  405. // Implement proper damage tracking, then deliver FrameTimingDetails
  406. // through the common begin frame path.
  407. VizCompositorThreadRunnerWebView::GetInstance()->ScheduleOnVizAndBlock(
  408. base::BindOnce(&HardwareRendererViz::OnViz::PostDrawOnViz,
  409. base::Unretained(on_viz_.get()), &timing_details));
  410. if (need_to_update_draw_constraints || !timing_details.empty()) {
  411. // |frame_token| will be reported through the FrameSinkManager so we pass 0
  412. // here.
  413. render_thread_manager_->PostParentDrawDataToChildCompositorOnRT(
  414. draw_constraints, child_frame_->frame_sink_id,
  415. std::move(timing_details), 0);
  416. }
  417. }
  418. void HardwareRendererViz::RemoveOverlays(
  419. OverlaysParams::MergeTransactionFn merge_transaction) {
  420. VizCompositorThreadRunnerWebView::GetInstance()->ScheduleOnVizAndBlock(
  421. base::BindOnce(&HardwareRendererViz::OnViz::RemoveOverlaysOnViz,
  422. base::Unretained(on_viz_.get())));
  423. MergeTransactionIfNeeded(merge_transaction);
  424. }
  425. void HardwareRendererViz::MergeTransactionIfNeeded(
  426. OverlaysParams::MergeTransactionFn merge_transaction) {
  427. auto* overlay_processor = on_viz_->overlay_processor();
  428. if (overlay_processor) {
  429. auto transaction = overlay_processor->TakeSurfaceTransactionOnRT();
  430. if (transaction) {
  431. DCHECK(merge_transaction);
  432. merge_transaction(transaction->GetTransaction());
  433. }
  434. }
  435. }
  436. void HardwareRendererViz::AbandonContext() {
  437. VizCompositorThreadRunnerWebView::GetInstance()->task_runner()->PostTask(
  438. FROM_HERE,
  439. base::BindOnce(&HardwareRendererViz::OnViz::MarkExpectContextLossOnViz,
  440. base::Unretained(on_viz_.get())));
  441. output_surface_provider_.MarkExpectContextLoss();
  442. output_surface_provider_.shared_context_state()->MarkContextLost(
  443. gpu::error::ContextLostReason::kUnknown);
  444. }
  445. } // namespace android_webview