1 // Copyright 2019 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 5 #ifndef COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_DEVICE_BUFFER_QUEUE_H_ 6 #define COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_DEVICE_BUFFER_QUEUE_H_ 7 8 #include "base/cancelable_callback.h" 9 #include "base/macros.h" 10 #include "components/viz/service/display_embedder/skia_output_device.h" 11 #include "components/viz/service/viz_service_export.h" 12 #include "gpu/command_buffer/service/shared_image_factory.h" 13 14 namespace gl { 15 class GLSurface; 16 } // namespace gl 17 18 namespace viz { 19 20 class SkiaOutputSurfaceDependency; 21 22 class VIZ_SERVICE_EXPORT SkiaOutputDeviceBufferQueue final 23 : public SkiaOutputDevice { 24 public: 25 SkiaOutputDeviceBufferQueue( 26 scoped_refptr<gl::GLSurface> gl_surface, 27 SkiaOutputSurfaceDependency* deps, 28 gpu::MemoryTracker* memory_tracker, 29 const DidSwapBufferCompleteCallback& did_swap_buffer_complete_callback); 30 SkiaOutputDeviceBufferQueue( 31 scoped_refptr<gl::GLSurface> gl_surface, 32 SkiaOutputSurfaceDependency* deps, 33 gpu::MemoryTracker* memory_tracker, 34 const DidSwapBufferCompleteCallback& did_swap_buffer_complete_callback, 35 uint32_t shared_image_usage); 36 ~SkiaOutputDeviceBufferQueue() override; 37 38 static std::unique_ptr<SkiaOutputDeviceBufferQueue> Create( 39 SkiaOutputSurfaceDependency* deps, 40 gpu::MemoryTracker* memory_tracker, 41 const DidSwapBufferCompleteCallback& did_swap_buffer_complete_callback); 42 43 void SwapBuffers(BufferPresentedCallback feedback, 44 std::vector<ui::LatencyInfo> latency_info) override; 45 void PostSubBuffer(const gfx::Rect& rect, 46 BufferPresentedCallback feedback, 47 std::vector<ui::LatencyInfo> latency_info) override; 48 void CommitOverlayPlanes(BufferPresentedCallback feedback, 49 std::vector<ui::LatencyInfo> latency_info) override; 50 bool Reshape(const gfx::Size& size, 51 float device_scale_factor, 52 const gfx::ColorSpace& color_space, 53 gfx::BufferFormat format, 54 gfx::OverlayTransform transform) override; 55 SkSurface* BeginPaint( 56 std::vector<GrBackendSemaphore>* end_semaphores) override; 57 void EndPaint() override; supports_alpha()58 bool supports_alpha() { return true; } 59 60 bool IsPrimaryPlaneOverlay() const override; 61 void SchedulePrimaryPlane( 62 const OverlayProcessorInterface::OutputSurfaceOverlayPlane& plane) 63 override; 64 void ScheduleOverlays(SkiaOutputSurface::OverlayList overlays) override; 65 gl_surface()66 gl::GLSurface* gl_surface() { return gl_surface_.get(); } 67 68 private: 69 friend class SkiaOutputDeviceBufferQueueTest; 70 class Image; 71 class OverlayData; 72 73 using CancelableSwapCompletionCallback = 74 base::CancelableOnceCallback<void(gfx::SwapResult, 75 std::unique_ptr<gfx::GpuFence>)>; 76 77 Image* GetNextImage(); 78 void PageFlipComplete(Image* image); 79 void FreeAllSurfaces(); 80 // Used as callback for SwapBuff ersAsync and PostSubBufferAsync to finish 81 // operation 82 void DoFinishSwapBuffers(const gfx::Size& size, 83 std::vector<ui::LatencyInfo> latency_info, 84 const base::WeakPtr<Image>& image, 85 std::vector<OverlayData> overlays, 86 gfx::SwapResult result, 87 std::unique_ptr<gfx::GpuFence> gpu_fence); 88 89 SkiaOutputSurfaceDependency* const dependency_; 90 scoped_refptr<gl::GLSurface> gl_surface_; 91 const bool supports_async_swap_; 92 // Format of images 93 gfx::ColorSpace color_space_; 94 gfx::Size image_size_; 95 ResourceFormat image_format_; 96 97 // All allocated images. 98 std::vector<std::unique_ptr<Image>> images_; 99 // This image is currently used by Skia as RenderTarget. This may be nullptr 100 // if there is no drawing for the current frame or if allocation failed. 101 Image* current_image_ = nullptr; 102 // The last image submitted for presenting. 103 Image* submitted_image_ = nullptr; 104 // The image currently on the screen, if any. 105 Image* displayed_image_ = nullptr; 106 // These are free for use, and are not nullptr. 107 base::circular_deque<Image*> available_images_; 108 // These cancelable callbacks bind images that have been scheduled to display 109 // but are not displayed yet. This deque will be cleared when represented 110 // frames are destroyed. Use CancelableOnceCallback to prevent resources 111 // from being destructed outside SkiaOutputDeviceBufferQueue life span. 112 base::circular_deque<std::unique_ptr<CancelableSwapCompletionCallback>> 113 swap_completion_callbacks_; 114 // Scheduled overlays for the next SwapBuffers call. 115 std::vector<OverlayData> pending_overlays_; 116 // Committed overlays for the last SwapBuffers call. 117 std::vector<OverlayData> committed_overlays_; 118 119 // Shared Image factories 120 gpu::SharedImageFactory shared_image_factory_; 121 std::unique_ptr<gpu::SharedImageRepresentationFactory> 122 shared_image_representation_factory_; 123 uint32_t shared_image_usage_; 124 125 DISALLOW_COPY_AND_ASSIGN(SkiaOutputDeviceBufferQueue); 126 }; 127 128 } // namespace viz 129 130 #endif // COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_DEVICE_BUFFER_QUEUE_H_ 131