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