1 // Copyright (c) 2012 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 #include "base/at_exit.h"
6 #include "base/bind.h"
7 #include "base/command_line.h"
8 #include "base/i18n/icu_util.h"
9 #include "base/memory/scoped_ptr.h"
10 #include "base/message_loop/message_loop.h"
11 #include "base/strings/string_split.h"
12 #include "base/time/time.h"
13 #include "cc/output/context_provider.h"
14 #include "gpu/command_buffer/client/gles2_interface.h"
15 #include "third_party/khronos/GLES2/gl2.h"
16 #include "third_party/skia/include/core/SkXfermode.h"
17 #include "ui/aura/client/default_capture_client.h"
18 #include "ui/aura/env.h"
19 #include "ui/aura/root_window.h"
20 #include "ui/aura/test/test_focus_client.h"
21 #include "ui/aura/test/test_screen.h"
22 #include "ui/aura/window.h"
23 #include "ui/base/hit_test.h"
24 #include "ui/base/resource/resource_bundle.h"
25 #include "ui/base/ui_base_paths.h"
26 #include "ui/compositor/compositor.h"
27 #include "ui/compositor/compositor_observer.h"
28 #include "ui/compositor/debug_utils.h"
29 #include "ui/compositor/layer.h"
30 #include "ui/compositor/test/context_factories_for_test.h"
31 #include "ui/gfx/canvas.h"
32 #include "ui/gfx/rect.h"
33 #include "ui/gfx/skia_util.h"
34 #ifndef GL_GLEXT_PROTOTYPES
35 #define GL_GLEXT_PROTOTYPES 1
36 #endif
37 #include "third_party/khronos/GLES2/gl2ext.h"
38
39 #if defined(USE_X11)
40 #include "base/message_loop/message_pump_x11.h"
41 #endif
42
43 using base::TimeTicks;
44 using ui::Compositor;
45 using ui::Layer;
46 using ui::LayerDelegate;
47 using blink::WebGraphicsContext3D;
48
49 namespace {
50
51 class ColoredLayer : public Layer, public LayerDelegate {
52 public:
ColoredLayer(SkColor color)53 explicit ColoredLayer(SkColor color)
54 : Layer(ui::LAYER_TEXTURED),
55 color_(color),
56 draw_(true) {
57 set_delegate(this);
58 }
59
~ColoredLayer()60 virtual ~ColoredLayer() {}
61
62 // Overridden from LayerDelegate:
OnPaintLayer(gfx::Canvas * canvas)63 virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
64 if (draw_) {
65 canvas->DrawColor(color_);
66 }
67 }
68
OnDeviceScaleFactorChanged(float device_scale_factor)69 virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
70 }
71
PrepareForLayerBoundsChange()72 virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
73 return base::Closure();
74 }
75
set_color(SkColor color)76 void set_color(SkColor color) { color_ = color; }
set_draw(bool draw)77 void set_draw(bool draw) { draw_ = draw; }
78
79 private:
80 SkColor color_;
81 bool draw_;
82
83 DISALLOW_COPY_AND_ASSIGN(ColoredLayer);
84 };
85
86 const int kFrames = 100;
87
88 // Benchmark base class, hooks up drawing callback and displaying FPS.
89 class BenchCompositorObserver : public ui::CompositorObserver {
90 public:
BenchCompositorObserver(int max_frames)91 explicit BenchCompositorObserver(int max_frames)
92 : start_time_(),
93 frames_(0),
94 max_frames_(max_frames) {
95 }
96
OnCompositingDidCommit(ui::Compositor * compositor)97 virtual void OnCompositingDidCommit(ui::Compositor* compositor) OVERRIDE {}
98
OnCompositingStarted(Compositor * compositor,base::TimeTicks start_time)99 virtual void OnCompositingStarted(Compositor* compositor,
100 base::TimeTicks start_time) OVERRIDE {}
101
OnCompositingEnded(Compositor * compositor)102 virtual void OnCompositingEnded(Compositor* compositor) OVERRIDE {
103 if (start_time_.is_null()) {
104 start_time_ = TimeTicks::Now();
105 } else {
106 ++frames_;
107 if (frames_ % kFrames == 0) {
108 TimeTicks now = TimeTicks::Now();
109 double ms = (now - start_time_).InMillisecondsF() / kFrames;
110 LOG(INFO) << "FPS: " << 1000.f / ms << " (" << ms << " ms)";
111 start_time_ = now;
112 }
113 }
114 if (max_frames_ && frames_ == max_frames_) {
115 base::MessageLoop::current()->Quit();
116 } else {
117 Draw();
118 }
119 }
120
OnCompositingAborted(Compositor * compositor)121 virtual void OnCompositingAborted(Compositor* compositor) OVERRIDE {}
122
OnCompositingLockStateChanged(Compositor * compositor)123 virtual void OnCompositingLockStateChanged(
124 Compositor* compositor) OVERRIDE {}
125
OnUpdateVSyncParameters(ui::Compositor * compositor,base::TimeTicks timebase,base::TimeDelta interval)126 virtual void OnUpdateVSyncParameters(ui::Compositor* compositor,
127 base::TimeTicks timebase,
128 base::TimeDelta interval) OVERRIDE {
129 }
130
Draw()131 virtual void Draw() {}
132
frames() const133 int frames() const { return frames_; }
134
135 private:
136 TimeTicks start_time_;
137 int frames_;
138 int max_frames_;
139
140 DISALLOW_COPY_AND_ASSIGN(BenchCompositorObserver);
141 };
142
143 class WebGLTexture : public ui::Texture {
144 public:
WebGLTexture(gpu::gles2::GLES2Interface * gl,const gfx::Size & size)145 WebGLTexture(gpu::gles2::GLES2Interface* gl, const gfx::Size& size)
146 : ui::Texture(false, size, 1.0f),
147 gl_(gl),
148 texture_id_(0u) {
149 gl->GenTextures(1, &texture_id_);
150 gl->BindTexture(GL_TEXTURE_2D, texture_id_);
151 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
152 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
153 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
154 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
155 gl->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(),
156 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
157 }
158
PrepareTexture()159 virtual unsigned int PrepareTexture() OVERRIDE {
160 return texture_id_;
161 }
162
163 private:
~WebGLTexture()164 virtual ~WebGLTexture() {
165 gl_->DeleteTextures(1, &texture_id_);
166 }
167
168 gpu::gles2::GLES2Interface* gl_;
169 GLuint texture_id_;
170
171 DISALLOW_COPY_AND_ASSIGN(WebGLTexture);
172 };
173
174 // A benchmark that adds a texture layer that is updated every frame.
175 class WebGLBench : public BenchCompositorObserver {
176 public:
WebGLBench(Layer * parent,Compositor * compositor,int max_frames)177 WebGLBench(Layer* parent, Compositor* compositor, int max_frames)
178 : BenchCompositorObserver(max_frames),
179 parent_(parent),
180 webgl_(ui::LAYER_TEXTURED),
181 compositor_(compositor),
182 texture_(),
183 fbo_(0),
184 do_draw_(true) {
185 CommandLine* command_line = CommandLine::ForCurrentProcess();
186 do_draw_ = !command_line->HasSwitch("disable-draw");
187
188 std::string webgl_size = command_line->GetSwitchValueASCII("webgl-size");
189 int width = 0;
190 int height = 0;
191 if (!webgl_size.empty()) {
192 std::vector<std::string> split_size;
193 base::SplitString(webgl_size, 'x', &split_size);
194 if (split_size.size() == 2) {
195 width = atoi(split_size[0].c_str());
196 height = atoi(split_size[1].c_str());
197 }
198 }
199 if (!width || !height) {
200 width = 800;
201 height = 600;
202 }
203 gfx::Rect bounds(width, height);
204 webgl_.SetBounds(bounds);
205 parent_->Add(&webgl_);
206
207 context_provider_ =
208 ui::ContextFactory::GetInstance()->SharedMainThreadContextProvider();
209 gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
210 texture_ = new WebGLTexture(gl, bounds.size());
211 gl->GenFramebuffers(1, &fbo_);
212 compositor->AddObserver(this);
213 webgl_.SetExternalTexture(texture_.get());
214 gl->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
215 gl->FramebufferTexture2D(
216 GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
217 GL_TEXTURE_2D, texture_->PrepareTexture(), 0);
218 gl->ClearColor(0.f, 1.f, 0.f, 1.f);
219 gl->Clear(GL_COLOR_BUFFER_BIT);
220 gl->Flush();
221 }
222
~WebGLBench()223 virtual ~WebGLBench() {
224 context_provider_->ContextGL()->DeleteFramebuffers(1, &fbo_);
225 webgl_.SetShowPaintedContent();
226 texture_ = NULL;
227 compositor_->RemoveObserver(this);
228 }
229
Draw()230 virtual void Draw() OVERRIDE {
231 if (do_draw_) {
232 gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
233 gl->ClearColor((frames() % kFrames)*1.0/kFrames, 1.f, 0.f, 1.f);
234 gl->Clear(GL_COLOR_BUFFER_BIT);
235 gl->Flush();
236 }
237 webgl_.SetExternalTexture(texture_.get());
238 webgl_.SchedulePaint(gfx::Rect(webgl_.bounds().size()));
239 compositor_->ScheduleDraw();
240 }
241
242 private:
243 Layer* parent_;
244 Layer webgl_;
245 Compositor* compositor_;
246 scoped_refptr<cc::ContextProvider> context_provider_;
247 scoped_refptr<WebGLTexture> texture_;
248
249 // The FBO that is used to render to the texture.
250 unsigned int fbo_;
251
252 // Whether or not to draw to the texture every frame.
253 bool do_draw_;
254
255 DISALLOW_COPY_AND_ASSIGN(WebGLBench);
256 };
257
258 // A benchmark that paints (in software) all tiles every frame.
259 class SoftwareScrollBench : public BenchCompositorObserver {
260 public:
SoftwareScrollBench(ColoredLayer * layer,Compositor * compositor,int max_frames)261 SoftwareScrollBench(ColoredLayer* layer,
262 Compositor* compositor,
263 int max_frames)
264 : BenchCompositorObserver(max_frames),
265 layer_(layer),
266 compositor_(compositor) {
267 compositor->AddObserver(this);
268 layer_->set_draw(
269 !CommandLine::ForCurrentProcess()->HasSwitch("disable-draw"));
270 }
271
~SoftwareScrollBench()272 virtual ~SoftwareScrollBench() {
273 compositor_->RemoveObserver(this);
274 }
275
Draw()276 virtual void Draw() OVERRIDE {
277 layer_->set_color(
278 SkColorSetARGBInline(255*(frames() % kFrames)/kFrames, 255, 0, 255));
279 layer_->SchedulePaint(gfx::Rect(layer_->bounds().size()));
280 }
281
282 private:
283 ColoredLayer* layer_;
284 Compositor* compositor_;
285
286 DISALLOW_COPY_AND_ASSIGN(SoftwareScrollBench);
287 };
288
289 } // namespace
290
main(int argc,char ** argv)291 int main(int argc, char** argv) {
292 CommandLine::Init(argc, argv);
293
294 base::AtExitManager exit_manager;
295
296 // The ContextFactory must exist before any Compositors are created.
297 bool allow_test_contexts = false;
298 ui::InitializeContextFactoryForTests(allow_test_contexts);
299
300 ui::RegisterPathProvider();
301 base::i18n::InitializeICU();
302 ResourceBundle::InitSharedInstanceWithLocale("en-US", NULL);
303
304 base::MessageLoop message_loop(base::MessageLoop::TYPE_UI);
305 aura::Env::CreateInstance();
306 scoped_ptr<aura::TestScreen> test_screen(
307 aura::TestScreen::CreateFullscreen());
308 gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, test_screen.get());
309 scoped_ptr<aura::RootWindow> root_window(
310 test_screen->CreateRootWindowForPrimaryDisplay());
311 aura::client::SetCaptureClient(
312 root_window->window(),
313 new aura::client::DefaultCaptureClient(root_window->window()));
314
315 scoped_ptr<aura::client::FocusClient> focus_client(
316 new aura::test::TestFocusClient);
317 aura::client::SetFocusClient(root_window->window(), focus_client.get());
318
319 // add layers
320 ColoredLayer background(SK_ColorRED);
321 background.SetBounds(root_window->window()->bounds());
322 root_window->window()->layer()->Add(&background);
323
324 ColoredLayer window(SK_ColorBLUE);
325 window.SetBounds(gfx::Rect(background.bounds().size()));
326 background.Add(&window);
327
328 Layer content_layer(ui::LAYER_NOT_DRAWN);
329
330 CommandLine* command_line = CommandLine::ForCurrentProcess();
331 bool force = command_line->HasSwitch("force-render-surface");
332 content_layer.SetForceRenderSurface(force);
333 gfx::Rect bounds(window.bounds().size());
334 bounds.Inset(0, 30, 0, 0);
335 content_layer.SetBounds(bounds);
336 window.Add(&content_layer);
337
338 ColoredLayer page_background(SK_ColorWHITE);
339 page_background.SetBounds(gfx::Rect(content_layer.bounds().size()));
340 content_layer.Add(&page_background);
341
342 int frames = atoi(command_line->GetSwitchValueASCII("frames").c_str());
343 scoped_ptr<BenchCompositorObserver> bench;
344
345 if (command_line->HasSwitch("bench-software-scroll")) {
346 bench.reset(new SoftwareScrollBench(&page_background,
347 root_window->compositor(),
348 frames));
349 } else {
350 bench.reset(new WebGLBench(&page_background,
351 root_window->compositor(),
352 frames));
353 }
354
355 #ifndef NDEBUG
356 ui::PrintLayerHierarchy(root_window->window()->layer(), gfx::Point(100, 100));
357 #endif
358
359 root_window->host()->Show();
360 base::MessageLoopForUI::current()->Run();
361 focus_client.reset();
362 root_window.reset();
363
364 return 0;
365 }
366