1// Copyright (c) 2013 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 CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
6#define CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
7
8#include "base/callback.h"
9#include "base/memory/weak_ptr.h"
10#include "base/time/time.h"
11#include "base/values.h"
12#include "cc/base/swap_promise.h"
13#include "cc/base/swap_promise_monitor.h"
14#include "cc/input/top_controls_state.h"
15#include "cc/trees/layer_tree_host_client.h"
16#include "cc/trees/layer_tree_host_single_thread_client.h"
17#include "cc/trees/layer_tree_settings.h"
18#include "content/common/content_export.h"
19#include "third_party/WebKit/public/platform/WebLayerTreeView.h"
20#include "third_party/skia/include/core/SkBitmap.h"
21#include "ui/gfx/rect.h"
22
23namespace ui {
24struct LatencyInfo;
25}
26
27namespace cc {
28class InputHandler;
29class Layer;
30class LayerTreeHost;
31}
32
33namespace content {
34class RenderWidget;
35
36class CONTENT_EXPORT RenderWidgetCompositor
37    : NON_EXPORTED_BASE(public blink::WebLayerTreeView),
38      NON_EXPORTED_BASE(public cc::LayerTreeHostClient),
39      NON_EXPORTED_BASE(public cc::LayerTreeHostSingleThreadClient) {
40 public:
41  // Attempt to construct and initialize a compositor instance for the widget
42  // with the given settings. Returns NULL if initialization fails.
43  static scoped_ptr<RenderWidgetCompositor> Create(RenderWidget* widget,
44                                                   bool threaded);
45
46  virtual ~RenderWidgetCompositor();
47
48  const base::WeakPtr<cc::InputHandler>& GetInputHandler();
49  bool BeginMainFrameRequested() const;
50  void SetNeedsDisplayOnAllLayers();
51  void SetRasterizeOnlyVisibleContent();
52  void UpdateTopControlsState(cc::TopControlsState constraints,
53                              cc::TopControlsState current,
54                              bool animate);
55  void SetTopControlsLayoutHeight(float height);
56  void SetNeedsRedrawRect(gfx::Rect damage_rect);
57  // Like setNeedsRedraw but forces the frame to be drawn, without early-outs.
58  // Redraw will be forced after the next commit
59  void SetNeedsForcedRedraw();
60  // Calling CreateLatencyInfoSwapPromiseMonitor() to get a scoped
61  // LatencyInfoSwapPromiseMonitor. During the life time of the
62  // LatencyInfoSwapPromiseMonitor, if SetNeedsCommit() or SetNeedsUpdateLayer()
63  // is called on LayerTreeHost, the original latency info will be turned
64  // into a LatencyInfoSwapPromise.
65  scoped_ptr<cc::SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
66      ui::LatencyInfo* latency);
67  // Calling QueueSwapPromise() to directly queue a SwapPromise into
68  // LayerTreeHost.
69  void QueueSwapPromise(scoped_ptr<cc::SwapPromise> swap_promise);
70  int GetLayerTreeId() const;
71  int GetSourceFrameNumber() const;
72  void SetNeedsCommit();
73  void NotifyInputThrottledUntilCommit();
74  const cc::Layer* GetRootLayer() const;
75  int ScheduleMicroBenchmark(
76      const std::string& name,
77      scoped_ptr<base::Value> value,
78      const base::Callback<void(scoped_ptr<base::Value>)>& callback);
79  bool SendMessageToMicroBenchmark(int id, scoped_ptr<base::Value> value);
80
81  // WebLayerTreeView implementation.
82  virtual void setSurfaceReady();
83  virtual void setRootLayer(const blink::WebLayer& layer);
84  virtual void clearRootLayer();
85  virtual void setViewportSize(
86      const blink::WebSize& unused_deprecated,
87      const blink::WebSize& device_viewport_size);
88  virtual void setViewportSize(const blink::WebSize& device_viewport_size);
89  virtual blink::WebSize layoutViewportSize() const;
90  virtual blink::WebSize deviceViewportSize() const;
91  virtual blink::WebFloatPoint adjustEventPointForPinchZoom(
92      const blink::WebFloatPoint& point) const;
93  virtual void setDeviceScaleFactor(float device_scale);
94  virtual float deviceScaleFactor() const;
95  virtual void setBackgroundColor(blink::WebColor color);
96  virtual void setHasTransparentBackground(bool transparent);
97  virtual void setOverhangBitmap(const SkBitmap& bitmap);
98  virtual void setVisible(bool visible);
99  virtual void setPageScaleFactorAndLimits(float page_scale_factor,
100                                           float minimum,
101                                           float maximum);
102  virtual void startPageScaleAnimation(const blink::WebPoint& destination,
103                                       bool use_anchor,
104                                       float new_page_scale,
105                                       double duration_sec);
106  virtual void heuristicsForGpuRasterizationUpdated(bool matches_heuristics);
107  virtual void setNeedsAnimate();
108  virtual bool commitRequested() const;
109  virtual void didStopFlinging();
110  virtual void compositeAndReadbackAsync(
111      blink::WebCompositeAndReadbackAsyncCallback* callback);
112  virtual void finishAllRendering();
113  virtual void setDeferCommits(bool defer_commits);
114  virtual void registerForAnimations(blink::WebLayer* layer);
115  virtual void registerViewportLayers(
116      const blink::WebLayer* pageScaleLayer,
117      const blink::WebLayer* innerViewportScrollLayer,
118      const blink::WebLayer* outerViewportScrollLayer) OVERRIDE;
119  virtual void clearViewportLayers() OVERRIDE;
120  virtual void registerSelection(const blink::WebSelectionBound& start,
121                                 const blink::WebSelectionBound& end) OVERRIDE;
122  virtual void clearSelection() OVERRIDE;
123  virtual void setShowFPSCounter(bool show);
124  virtual void setShowPaintRects(bool show);
125  virtual void setShowDebugBorders(bool show);
126  virtual void setContinuousPaintingEnabled(bool enabled);
127  virtual void setShowScrollBottleneckRects(bool show);
128  virtual void setTopControlsContentOffset(float);
129
130  // cc::LayerTreeHostClient implementation.
131  virtual void WillBeginMainFrame(int frame_id) OVERRIDE;
132  virtual void DidBeginMainFrame() OVERRIDE;
133  virtual void BeginMainFrame(const cc::BeginFrameArgs& args) OVERRIDE;
134  virtual void Layout() OVERRIDE;
135  virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
136                                   float page_scale,
137                                   float top_controls_delta) OVERRIDE;
138  virtual void RequestNewOutputSurface(bool fallback) OVERRIDE;
139  virtual void DidInitializeOutputSurface() OVERRIDE;
140  virtual void WillCommit() OVERRIDE;
141  virtual void DidCommit() OVERRIDE;
142  virtual void DidCommitAndDrawFrame() OVERRIDE;
143  virtual void DidCompleteSwapBuffers() OVERRIDE;
144  virtual void RateLimitSharedMainThreadContext() OVERRIDE;
145
146  // cc::LayerTreeHostSingleThreadClient implementation.
147  virtual void ScheduleAnimation() OVERRIDE;
148  virtual void DidPostSwapBuffers() OVERRIDE;
149  virtual void DidAbortSwapBuffers() OVERRIDE;
150
151 private:
152  RenderWidgetCompositor(RenderWidget* widget, bool threaded);
153
154  void Initialize(cc::LayerTreeSettings settings);
155
156  bool threaded_;
157  RenderWidget* widget_;
158  scoped_ptr<cc::LayerTreeHost> layer_tree_host_;
159
160  bool send_v8_idle_notification_after_commit_;
161  base::TimeTicks begin_main_frame_time_;
162  // The time interval between BeginMainFrame calls, provided by the scheduler.
163  base::TimeDelta begin_main_frame_interval_;
164};
165
166}  // namespace content
167
168#endif  // CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
169