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 <string>
10#include <vector>
11
12#include "base/containers/hash_tables.h"
13#include "base/values.h"
14#include "cc/layers/layer_impl.h"
15#include "cc/resources/ui_resource_client.h"
16#include "ui/base/latency_info.h"
17
18#if defined(COMPILER_GCC)
19namespace BASE_HASH_NAMESPACE {
20template<>
21struct hash<cc::LayerImpl*> {
22  size_t operator()(cc::LayerImpl* ptr) const {
23    return hash<size_t>()(reinterpret_cast<size_t>(ptr));
24  }
25};
26}  // namespace BASE_HASH_NAMESPACE
27#endif  // COMPILER
28
29namespace cc {
30
31class DebugRectHistory;
32class FrameRateCounter;
33class HeadsUpDisplayLayerImpl;
34class LayerTreeDebugState;
35class LayerTreeHostImpl;
36class LayerTreeImpl;
37class LayerTreeSettings;
38class MemoryHistory;
39class OutputSurface;
40class PaintTimeCounter;
41class Proxy;
42class ResourceProvider;
43class TileManager;
44struct RendererCapabilities;
45struct UIResourceRequest;
46
47typedef std::list<UIResourceRequest> UIResourceRequestQueue;
48
49class CC_EXPORT LayerTreeImpl {
50 public:
51  static scoped_ptr<LayerTreeImpl> create(
52      LayerTreeHostImpl* layer_tree_host_impl) {
53    return make_scoped_ptr(new LayerTreeImpl(layer_tree_host_impl));
54  }
55  virtual ~LayerTreeImpl();
56
57  // Methods called by the layer tree that pass-through or access LTHI.
58  // ---------------------------------------------------------------------------
59  const LayerTreeSettings& settings() const;
60  const RendererCapabilities& GetRendererCapabilities() const;
61  OutputSurface* output_surface() const;
62  ResourceProvider* resource_provider() const;
63  TileManager* tile_manager() const;
64  FrameRateCounter* frame_rate_counter() const;
65  PaintTimeCounter* paint_time_counter() const;
66  MemoryHistory* memory_history() const;
67  bool IsActiveTree() const;
68  bool IsPendingTree() const;
69  bool IsRecycleTree() const;
70  LayerImpl* FindActiveTreeLayerById(int id);
71  LayerImpl* FindPendingTreeLayerById(int id);
72  int MaxTextureSize() const;
73  bool PinchGestureActive() const;
74  base::TimeTicks CurrentFrameTimeTicks() const;
75  base::Time CurrentFrameTime() const;
76  base::TimeTicks CurrentPhysicalTimeTicks() const;
77  void SetNeedsCommit();
78  gfx::Rect DeviceViewport() const;
79  bool DeviceViewportValidForTileManagement() const;
80
81  // Tree specific methods exposed to layer-impl tree.
82  // ---------------------------------------------------------------------------
83  void SetNeedsRedraw();
84
85  // TODO(nduca): These are implemented in cc files temporarily, but will become
86  // trivial accessors in a followup patch.
87  const LayerTreeDebugState& debug_state() const;
88  float device_scale_factor() const;
89  DebugRectHistory* debug_rect_history() const;
90  scoped_ptr<base::Value> AsValue() const;
91
92  // Other public methods
93  // ---------------------------------------------------------------------------
94  LayerImpl* root_layer() const { return root_layer_.get(); }
95  void SetRootLayer(scoped_ptr<LayerImpl>);
96  scoped_ptr<LayerImpl> DetachLayerTree();
97
98  void PushPropertiesTo(LayerTreeImpl* tree_impl);
99
100  int source_frame_number() const { return source_frame_number_; }
101  void set_source_frame_number(int frame_number) {
102    source_frame_number_ = frame_number;
103  }
104
105  HeadsUpDisplayLayerImpl* hud_layer() { return hud_layer_; }
106  void set_hud_layer(HeadsUpDisplayLayerImpl* layer_impl) {
107    hud_layer_ = layer_impl;
108  }
109
110  LayerImpl* RootScrollLayer() const;
111  LayerImpl* RootContainerLayer() const;
112  LayerImpl* CurrentlyScrollingLayer() const;
113  void SetCurrentlyScrollingLayer(LayerImpl* layer);
114  void ClearCurrentlyScrollingLayer();
115
116  void FindRootScrollLayer();
117  void UpdateMaxScrollOffset();
118  void ApplySentScrollAndScaleDeltas();
119
120  SkColor background_color() const { return background_color_; }
121  void set_background_color(SkColor color) { background_color_ = color; }
122
123  bool has_transparent_background() const {
124    return has_transparent_background_;
125  }
126  void set_has_transparent_background(bool transparent) {
127    has_transparent_background_ = transparent;
128  }
129
130  void SetPageScaleFactorAndLimits(float page_scale_factor,
131      float min_page_scale_factor, float max_page_scale_factor);
132  void SetPageScaleDelta(float delta);
133  float total_page_scale_factor() const {
134    return page_scale_factor_ * page_scale_delta_;
135  }
136  float page_scale_factor() const { return page_scale_factor_; }
137  float min_page_scale_factor() const { return min_page_scale_factor_; }
138  float max_page_scale_factor() const { return max_page_scale_factor_; }
139  float page_scale_delta() const  { return page_scale_delta_; }
140  void set_sent_page_scale_delta(float delta) {
141    sent_page_scale_delta_ = delta;
142  }
143  float sent_page_scale_delta() const { return sent_page_scale_delta_; }
144
145  // Updates draw properties and render surface layer list, as well as tile
146  // priorities.
147  void UpdateDrawProperties();
148
149  void set_needs_update_draw_properties() {
150    needs_update_draw_properties_ = true;
151  }
152  bool needs_update_draw_properties() const {
153    return needs_update_draw_properties_;
154  }
155
156  void set_needs_full_tree_sync(bool needs) { needs_full_tree_sync_ = needs; }
157  bool needs_full_tree_sync() const { return needs_full_tree_sync_; }
158
159  void set_ui_resource_request_queue(const UIResourceRequestQueue& queue);
160
161  const LayerImplList& RenderSurfaceLayerList() const;
162
163  // These return the size of the root scrollable area and the size of
164  // the user-visible scrolling viewport, in CSS layout coordinates.
165  gfx::Size ScrollableSize() const;
166  gfx::SizeF ScrollableViewportSize() const;
167
168  LayerImpl* LayerById(int id);
169
170  // These should be called by LayerImpl's ctor/dtor.
171  void RegisterLayer(LayerImpl* layer);
172  void UnregisterLayer(LayerImpl* layer);
173
174  AnimationRegistrar* animationRegistrar() const;
175
176  void PushPersistedState(LayerTreeImpl* pending_tree);
177
178  void DidBecomeActive();
179
180  bool ContentsTexturesPurged() const;
181  void SetContentsTexturesPurged();
182  void ResetContentsTexturesPurged();
183
184  // Set on the active tree when the viewport size recently changed
185  // and the active tree's size is now out of date.
186  bool ViewportSizeInvalid() const;
187  void SetViewportSizeInvalid();
188  void ResetViewportSizeInvalid();
189
190  // Useful for debug assertions, probably shouldn't be used for anything else.
191  Proxy* proxy() const;
192
193  void SetRootLayerScrollOffsetDelegate(
194      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate);
195
196  void SetLatencyInfo(const ui::LatencyInfo& latency_info);
197  const ui::LatencyInfo& GetLatencyInfo();
198  void ClearLatencyInfo();
199
200  void WillModifyTilePriorities();
201
202  ResourceProvider::ResourceId ResourceIdForUIResource(UIResourceId uid) const;
203  void ProcessUIResourceRequestQueue();
204
205  void AddLayerWithCopyOutputRequest(LayerImpl* layer);
206  void RemoveLayerWithCopyOutputRequest(LayerImpl* layer);
207  const std::vector<LayerImpl*> LayersWithCopyOutputRequest() const;
208
209 protected:
210  explicit LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl);
211
212  void UpdateSolidColorScrollbars();
213
214  void UpdateRootScrollLayerSizeDelta();
215
216  LayerTreeHostImpl* layer_tree_host_impl_;
217  int source_frame_number_;
218  scoped_ptr<LayerImpl> root_layer_;
219  HeadsUpDisplayLayerImpl* hud_layer_;
220  LayerImpl* root_scroll_layer_;
221  LayerImpl* currently_scrolling_layer_;
222  LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
223  SkColor background_color_;
224  bool has_transparent_background_;
225
226  float page_scale_factor_;
227  float page_scale_delta_;
228  float sent_page_scale_delta_;
229  float min_page_scale_factor_;
230  float max_page_scale_factor_;
231
232  typedef base::hash_map<int, LayerImpl*> LayerIdMap;
233  LayerIdMap layer_id_map_;
234
235  std::vector<LayerImpl*> layers_with_copy_output_request_;
236
237  // Persisted state for non-impl-side-painting.
238  int scrolling_layer_id_from_previous_tree_;
239
240  // List of visible layers for the most recently prepared frame. Used for
241  // rendering and input event hit testing.
242  LayerImplList render_surface_layer_list_;
243
244  bool contents_textures_purged_;
245  bool viewport_size_invalid_;
246  bool needs_update_draw_properties_;
247
248  // In impl-side painting mode, this is true when the tree may contain
249  // structural differences relative to the active tree.
250  bool needs_full_tree_sync_;
251
252  ui::LatencyInfo latency_info_;
253
254  UIResourceRequestQueue ui_resource_request_queue_;
255
256 private:
257  DISALLOW_COPY_AND_ASSIGN(LayerTreeImpl);
258};
259
260}  // namespace cc
261
262#endif  // CC_TREES_LAYER_TREE_IMPL_H_
263