src/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/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_