cc/test/layer_tree_test_common.cc

   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 "cc/test/layer_tree_test_common.h"
   6
   7 #include "cc/animation.h"
   8 #include "cc/animation_registrar.h"
   9 #include "cc/content_layer.h"
  10 #include "cc/input_handler.h"
  11 #include "cc/layer.h"
  12 #include "cc/layer_animation_controller.h"
  13 #include "cc/layer_impl.h"
  14 #include "cc/layer_tree_host_impl.h"
  15 #include "cc/single_thread_proxy.h"
  16 #include "cc/thread_impl.h"
  17 #include "cc/test/animation_test_common.h"
  18 #include "cc/test/fake_layer_tree_host_client.h"
  19 #include "cc/test/fake_output_surface.h"
  20 #include "cc/test/occlusion_tracker_test_common.h"
  21 #include "cc/test/tiled_layer_test_common.h"
  22 #include "cc/timing_function.h"
  23 #include "testing/gmock/include/gmock/gmock.h"
  24 #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperation.h"
  25 #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperations.h"
  26 #include "ui/gfx/size_conversions.h"
  27
  28 using namespace WebKit;
  29
  30 namespace cc {
  31
  32 TestHooks::TestHooks()
  33 {
  34   bool useSoftwareRendering = false;
  35   bool useDelegatingRenderer = false;
  36   m_fakeClient.reset(new FakeLayerImplTreeHostClient(useSoftwareRendering, useDelegatingRenderer));
  37 }
  38
  39 TestHooks::~TestHooks() { }
  40
  41 bool TestHooks::prepareToDrawOnThread(cc::LayerTreeHostImpl*, LayerTreeHostImpl::FrameData&, bool)
  42 {
  43     return true;
  44 }
  45
  46 bool TestHooks::canActivatePendingTree()
  47 {
  48     return true;
  49 }
  50
  51 scoped_ptr<OutputSurface> TestHooks::createOutputSurface()
  52 {
  53     return createFakeOutputSurface();
  54 }
  55
  56 scoped_refptr<cc::ContextProvider> TestHooks::OffscreenContextProviderForMainThread()
  57 {
  58     return m_fakeClient->OffscreenContextProviderForMainThread();
  59 }
  60
  61 scoped_refptr<cc::ContextProvider> TestHooks::OffscreenContextProviderForCompositorThread()
  62 {
  63     return m_fakeClient->OffscreenContextProviderForCompositorThread();
  64 }
  65
  66 scoped_ptr<MockLayerTreeHostImpl> MockLayerTreeHostImpl::create(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
  67 {
  68     return make_scoped_ptr(new MockLayerTreeHostImpl(testHooks, settings, client, proxy));
  69 }
  70
  71 void MockLayerTreeHostImpl::beginCommit()
  72 {
  73     LayerTreeHostImpl::beginCommit();
  74     m_testHooks->beginCommitOnThread(this);
  75 }
  76
  77 void MockLayerTreeHostImpl::commitComplete()
  78 {
  79     LayerTreeHostImpl::commitComplete();
  80     m_testHooks->commitCompleteOnThread(this);
  81
  82     if (!settings().implSidePainting)
  83         m_testHooks->treeActivatedOnThread(this);
  84
  85 }
  86
  87 bool MockLayerTreeHostImpl::prepareToDraw(FrameData& frame)
  88 {
  89     bool result = LayerTreeHostImpl::prepareToDraw(frame);
  90     if (!m_testHooks->prepareToDrawOnThread(this, frame, result))
  91         result = false;
  92     return result;
  93 }
  94
  95 void MockLayerTreeHostImpl::drawLayers(FrameData& frame)
  96 {
  97     LayerTreeHostImpl::drawLayers(frame);
  98     m_testHooks->drawLayersOnThread(this);
  99 }
 100
 101 bool MockLayerTreeHostImpl::activatePendingTreeIfNeeded()
 102 {
 103     if (!pendingTree())
 104         return false;
 105
 106     if (!m_testHooks->canActivatePendingTree())
 107         return false;
 108
 109     bool activated = LayerTreeHostImpl::activatePendingTreeIfNeeded();
 110     if (activated)
 111         m_testHooks->treeActivatedOnThread(this);
 112     return activated;
 113 }
 114
 115 bool MockLayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurface)
 116 {
 117     bool success = LayerTreeHostImpl::initializeRenderer(outputSurface.Pass());
 118     m_testHooks->initializedRendererOnThread(this, success);
 119     return success;
 120 }
 121
 122 void MockLayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
 123 {
 124     m_testHooks->willAnimateLayers(this, monotonicTime);
 125     LayerTreeHostImpl::animateLayers(monotonicTime, wallClockTime);
 126     m_testHooks->animateLayers(this, monotonicTime);
 127 }
 128
 129 void MockLayerTreeHostImpl::updateAnimationState()
 130 {
 131     LayerTreeHostImpl::updateAnimationState();
 132     bool hasUnfinishedAnimation = false;
 133     AnimationRegistrar::AnimationControllerMap::const_iterator iter = activeAnimationControllers().begin();
 134     for (; iter != activeAnimationControllers().end(); ++iter) {
 135         if (iter->second->hasActiveAnimation()) {
 136             hasUnfinishedAnimation = true;
 137             break;
 138         }
 139     }
 140     m_testHooks->updateAnimationState(this, hasUnfinishedAnimation);
 141 }
 142
 143 base::TimeDelta MockLayerTreeHostImpl::lowFrequencyAnimationInterval() const
 144 {
 145     return base::TimeDelta::FromMilliseconds(16);
 146 }
 147
 148 MockLayerTreeHostImpl::MockLayerTreeHostImpl(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
 149     : LayerTreeHostImpl(settings, client, proxy)
 150     , m_testHooks(testHooks)
 151 {
 152 }
 153
 154 // Adapts LayerTreeHost for test. Injects MockLayerTreeHostImpl.
 155 class MockLayerTreeHost : public cc::LayerTreeHost {
 156 public:
 157     static scoped_ptr<MockLayerTreeHost> create(TestHooks* testHooks, cc::LayerTreeHostClient* client, const cc::LayerTreeSettings& settings, scoped_ptr<cc::Thread> implThread)
 158     {
 159         scoped_ptr<MockLayerTreeHost> layerTreeHost(new MockLayerTreeHost(testHooks, client, settings));
 160         bool success = layerTreeHost->initialize(implThread.Pass());
 161         EXPECT_TRUE(success);
 162         return layerTreeHost.Pass();
 163     }
 164
 165     virtual scoped_ptr<cc::LayerTreeHostImpl> createLayerTreeHostImpl(cc::LayerTreeHostImplClient* client) OVERRIDE
 166     {
 167         return MockLayerTreeHostImpl::create(m_testHooks, settings(), client, proxy()).PassAs<cc::LayerTreeHostImpl>();
 168     }
 169
 170     virtual void setNeedsCommit() OVERRIDE
 171     {
 172         if (!m_testStarted)
 173             return;
 174         LayerTreeHost::setNeedsCommit();
 175     }
 176
 177     void setTestStarted(bool started) { m_testStarted = started; }
 178
 179     virtual void didDeferCommit() OVERRIDE
 180     {
 181         m_testHooks->didDeferCommit();
 182     }
 183
 184 private:
 185     MockLayerTreeHost(TestHooks* testHooks, cc::LayerTreeHostClient* client, const cc::LayerTreeSettings& settings)
 186         : LayerTreeHost(client, settings)
 187         , m_testHooks(testHooks)
 188         , m_testStarted(false)
 189     {
 190     }
 191
 192     TestHooks* m_testHooks;
 193     bool m_testStarted;
 194 };
 195
 196 // Implementation of LayerTreeHost callback interface.
 197 class ThreadedMockLayerTreeHostClient : public MockLayerImplTreeHostClient {
 198 public:
 199     static scoped_ptr<ThreadedMockLayerTreeHostClient> create(TestHooks* testHooks)
 200     {
 201         return make_scoped_ptr(new ThreadedMockLayerTreeHostClient(testHooks));
 202     }
 203
 204     virtual void willBeginFrame() OVERRIDE
 205     {
 206     }
 207
 208     virtual void didBeginFrame() OVERRIDE
 209     {
 210     }
 211
 212     virtual void animate(double monotonicTime) OVERRIDE
 213     {
 214         m_testHooks->animate(base::TimeTicks::FromInternalValue(monotonicTime * base::Time::kMicrosecondsPerSecond));
 215     }
 216
 217     virtual void layout() OVERRIDE
 218     {
 219         m_testHooks->layout();
 220     }
 221
 222   virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
 223     {
 224         m_testHooks->applyScrollAndScale(scrollDelta, scale);
 225     }
 226
 227     virtual scoped_ptr<OutputSurface> createOutputSurface() OVERRIDE
 228     {
 229         return m_testHooks->createOutputSurface();
 230     }
 231
 232     virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE
 233     {
 234         m_testHooks->didRecreateOutputSurface(succeeded);
 235     }
 236
 237     virtual void willRetryRecreateOutputSurface() OVERRIDE
 238     {
 239         m_testHooks->willRetryRecreateOutputSurface();
 240     }
 241
 242     virtual scoped_ptr<InputHandler> createInputHandler() OVERRIDE
 243     {
 244         return scoped_ptr<InputHandler>();
 245     }
 246
 247     virtual void willCommit() OVERRIDE
 248     {
 249     }
 250
 251     virtual void didCommit() OVERRIDE
 252     {
 253         m_testHooks->didCommit();
 254     }
 255
 256     virtual void didCommitAndDrawFrame() OVERRIDE
 257     {
 258         m_testHooks->didCommitAndDrawFrame();
 259     }
 260
 261     virtual void didCompleteSwapBuffers() OVERRIDE
 262     {
 263     }
 264
 265     virtual void scheduleComposite() OVERRIDE
 266     {
 267         m_testHooks->scheduleComposite();
 268     }
 269
 270     virtual scoped_refptr<cc::ContextProvider> OffscreenContextProviderForMainThread() OVERRIDE
 271     {
 272         return m_testHooks->OffscreenContextProviderForMainThread();
 273     }
 274
 275     virtual scoped_refptr<cc::ContextProvider> OffscreenContextProviderForCompositorThread() OVERRIDE
 276     {
 277         return m_testHooks->OffscreenContextProviderForCompositorThread();
 278     }
 279
 280 private:
 281     explicit ThreadedMockLayerTreeHostClient(TestHooks* testHooks) : m_testHooks(testHooks) { }
 282
 283     TestHooks* m_testHooks;
 284 };
 285
 286 ThreadedTest::ThreadedTest()
 287     : m_beginning(false)
 288     , m_endWhenBeginReturns(false)
 289     , m_timedOut(false)
 290     , m_scheduled(false)
 291     , m_started(false)
 292     , m_implThread(0)
 293     , m_weakFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this))
 294 {
 295     m_mainThreadWeakPtr = m_weakFactory.GetWeakPtr();
 296 }
 297
 298 ThreadedTest::~ThreadedTest()
 299 {
 300 }
 301
 302 void ThreadedTest::endTest()
 303 {
 304     // For the case where we endTest during beginTest(), set a flag to indicate that
 305     // the test should end the second beginTest regains control.
 306     if (m_beginning)
 307         m_endWhenBeginReturns = true;
 308     else
 309         proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::realEndTest, m_mainThreadWeakPtr));
 310 }
 311
 312 void ThreadedTest::endTestAfterDelay(int delayMilliseconds)
 313 {
 314     proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::endTest, m_mainThreadWeakPtr));
 315 }
 316
 317 void ThreadedTest::postAddAnimationToMainThread(Layer* layerToReceiveAnimation)
 318 {
 319     proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::dispatchAddAnimation, m_mainThreadWeakPtr, base::Unretained(layerToReceiveAnimation)));
 320 }
 321
 322 void ThreadedTest::postAddInstantAnimationToMainThread()
 323 {
 324     proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::dispatchAddInstantAnimation, m_mainThreadWeakPtr));
 325 }
 326
 327 void ThreadedTest::postSetNeedsCommitToMainThread()
 328 {
 329     proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::dispatchSetNeedsCommit, m_mainThreadWeakPtr));
 330 }
 331
 332 void ThreadedTest::postAcquireLayerTextures()
 333 {
 334     proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::dispatchAcquireLayerTextures, m_mainThreadWeakPtr));
 335 }
 336
 337 void ThreadedTest::postSetNeedsRedrawToMainThread()
 338 {
 339     proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::dispatchSetNeedsRedraw, m_mainThreadWeakPtr));
 340 }
 341
 342 void ThreadedTest::postSetVisibleToMainThread(bool visible)
 343 {
 344     proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::dispatchSetVisible, m_mainThreadWeakPtr, visible));
 345 }
 346
 347 void ThreadedTest::doBeginTest()
 348 {
 349     m_client = ThreadedMockLayerTreeHostClient::create(this);
 350
 351     scoped_ptr<cc::Thread> implCCThread(NULL);
 352     if (m_implThread)
 353         implCCThread = cc::ThreadImpl::createForDifferentThread(m_implThread->message_loop_proxy());
 354     m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), m_settings, implCCThread.Pass());
 355     ASSERT_TRUE(m_layerTreeHost.get());
 356
 357     m_started = true;
 358     m_beginning = true;
 359     setupTree();
 360     m_layerTreeHost->setSurfaceReady();
 361     beginTest();
 362     m_beginning = false;
 363     if (m_endWhenBeginReturns)
 364         realEndTest();
 365
 366     // Allow commits to happen once beginTest() has had a chance to post tasks
 367     // so that those tasks will happen before the first commit.
 368     if (m_layerTreeHost)
 369         static_cast<MockLayerTreeHost*>(m_layerTreeHost.get())->setTestStarted(true);
 370 }
 371
 372 void ThreadedTest::setupTree()
 373 {
 374     if (!m_layerTreeHost->rootLayer()) {
 375         scoped_refptr<Layer> rootLayer = Layer::create();
 376         rootLayer->setBounds(gfx::Size(1, 1));
 377         m_layerTreeHost->setRootLayer(rootLayer);
 378     }
 379
 380     gfx::Size rootBounds = m_layerTreeHost->rootLayer()->bounds();
 381     gfx::Size deviceRootBounds = gfx::ToCeiledSize(
 382         gfx::ScaleSize(rootBounds, m_layerTreeHost->deviceScaleFactor()));
 383     m_layerTreeHost->setViewportSize(rootBounds, deviceRootBounds);
 384 }
 385
 386 void ThreadedTest::timeout()
 387 {
 388     m_timedOut = true;
 389     endTest();
 390 }
 391
 392 void ThreadedTest::scheduleComposite()
 393 {
 394     if (!m_started || m_scheduled)
 395         return;
 396     m_scheduled = true;
 397     proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::dispatchComposite, m_mainThreadWeakPtr));
 398 }
 399
 400 void ThreadedTest::realEndTest()
 401 {
 402     if (m_layerTreeHost && proxy()->commitPendingForTesting()) {
 403         proxy()->mainThread()->postTask(base::Bind(&ThreadedTest::realEndTest, m_mainThreadWeakPtr));
 404         return;
 405     }
 406
 407     MessageLoop::current()->Quit();
 408 }
 409
 410 void ThreadedTest::dispatchAddInstantAnimation()
 411 {
 412     DCHECK(!proxy() || proxy()->isMainThread());
 413
 414     if (m_layerTreeHost.get() && m_layerTreeHost->rootLayer())
 415         addOpacityTransitionToLayer(*m_layerTreeHost->rootLayer(), 0, 0, 0.5, false);
 416 }
 417
 418 void ThreadedTest::dispatchAddAnimation(Layer* layerToReceiveAnimation)
 419 {
 420     DCHECK(!proxy() || proxy()->isMainThread());
 421
 422     if (layerToReceiveAnimation)
 423         addOpacityTransitionToLayer(*layerToReceiveAnimation, 10, 0, 0.5, true);
 424 }
 425
 426 void ThreadedTest::dispatchSetNeedsCommit()
 427 {
 428     DCHECK(!proxy() || proxy()->isMainThread());
 429
 430     if (m_layerTreeHost.get())
 431         m_layerTreeHost->setNeedsCommit();
 432 }
 433
 434 void ThreadedTest::dispatchAcquireLayerTextures()
 435 {
 436     DCHECK(!proxy() || proxy()->isMainThread());
 437
 438     if (m_layerTreeHost.get())
 439         m_layerTreeHost->acquireLayerTextures();
 440 }
 441
 442 void ThreadedTest::dispatchSetNeedsRedraw()
 443 {
 444     DCHECK(!proxy() || proxy()->isMainThread());
 445
 446     if (m_layerTreeHost.get())
 447         m_layerTreeHost->setNeedsRedraw();
 448 }
 449
 450 void ThreadedTest::dispatchSetVisible(bool visible)
 451 {
 452     DCHECK(!proxy() || proxy()->isMainThread());
 453
 454     if (m_layerTreeHost.get())
 455         m_layerTreeHost->setVisible(visible);
 456 }
 457
 458 void ThreadedTest::dispatchComposite()
 459 {
 460     m_scheduled = false;
 461     if (m_layerTreeHost.get())
 462         m_layerTreeHost->composite();
 463 }
 464
 465 void ThreadedTest::runTest(bool threaded)
 466 {
 467     if (threaded) {
 468         m_implThread.reset(new base::Thread("ThreadedTest"));
 469         ASSERT_TRUE(m_implThread->Start());
 470     }
 471
 472     m_mainCCThread = cc::ThreadImpl::createForCurrentThread();
 473
 474     initializeSettings(m_settings);
 475
 476     m_mainCCThread->postTask(base::Bind(&ThreadedTest::doBeginTest, base::Unretained(this)));
 477     m_timeout.Reset(base::Bind(&ThreadedTest::timeout, base::Unretained(this)));
 478     m_mainCCThread->postDelayedTask(m_timeout.callback(), 5000);
 479     MessageLoop::current()->Run();
 480     if (m_layerTreeHost.get() && m_layerTreeHost->rootLayer())
 481         m_layerTreeHost->rootLayer()->setLayerTreeHost(0);
 482     m_layerTreeHost.reset();
 483
 484     m_timeout.Cancel();
 485
 486     ASSERT_FALSE(m_layerTreeHost.get());
 487     m_client.reset();
 488     if (m_timedOut) {
 489         FAIL() << "Test timed out";
 490         return;
 491     }
 492     afterTest();
 493 }
 494
 495 }  // namespace cc