src/cc/trees/layer_tree_impl.h

   1 // Copyright 2012 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_LAYER_TREE_IMPL_H_
   6 #define CC_TREES_LAYER_TREE_IMPL_H_
   7
   8 #include <list>
   9 #include <set>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/containers/hash_tables.h"
  14 #include "base/values.h"
  15 #include "cc/base/scoped_ptr_vector.h"
  16 #include "cc/base/swap_promise.h"
  17 #include "cc/layers/layer_impl.h"
  18 #include "cc/output/renderer.h"
  19 #include "cc/resources/ui_resource_client.h"
  20
  21 #if defined(COMPILER_GCC)
  22 namespace BASE_HASH_NAMESPACE {
  23 template<>
  24 struct hash<cc::LayerImpl*> {
  25   size_t operator()(cc::LayerImpl* ptr) const {
  26     return hash<size_t>()(reinterpret_cast<size_t>(ptr));
  27   }
  28 };
  29 }  // namespace BASE_HASH_NAMESPACE
  30 #endif  // COMPILER
  31
  32 namespace base {
  33 namespace debug {
  34 class TracedValue;
  35 }
  36 }
  37
  38 namespace cc {
  39
  40 class ContextProvider;
  41 class DebugRectHistory;
  42 class FrameRateCounter;
  43 class HeadsUpDisplayLayerImpl;
  44 class LayerScrollOffsetDelegateProxy;
  45 class LayerTreeDebugState;
  46 class LayerTreeHostImpl;
  47 class LayerTreeImpl;
  48 class LayerTreeSettings;
  49 class MemoryHistory;
  50 class OutputSurface;
  51 class PageScaleAnimation;
  52 class PaintTimeCounter;
  53 class PictureLayerImpl;
  54 class Proxy;
  55 class ResourceProvider;
  56 class TileManager;
  57 class UIResourceRequest;
  58 struct RendererCapabilities;
  59 struct SelectionHandle;
  60
  61 typedef std::list<UIResourceRequest> UIResourceRequestQueue;
  62
  63 class CC_EXPORT LayerTreeImpl {
  64  public:
  65   static scoped_ptr<LayerTreeImpl> create(
  66       LayerTreeHostImpl* layer_tree_host_impl) {
  67     return make_scoped_ptr(new LayerTreeImpl(layer_tree_host_impl));
  68   }
  69   virtual ~LayerTreeImpl();
  70
  71   void Shutdown();
  72   void ReleaseResources();
  73
  74   // Methods called by the layer tree that pass-through or access LTHI.
  75   // ---------------------------------------------------------------------------
  76   const LayerTreeSettings& settings() const;
  77   const RendererCapabilitiesImpl& GetRendererCapabilities() const;
  78   ContextProvider* context_provider() const;
  79   OutputSurface* output_surface() const;
  80   ResourceProvider* resource_provider() const;
  81   TileManager* tile_manager() const;
  82   FrameRateCounter* frame_rate_counter() const;
  83   PaintTimeCounter* paint_time_counter() const;
  84   MemoryHistory* memory_history() const;
  85   gfx::Size device_viewport_size() const;
  86   bool IsActiveTree() const;
  87   bool IsPendingTree() const;
  88   bool IsRecycleTree() const;
  89   LayerImpl* FindActiveTreeLayerById(int id);
  90   LayerImpl* FindPendingTreeLayerById(int id);
  91   LayerImpl* FindRecycleTreeLayerById(int id);
  92   bool PinchGestureActive() const;
  93   BeginFrameArgs CurrentBeginFrameArgs() const;
  94   base::TimeDelta begin_impl_frame_interval() const;
  95   void SetNeedsCommit();
  96   gfx::Rect DeviceViewport() const;
  97   gfx::Size DrawViewportSize() const;
  98   const gfx::Rect ViewportRectForTilePriority() const;
  99   scoped_ptr<ScrollbarAnimationController> CreateScrollbarAnimationController(
 100       LayerImpl* scrolling_layer);
 101   void DidAnimateScrollOffset();
 102   void InputScrollAnimationFinished();
 103   bool use_gpu_rasterization() const;
 104   bool create_low_res_tiling() const;
 105   BlockingTaskRunner* BlockingMainThreadTaskRunner() const;
 106
 107   // Tree specific methods exposed to layer-impl tree.
 108   // ---------------------------------------------------------------------------
 109   void SetNeedsRedraw();
 110
 111   // TODO(nduca): These are implemented in cc files temporarily, but will become
 112   // trivial accessors in a followup patch.
 113   const LayerTreeDebugState& debug_state() const;
 114   float device_scale_factor() const;
 115   DebugRectHistory* debug_rect_history() const;
 116   void GetAllTilesForTracing(std::set<const Tile*>* tiles) const;
 117   void AsValueInto(base::debug::TracedValue* dict) const;
 118
 119   // Other public methods
 120   // ---------------------------------------------------------------------------
 121   LayerImpl* root_layer() const { return root_layer_.get(); }
 122   void SetRootLayer(scoped_ptr<LayerImpl>);
 123   scoped_ptr<LayerImpl> DetachLayerTree();
 124
 125   void PushPropertiesTo(LayerTreeImpl* tree_impl);
 126
 127   int source_frame_number() const { return source_frame_number_; }
 128   void set_source_frame_number(int frame_number) {
 129     source_frame_number_ = frame_number;
 130   }
 131
 132   HeadsUpDisplayLayerImpl* hud_layer() { return hud_layer_; }
 133   void set_hud_layer(HeadsUpDisplayLayerImpl* layer_impl) {
 134     hud_layer_ = layer_impl;
 135   }
 136
 137   LayerImpl* InnerViewportScrollLayer() const;
 138   // This function may return NULL, it is the caller's responsibility to check.
 139   LayerImpl* OuterViewportScrollLayer() const;
 140   gfx::Vector2dF TotalScrollOffset() const;
 141   gfx::Vector2dF TotalMaxScrollOffset() const;
 142   gfx::Vector2dF TotalScrollDelta() const;
 143
 144   LayerImpl* InnerViewportContainerLayer() const;
 145   LayerImpl* CurrentlyScrollingLayer() const;
 146   void SetCurrentlyScrollingLayer(LayerImpl* layer);
 147   void ClearCurrentlyScrollingLayer();
 148
 149   void SetViewportLayersFromIds(int page_scale_layer_id,
 150                                 int inner_viewport_scroll_layer_id,
 151                                 int outer_viewport_scroll_layer_id);
 152   void ClearViewportLayers();
 153   LayerImpl* page_scale_layer() { return page_scale_layer_; }
 154   void ApplySentScrollAndScaleDeltasFromAbortedCommit();
 155   void ApplyScrollDeltasSinceBeginMainFrame();
 156
 157   SkColor background_color() const { return background_color_; }
 158   void set_background_color(SkColor color) { background_color_ = color; }
 159
 160   bool has_transparent_background() const {
 161     return has_transparent_background_;
 162   }
 163   void set_has_transparent_background(bool transparent) {
 164     has_transparent_background_ = transparent;
 165   }
 166
 167   void SetPageScaleFactorAndLimits(float page_scale_factor,
 168       float min_page_scale_factor, float max_page_scale_factor);
 169   void SetPageScaleDelta(float delta);
 170   void SetPageScaleValues(float page_scale_factor,
 171       float min_page_scale_factor, float max_page_scale_factor,
 172       float page_scale_delta);
 173   float total_page_scale_factor() const {
 174     return page_scale_factor_ * page_scale_delta_;
 175   }
 176   float page_scale_factor() const { return page_scale_factor_; }
 177   float min_page_scale_factor() const { return min_page_scale_factor_; }
 178   float max_page_scale_factor() const { return max_page_scale_factor_; }
 179   float page_scale_delta() const  { return page_scale_delta_; }
 180   void set_sent_page_scale_delta(float delta) {
 181     sent_page_scale_delta_ = delta;
 182   }
 183   float sent_page_scale_delta() const { return sent_page_scale_delta_; }
 184
 185   // Updates draw properties and render surface layer list, as well as tile
 186   // priorities. Returns false if it was unable to update.
 187   bool UpdateDrawProperties();
 188
 189   void set_needs_update_draw_properties() {
 190     needs_update_draw_properties_ = true;
 191   }
 192   bool needs_update_draw_properties() const {
 193     return needs_update_draw_properties_;
 194   }
 195
 196   void set_needs_full_tree_sync(bool needs) { needs_full_tree_sync_ = needs; }
 197   bool needs_full_tree_sync() const { return needs_full_tree_sync_; }
 198
 199   void ForceRedrawNextActivation() { next_activation_forces_redraw_ = true; }
 200
 201   void set_has_ever_been_drawn(bool has_drawn) {
 202     has_ever_been_drawn_ = has_drawn;
 203   }
 204   bool has_ever_been_drawn() const { return has_ever_been_drawn_; }
 205
 206   void set_ui_resource_request_queue(const UIResourceRequestQueue& queue);
 207
 208   const LayerImplList& RenderSurfaceLayerList() const;
 209
 210   // These return the size of the root scrollable area and the size of
 211   // the user-visible scrolling viewport, in CSS layout coordinates.
 212   gfx::Size ScrollableSize() const;
 213   gfx::SizeF ScrollableViewportSize() const;
 214
 215   gfx::Rect RootScrollLayerDeviceViewportBounds() const;
 216
 217   LayerImpl* LayerById(int id);
 218
 219   // These should be called by LayerImpl's ctor/dtor.
 220   void RegisterLayer(LayerImpl* layer);
 221   void UnregisterLayer(LayerImpl* layer);
 222
 223   size_t NumLayers();
 224
 225   AnimationRegistrar* animationRegistrar() const;
 226
 227   void PushPersistedState(LayerTreeImpl* pending_tree);
 228
 229   void DidBecomeActive();
 230
 231   bool ContentsTexturesPurged() const;
 232   void SetContentsTexturesPurged();
 233   void ResetContentsTexturesPurged();
 234
 235   void SetRequiresHighResToDraw();
 236   void ResetRequiresHighResToDraw();
 237   bool RequiresHighResToDraw() const;
 238
 239   // Set on the active tree when the viewport size recently changed
 240   // and the active tree's size is now out of date.
 241   bool ViewportSizeInvalid() const;
 242   void SetViewportSizeInvalid();
 243   void ResetViewportSizeInvalid();
 244
 245   // Useful for debug assertions, probably shouldn't be used for anything else.
 246   Proxy* proxy() const;
 247
 248   void SetRootLayerScrollOffsetDelegate(
 249       LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate);
 250   void UpdateScrollOffsetDelegate();
 251   gfx::Vector2dF GetDelegatedScrollOffset(LayerImpl* layer);
 252
 253   // Call this function when you expect there to be a swap buffer.
 254   // See swap_promise.h for how to use SwapPromise.
 255   void QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise);
 256
 257   // Take the |new_swap_promise| and append it to |swap_promise_list_|.
 258   void PassSwapPromises(ScopedPtrVector<SwapPromise>* new_swap_promise);
 259   void FinishSwapPromises(CompositorFrameMetadata* metadata);
 260   void BreakSwapPromises(SwapPromise::DidNotSwapReason reason);
 261
 262   void DidModifyTilePriorities();
 263
 264   ResourceProvider::ResourceId ResourceIdForUIResource(UIResourceId uid) const;
 265   void ProcessUIResourceRequestQueue();
 266
 267   bool IsUIResourceOpaque(UIResourceId uid) const;
 268
 269   void AddLayerWithCopyOutputRequest(LayerImpl* layer);
 270   void RemoveLayerWithCopyOutputRequest(LayerImpl* layer);
 271   const std::vector<LayerImpl*>& LayersWithCopyOutputRequest() const;
 272
 273   int current_render_surface_list_id() const {
 274     return render_surface_layer_list_id_;
 275   }
 276
 277   LayerImpl* FindFirstScrollingLayerThatIsHitByPoint(
 278       const gfx::PointF& screen_space_point);
 279
 280   LayerImpl* FindLayerThatIsHitByPoint(const gfx::PointF& screen_space_point);
 281
 282   LayerImpl* FindLayerThatIsHitByPointInTouchHandlerRegion(
 283       const gfx::PointF& screen_space_point);
 284
 285   void RegisterSelection(const LayerSelectionBound& start,
 286                          const LayerSelectionBound& end);
 287
 288   // Compute the current selection handle location and visbility with respect to
 289   // the viewport.
 290   void GetViewportSelection(ViewportSelectionBound* start,
 291                             ViewportSelectionBound* end);
 292
 293   void RegisterPictureLayerImpl(PictureLayerImpl* layer);
 294   void UnregisterPictureLayerImpl(PictureLayerImpl* layer);
 295
 296   void set_top_controls_layout_height(float height) {
 297     top_controls_layout_height_ = height;
 298   }
 299   void set_top_controls_content_offset(float offset) {
 300     top_controls_content_offset_ = offset;
 301   }
 302   void set_top_controls_delta(float delta) {
 303     top_controls_delta_ = delta;
 304   }
 305   void set_sent_top_controls_delta(float sent_delta) {
 306     sent_top_controls_delta_ = sent_delta;
 307   }
 308
 309   float top_controls_layout_height() const {
 310     return top_controls_layout_height_;
 311   }
 312   float top_controls_content_offset() const {
 313     return top_controls_content_offset_;
 314   }
 315   float top_controls_delta() const {
 316     return top_controls_delta_;
 317   }
 318   float sent_top_controls_delta() const {
 319     return sent_top_controls_delta_;
 320   }
 321   float total_top_controls_content_offset() const {
 322     return top_controls_content_offset_ + top_controls_delta_;
 323   }
 324
 325   void SetPageScaleAnimation(const gfx::Vector2d& target_offset,
 326                              bool anchor_point,
 327                              float page_scale,
 328                              base::TimeDelta duration);
 329   scoped_ptr<PageScaleAnimation> TakePageScaleAnimation();
 330
 331  protected:
 332   explicit LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl);
 333   void ReleaseResourcesRecursive(LayerImpl* current);
 334
 335   LayerTreeHostImpl* layer_tree_host_impl_;
 336   int source_frame_number_;
 337   scoped_ptr<LayerImpl> root_layer_;
 338   HeadsUpDisplayLayerImpl* hud_layer_;
 339   LayerImpl* currently_scrolling_layer_;
 340   LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
 341   scoped_ptr<LayerScrollOffsetDelegateProxy>
 342       inner_viewport_scroll_delegate_proxy_;
 343   scoped_ptr<LayerScrollOffsetDelegateProxy>
 344       outer_viewport_scroll_delegate_proxy_;
 345   SkColor background_color_;
 346   bool has_transparent_background_;
 347
 348   LayerImpl* page_scale_layer_;
 349   LayerImpl* inner_viewport_scroll_layer_;
 350   LayerImpl* outer_viewport_scroll_layer_;
 351
 352   LayerSelectionBound selection_start_;
 353   LayerSelectionBound selection_end_;
 354
 355   float page_scale_factor_;
 356   float page_scale_delta_;
 357   float sent_page_scale_delta_;
 358   float min_page_scale_factor_;
 359   float max_page_scale_factor_;
 360
 361   typedef base::hash_map<int, LayerImpl*> LayerIdMap;
 362   LayerIdMap layer_id_map_;
 363
 364   std::vector<LayerImpl*> layers_with_copy_output_request_;
 365
 366   // Persisted state for non-impl-side-painting.
 367   int scrolling_layer_id_from_previous_tree_;
 368
 369   // List of visible layers for the most recently prepared frame.
 370   LayerImplList render_surface_layer_list_;
 371
 372   bool contents_textures_purged_;
 373   bool requires_high_res_to_draw_;
 374   bool viewport_size_invalid_;
 375   bool needs_update_draw_properties_;
 376
 377   // In impl-side painting mode, this is true when the tree may contain
 378   // structural differences relative to the active tree.
 379   bool needs_full_tree_sync_;
 380
 381   bool next_activation_forces_redraw_;
 382
 383   bool has_ever_been_drawn_;
 384
 385   ScopedPtrVector<SwapPromise> swap_promise_list_;
 386
 387   UIResourceRequestQueue ui_resource_request_queue_;
 388
 389   int render_surface_layer_list_id_;
 390
 391   // The top controls content offset at the time of the last layout (and thus,
 392   // viewport resize) in Blink. i.e. How much the viewport was shrunk by the top
 393   // controls.
 394   float top_controls_layout_height_;
 395
 396   // The up-to-date content offset of the top controls, i.e. the amount that the
 397   // web contents have been shifted down from the top of the device viewport.
 398   float top_controls_content_offset_;
 399   float top_controls_delta_;
 400   float sent_top_controls_delta_;
 401
 402   scoped_ptr<PageScaleAnimation> page_scale_animation_;
 403
 404  private:
 405   DISALLOW_COPY_AND_ASSIGN(LayerTreeImpl);
 406 };
 407
 408 }  // namespace cc
 409
 410 #endif  // CC_TREES_LAYER_TREE_IMPL_H_