| OLD | NEW |
|---|
| (Empty) |
| 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_SOLID_COLOR), | |
| 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_.SetShowSolidColorContent(); | |
| 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 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
