cc/test/layer_tree_test.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.h"
   6
   7 #include "base/command_line.h"
   8 #include "cc/animation/animation.h"
   9 #include "cc/animation/animation_registrar.h"
  10 #include "cc/animation/layer_animation_controller.h"
  11 #include "cc/animation/timing_function.h"
  12 #include "cc/base/switches.h"
  13 #include "cc/input/input_handler.h"
  14 #include "cc/layers/content_layer.h"
  15 #include "cc/layers/layer.h"
  16 #include "cc/layers/layer_impl.h"
  17 #include "cc/test/animation_test_common.h"
  18 #include "cc/test/begin_frame_args_test.h"
  19 #include "cc/test/fake_external_begin_frame_source.h"
  20 #include "cc/test/fake_layer_tree_host_client.h"
  21 #include "cc/test/fake_output_surface.h"
  22 #include "cc/test/test_context_provider.h"
  23 #include "cc/test/test_gpu_memory_buffer_manager.h"
  24 #include "cc/test/test_shared_bitmap_manager.h"
  25 #include "cc/test/test_task_graph_runner.h"
  26 #include "cc/test/tiled_layer_test_common.h"
  27 #include "cc/trees/layer_tree_host_client.h"
  28 #include "cc/trees/layer_tree_host_impl.h"
  29 #include "cc/trees/layer_tree_host_single_thread_client.h"
  30 #include "cc/trees/layer_tree_impl.h"
  31 #include "cc/trees/single_thread_proxy.h"
  32 #include "cc/trees/thread_proxy.h"
  33 #include "testing/gmock/include/gmock/gmock.h"
  34 #include "ui/gfx/frame_time.h"
  35 #include "ui/gfx/geometry/size_conversions.h"
  36
  37 namespace cc {
  38
  39 TestHooks::TestHooks() {}
  40
  41 TestHooks::~TestHooks() {}
  42
  43 DrawResult TestHooks::PrepareToDrawOnThread(
  44     LayerTreeHostImpl* host_impl,
  45     LayerTreeHostImpl::FrameData* frame_data,
  46     DrawResult draw_result) {
  47   return draw_result;
  48 }
  49
  50 scoped_ptr<Rasterizer> TestHooks::CreateRasterizer(
  51     LayerTreeHostImpl* host_impl) {
  52   return host_impl->LayerTreeHostImpl::CreateRasterizer();
  53 }
  54
  55 void TestHooks::CreateResourceAndTileTaskWorkerPool(
  56     LayerTreeHostImpl* host_impl,
  57     scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
  58     scoped_ptr<ResourcePool>* resource_pool,
  59     scoped_ptr<ResourcePool>* staging_resource_pool) {
  60   host_impl->LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
  61       tile_task_worker_pool, resource_pool, staging_resource_pool);
  62 }
  63
  64 // Adapts ThreadProxy for test. Injects test hooks for testing.
  65 class ThreadProxyForTest : public ThreadProxy {
  66  public:
  67   static scoped_ptr<Proxy> Create(
  68       TestHooks* test_hooks,
  69       LayerTreeHost* host,
  70       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
  71       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
  72       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
  73     return make_scoped_ptr(new ThreadProxyForTest(
  74         test_hooks,
  75         host,
  76         main_task_runner,
  77         impl_task_runner,
  78         external_begin_frame_source.Pass()));
  79   }
  80
  81   ~ThreadProxyForTest() override {}
  82
  83  private:
  84   TestHooks* test_hooks_;
  85
  86   void WillBeginImplFrame(const BeginFrameArgs& args) override {
  87     ThreadProxy::WillBeginImplFrame(args);
  88     test_hooks_->WillBeginImplFrame(args);
  89   }
  90
  91   void ScheduledActionSendBeginMainFrame() override {
  92     test_hooks_->ScheduledActionWillSendBeginMainFrame();
  93     ThreadProxy::ScheduledActionSendBeginMainFrame();
  94     test_hooks_->ScheduledActionSendBeginMainFrame();
  95   }
  96
  97   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
  98     DrawResult result = ThreadProxy::ScheduledActionDrawAndSwapIfPossible();
  99     test_hooks_->ScheduledActionDrawAndSwapIfPossible();
 100     return result;
 101   }
 102
 103   void ScheduledActionAnimate() override {
 104     ThreadProxy::ScheduledActionAnimate();
 105     test_hooks_->ScheduledActionAnimate();
 106   }
 107
 108   void ScheduledActionCommit() override {
 109     ThreadProxy::ScheduledActionCommit();
 110     test_hooks_->ScheduledActionCommit();
 111   }
 112
 113   void ScheduledActionBeginOutputSurfaceCreation() override {
 114     ThreadProxy::ScheduledActionBeginOutputSurfaceCreation();
 115     test_hooks_->ScheduledActionBeginOutputSurfaceCreation();
 116   }
 117
 118   void ScheduledActionPrepareTiles() override {
 119     ThreadProxy::ScheduledActionPrepareTiles();
 120     test_hooks_->ScheduledActionPrepareTiles();
 121   }
 122
 123   ThreadProxyForTest(
 124       TestHooks* test_hooks,
 125       LayerTreeHost* host,
 126       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
 127       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
 128       scoped_ptr<BeginFrameSource> external_begin_frame_source)
 129       : ThreadProxy(host, main_task_runner,
 130                     impl_task_runner,
 131                     external_begin_frame_source.Pass()),
 132         test_hooks_(test_hooks) {}
 133 };
 134
 135 // Adapts ThreadProxy for test. Injects test hooks for testing.
 136 class SingleThreadProxyForTest : public SingleThreadProxy {
 137  public:
 138   static scoped_ptr<Proxy> Create(
 139       TestHooks* test_hooks,
 140       LayerTreeHost* host,
 141       LayerTreeHostSingleThreadClient* client,
 142       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
 143       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
 144     return make_scoped_ptr(new SingleThreadProxyForTest(
 145         test_hooks, host, client, main_task_runner,
 146         external_begin_frame_source.Pass()));
 147   }
 148
 149   ~SingleThreadProxyForTest() override {}
 150
 151  private:
 152   TestHooks* test_hooks_;
 153
 154   void WillBeginImplFrame(const BeginFrameArgs& args) override {
 155     SingleThreadProxy::WillBeginImplFrame(args);
 156     test_hooks_->WillBeginImplFrame(args);
 157   }
 158
 159   void ScheduledActionSendBeginMainFrame() override {
 160     test_hooks_->ScheduledActionWillSendBeginMainFrame();
 161     SingleThreadProxy::ScheduledActionSendBeginMainFrame();
 162     test_hooks_->ScheduledActionSendBeginMainFrame();
 163   }
 164
 165   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
 166     DrawResult result =
 167         SingleThreadProxy::ScheduledActionDrawAndSwapIfPossible();
 168     test_hooks_->ScheduledActionDrawAndSwapIfPossible();
 169     return result;
 170   }
 171
 172   void ScheduledActionAnimate() override {
 173     SingleThreadProxy::ScheduledActionAnimate();
 174     test_hooks_->ScheduledActionAnimate();
 175   }
 176
 177   void ScheduledActionCommit() override {
 178     SingleThreadProxy::ScheduledActionCommit();
 179     test_hooks_->ScheduledActionCommit();
 180   }
 181
 182   void ScheduledActionBeginOutputSurfaceCreation() override {
 183     SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation();
 184     test_hooks_->ScheduledActionBeginOutputSurfaceCreation();
 185   }
 186
 187   void ScheduledActionPrepareTiles() override {
 188     SingleThreadProxy::ScheduledActionPrepareTiles();
 189     test_hooks_->ScheduledActionPrepareTiles();
 190   }
 191
 192   SingleThreadProxyForTest(
 193       TestHooks* test_hooks,
 194       LayerTreeHost* host,
 195       LayerTreeHostSingleThreadClient* client,
 196       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
 197       scoped_ptr<BeginFrameSource> external_begin_frame_source)
 198       : SingleThreadProxy(host, client, main_task_runner,
 199                           external_begin_frame_source.Pass()),
 200         test_hooks_(test_hooks) {}
 201 };
 202
 203 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 204 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
 205  public:
 206   static scoped_ptr<LayerTreeHostImplForTesting> Create(
 207       TestHooks* test_hooks,
 208       const LayerTreeSettings& settings,
 209       LayerTreeHostImplClient* host_impl_client,
 210       Proxy* proxy,
 211       SharedBitmapManager* shared_bitmap_manager,
 212       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
 213       TaskGraphRunner* task_graph_runner,
 214       RenderingStatsInstrumentation* stats_instrumentation) {
 215     return make_scoped_ptr(new LayerTreeHostImplForTesting(
 216         test_hooks, settings, host_impl_client, proxy, shared_bitmap_manager,
 217         gpu_memory_buffer_manager, task_graph_runner, stats_instrumentation));
 218   }
 219
 220  protected:
 221   LayerTreeHostImplForTesting(
 222       TestHooks* test_hooks,
 223       const LayerTreeSettings& settings,
 224       LayerTreeHostImplClient* host_impl_client,
 225       Proxy* proxy,
 226       SharedBitmapManager* shared_bitmap_manager,
 227       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
 228       TaskGraphRunner* task_graph_runner,
 229       RenderingStatsInstrumentation* stats_instrumentation)
 230       : LayerTreeHostImpl(settings,
 231                           host_impl_client,
 232                           proxy,
 233                           stats_instrumentation,
 234                           shared_bitmap_manager,
 235                           gpu_memory_buffer_manager,
 236                           task_graph_runner,
 237                           0),
 238         test_hooks_(test_hooks),
 239         block_notify_ready_to_activate_for_testing_(false),
 240         notify_ready_to_activate_was_blocked_(false) {}
 241
 242   scoped_ptr<Rasterizer> CreateRasterizer() override {
 243     return test_hooks_->CreateRasterizer(this);
 244   }
 245
 246   void CreateResourceAndTileTaskWorkerPool(
 247       scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
 248       scoped_ptr<ResourcePool>* resource_pool,
 249       scoped_ptr<ResourcePool>* staging_resource_pool) override {
 250     test_hooks_->CreateResourceAndTileTaskWorkerPool(
 251         this, tile_task_worker_pool, resource_pool, staging_resource_pool);
 252   }
 253
 254   void WillBeginImplFrame(const BeginFrameArgs& args) override {
 255     LayerTreeHostImpl::WillBeginImplFrame(args);
 256     test_hooks_->WillBeginImplFrameOnThread(this, args);
 257   }
 258
 259   void BeginMainFrameAborted(CommitEarlyOutReason reason) override {
 260     LayerTreeHostImpl::BeginMainFrameAborted(reason);
 261     test_hooks_->BeginMainFrameAbortedOnThread(this, reason);
 262   }
 263
 264   void BeginCommit() override {
 265     LayerTreeHostImpl::BeginCommit();
 266     test_hooks_->BeginCommitOnThread(this);
 267   }
 268
 269   void CommitComplete() override {
 270     LayerTreeHostImpl::CommitComplete();
 271     test_hooks_->CommitCompleteOnThread(this);
 272   }
 273
 274   DrawResult PrepareToDraw(FrameData* frame) override {
 275     DrawResult draw_result = LayerTreeHostImpl::PrepareToDraw(frame);
 276     return test_hooks_->PrepareToDrawOnThread(this, frame, draw_result);
 277   }
 278
 279   void DrawLayers(FrameData* frame, base::TimeTicks frame_begin_time) override {
 280     LayerTreeHostImpl::DrawLayers(frame, frame_begin_time);
 281     test_hooks_->DrawLayersOnThread(this);
 282   }
 283
 284   bool SwapBuffers(const LayerTreeHostImpl::FrameData& frame) override {
 285     bool result = LayerTreeHostImpl::SwapBuffers(frame);
 286     test_hooks_->SwapBuffersOnThread(this, result);
 287     return result;
 288   }
 289
 290   void DidSwapBuffersComplete() override {
 291     LayerTreeHostImpl::DidSwapBuffersComplete();
 292     test_hooks_->SwapBuffersCompleteOnThread(this);
 293   }
 294
 295   void ReclaimResources(const CompositorFrameAck* ack) override {
 296     LayerTreeHostImpl::ReclaimResources(ack);
 297   }
 298
 299   void NotifyReadyToActivate() override {
 300     if (block_notify_ready_to_activate_for_testing_) {
 301       notify_ready_to_activate_was_blocked_ = true;
 302     } else {
 303       LayerTreeHostImpl::NotifyReadyToActivate();
 304       test_hooks_->NotifyReadyToActivateOnThread(this);
 305     }
 306   }
 307
 308   void NotifyReadyToDraw() override {
 309     LayerTreeHostImpl::NotifyReadyToDraw();
 310     test_hooks_->NotifyReadyToDrawOnThread(this);
 311   }
 312
 313   void BlockNotifyReadyToActivateForTesting(bool block) override {
 314     CHECK(settings().impl_side_painting);
 315     CHECK(proxy()->ImplThreadTaskRunner())
 316         << "Not supported for single-threaded mode.";
 317     block_notify_ready_to_activate_for_testing_ = block;
 318     if (!block && notify_ready_to_activate_was_blocked_) {
 319       NotifyReadyToActivate();
 320       notify_ready_to_activate_was_blocked_ = false;
 321     }
 322   }
 323
 324   void ActivateSyncTree() override {
 325     test_hooks_->WillActivateTreeOnThread(this);
 326     LayerTreeHostImpl::ActivateSyncTree();
 327     DCHECK(!pending_tree());
 328     test_hooks_->DidActivateTreeOnThread(this);
 329   }
 330
 331   bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface) override {
 332     bool success = LayerTreeHostImpl::InitializeRenderer(output_surface.Pass());
 333     test_hooks_->InitializedRendererOnThread(this, success);
 334     return success;
 335   }
 336
 337   void SetVisible(bool visible) override {
 338     LayerTreeHostImpl::SetVisible(visible);
 339     test_hooks_->DidSetVisibleOnImplTree(this, visible);
 340   }
 341
 342   void AnimateLayers(base::TimeTicks monotonic_time) override {
 343     test_hooks_->WillAnimateLayers(this, monotonic_time);
 344     LayerTreeHostImpl::AnimateLayers(monotonic_time);
 345     test_hooks_->AnimateLayers(this, monotonic_time);
 346   }
 347
 348   void UpdateAnimationState(bool start_ready_animations) override {
 349     LayerTreeHostImpl::UpdateAnimationState(start_ready_animations);
 350     bool has_unfinished_animation = false;
 351     for (const auto& it :
 352          animation_registrar()->active_animation_controllers_for_testing()) {
 353       if (it.second->HasActiveAnimation()) {
 354         has_unfinished_animation = true;
 355         break;
 356       }
 357     }
 358     test_hooks_->UpdateAnimationState(this, has_unfinished_animation);
 359   }
 360
 361   void NotifyTileStateChanged(const Tile* tile) override {
 362     LayerTreeHostImpl::NotifyTileStateChanged(tile);
 363     test_hooks_->NotifyTileStateChangedOnThread(this, tile);
 364   }
 365
 366  private:
 367   TestHooks* test_hooks_;
 368   bool block_notify_ready_to_activate_for_testing_;
 369   bool notify_ready_to_activate_was_blocked_;
 370 };
 371
 372 // Implementation of LayerTreeHost callback interface.
 373 class LayerTreeHostClientForTesting : public LayerTreeHostClient,
 374                                       public LayerTreeHostSingleThreadClient {
 375  public:
 376   static scoped_ptr<LayerTreeHostClientForTesting> Create(
 377       TestHooks* test_hooks) {
 378     return make_scoped_ptr(new LayerTreeHostClientForTesting(test_hooks));
 379   }
 380   ~LayerTreeHostClientForTesting() override {}
 381
 382   void WillBeginMainFrame() override { test_hooks_->WillBeginMainFrame(); }
 383
 384   void DidBeginMainFrame() override { test_hooks_->DidBeginMainFrame(); }
 385
 386   void BeginMainFrame(const BeginFrameArgs& args) override {
 387     test_hooks_->BeginMainFrame(args);
 388   }
 389
 390   void Layout() override { test_hooks_->Layout(); }
 391
 392   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
 393                            const gfx::Vector2dF& outer_delta,
 394                            const gfx::Vector2dF& elastic_overscroll_delta,
 395                            float page_scale,
 396                            float top_controls_delta) override {
 397     test_hooks_->ApplyViewportDeltas(inner_delta, outer_delta,
 398                                      elastic_overscroll_delta, page_scale,
 399                                      top_controls_delta);
 400   }
 401   void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
 402                            float scale,
 403                            float top_controls_delta) override {
 404     test_hooks_->ApplyViewportDeltas(scroll_delta,
 405                                      scale,
 406                                      top_controls_delta);
 407   }
 408
 409   void RequestNewOutputSurface() override {
 410     test_hooks_->RequestNewOutputSurface();
 411   }
 412
 413   void DidInitializeOutputSurface() override {
 414     test_hooks_->DidInitializeOutputSurface();
 415   }
 416
 417   void SendBeginFramesToChildren(const BeginFrameArgs& args) override {
 418     test_hooks_->SendBeginFramesToChildren(args);
 419   }
 420
 421   void DidFailToInitializeOutputSurface() override {
 422     test_hooks_->DidFailToInitializeOutputSurface();
 423     RequestNewOutputSurface();
 424   }
 425
 426   void WillCommit() override { test_hooks_->WillCommit(); }
 427
 428   void DidCommit() override { test_hooks_->DidCommit(); }
 429
 430   void DidCommitAndDrawFrame() override {
 431     test_hooks_->DidCommitAndDrawFrame();
 432   }
 433
 434   void DidCompleteSwapBuffers() override {
 435     test_hooks_->DidCompleteSwapBuffers();
 436   }
 437
 438   void DidPostSwapBuffers() override {}
 439   void DidAbortSwapBuffers() override {}
 440   void ScheduleComposite() override { test_hooks_->ScheduleComposite(); }
 441   void DidCompletePageScaleAnimation() override {}
 442   void BeginMainFrameNotExpectedSoon() override {}
 443
 444  private:
 445   explicit LayerTreeHostClientForTesting(TestHooks* test_hooks)
 446       : test_hooks_(test_hooks) {}
 447
 448   TestHooks* test_hooks_;
 449 };
 450
 451 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 452 class LayerTreeHostForTesting : public LayerTreeHost {
 453  public:
 454   static scoped_ptr<LayerTreeHostForTesting> Create(
 455       TestHooks* test_hooks,
 456       LayerTreeHostClientForTesting* client,
 457       SharedBitmapManager* shared_bitmap_manager,
 458       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
 459       TaskGraphRunner* task_graph_runner,
 460       const LayerTreeSettings& settings,
 461       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
 462       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
 463       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
 464     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
 465         new LayerTreeHostForTesting(test_hooks, client, shared_bitmap_manager,
 466                                     gpu_memory_buffer_manager,
 467                                     task_graph_runner, settings));
 468     if (impl_task_runner.get()) {
 469       layer_tree_host->InitializeForTesting(
 470           ThreadProxyForTest::Create(test_hooks,
 471                                      layer_tree_host.get(),
 472                                      main_task_runner,
 473                                      impl_task_runner,
 474                                      external_begin_frame_source.Pass()));
 475     } else {
 476       layer_tree_host->InitializeForTesting(
 477           SingleThreadProxyForTest::Create(
 478               test_hooks,
 479               layer_tree_host.get(),
 480               client,
 481               main_task_runner,
 482               external_begin_frame_source.Pass()));
 483     }
 484     return layer_tree_host.Pass();
 485   }
 486
 487   scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
 488       LayerTreeHostImplClient* host_impl_client) override {
 489     return LayerTreeHostImplForTesting::Create(
 490         test_hooks_, settings(), host_impl_client, proxy(),
 491         shared_bitmap_manager_, gpu_memory_buffer_manager_, task_graph_runner_,
 492         rendering_stats_instrumentation());
 493   }
 494
 495   void SetNeedsCommit() override {
 496     if (!test_started_)
 497       return;
 498     LayerTreeHost::SetNeedsCommit();
 499   }
 500
 501   void set_test_started(bool started) { test_started_ = started; }
 502
 503  private:
 504   LayerTreeHostForTesting(
 505       TestHooks* test_hooks,
 506       LayerTreeHostClient* client,
 507       SharedBitmapManager* shared_bitmap_manager,
 508       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
 509       TaskGraphRunner* task_graph_runner,
 510       const LayerTreeSettings& settings)
 511       : LayerTreeHost(client, NULL, NULL, NULL, settings),
 512         shared_bitmap_manager_(shared_bitmap_manager),
 513         gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
 514         task_graph_runner_(task_graph_runner),
 515         test_hooks_(test_hooks),
 516         test_started_(false) {}
 517
 518   SharedBitmapManager* shared_bitmap_manager_;
 519   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
 520   TaskGraphRunner* task_graph_runner_;
 521   TestHooks* test_hooks_;
 522   bool test_started_;
 523 };
 524
 525 LayerTreeTest::LayerTreeTest()
 526     : output_surface_(nullptr),
 527       external_begin_frame_source_(nullptr),
 528       beginning_(false),
 529       end_when_begin_returns_(false),
 530       timed_out_(false),
 531       scheduled_(false),
 532       started_(false),
 533       ended_(false),
 534       delegating_renderer_(false),
 535       verify_property_trees_(true),
 536       timeout_seconds_(0),
 537       weak_factory_(this) {
 538   main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
 539
 540   // Tests should timeout quickly unless --cc-layer-tree-test-no-timeout was
 541   // specified (for running in a debugger).
 542   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 543   if (!command_line->HasSwitch(switches::kCCLayerTreeTestNoTimeout))
 544     timeout_seconds_ = 5;
 545 }
 546
 547 LayerTreeTest::~LayerTreeTest() {}
 548
 549 void LayerTreeTest::EndTest() {
 550   if (ended_)
 551     return;
 552   ended_ = true;
 553
 554   // For the case where we EndTest during BeginTest(), set a flag to indicate
 555   // that the test should end the second BeginTest regains control.
 556   if (beginning_) {
 557     end_when_begin_returns_ = true;
 558   } else {
 559     main_task_runner_->PostTask(
 560         FROM_HERE,
 561         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
 562   }
 563 }
 564
 565 void LayerTreeTest::EndTestAfterDelayMs(int delay_milliseconds) {
 566   main_task_runner_->PostDelayedTask(
 567       FROM_HERE,
 568       base::Bind(&LayerTreeTest::EndTest, main_thread_weak_ptr_),
 569       base::TimeDelta::FromMilliseconds(delay_milliseconds));
 570 }
 571
 572 void LayerTreeTest::PostAddAnimationToMainThread(
 573     Layer* layer_to_receive_animation) {
 574   main_task_runner_->PostTask(
 575       FROM_HERE,
 576       base::Bind(&LayerTreeTest::DispatchAddAnimation, main_thread_weak_ptr_,
 577                  base::Unretained(layer_to_receive_animation), 0.000004));
 578 }
 579
 580 void LayerTreeTest::PostAddInstantAnimationToMainThread(
 581     Layer* layer_to_receive_animation) {
 582   main_task_runner_->PostTask(
 583       FROM_HERE,
 584       base::Bind(&LayerTreeTest::DispatchAddAnimation,
 585                  main_thread_weak_ptr_,
 586                  base::Unretained(layer_to_receive_animation),
 587                  0.0));
 588 }
 589
 590 void LayerTreeTest::PostAddLongAnimationToMainThread(
 591     Layer* layer_to_receive_animation) {
 592   main_task_runner_->PostTask(
 593       FROM_HERE,
 594       base::Bind(&LayerTreeTest::DispatchAddAnimation,
 595                  main_thread_weak_ptr_,
 596                  base::Unretained(layer_to_receive_animation),
 597                  1.0));
 598 }
 599
 600 void LayerTreeTest::PostSetDeferCommitsToMainThread(bool defer_commits) {
 601   main_task_runner_->PostTask(
 602       FROM_HERE,
 603       base::Bind(&LayerTreeTest::DispatchSetDeferCommits,
 604                  main_thread_weak_ptr_, defer_commits));
 605 }
 606
 607 void LayerTreeTest::PostSetNeedsCommitToMainThread() {
 608   main_task_runner_->PostTask(FROM_HERE,
 609                               base::Bind(&LayerTreeTest::DispatchSetNeedsCommit,
 610                                          main_thread_weak_ptr_));
 611 }
 612
 613 void LayerTreeTest::PostSetNeedsUpdateLayersToMainThread() {
 614   main_task_runner_->PostTask(
 615       FROM_HERE,
 616       base::Bind(&LayerTreeTest::DispatchSetNeedsUpdateLayers,
 617                  main_thread_weak_ptr_));
 618 }
 619
 620 void LayerTreeTest::PostSetNeedsRedrawToMainThread() {
 621   main_task_runner_->PostTask(FROM_HERE,
 622                               base::Bind(&LayerTreeTest::DispatchSetNeedsRedraw,
 623                                          main_thread_weak_ptr_));
 624 }
 625
 626 void LayerTreeTest::PostSetNeedsRedrawRectToMainThread(
 627     const gfx::Rect& damage_rect) {
 628   main_task_runner_->PostTask(
 629       FROM_HERE,
 630       base::Bind(&LayerTreeTest::DispatchSetNeedsRedrawRect,
 631                  main_thread_weak_ptr_,
 632                  damage_rect));
 633 }
 634
 635 void LayerTreeTest::PostSetVisibleToMainThread(bool visible) {
 636   main_task_runner_->PostTask(
 637       FROM_HERE,
 638       base::Bind(
 639           &LayerTreeTest::DispatchSetVisible, main_thread_weak_ptr_, visible));
 640 }
 641
 642 void LayerTreeTest::PostSetNextCommitForcesRedrawToMainThread() {
 643   main_task_runner_->PostTask(
 644       FROM_HERE,
 645       base::Bind(&LayerTreeTest::DispatchSetNextCommitForcesRedraw,
 646                  main_thread_weak_ptr_));
 647 }
 648
 649 void LayerTreeTest::PostCompositeImmediatelyToMainThread() {
 650   main_task_runner_->PostTask(
 651       FROM_HERE,
 652       base::Bind(&LayerTreeTest::DispatchCompositeImmediately,
 653                  main_thread_weak_ptr_));
 654 }
 655
 656 void LayerTreeTest::WillBeginTest() {
 657   layer_tree_host_->SetLayerTreeHostClientReady();
 658 }
 659
 660 void LayerTreeTest::DoBeginTest() {
 661   client_ = LayerTreeHostClientForTesting::Create(this);
 662
 663   scoped_ptr<FakeExternalBeginFrameSource> external_begin_frame_source;
 664   if (settings_.use_external_begin_frame_source) {
 665     external_begin_frame_source.reset(new FakeExternalBeginFrameSource(
 666         settings_.renderer_settings.refresh_rate));
 667     external_begin_frame_source_ = external_begin_frame_source.get();
 668   }
 669
 670   DCHECK(!impl_thread_ || impl_thread_->message_loop_proxy().get());
 671   layer_tree_host_ = LayerTreeHostForTesting::Create(
 672       this, client_.get(), shared_bitmap_manager_.get(),
 673       gpu_memory_buffer_manager_.get(), task_graph_runner_.get(), settings_,
 674       base::MessageLoopProxy::current(),
 675       impl_thread_ ? impl_thread_->message_loop_proxy() : NULL,
 676       external_begin_frame_source.Pass());
 677   ASSERT_TRUE(layer_tree_host_);
 678
 679   started_ = true;
 680   beginning_ = true;
 681   SetupTree();
 682   WillBeginTest();
 683   BeginTest();
 684   beginning_ = false;
 685   if (end_when_begin_returns_)
 686     RealEndTest();
 687
 688   // Allow commits to happen once BeginTest() has had a chance to post tasks
 689   // so that those tasks will happen before the first commit.
 690   if (layer_tree_host_) {
 691     static_cast<LayerTreeHostForTesting*>(layer_tree_host_.get())
 692         ->set_test_started(true);
 693   }
 694 }
 695
 696 void LayerTreeTest::SetupTree() {
 697   if (!layer_tree_host_->root_layer()) {
 698     scoped_refptr<Layer> root_layer = Layer::Create();
 699     root_layer->SetBounds(gfx::Size(1, 1));
 700     root_layer->SetIsDrawable(true);
 701     layer_tree_host_->SetRootLayer(root_layer);
 702   }
 703
 704   gfx::Size root_bounds = layer_tree_host_->root_layer()->bounds();
 705   gfx::Size device_root_bounds = gfx::ToCeiledSize(
 706       gfx::ScaleSize(root_bounds, layer_tree_host_->device_scale_factor()));
 707   layer_tree_host_->SetViewportSize(device_root_bounds);
 708 }
 709
 710 void LayerTreeTest::Timeout() {
 711   timed_out_ = true;
 712   EndTest();
 713 }
 714
 715 void LayerTreeTest::RealEndTest() {
 716   if (layer_tree_host_ && !timed_out_ &&
 717       proxy()->MainFrameWillHappenForTesting()) {
 718     main_task_runner_->PostTask(
 719         FROM_HERE,
 720         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
 721     return;
 722   }
 723
 724   base::MessageLoop::current()->Quit();
 725 }
 726
 727 void LayerTreeTest::DispatchAddAnimation(Layer* layer_to_receive_animation,
 728                                          double animation_duration) {
 729   DCHECK(!proxy() || proxy()->IsMainThread());
 730
 731   if (layer_to_receive_animation) {
 732     AddOpacityTransitionToLayer(
 733         layer_to_receive_animation, animation_duration, 0, 0.5, true);
 734   }
 735 }
 736
 737 void LayerTreeTest::DispatchSetDeferCommits(bool defer_commits) {
 738   DCHECK(!proxy() || proxy()->IsMainThread());
 739
 740   if (layer_tree_host_)
 741     layer_tree_host_->SetDeferCommits(defer_commits);
 742 }
 743
 744 void LayerTreeTest::DispatchSetNeedsCommit() {
 745   DCHECK(!proxy() || proxy()->IsMainThread());
 746
 747   if (layer_tree_host_)
 748     layer_tree_host_->SetNeedsCommit();
 749 }
 750
 751 void LayerTreeTest::DispatchSetNeedsUpdateLayers() {
 752   DCHECK(!proxy() || proxy()->IsMainThread());
 753
 754   if (layer_tree_host_)
 755     layer_tree_host_->SetNeedsUpdateLayers();
 756 }
 757
 758 void LayerTreeTest::DispatchSetNeedsRedraw() {
 759   DCHECK(!proxy() || proxy()->IsMainThread());
 760
 761   if (layer_tree_host_)
 762     layer_tree_host_->SetNeedsRedraw();
 763 }
 764
 765 void LayerTreeTest::DispatchSetNeedsRedrawRect(const gfx::Rect& damage_rect) {
 766   DCHECK(!proxy() || proxy()->IsMainThread());
 767
 768   if (layer_tree_host_)
 769     layer_tree_host_->SetNeedsRedrawRect(damage_rect);
 770 }
 771
 772 void LayerTreeTest::DispatchSetVisible(bool visible) {
 773   DCHECK(!proxy() || proxy()->IsMainThread());
 774   if (layer_tree_host_)
 775     layer_tree_host_->SetVisible(visible);
 776 }
 777
 778 void LayerTreeTest::DispatchSetNextCommitForcesRedraw() {
 779   DCHECK(!proxy() || proxy()->IsMainThread());
 780
 781   if (layer_tree_host_)
 782     layer_tree_host_->SetNextCommitForcesRedraw();
 783 }
 784
 785 void LayerTreeTest::DispatchCompositeImmediately() {
 786   DCHECK(!proxy() || proxy()->IsMainThread());
 787   if (layer_tree_host_)
 788     layer_tree_host_->Composite(gfx::FrameTime::Now());
 789 }
 790
 791 void LayerTreeTest::RunTest(bool threaded,
 792                             bool delegating_renderer,
 793                             bool impl_side_painting) {
 794   if (threaded) {
 795     impl_thread_.reset(new base::Thread("Compositor"));
 796     ASSERT_TRUE(impl_thread_->Start());
 797   }
 798
 799   main_task_runner_ = base::MessageLoopProxy::current();
 800
 801   shared_bitmap_manager_.reset(new TestSharedBitmapManager);
 802   gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
 803   task_graph_runner_.reset(new TestTaskGraphRunner);
 804
 805   delegating_renderer_ = delegating_renderer;
 806
 807   // Spend less time waiting for BeginFrame because the output is
 808   // mocked out.
 809   settings_.renderer_settings.refresh_rate = 200.0;
 810   settings_.background_animation_rate = 200.0;
 811   settings_.impl_side_painting = impl_side_painting;
 812   settings_.verify_property_trees = verify_property_trees_;
 813   InitializeSettings(&settings_);
 814
 815   main_task_runner_->PostTask(
 816       FROM_HERE,
 817       base::Bind(&LayerTreeTest::DoBeginTest, base::Unretained(this)));
 818
 819   if (timeout_seconds_) {
 820     timeout_.Reset(base::Bind(&LayerTreeTest::Timeout, base::Unretained(this)));
 821     main_task_runner_->PostDelayedTask(
 822         FROM_HERE,
 823         timeout_.callback(),
 824         base::TimeDelta::FromSeconds(timeout_seconds_));
 825   }
 826
 827   base::MessageLoop::current()->Run();
 828   DestroyLayerTreeHost();
 829
 830   timeout_.Cancel();
 831
 832   ASSERT_FALSE(layer_tree_host_.get());
 833   client_ = nullptr;
 834   if (timed_out_) {
 835     FAIL() << "Test timed out";
 836     return;
 837   }
 838   AfterTest();
 839 }
 840
 841 void LayerTreeTest::RunTestWithImplSidePainting() {
 842   RunTest(true, false, true);
 843 }
 844
 845 void LayerTreeTest::RequestNewOutputSurface() {
 846   layer_tree_host_->SetOutputSurface(CreateOutputSurface());
 847 }
 848
 849 scoped_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface() {
 850   scoped_ptr<FakeOutputSurface> output_surface = CreateFakeOutputSurface();
 851   DCHECK_EQ(delegating_renderer_,
 852             output_surface->capabilities().delegated_rendering);
 853   output_surface_ = output_surface.get();
 854
 855   if (settings_.use_external_begin_frame_source) {
 856     DCHECK(external_begin_frame_source_);
 857     DCHECK(external_begin_frame_source_->is_ready());
 858   }
 859   return output_surface.Pass();
 860 }
 861
 862 scoped_ptr<FakeOutputSurface> LayerTreeTest::CreateFakeOutputSurface() {
 863   if (delegating_renderer_)
 864     return FakeOutputSurface::CreateDelegating3d();
 865   else
 866     return FakeOutputSurface::Create3d();
 867 }
 868
 869 TestWebGraphicsContext3D* LayerTreeTest::TestContext() {
 870   return static_cast<TestContextProvider*>(output_surface_->context_provider())
 871       ->TestContext3d();
 872 }
 873
 874 int LayerTreeTest::LastCommittedSourceFrameNumber(LayerTreeHostImpl* impl)
 875     const {
 876   if (impl->pending_tree())
 877     return impl->pending_tree()->source_frame_number();
 878   if (impl->active_tree())
 879     return impl->active_tree()->source_frame_number();
 880   // Source frames start at 0, so this is invalid.
 881   return -1;
 882 }
 883
 884 void LayerTreeTest::DestroyLayerTreeHost() {
 885   if (layer_tree_host_ && layer_tree_host_->root_layer())
 886     layer_tree_host_->root_layer()->SetLayerTreeHost(NULL);
 887   layer_tree_host_ = nullptr;
 888 }
 889
 890 LayerTreeHost* LayerTreeTest::layer_tree_host() {
 891   // We check for a null proxy here as we sometimes ask for the layer tree host
 892   // when the proxy does not exist, often for checking settings after a test has
 893   // completed. For example, LTHPixelResourceTest::RunPixelResourceTest. See
 894   // elsewhere in this file for other examples.
 895   DCHECK(!proxy() || proxy()->IsMainThread() || proxy()->IsMainThreadBlocked());
 896   return layer_tree_host_.get();
 897 }
 898
 899 }  // namespace cc