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