cc/CCThreadedTest.cpp

   1 // Copyright 2011 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 "config.h"
   6
   7 #include "CCThreadedTest.h"
   8
   9 #include "CCActiveAnimation.h"
  10 #include "CCAnimationTestCommon.h"
  11 #include "CCInputHandler.h"
  12 #include "CCLayerAnimationController.h"
  13 #include "CCLayerImpl.h"
  14 #include "CCLayerTreeHostImpl.h"
  15 #include "CCOcclusionTrackerTestCommon.h"
  16 #include "CCScopedThreadProxy.h"
  17 #include "CCSingleThreadProxy.h"
  18 #include "CCTextureUpdateQueue.h"
  19 #include "CCThreadTask.h"
  20 #include "CCTiledLayerTestCommon.h"
  21 #include "CCTimingFunction.h"
  22 #include "ContentLayerChromium.h"
  23 #include "FakeWebCompositorOutputSurface.h"
  24 #include "FakeWebGraphicsContext3D.h"
  25 #include "LayerChromium.h"
  26 #include <gmock/gmock.h>
  27 #include <public/Platform.h>
  28 #include <public/WebCompositorSupport.h>
  29 #include <public/WebFilterOperation.h>
  30 #include <public/WebFilterOperations.h>
  31 #include <public/WebThread.h>
  32 #include <wtf/Locker.h>
  33 #include <wtf/MainThread.h>
  34 #include <wtf/PassRefPtr.h>
  35 #include <wtf/ThreadingPrimitives.h>
  36 #include <wtf/Vector.h>
  37
  38 using namespace WebCore;
  39 using namespace WebKit;
  40
  41 namespace WebKitTests {
  42
  43 PassOwnPtr<CompositorFakeWebGraphicsContext3DWithTextureTracking> CompositorFakeWebGraphicsContext3DWithTextureTracking::create(Attributes attrs)
  44 {
  45     return adoptPtr(new CompositorFakeWebGraphicsContext3DWithTextureTracking(attrs));
  46 }
  47
  48 WebGLId CompositorFakeWebGraphicsContext3DWithTextureTracking::createTexture()
  49 {
  50     WebGLId texture = m_textures.size() + 1;
  51     m_textures.append(texture);
  52     return texture;
  53 }
  54
  55 void CompositorFakeWebGraphicsContext3DWithTextureTracking::deleteTexture(WebGLId texture)
  56 {
  57     for (size_t i = 0; i < m_textures.size(); i++) {
  58         if (m_textures[i] == texture) {
  59             m_textures.remove(i);
  60             break;
  61         }
  62     }
  63 }
  64
  65 void CompositorFakeWebGraphicsContext3DWithTextureTracking::bindTexture(WGC3Denum /* target */, WebGLId texture)
  66 {
  67     m_usedTextures.add(texture);
  68 }
  69
  70 int CompositorFakeWebGraphicsContext3DWithTextureTracking::numTextures() const { return static_cast<int>(m_textures.size()); }
  71 int CompositorFakeWebGraphicsContext3DWithTextureTracking::texture(int i) const { return m_textures[i]; }
  72 void CompositorFakeWebGraphicsContext3DWithTextureTracking::resetTextures() { m_textures.clear(); }
  73
  74 int CompositorFakeWebGraphicsContext3DWithTextureTracking::numUsedTextures() const { return static_cast<int>(m_usedTextures.size()); }
  75 bool CompositorFakeWebGraphicsContext3DWithTextureTracking::usedTexture(int texture) const { return m_usedTextures.find(texture) != m_usedTextures.end(); }
  76 void CompositorFakeWebGraphicsContext3DWithTextureTracking::resetUsedTextures() { m_usedTextures.clear(); }
  77
  78 CompositorFakeWebGraphicsContext3DWithTextureTracking::CompositorFakeWebGraphicsContext3DWithTextureTracking(Attributes attrs) : CompositorFakeWebGraphicsContext3D(attrs)
  79 {
  80 }
  81
  82 PassOwnPtr<WebCompositorOutputSurface> TestHooks::createOutputSurface()
  83 {
  84     return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3DWithTextureTracking::create(WebGraphicsContext3D::Attributes()));
  85 }
  86
  87 PassOwnPtr<MockLayerTreeHostImpl> MockLayerTreeHostImpl::create(TestHooks* testHooks, const CCLayerTreeSettings& settings, CCLayerTreeHostImplClient* client)
  88 {
  89     return adoptPtr(new MockLayerTreeHostImpl(testHooks, settings, client));
  90 }
  91
  92 void MockLayerTreeHostImpl::beginCommit()
  93 {
  94     CCLayerTreeHostImpl::beginCommit();
  95     m_testHooks->beginCommitOnCCThread(this);
  96 }
  97
  98 void MockLayerTreeHostImpl::commitComplete()
  99 {
 100     CCLayerTreeHostImpl::commitComplete();
 101     m_testHooks->commitCompleteOnCCThread(this);
 102 }
 103
 104 bool MockLayerTreeHostImpl::prepareToDraw(FrameData& frame)
 105 {
 106     bool result = CCLayerTreeHostImpl::prepareToDraw(frame);
 107     if (!m_testHooks->prepareToDrawOnCCThread(this))
 108         result = false;
 109     return result;
 110 }
 111
 112 void MockLayerTreeHostImpl::drawLayers(const FrameData& frame)
 113 {
 114     CCLayerTreeHostImpl::drawLayers(frame);
 115     m_testHooks->drawLayersOnCCThread(this);
 116 }
 117
 118 void MockLayerTreeHostImpl::animateLayers(double monotonicTime, double wallClockTime)
 119 {
 120     m_testHooks->willAnimateLayers(this, monotonicTime);
 121     CCLayerTreeHostImpl::animateLayers(monotonicTime, wallClockTime);
 122     m_testHooks->animateLayers(this, monotonicTime);
 123 }
 124
 125 double MockLayerTreeHostImpl::lowFrequencyAnimationInterval() const
 126 {
 127     return 1.0 / 60;
 128 }
 129
 130 MockLayerTreeHostImpl::MockLayerTreeHostImpl(TestHooks* testHooks, const CCLayerTreeSettings& settings, CCLayerTreeHostImplClient* client)
 131     : CCLayerTreeHostImpl(settings, client)
 132     , m_testHooks(testHooks)
 133 {
 134 }
 135
 136 // Adapts CCLayerTreeHost for test. Injects MockLayerTreeHostImpl.
 137 class MockLayerTreeHost : public WebCore::CCLayerTreeHost {
 138 public:
 139     static PassOwnPtr<MockLayerTreeHost> create(TestHooks* testHooks, WebCore::CCLayerTreeHostClient* client, PassRefPtr<WebCore::LayerChromium> rootLayer, const WebCore::CCLayerTreeSettings& settings)
 140     {
 141         OwnPtr<MockLayerTreeHost> layerTreeHost(adoptPtr(new MockLayerTreeHost(testHooks, client, settings)));
 142         bool success = layerTreeHost->initialize();
 143         EXPECT_TRUE(success);
 144         layerTreeHost->setRootLayer(rootLayer);
 145
 146         // LayerTreeHostImpl won't draw if it has 1x1 viewport.
 147         layerTreeHost->setViewportSize(IntSize(1, 1), IntSize(1, 1));
 148
 149         layerTreeHost->rootLayer()->setLayerAnimationDelegate(testHooks);
 150
 151         return layerTreeHost.release();
 152     }
 153
 154     virtual PassOwnPtr<WebCore::CCLayerTreeHostImpl> createLayerTreeHostImpl(WebCore::CCLayerTreeHostImplClient* client)
 155     {
 156         return MockLayerTreeHostImpl::create(m_testHooks, settings(), client);
 157     }
 158
 159     virtual void didAddAnimation() OVERRIDE
 160     {
 161         CCLayerTreeHost::didAddAnimation();
 162         m_testHooks->didAddAnimation();
 163     }
 164
 165 private:
 166     MockLayerTreeHost(TestHooks* testHooks, WebCore::CCLayerTreeHostClient* client, const WebCore::CCLayerTreeSettings& settings)
 167         : CCLayerTreeHost(client, settings)
 168         , m_testHooks(testHooks)
 169     {
 170     }
 171
 172     TestHooks* m_testHooks;
 173 };
 174
 175 // Implementation of CCLayerTreeHost callback interface.
 176 class MockLayerTreeHostClient : public MockCCLayerTreeHostClient {
 177 public:
 178     static PassOwnPtr<MockLayerTreeHostClient> create(TestHooks* testHooks)
 179     {
 180         return adoptPtr(new MockLayerTreeHostClient(testHooks));
 181     }
 182
 183     virtual void willBeginFrame() OVERRIDE
 184     {
 185     }
 186
 187     virtual void didBeginFrame() OVERRIDE
 188     {
 189     }
 190
 191     virtual void animate(double monotonicTime) OVERRIDE
 192     {
 193         m_testHooks->animate(monotonicTime);
 194     }
 195
 196     virtual void layout() OVERRIDE
 197     {
 198         m_testHooks->layout();
 199     }
 200
 201     virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) OVERRIDE
 202     {
 203         m_testHooks->applyScrollAndScale(scrollDelta, scale);
 204     }
 205
 206     virtual PassOwnPtr<WebCompositorOutputSurface> createOutputSurface() OVERRIDE
 207     {
 208         return m_testHooks->createOutputSurface();
 209     }
 210
 211     virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE
 212     {
 213         m_testHooks->didRecreateOutputSurface(succeeded);
 214     }
 215
 216     virtual PassOwnPtr<CCInputHandler> createInputHandler() OVERRIDE
 217     {
 218         return nullptr;
 219     }
 220
 221     virtual void willCommit() OVERRIDE
 222     {
 223     }
 224
 225     virtual void didCommit() OVERRIDE
 226     {
 227         m_testHooks->didCommit();
 228     }
 229
 230     virtual void didCommitAndDrawFrame() OVERRIDE
 231     {
 232         m_testHooks->didCommitAndDrawFrame();
 233     }
 234
 235     virtual void didCompleteSwapBuffers() OVERRIDE
 236     {
 237     }
 238
 239     virtual void scheduleComposite() OVERRIDE
 240     {
 241         m_testHooks->scheduleComposite();
 242     }
 243
 244 private:
 245     explicit MockLayerTreeHostClient(TestHooks* testHooks) : m_testHooks(testHooks) { }
 246
 247     TestHooks* m_testHooks;
 248 };
 249
 250 class TimeoutTask : public WebThread::Task {
 251 public:
 252     explicit TimeoutTask(CCThreadedTest* test)
 253         : m_test(test)
 254     {
 255     }
 256
 257     void clearTest()
 258     {
 259         m_test = 0;
 260     }
 261
 262     virtual ~TimeoutTask()
 263     {
 264         if (m_test)
 265             m_test->clearTimeout();
 266     }
 267
 268     virtual void run()
 269     {
 270         if (m_test)
 271             m_test->timeout();
 272     }
 273
 274 private:
 275     CCThreadedTest* m_test;
 276 };
 277
 278 class BeginTask : public WebThread::Task {
 279 public:
 280     explicit BeginTask(CCThreadedTest* test)
 281         : m_test(test)
 282     {
 283     }
 284
 285     virtual ~BeginTask() { }
 286     virtual void run()
 287     {
 288         m_test->doBeginTest();
 289     }
 290 private:
 291     CCThreadedTest* m_test;
 292 };
 293
 294 class EndTestTask : public WebThread::Task {
 295 public:
 296     explicit EndTestTask(CCThreadedTest* test)
 297         : m_test(test)
 298     {
 299     }
 300
 301     virtual ~EndTestTask()
 302     {
 303         if (m_test)
 304             m_test->clearEndTestTask();
 305     }
 306
 307     void clearTest()
 308     {
 309         m_test = 0;
 310     }
 311
 312     virtual void run()
 313     {
 314         if (m_test)
 315             m_test->endTest();
 316     }
 317
 318 private:
 319     CCThreadedTest* m_test;
 320 };
 321
 322 CCThreadedTest::CCThreadedTest()
 323     : m_beginning(false)
 324     , m_endWhenBeginReturns(false)
 325     , m_timedOut(false)
 326     , m_finished(false)
 327     , m_scheduled(false)
 328     , m_started(false)
 329     , m_endTestTask(0)
 330 { }
 331
 332 void CCThreadedTest::endTest()
 333 {
 334     m_finished = true;
 335
 336     // If we are called from the CCThread, re-call endTest on the main thread.
 337     if (!isMainThread())
 338         m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadedTest::endTest));
 339     else {
 340         // For the case where we endTest during beginTest(), set a flag to indicate that
 341         // the test should end the second beginTest regains control.
 342         if (m_beginning)
 343             m_endWhenBeginReturns = true;
 344         else
 345             onEndTest(static_cast<void*>(this));
 346     }
 347 }
 348
 349 void CCThreadedTest::endTestAfterDelay(int delayMilliseconds)
 350 {
 351     // If we are called from the CCThread, re-call endTest on the main thread.
 352     if (!isMainThread())
 353         m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadedTest::endTestAfterDelay, delayMilliseconds));
 354     else {
 355         m_endTestTask = new EndTestTask(this);
 356         WebKit::Platform::current()->currentThread()->postDelayedTask(m_endTestTask, delayMilliseconds);
 357     }
 358 }
 359
 360 void CCThreadedTest::postSetNeedsAnimateToMainThread()
 361 {
 362     callOnMainThread(CCThreadedTest::dispatchSetNeedsAnimate, this);
 363 }
 364
 365 void CCThreadedTest::postAddAnimationToMainThread()
 366 {
 367     callOnMainThread(CCThreadedTest::dispatchAddAnimation, this);
 368 }
 369
 370 void CCThreadedTest::postAddInstantAnimationToMainThread()
 371 {
 372     callOnMainThread(CCThreadedTest::dispatchAddInstantAnimation, this);
 373 }
 374
 375 void CCThreadedTest::postSetNeedsCommitToMainThread()
 376 {
 377     callOnMainThread(CCThreadedTest::dispatchSetNeedsCommit, this);
 378 }
 379
 380 void CCThreadedTest::postAcquireLayerTextures()
 381 {
 382     callOnMainThread(CCThreadedTest::dispatchAcquireLayerTextures, this);
 383 }
 384
 385 void CCThreadedTest::postSetNeedsRedrawToMainThread()
 386 {
 387     callOnMainThread(CCThreadedTest::dispatchSetNeedsRedraw, this);
 388 }
 389
 390 void CCThreadedTest::postSetNeedsAnimateAndCommitToMainThread()
 391 {
 392     callOnMainThread(CCThreadedTest::dispatchSetNeedsAnimateAndCommit, this);
 393 }
 394
 395 void CCThreadedTest::postSetVisibleToMainThread(bool visible)
 396 {
 397     callOnMainThread(visible ? CCThreadedTest::dispatchSetVisible : CCThreadedTest::dispatchSetInvisible, this);
 398 }
 399
 400 void CCThreadedTest::postDidAddAnimationToMainThread()
 401 {
 402     callOnMainThread(CCThreadedTest::dispatchDidAddAnimation, this);
 403 }
 404
 405 void CCThreadedTest::doBeginTest()
 406 {
 407     ASSERT(isMainThread());
 408     m_client = MockLayerTreeHostClient::create(this);
 409
 410     RefPtr<LayerChromium> rootLayer = LayerChromium::create();
 411     m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), rootLayer, m_settings);
 412     ASSERT_TRUE(m_layerTreeHost);
 413     rootLayer->setLayerTreeHost(m_layerTreeHost.get());
 414     m_layerTreeHost->setSurfaceReady();
 415
 416     m_started = true;
 417     m_beginning = true;
 418     beginTest();
 419     m_beginning = false;
 420     if (m_endWhenBeginReturns)
 421         onEndTest(static_cast<void*>(this));
 422 }
 423
 424 void CCThreadedTest::timeout()
 425 {
 426     m_timedOut = true;
 427     endTest();
 428 }
 429
 430 void CCThreadedTest::scheduleComposite()
 431 {
 432     if (!m_started || m_scheduled || m_finished)
 433         return;
 434     m_scheduled = true;
 435     callOnMainThread(&CCThreadedTest::dispatchComposite, this);
 436 }
 437
 438 void CCThreadedTest::onEndTest(void* self)
 439 {
 440     ASSERT(isMainThread());
 441     WebKit::Platform::current()->currentThread()->exitRunLoop();
 442 }
 443
 444 void CCThreadedTest::dispatchSetNeedsAnimate(void* self)
 445 {
 446     ASSERT(isMainThread());
 447
 448     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 449     ASSERT(test);
 450     if (test->m_finished)
 451         return;
 452
 453     if (test->m_layerTreeHost)
 454         test->m_layerTreeHost->setNeedsAnimate();
 455 }
 456
 457 void CCThreadedTest::dispatchAddInstantAnimation(void* self)
 458 {
 459     ASSERT(isMainThread());
 460
 461     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 462     ASSERT(test);
 463     if (test->m_finished)
 464         return;
 465
 466     if (test->m_layerTreeHost && test->m_layerTreeHost->rootLayer())
 467         addOpacityTransitionToLayer(*test->m_layerTreeHost->rootLayer(), 0, 0, 0.5, false);
 468 }
 469
 470 void CCThreadedTest::dispatchAddAnimation(void* self)
 471 {
 472     ASSERT(isMainThread());
 473
 474     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 475     ASSERT(test);
 476     if (test->m_finished)
 477         return;
 478
 479     if (test->m_layerTreeHost && test->m_layerTreeHost->rootLayer())
 480         addOpacityTransitionToLayer(*test->m_layerTreeHost->rootLayer(), 10, 0, 0.5, true);
 481 }
 482
 483 void CCThreadedTest::dispatchSetNeedsAnimateAndCommit(void* self)
 484 {
 485     ASSERT(isMainThread());
 486
 487     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 488     ASSERT(test);
 489     if (test->m_finished)
 490         return;
 491
 492     if (test->m_layerTreeHost) {
 493         test->m_layerTreeHost->setNeedsAnimate();
 494         test->m_layerTreeHost->setNeedsCommit();
 495     }
 496 }
 497
 498 void CCThreadedTest::dispatchSetNeedsCommit(void* self)
 499 {
 500     ASSERT(isMainThread());
 501
 502     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 503     ASSERT_TRUE(test);
 504     if (test->m_finished)
 505         return;
 506
 507     if (test->m_layerTreeHost)
 508         test->m_layerTreeHost->setNeedsCommit();
 509 }
 510
 511 void CCThreadedTest::dispatchAcquireLayerTextures(void* self)
 512 {
 513     ASSERT(isMainThread());
 514
 515     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 516     ASSERT_TRUE(test);
 517     if (test->m_finished)
 518         return;
 519
 520     if (test->m_layerTreeHost)
 521         test->m_layerTreeHost->acquireLayerTextures();
 522 }
 523
 524 void CCThreadedTest::dispatchSetNeedsRedraw(void* self)
 525 {
 526     ASSERT(isMainThread());
 527
 528     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 529     ASSERT_TRUE(test);
 530     if (test->m_finished)
 531         return;
 532
 533     if (test->m_layerTreeHost)
 534         test->m_layerTreeHost->setNeedsRedraw();
 535 }
 536
 537 void CCThreadedTest::dispatchSetVisible(void* self)
 538 {
 539     ASSERT(isMainThread());
 540
 541     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 542     ASSERT(test);
 543     if (test->m_finished)
 544         return;
 545
 546     if (test->m_layerTreeHost)
 547         test->m_layerTreeHost->setVisible(true);
 548 }
 549
 550 void CCThreadedTest::dispatchSetInvisible(void* self)
 551 {
 552     ASSERT(isMainThread());
 553
 554     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 555     ASSERT(test);
 556     if (test->m_finished)
 557         return;
 558
 559     if (test->m_layerTreeHost)
 560         test->m_layerTreeHost->setVisible(false);
 561 }
 562
 563 void CCThreadedTest::dispatchComposite(void* self)
 564 {
 565     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 566     ASSERT(isMainThread());
 567     ASSERT(test);
 568     test->m_scheduled = false;
 569     if (test->m_layerTreeHost && !test->m_finished)
 570         test->m_layerTreeHost->composite();
 571 }
 572
 573 void CCThreadedTest::dispatchDidAddAnimation(void* self)
 574 {
 575     ASSERT(isMainThread());
 576
 577     CCThreadedTest* test = static_cast<CCThreadedTest*>(self);
 578     ASSERT(test);
 579     if (test->m_finished)
 580         return;
 581
 582     if (test->m_layerTreeHost)
 583         test->m_layerTreeHost->didAddAnimation();
 584 }
 585
 586 void CCThreadedTest::runTest(bool threaded)
 587 {
 588     // For these tests, we will enable threaded animations.
 589     Platform::current()->compositorSupport()->setAcceleratedAnimationEnabled(true);
 590
 591     if (threaded) {
 592         m_webThread = adoptPtr(WebKit::Platform::current()->createThread("CCThreadedTest"));
 593         Platform::current()->compositorSupport()->initialize(m_webThread.get());
 594     } else
 595         Platform::current()->compositorSupport()->initialize(0);
 596
 597     ASSERT(CCProxy::isMainThread());
 598     m_mainThreadProxy = CCScopedThreadProxy::create(CCProxy::mainThread());
 599
 600     initializeSettings(m_settings);
 601
 602     m_beginTask = new BeginTask(this);
 603     WebKit::Platform::current()->currentThread()->postDelayedTask(m_beginTask, 0); // postDelayedTask takes ownership of the task
 604     m_timeoutTask = new TimeoutTask(this);
 605     WebKit::Platform::current()->currentThread()->postDelayedTask(m_timeoutTask, 5000);
 606     WebKit::Platform::current()->currentThread()->enterRunLoop();
 607
 608     if (m_layerTreeHost && m_layerTreeHost->rootLayer())
 609         m_layerTreeHost->rootLayer()->setLayerTreeHost(0);
 610     m_layerTreeHost.clear();
 611
 612     if (m_timeoutTask)
 613         m_timeoutTask->clearTest();
 614
 615     if (m_endTestTask)
 616         m_endTestTask->clearTest();
 617
 618     ASSERT_FALSE(m_layerTreeHost.get());
 619     m_client.clear();
 620     if (m_timedOut) {
 621         FAIL() << "Test timed out";
 622         Platform::current()->compositorSupport()->shutdown();
 623         return;
 624     }
 625     afterTest();
 626     Platform::current()->compositorSupport()->shutdown();
 627 }
 628
 629 } // namespace WebKitTests