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