1 // Copyright 2016 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 CC_TEST_TEST_LAYER_TREE_FRAME_SINK_H_ 6 #define CC_TEST_TEST_LAYER_TREE_FRAME_SINK_H_ 7 8 #include <memory> 9 #include <set> 10 #include <vector> 11 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/weak_ptr.h" 14 #include "cc/trees/layer_tree_frame_sink.h" 15 #include "components/viz/common/display/renderer_settings.h" 16 #include "components/viz/common/frame_sinks/begin_frame_source.h" 17 #include "components/viz/common/frame_timing_details_map.h" 18 #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h" 19 #include "components/viz/service/display/display.h" 20 #include "components/viz/service/display/display_client.h" 21 #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h" 22 #include "components/viz/test/test_shared_bitmap_manager.h" 23 #include "services/viz/public/mojom/compositing/compositor_frame_sink.mojom.h" 24 25 namespace base { 26 class SingleThreadTaskRunner; 27 } 28 29 namespace viz { 30 class CompositorFrameSinkSupport; 31 } // namespace viz 32 33 namespace cc { 34 35 class TestLayerTreeFrameSinkClient { 36 public: ~TestLayerTreeFrameSinkClient()37 virtual ~TestLayerTreeFrameSinkClient() {} 38 39 virtual std::unique_ptr<viz::DisplayCompositorMemoryAndTaskController> 40 CreateDisplayController() = 0; 41 virtual std::unique_ptr<viz::SkiaOutputSurface> 42 CreateDisplaySkiaOutputSurface( 43 viz::DisplayCompositorMemoryAndTaskController*) = 0; 44 45 // This passes the ContextProvider being used by LayerTreeHostImpl which 46 // can be used for the OutputSurface optionally. 47 virtual std::unique_ptr<viz::OutputSurface> CreateDisplayOutputSurface( 48 scoped_refptr<viz::ContextProvider> compositor_context_provider) = 0; 49 50 virtual void DisplayReceivedLocalSurfaceId( 51 const viz::LocalSurfaceId& local_surface_id) = 0; 52 virtual void DisplayReceivedCompositorFrame( 53 const viz::CompositorFrame& frame) = 0; 54 virtual void DisplayWillDrawAndSwap( 55 bool will_draw_and_swap, 56 viz::AggregatedRenderPassList* render_passes) = 0; 57 virtual void DisplayDidDrawAndSwap() = 0; 58 }; 59 60 // LayerTreeFrameSink that owns and forwards frames to a Display. 61 class TestLayerTreeFrameSink : public LayerTreeFrameSink, 62 public viz::mojom::CompositorFrameSinkClient, 63 public viz::DisplayClient, 64 public viz::ExternalBeginFrameSourceClient { 65 public: 66 // Pass true for |force_disable_reclaim_resources| to act like the Display 67 // is out-of-process and can't return resources synchronously. 68 // If |begin_frame_source| is specified, |disable_display_vsync| and 69 // |refresh_rate| are ignored. 70 TestLayerTreeFrameSink( 71 scoped_refptr<viz::ContextProvider> compositor_context_provider, 72 scoped_refptr<viz::RasterContextProvider> worker_context_provider, 73 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, 74 const viz::RendererSettings& renderer_settings, 75 const viz::DebugRendererSettings* debug_settings, 76 scoped_refptr<base::SingleThreadTaskRunner> task_runner, 77 bool synchronous_composite, 78 bool disable_display_vsync, 79 double refresh_rate, 80 viz::BeginFrameSource* begin_frame_source = nullptr); 81 ~TestLayerTreeFrameSink() override; 82 83 // This client must be set before BindToClient() happens. SetClient(TestLayerTreeFrameSinkClient * client)84 void SetClient(TestLayerTreeFrameSinkClient* client) { 85 test_client_ = client; 86 } SetEnlargePassTextureAmount(const gfx::Size & s)87 void SetEnlargePassTextureAmount(const gfx::Size& s) { 88 enlarge_pass_texture_amount_ = s; 89 } 90 91 // Forward the color space to the existant Display, or the new one when it is 92 // created. 93 void SetDisplayColorSpace(const gfx::ColorSpace& output_color_space); 94 display()95 viz::Display* display() const { return display_.get(); } 96 97 // LayerTreeFrameSink implementation. 98 bool BindToClient(LayerTreeFrameSinkClient* client) override; 99 void DetachFromClient() override; 100 void SetLocalSurfaceId(const viz::LocalSurfaceId& local_surface_id) override; 101 void SubmitCompositorFrame(viz::CompositorFrame frame, 102 bool hit_test_data_changed, 103 bool show_hit_test_borders) override; 104 void DidNotProduceFrame(const viz::BeginFrameAck& ack) override; 105 void DidAllocateSharedBitmap(base::ReadOnlySharedMemoryRegion buffer, 106 const viz::SharedBitmapId& id) override; 107 void DidDeleteSharedBitmap(const viz::SharedBitmapId& id) override; 108 109 // mojom::CompositorFrameSinkClient implementation. 110 void DidReceiveCompositorFrameAck( 111 const std::vector<viz::ReturnedResource>& resources) override; 112 void OnBeginFrame(const viz::BeginFrameArgs& args, 113 const viz::FrameTimingDetailsMap& timing_details) override; 114 void ReclaimResources( 115 const std::vector<viz::ReturnedResource>& resources) override; 116 void OnBeginFramePausedChanged(bool paused) override; 117 118 // DisplayClient implementation. 119 void DisplayOutputSurfaceLost() override; 120 void DisplayWillDrawAndSwap( 121 bool will_draw_and_swap, 122 viz::AggregatedRenderPassList* render_passes) override; 123 void DisplayDidDrawAndSwap() override; 124 void DisplayDidReceiveCALayerParams( 125 const gfx::CALayerParams& ca_layer_params) override; 126 void DisplayDidCompleteSwapWithSize(const gfx::Size& pixel_size) override; SetWideColorEnabled(bool enabled)127 void SetWideColorEnabled(bool enabled) override {} SetPreferredFrameInterval(base::TimeDelta interval)128 void SetPreferredFrameInterval(base::TimeDelta interval) override {} 129 base::TimeDelta GetPreferredFrameIntervalForFrameSinkId( 130 const viz::FrameSinkId& id, 131 viz::mojom::CompositorFrameSinkType* type) override; 132 owned_bitmaps()133 const std::set<viz::SharedBitmapId>& owned_bitmaps() const { 134 return owned_bitmaps_; 135 } 136 137 private: 138 // ExternalBeginFrameSource implementation. 139 void OnNeedsBeginFrames(bool needs_begin_frames) override; 140 141 void SendCompositorFrameAckToClient(); 142 143 const bool synchronous_composite_; 144 const bool disable_display_vsync_; 145 const viz::RendererSettings renderer_settings_; 146 const viz::DebugRendererSettings* const debug_settings_; 147 const double refresh_rate_; 148 149 viz::FrameSinkId frame_sink_id_; 150 // TODO(danakj): These don't need to be stored in unique_ptrs when 151 // LayerTreeFrameSink is owned/destroyed on the compositor thread. 152 std::unique_ptr<viz::TestSharedBitmapManager> shared_bitmap_manager_; 153 std::unique_ptr<viz::FrameSinkManagerImpl> frame_sink_manager_; 154 std::unique_ptr<viz::ParentLocalSurfaceIdAllocator> 155 parent_local_surface_id_allocator_; 156 gfx::Size display_size_; 157 float device_scale_factor_ = 0; 158 gfx::DisplayColorSpaces display_color_spaces_; 159 160 // Uses surface_manager_. 161 std::unique_ptr<viz::CompositorFrameSinkSupport> support_; 162 163 std::unique_ptr<viz::SyntheticBeginFrameSource> begin_frame_source_; 164 viz::BeginFrameSource* client_provided_begin_frame_source_; // Not owned. 165 viz::BeginFrameSource* display_begin_frame_source_ = nullptr; // Not owned. 166 viz::ExternalBeginFrameSource external_begin_frame_source_; 167 168 // Uses surface_manager_, begin_frame_source_, shared_bitmap_manager_. 169 std::unique_ptr<viz::Display> display_; 170 171 TestLayerTreeFrameSinkClient* test_client_ = nullptr; 172 gfx::Size enlarge_pass_texture_amount_; 173 174 // The set of SharedBitmapIds that have been reported as allocated to this 175 // interface. On closing this interface, the display compositor should drop 176 // ownership of the bitmaps with these ids to avoid leaking them. 177 std::set<viz::SharedBitmapId> owned_bitmaps_; 178 179 base::WeakPtrFactory<TestLayerTreeFrameSink> weak_ptr_factory_{this}; 180 }; 181 182 } // namespace cc 183 184 #endif // CC_TEST_TEST_LAYER_TREE_FRAME_SINK_H_ 185