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/resources/resource_update_controller.h"
  16 #include "cc/scheduler/rolling_time_delta_history.h"
  17 #include "cc/scheduler/scheduler.h"
  18 #include "cc/trees/layer_tree_host_impl.h"
  19 #include "cc/trees/proxy.h"
  20
  21 namespace base {
  22 class SingleThreadTaskRunner;
  23 }
  24
  25 namespace cc {
  26
  27 class ContextProvider;
  28 class InputHandlerClient;
  29 class LayerTreeHost;
  30 class ResourceUpdateQueue;
  31 class Scheduler;
  32 class ScopedThreadProxy;
  33
  34 class ThreadProxy : public Proxy,
  35                     LayerTreeHostImplClient,
  36                     SchedulerClient,
  37                     ResourceUpdateControllerClient {
  38  public:
  39   static scoped_ptr<Proxy> Create(
  40       LayerTreeHost* layer_tree_host,
  41       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
  42
  43   virtual ~ThreadProxy();
  44
  45   // Proxy implementation
  46   virtual bool CompositeAndReadback(void* pixels,
  47                                     const gfx::Rect& rect) OVERRIDE;
  48   virtual void FinishAllRendering() OVERRIDE;
  49   virtual bool IsStarted() const OVERRIDE;
  50   virtual void SetLayerTreeHostClientReady() OVERRIDE;
  51   virtual void SetVisible(bool visible) OVERRIDE;
  52   virtual void CreateAndInitializeOutputSurface() OVERRIDE;
  53   virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
  54   virtual void SetNeedsAnimate() OVERRIDE;
  55   virtual void SetNeedsUpdateLayers() OVERRIDE;
  56   virtual void SetNeedsCommit() OVERRIDE;
  57   virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) OVERRIDE;
  58   virtual void SetNextCommitWaitsForActivation() OVERRIDE;
  59   virtual void NotifyInputThrottledUntilCommit() OVERRIDE;
  60   virtual void SetDeferCommits(bool defer_commits) OVERRIDE;
  61   virtual bool CommitRequested() const OVERRIDE;
  62   virtual bool BeginMainFrameRequested() const OVERRIDE;
  63   virtual void MainThreadHasStoppedFlinging() OVERRIDE;
  64   virtual void Start() OVERRIDE;
  65   virtual void Stop() OVERRIDE;
  66   virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
  67   virtual void AcquireLayerTextures() OVERRIDE;
  68   virtual void ForceSerializeOnSwapBuffers() OVERRIDE;
  69   virtual scoped_ptr<base::Value> AsValue() const OVERRIDE;
  70   virtual bool CommitPendingForTesting() OVERRIDE;
  71   virtual scoped_ptr<base::Value> SchedulerStateAsValueForTesting() OVERRIDE;
  72
  73   // LayerTreeHostImplClient implementation
  74   virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE;
  75   virtual void DidSwapBuffersOnImplThread() OVERRIDE {}
  76   virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE;
  77   virtual void BeginImplFrame(const BeginFrameArgs& args) OVERRIDE;
  78   virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE;
  79   virtual void NotifyReadyToActivate() OVERRIDE;
  80   // Please call these 2 functions through
  81   // LayerTreeHostImpl's SetNeedsRedraw() and SetNeedsRedrawRect().
  82   virtual void SetNeedsRedrawOnImplThread() OVERRIDE;
  83   virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& dirty_rect)
  84       OVERRIDE;
  85   virtual void SetNeedsManageTilesOnImplThread() OVERRIDE;
  86   virtual void DidInitializeVisibleTileOnImplThread() OVERRIDE;
  87   virtual void SetNeedsCommitOnImplThread() OVERRIDE;
  88   virtual void PostAnimationEventsToMainThreadOnImplThread(
  89       scoped_ptr<AnimationEventsVector> queue,
  90       base::Time wall_clock_time) OVERRIDE;
  91   virtual bool ReduceContentsTextureMemoryOnImplThread(size_t limit_bytes,
  92                                                        int priority_cutoff)
  93       OVERRIDE;
  94   virtual void SendManagedMemoryStats() OVERRIDE;
  95   virtual bool IsInsideDraw() OVERRIDE;
  96   virtual void RenewTreePriority() OVERRIDE;
  97   virtual void RequestScrollbarAnimationOnImplThread(base::TimeDelta delay)
  98       OVERRIDE;
  99   virtual void DidActivatePendingTree() OVERRIDE;
 100   virtual void DidManageTiles() OVERRIDE;
 101
 102   // SchedulerClient implementation
 103   virtual void SetNeedsBeginImplFrame(bool enable) OVERRIDE;
 104   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE;
 105   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
 106       OVERRIDE;
 107   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE;
 108   virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() OVERRIDE;
 109   virtual void ScheduledActionCommit() OVERRIDE;
 110   virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE;
 111   virtual void ScheduledActionActivatePendingTree() OVERRIDE;
 112   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE;
 113   virtual void ScheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
 114   virtual void ScheduledActionManageTiles() OVERRIDE;
 115   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) OVERRIDE;
 116   virtual base::TimeDelta DrawDurationEstimate() OVERRIDE;
 117   virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE;
 118   virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE;
 119   virtual void PostBeginImplFrameDeadline(const base::Closure& closure,
 120                                           base::TimeTicks deadline) OVERRIDE;
 121   virtual void DidBeginImplFrameDeadline() OVERRIDE;
 122
 123   // ResourceUpdateControllerClient implementation
 124   virtual void ReadyToFinalizeTextureUpdates() OVERRIDE;
 125
 126  private:
 127   ThreadProxy(LayerTreeHost* layer_tree_host,
 128               scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
 129
 130   struct BeginMainFrameAndCommitState {
 131     BeginMainFrameAndCommitState();
 132     ~BeginMainFrameAndCommitState();
 133
 134     base::TimeTicks monotonic_frame_begin_time;
 135     scoped_ptr<ScrollAndScaleSet> scroll_info;
 136     size_t memory_allocation_limit_bytes;
 137     int memory_allocation_priority_cutoff;
 138     bool evicted_ui_resources;
 139   };
 140
 141   // Called on main thread.
 142   void BeginMainFrame(
 143       scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state);
 144   void DidCommitAndDrawFrame();
 145   void DidCompleteSwapBuffers();
 146   void SetAnimationEvents(scoped_ptr<AnimationEventsVector> queue,
 147                           base::Time wall_clock_time);
 148   void DoCreateAndInitializeOutputSurface();
 149   // |capabilities| is set only when |success| is true.
 150   void OnOutputSurfaceInitializeAttempted(
 151       bool success,
 152       const RendererCapabilities& capabilities);
 153   void SendCommitRequestToImplThreadIfNeeded();
 154
 155   // Called on impl thread.
 156   struct ReadbackRequest;
 157   struct CommitPendingRequest;
 158   struct SchedulerStateRequest;
 159
 160   void ForceCommitForReadbackOnImplThread(
 161       CompletionEvent* begin_main_frame_sent_completion,
 162       ReadbackRequest* request);
 163   void StartCommitOnImplThread(
 164       CompletionEvent* completion,
 165       ResourceUpdateQueue* queue,
 166       scoped_refptr<ContextProvider> offscreen_context_provider);
 167   void BeginMainFrameAbortedOnImplThread(bool did_handle);
 168   void RequestReadbackOnImplThread(ReadbackRequest* request);
 169   void FinishAllRenderingOnImplThread(CompletionEvent* completion);
 170   void InitializeImplOnImplThread(CompletionEvent* completion,
 171                                   int layer_tree_host_id);
 172   void SetLayerTreeHostClientReadyOnImplThread();
 173   void SetVisibleOnImplThread(CompletionEvent* completion, bool visible);
 174   void UpdateBackgroundAnimateTicking();
 175   void HasInitializedOutputSurfaceOnImplThread(
 176       CompletionEvent* completion,
 177       bool* has_initialized_output_surface);
 178   void InitializeOutputSurfaceOnImplThread(
 179       CompletionEvent* completion,
 180       scoped_ptr<OutputSurface> output_surface,
 181       scoped_refptr<ContextProvider> offscreen_context_provider,
 182       bool* success,
 183       RendererCapabilities* capabilities);
 184   void FinishGLOnImplThread(CompletionEvent* completion);
 185   void LayerTreeHostClosedOnImplThread(CompletionEvent* completion);
 186   void AcquireLayerTexturesForMainThreadOnImplThread(
 187       CompletionEvent* completion);
 188   DrawSwapReadbackResult DrawSwapReadbackInternal(bool forced_draw,
 189                                                   bool swap_requested,
 190                                                   bool readback_requested);
 191   void ForceSerializeOnSwapBuffersOnImplThread(CompletionEvent* completion);
 192   void CheckOutputSurfaceStatusOnImplThread();
 193   void CommitPendingOnImplThreadForTesting(CommitPendingRequest* request);
 194   void SchedulerStateAsValueOnImplThreadForTesting(
 195       SchedulerStateRequest* request);
 196   void AsValueOnImplThread(CompletionEvent* completion,
 197                            base::DictionaryValue* state) const;
 198   void RenewTreePriorityOnImplThread();
 199   void SetSwapUsedIncompleteTileOnImplThread(bool used_incomplete_tile);
 200   void StartScrollbarAnimationOnImplThread();
 201   void MainThreadHasStoppedFlingingOnImplThread();
 202   void SetInputThrottledUntilCommitOnImplThread(bool is_throttled);
 203   LayerTreeHost* layer_tree_host();
 204   const LayerTreeHost* layer_tree_host() const;
 205
 206   struct MainThreadOnly {
 207     MainThreadOnly(ThreadProxy* proxy, int layer_tree_host_id);
 208     ~MainThreadOnly();
 209
 210     const int layer_tree_host_id;
 211
 212     // Set only when SetNeedsAnimate is called.
 213     bool animate_requested;
 214     // Set only when SetNeedsCommit is called.
 215     bool commit_requested;
 216     // Set by SetNeedsAnimate, SetNeedsUpdateLayers, and SetNeedsCommit.
 217     bool commit_request_sent_to_impl_thread;
 218     // Set by BeginMainFrame
 219     bool created_offscreen_context_provider;
 220
 221     bool started;
 222     bool textures_acquired;
 223     bool in_composite_and_readback;
 224     bool manage_tiles_pending;
 225     bool can_cancel_commit;
 226     bool defer_commits;
 227
 228     base::CancelableClosure output_surface_creation_callback;
 229     RendererCapabilities renderer_capabilities_main_thread_copy;
 230
 231     scoped_ptr<BeginMainFrameAndCommitState> pending_deferred_commit;
 232     base::WeakPtrFactory<ThreadProxy> weak_factory;
 233   };
 234   // Use accessors instead of this variable directly.
 235   MainThreadOnly main_thread_only_vars_unsafe_;
 236   MainThreadOnly& main();
 237   const MainThreadOnly& main() const;
 238
 239   // Accessed on the main thread, or when main thread is blocked.
 240   struct MainThreadOrBlockedMainThread {
 241     explicit MainThreadOrBlockedMainThread(LayerTreeHost* host);
 242     ~MainThreadOrBlockedMainThread();
 243
 244     PrioritizedResourceManager* contents_texture_manager();
 245
 246     LayerTreeHost* layer_tree_host;
 247     bool commit_waits_for_activation;
 248     bool main_thread_inside_commit;
 249   };
 250   // Use accessors instead of this variable directly.
 251   MainThreadOrBlockedMainThread main_thread_or_blocked_vars_unsafe_;
 252   MainThreadOrBlockedMainThread& blocked_main();
 253   const MainThreadOrBlockedMainThread& blocked_main() const;
 254
 255   struct CompositorThreadOnly {
 256     explicit CompositorThreadOnly(ThreadProxy* proxy);
 257     ~CompositorThreadOnly();
 258
 259     // Copy of the main thread side contents texture manager for work
 260     // that needs to be done on the compositor thread.
 261     PrioritizedResourceManager* contents_texture_manager;
 262
 263     scoped_ptr<Scheduler> scheduler;
 264
 265     // Set when the main thread is waiting on a
 266     // ScheduledActionSendBeginMainFrame to be issued.
 267     CompletionEvent* begin_main_frame_sent_completion_event;
 268
 269     // Set when the main thread is waiting on a readback.
 270     ReadbackRequest* readback_request;
 271
 272     // Set when the main thread is waiting on a commit to complete.
 273     CompletionEvent* commit_completion_event;
 274
 275     // Set when the main thread is waiting on a pending tree activation.
 276     CompletionEvent* completion_event_for_commit_held_on_tree_activation;
 277
 278     // Set when the main thread is waiting on layers to be drawn.
 279     CompletionEvent* texture_acquisition_completion_event;
 280
 281     scoped_ptr<ResourceUpdateController> current_resource_update_controller;
 282
 283     // Set when the next draw should post DidCommitAndDrawFrame to the main
 284     // thread.
 285     bool next_frame_is_newly_committed_frame;
 286
 287     bool inside_draw;
 288
 289     bool input_throttled_until_commit;
 290
 291     base::TimeTicks smoothness_takes_priority_expiration_time;
 292     bool renew_tree_priority_pending;
 293
 294     RollingTimeDeltaHistory draw_duration_history;
 295     RollingTimeDeltaHistory begin_main_frame_to_commit_duration_history;
 296     RollingTimeDeltaHistory commit_to_activate_duration_history;
 297
 298     // Used for computing samples added to
 299     // begin_main_frame_to_commit_duration_history_ and
 300     // activation_duration_history_.
 301     base::TimeTicks begin_main_frame_sent_time;
 302     base::TimeTicks commit_complete_time;
 303
 304     scoped_ptr<LayerTreeHostImpl> layer_tree_host_impl;
 305     base::WeakPtrFactory<ThreadProxy> weak_factory;
 306   };
 307   // Use accessors instead of this variable directly.
 308   CompositorThreadOnly compositor_thread_vars_unsafe_;
 309   CompositorThreadOnly& impl();
 310   const CompositorThreadOnly& impl() const;
 311
 312   base::WeakPtr<ThreadProxy> main_thread_weak_ptr_;
 313   base::WeakPtr<ThreadProxy> impl_thread_weak_ptr_;
 314
 315   DISALLOW_COPY_AND_ASSIGN(ThreadProxy);
 316 };
 317
 318 }  // namespace cc
 319
 320 #endif  // CC_TREES_THREAD_PROXY_H_