src/cc/trees/layer_tree_host_impl.h

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