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