#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "base/values.h"
-#include "cc/debug/rendering_stats.h"
+#include "cc/base/swap_promise.h"
+#include "cc/base/swap_promise_monitor.h"
#include "cc/input/top_controls_state.h"
#include "cc/trees/layer_tree_host_client.h"
+#include "cc/trees/layer_tree_host_single_thread_client.h"
#include "cc/trees/layer_tree_settings.h"
+#include "content/common/content_export.h"
#include "third_party/WebKit/public/platform/WebLayerTreeView.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/gfx/rect.h"
namespace content {
class RenderWidget;
-class RenderWidgetCompositor : public WebKit::WebLayerTreeView,
- public cc::LayerTreeHostClient {
+class CONTENT_EXPORT RenderWidgetCompositor
+ : NON_EXPORTED_BASE(public blink::WebLayerTreeView),
+ NON_EXPORTED_BASE(public cc::LayerTreeHostClient),
+ NON_EXPORTED_BASE(public cc::LayerTreeHostSingleThreadClient) {
public:
// Attempt to construct and initialize a compositor instance for the widget
// with the given settings. Returns NULL if initialization fails.
virtual ~RenderWidgetCompositor();
const base::WeakPtr<cc::InputHandler>& GetInputHandler();
- void SetSuppressScheduleComposite(bool suppress);
bool BeginMainFrameRequested() const;
- void Animate(base::TimeTicks time);
- void Composite(base::TimeTicks frame_begin_time);
void SetNeedsDisplayOnAllLayers();
void SetRasterizeOnlyVisibleContent();
- void GetRenderingStats(cc::RenderingStats* stats);
void UpdateTopControlsState(cc::TopControlsState constraints,
cc::TopControlsState current,
bool animate);
- void SetOverdrawBottomHeight(float overdraw_bottom_height);
+ void SetTopControlsLayoutHeight(float height);
void SetNeedsRedrawRect(gfx::Rect damage_rect);
// Like setNeedsRedraw but forces the frame to be drawn, without early-outs.
// Redraw will be forced after the next commit
void SetNeedsForcedRedraw();
- void SetLatencyInfo(const ui::LatencyInfo& latency_info);
+ // Calling CreateLatencyInfoSwapPromiseMonitor() to get a scoped
+ // LatencyInfoSwapPromiseMonitor. During the life time of the
+ // LatencyInfoSwapPromiseMonitor, if SetNeedsCommit() or SetNeedsUpdateLayer()
+ // is called on LayerTreeHost, the original latency info will be turned
+ // into a LatencyInfoSwapPromise.
+ scoped_ptr<cc::SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
+ ui::LatencyInfo* latency);
+ // Calling QueueSwapPromise() to directly queue a SwapPromise into
+ // LayerTreeHost.
+ void QueueSwapPromise(scoped_ptr<cc::SwapPromise> swap_promise);
int GetLayerTreeId() const;
+ int GetSourceFrameNumber() const;
+ void SetNeedsCommit();
void NotifyInputThrottledUntilCommit();
const cc::Layer* GetRootLayer() const;
- bool ScheduleMicroBenchmark(
+ int ScheduleMicroBenchmark(
const std::string& name,
scoped_ptr<base::Value> value,
const base::Callback<void(scoped_ptr<base::Value>)>& callback);
+ bool SendMessageToMicroBenchmark(int id, scoped_ptr<base::Value> value);
// WebLayerTreeView implementation.
virtual void setSurfaceReady();
- virtual void setRootLayer(const WebKit::WebLayer& layer);
+ virtual void setRootLayer(const blink::WebLayer& layer);
virtual void clearRootLayer();
virtual void setViewportSize(
- const WebKit::WebSize& unused_deprecated,
- const WebKit::WebSize& device_viewport_size);
- virtual WebKit::WebSize layoutViewportSize() const;
- virtual WebKit::WebSize deviceViewportSize() const;
- virtual WebKit::WebFloatPoint adjustEventPointForPinchZoom(
- const WebKit::WebFloatPoint& point) const;
+ const blink::WebSize& unused_deprecated,
+ const blink::WebSize& device_viewport_size);
+ virtual void setViewportSize(const blink::WebSize& device_viewport_size);
+ virtual blink::WebSize layoutViewportSize() const;
+ virtual blink::WebSize deviceViewportSize() const;
+ virtual blink::WebFloatPoint adjustEventPointForPinchZoom(
+ const blink::WebFloatPoint& point) const;
virtual void setDeviceScaleFactor(float device_scale);
virtual float deviceScaleFactor() const;
- virtual void setBackgroundColor(WebKit::WebColor color);
+ virtual void setBackgroundColor(blink::WebColor color);
virtual void setHasTransparentBackground(bool transparent);
virtual void setOverhangBitmap(const SkBitmap& bitmap);
virtual void setVisible(bool visible);
virtual void setPageScaleFactorAndLimits(float page_scale_factor,
float minimum,
float maximum);
- virtual void startPageScaleAnimation(const WebKit::WebPoint& destination,
+ virtual void startPageScaleAnimation(const blink::WebPoint& destination,
bool use_anchor,
float new_page_scale,
double duration_sec);
+ virtual void heuristicsForGpuRasterizationUpdated(bool matches_heuristics);
virtual void setNeedsAnimate();
- virtual void setNeedsRedraw();
virtual bool commitRequested() const;
virtual void didStopFlinging();
- virtual bool compositeAndReadback(void *pixels, const WebKit::WebRect& rect);
+ virtual void compositeAndReadbackAsync(
+ blink::WebCompositeAndReadbackAsyncCallback* callback);
virtual void finishAllRendering();
virtual void setDeferCommits(bool defer_commits);
- virtual void registerForAnimations(WebKit::WebLayer* layer);
+ virtual void registerForAnimations(blink::WebLayer* layer);
virtual void registerViewportLayers(
- const WebKit::WebLayer* pageScaleLayer,
- const WebKit::WebLayer* innerViewportScrollLayer,
- const WebKit::WebLayer* outerViewportScrollLayer) OVERRIDE;
+ const blink::WebLayer* pageScaleLayer,
+ const blink::WebLayer* innerViewportScrollLayer,
+ const blink::WebLayer* outerViewportScrollLayer) OVERRIDE;
virtual void clearViewportLayers() OVERRIDE;
- virtual void renderingStats(WebKit::WebRenderingStats& stats) const {}
+ virtual void registerSelection(const blink::WebSelectionBound& start,
+ const blink::WebSelectionBound& end) OVERRIDE;
+ virtual void clearSelection() OVERRIDE;
virtual void setShowFPSCounter(bool show);
virtual void setShowPaintRects(bool show);
virtual void setShowDebugBorders(bool show);
virtual void setContinuousPaintingEnabled(bool enabled);
virtual void setShowScrollBottleneckRects(bool show);
+ virtual void setTopControlsContentOffset(float);
// cc::LayerTreeHostClient implementation.
- virtual void WillBeginMainFrame() OVERRIDE;
+ virtual void WillBeginMainFrame(int frame_id) OVERRIDE;
virtual void DidBeginMainFrame() OVERRIDE;
- virtual void Animate(double frame_begin_time) OVERRIDE;
+ virtual void BeginMainFrame(const cc::BeginFrameArgs& args) OVERRIDE;
virtual void Layout() OVERRIDE;
- virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta,
- float page_scale) OVERRIDE;
- virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback)
- OVERRIDE;
- virtual void DidInitializeOutputSurface(bool success) OVERRIDE;
+ virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
+ float page_scale,
+ float top_controls_delta) OVERRIDE;
+ virtual void RequestNewOutputSurface(bool fallback) OVERRIDE;
+ virtual void DidInitializeOutputSurface() OVERRIDE;
virtual void WillCommit() OVERRIDE;
virtual void DidCommit() OVERRIDE;
virtual void DidCommitAndDrawFrame() OVERRIDE;
virtual void DidCompleteSwapBuffers() OVERRIDE;
- virtual void ScheduleComposite() OVERRIDE;
- virtual scoped_refptr<cc::ContextProvider>
- OffscreenContextProvider() OVERRIDE;
+ virtual void RateLimitSharedMainThreadContext() OVERRIDE;
+
+ // cc::LayerTreeHostSingleThreadClient implementation.
+ virtual void ScheduleAnimation() OVERRIDE;
+ virtual void DidPostSwapBuffers() OVERRIDE;
+ virtual void DidAbortSwapBuffers() OVERRIDE;
private:
RenderWidgetCompositor(RenderWidget* widget, bool threaded);
- bool initialize(cc::LayerTreeSettings settings);
+ void Initialize(cc::LayerTreeSettings settings);
bool threaded_;
- bool suppress_schedule_composite_;
RenderWidget* widget_;
scoped_ptr<cc::LayerTreeHost> layer_tree_host_;
+
+ bool send_v8_idle_notification_after_commit_;
+ base::TimeTicks begin_main_frame_time_;
+ // The time interval between BeginMainFrame calls, provided by the scheduler.
+ base::TimeDelta begin_main_frame_interval_;
};
} // namespace content
projects / platform / framework / web / crosswalk.git / blobdiff