blob: e7b3f6163470bba5d7a5c42a1c31a8cacdb2c698 [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 <stddef.h>
#include <bitset>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include "base/callback.h"
#include "base/macros.h"
#include "base/time/time.h"
#include "cc/base/synced_property.h"
#include "cc/benchmarks/micro_benchmark_controller_impl.h"
#include "cc/cc_export.h"
#include "cc/input/browser_controls_offset_manager_client.h"
#include "cc/input/input_handler.h"
#include "cc/input/scrollbar_animation_controller.h"
#include "cc/layers/layer_collections.h"
#include "cc/output/begin_frame_args.h"
#include "cc/output/compositor_frame_sink_client.h"
#include "cc/output/context_cache_controller.h"
#include "cc/output/managed_memory_policy.h"
#include "cc/quads/render_pass.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/ui_resource_client.h"
#include "cc/scheduler/begin_frame_tracker.h"
#include "cc/scheduler/commit_earlyout_reason.h"
#include "cc/scheduler/draw_result.h"
#include "cc/scheduler/video_frame_controller.h"
#include "cc/surfaces/local_surface_id.h"
#include "cc/surfaces/surface_id.h"
#include "cc/tiles/decoded_image_tracker.h"
#include "cc/tiles/image_decode_cache.h"
#include "cc/tiles/tile_manager.h"
#include "cc/trees/layer_tree_mutator.h"
#include "cc/trees/layer_tree_settings.h"
#include "cc/trees/mutator_host_client.h"
#include "cc/trees/task_runner_provider.h"
#include "ui/gfx/geometry/rect.h"
namespace gfx {
class ScrollOffset;
}
namespace cc {
class BrowserControlsOffsetManager;
class CompositorFrameMetadata;
class CompositorFrameSink;
class DebugRectHistory;
class EvictionTilePriorityQueue;
class FrameRateCounter;
class LayerImpl;
class LayerTreeImpl;
class MemoryHistory;
class MutatorEvents;
class MutatorHost;
class PageScaleAnimation;
class PendingTreeDurationHistogramTimer;
class RasterTilePriorityQueue;
class RasterBufferProvider;
class RenderingStatsInstrumentation;
class ResourcePool;
class ScrollElasticityHelper;
class SwapPromise;
class SwapPromiseMonitor;
class SynchronousTaskGraphRunner;
class TaskGraphRunner;
class UIResourceBitmap;
struct ScrollAndScaleSet;
class Viewport;
using BeginFrameCallbackList = std::vector<base::Closure>;
enum class GpuRasterizationStatus {
ON,
ON_FORCED,
OFF_DEVICE,
OFF_VIEWPORT,
MSAA_CONTENT,
};
// LayerTreeHost->Proxy callback interface.
class LayerTreeHostImplClient {
public:
virtual void DidLoseCompositorFrameSinkOnImplThread() = 0;
virtual void SetBeginFrameSource(BeginFrameSource* source) = 0;
virtual void DidReceiveCompositorFrameAckOnImplThread() = 0;
virtual void OnCanDrawStateChanged(bool can_draw) = 0;
virtual void NotifyReadyToActivate() = 0;
virtual void NotifyReadyToDraw() = 0;
// Please call these 2 functions through
// LayerTreeHostImpl's SetNeedsRedraw() and SetNeedsOneBeginImplFrame().
virtual void SetNeedsRedrawOnImplThread() = 0;
virtual void SetNeedsOneBeginImplFrameOnImplThread() = 0;
virtual void SetNeedsCommitOnImplThread() = 0;
virtual void SetNeedsPrepareTilesOnImplThread() = 0;
virtual void SetVideoNeedsBeginFrames(bool needs_begin_frames) = 0;
virtual void PostAnimationEventsToMainThreadOnImplThread(
std::unique_ptr<MutatorEvents> events) = 0;
virtual bool IsInsideDraw() = 0;
virtual void RenewTreePriority() = 0;
virtual void PostDelayedAnimationTaskOnImplThread(const base::Closure& task,
base::TimeDelta delay) = 0;
virtual void DidActivateSyncTree() = 0;
virtual void WillPrepareTiles() = 0;
virtual void DidPrepareTiles() = 0;
// Called when page scale animation has completed on the impl thread.
virtual void DidCompletePageScaleAnimationOnImplThread() = 0;
// Called when output surface asks for a draw.
virtual void OnDrawForCompositorFrameSink(
bool resourceless_software_draw) = 0;
virtual void NeedsImplSideInvalidation() = 0;
protected:
virtual ~LayerTreeHostImplClient() {}
};
// LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
// state.
class CC_EXPORT LayerTreeHostImpl
: public InputHandler,
public TileManagerClient,
public CompositorFrameSinkClient,
public BrowserControlsOffsetManagerClient,
public ScrollbarAnimationControllerClient,
public VideoFrameControllerClient,
public LayerTreeMutatorClient,
public MutatorHostClient,
public base::SupportsWeakPtr<LayerTreeHostImpl> {
public:
static std::unique_ptr<LayerTreeHostImpl> Create(
const LayerTreeSettings& settings,
LayerTreeHostImplClient* client,
TaskRunnerProvider* task_runner_provider,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
TaskGraphRunner* task_graph_runner,
std::unique_ptr<MutatorHost> mutator_host,
int id,
scoped_refptr<base::SequencedTaskRunner> image_worker_task_runner);
~LayerTreeHostImpl() override;
// InputHandler implementation
void BindToClient(InputHandlerClient* client,
bool wheel_scroll_latching_enabled) override;
InputHandler::ScrollStatus ScrollBegin(
ScrollState* scroll_state,
InputHandler::ScrollInputType type) override;
InputHandler::ScrollStatus RootScrollBegin(
ScrollState* scroll_state,
InputHandler::ScrollInputType type) override;
ScrollStatus ScrollAnimatedBegin(const gfx::Point& viewport_point) override;
InputHandler::ScrollStatus ScrollAnimated(
const gfx::Point& viewport_point,
const gfx::Vector2dF& scroll_delta,
base::TimeDelta delayed_by = base::TimeDelta()) override;
void ApplyScroll(ScrollNode* scroll_node, ScrollState* scroll_state);
InputHandlerScrollResult ScrollBy(ScrollState* scroll_state) override;
void RequestUpdateForSynchronousInputHandler() override;
void SetSynchronousInputHandlerRootScrollOffset(
const gfx::ScrollOffset& root_offset) override;
void ScrollEnd(ScrollState* scroll_state) override;
InputHandler::ScrollStatus FlingScrollBegin() override;
void MouseDown() override;
void MouseUp() override;
void MouseMoveAt(const gfx::Point& viewport_point) override;
void MouseLeave() 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 SetNeedsAnimateInput() override;
bool IsCurrentlyScrollingViewport() const override;
bool IsCurrentlyScrollingLayerAt(
const gfx::Point& viewport_point,
InputHandler::ScrollInputType type) const override;
EventListenerProperties GetEventListenerProperties(
EventListenerClass event_class) const override;
InputHandler::TouchStartEventListenerType EventListenerTypeForTouchStartAt(
const gfx::Point& viewport_port) override;
std::unique_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
ui::LatencyInfo* latency) override;
ScrollElasticityHelper* CreateScrollElasticityHelper() override;
bool GetScrollOffsetForLayer(int layer_id,
gfx::ScrollOffset* offset) override;
bool ScrollLayerTo(int layer_id, const gfx::ScrollOffset& offset) override;
bool ScrollingShouldSwitchtoMainThread() override;
// BrowserControlsOffsetManagerClient implementation.
float TopControlsHeight() const override;
float BottomControlsHeight() const override;
void SetCurrentBrowserControlsShownRatio(float offset) override;
float CurrentBrowserControlsShownRatio() const override;
void DidChangeBrowserControlsPosition() override;
bool HaveRootScrollLayer() const override;
void UpdateViewportContainerSizes();
void set_resourceless_software_draw_for_testing() {
resourceless_software_draw_ = true;
}
struct CC_EXPORT FrameData {
FrameData();
~FrameData();
void AsValueInto(base::trace_event::TracedValue* value) const;
std::vector<SurfaceId> embedded_surfaces;
std::vector<gfx::Rect> occluding_screen_space_rects;
std::vector<gfx::Rect> non_occluding_screen_space_rects;
RenderPassList render_passes;
const LayerImplList* render_surface_layer_list;
LayerImplList will_draw_layers;
bool has_no_damage;
bool may_contain_video;
BeginFrameAck begin_frame_ack;
private:
DISALLOW_COPY_AND_ASSIGN(FrameData);
};
virtual void DidSendBeginMainFrame() {}
virtual void BeginMainFrameAborted(
CommitEarlyOutReason reason,
std::vector<std::unique_ptr<SwapPromise>> swap_promises);
virtual void ReadyToCommit() {} // For tests.
virtual void BeginCommit();
virtual void CommitComplete();
virtual void UpdateAnimationState(bool start_ready_animations);
bool Mutate(base::TimeTicks monotonic_time);
void ActivateAnimations();
void Animate();
void AnimatePendingTreeAfterCommit();
void MainThreadHasStoppedFlinging();
void DidAnimateScrollOffset();
void SetFullViewportDamage();
void SetViewportDamage(const gfx::Rect& damage_rect);
// Analogous to a commit, this function is used to create a sync tree and
// add impl-side invalidations to it.
// virtual for testing.
virtual void InvalidateContentOnImplSide();
void SetTreeLayerScrollOffsetMutated(ElementId element_id,
LayerTreeImpl* tree,
const gfx::ScrollOffset& scroll_offset);
bool AnimationsPreserveAxisAlignment(const LayerImpl* layer) const;
void SetNeedUpdateGpuRasterizationStatus();
// MutatorHostClient implementation.
bool IsElementInList(ElementId element_id,
ElementListType list_type) const override;
void SetMutatorsNeedCommit() override;
void SetMutatorsNeedRebuildPropertyTrees() override;
void SetElementFilterMutated(ElementId element_id,
ElementListType list_type,
const FilterOperations& filters) override;
void SetElementOpacityMutated(ElementId element_id,
ElementListType list_type,
float opacity) override;
void SetElementTransformMutated(ElementId element_id,
ElementListType list_type,
const gfx::Transform& transform) override;
void SetElementScrollOffsetMutated(
ElementId element_id,
ElementListType list_type,
const gfx::ScrollOffset& scroll_offset) override;
void ElementIsAnimatingChanged(ElementId element_id,
ElementListType list_type,
const PropertyAnimationState& mask,
const PropertyAnimationState& state) override;
void ScrollOffsetAnimationFinished() override;
gfx::ScrollOffset GetScrollOffsetForAnimation(
ElementId element_id) const override;
virtual bool PrepareTiles();
// 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 bool DrawLayers(FrameData* frame);
// 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);
// Prevents notifying the |client_| when an impl side invalidation request is
// made. When unblocked, the disabled request will immediately be called.
virtual void BlockImplSideInvalidationRequestsForTesting(bool block);
// Resets all of the trees to an empty state.
void ResetTreesForTesting();
size_t SourceAnimationFrameNumberForTesting() const;
void RegisterScrollbarAnimationController(ElementId scroll_element_id);
void UnregisterScrollbarAnimationController(ElementId scroll_element_id);
ScrollbarAnimationController* ScrollbarAnimationControllerForElementId(
ElementId scroll_element_id) const;
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;
// TileManagerClient implementation.
void NotifyReadyToActivate() override;
void NotifyReadyToDraw() override;
void NotifyAllTileTasksCompleted() override;
void NotifyTileStateChanged(const Tile* tile) override;
std::unique_ptr<RasterTilePriorityQueue> BuildRasterQueue(
TreePriority tree_priority,
RasterTilePriorityQueue::Type type) override;
std::unique_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
TreePriority tree_priority) override;
void SetIsLikelyToRequireADraw(bool is_likely_to_require_a_draw) override;
gfx::ColorSpace GetRasterColorSpace() const override;
void RequestImplSideInvalidation() override;
// ScrollbarAnimationControllerClient implementation.
void PostDelayedScrollbarAnimationTask(const base::Closure& task,
base::TimeDelta delay) override;
void SetNeedsAnimateForScrollbarAnimation() override;
void SetNeedsRedrawForScrollbarAnimation() override;
ScrollbarSet ScrollbarsFor(ElementId scroll_element_id) const override;
void DidChangeScrollbarVisibility() override;
// VideoBeginFrameSource implementation.
void AddVideoFrameController(VideoFrameController* controller) override;
void RemoveVideoFrameController(VideoFrameController* controller) override;
// CompositorFrameSinkClient implementation.
void SetBeginFrameSource(BeginFrameSource* source) override;
void SetExternalTilePriorityConstraints(
const gfx::Rect& viewport_rect,
const gfx::Transform& transform) override;
void DidLoseCompositorFrameSink() override;
void DidReceiveCompositorFrameAck() override;
void ReclaimResources(const ReturnedResourceArray& resources) override;
void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
void SetTreeActivationCallback(const base::Closure& callback) override;
void OnDraw(const gfx::Transform& transform,
const gfx::Rect& viewport,
bool resourceless_software_draw) override;
// LayerTreeMutatorClient.
void SetNeedsMutate() override;
// Called from LayerTreeImpl.
void OnCanDrawStateChangedForTree();
// Implementation.
int id() const { return id_; }
bool CanDraw() const;
CompositorFrameSink* compositor_frame_sink() const {
return compositor_frame_sink_;
}
void ReleaseCompositorFrameSink();
std::string LayerTreeAsJson() const;
int RequestedMSAASampleCount() const;
// TODO(danakj): Rename this, there is no renderer.
virtual bool InitializeRenderer(CompositorFrameSink* compositor_frame_sink);
TileManager* tile_manager() { return &tile_manager_; }
void SetHasGpuRasterizationTrigger(bool flag);
void SetContentIsSuitableForGpuRasterization(bool flag);
bool CanUseGpuRasterization();
bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
bool use_msaa() const { return use_msaa_; }
GpuRasterizationStatus gpu_rasterization_status() const {
return 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(); }
ImageDecodeCache* image_decode_cache() { return image_decode_cache_.get(); }
virtual void WillBeginImplFrame(const BeginFrameArgs& args);
virtual void DidFinishImplFrame();
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() const {
// TODO(enne): This is bogus. It should return based on the value of
// CommitToActiveTree() and not whether the pending tree exists.
return pending_tree_ ? pending_tree_.get() : active_tree_.get();
}
virtual void CreatePendingTree();
virtual void ActivateSyncTree();
// Shortcuts to layers/nodes on the active tree.
LayerImpl* InnerViewportScrollLayer() const;
LayerImpl* OuterViewportScrollLayer() const;
ScrollNode* OuterViewportScrollNode() const;
ScrollNode* CurrentlyScrollingNode();
const ScrollNode* CurrentlyScrollingNode() const;
bool scroll_affects_scroll_handler() const {
return scroll_affects_scroll_handler_;
}
void QueueSwapPromiseForMainThreadScrollUpdate(
std::unique_ptr<SwapPromise> swap_promise);
bool IsActivelyScrolling() const;
virtual void SetVisible(bool visible);
bool visible() const { return visible_; }
void SetNeedsCommit() { client_->SetNeedsCommitOnImplThread(); }
void SetNeedsOneBeginImplFrame();
void SetNeedsRedraw();
ManagedMemoryPolicy ActualManagedMemoryPolicy() const;
void SetViewportSize(const gfx::Size& device_viewport_size);
gfx::Size device_viewport_size() const { return device_viewport_size_; }
const gfx::Transform& DrawTransform() const;
std::unique_ptr<BeginFrameCallbackList> ProcessLayerTreeMutations();
std::unique_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
void set_max_memory_needed_bytes(size_t bytes) {
max_memory_needed_bytes_ = bytes;
}
FrameRateCounter* fps_counter() { return fps_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(); }
BrowserControlsOffsetManager* browser_controls_manager() {
return browser_controls_offset_manager_.get();
}
const GlobalStateThatImpactsTilePriority& global_tile_state() {
return global_tile_state_;
}
TaskRunnerProvider* task_runner_provider() const {
return task_runner_provider_;
}
MutatorHost* mutator_host() const { return mutator_host_.get(); }
void SetDebugState(const LayerTreeDebugState& new_debug_state);
const LayerTreeDebugState& debug_state() const { return debug_state_; }
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;
// TODO(mithro): Remove this methods which exposes the internal
// BeginFrameArgs to external callers.
virtual BeginFrameArgs CurrentBeginFrameArgs() const;
// Expected time between two begin impl frame calls.
base::TimeDelta CurrentBeginFrameInterval() const;
void AsValueWithFrameInto(FrameData* frame,
base::trace_event::TracedValue* value) const;
std::unique_ptr<base::trace_event::ConvertableToTraceFormat> AsValueWithFrame(
FrameData* frame) const;
void ActivationStateAsValueInto(base::trace_event::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 ResourceId ResourceIdForUIResource(UIResourceId uid) const;
virtual bool IsUIResourceOpaque(UIResourceId uid) const;
struct UIResourceData {
ResourceId resource_id;
bool opaque;
};
// Returns the amount of delta that can be applied to scroll_node, taking
// page scale into account.
gfx::Vector2dF ComputeScrollDelta(ScrollNode* scroll_node,
const gfx::Vector2dF& delta);
void ScheduleMicroBenchmark(std::unique_ptr<MicroBenchmarkImpl> benchmark);
CompositorFrameMetadata MakeCompositorFrameMetadata() const;
// Viewport rectangle and clip in device space. These rects are used to
// prioritize raster and determine what is submitted in a CompositorFrame.
gfx::Rect DeviceViewport() 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);
// TODO(weiliangc): Replace RequiresHighResToDraw with scheduler waits for
// ReadyToDraw. crbug.com/469175
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();
bool SupportsImplScrolling() const;
bool CommitToActiveTree() const;
virtual void CreateResourceAndRasterBufferProvider(
std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
std::unique_ptr<ResourcePool>* resource_pool);
bool prepare_tiles_needed() const { return tile_priorities_dirty_; }
gfx::Vector2dF ScrollSingleNode(ScrollNode* scroll_node,
const gfx::Vector2dF& delta,
const gfx::Point& viewport_point,
bool is_direct_manipulation,
ScrollTree* scroll_tree);
base::SingleThreadTaskRunner* GetTaskRunner() const {
DCHECK(task_runner_provider_);
return task_runner_provider_->HasImplThread()
? task_runner_provider_->ImplThreadTaskRunner()
: task_runner_provider_->MainThreadTaskRunner();
}
InputHandler::ScrollStatus TryScroll(const gfx::PointF& screen_space_point,
InputHandler::ScrollInputType type,
const ScrollTree& scroll_tree,
ScrollNode* scroll_node) const;
// Returns true if a scroll offset animation is created and false if we scroll
// by the desired amount without an animation.
bool ScrollAnimationCreate(ScrollNode* scroll_node,
const gfx::Vector2dF& scroll_amount,
base::TimeDelta delayed_by);
void SetLayerTreeMutator(std::unique_ptr<LayerTreeMutator> mutator);
LayerTreeMutator* mutator() { return mutator_.get(); }
LayerImpl* ViewportMainScrollLayer();
void QueueImageDecode(sk_sp<const SkImage> image,
const base::Callback<void(bool)>& embedder_callback);
std::vector<base::Closure> TakeCompletedImageDecodeCallbacks();
void ClearImageCacheOnNavigation();
protected:
LayerTreeHostImpl(
const LayerTreeSettings& settings,
LayerTreeHostImplClient* client,
TaskRunnerProvider* task_runner_provider,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
TaskGraphRunner* task_graph_runner,
std::unique_ptr<MutatorHost> mutator_host,
int id,
scoped_refptr<base::SequencedTaskRunner> image_worker_task_runner);
// Virtual for testing.
virtual bool AnimateLayers(base::TimeTicks monotonic_time);
bool is_likely_to_require_a_draw() const {
return is_likely_to_require_a_draw_;
}
// Removes empty or orphan RenderPasses from the frame.
static void RemoveRenderPasses(FrameData* frame);
LayerTreeHostImplClient* client_;
TaskRunnerProvider* task_runner_provider_;
BeginFrameTracker current_begin_frame_tracker_;
private:
gfx::Vector2dF ScrollNodeWithViewportSpaceDelta(
ScrollNode* scroll_node,
const gfx::PointF& viewport_point,
const gfx::Vector2dF& viewport_delta,
ScrollTree* scroll_tree);
void CleanUpTileManagerAndUIResources();
void CreateTileManagerResources();
void ReleaseTreeResources();
void ReleaseTileResources();
void RecreateTileResources();
void AnimateInternal(bool active_tree);
// The function is called to update state on the sync tree after a commit
// finishes or after the sync tree was created to invalidate content on the
// impl thread.
void UpdateSyncTreeAfterCommitOrImplSideInvalidation();
// Returns true if status changed.
bool UpdateGpuRasterizationStatus();
void UpdateTreeResourcesForGpuRasterizationIfNeeded();
Viewport* viewport() const { return viewport_.get(); }
InputHandler::ScrollStatus ScrollBeginImpl(
ScrollState* scroll_state,
ScrollNode* scrolling_node,
InputHandler::ScrollInputType type);
bool IsInitialScrollHitTestReliable(LayerImpl* layer, const gfx::PointF&);
void DistributeScrollDelta(ScrollState* scroll_state);
bool AnimatePageScale(base::TimeTicks monotonic_time);
bool AnimateScrollbars(base::TimeTicks monotonic_time);
bool AnimateBrowserControls(base::TimeTicks monotonic_time);
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 ClearCurrentlyScrollingNode();
ScrollNode* FindScrollNodeForDeviceViewportPoint(
const gfx::PointF& device_viewport_point,
InputHandler::ScrollInputType type,
LayerImpl* layer_hit_by_point,
bool* scroll_on_main_thread,
uint32_t* main_thread_scrolling_reason) const;
float DeviceSpaceDistanceToLayer(const gfx::PointF& device_viewport_point,
LayerImpl* layer_impl);
void StartScrollbarFadeRecursive(LayerImpl* layer);
void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy);
void MarkUIResourceNotEvicted(UIResourceId uid);
void ClearUIResources();
void NotifySwapPromiseMonitorsOfSetNeedsRedraw();
void NotifySwapPromiseMonitorsOfForwardingToMainThread();
void UpdateRootLayerStateForSynchronousInputHandler();
bool ScrollAnimationUpdateTarget(ScrollNode* scroll_node,
const gfx::Vector2dF& scroll_delta,
base::TimeDelta delayed_by);
void SetContextVisibility(bool is_visible);
void ImageDecodeFinished(const base::Callback<void(bool)>& embedder_callback,
bool decode_succeeded);
// This function keeps track of sources of scrolls that are handled in the
// compositor side. The information gets shared by the main thread as part of
// the begin_main_frame_state. Finally Use counters are updated in the main
// thread side to keep track of the frequency of scrolling with different
// sources per page load. TODO(crbug.com/691886): Use GRC API to plumb the
// scroll source info for Use Counters.
void UpdateScrollSourceInfo(bool is_wheel_scroll);
bool IsScrolledBy(LayerImpl* child, ScrollNode* ancestor);
using UIResourceMap = std::unordered_map<UIResourceId, UIResourceData>;
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_;
CompositorFrameSink* compositor_frame_sink_;
LocalSurfaceId local_surface_id_;
// The following scoped variables must not outlive the
// |compositor_frame_sink_|.
// These should be transfered to ContextCacheController's
// ClientBecameNotVisible() before the output surface is destroyed.
std::unique_ptr<ContextCacheController::ScopedVisibility>
compositor_context_visibility_;
std::unique_ptr<ContextCacheController::ScopedVisibility>
worker_context_visibility_;
std::unique_ptr<ResourceProvider> resource_provider_;
bool need_update_gpu_rasterization_status_;
bool content_is_suitable_for_gpu_rasterization_;
bool has_gpu_rasterization_trigger_;
bool use_gpu_rasterization_;
bool use_msaa_;
GpuRasterizationStatus gpu_rasterization_status_;
std::unique_ptr<RasterBufferProvider> raster_buffer_provider_;
std::unique_ptr<ResourcePool> resource_pool_;
std::unique_ptr<ImageDecodeCache> image_decode_cache_;
GlobalStateThatImpactsTilePriority global_tile_state_;
// Tree currently being drawn.
std::unique_ptr<LayerTreeImpl> active_tree_;
// In impl-side painting mode, tree with possibly incomplete rasterized
// content. May be promoted to active by ActivatePendingTree().
std::unique_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.
std::unique_ptr<LayerTreeImpl> recycle_tree_;
InputHandlerClient* input_handler_client_;
bool did_lock_scrolling_layer_;
bool wheel_scrolling_;
bool scroll_affects_scroll_handler_;
ElementId scroll_element_id_mouse_currently_over_;
ElementId scroll_element_id_mouse_currently_captured_;
std::vector<std::unique_ptr<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.
std::unique_ptr<ScrollElasticityHelper> scroll_elasticity_helper_;
bool tile_priorities_dirty_;
const LayerTreeSettings settings_;
LayerTreeDebugState debug_state_;
bool visible_;
ManagedMemoryPolicy cached_managed_memory_policy_;
const bool is_synchronous_single_threaded_;
TileManager tile_manager_;
DecodedImageTracker decoded_image_tracker_;
gfx::Vector2dF accumulated_root_overscroll_;
bool pinch_gesture_active_;
bool pinch_gesture_end_should_clear_scrolling_node_;
std::unique_ptr<BrowserControlsOffsetManager>
browser_controls_offset_manager_;
std::unique_ptr<PageScaleAnimation> page_scale_animation_;
std::unique_ptr<FrameRateCounter> fps_counter_;
std::unique_ptr<MemoryHistory> memory_history_;
std::unique_ptr<DebugRectHistory> debug_rect_history_;
// 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_;
// 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_;
// Optional top-level constraints that can be set by the CompositorFrameSink.
// - external_transform_ applies a transform above the root layer
// - external_viewport_ is used DrawProperties, tile management and
// glViewport/window projection matrix.
// - 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 viewport_rect_for_tile_priority_;
bool resourceless_software_draw_;
gfx::Rect viewport_damage_rect_;
std::unique_ptr<MutatorHost> mutator_host_;
std::set<VideoFrameController*> video_frame_controllers_;
// Map from scroll element ID to scrollbar animation controller.
// There is one animation controller per pair of overlay scrollbars.
std::unordered_map<ElementId,
std::unique_ptr<ScrollbarAnimationController>,
ElementIdHash>
scrollbar_animation_controllers_;
RenderingStatsInstrumentation* rendering_stats_instrumentation_;
MicroBenchmarkControllerImpl micro_benchmark_controller_;
std::unique_ptr<SynchronousTaskGraphRunner>
single_thread_synchronous_task_graph_runner_;
// Optional callback to notify of new tree activations.
base::Closure tree_activation_callback_;
TaskGraphRunner* task_graph_runner_;
int id_;
std::set<SwapPromiseMonitor*> swap_promise_monitor_;
bool requires_high_res_to_draw_;
bool is_likely_to_require_a_draw_;
// TODO(danakj): Delete the compositor frame sink and all resources when
// it's lost instead of having this bool.
bool has_valid_compositor_frame_sink_;
std::unique_ptr<Viewport> viewport_;
std::unique_ptr<LayerTreeMutator> mutator_;
std::unique_ptr<PendingTreeDurationHistogramTimer>
pending_tree_duration_timer_;
// The id of the scroll node to which scroll animations must latch.
// This gets reset at ScrollAnimatedBegin, and updated the first time that a
// scroll animation is created in ScrollAnimated.
int scroll_animating_latched_node_id_;
// These callbacks are stored here to be transfered to the main thread when we
// begin main frame. These callbacks must only be called on the main thread.
std::vector<base::Closure> completed_image_decode_callbacks_;
// These are used to transfer usage of touch and wheel scrolls to the main
// thread.
bool has_scrolled_by_wheel_;
bool has_scrolled_by_touch_;
bool touchpad_and_wheel_scroll_latching_enabled_;
DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
};
} // namespace cc
#endif // CC_TREES_LAYER_TREE_HOST_IMPL_H_