1 // Copyright (c) 2013 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 CONTENT_RENDERER_COMPOSITOR_LAYER_TREE_VIEW_H_ 6 #define CONTENT_RENDERER_COMPOSITOR_LAYER_TREE_VIEW_H_ 7 8 #include <stdint.h> 9 10 #include "base/callback.h" 11 #include "base/containers/circular_deque.h" 12 #include "base/memory/weak_ptr.h" 13 #include "base/single_thread_task_runner.h" 14 #include "base/time/time.h" 15 #include "base/values.h" 16 #include "cc/input/browser_controls_state.h" 17 #include "cc/trees/layer_tree_host_client.h" 18 #include "cc/trees/layer_tree_host_single_thread_client.h" 19 #include "cc/trees/swap_promise.h" 20 #include "cc/trees/swap_promise_monitor.h" 21 #include "content/common/content_export.h" 22 #include "ui/gfx/geometry/rect.h" 23 24 namespace blink { 25 namespace scheduler { 26 class WebThreadScheduler; 27 } 28 } // namespace blink 29 30 namespace cc { 31 class AnimationHost; 32 class LayerTreeFrameSink; 33 class LayerTreeHost; 34 class LayerTreeSettings; 35 class RenderFrameMetadataObserver; 36 class TaskGraphRunner; 37 class UkmRecorderFactory; 38 } // namespace cc 39 40 namespace content { 41 class LayerTreeViewDelegate; 42 43 class CONTENT_EXPORT LayerTreeView : public cc::LayerTreeHostClient, 44 public cc::LayerTreeHostSingleThreadClient, 45 public cc::LayerTreeHostSchedulingClient { 46 public: 47 // The |main_thread| is the task runner that the compositor will use for the 48 // main thread (where it is constructed). The |compositor_thread| is the task 49 // runner for the compositor thread, but is null if the compositor will run in 50 // single-threaded mode (in tests only). 51 LayerTreeView(LayerTreeViewDelegate* delegate, 52 scoped_refptr<base::SingleThreadTaskRunner> main_thread, 53 scoped_refptr<base::SingleThreadTaskRunner> compositor_thread, 54 cc::TaskGraphRunner* task_graph_runner, 55 blink::scheduler::WebThreadScheduler* scheduler); 56 ~LayerTreeView() override; 57 58 // The |ukm_recorder_factory| may be null to disable recording (in tests 59 // only). 60 void Initialize(const cc::LayerTreeSettings& settings, 61 std::unique_ptr<cc::UkmRecorderFactory> ukm_recorder_factory); 62 63 // Drops any references back to the delegate in preparation for being 64 // destroyed. 65 void Disconnect(); 66 animation_host()67 cc::AnimationHost* animation_host() { return animation_host_.get(); } 68 69 void SetVisible(bool visible); 70 71 // cc::LayerTreeHostClient implementation. 72 void WillBeginMainFrame() override; 73 void DidBeginMainFrame() override; 74 void WillUpdateLayers() override; 75 void DidUpdateLayers() override; 76 void BeginMainFrame(const viz::BeginFrameArgs& args) override; 77 void OnDeferMainFrameUpdatesChanged(bool) override; 78 void OnDeferCommitsChanged(bool) override; 79 void BeginMainFrameNotExpectedSoon() override; 80 void BeginMainFrameNotExpectedUntil(base::TimeTicks time) override; 81 void UpdateLayerTreeHost() override; 82 void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override; 83 void RecordManipulationTypeCounts(cc::ManipulationInfo info) override; 84 void SendOverscrollEventFromImplSide( 85 const gfx::Vector2dF& overscroll_delta, 86 cc::ElementId scroll_latched_element_id) override; 87 void SendScrollEndEventFromImplSide( 88 cc::ElementId scroll_latched_element_id) override; 89 void RequestNewLayerTreeFrameSink() override; 90 void DidInitializeLayerTreeFrameSink() override; 91 void DidFailToInitializeLayerTreeFrameSink() override; 92 void WillCommit() override; 93 void DidCommit(base::TimeTicks commit_start_time) override; 94 void DidCommitAndDrawFrame() override; DidReceiveCompositorFrameAck()95 void DidReceiveCompositorFrameAck() override {} 96 void DidCompletePageScaleAnimation() override; 97 void DidPresentCompositorFrame( 98 uint32_t frame_token, 99 const gfx::PresentationFeedback& feedback) override; 100 void RecordStartOfFrameMetrics() override; 101 void RecordEndOfFrameMetrics( 102 base::TimeTicks frame_begin_time, 103 cc::ActiveFrameSequenceTrackers trackers) override; 104 std::unique_ptr<cc::BeginMainFrameMetrics> GetBeginMainFrameMetrics() 105 override; 106 107 // cc::LayerTreeHostSingleThreadClient implementation. 108 void DidSubmitCompositorFrame() override; 109 void DidLoseLayerTreeFrameSink() override; 110 111 // cc::LayerTreeHostSchedulingClient implementation. 112 void DidScheduleBeginMainFrame() override; 113 void DidRunBeginMainFrame() override; 114 115 void AddPresentationCallback( 116 uint32_t frame_token, 117 base::OnceCallback<void(base::TimeTicks)> callback); 118 layer_tree_host()119 cc::LayerTreeHost* layer_tree_host() { return layer_tree_host_.get(); } layer_tree_host()120 const cc::LayerTreeHost* layer_tree_host() const { 121 return layer_tree_host_.get(); 122 } 123 124 protected: 125 friend class RenderViewImplScaleFactorTest; 126 127 private: 128 void SetLayerTreeFrameSink( 129 std::unique_ptr<cc::LayerTreeFrameSink> layer_tree_frame_sink, 130 std::unique_ptr<cc::RenderFrameMetadataObserver> 131 render_frame_metadata_observer); 132 133 const scoped_refptr<base::SingleThreadTaskRunner> main_thread_; 134 const scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_; 135 cc::TaskGraphRunner* const task_graph_runner_; 136 blink::scheduler::WebThreadScheduler* const web_main_thread_scheduler_; 137 const std::unique_ptr<cc::AnimationHost> animation_host_; 138 139 // The delegate_ becomes null when Disconnect() is called. After that, the 140 // class should do nothing in calls from the LayerTreeHost, and just wait to 141 // be destroyed. It is not expected to be used at all after Disconnect() 142 // outside of handling/dropping LayerTreeHost client calls. 143 LayerTreeViewDelegate* delegate_; 144 std::unique_ptr<cc::LayerTreeHost> layer_tree_host_; 145 146 // This class should do nothing and access no pointers once this value becomes 147 // true. 148 bool layer_tree_frame_sink_request_failed_while_invisible_ = false; 149 150 int layer_tree_frame_sink_init_failures = 0; 151 152 base::circular_deque< 153 std::pair<uint32_t, 154 std::vector<base::OnceCallback<void(base::TimeTicks)>>>> 155 presentation_callbacks_; 156 157 base::WeakPtrFactory<LayerTreeView> weak_factory_{this}; 158 159 DISALLOW_COPY_AND_ASSIGN(LayerTreeView); 160 }; 161 162 } // namespace content 163 164 #endif // CONTENT_RENDERER_COMPOSITOR_LAYER_TREE_VIEW_H_ 165