1 // Copyright 2011 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_TREES_THREAD_PROXY_H_ 6 #define CC_TREES_THREAD_PROXY_H_ 7 8 #include <string> 9 10 #include "base/memory/scoped_ptr.h" 11 #include "base/memory/weak_ptr.h" 12 #include "base/time/time.h" 13 #include "cc/animation/animation_events.h" 14 #include "cc/base/completion_event.h" 15 #include "cc/base/delayed_unique_notifier.h" 16 #include "cc/resources/resource_update_controller.h" 17 #include "cc/scheduler/scheduler.h" 18 #include "cc/trees/layer_tree_host_impl.h" 19 #include "cc/trees/proxy.h" 20 #include "cc/trees/proxy_timing_history.h" 21 22 namespace base { 23 class SingleThreadTaskRunner; 24 } 25 26 namespace cc { 27 28 class ContextProvider; 29 class InputHandlerClient; 30 class LayerTreeHost; 31 class ResourceUpdateQueue; 32 class Scheduler; 33 class ScopedThreadProxy; 34 35 class CC_EXPORT ThreadProxy : public Proxy, 36 NON_EXPORTED_BASE(LayerTreeHostImplClient), 37 NON_EXPORTED_BASE(SchedulerClient), 38 NON_EXPORTED_BASE(ResourceUpdateControllerClient) { 39 public: 40 static scoped_ptr<Proxy> Create( 41 LayerTreeHost* layer_tree_host, 42 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, 43 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner); 44 45 virtual ~ThreadProxy(); 46 47 struct BeginMainFrameAndCommitState { 48 BeginMainFrameAndCommitState(); 49 ~BeginMainFrameAndCommitState(); 50 51 unsigned int begin_frame_id; 52 BeginFrameArgs begin_frame_args; 53 scoped_ptr<ScrollAndScaleSet> scroll_info; 54 size_t memory_allocation_limit_bytes; 55 int memory_allocation_priority_cutoff; 56 bool evicted_ui_resources; 57 }; 58 59 struct MainThreadOnly { 60 MainThreadOnly(ThreadProxy* proxy, int layer_tree_host_id); 61 ~MainThreadOnly(); 62 63 const int layer_tree_host_id; 64 65 // Set only when SetNeedsAnimate is called. 66 bool animate_requested; 67 // Set only when SetNeedsCommit is called. 68 bool commit_requested; 69 // Set by SetNeedsAnimate, SetNeedsUpdateLayers, and SetNeedsCommit. 70 bool commit_request_sent_to_impl_thread; 71 72 bool started; 73 bool manage_tiles_pending; 74 bool can_cancel_commit; 75 bool defer_commits; 76 77 RendererCapabilities renderer_capabilities_main_thread_copy; 78 79 scoped_ptr<BeginMainFrameAndCommitState> pending_deferred_commit; 80 base::WeakPtrFactory<ThreadProxy> weak_factory; 81 }; 82 83 // Accessed on the main thread, or when main thread is blocked. 84 struct MainThreadOrBlockedMainThread { 85 explicit MainThreadOrBlockedMainThread(LayerTreeHost* host); 86 ~MainThreadOrBlockedMainThread(); 87 88 PrioritizedResourceManager* contents_texture_manager(); 89 90 LayerTreeHost* layer_tree_host; 91 bool commit_waits_for_activation; 92 bool main_thread_inside_commit; 93 94 base::TimeTicks last_monotonic_frame_begin_time; 95 }; 96 97 struct CompositorThreadOnly { 98 CompositorThreadOnly( 99 ThreadProxy* proxy, 100 int layer_tree_host_id, 101 RenderingStatsInstrumentation* rendering_stats_instrumentation); 102 ~CompositorThreadOnly(); 103 104 const int layer_tree_host_id; 105 106 // Copy of the main thread side contents texture manager for work 107 // that needs to be done on the compositor thread. 108 PrioritizedResourceManager* contents_texture_manager; 109 110 scoped_ptr<Scheduler> scheduler; 111 112 // Set when the main thread is waiting on a 113 // ScheduledActionSendBeginMainFrame to be issued. 114 CompletionEvent* begin_main_frame_sent_completion_event; 115 116 // Set when the main thread is waiting on a commit to complete. 117 CompletionEvent* commit_completion_event; 118 119 // Set when the main thread is waiting on a pending tree activation. 120 CompletionEvent* completion_event_for_commit_held_on_tree_activation; 121 122 scoped_ptr<ResourceUpdateController> current_resource_update_controller; 123 124 // Set when the next draw should post DidCommitAndDrawFrame to the main 125 // thread. 126 bool next_frame_is_newly_committed_frame; 127 128 bool inside_draw; 129 130 bool input_throttled_until_commit; 131 132 // Set when we freeze animations to avoid checkerboarding. 133 bool animations_frozen_until_next_draw; 134 base::TimeTicks animation_time; 135 136 // Whether a commit has been completed since the last time animations were 137 // ticked. If this happens, we need to animate again. 138 bool did_commit_after_animating; 139 140 DelayedUniqueNotifier smoothness_priority_expiration_notifier; 141 142 ProxyTimingHistory timing_history; 143 144 scoped_ptr<LayerTreeHostImpl> layer_tree_host_impl; 145 base::WeakPtrFactory<ThreadProxy> weak_factory; 146 }; 147 148 const MainThreadOnly& main() const; 149 const MainThreadOrBlockedMainThread& blocked_main() const; 150 const CompositorThreadOnly& impl() const; 151 152 // Proxy implementation 153 virtual void FinishAllRendering() OVERRIDE; 154 virtual bool IsStarted() const OVERRIDE; 155 virtual void SetOutputSurface(scoped_ptr<OutputSurface>) OVERRIDE; 156 virtual void SetLayerTreeHostClientReady() OVERRIDE; 157 virtual void SetVisible(bool visible) OVERRIDE; 158 virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE; 159 virtual void SetNeedsAnimate() OVERRIDE; 160 virtual void SetNeedsUpdateLayers() OVERRIDE; 161 virtual void SetNeedsCommit() OVERRIDE; 162 virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) OVERRIDE; 163 virtual void SetNextCommitWaitsForActivation() OVERRIDE; 164 virtual void NotifyInputThrottledUntilCommit() OVERRIDE; 165 virtual void SetDeferCommits(bool defer_commits) OVERRIDE; 166 virtual bool CommitRequested() const OVERRIDE; 167 virtual bool BeginMainFrameRequested() const OVERRIDE; 168 virtual void MainThreadHasStoppedFlinging() OVERRIDE; 169 virtual void Start() OVERRIDE; 170 virtual void Stop() OVERRIDE; 171 virtual size_t MaxPartialTextureUpdates() const OVERRIDE; 172 virtual void ForceSerializeOnSwapBuffers() OVERRIDE; 173 virtual bool SupportsImplScrolling() const OVERRIDE; 174 virtual void SetDebugState(const LayerTreeDebugState& debug_state) OVERRIDE; 175 virtual void AsValueInto(base::debug::TracedValue* value) const OVERRIDE; 176 virtual bool MainFrameWillHappenForTesting() OVERRIDE; 177 178 // LayerTreeHostImplClient implementation 179 virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE; 180 virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE; 181 virtual void CommitVSyncParameters(base::TimeTicks timebase, 182 base::TimeDelta interval) OVERRIDE; 183 virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) OVERRIDE; 184 virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE; 185 virtual void SetMaxSwapsPendingOnImplThread(int max) OVERRIDE; 186 virtual void DidSwapBuffersOnImplThread() OVERRIDE; 187 virtual void DidSwapBuffersCompleteOnImplThread() OVERRIDE; 188 virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE; 189 virtual void NotifyReadyToActivate() OVERRIDE; 190 // Please call these 3 functions through 191 // LayerTreeHostImpl's SetNeedsRedraw(), SetNeedsRedrawRect() and 192 // SetNeedsAnimate(). 193 virtual void SetNeedsRedrawOnImplThread() OVERRIDE; 194 virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& dirty_rect) 195 OVERRIDE; 196 virtual void SetNeedsAnimateOnImplThread() OVERRIDE; 197 virtual void SetNeedsManageTilesOnImplThread() OVERRIDE; 198 virtual void DidInitializeVisibleTileOnImplThread() OVERRIDE; 199 virtual void SetNeedsCommitOnImplThread() OVERRIDE; 200 virtual void PostAnimationEventsToMainThreadOnImplThread( 201 scoped_ptr<AnimationEventsVector> queue) OVERRIDE; 202 virtual bool ReduceContentsTextureMemoryOnImplThread(size_t limit_bytes, 203 int priority_cutoff) 204 OVERRIDE; 205 virtual bool IsInsideDraw() OVERRIDE; 206 virtual void RenewTreePriority() OVERRIDE; 207 virtual void PostDelayedScrollbarFadeOnImplThread( 208 const base::Closure& start_fade, 209 base::TimeDelta delay) OVERRIDE; 210 virtual void DidActivateSyncTree() OVERRIDE; 211 virtual void DidManageTiles() OVERRIDE; 212 213 // SchedulerClient implementation 214 virtual void SetNeedsBeginFrame(bool enable) OVERRIDE; 215 virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE; 216 virtual void ScheduledActionSendBeginMainFrame() OVERRIDE; 217 virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE; 218 virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE; 219 virtual void ScheduledActionAnimate() OVERRIDE; 220 virtual void ScheduledActionCommit() OVERRIDE; 221 virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE; 222 virtual void ScheduledActionActivateSyncTree() OVERRIDE; 223 virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE; 224 virtual void ScheduledActionManageTiles() OVERRIDE; 225 virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) OVERRIDE; 226 virtual base::TimeDelta DrawDurationEstimate() OVERRIDE; 227 virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE; 228 virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE; 229 virtual void DidBeginImplFrameDeadline() OVERRIDE; 230 231 // ResourceUpdateControllerClient implementation 232 virtual void ReadyToFinalizeTextureUpdates() OVERRIDE; 233 234 protected: 235 ThreadProxy(LayerTreeHost* layer_tree_host, 236 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, 237 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner); 238 239 private: 240 // Called on main thread. 241 void SetRendererCapabilitiesMainThreadCopy( 242 const RendererCapabilities& capabilities); 243 void BeginMainFrame( 244 scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state); 245 void DidCommitAndDrawFrame(); 246 void DidCompleteSwapBuffers(); 247 void SetAnimationEvents(scoped_ptr<AnimationEventsVector> queue); 248 void DidLoseOutputSurface(); 249 void RequestNewOutputSurface(); 250 void DidInitializeOutputSurface(bool success, 251 const RendererCapabilities& capabilities); 252 void SendCommitRequestToImplThreadIfNeeded(); 253 254 // Called on impl thread. 255 struct SchedulerStateRequest; 256 257 void StartCommitOnImplThread(CompletionEvent* completion, 258 ResourceUpdateQueue* queue); 259 void BeginMainFrameAbortedOnImplThread(bool did_handle); 260 void FinishAllRenderingOnImplThread(CompletionEvent* completion); 261 void InitializeImplOnImplThread(CompletionEvent* completion); 262 void SetLayerTreeHostClientReadyOnImplThread(); 263 void SetVisibleOnImplThread(CompletionEvent* completion, bool visible); 264 void UpdateBackgroundAnimateTicking(); 265 void HasInitializedOutputSurfaceOnImplThread( 266 CompletionEvent* completion, 267 bool* has_initialized_output_surface); 268 void DeleteContentsTexturesOnImplThread(CompletionEvent* completion); 269 void InitializeOutputSurfaceOnImplThread( 270 scoped_ptr<OutputSurface> output_surface); 271 void FinishGLOnImplThread(CompletionEvent* completion); 272 void LayerTreeHostClosedOnImplThread(CompletionEvent* completion); 273 DrawResult DrawSwapInternal(bool forced_draw); 274 void ForceSerializeOnSwapBuffersOnImplThread(CompletionEvent* completion); 275 void MainFrameWillHappenOnImplThreadForTesting(CompletionEvent* completion, 276 bool* main_frame_will_happen); 277 void AsValueOnImplThread(CompletionEvent* completion, 278 base::debug::TracedValue* state) const; 279 void SetSwapUsedIncompleteTileOnImplThread(bool used_incomplete_tile); 280 void MainThreadHasStoppedFlingingOnImplThread(); 281 void SetInputThrottledUntilCommitOnImplThread(bool is_throttled); 282 void SetDebugStateOnImplThread(const LayerTreeDebugState& debug_state); 283 284 LayerTreeHost* layer_tree_host(); 285 const LayerTreeHost* layer_tree_host() const; 286 287 // Use accessors instead of this variable directly. 288 MainThreadOnly main_thread_only_vars_unsafe_; 289 MainThreadOnly& main(); 290 291 // Use accessors instead of this variable directly. 292 MainThreadOrBlockedMainThread main_thread_or_blocked_vars_unsafe_; 293 MainThreadOrBlockedMainThread& blocked_main(); 294 295 // Use accessors instead of this variable directly. 296 CompositorThreadOnly compositor_thread_vars_unsafe_; 297 CompositorThreadOnly& impl(); 298 299 base::WeakPtr<ThreadProxy> main_thread_weak_ptr_; 300 base::WeakPtr<ThreadProxy> impl_thread_weak_ptr_; 301 302 DISALLOW_COPY_AND_ASSIGN(ThreadProxy); 303 }; 304 305 } // namespace cc 306 307 #endif // CC_TREES_THREAD_PROXY_H_ 308