#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/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/quads/render_pass.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/tile_manager.h"
+#include "cc/scheduler/draw_swap_readback_result.h"
#include "skia/ext/refptr.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/rect.h"
class LayerImpl;
class LayerTreeHostImplTimeSourceAdapter;
class LayerTreeImpl;
+class MemoryHistory;
class PageScaleAnimation;
class PaintTimeCounter;
-class MemoryHistory;
-class RenderingStatsInstrumentation;
+class RasterWorkerPool;
class RenderPassDrawQuad;
+class RenderingStatsInstrumentation;
+class ResourcePool;
class ScrollbarLayerImplBase;
class TextureMailboxDeleter;
class TopControlsManager;
class UIResourceBitmap;
class UIResourceRequest;
-struct RendererCapabilities;
+struct RendererCapabilitiesImpl;
// LayerTreeHost->Proxy callback interface.
class LayerTreeHostImplClient {
public:
+ virtual void UpdateRendererCapabilitiesOnImplThread() = 0;
virtual void DidLoseOutputSurfaceOnImplThread() = 0;
- virtual void OnSwapBuffersCompleteOnImplThread() = 0;
- virtual void BeginImplFrame(const BeginFrameArgs& args) = 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 BeginFrame(const BeginFrameArgs& args) = 0;
virtual void OnCanDrawStateChanged(bool can_draw) = 0;
virtual void NotifyReadyToActivate() = 0;
+ // Please call these 3 functions through
+ // LayerTreeHostImpl's SetNeedsRedraw(), SetNeedsRedrawRect() and
+ // SetNeedsAnimate().
virtual void SetNeedsRedrawOnImplThread() = 0;
- virtual void SetNeedsRedrawRectOnImplThread(gfx::Rect damage_rect) = 0;
+ virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) = 0;
+ virtual void SetNeedsAnimateOnImplThread() = 0;
virtual void DidInitializeVisibleTileOnImplThread() = 0;
virtual void SetNeedsCommitOnImplThread() = 0;
virtual void SetNeedsManageTilesOnImplThread() = 0;
virtual void PostAnimationEventsToMainThreadOnImplThread(
- scoped_ptr<AnimationEventsVector> events,
- base::Time wall_clock_time) = 0;
+ scoped_ptr<AnimationEventsVector> events) = 0;
// Returns true if resources were deleted by this call.
virtual bool ReduceContentsTextureMemoryOnImplThread(
size_t limit_bytes,
virtual void SendManagedMemoryStats() = 0;
virtual bool IsInsideDraw() = 0;
virtual void RenewTreePriority() = 0;
- virtual void RequestScrollbarAnimationOnImplThread(base::TimeDelta delay) = 0;
+ virtual void PostDelayedScrollbarFadeOnImplThread(
+ const base::Closure& start_fade,
+ base::TimeDelta delay) = 0;
virtual void DidActivatePendingTree() = 0;
+ virtual void DidManageTiles() = 0;
protected:
virtual ~LayerTreeHostImplClient() {}
public TileManagerClient,
public OutputSurfaceClient,
public TopControlsManagerClient,
+ public ScrollbarAnimationControllerClient,
public base::SupportsWeakPtr<LayerTreeHostImpl> {
public:
static scoped_ptr<LayerTreeHostImpl> Create(
LayerTreeHostImplClient* client,
Proxy* proxy,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
- SharedBitmapManager* manager);
+ SharedBitmapManager* manager,
+ int id);
virtual ~LayerTreeHostImpl();
// InputHandler implementation
virtual void BindToClient(InputHandlerClient* client) OVERRIDE;
virtual InputHandler::ScrollStatus ScrollBegin(
- gfx::Point viewport_point,
+ const gfx::Point& viewport_point,
InputHandler::ScrollInputType type) OVERRIDE;
- virtual bool ScrollBy(gfx::Point viewport_point,
- gfx::Vector2dF scroll_delta) OVERRIDE;
- virtual bool ScrollVerticallyByPage(gfx::Point viewport_point,
+ virtual bool ScrollBy(const gfx::Point& viewport_point,
+ const gfx::Vector2dF& scroll_delta) OVERRIDE;
+ virtual bool ScrollVerticallyByPage(const gfx::Point& viewport_point,
ScrollDirection direction) OVERRIDE;
virtual void SetRootLayerScrollOffsetDelegate(
LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) OVERRIDE;
virtual void OnRootLayerDelegatedScrollOffsetChanged() OVERRIDE;
virtual void ScrollEnd() OVERRIDE;
virtual InputHandler::ScrollStatus FlingScrollBegin() OVERRIDE;
- virtual void NotifyCurrentFlingVelocity(gfx::Vector2dF velocity) OVERRIDE;
- virtual void MouseMoveAt(gfx::Point viewport_point) OVERRIDE;
+ virtual void MouseMoveAt(const gfx::Point& viewport_point) OVERRIDE;
virtual void PinchGestureBegin() OVERRIDE;
virtual void PinchGestureUpdate(float magnify_delta,
- gfx::Point anchor) OVERRIDE;
+ const gfx::Point& anchor) OVERRIDE;
virtual void PinchGestureEnd() OVERRIDE;
- virtual void StartPageScaleAnimation(gfx::Vector2d target_offset,
+ virtual void StartPageScaleAnimation(const gfx::Vector2d& target_offset,
bool anchor_point,
float page_scale,
base::TimeDelta duration) OVERRIDE;
- virtual void ScheduleAnimation() OVERRIDE;
- virtual bool HaveTouchEventHandlersAt(gfx::Point viewport_port) OVERRIDE;
- virtual void SetLatencyInfoForInputEvent(const ui::LatencyInfo& latency_info)
- OVERRIDE;
+ virtual void SetNeedsAnimate() OVERRIDE;
+ virtual bool IsCurrentlyScrollingLayerAt(
+ const gfx::Point& viewport_point,
+ InputHandler::ScrollInputType type) OVERRIDE;
+ virtual bool HaveTouchEventHandlersAt(
+ const gfx::Point& viewport_port) OVERRIDE;
+ virtual scoped_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
+ ui::LatencyInfo* latency) OVERRIDE;
// TopControlsManagerClient implementation.
virtual void DidChangeTopControlsPosition() OVERRIDE;
virtual bool HaveRootScrollLayer() const OVERRIDE;
- void StartScrollbarAnimation();
-
struct CC_EXPORT FrameData : public RenderPassSink {
FrameData();
virtual ~FrameData();
virtual 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,
- base::Time wall_clock_time);
+ virtual void Animate(base::TimeTicks monotonic_time);
virtual void UpdateAnimationState(bool start_ready_animations);
+ void ActivateAnimations();
void MainThreadHasStoppedFlinging();
void UpdateBackgroundAnimateTicking(bool should_background_tick);
- void SetViewportDamage(gfx::Rect damage_rect);
+ void DidAnimateScrollOffset();
+ void SetViewportDamage(const gfx::Rect& damage_rect);
virtual void ManageTiles();
// to avoid displaying the frame. If PrepareToDraw is called, DidDrawAllLayers
// must also be called, regardless of whether DrawLayers is called between the
// two.
- virtual bool PrepareToDraw(FrameData* frame,
- gfx::Rect device_viewport_damage_rect);
+ virtual DrawSwapReadbackResult::DrawResult PrepareToDraw(
+ FrameData* frame,
+ const gfx::Rect& damage_rect);
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);
// excludes the URL bar and non-overlay scrollbars and is in DIP (and
// invariant relative to page scale).
gfx::SizeF UnscaledScrollableViewportSize() const;
+ float VerticalAdjust() const;
- // RendererClient implementation
-
- // 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.
- virtual gfx::Rect DeviceViewport() const OVERRIDE;
- virtual gfx::Rect DeviceClip() const OVERRIDE;
+ // RendererClient implementation.
virtual void SetFullRootLayerDamage() OVERRIDE;
- virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE;
// TileManagerClient implementation.
virtual void NotifyReadyToActivate() OVERRIDE;
+ virtual void NotifyTileInitialized(const Tile* tile) OVERRIDE;
+
+ // ScrollbarAnimationControllerClient implementation.
+ virtual void PostDelayedScrollbarFade(const base::Closure& start_fade,
+ base::TimeDelta delay) OVERRIDE;
+ virtual void SetNeedsScrollbarAnimationFrame() OVERRIDE;
// OutputSurfaceClient implementation.
- virtual bool DeferredInitialize(
- scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE;
+ virtual void DeferredInitialize() OVERRIDE;
virtual void ReleaseGL() OVERRIDE;
- virtual void SetNeedsRedrawRect(gfx::Rect rect) OVERRIDE;
- virtual void BeginImplFrame(const BeginFrameArgs& args) OVERRIDE;
+ virtual void CommitVSyncParameters(base::TimeTicks timebase,
+ base::TimeDelta interval) OVERRIDE;
+ virtual void SetNeedsRedrawRect(const gfx::Rect& rect) OVERRIDE;
+ virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE;
virtual void SetExternalDrawConstraints(
const gfx::Transform& transform,
- gfx::Rect viewport,
- gfx::Rect clip,
+ const gfx::Rect& viewport,
+ const gfx::Rect& clip,
bool valid_for_tile_management) OVERRIDE;
virtual void DidLoseOutputSurface() OVERRIDE;
- virtual void OnSwapBuffersComplete() OVERRIDE;
+ virtual void DidSwapBuffers() OVERRIDE;
+ virtual void DidSwapBuffersComplete() OVERRIDE;
virtual void ReclaimResources(const CompositorFrameAck* ack) OVERRIDE;
virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
virtual void SetTreeActivationCallback(const base::Closure& callback)
bool CanDraw() const;
OutputSurface* output_surface() const { return output_surface_.get(); }
- void SetOffscreenContextProvider(
- const scoped_refptr<ContextProvider>& offscreen_context_provider);
- ContextProvider* offscreen_context_provider() const {
- return offscreen_context_provider_.get();
- }
-
std::string LayerTreeAsJson() const;
void FinishAllRendering();
virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface);
bool IsContextLost();
TileManager* tile_manager() { return tile_manager_.get(); }
+ ResourcePool* resource_pool() { return resource_pool_.get(); }
Renderer* renderer() { return renderer_.get(); }
- const RendererCapabilities& GetRendererCapabilities() const;
+ const RendererCapabilitiesImpl& GetRendererCapabilities() const;
virtual bool SwapBuffers(const FrameData& frame);
- void SetNeedsBeginImplFrame(bool enable);
+ void SetNeedsBeginFrame(bool enable);
+ virtual void WillBeginImplFrame(const BeginFrameArgs& args);
void DidModifyTilePriorities();
- void Readback(void* pixels, gfx::Rect rect_in_device_viewport);
+ void Readback(void* pixels, const gfx::Rect& rect_in_device_viewport);
LayerTreeImpl* active_tree() { return active_tree_.get(); }
const LayerTreeImpl* active_tree() const { return active_tree_.get(); }
// Shortcuts to layers on the active tree.
LayerImpl* RootLayer() const;
- LayerImpl* RootScrollLayer() const;
+ LayerImpl* InnerViewportScrollLayer() const;
+ LayerImpl* OuterViewportScrollLayer() const;
LayerImpl* CurrentlyScrollingLayer() const;
- int scroll_layer_id_when_mouse_over_scrollbar() {
+ 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_;
+ }
bool IsCurrentlyScrolling() const;
bool visible() const { return visible_; }
void SetNeedsCommit() { client_->SetNeedsCommitOnImplThread(); }
- void SetNeedsRedraw() { client_->SetNeedsRedrawOnImplThread(); }
+ void SetNeedsRedraw();
ManagedMemoryPolicy ActualManagedMemoryPolicy() const;
size_t memory_allocation_limit_bytes() const;
int memory_allocation_priority_cutoff() const;
- void SetViewportSize(gfx::Size device_viewport_size);
+ void SetViewportSize(const gfx::Size& device_viewport_size);
+ gfx::Size device_viewport_size() const { return device_viewport_size_; }
void SetOverdrawBottomHeight(float overdraw_bottom_height);
float overdraw_bottom_height() const { return overdraw_bottom_height_; }
void SetOverhangUIResource(UIResourceId overhang_ui_resource_id,
- gfx::Size overhang_ui_resource_size);
+ const gfx::Size& overhang_ui_resource_size);
void SetDeviceScaleFactor(float device_scale_factor);
float device_scale_factor() const { return device_scale_factor_; }
TopControlsManager* top_controls_manager() {
return top_controls_manager_.get();
}
+ const GlobalStateThatImpactsTilePriority& global_tile_state() {
+ return global_tile_state_;
+ }
Proxy* proxy() const { return proxy_; }
gfx::Vector2dF accumulated_root_overscroll() const {
return accumulated_root_overscroll_;
}
- gfx::Vector2dF current_fling_velocity() const {
- return current_fling_velocity_;
- }
bool pinch_gesture_active() const { return pinch_gesture_active_; }
void SetTreePriority(TreePriority priority);
+ void UpdateCurrentFrameTime();
void ResetCurrentFrameTimeForNextFrame();
virtual base::TimeTicks CurrentFrameTimeTicks();
- base::Time CurrentFrameTime();
- virtual base::TimeTicks CurrentPhysicalTimeTicks() const;
+ // Expected time between two begin impl frame calls.
+ base::TimeDelta begin_impl_frame_interval() const {
+ return begin_impl_frame_interval_;
+ }
scoped_ptr<base::Value> AsValue() const { return AsValueWithFrame(NULL); }
scoped_ptr<base::Value> AsValueWithFrame(FrameData* frame) const;
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);
+
protected:
LayerTreeHostImpl(
const LayerTreeSettings& settings,
LayerTreeHostImplClient* client,
Proxy* proxy,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
- SharedBitmapManager* manager);
+ SharedBitmapManager* manager,
+ int id);
+
+ gfx::SizeF ComputeInnerViewportContainerSize() const;
+ void UpdateInnerViewportContainerSize();
// Virtual for testing.
- virtual void AnimateLayers(base::TimeTicks monotonic_time,
- base::Time wall_clock_time);
+ virtual void AnimateLayers(base::TimeTicks monotonic_time);
// Virtual for testing.
virtual base::TimeDelta LowFrequencyAnimationInterval() const;
bool skip_gl_renderer);
void CreateAndSetTileManager(ResourceProvider* resource_provider,
ContextProvider* context_provider,
- bool using_map_image);
+ bool use_zero_copy,
+ bool use_one_copy,
+ bool allow_rasterize_on_demand);
void ReleaseTreeResources();
void EnforceZeroBudget(bool zero_budget);
+ void ScrollViewportBy(gfx::Vector2dF scroll_delta);
void AnimatePageScale(base::TimeTicks monotonic_time);
void AnimateScrollbars(base::TimeTicks monotonic_time);
void AnimateTopControls(base::TimeTicks monotonic_time);
gfx::Vector2dF ScrollLayerWithViewportSpaceDelta(
LayerImpl* layer_impl,
float scale_from_viewport_to_screen_space,
- gfx::PointF viewport_point,
- gfx::Vector2dF viewport_delta);
+ const gfx::PointF& viewport_point,
+ const gfx::Vector2dF& viewport_delta);
- void UpdateMaxScrollOffset();
void TrackDamageForAllSurfaces(
LayerImpl* root_draw_layer,
const LayerImplList& render_surface_layer_list);
void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy);
- // Returns false if the frame should not be displayed. This function should
- // only be called from PrepareToDraw, as DidDrawAllLayers must be called
- // if this helper function is called.
- bool CalculateRenderPasses(FrameData* frame);
+ // 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.
+ DrawSwapReadbackResult::DrawResult CalculateRenderPasses(FrameData* frame);
- void SendReleaseResourcesRecursive(LayerImpl* current);
bool EnsureRenderSurfaceLayerList();
void ClearCurrentlyScrollingLayer();
bool HandleMouseOverScrollbar(LayerImpl* layer_impl,
- gfx::PointF device_viewport_point);
+ const gfx::PointF& device_viewport_point);
void AnimateScrollbarsRecursive(LayerImpl* layer,
base::TimeTicks time);
- void UpdateCurrentFrameTime(base::TimeTicks* ticks, base::Time* now) const;
-
LayerImpl* FindScrollLayerForDeviceViewportPoint(
- gfx::PointF device_viewport_point,
+ const gfx::PointF& device_viewport_point,
InputHandler::ScrollInputType type,
LayerImpl* layer_hit_by_point,
- bool* scroll_on_main_thread) const;
- float DeviceSpaceDistanceToLayer(gfx::PointF device_viewport_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 StartScrollbarAnimationRecursive(LayerImpl* layer, base::TimeTicks time);
+ void StartScrollbarFadeRecursive(LayerImpl* layer);
void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy,
bool zero_budget);
void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy);
void MarkUIResourceNotEvicted(UIResourceId uid);
+ void NotifySwapPromiseMonitorsOfSetNeedsRedraw();
+
typedef base::hash_map<UIResourceId, UIResourceData>
UIResourceMap;
UIResourceMap ui_resource_map_;
// free rendering - see OutputSurface::ForcedDrawToSoftwareDevice().
scoped_ptr<ResourceProvider> resource_provider_;
scoped_ptr<TileManager> tile_manager_;
+ scoped_ptr<RasterWorkerPool> raster_worker_pool_;
+ scoped_ptr<RasterWorkerPool> direct_raster_worker_pool_;
+ scoped_ptr<ResourcePool> resource_pool_;
+ scoped_ptr<ResourcePool> staging_resource_pool_;
scoped_ptr<Renderer> renderer_;
GlobalStateThatImpactsTilePriority global_tile_state_;
InputHandlerClient* input_handler_client_;
bool did_lock_scrolling_layer_;
bool should_bubble_scrolls_;
- bool last_scroll_did_bubble_;
bool wheel_scrolling_;
+ bool scroll_affects_scroll_handler_;
int scroll_layer_id_when_mouse_over_scrollbar_;
bool tile_priorities_dirty_;
ManagedMemoryPolicy cached_managed_memory_policy_;
gfx::Vector2dF accumulated_root_overscroll_;
- gfx::Vector2dF current_fling_velocity_;
bool pinch_gesture_active_;
bool pinch_gesture_end_should_clear_scrolling_layer_;
gfx::Point previous_pinch_anchor_;
- // This is set by AnimateLayers() and used by UpdateAnimationState()
- // when sending animation events to the main thread.
- base::Time last_animation_time_;
-
scoped_ptr<TopControlsManager> top_controls_manager_;
scoped_ptr<PageScaleAnimation> page_scale_animation_;
// - external_viewport_ is used DrawProperties, tile management and
// glViewport/window projection matrix.
// - external_clip_ specifies a top-level clip rect
- // - external_stencil_test_enabled_ tells CC to respect existing stencil bits
- // (When these are specified, device_viewport_size_ remains used only for
- // scrollable size.)
gfx::Transform external_transform_;
gfx::Rect external_viewport_;
gfx::Rect external_clip_;
bool device_viewport_valid_for_tile_management_;
- bool external_stencil_test_enabled_;
gfx::Rect viewport_damage_rect_;
base::TimeTicks current_frame_timeticks_;
- base::Time current_frame_time_;
+
+ // 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_;
bool need_to_update_visible_tiles_before_draw_;
+#if DCHECK_IS_ON
+ bool did_lose_called_;
+#endif
// Optional callback to notify of new tree activations.
base::Closure tree_activation_callback_;
SharedBitmapManager* shared_bitmap_manager_;
+ int id_;
+
+ std::set<SwapPromiseMonitor*> swap_promise_monitor_;
+
+ size_t transfer_buffer_memory_limit_;
DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
};