Home | History | Annotate | Download | only in trees 
      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 { class SingleThreadTaskRunner; }
     22 
     23 namespace cc {
     24 
     25 class ContextProvider;
     26 class InputHandlerClient;
     27 class LayerTreeHost;
     28 class ResourceUpdateQueue;
     29 class Scheduler;
     30 class ScopedThreadProxy;
     31 
     32 class ThreadProxy : public Proxy,
     33                     LayerTreeHostImplClient,
     34                     SchedulerClient,
     35                     ResourceUpdateControllerClient {
     36  public:
     37   static scoped_ptr<Proxy> Create(
     38       LayerTreeHost* layer_tree_host,
     39       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
     40 
     41   virtual ~ThreadProxy();
     42 
     43   // Proxy implementation
     44   virtual bool CompositeAndReadback(void* pixels, gfx::Rect rect) OVERRIDE;
     45   virtual void FinishAllRendering() OVERRIDE;
     46   virtual bool IsStarted() const OVERRIDE;
     47   virtual void SetLayerTreeHostClientReady() OVERRIDE;
     48   virtual void SetVisible(bool visible) OVERRIDE;
     49   virtual void CreateAndInitializeOutputSurface() OVERRIDE;
     50   virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
     51   virtual void SetNeedsAnimate() OVERRIDE;
     52   virtual void SetNeedsUpdateLayers() OVERRIDE;
     53   virtual void SetNeedsCommit() OVERRIDE;
     54   virtual void SetNeedsRedraw(gfx::Rect damage_rect) OVERRIDE;
     55   virtual void SetNextCommitWaitsForActivation() OVERRIDE;
     56   virtual void NotifyInputThrottledUntilCommit() OVERRIDE;
     57   virtual void SetDeferCommits(bool defer_commits) OVERRIDE;
     58   virtual bool CommitRequested() const OVERRIDE;
     59   virtual bool BeginMainFrameRequested() const OVERRIDE;
     60   virtual void MainThreadHasStoppedFlinging() OVERRIDE;
     61   virtual void Start(scoped_ptr<OutputSurface> first_output_surface) OVERRIDE;
     62   virtual void Stop() OVERRIDE;
     63   virtual size_t MaxPartialTextureUpdates() const OVERRIDE;
     64   virtual void AcquireLayerTextures() OVERRIDE;
     65   virtual void ForceSerializeOnSwapBuffers() OVERRIDE;
     66   virtual scoped_ptr<base::Value> AsValue() const OVERRIDE;
     67   virtual bool CommitPendingForTesting() OVERRIDE;
     68   virtual scoped_ptr<base::Value> SchedulerStateAsValueForTesting() OVERRIDE;
     69 
     70   // LayerTreeHostImplClient implementation
     71   virtual void UpdateRendererCapabilitiesOnImplThread() OVERRIDE;
     72   virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE;
     73   virtual void DidSwapBuffersOnImplThread() OVERRIDE {}
     74   virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE;
     75   virtual void BeginImplFrame(const BeginFrameArgs& args) OVERRIDE;
     76   virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE;
     77   virtual void NotifyReadyToActivate() OVERRIDE;
     78   // Please call these 2 functions through
     79   // LayerTreeHostImpl's SetNeedsRedraw() and SetNeedsRedrawRect().
     80   virtual void SetNeedsRedrawOnImplThread() OVERRIDE;
     81   virtual void SetNeedsRedrawRectOnImplThread(gfx::Rect dirty_rect) OVERRIDE;
     82   virtual void SetNeedsManageTilesOnImplThread() OVERRIDE;
     83   virtual void DidInitializeVisibleTileOnImplThread() OVERRIDE;
     84   virtual void SetNeedsCommitOnImplThread() OVERRIDE;
     85   virtual void PostAnimationEventsToMainThreadOnImplThread(
     86       scoped_ptr<AnimationEventsVector> queue,
     87       base::Time wall_clock_time) OVERRIDE;
     88   virtual bool ReduceContentsTextureMemoryOnImplThread(size_t limit_bytes,
     89                                                        int priority_cutoff)
     90       OVERRIDE;
     91   virtual void SendManagedMemoryStats() OVERRIDE;
     92   virtual bool IsInsideDraw() OVERRIDE;
     93   virtual void RenewTreePriority() OVERRIDE;
     94   virtual void RequestScrollbarAnimationOnImplThread(base::TimeDelta delay)
     95       OVERRIDE;
     96   virtual void DidActivatePendingTree() OVERRIDE;
     97   virtual void DidManageTiles() OVERRIDE;
     98 
     99   // SchedulerClient implementation
    100   virtual void SetNeedsBeginImplFrame(bool enable) OVERRIDE;
    101   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE;
    102   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
    103       OVERRIDE;
    104   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE;
    105   virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() OVERRIDE;
    106   virtual void ScheduledActionCommit() OVERRIDE;
    107   virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE;
    108   virtual void ScheduledActionActivatePendingTree() OVERRIDE;
    109   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE;
    110   virtual void ScheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
    111   virtual void ScheduledActionManageTiles() OVERRIDE;
    112   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) OVERRIDE;
    113   virtual base::TimeDelta DrawDurationEstimate() OVERRIDE;
    114   virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE;
    115   virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE;
    116   virtual void PostBeginImplFrameDeadline(const base::Closure& closure,
    117                                           base::TimeTicks deadline) OVERRIDE;
    118   virtual void DidBeginImplFrameDeadline() OVERRIDE;
    119 
    120   // ResourceUpdateControllerClient implementation
    121   virtual void ReadyToFinalizeTextureUpdates() OVERRIDE;
    122 
    123  private:
    124   ThreadProxy(LayerTreeHost* layer_tree_host,
    125               scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
    126 
    127   struct BeginMainFrameAndCommitState {
    128     BeginMainFrameAndCommitState();
    129     ~BeginMainFrameAndCommitState();
    130 
    131     base::TimeTicks monotonic_frame_begin_time;
    132     scoped_ptr<ScrollAndScaleSet> scroll_info;
    133     size_t memory_allocation_limit_bytes;
    134     int memory_allocation_priority_cutoff;
    135     bool evicted_ui_resources;
    136   };
    137 
    138   // Called on main thread.
    139   void SetRendererCapabilitiesMainThreadCopy(
    140       const RendererCapabilities& capabilities);
    141   void BeginMainFrame(
    142       scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state);
    143   void DidCommitAndDrawFrame();
    144   void DidCompleteSwapBuffers();
    145   void SetAnimationEvents(scoped_ptr<AnimationEventsVector> queue,
    146                           base::Time wall_clock_time);
    147   void DoCreateAndInitializeOutputSurface();
    148   // |capabilities| is set only when |success| is true.
    149   void OnOutputSurfaceInitializeAttempted(
    150       bool success,
    151       const RendererCapabilities& capabilities);
    152   void SendCommitRequestToImplThreadIfNeeded();
    153 
    154   // Called on impl thread.
    155   struct ReadbackRequest;
    156   struct CommitPendingRequest;
    157   struct SchedulerStateRequest;
    158 
    159   void ForceCommitForReadbackOnImplThread(
    160       CompletionEvent* begin_main_frame_sent_completion,
    161       ReadbackRequest* request);
    162   void StartCommitOnImplThread(
    163       CompletionEvent* completion,
    164       ResourceUpdateQueue* queue,
    165       scoped_refptr<ContextProvider> offscreen_context_provider);
    166   void BeginMainFrameAbortedOnImplThread(bool did_handle);
    167   void RequestReadbackOnImplThread(ReadbackRequest* request);
    168   void FinishAllRenderingOnImplThread(CompletionEvent* completion);
    169   void InitializeImplOnImplThread(CompletionEvent* completion);
    170   void SetLayerTreeHostClientReadyOnImplThread();
    171   void SetVisibleOnImplThread(CompletionEvent* completion, bool visible);
    172   void UpdateBackgroundAnimateTicking();
    173   void HasInitializedOutputSurfaceOnImplThread(
    174       CompletionEvent* completion,
    175       bool* has_initialized_output_surface);
    176   void InitializeOutputSurfaceOnImplThread(
    177       CompletionEvent* completion,
    178       scoped_ptr<OutputSurface> output_surface,
    179       scoped_refptr<ContextProvider> offscreen_context_provider,
    180       bool* success,
    181       RendererCapabilities* capabilities);
    182   void FinishGLOnImplThread(CompletionEvent* completion);
    183   void LayerTreeHostClosedOnImplThread(CompletionEvent* completion);
    184   void AcquireLayerTexturesForMainThreadOnImplThread(
    185       CompletionEvent* completion);
    186   DrawSwapReadbackResult DrawSwapReadbackInternal(bool forced_draw,
    187                                                   bool swap_requested,
    188                                                   bool readback_requested);
    189   void ForceSerializeOnSwapBuffersOnImplThread(CompletionEvent* completion);
    190   void CheckOutputSurfaceStatusOnImplThread();
    191   void CommitPendingOnImplThreadForTesting(CommitPendingRequest* request);
    192   void SchedulerStateAsValueOnImplThreadForTesting(
    193       SchedulerStateRequest* request);
    194   void AsValueOnImplThread(CompletionEvent* completion,
    195                            base::DictionaryValue* state) const;
    196   void RenewTreePriorityOnImplThread();
    197   void SetSwapUsedIncompleteTileOnImplThread(bool used_incomplete_tile);
    198   void StartScrollbarAnimationOnImplThread();
    199   void MainThreadHasStoppedFlingingOnImplThread();
    200   void SetInputThrottledUntilCommitOnImplThread(bool is_throttled);
    201   LayerTreeHost* layer_tree_host();
    202   const LayerTreeHost* layer_tree_host() const;
    203   PrioritizedResourceManager* contents_texture_manager_on_main_thread();
    204   PrioritizedResourceManager* contents_texture_manager_on_impl_thread();
    205 
    206   // Accessed on main thread only.
    207 
    208   // Set only when SetNeedsAnimate is called.
    209   bool animate_requested_;
    210   // Set only when SetNeedsCommit is called.
    211   bool commit_requested_;
    212   // Set by SetNeedsAnimate, SetNeedsUpdateLayers, and SetNeedsCommit.
    213   bool commit_request_sent_to_impl_thread_;
    214   // Set by BeginMainFrame
    215   bool created_offscreen_context_provider_;
    216   base::CancelableClosure output_surface_creation_callback_;
    217   // Don't use this variable directly, go through layer_tree_host() to ensure it
    218   // is only used on the main thread or if the main thread is blocked.
    219   LayerTreeHost* layer_tree_host_unsafe_;
    220   // Use one of the contents_texture_manager_on functions above instead of using
    221   // this variable directly.
    222   PrioritizedResourceManager* contents_texture_manager_unsafe_;
    223   RendererCapabilities renderer_capabilities_main_thread_copy_;
    224   bool started_;
    225   bool textures_acquired_;
    226   bool in_composite_and_readback_;
    227   bool manage_tiles_pending_;
    228   // Weak pointer to use when posting tasks to the impl thread.
    229   base::WeakPtr<ThreadProxy> impl_thread_weak_ptr_;
    230   // Holds the first output surface passed from Start. Should not be used for
    231   // anything else.
    232   scoped_ptr<OutputSurface> first_output_surface_;
    233 
    234   // Accessed on the main thread, or when main thread is blocked.
    235   bool commit_waits_for_activation_;
    236   bool inside_commit_;
    237 
    238   scoped_ptr<LayerTreeHostImpl> layer_tree_host_impl_;
    239 
    240   scoped_ptr<Scheduler> scheduler_on_impl_thread_;
    241 
    242   // Set when the main thread is waiting on a
    243   // ScheduledActionSendBeginMainFrame to be issued.
    244   CompletionEvent*
    245       begin_main_frame_sent_completion_event_on_impl_thread_;
    246 
    247   // Set when the main thread is waiting on a readback.
    248   ReadbackRequest* readback_request_on_impl_thread_;
    249 
    250   // Set when the main thread is waiting on a commit to complete.
    251   CompletionEvent* commit_completion_event_on_impl_thread_;
    252 
    253   // Set when the main thread is waiting on a pending tree activation.
    254   CompletionEvent* completion_event_for_commit_held_on_tree_activation_;
    255 
    256   // Set when the main thread is waiting on layers to be drawn.
    257   CompletionEvent* texture_acquisition_completion_event_on_impl_thread_;
    258 
    259   scoped_ptr<ResourceUpdateController>
    260       current_resource_update_controller_on_impl_thread_;
    261 
    262   // Set when the next draw should post DidCommitAndDrawFrame to the main
    263   // thread.
    264   bool next_frame_is_newly_committed_frame_on_impl_thread_;
    265 
    266   bool throttle_frame_production_;
    267   bool begin_impl_frame_scheduling_enabled_;
    268   bool using_synchronous_renderer_compositor_;
    269 
    270   bool inside_draw_;
    271 
    272   bool can_cancel_commit_;
    273 
    274   bool defer_commits_;
    275   bool input_throttled_until_commit_;
    276   scoped_ptr<BeginMainFrameAndCommitState> pending_deferred_commit_;
    277 
    278   base::TimeTicks smoothness_takes_priority_expiration_time_;
    279   bool renew_tree_priority_on_impl_thread_pending_;
    280 
    281   RollingTimeDeltaHistory draw_duration_history_;
    282   RollingTimeDeltaHistory begin_main_frame_to_commit_duration_history_;
    283   RollingTimeDeltaHistory commit_to_activate_duration_history_;
    284 
    285   // Used for computing samples added to
    286   // begin_main_frame_to_commit_duration_history_ and
    287   // activation_duration_history_.
    288   base::TimeTicks begin_main_frame_sent_time_;
    289   base::TimeTicks commit_complete_time_;
    290 
    291   base::WeakPtr<ThreadProxy> main_thread_weak_ptr_;
    292   base::WeakPtrFactory<ThreadProxy> weak_factory_on_impl_thread_;
    293   base::WeakPtrFactory<ThreadProxy> weak_factory_;
    294 
    295   const int layer_tree_host_id_;
    296 
    297   DISALLOW_COPY_AND_ASSIGN(ThreadProxy);
    298 };
    299 
    300 }  // namespace cc
    301 
    302 #endif  // CC_TREES_THREAD_PROXY_H_
    303