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 <string>
10#include <vector>
11
12#include "base/basictypes.h"
13#include "base/containers/hash_tables.h"
14#include "base/memory/scoped_ptr.h"
15#include "base/time/time.h"
16#include "cc/animation/animation_events.h"
17#include "cc/animation/animation_registrar.h"
18#include "cc/base/cc_export.h"
19#include "cc/input/input_handler.h"
20#include "cc/input/layer_scroll_offset_delegate.h"
21#include "cc/input/top_controls_manager_client.h"
22#include "cc/layers/layer_lists.h"
23#include "cc/layers/render_pass_sink.h"
24#include "cc/output/begin_frame_args.h"
25#include "cc/output/managed_memory_policy.h"
26#include "cc/output/output_surface_client.h"
27#include "cc/output/renderer.h"
28#include "cc/quads/render_pass.h"
29#include "cc/resources/resource_provider.h"
30#include "cc/resources/tile_manager.h"
31#include "skia/ext/refptr.h"
32#include "third_party/skia/include/core/SkColor.h"
33#include "ui/gfx/rect.h"
34
35namespace cc {
36
37class CompletionEvent;
38class CompositorFrameMetadata;
39class DebugRectHistory;
40class FrameRateCounter;
41class LayerImpl;
42class LayerTreeHostImplTimeSourceAdapter;
43class LayerTreeImpl;
44class PageScaleAnimation;
45class PaintTimeCounter;
46class MemoryHistory;
47class RenderingStatsInstrumentation;
48class RenderPassDrawQuad;
49class TopControlsManager;
50class UIResourceBitmap;
51struct RendererCapabilities;
52struct UIResourceRequest;
53
54// LayerTreeHost->Proxy callback interface.
55class LayerTreeHostImplClient {
56 public:
57  virtual void DidTryInitializeRendererOnImplThread(
58      bool success,
59      scoped_refptr<ContextProvider> offscreen_context_provider) = 0;
60  virtual void DidLoseOutputSurfaceOnImplThread() = 0;
61  virtual void OnSwapBuffersCompleteOnImplThread() = 0;
62  virtual void BeginFrameOnImplThread(const BeginFrameArgs& args) = 0;
63  virtual void OnCanDrawStateChanged(bool can_draw) = 0;
64  virtual void OnHasPendingTreeStateChanged(bool has_pending_tree) = 0;
65  virtual void SetNeedsRedrawOnImplThread() = 0;
66  virtual void SetNeedsRedrawRectOnImplThread(gfx::Rect damage_rect) = 0;
67  virtual void DidInitializeVisibleTileOnImplThread() = 0;
68  virtual void SetNeedsCommitOnImplThread() = 0;
69  virtual void PostAnimationEventsToMainThreadOnImplThread(
70      scoped_ptr<AnimationEventsVector> events,
71      base::Time wall_clock_time) = 0;
72  // Returns true if resources were deleted by this call.
73  virtual bool ReduceContentsTextureMemoryOnImplThread(
74      size_t limit_bytes,
75      int priority_cutoff) = 0;
76  virtual void ReduceWastedContentsTextureMemoryOnImplThread() = 0;
77  virtual void SendManagedMemoryStats() = 0;
78  virtual bool IsInsideDraw() = 0;
79  virtual void RenewTreePriority() = 0;
80  virtual void RequestScrollbarAnimationOnImplThread(base::TimeDelta delay) = 0;
81  virtual void DidActivatePendingTree() = 0;
82
83 protected:
84  virtual ~LayerTreeHostImplClient() {}
85};
86
87// LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
88// state.
89class CC_EXPORT LayerTreeHostImpl
90    : public InputHandler,
91      public RendererClient,
92      public TileManagerClient,
93      public OutputSurfaceClient,
94      public TopControlsManagerClient,
95      public base::SupportsWeakPtr<LayerTreeHostImpl> {
96 public:
97  static scoped_ptr<LayerTreeHostImpl> Create(
98      const LayerTreeSettings& settings,
99      LayerTreeHostImplClient* client,
100      Proxy* proxy,
101      RenderingStatsInstrumentation* rendering_stats_instrumentation);
102  virtual ~LayerTreeHostImpl();
103
104  // InputHandler implementation
105  virtual void BindToClient(InputHandlerClient* client) OVERRIDE;
106  virtual InputHandler::ScrollStatus ScrollBegin(
107      gfx::Point viewport_point,
108      InputHandler::ScrollInputType type) OVERRIDE;
109  virtual bool ScrollBy(gfx::Point viewport_point,
110                        gfx::Vector2dF scroll_delta) OVERRIDE;
111  virtual bool ScrollVerticallyByPage(gfx::Point viewport_point,
112                                      ScrollDirection direction) OVERRIDE;
113  virtual void SetRootLayerScrollOffsetDelegate(
114      LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) OVERRIDE;
115  virtual void OnRootLayerDelegatedScrollOffsetChanged() OVERRIDE;
116  virtual void ScrollEnd() OVERRIDE;
117  virtual InputHandler::ScrollStatus FlingScrollBegin() OVERRIDE;
118  virtual void NotifyCurrentFlingVelocity(gfx::Vector2dF velocity) OVERRIDE;
119  virtual void PinchGestureBegin() OVERRIDE;
120  virtual void PinchGestureUpdate(float magnify_delta,
121                                  gfx::Point anchor) OVERRIDE;
122  virtual void PinchGestureEnd() OVERRIDE;
123  virtual void StartPageScaleAnimation(gfx::Vector2d target_offset,
124                                       bool anchor_point,
125                                       float page_scale,
126                                       base::TimeTicks start_time,
127                                       base::TimeDelta duration) OVERRIDE;
128  virtual void ScheduleAnimation() OVERRIDE;
129  virtual bool HaveTouchEventHandlersAt(gfx::Point viewport_port) OVERRIDE;
130  virtual void SetLatencyInfoForInputEvent(const ui::LatencyInfo& latency_info)
131      OVERRIDE;
132
133  // TopControlsManagerClient implementation.
134  virtual void DidChangeTopControlsPosition() OVERRIDE;
135  virtual bool HaveRootScrollLayer() const OVERRIDE;
136
137  void StartScrollbarAnimation();
138
139  struct CC_EXPORT FrameData : public RenderPassSink {
140    FrameData();
141    virtual ~FrameData();
142    scoped_ptr<base::Value> AsValue() const;
143
144    std::vector<gfx::Rect> occluding_screen_space_rects;
145    std::vector<gfx::Rect> non_occluding_screen_space_rects;
146    RenderPassList render_passes;
147    RenderPassIdHashMap render_passes_by_id;
148    const LayerImplList* render_surface_layer_list;
149    LayerImplList will_draw_layers;
150    bool contains_incomplete_tile;
151    bool has_no_damage;
152
153    // RenderPassSink implementation.
154    virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) OVERRIDE;
155  };
156
157  virtual void BeginCommit();
158  virtual void CommitComplete();
159  virtual void Animate(base::TimeTicks monotonic_time,
160                       base::Time wall_clock_time);
161  virtual void UpdateAnimationState(bool start_ready_animations);
162  void MainThreadHasStoppedFlinging();
163  void UpdateBackgroundAnimateTicking(bool should_background_tick);
164  void SetViewportDamage(gfx::Rect damage_rect);
165
166  void ManageTiles();
167
168  // Returns false if problems occured preparing the frame, and we should try
169  // to avoid displaying the frame. If PrepareToDraw is called, DidDrawAllLayers
170  // must also be called, regardless of whether DrawLayers is called between the
171  // two.
172  virtual bool PrepareToDraw(FrameData* frame,
173                             gfx::Rect device_viewport_damage_rect);
174  virtual void DrawLayers(FrameData* frame, base::TimeTicks frame_begin_time);
175  // Must be called if and only if PrepareToDraw was called.
176  void DidDrawAllLayers(const FrameData& frame);
177
178  const LayerTreeSettings& settings() const { return settings_; }
179
180  // Returns the currently visible viewport size in DIP. This value excludes
181  // the URL bar and non-overlay scrollbars.
182  gfx::SizeF UnscaledScrollableViewportSize() const;
183
184  // Evict all textures by enforcing a memory policy with an allocation of 0.
185  void EvictTexturesForTesting();
186
187  bool device_viewport_valid_for_tile_management() const {
188    return device_viewport_valid_for_tile_management_;
189  }
190
191  // RendererClient implementation
192  virtual gfx::Rect DeviceViewport() const OVERRIDE;
193  virtual gfx::Rect DeviceClip() const OVERRIDE;
194 private:
195  virtual float DeviceScaleFactor() const OVERRIDE;
196  virtual const LayerTreeSettings& Settings() const OVERRIDE;
197 public:
198  virtual void SetFullRootLayerDamage() OVERRIDE;
199  virtual bool HasImplThread() const OVERRIDE;
200  virtual bool ShouldClearRootRenderPass() const OVERRIDE;
201  virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE;
202  virtual bool AllowPartialSwap() const OVERRIDE;
203  virtual bool ExternalStencilTestEnabled() const OVERRIDE;
204
205  // TileManagerClient implementation.
206  virtual void NotifyReadyToActivate() OVERRIDE;
207
208  // OutputSurfaceClient implementation.
209  virtual bool DeferredInitialize(
210      scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE;
211  virtual void ReleaseGL() OVERRIDE;
212  virtual void SetNeedsRedrawRect(gfx::Rect rect) OVERRIDE;
213  virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE;
214  virtual void SetExternalDrawConstraints(
215      const gfx::Transform& transform,
216      gfx::Rect viewport,
217      gfx::Rect clip,
218      bool valid_for_tile_management) OVERRIDE;
219  virtual void SetExternalStencilTest(bool enabled) OVERRIDE;
220  virtual void DidLoseOutputSurface() OVERRIDE;
221  virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) OVERRIDE;
222  virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
223  virtual void SetDiscardBackBufferWhenNotVisible(bool discard) OVERRIDE;
224  virtual void SetTreeActivationCallback(const base::Closure& callback)
225      OVERRIDE;
226
227  // Called from LayerTreeImpl.
228  void OnCanDrawStateChangedForTree();
229
230  // Implementation
231  bool CanDraw() const;
232  OutputSurface* output_surface() const { return output_surface_.get(); }
233
234  std::string LayerTreeAsJson() const;
235
236  void FinishAllRendering();
237  int SourceAnimationFrameNumber() const;
238
239  virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface);
240  bool IsContextLost();
241  TileManager* tile_manager() { return tile_manager_.get(); }
242  Renderer* renderer() { return renderer_.get(); }
243  const RendererCapabilities& GetRendererCapabilities() const;
244
245  virtual bool SwapBuffers(const FrameData& frame);
246  void SetNeedsBeginFrame(bool enable);
247  void SetNeedsManageTiles() { manage_tiles_needed_ = true; }
248
249  void Readback(void* pixels, gfx::Rect rect_in_device_viewport);
250
251  LayerTreeImpl* active_tree() { return active_tree_.get(); }
252  const LayerTreeImpl* active_tree() const { return active_tree_.get(); }
253  LayerTreeImpl* pending_tree() { return pending_tree_.get(); }
254  const LayerTreeImpl* pending_tree() const { return pending_tree_.get(); }
255  const LayerTreeImpl* recycle_tree() const { return recycle_tree_.get(); }
256  virtual void CreatePendingTree();
257  void UpdateVisibleTiles();
258  virtual void ActivatePendingTreeIfNeeded();
259
260  // Shortcuts to layers on the active tree.
261  LayerImpl* RootLayer() const;
262  LayerImpl* RootScrollLayer() const;
263  LayerImpl* CurrentlyScrollingLayer() const;
264
265  bool IsCurrentlyScrolling() const;
266
267  virtual void SetVisible(bool visible);
268  bool visible() const { return visible_; }
269
270  void SetNeedsCommit() { client_->SetNeedsCommitOnImplThread(); }
271  void SetNeedsRedraw() { client_->SetNeedsRedrawOnImplThread(); }
272
273  ManagedMemoryPolicy ActualManagedMemoryPolicy() const;
274
275  size_t memory_allocation_limit_bytes() const;
276
277  void SetViewportSize(gfx::Size device_viewport_size);
278
279  void SetOverdrawBottomHeight(float overdraw_bottom_height);
280  float overdraw_bottom_height() const { return overdraw_bottom_height_; }
281
282  void SetDeviceScaleFactor(float device_scale_factor);
283  float device_scale_factor() const { return device_scale_factor_; }
284
285  const gfx::Transform& DeviceTransform() const;
286
287  scoped_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
288
289  bool needs_animate_layers() const {
290    return !animation_registrar_->active_animation_controllers().empty();
291  }
292
293  void SendManagedMemoryStats(
294      size_t memory_visible_bytes,
295      size_t memory_visible_and_nearby_bytes,
296      size_t memory_use_bytes);
297
298  void set_max_memory_needed_bytes(size_t bytes) {
299    max_memory_needed_bytes_ = bytes;
300  }
301
302  FrameRateCounter* fps_counter() {
303    return fps_counter_.get();
304  }
305  PaintTimeCounter* paint_time_counter() {
306    return paint_time_counter_.get();
307  }
308  MemoryHistory* memory_history() {
309    return memory_history_.get();
310  }
311  DebugRectHistory* debug_rect_history() {
312    return debug_rect_history_.get();
313  }
314  ResourceProvider* resource_provider() {
315    return resource_provider_.get();
316  }
317  TopControlsManager* top_controls_manager() {
318    return top_controls_manager_.get();
319  }
320
321  Proxy* proxy() const { return proxy_; }
322
323  AnimationRegistrar* animation_registrar() const {
324    return animation_registrar_.get();
325  }
326
327  void SetDebugState(const LayerTreeDebugState& new_debug_state);
328  const LayerTreeDebugState& debug_state() const { return debug_state_; }
329
330  class CC_EXPORT CullRenderPassesWithCachedTextures {
331 public:
332    bool ShouldRemoveRenderPass(const RenderPassDrawQuad& quad,
333                                const FrameData& frame) const;
334
335    // Iterates from the root first, in order to remove the surfaces closest
336    // to the root with cached textures, and all surfaces that draw into
337    // them.
338    size_t RenderPassListBegin(const RenderPassList& list) const {
339      return list.size() - 1;
340    }
341    size_t RenderPassListEnd(const RenderPassList& list) const { return 0 - 1; }
342    size_t RenderPassListNext(size_t it) const { return it - 1; }
343
344    explicit CullRenderPassesWithCachedTextures(Renderer* renderer)
345        : renderer_(renderer) {}
346 private:
347    Renderer* renderer_;
348  };
349
350  class CC_EXPORT CullRenderPassesWithNoQuads {
351 public:
352    bool ShouldRemoveRenderPass(const RenderPassDrawQuad& quad,
353                                const FrameData& frame) const;
354
355    // Iterates in draw order, so that when a surface is removed, and its
356    // target becomes empty, then its target can be removed also.
357    size_t RenderPassListBegin(const RenderPassList& list) const { return 0; }
358    size_t RenderPassListEnd(const RenderPassList& list) const {
359      return list.size();
360    }
361    size_t RenderPassListNext(size_t it) const { return it + 1; }
362  };
363
364  template <typename RenderPassCuller>
365      static void RemoveRenderPasses(RenderPassCuller culler, FrameData* frame);
366
367  gfx::Vector2dF accumulated_root_overscroll() const {
368    return accumulated_root_overscroll_;
369  }
370  gfx::Vector2dF current_fling_velocity() const {
371    return current_fling_velocity_;
372  }
373
374  bool pinch_gesture_active() const { return pinch_gesture_active_; }
375
376  void SetTreePriority(TreePriority priority);
377
378  void ResetCurrentFrameTimeForNextFrame();
379  base::TimeTicks CurrentFrameTimeTicks();
380  base::Time CurrentFrameTime();
381
382  virtual base::TimeTicks CurrentPhysicalTimeTicks() const;
383
384  scoped_ptr<base::Value> AsValue() const { return AsValueWithFrame(NULL); }
385  scoped_ptr<base::Value> AsValueWithFrame(FrameData* frame) const;
386  scoped_ptr<base::Value> ActivationStateAsValue() const;
387
388  bool page_scale_animation_active() const { return !!page_scale_animation_; }
389
390  void CreateUIResource(UIResourceId uid,
391                        scoped_refptr<UIResourceBitmap> bitmap);
392  // Deletes a UI resource.  May safely be called more than once.
393  void DeleteUIResource(UIResourceId uid);
394
395  ResourceProvider::ResourceId ResourceIdForUIResource(UIResourceId uid) const;
396
397 protected:
398  LayerTreeHostImpl(
399      const LayerTreeSettings& settings,
400      LayerTreeHostImplClient* client,
401      Proxy* proxy,
402      RenderingStatsInstrumentation* rendering_stats_instrumentation);
403  virtual void ActivatePendingTree();
404
405  // Virtual for testing.
406  virtual void AnimateLayers(base::TimeTicks monotonic_time,
407                             base::Time wall_clock_time);
408
409  // Virtual for testing.
410  virtual base::TimeDelta LowFrequencyAnimationInterval() const;
411
412  const AnimationRegistrar::AnimationControllerMap&
413      active_animation_controllers() const {
414    return animation_registrar_->active_animation_controllers();
415  }
416
417  LayerTreeHostImplClient* client_;
418  Proxy* proxy_;
419
420 private:
421  void CreateAndSetRenderer(OutputSurface* output_surface,
422                            ResourceProvider* resource_provider,
423                            bool skip_gl_renderer);
424  void CreateAndSetTileManager(ResourceProvider* resource_provider,
425                               bool using_map_image);
426  void ReleaseTreeResources();
427  void EnforceZeroBudget(bool zero_budget);
428
429  void AnimatePageScale(base::TimeTicks monotonic_time);
430  void AnimateScrollbars(base::TimeTicks monotonic_time);
431  void AnimateTopControls(base::TimeTicks monotonic_time);
432
433  gfx::Vector2dF ScrollLayerWithViewportSpaceDelta(
434      LayerImpl* layer_impl,
435      float scale_from_viewport_to_screen_space,
436      gfx::PointF viewport_point,
437      gfx::Vector2dF viewport_delta);
438
439  void UpdateMaxScrollOffset();
440  void TrackDamageForAllSurfaces(
441      LayerImpl* root_draw_layer,
442      const LayerImplList& render_surface_layer_list);
443
444  void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy);
445
446  // Returns false if the frame should not be displayed. This function should
447  // only be called from PrepareToDraw, as DidDrawAllLayers must be called
448  // if this helper function is called.
449  bool CalculateRenderPasses(FrameData* frame);
450
451  void SendReleaseResourcesRecursive(LayerImpl* current);
452  bool EnsureRenderSurfaceLayerList();
453  void ClearCurrentlyScrollingLayer();
454
455  void AnimateScrollbarsRecursive(LayerImpl* layer,
456                                  base::TimeTicks time);
457
458  void UpdateCurrentFrameTime(base::TimeTicks* ticks, base::Time* now) const;
459
460  void StartScrollbarAnimationRecursive(LayerImpl* layer, base::TimeTicks time);
461  void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy,
462                              bool zero_budget);
463  void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy);
464
465  void DidInitializeVisibleTile();
466
467  typedef base::hash_map<UIResourceId, ResourceProvider::ResourceId>
468      UIResourceMap;
469  UIResourceMap ui_resource_map_;
470
471  scoped_ptr<OutputSurface> output_surface_;
472
473  // |resource_provider_| and |tile_manager_| can be NULL, e.g. when using tile-
474  // free rendering - see OutputSurface::ForcedDrawToSoftwareDevice().
475  scoped_ptr<ResourceProvider> resource_provider_;
476  scoped_ptr<TileManager> tile_manager_;
477  scoped_ptr<Renderer> renderer_;
478
479  // Tree currently being drawn.
480  scoped_ptr<LayerTreeImpl> active_tree_;
481
482  // In impl-side painting mode, tree with possibly incomplete rasterized
483  // content. May be promoted to active by ActivatePendingTreeIfNeeded().
484  scoped_ptr<LayerTreeImpl> pending_tree_;
485
486  // In impl-side painting mode, inert tree with layers that can be recycled
487  // by the next sync from the main thread.
488  scoped_ptr<LayerTreeImpl> recycle_tree_;
489
490  InputHandlerClient* input_handler_client_;
491  bool did_lock_scrolling_layer_;
492  bool should_bubble_scrolls_;
493  bool wheel_scrolling_;
494
495  bool manage_tiles_needed_;
496
497  // The optional delegate for the root layer scroll offset.
498  LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
499  LayerTreeSettings settings_;
500  LayerTreeDebugState debug_state_;
501  bool visible_;
502  ManagedMemoryPolicy cached_managed_memory_policy_;
503
504  gfx::Vector2dF accumulated_root_overscroll_;
505  gfx::Vector2dF current_fling_velocity_;
506
507  bool pinch_gesture_active_;
508  gfx::Point previous_pinch_anchor_;
509
510  // This is set by AnimateLayers() and used by UpdateAnimationState()
511  // when sending animation events to the main thread.
512  base::Time last_animation_time_;
513
514  scoped_ptr<TopControlsManager> top_controls_manager_;
515
516  scoped_ptr<PageScaleAnimation> page_scale_animation_;
517
518  // This is used for ticking animations slowly when hidden.
519  scoped_ptr<LayerTreeHostImplTimeSourceAdapter> time_source_client_adapter_;
520
521  scoped_ptr<FrameRateCounter> fps_counter_;
522  scoped_ptr<PaintTimeCounter> paint_time_counter_;
523  scoped_ptr<MemoryHistory> memory_history_;
524  scoped_ptr<DebugRectHistory> debug_rect_history_;
525
526  // The maximum memory that would be used by the prioritized resource
527  // manager, if there were no limit on memory usage.
528  size_t max_memory_needed_bytes_;
529
530  size_t last_sent_memory_visible_bytes_;
531  size_t last_sent_memory_visible_and_nearby_bytes_;
532  size_t last_sent_memory_use_bytes_;
533  bool zero_budget_;
534
535  // Viewport size passed in from the main thread, in physical pixels.
536  gfx::Size device_viewport_size_;
537
538  // Conversion factor from CSS pixels to physical pixels when
539  // pageScaleFactor=1.
540  float device_scale_factor_;
541
542  // Vertical amount of the viewport size that's known to covered by a
543  // browser-side UI element, such as an on-screen-keyboard.  This affects
544  // scrollable size since we want to still be able to scroll to the bottom of
545  // the page when the keyboard is up.
546  float overdraw_bottom_height_;
547
548  // Optional top-level constraints that can be set by the OutputSurface.
549  // - external_transform_ applies a transform above the root layer
550  // - external_viewport_ is used DrawProperties, tile management and
551  // glViewport/window projection matrix.
552  // - external_clip_ specifies a top-level clip rect
553  // - external_stencil_test_enabled_ tells CC to respect existing stencil bits
554  // (When these are specified, device_viewport_size_ remains used only for
555  // scrollable size.)
556  gfx::Transform external_transform_;
557  gfx::Rect external_viewport_;
558  gfx::Rect external_clip_;
559  bool device_viewport_valid_for_tile_management_;
560  bool external_stencil_test_enabled_;
561
562  gfx::Rect viewport_damage_rect_;
563
564  base::TimeTicks current_frame_timeticks_;
565  base::Time current_frame_time_;
566
567  scoped_ptr<AnimationRegistrar> animation_registrar_;
568
569  RenderingStatsInstrumentation* rendering_stats_instrumentation_;
570
571  bool need_to_update_visible_tiles_before_draw_;
572
573  // Optional callback to notify of new tree activations.
574  base::Closure tree_activation_callback_;
575
576  DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
577};
578
579}  // namespace cc
580
581#endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_
582