blob: 1702e0937d505212906760d2446537e3a957fd16 [file] [log] [blame]
// Copyright 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_TREES_LAYER_TREE_HOST_IMPL_H_
#define CC_TREES_LAYER_TREE_HOST_IMPL_H_
#include <list>
#include <set>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/containers/hash_tables.h"
#include "base/memory/scoped_ptr.h"
#include "base/time/time.h"
#include "cc/animation/animation_events.h"
#include "cc/animation/animation_registrar.h"
#include "cc/animation/scrollbar_animation_controller.h"
#include "cc/base/cc_export.h"
#include "cc/base/synced_property.h"
#include "cc/debug/micro_benchmark_controller_impl.h"
#include "cc/input/input_handler.h"
#include "cc/input/layer_scroll_offset_delegate.h"
#include "cc/input/top_controls_manager_client.h"
#include "cc/layers/layer_lists.h"
#include "cc/layers/render_pass_sink.h"
#include "cc/output/begin_frame_args.h"
#include "cc/output/managed_memory_policy.h"
#include "cc/output/output_surface_client.h"
#include "cc/output/renderer.h"
#include "cc/quads/render_pass.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/tile_manager.h"
#include "cc/scheduler/draw_result.h"
#include "skia/ext/refptr.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/geometry/rect.h"
namespace cc {
class CompletionEvent;
class CompositorFrameMetadata;
class DebugRectHistory;
class EvictionTilePriorityQueue;
class FrameRateCounter;
class LayerImpl;
class LayerTreeImpl;
class MemoryHistory;
class PageScaleAnimation;
class PaintTimeCounter;
class PictureLayerImpl;
class RasterTilePriorityQueue;
class RasterWorkerPool;
class RenderPassDrawQuad;
class RenderingStatsInstrumentation;
class ResourcePool;
class ScrollElasticityHelper;
class ScrollbarLayerImplBase;
class TextureMailboxDeleter;
class TopControlsManager;
class UIResourceBitmap;
class UIResourceRequest;
struct RendererCapabilitiesImpl;
enum class GpuRasterizationStatus {
ON,
ON_FORCED,
OFF_DEVICE,
OFF_VIEWPORT,
OFF_CONTENT
};
// LayerTreeHost->Proxy callback interface.
class LayerTreeHostImplClient {
public:
virtual void UpdateRendererCapabilitiesOnImplThread() = 0;
virtual void DidLoseOutputSurfaceOnImplThread() = 0;
virtual void CommitVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval) = 0;
virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) = 0;
virtual void SetMaxSwapsPendingOnImplThread(int max) = 0;
virtual void DidSwapBuffersOnImplThread() = 0;
virtual void DidSwapBuffersCompleteOnImplThread() = 0;
virtual void OnCanDrawStateChanged(bool can_draw) = 0;
virtual void NotifyReadyToActivate() = 0;
virtual void NotifyReadyToDraw() = 0;
// Please call these 3 functions through
// LayerTreeHostImpl's SetNeedsRedraw(), SetNeedsRedrawRect() and
// SetNeedsAnimate().
virtual void SetNeedsRedrawOnImplThread() = 0;
virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) = 0;
virtual void SetNeedsAnimateOnImplThread() = 0;
virtual void SetNeedsCommitOnImplThread() = 0;
virtual void SetNeedsManageTilesOnImplThread() = 0;
virtual void PostAnimationEventsToMainThreadOnImplThread(
scoped_ptr<AnimationEventsVector> events) = 0;
// Returns true if resources were deleted by this call.
virtual bool ReduceContentsTextureMemoryOnImplThread(
size_t limit_bytes,
int priority_cutoff) = 0;
virtual bool IsInsideDraw() = 0;
virtual void RenewTreePriority() = 0;
virtual void PostDelayedScrollbarFadeOnImplThread(
const base::Closure& start_fade,
base::TimeDelta delay) = 0;
virtual void DidActivateSyncTree() = 0;
virtual void DidManageTiles() = 0;
protected:
virtual ~LayerTreeHostImplClient() {}
};
// LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
// state.
class CC_EXPORT LayerTreeHostImpl
: public InputHandler,
public RendererClient,
public TileManagerClient,
public OutputSurfaceClient,
public TopControlsManagerClient,
public ScrollbarAnimationControllerClient,
public base::SupportsWeakPtr<LayerTreeHostImpl> {
public:
static scoped_ptr<LayerTreeHostImpl> Create(
const LayerTreeSettings& settings,
LayerTreeHostImplClient* client,
Proxy* proxy,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
SharedBitmapManager* shared_bitmap_manager,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
int id);
~LayerTreeHostImpl() override;
// InputHandler implementation
void BindToClient(InputHandlerClient* client) override;
InputHandler::ScrollStatus ScrollBegin(
const gfx::Point& viewport_point,
InputHandler::ScrollInputType type) override;
InputHandler::ScrollStatus ScrollAnimated(
const gfx::Point& viewport_point,
const gfx::Vector2dF& scroll_delta) override;
InputHandlerScrollResult ScrollBy(
const gfx::Point& viewport_point,
const gfx::Vector2dF& scroll_delta) override;
bool ScrollVerticallyByPage(const gfx::Point& viewport_point,
ScrollDirection direction) override;
void SetRootLayerScrollOffsetDelegate(
LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) override;
void OnRootLayerDelegatedScrollOffsetChanged() override;
void ScrollEnd() override;
InputHandler::ScrollStatus FlingScrollBegin() override;
void MouseMoveAt(const gfx::Point& viewport_point) override;
void PinchGestureBegin() override;
void PinchGestureUpdate(float magnify_delta,
const gfx::Point& anchor) override;
void PinchGestureEnd() override;
void StartPageScaleAnimation(const gfx::Vector2d& target_offset,
bool anchor_point,
float page_scale,
base::TimeDelta duration);
void SetNeedsAnimate() override;
bool IsCurrentlyScrollingLayerAt(const gfx::Point& viewport_point,
InputHandler::ScrollInputType type) override;
bool HaveTouchEventHandlersAt(const gfx::Point& viewport_port) override;
scoped_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
ui::LatencyInfo* latency) override;
ScrollElasticityHelper* CreateScrollElasticityHelper() override;
// TopControlsManagerClient implementation.
void SetControlsTopOffset(float offset) override;
float ControlsTopOffset() const override;
void DidChangeTopControlsPosition() override;
bool HaveRootScrollLayer() const override;
struct CC_EXPORT FrameData : public RenderPassSink {
FrameData();
~FrameData() override;
void AsValueInto(base::debug::TracedValue* value) const;
std::vector<gfx::Rect> occluding_screen_space_rects;
std::vector<gfx::Rect> non_occluding_screen_space_rects;
RenderPassList render_passes;
RenderPassIdHashMap render_passes_by_id;
const LayerImplList* render_surface_layer_list;
LayerImplList will_draw_layers;
bool has_no_damage;
// RenderPassSink implementation.
void AppendRenderPass(scoped_ptr<RenderPass> render_pass) override;
};
virtual void BeginMainFrameAborted(bool did_handle);
virtual void BeginCommit();
virtual void CommitComplete();
virtual void Animate(base::TimeTicks monotonic_time);
virtual void UpdateAnimationState(bool start_ready_animations);
void ActivateAnimations();
void MainThreadHasStoppedFlinging();
void DidAnimateScrollOffset();
void SetViewportDamage(const gfx::Rect& damage_rect);
virtual void ManageTiles();
// Returns DRAW_SUCCESS unless problems occured preparing the frame, and we
// should try to avoid displaying the frame. If PrepareToDraw is called,
// DidDrawAllLayers must also be called, regardless of whether DrawLayers is
// called between the two.
virtual DrawResult PrepareToDraw(FrameData* frame);
virtual void DrawLayers(FrameData* frame, base::TimeTicks frame_begin_time);
// Must be called if and only if PrepareToDraw was called.
void DidDrawAllLayers(const FrameData& frame);
const LayerTreeSettings& settings() const { return settings_; }
// Evict all textures by enforcing a memory policy with an allocation of 0.
void EvictTexturesForTesting();
// When blocking, this prevents client_->NotifyReadyToActivate() from being
// called. When disabled, it calls client_->NotifyReadyToActivate()
// immediately if any notifications had been blocked while blocking.
virtual void BlockNotifyReadyToActivateForTesting(bool block);
// Resets all of the trees to an empty state.
void ResetTreesForTesting();
DrawMode GetDrawMode() const;
// Viewport size in draw space: this size is in physical pixels and is used
// for draw properties, tilings, quads and render passes.
gfx::Size DrawViewportSize() const;
// Viewport rect in view space used for tiling prioritization.
const gfx::Rect ViewportRectForTilePriority() const;
// RendererClient implementation.
void SetFullRootLayerDamage() override;
// TileManagerClient implementation.
const std::vector<PictureLayerImpl*>& GetPictureLayers() const override;
void NotifyReadyToActivate() override;
void NotifyReadyToDraw() override;
void NotifyTileStateChanged(const Tile* tile) override;
void BuildRasterQueue(RasterTilePriorityQueue* queue,
TreePriority tree_priority) override;
void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
TreePriority tree_priority) override;
// ScrollbarAnimationControllerClient implementation.
void PostDelayedScrollbarFade(const base::Closure& start_fade,
base::TimeDelta delay) override;
void SetNeedsScrollbarAnimationFrame() override;
// OutputSurfaceClient implementation.
void DeferredInitialize() override;
void ReleaseGL() override;
void CommitVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval) override;
void SetNeedsRedrawRect(const gfx::Rect& rect) override;
void SetExternalDrawConstraints(
const gfx::Transform& transform,
const gfx::Rect& viewport,
const gfx::Rect& clip,
const gfx::Rect& viewport_rect_for_tile_priority,
const gfx::Transform& transform_for_tile_priority,
bool resourceless_software_draw) override;
void DidLoseOutputSurface() override;
void DidSwapBuffers() override;
void DidSwapBuffersComplete() override;
void ReclaimResources(const CompositorFrameAck* ack) override;
void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
void SetTreeActivationCallback(const base::Closure& callback) override;
// Called from LayerTreeImpl.
void OnCanDrawStateChangedForTree();
// Implementation.
int id() const { return id_; }
bool CanDraw() const;
OutputSurface* output_surface() const { return output_surface_.get(); }
std::string LayerTreeAsJson() const;
void FinishAllRendering();
int SourceAnimationFrameNumber() const;
virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface);
TileManager* tile_manager() { return tile_manager_.get(); }
void SetUseGpuRasterization(bool use_gpu);
bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
GpuRasterizationStatus gpu_rasterization_status() const {
return gpu_rasterization_status_;
}
void set_gpu_rasterization_status(
GpuRasterizationStatus gpu_rasterization_status) {
gpu_rasterization_status_ = gpu_rasterization_status;
}
bool create_low_res_tiling() const {
return settings_.create_low_res_tiling && !use_gpu_rasterization_;
}
ResourcePool* resource_pool() { return resource_pool_.get(); }
Renderer* renderer() { return renderer_.get(); }
const RendererCapabilitiesImpl& GetRendererCapabilities() const;
virtual bool SwapBuffers(const FrameData& frame);
virtual void WillBeginImplFrame(const BeginFrameArgs& args);
void DidModifyTilePriorities();
LayerTreeImpl* active_tree() { return active_tree_.get(); }
const LayerTreeImpl* active_tree() const { return active_tree_.get(); }
LayerTreeImpl* pending_tree() { return pending_tree_.get(); }
const LayerTreeImpl* pending_tree() const { return pending_tree_.get(); }
LayerTreeImpl* recycle_tree() { return recycle_tree_.get(); }
const LayerTreeImpl* recycle_tree() const { return recycle_tree_.get(); }
// Returns the tree LTH synchronizes with.
LayerTreeImpl* sync_tree() {
return pending_tree_ ? pending_tree_.get() : active_tree_.get();
}
virtual void CreatePendingTree();
virtual void ActivateSyncTree();
// Shortcuts to layers on the active tree.
LayerImpl* RootLayer() const;
LayerImpl* InnerViewportScrollLayer() const;
LayerImpl* OuterViewportScrollLayer() const;
LayerImpl* CurrentlyScrollingLayer() const;
int scroll_layer_id_when_mouse_over_scrollbar() const {
return scroll_layer_id_when_mouse_over_scrollbar_;
}
bool scroll_affects_scroll_handler() const {
return scroll_affects_scroll_handler_;
}
void QueueSwapPromiseForMainThreadScrollUpdate(
scoped_ptr<SwapPromise> swap_promise);
bool IsActivelyScrolling() const;
virtual void SetVisible(bool visible);
bool visible() const { return visible_; }
bool AnimationsAreVisible() { return visible() && CanDraw(); }
void SetNeedsCommit() { client_->SetNeedsCommitOnImplThread(); }
void SetNeedsRedraw();
ManagedMemoryPolicy ActualManagedMemoryPolicy() const;
size_t memory_allocation_limit_bytes() const;
int memory_allocation_priority_cutoff() const;
void SetViewportSize(const gfx::Size& device_viewport_size);
gfx::Size device_viewport_size() const { return device_viewport_size_; }
void SetOverhangUIResource(UIResourceId overhang_ui_resource_id,
const gfx::Size& overhang_ui_resource_size);
void SetDeviceScaleFactor(float device_scale_factor);
float device_scale_factor() const { return device_scale_factor_; }
void SetPageScaleOnActiveTree(float page_scale_factor);
const gfx::Transform& DrawTransform() const;
scoped_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
bool needs_animate_layers() const {
return !animation_registrar_->active_animation_controllers().empty();
}
void set_max_memory_needed_bytes(size_t bytes) {
max_memory_needed_bytes_ = bytes;
}
FrameRateCounter* fps_counter() {
return fps_counter_.get();
}
PaintTimeCounter* paint_time_counter() {
return paint_time_counter_.get();
}
MemoryHistory* memory_history() {
return memory_history_.get();
}
DebugRectHistory* debug_rect_history() {
return debug_rect_history_.get();
}
ResourceProvider* resource_provider() {
return resource_provider_.get();
}
TopControlsManager* top_controls_manager() {
return top_controls_manager_.get();
}
const GlobalStateThatImpactsTilePriority& global_tile_state() {
return global_tile_state_;
}
Proxy* proxy() const { return proxy_; }
AnimationRegistrar* animation_registrar() const {
return animation_registrar_.get();
}
void SetDebugState(const LayerTreeDebugState& new_debug_state);
const LayerTreeDebugState& debug_state() const { return debug_state_; }
class CC_EXPORT CullRenderPassesWithNoQuads {
public:
bool ShouldRemoveRenderPass(const RenderPassDrawQuad& quad,
const FrameData& frame) const;
// Iterates in draw order, so that when a surface is removed, and its
// target becomes empty, then its target can be removed also.
size_t RenderPassListBegin(const RenderPassList& list) const { return 0; }
size_t RenderPassListEnd(const RenderPassList& list) const {
return list.size();
}
size_t RenderPassListNext(size_t it) const { return it + 1; }
};
template <typename RenderPassCuller>
static void RemoveRenderPasses(RenderPassCuller culler, FrameData* frame);
gfx::Vector2dF accumulated_root_overscroll() const {
return accumulated_root_overscroll_;
}
bool pinch_gesture_active() const { return pinch_gesture_active_; }
void SetTreePriority(TreePriority priority);
TreePriority GetTreePriority() const;
void UpdateCurrentBeginFrameArgs(const BeginFrameArgs& args);
void ResetCurrentBeginFrameArgsForNextFrame();
virtual BeginFrameArgs CurrentBeginFrameArgs() const;
// Expected time between two begin impl frame calls.
base::TimeDelta begin_impl_frame_interval() const {
return begin_impl_frame_interval_;
}
void AsValueInto(base::debug::TracedValue* value) const;
void AsValueWithFrameInto(FrameData* frame,
base::debug::TracedValue* value) const;
scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
scoped_refptr<base::debug::ConvertableToTraceFormat> AsValueWithFrame(
FrameData* frame) const;
scoped_refptr<base::debug::ConvertableToTraceFormat> ActivationStateAsValue()
const;
void ActivationStateAsValueInto(base::debug::TracedValue* value) const;
bool page_scale_animation_active() const { return !!page_scale_animation_; }
virtual void CreateUIResource(UIResourceId uid,
const UIResourceBitmap& bitmap);
// Deletes a UI resource. May safely be called more than once.
virtual void DeleteUIResource(UIResourceId uid);
void EvictAllUIResources();
bool EvictedUIResourcesExist() const;
virtual ResourceProvider::ResourceId ResourceIdForUIResource(
UIResourceId uid) const;
virtual bool IsUIResourceOpaque(UIResourceId uid) const;
struct UIResourceData {
ResourceProvider::ResourceId resource_id;
gfx::Size size;
bool opaque;
};
void ScheduleMicroBenchmark(scoped_ptr<MicroBenchmarkImpl> benchmark);
CompositorFrameMetadata MakeCompositorFrameMetadata() const;
// Viewport rectangle and clip in nonflipped window space. These rects
// should only be used by Renderer subclasses to populate glViewport/glClip
// and their software-mode equivalents.
gfx::Rect DeviceViewport() const;
gfx::Rect DeviceClip() const;
// When a SwapPromiseMonitor is created on the impl thread, it calls
// InsertSwapPromiseMonitor() to register itself with LayerTreeHostImpl.
// When the monitor is destroyed, it calls RemoveSwapPromiseMonitor()
// to unregister itself.
void InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor);
void RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor);
void RegisterPictureLayerImpl(PictureLayerImpl* layer);
void UnregisterPictureLayerImpl(PictureLayerImpl* layer);
void GetPictureLayerImplPairs(std::vector<PictureLayerImpl::Pair>* layers,
bool need_valid_tile_priorities) const;
void SetRequiresHighResToDraw() { requires_high_res_to_draw_ = true; }
void ResetRequiresHighResToDraw() { requires_high_res_to_draw_ = false; }
bool RequiresHighResToDraw() const { return requires_high_res_to_draw_; }
// Only valid for synchronous (non-scheduled) single-threaded case.
void SynchronouslyInitializeAllTiles();
virtual void CreateResourceAndRasterWorkerPool(
scoped_ptr<RasterWorkerPool>* raster_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
scoped_ptr<ResourcePool>* staging_resource_pool);
protected:
LayerTreeHostImpl(
const LayerTreeSettings& settings,
LayerTreeHostImplClient* client,
Proxy* proxy,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
SharedBitmapManager* shared_bitmap_manager,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
int id);
void UpdateViewportContainerSizes();
// Virtual for testing.
virtual void AnimateLayers(base::TimeTicks monotonic_time);
const AnimationRegistrar::AnimationControllerMap&
active_animation_controllers() const {
return animation_registrar_->active_animation_controllers();
}
bool manage_tiles_needed() const { return tile_priorities_dirty_; }
LayerTreeHostImplClient* client_;
Proxy* proxy_;
private:
void CreateAndSetRenderer();
void CreateAndSetTileManager();
void DestroyTileManager();
void ReleaseTreeResources();
void EnforceZeroBudget(bool zero_budget);
bool UsePendingTreeForSync() const;
bool IsSynchronousSingleThreaded() const;
// Scroll by preferring to move the outer viewport first, only moving the
// inner if the outer is at its scroll extents.
void ScrollViewportBy(gfx::Vector2dF scroll_delta);
// Scroll by preferring to move the inner viewport first, only moving the
// outer if the inner is at its scroll extents.
void ScrollViewportInnerFirst(gfx::Vector2dF scroll_delta);
void AnimatePageScale(base::TimeTicks monotonic_time);
void AnimateScrollbars(base::TimeTicks monotonic_time);
void AnimateTopControls(base::TimeTicks monotonic_time);
bool ShouldTopControlsConsumeScroll(const gfx::Vector2dF& scroll_delta) const;
gfx::Vector2dF ScrollLayerWithViewportSpaceDelta(
LayerImpl* layer_impl,
float scale_from_viewport_to_screen_space,
const gfx::PointF& viewport_point,
const gfx::Vector2dF& viewport_delta);
void TrackDamageForAllSurfaces(
LayerImpl* root_draw_layer,
const LayerImplList& render_surface_layer_list);
void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy);
// This function should only be called from PrepareToDraw, as DidDrawAllLayers
// must be called if this helper function is called. Returns DRAW_SUCCESS if
// the frame should be drawn.
DrawResult CalculateRenderPasses(FrameData* frame);
void ClearCurrentlyScrollingLayer();
bool HandleMouseOverScrollbar(LayerImpl* layer_impl,
const gfx::PointF& device_viewport_point);
void AnimateScrollbarsRecursive(LayerImpl* layer,
base::TimeTicks time);
LayerImpl* FindScrollLayerForDeviceViewportPoint(
const gfx::PointF& device_viewport_point,
InputHandler::ScrollInputType type,
LayerImpl* layer_hit_by_point,
bool* scroll_on_main_thread,
bool* optional_has_ancestor_scroll_handler) const;
float DeviceSpaceDistanceToLayer(const gfx::PointF& device_viewport_point,
LayerImpl* layer_impl);
void StartScrollbarFadeRecursive(LayerImpl* layer);
void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy,
bool zero_budget);
void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy);
void MarkUIResourceNotEvicted(UIResourceId uid);
void NotifySwapPromiseMonitorsOfSetNeedsRedraw();
void NotifySwapPromiseMonitorsOfForwardingToMainThread();
typedef base::hash_map<UIResourceId, UIResourceData>
UIResourceMap;
UIResourceMap ui_resource_map_;
// Resources that were evicted by EvictAllUIResources. Resources are removed
// from this when they are touched by a create or destroy from the UI resource
// request queue.
std::set<UIResourceId> evicted_ui_resources_;
scoped_ptr<OutputSurface> output_surface_;
// |resource_provider_| and |tile_manager_| can be NULL, e.g. when using tile-
// free rendering - see OutputSurface::ForcedDrawToSoftwareDevice().
scoped_ptr<ResourceProvider> resource_provider_;
scoped_ptr<TileManager> tile_manager_;
bool use_gpu_rasterization_;
GpuRasterizationStatus gpu_rasterization_status_;
scoped_ptr<RasterWorkerPool> raster_worker_pool_;
scoped_ptr<ResourcePool> resource_pool_;
scoped_ptr<ResourcePool> staging_resource_pool_;
scoped_ptr<Renderer> renderer_;
GlobalStateThatImpactsTilePriority global_tile_state_;
// Tree currently being drawn.
scoped_ptr<LayerTreeImpl> active_tree_;
// In impl-side painting mode, tree with possibly incomplete rasterized
// content. May be promoted to active by ActivatePendingTree().
scoped_ptr<LayerTreeImpl> pending_tree_;
// In impl-side painting mode, inert tree with layers that can be recycled
// by the next sync from the main thread.
scoped_ptr<LayerTreeImpl> recycle_tree_;
InputHandlerClient* input_handler_client_;
bool did_lock_scrolling_layer_;
bool should_bubble_scrolls_;
bool wheel_scrolling_;
bool scroll_affects_scroll_handler_;
int scroll_layer_id_when_mouse_over_scrollbar_;
ScopedPtrVector<SwapPromise> swap_promises_for_main_thread_scroll_update_;
// An object to implement the ScrollElasticityHelper interface and
// hold all state related to elasticity. May be NULL if never requested.
scoped_ptr<ScrollElasticityHelper> scroll_elasticity_helper_;
bool tile_priorities_dirty_;
// The optional delegate for the root layer scroll offset.
LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
LayerTreeSettings settings_;
LayerTreeDebugState debug_state_;
bool visible_;
ManagedMemoryPolicy cached_managed_memory_policy_;
gfx::Vector2dF accumulated_root_overscroll_;
bool pinch_gesture_active_;
bool pinch_gesture_end_should_clear_scrolling_layer_;
gfx::Point previous_pinch_anchor_;
scoped_ptr<TopControlsManager> top_controls_manager_;
scoped_ptr<PageScaleAnimation> page_scale_animation_;
scoped_ptr<FrameRateCounter> fps_counter_;
scoped_ptr<PaintTimeCounter> paint_time_counter_;
scoped_ptr<MemoryHistory> memory_history_;
scoped_ptr<DebugRectHistory> debug_rect_history_;
scoped_ptr<TextureMailboxDeleter> texture_mailbox_deleter_;
// The maximum memory that would be used by the prioritized resource
// manager, if there were no limit on memory usage.
size_t max_memory_needed_bytes_;
bool zero_budget_;
// Viewport size passed in from the main thread, in physical pixels. This
// value is the default size for all concepts of physical viewport (draw
// viewport, scrolling viewport and device viewport), but it can be
// overridden.
gfx::Size device_viewport_size_;
// Conversion factor from CSS pixels to physical pixels when
// pageScaleFactor=1.
float device_scale_factor_;
// UI resource to use for drawing overhang gutters.
UIResourceId overhang_ui_resource_id_;
gfx::Size overhang_ui_resource_size_;
// Optional top-level constraints that can be set by the OutputSurface.
// - external_transform_ applies a transform above the root layer
// - external_viewport_ is used DrawProperties, tile management and
// glViewport/window projection matrix.
// - external_clip_ specifies a top-level clip rect
// - viewport_rect_for_tile_priority_ is the rect in view space used for
// tiling priority.
gfx::Transform external_transform_;
gfx::Rect external_viewport_;
gfx::Rect external_clip_;
gfx::Rect viewport_rect_for_tile_priority_;
bool resourceless_software_draw_;
gfx::Rect viewport_damage_rect_;
BeginFrameArgs current_begin_frame_args_;
// Expected time between two begin impl frame calls.
base::TimeDelta begin_impl_frame_interval_;
scoped_ptr<AnimationRegistrar> animation_registrar_;
RenderingStatsInstrumentation* rendering_stats_instrumentation_;
MicroBenchmarkControllerImpl micro_benchmark_controller_;
scoped_ptr<TaskGraphRunner> single_thread_synchronous_task_graph_runner_;
// Optional callback to notify of new tree activations.
base::Closure tree_activation_callback_;
SharedBitmapManager* shared_bitmap_manager_;
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
int id_;
std::set<SwapPromiseMonitor*> swap_promise_monitor_;
std::vector<PictureLayerImpl*> picture_layers_;
std::vector<PictureLayerImpl::Pair> picture_layer_pairs_;
bool requires_high_res_to_draw_;
bool required_for_draw_tile_is_top_of_raster_queue_;
DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
};
} // namespace cc
#endif // CC_TREES_LAYER_TREE_HOST_IMPL_H_