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_LAYER_TREE_HOST_IMPL_H_
6#define CC_TREES_LAYER_TREE_HOST_IMPL_H_
7
8#include <list>
9#include <set>
10#include <string>
11#include <vector>
12
13#include "base/basictypes.h"
14#include "base/containers/hash_tables.h"
15#include "base/memory/scoped_ptr.h"
16#include "base/time/time.h"
17#include "cc/animation/animation_events.h"
18#include "cc/animation/animation_registrar.h"
19#include "cc/animation/scrollbar_animation_controller.h"
20#include "cc/base/cc_export.h"
21#include "cc/debug/micro_benchmark_controller_impl.h"
22#include "cc/input/input_handler.h"
23#include "cc/input/layer_scroll_offset_delegate.h"
24#include "cc/input/top_controls_manager_client.h"
25#include "cc/layers/layer_lists.h"
26#include "cc/layers/render_pass_sink.h"
27#include "cc/output/begin_frame_args.h"
28#include "cc/output/managed_memory_policy.h"
29#include "cc/output/output_surface_client.h"
30#include "cc/output/renderer.h"
31#include "cc/quads/render_pass.h"
32#include "cc/resources/resource_provider.h"
33#include "cc/resources/tile_manager.h"
34#include "cc/scheduler/draw_result.h"
35#include "skia/ext/refptr.h"
36#include "third_party/skia/include/core/SkColor.h"
37#include "ui/gfx/rect.h"
38
39namespace cc {
40
41class CompletionEvent;
42class CompositorFrameMetadata;
43class DebugRectHistory;
44class EvictionTilePriorityQueue;
45class FrameRateCounter;
46class LayerImpl;
47class LayerTreeHostImplTimeSourceAdapter;
48class LayerTreeImpl;
49class MemoryHistory;
50class PageScaleAnimation;
51class PaintTimeCounter;
52class PictureLayerImpl;
53class RasterTilePriorityQueue;
54class RasterWorkerPool;
55class RenderPassDrawQuad;
56class RenderingStatsInstrumentation;
57class ResourcePool;
58class ScrollbarLayerImplBase;
59class TextureMailboxDeleter;
60class TopControlsManager;
61class UIResourceBitmap;
62class UIResourceRequest;
63struct RendererCapabilitiesImpl;
64
65// LayerTreeHost->Proxy callback interface.
66class LayerTreeHostImplClient {
67 public:
68  virtual void UpdateRendererCapabilitiesOnImplThread() = 0;
69  virtual void DidLoseOutputSurfaceOnImplThread() = 0;
70  virtual void CommitVSyncParameters(base::TimeTicks timebase,
71                                     base::TimeDelta interval) = 0;
72  virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) = 0;
73  virtual void SetMaxSwapsPendingOnImplThread(int max) = 0;
74  virtual void DidSwapBuffersOnImplThread() = 0;
75  virtual void DidSwapBuffersCompleteOnImplThread() = 0;
76  virtual void BeginFrame(const BeginFrameArgs& args) = 0;
77  virtual void OnCanDrawStateChanged(bool can_draw) = 0;
78  virtual void NotifyReadyToActivate() = 0;
79  // Please call these 3 functions through
80  // LayerTreeHostImpl's SetNeedsRedraw(), SetNeedsRedrawRect() and
81  // SetNeedsAnimate().
82  virtual void SetNeedsRedrawOnImplThread() = 0;
83  virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) = 0;
84  virtual void SetNeedsAnimateOnImplThread() = 0;
85  virtual void DidInitializeVisibleTileOnImplThread() = 0;
86  virtual void SetNeedsCommitOnImplThread() = 0;
87  virtual void SetNeedsManageTilesOnImplThread() = 0;
88  virtual void PostAnimationEventsToMainThreadOnImplThread(
89      scoped_ptr<AnimationEventsVector> events) = 0;
90  // Returns true if resources were deleted by this call.
91  virtual bool ReduceContentsTextureMemoryOnImplThread(
92      size_t limit_bytes,
93      int priority_cutoff) = 0;
94  virtual bool IsInsideDraw() = 0;
95  virtual void RenewTreePriority() = 0;
96  virtual void PostDelayedScrollbarFadeOnImplThread(
97      const base::Closure& start_fade,
98      base::TimeDelta delay) = 0;
99  virtual void DidActivateSyncTree() = 0;
100  virtual void DidManageTiles() = 0;
101
102 protected:
103  virtual ~LayerTreeHostImplClient() {}
104};
105
106// LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
107// state.
108class CC_EXPORT LayerTreeHostImpl
109    : public InputHandler,
110      public RendererClient,
111      public TileManagerClient,
112      public OutputSurfaceClient,
113      public TopControlsManagerClient,
114      public ScrollbarAnimationControllerClient,
115      public base::SupportsWeakPtr<LayerTreeHostImpl> {
116 public:
117  static scoped_ptr<LayerTreeHostImpl> Create(
118      const LayerTreeSettings& settings,
119      LayerTreeHostImplClient* client,
120      Proxy* proxy,
121      RenderingStatsInstrumentation* rendering_stats_instrumentation,
122      SharedBitmapManager* manager,
123      int id);
124  virtual ~LayerTreeHostImpl();
125
126  // InputHandler implementation
127  virtual void BindToClient(InputHandlerClient* client) OVERRIDE;
128  virtual InputHandler::ScrollStatus ScrollBegin(
129      const gfx::Point& viewport_point,
130      InputHandler::ScrollInputType type) OVERRIDE;
131  virtual InputHandler::ScrollStatus ScrollAnimated(
132      const gfx::Point& viewport_point,
133      const gfx::Vector2dF& scroll_delta) OVERRIDE;
134  virtual bool ScrollBy(const gfx::Point& viewport_point,
135                        const gfx::Vector2dF& scroll_delta) OVERRIDE;
136  virtual bool ScrollVerticallyByPage(const gfx::Point& viewport_point,
137                                      ScrollDirection direction) OVERRIDE;
138  virtual void SetRootLayerScrollOffsetDelegate(
139      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) OVERRIDE;
140  virtual void OnRootLayerDelegatedScrollOffsetChanged() OVERRIDE;
141  virtual void ScrollEnd() OVERRIDE;
142  virtual InputHandler::ScrollStatus FlingScrollBegin() OVERRIDE;
143  virtual void MouseMoveAt(const gfx::Point& viewport_point) OVERRIDE;
144  virtual void PinchGestureBegin() OVERRIDE;
145  virtual void PinchGestureUpdate(float magnify_delta,
146                                  const gfx::Point& anchor) OVERRIDE;
147  virtual void PinchGestureEnd() OVERRIDE;
148  virtual void SetNeedsAnimate() OVERRIDE;
149  virtual bool IsCurrentlyScrollingLayerAt(
150      const gfx::Point& viewport_point,
151      InputHandler::ScrollInputType type) OVERRIDE;
152  virtual bool HaveTouchEventHandlersAt(
153      const gfx::Point& viewport_port) OVERRIDE;
154  virtual scoped_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
155      ui::LatencyInfo* latency) OVERRIDE;
156
157  // TopControlsManagerClient implementation.
158  virtual void SetControlsTopOffset(float offset) OVERRIDE;
159  virtual float ControlsTopOffset() const OVERRIDE;
160  virtual void DidChangeTopControlsPosition() OVERRIDE;
161  virtual bool HaveRootScrollLayer() const OVERRIDE;
162
163  struct CC_EXPORT FrameData : public RenderPassSink {
164    FrameData();
165    virtual ~FrameData();
166    void AsValueInto(base::debug::TracedValue* value) const;
167
168    std::vector<gfx::Rect> occluding_screen_space_rects;
169    std::vector<gfx::Rect> non_occluding_screen_space_rects;
170    RenderPassList render_passes;
171    RenderPassIdHashMap render_passes_by_id;
172    const LayerImplList* render_surface_layer_list;
173    LayerImplList will_draw_layers;
174    bool contains_incomplete_tile;
175    bool has_no_damage;
176
177    // RenderPassSink implementation.
178    virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) OVERRIDE;
179  };
180
181  virtual void BeginMainFrameAborted(bool did_handle);
182  virtual void BeginCommit();
183  virtual void CommitComplete();
184  virtual void Animate(base::TimeTicks monotonic_time);
185  virtual void UpdateAnimationState(bool start_ready_animations);
186  void ActivateAnimations();
187  void MainThreadHasStoppedFlinging();
188  void UpdateBackgroundAnimateTicking(bool should_background_tick);
189  void DidAnimateScrollOffset();
190  void SetViewportDamage(const gfx::Rect& damage_rect);
191
192  virtual void ManageTiles();
193
194  // Returns DRAW_SUCCESS unless problems occured preparing the frame, and we
195  // should try to avoid displaying the frame. If PrepareToDraw is called,
196  // DidDrawAllLayers must also be called, regardless of whether DrawLayers is
197  // called between the two.
198  virtual DrawResult PrepareToDraw(FrameData* frame);
199  virtual void DrawLayers(FrameData* frame, base::TimeTicks frame_begin_time);
200  // Must be called if and only if PrepareToDraw was called.
201  void DidDrawAllLayers(const FrameData& frame);
202
203  const LayerTreeSettings& settings() const { return settings_; }
204
205  // Evict all textures by enforcing a memory policy with an allocation of 0.
206  void EvictTexturesForTesting();
207
208  // When blocking, this prevents client_->NotifyReadyToActivate() from being
209  // called. When disabled, it calls client_->NotifyReadyToActivate()
210  // immediately if any notifications had been blocked while blocking.
211  virtual void BlockNotifyReadyToActivateForTesting(bool block);
212
213  // This allows us to inject DidInitializeVisibleTile events for testing.
214  void DidInitializeVisibleTileForTesting();
215
216  // Resets all of the trees to an empty state.
217  void ResetTreesForTesting();
218  void ResetRecycleTreeForTesting();
219
220  DrawMode GetDrawMode() const;
221
222  // Viewport size in draw space: this size is in physical pixels and is used
223  // for draw properties, tilings, quads and render passes.
224  gfx::Size DrawViewportSize() const;
225
226  // Viewport rect in view space used for tiling prioritization.
227  const gfx::Rect ViewportRectForTilePriority() const;
228
229  // RendererClient implementation.
230  virtual void SetFullRootLayerDamage() OVERRIDE;
231
232  // TileManagerClient implementation.
233  virtual const std::vector<PictureLayerImpl*>& GetPictureLayers()
234      const OVERRIDE;
235  virtual void NotifyReadyToActivate() OVERRIDE;
236  virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE;
237  virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
238                                TreePriority tree_priority) OVERRIDE;
239  virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
240                                  TreePriority tree_priority) OVERRIDE;
241
242  // ScrollbarAnimationControllerClient implementation.
243  virtual void PostDelayedScrollbarFade(const base::Closure& start_fade,
244                                        base::TimeDelta delay) OVERRIDE;
245  virtual void SetNeedsScrollbarAnimationFrame() OVERRIDE;
246
247  // OutputSurfaceClient implementation.
248  virtual void DeferredInitialize() OVERRIDE;
249  virtual void ReleaseGL() OVERRIDE;
250  virtual void CommitVSyncParameters(base::TimeTicks timebase,
251                                     base::TimeDelta interval) OVERRIDE;
252  virtual void SetNeedsRedrawRect(const gfx::Rect& rect) OVERRIDE;
253  virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE;
254
255  virtual void SetExternalDrawConstraints(
256      const gfx::Transform& transform,
257      const gfx::Rect& viewport,
258      const gfx::Rect& clip,
259      const gfx::Rect& viewport_rect_for_tile_priority,
260      const gfx::Transform& transform_for_tile_priority,
261      bool resourceless_software_draw) OVERRIDE;
262  virtual void DidLoseOutputSurface() OVERRIDE;
263  virtual void DidSwapBuffers() OVERRIDE;
264  virtual void DidSwapBuffersComplete() OVERRIDE;
265  virtual void ReclaimResources(const CompositorFrameAck* ack) OVERRIDE;
266  virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
267  virtual void SetTreeActivationCallback(const base::Closure& callback)
268      OVERRIDE;
269
270  // Called from LayerTreeImpl.
271  void OnCanDrawStateChangedForTree();
272
273  // Implementation.
274  int id() const { return id_; }
275  bool CanDraw() const;
276  OutputSurface* output_surface() const { return output_surface_.get(); }
277
278  std::string LayerTreeAsJson() const;
279
280  void FinishAllRendering();
281  int SourceAnimationFrameNumber() const;
282
283  virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface);
284  TileManager* tile_manager() { return tile_manager_.get(); }
285  void SetUseGpuRasterization(bool use_gpu);
286  bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
287  bool create_low_res_tiling() const {
288    return settings_.create_low_res_tiling && !use_gpu_rasterization_;
289  }
290  ResourcePool* resource_pool() { return resource_pool_.get(); }
291  Renderer* renderer() { return renderer_.get(); }
292  const RendererCapabilitiesImpl& GetRendererCapabilities() const;
293
294  virtual bool SwapBuffers(const FrameData& frame);
295  void SetNeedsBeginFrame(bool enable);
296  virtual void WillBeginImplFrame(const BeginFrameArgs& args);
297  void DidModifyTilePriorities();
298
299  LayerTreeImpl* active_tree() { return active_tree_.get(); }
300  const LayerTreeImpl* active_tree() const { return active_tree_.get(); }
301  LayerTreeImpl* pending_tree() { return pending_tree_.get(); }
302  const LayerTreeImpl* pending_tree() const { return pending_tree_.get(); }
303  LayerTreeImpl* recycle_tree() { return recycle_tree_.get(); }
304  const LayerTreeImpl* recycle_tree() const { return recycle_tree_.get(); }
305  // Returns the tree LTH synchronizes with.
306  LayerTreeImpl* sync_tree() {
307    return pending_tree_ ? pending_tree_.get() : active_tree_.get();
308  }
309  virtual void CreatePendingTree();
310  virtual void UpdateVisibleTiles();
311  virtual void ActivateSyncTree();
312
313  // Shortcuts to layers on the active tree.
314  LayerImpl* RootLayer() const;
315  LayerImpl* InnerViewportScrollLayer() const;
316  LayerImpl* OuterViewportScrollLayer() const;
317  LayerImpl* CurrentlyScrollingLayer() const;
318
319  int scroll_layer_id_when_mouse_over_scrollbar() const {
320    return scroll_layer_id_when_mouse_over_scrollbar_;
321  }
322  bool scroll_affects_scroll_handler() const {
323    return scroll_affects_scroll_handler_;
324  }
325  void QueueSwapPromiseForMainThreadScrollUpdate(
326      scoped_ptr<SwapPromise> swap_promise);
327
328  bool IsActivelyScrolling() const;
329
330  virtual void SetVisible(bool visible);
331  bool visible() const { return visible_; }
332
333  void SetNeedsCommit() { client_->SetNeedsCommitOnImplThread(); }
334  void SetNeedsRedraw();
335
336  ManagedMemoryPolicy ActualManagedMemoryPolicy() const;
337
338  size_t memory_allocation_limit_bytes() const;
339  int memory_allocation_priority_cutoff() const;
340
341  void SetViewportSize(const gfx::Size& device_viewport_size);
342  gfx::Size device_viewport_size() const { return device_viewport_size_; }
343
344  void SetOverhangUIResource(UIResourceId overhang_ui_resource_id,
345                             const gfx::Size& overhang_ui_resource_size);
346
347  void SetDeviceScaleFactor(float device_scale_factor);
348  float device_scale_factor() const { return device_scale_factor_; }
349
350  const gfx::Transform& DrawTransform() const;
351
352  scoped_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
353
354  bool needs_animate_layers() const {
355    return !animation_registrar_->active_animation_controllers().empty();
356  }
357
358  void set_max_memory_needed_bytes(size_t bytes) {
359    max_memory_needed_bytes_ = bytes;
360  }
361
362  FrameRateCounter* fps_counter() {
363    return fps_counter_.get();
364  }
365  PaintTimeCounter* paint_time_counter() {
366    return paint_time_counter_.get();
367  }
368  MemoryHistory* memory_history() {
369    return memory_history_.get();
370  }
371  DebugRectHistory* debug_rect_history() {
372    return debug_rect_history_.get();
373  }
374  ResourceProvider* resource_provider() {
375    return resource_provider_.get();
376  }
377  TopControlsManager* top_controls_manager() {
378    return top_controls_manager_.get();
379  }
380  const GlobalStateThatImpactsTilePriority& global_tile_state() {
381    return global_tile_state_;
382  }
383
384  Proxy* proxy() const { return proxy_; }
385
386  AnimationRegistrar* animation_registrar() const {
387    return animation_registrar_.get();
388  }
389
390  void SetDebugState(const LayerTreeDebugState& new_debug_state);
391  const LayerTreeDebugState& debug_state() const { return debug_state_; }
392
393  class CC_EXPORT CullRenderPassesWithNoQuads {
394   public:
395    bool ShouldRemoveRenderPass(const RenderPassDrawQuad& quad,
396                                const FrameData& frame) const;
397
398    // Iterates in draw order, so that when a surface is removed, and its
399    // target becomes empty, then its target can be removed also.
400    size_t RenderPassListBegin(const RenderPassList& list) const { return 0; }
401    size_t RenderPassListEnd(const RenderPassList& list) const {
402      return list.size();
403    }
404    size_t RenderPassListNext(size_t it) const { return it + 1; }
405  };
406
407  template <typename RenderPassCuller>
408      static void RemoveRenderPasses(RenderPassCuller culler, FrameData* frame);
409
410  gfx::Vector2dF accumulated_root_overscroll() const {
411    return accumulated_root_overscroll_;
412  }
413
414  bool pinch_gesture_active() const { return pinch_gesture_active_; }
415
416  void SetTreePriority(TreePriority priority);
417
418  void UpdateCurrentBeginFrameArgs(const BeginFrameArgs& args);
419  void ResetCurrentBeginFrameArgsForNextFrame();
420  virtual BeginFrameArgs CurrentBeginFrameArgs() const;
421
422  // Expected time between two begin impl frame calls.
423  base::TimeDelta begin_impl_frame_interval() const {
424    return begin_impl_frame_interval_;
425  }
426
427  void AsValueInto(base::debug::TracedValue* value) const {
428    return AsValueWithFrameInto(NULL, value);
429  }
430  void AsValueWithFrameInto(FrameData* frame,
431                            base::debug::TracedValue* value) const;
432  scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
433  scoped_refptr<base::debug::ConvertableToTraceFormat> AsValueWithFrame(
434      FrameData* frame) const;
435  scoped_refptr<base::debug::ConvertableToTraceFormat> ActivationStateAsValue()
436      const;
437  void ActivationStateAsValueInto(base::debug::TracedValue* value) const;
438
439  bool page_scale_animation_active() const { return !!page_scale_animation_; }
440
441  virtual void CreateUIResource(UIResourceId uid,
442                                const UIResourceBitmap& bitmap);
443  // Deletes a UI resource.  May safely be called more than once.
444  virtual void DeleteUIResource(UIResourceId uid);
445  void EvictAllUIResources();
446  bool EvictedUIResourcesExist() const;
447
448  virtual ResourceProvider::ResourceId ResourceIdForUIResource(
449      UIResourceId uid) const;
450
451  virtual bool IsUIResourceOpaque(UIResourceId uid) const;
452
453  struct UIResourceData {
454    ResourceProvider::ResourceId resource_id;
455    gfx::Size size;
456    bool opaque;
457  };
458
459  void ScheduleMicroBenchmark(scoped_ptr<MicroBenchmarkImpl> benchmark);
460
461  CompositorFrameMetadata MakeCompositorFrameMetadata() const;
462  // Viewport rectangle and clip in nonflipped window space.  These rects
463  // should only be used by Renderer subclasses to populate glViewport/glClip
464  // and their software-mode equivalents.
465  gfx::Rect DeviceViewport() const;
466  gfx::Rect DeviceClip() const;
467
468  // When a SwapPromiseMonitor is created on the impl thread, it calls
469  // InsertSwapPromiseMonitor() to register itself with LayerTreeHostImpl.
470  // When the monitor is destroyed, it calls RemoveSwapPromiseMonitor()
471  // to unregister itself.
472  void InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor);
473  void RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor);
474
475  void RegisterPictureLayerImpl(PictureLayerImpl* layer);
476  void UnregisterPictureLayerImpl(PictureLayerImpl* layer);
477
478  void GetPictureLayerImplPairs(
479      std::vector<PictureLayerImpl::Pair>* layers) const;
480
481  void SetTopControlsLayoutHeight(float height);
482
483 protected:
484  LayerTreeHostImpl(
485      const LayerTreeSettings& settings,
486      LayerTreeHostImplClient* client,
487      Proxy* proxy,
488      RenderingStatsInstrumentation* rendering_stats_instrumentation,
489      SharedBitmapManager* manager,
490      int id);
491
492  void UpdateInnerViewportContainerSize();
493
494  // Virtual for testing.
495  virtual void AnimateLayers(base::TimeTicks monotonic_time);
496
497  // Virtual for testing.
498  virtual base::TimeDelta LowFrequencyAnimationInterval() const;
499
500  const AnimationRegistrar::AnimationControllerMap&
501      active_animation_controllers() const {
502    return animation_registrar_->active_animation_controllers();
503  }
504
505  bool manage_tiles_needed() const { return tile_priorities_dirty_; }
506
507  LayerTreeHostImplClient* client_;
508  Proxy* proxy_;
509
510 private:
511  void CreateAndSetRenderer();
512  void CreateAndSetTileManager();
513  void DestroyTileManager();
514  void ReleaseTreeResources();
515  void EnforceZeroBudget(bool zero_budget);
516
517  bool UsePendingTreeForSync() const;
518  bool UseZeroCopyRasterizer() const;
519  bool UseOneCopyRasterizer() const;
520
521  void ScrollViewportBy(gfx::Vector2dF scroll_delta);
522  void AnimatePageScale(base::TimeTicks monotonic_time);
523  void AnimateScrollbars(base::TimeTicks monotonic_time);
524  void AnimateTopControls(base::TimeTicks monotonic_time);
525
526  gfx::Vector2dF ScrollLayerWithViewportSpaceDelta(
527      LayerImpl* layer_impl,
528      float scale_from_viewport_to_screen_space,
529      const gfx::PointF& viewport_point,
530      const gfx::Vector2dF& viewport_delta);
531
532  void TrackDamageForAllSurfaces(
533      LayerImpl* root_draw_layer,
534      const LayerImplList& render_surface_layer_list);
535
536  void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy);
537
538  // This function should only be called from PrepareToDraw, as DidDrawAllLayers
539  // must be called if this helper function is called.  Returns DRAW_SUCCESS if
540  // the frame should be drawn.
541  DrawResult CalculateRenderPasses(FrameData* frame);
542
543  void ClearCurrentlyScrollingLayer();
544
545  bool HandleMouseOverScrollbar(LayerImpl* layer_impl,
546                                const gfx::PointF& device_viewport_point);
547
548  void AnimateScrollbarsRecursive(LayerImpl* layer,
549                                  base::TimeTicks time);
550
551  LayerImpl* FindScrollLayerForDeviceViewportPoint(
552      const gfx::PointF& device_viewport_point,
553      InputHandler::ScrollInputType type,
554      LayerImpl* layer_hit_by_point,
555      bool* scroll_on_main_thread,
556      bool* optional_has_ancestor_scroll_handler) const;
557  float DeviceSpaceDistanceToLayer(const gfx::PointF& device_viewport_point,
558                                   LayerImpl* layer_impl);
559  void StartScrollbarFadeRecursive(LayerImpl* layer);
560  void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy,
561                              bool zero_budget);
562  void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy);
563
564  void DidInitializeVisibleTile();
565
566  void MarkUIResourceNotEvicted(UIResourceId uid);
567
568  void NotifySwapPromiseMonitorsOfSetNeedsRedraw();
569  void NotifySwapPromiseMonitorsOfForwardingToMainThread();
570
571  typedef base::hash_map<UIResourceId, UIResourceData>
572      UIResourceMap;
573  UIResourceMap ui_resource_map_;
574
575  // Resources that were evicted by EvictAllUIResources. Resources are removed
576  // from this when they are touched by a create or destroy from the UI resource
577  // request queue.
578  std::set<UIResourceId> evicted_ui_resources_;
579
580  scoped_ptr<OutputSurface> output_surface_;
581
582  // |resource_provider_| and |tile_manager_| can be NULL, e.g. when using tile-
583  // free rendering - see OutputSurface::ForcedDrawToSoftwareDevice().
584  scoped_ptr<ResourceProvider> resource_provider_;
585  scoped_ptr<TileManager> tile_manager_;
586  bool use_gpu_rasterization_;
587  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
588  scoped_ptr<ResourcePool> resource_pool_;
589  scoped_ptr<ResourcePool> staging_resource_pool_;
590  scoped_ptr<Renderer> renderer_;
591
592  GlobalStateThatImpactsTilePriority global_tile_state_;
593
594  // Tree currently being drawn.
595  scoped_ptr<LayerTreeImpl> active_tree_;
596
597  // In impl-side painting mode, tree with possibly incomplete rasterized
598  // content. May be promoted to active by ActivatePendingTree().
599  scoped_ptr<LayerTreeImpl> pending_tree_;
600
601  // In impl-side painting mode, inert tree with layers that can be recycled
602  // by the next sync from the main thread.
603  scoped_ptr<LayerTreeImpl> recycle_tree_;
604
605  InputHandlerClient* input_handler_client_;
606  bool did_lock_scrolling_layer_;
607  bool should_bubble_scrolls_;
608  bool wheel_scrolling_;
609  bool scroll_affects_scroll_handler_;
610  int scroll_layer_id_when_mouse_over_scrollbar_;
611  ScopedPtrVector<SwapPromise> swap_promises_for_main_thread_scroll_update_;
612
613  bool tile_priorities_dirty_;
614
615  // The optional delegate for the root layer scroll offset.
616  LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
617  LayerTreeSettings settings_;
618  LayerTreeDebugState debug_state_;
619  bool visible_;
620  ManagedMemoryPolicy cached_managed_memory_policy_;
621
622  gfx::Vector2dF accumulated_root_overscroll_;
623
624  bool pinch_gesture_active_;
625  bool pinch_gesture_end_should_clear_scrolling_layer_;
626  gfx::Point previous_pinch_anchor_;
627
628  scoped_ptr<TopControlsManager> top_controls_manager_;
629
630  scoped_ptr<PageScaleAnimation> page_scale_animation_;
631
632  // This is used for ticking animations slowly when hidden.
633  scoped_ptr<LayerTreeHostImplTimeSourceAdapter> time_source_client_adapter_;
634
635  scoped_ptr<FrameRateCounter> fps_counter_;
636  scoped_ptr<PaintTimeCounter> paint_time_counter_;
637  scoped_ptr<MemoryHistory> memory_history_;
638  scoped_ptr<DebugRectHistory> debug_rect_history_;
639
640  scoped_ptr<TextureMailboxDeleter> texture_mailbox_deleter_;
641
642  // The maximum memory that would be used by the prioritized resource
643  // manager, if there were no limit on memory usage.
644  size_t max_memory_needed_bytes_;
645
646  bool zero_budget_;
647
648  // Viewport size passed in from the main thread, in physical pixels.  This
649  // value is the default size for all concepts of physical viewport (draw
650  // viewport, scrolling viewport and device viewport), but it can be
651  // overridden.
652  gfx::Size device_viewport_size_;
653
654  // Conversion factor from CSS pixels to physical pixels when
655  // pageScaleFactor=1.
656  float device_scale_factor_;
657
658  // UI resource to use for drawing overhang gutters.
659  UIResourceId overhang_ui_resource_id_;
660  gfx::Size overhang_ui_resource_size_;
661
662  // Optional top-level constraints that can be set by the OutputSurface.
663  // - external_transform_ applies a transform above the root layer
664  // - external_viewport_ is used DrawProperties, tile management and
665  // glViewport/window projection matrix.
666  // - external_clip_ specifies a top-level clip rect
667  // - viewport_rect_for_tile_priority_ is the rect in view space used for
668  // tiling priority.
669  gfx::Transform external_transform_;
670  gfx::Rect external_viewport_;
671  gfx::Rect external_clip_;
672  gfx::Rect viewport_rect_for_tile_priority_;
673  bool resourceless_software_draw_;
674
675  gfx::Rect viewport_damage_rect_;
676
677  BeginFrameArgs current_begin_frame_args_;
678
679  // Expected time between two begin impl frame calls.
680  base::TimeDelta begin_impl_frame_interval_;
681
682  scoped_ptr<AnimationRegistrar> animation_registrar_;
683
684  RenderingStatsInstrumentation* rendering_stats_instrumentation_;
685  MicroBenchmarkControllerImpl micro_benchmark_controller_;
686
687  bool need_to_update_visible_tiles_before_draw_;
688
689  // Optional callback to notify of new tree activations.
690  base::Closure tree_activation_callback_;
691
692  SharedBitmapManager* shared_bitmap_manager_;
693  int id_;
694
695  std::set<SwapPromiseMonitor*> swap_promise_monitor_;
696
697  std::vector<PictureLayerImpl*> picture_layers_;
698  std::vector<PictureLayerImpl::Pair> picture_layer_pairs_;
699
700  DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
701};
702
703}  // namespace cc
704
705#endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_
706