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