cc/trees/thread_proxy.h

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