cc/test/layer_tree_test.h

   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 #ifndef CC_TEST_LAYER_TREE_TEST_H_
   6 #define CC_TEST_LAYER_TREE_TEST_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/threading/thread.h"
  10 #include "cc/animation/animation_delegate.h"
  11 #include "cc/trees/layer_tree_host.h"
  12 #include "cc/trees/layer_tree_host_impl.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace cc {
  16 class FakeExternalBeginFrameSource;
  17 class FakeLayerTreeHostClient;
  18 class FakeOutputSurface;
  19 class LayerImpl;
  20 class LayerTreeHost;
  21 class LayerTreeHostClient;
  22 class LayerTreeHostImpl;
  23 class TestContextProvider;
  24 class TestGpuMemoryBufferManager;
  25 class TestWebGraphicsContext3D;
  26
  27 // Used by test stubs to notify the test when something interesting happens.
  28 class TestHooks : public AnimationDelegate {
  29  public:
  30   TestHooks();
  31   ~TestHooks() override;
  32
  33   void ReadSettings(const LayerTreeSettings& settings);
  34
  35   virtual void CreateResourceAndTileTaskWorkerPool(
  36       LayerTreeHostImpl* host_impl,
  37       scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
  38       scoped_ptr<ResourcePool>* resource_pool,
  39       scoped_ptr<ResourcePool>* staging_resource_pool);
  40   virtual void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
  41                                           const BeginFrameArgs& args) {}
  42   virtual void DidFinishImplFrameOnThread(LayerTreeHostImpl* host_impl) {}
  43   virtual void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
  44                                              CommitEarlyOutReason reason) {}
  45   virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) {}
  46   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) {}
  47   virtual void WillActivateTreeOnThread(LayerTreeHostImpl* host_impl) {}
  48   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) {}
  49   virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
  50                                            bool success) {}
  51   virtual DrawResult PrepareToDrawOnThread(
  52       LayerTreeHostImpl* host_impl,
  53       LayerTreeHostImpl::FrameData* frame_data,
  54       DrawResult draw_result);
  55   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) {}
  56   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) {}
  57   virtual void SwapBuffersCompleteOnThread(LayerTreeHostImpl* host_impl) {}
  58   virtual void NotifyReadyToActivateOnThread(LayerTreeHostImpl* host_impl) {}
  59   virtual void NotifyReadyToDrawOnThread(LayerTreeHostImpl* host_impl) {}
  60   virtual void NotifyTileStateChangedOnThread(LayerTreeHostImpl* host_impl,
  61                                               const Tile* tile) {}
  62   virtual void AnimateLayers(LayerTreeHostImpl* host_impl,
  63                              base::TimeTicks monotonic_time) {}
  64   virtual void UpdateAnimationState(LayerTreeHostImpl* host_impl,
  65                                     bool has_unfinished_animation) {}
  66   virtual void WillAnimateLayers(LayerTreeHostImpl* host_impl,
  67                                  base::TimeTicks monotonic_time) {}
  68   virtual void ApplyViewportDeltas(
  69       const gfx::Vector2dF& inner_delta,
  70       const gfx::Vector2dF& outer_delta,
  71       const gfx::Vector2dF& elastic_overscroll_delta,
  72       float scale,
  73       float top_controls_delta) {}
  74   virtual void BeginMainFrame(const BeginFrameArgs& args) {}
  75   virtual void WillBeginMainFrame() {}
  76   virtual void DidBeginMainFrame() {}
  77   virtual void Layout() {}
  78   virtual void DidInitializeOutputSurface() {}
  79   virtual void DidFailToInitializeOutputSurface() {}
  80   virtual void DidAddAnimation() {}
  81   virtual void WillCommit() {}
  82   virtual void DidCommit() {}
  83   virtual void DidCommitAndDrawFrame() {}
  84   virtual void DidCompleteSwapBuffers() {}
  85   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
  86                                        bool visible) {}
  87   virtual void ScheduleComposite() {}
  88
  89   // Hooks for SchedulerClient.
  90   virtual void ScheduledActionWillSendBeginMainFrame() {}
  91   virtual void ScheduledActionSendBeginMainFrame() {}
  92   virtual void ScheduledActionDrawAndSwapIfPossible() {}
  93   virtual void ScheduledActionAnimate() {}
  94   virtual void ScheduledActionCommit() {}
  95   virtual void ScheduledActionBeginOutputSurfaceCreation() {}
  96   virtual void ScheduledActionPrepareTiles() {}
  97   virtual void ScheduledActionInvalidateOutputSurface() {}
  98   virtual void SendBeginFramesToChildren(const BeginFrameArgs& args) {}
  99   virtual void SendBeginMainFrameNotExpectedSoon() {}
 100
 101   // Implementation of AnimationDelegate:
 102   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
 103                               Animation::TargetProperty target_property,
 104                               int group) override {}
 105   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
 106                                Animation::TargetProperty target_property,
 107                                int group) override {}
 108
 109   virtual void RequestNewOutputSurface() = 0;
 110 };
 111
 112 class BeginTask;
 113 class LayerTreeHostClientForTesting;
 114 class TimeoutTask;
 115
 116 // The LayerTreeTests runs with the main loop running. It instantiates a single
 117 // LayerTreeHostForTesting and associated LayerTreeHostImplForTesting and
 118 // LayerTreeHostClientForTesting.
 119 //
 120 // BeginTest() is called once the main message loop is running and the layer
 121 // tree host is initialized.
 122 //
 123 // Key stages of the drawing loop, e.g. drawing or commiting, redirect to
 124 // LayerTreeTest methods of similar names. To track the commit process, override
 125 // these functions.
 126 //
 127 // The test continues until someone calls EndTest. EndTest can be called on any
 128 // thread, but be aware that ending the test is an asynchronous process.
 129 class LayerTreeTest : public testing::Test, public TestHooks {
 130  public:
 131   ~LayerTreeTest() override;
 132
 133   virtual void EndTest();
 134   void EndTestAfterDelayMs(int delay_milliseconds);
 135
 136   void PostAddAnimationToMainThread(Layer* layer_to_receive_animation);
 137   void PostAddInstantAnimationToMainThread(Layer* layer_to_receive_animation);
 138   void PostAddLongAnimationToMainThread(Layer* layer_to_receive_animation);
 139   void PostSetDeferCommitsToMainThread(bool defer_commits);
 140   void PostSetNeedsCommitToMainThread();
 141   void PostSetNeedsUpdateLayersToMainThread();
 142   void PostSetNeedsRedrawToMainThread();
 143   void PostSetNeedsRedrawRectToMainThread(const gfx::Rect& damage_rect);
 144   void PostSetVisibleToMainThread(bool visible);
 145   void PostSetNextCommitForcesRedrawToMainThread();
 146   void PostCompositeImmediatelyToMainThread();
 147
 148   void DoBeginTest();
 149   void Timeout();
 150
 151   bool verify_property_trees() const { return verify_property_trees_; }
 152   void set_verify_property_trees(bool verify_property_trees) {
 153     verify_property_trees_ = verify_property_trees;
 154   }
 155
 156   const LayerSettings& layer_settings() { return layer_settings_; }
 157
 158  protected:
 159   LayerTreeTest();
 160
 161   virtual void InitializeSettings(LayerTreeSettings* settings) {}
 162   virtual void InitializeLayerSettings(LayerSettings* layer_settings) {}
 163
 164   void RealEndTest();
 165
 166   virtual void DispatchAddAnimation(Layer* layer_to_receive_animation,
 167                                     double animation_duration);
 168   void DispatchSetDeferCommits(bool defer_commits);
 169   void DispatchSetNeedsCommit();
 170   void DispatchSetNeedsUpdateLayers();
 171   void DispatchSetNeedsRedraw();
 172   void DispatchSetNeedsRedrawRect(const gfx::Rect& damage_rect);
 173   void DispatchSetVisible(bool visible);
 174   void DispatchSetNextCommitForcesRedraw();
 175   void DispatchDidAddAnimation();
 176   void DispatchCompositeImmediately();
 177
 178   virtual void AfterTest() = 0;
 179   virtual void WillBeginTest();
 180   virtual void BeginTest() = 0;
 181   virtual void SetupTree();
 182
 183   virtual void RunTest(bool threaded,
 184                        bool delegating_renderer,
 185                        bool impl_side_painting);
 186   virtual void RunTestWithImplSidePainting();
 187
 188   bool HasImplThread() { return !!impl_thread_; }
 189   base::SingleThreadTaskRunner* ImplThreadTaskRunner() {
 190     DCHECK(proxy());
 191     return proxy()->ImplThreadTaskRunner() ? proxy()->ImplThreadTaskRunner()
 192                                            : main_task_runner_.get();
 193   }
 194   base::SingleThreadTaskRunner* MainThreadTaskRunner() {
 195     return main_task_runner_.get();
 196   }
 197   Proxy* proxy() const {
 198     return layer_tree_host_ ? layer_tree_host_->proxy() : NULL;
 199   }
 200   TaskGraphRunner* task_graph_runner() const {
 201     return task_graph_runner_.get();
 202   }
 203
 204   bool TestEnded() const { return ended_; }
 205
 206   LayerTreeHost* layer_tree_host();
 207   bool delegating_renderer() const { return delegating_renderer_; }
 208   FakeOutputSurface* output_surface() { return output_surface_; }
 209   int LastCommittedSourceFrameNumber(LayerTreeHostImpl* impl) const;
 210
 211   void DestroyLayerTreeHost();
 212
 213   // By default, output surface recreation is synchronous.
 214   void RequestNewOutputSurface() override;
 215   // Override this for pixel tests, where you need a real output surface.
 216   virtual scoped_ptr<OutputSurface> CreateOutputSurface();
 217   // Override this for unit tests, which should not produce pixel output.
 218   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface();
 219
 220   TestWebGraphicsContext3D* TestContext();
 221
 222   TestGpuMemoryBufferManager* GetTestGpuMemoryBufferManager() {
 223     return gpu_memory_buffer_manager_.get();
 224   }
 225
 226  private:
 227   LayerTreeSettings settings_;
 228   LayerSettings layer_settings_;
 229
 230   scoped_ptr<LayerTreeHostClientForTesting> client_;
 231   scoped_ptr<LayerTreeHost> layer_tree_host_;
 232   FakeOutputSurface* output_surface_;
 233   FakeExternalBeginFrameSource* external_begin_frame_source_;
 234
 235   bool beginning_;
 236   bool end_when_begin_returns_;
 237   bool timed_out_;
 238   bool scheduled_;
 239   bool started_;
 240   bool ended_;
 241   bool delegating_renderer_;
 242   bool verify_property_trees_;
 243
 244   int timeout_seconds_;
 245
 246   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 247   scoped_ptr<base::Thread> impl_thread_;
 248   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
 249   scoped_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
 250   scoped_ptr<TaskGraphRunner> task_graph_runner_;
 251   base::CancelableClosure timeout_;
 252   scoped_refptr<TestContextProvider> compositor_contexts_;
 253   base::WeakPtr<LayerTreeTest> main_thread_weak_ptr_;
 254   base::WeakPtrFactory<LayerTreeTest> weak_factory_;
 255 };
 256
 257 }  // namespace cc
 258
 259 #define SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)        \
 260   TEST_F(TEST_FIXTURE_NAME, RunSingleThread_DirectRenderer_MainThreadPaint) { \
 261     RunTest(false, false, false);                                             \
 262   }                                                                           \
 263   class SingleThreadDirectNoImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 264
 265 #define SINGLE_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)        \
 266   TEST_F(TEST_FIXTURE_NAME, RunSingleThread_DirectRenderer_ImplSidePaint) { \
 267     RunTest(false, false, true);                                            \
 268   }                                                                         \
 269   class SingleThreadDirectImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 270
 271 #define SINGLE_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME)   \
 272   SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 273   SINGLE_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 274
 275 #define SINGLE_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME) \
 276   TEST_F(TEST_FIXTURE_NAME,                                                \
 277          RunSingleThread_DelegatingRenderer_MainThreadPaint) {             \
 278     RunTest(false, true, false);                                           \
 279   }                                                                        \
 280   class SingleThreadDelegatingNoImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 281
 282 #define SINGLE_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME) \
 283   TEST_F(TEST_FIXTURE_NAME,                                              \
 284          RunSingleThread_DelegatingRenderer_ImplSidePaint) {             \
 285     RunTest(false, true, true);                                          \
 286   }                                                                      \
 287   class SingleThreadDelegatingImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 288
 289 #define SINGLE_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)   \
 290   SINGLE_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 291   SINGLE_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 292
 293 #define SINGLE_THREAD_NOIMPL_TEST_F(TEST_FIXTURE_NAME)            \
 294   SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 295   SINGLE_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
 296
 297 #define SINGLE_THREAD_IMPL_TEST_F(TEST_FIXTURE_NAME)            \
 298   SINGLE_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME); \
 299   SINGLE_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 300
 301 #define SINGLE_THREAD_TEST_F(TEST_FIXTURE_NAME)            \
 302   SINGLE_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME); \
 303   SINGLE_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 304
 305 #define MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)        \
 306   TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DirectRenderer_MainThreadPaint) { \
 307     RunTest(true, false, false);                                             \
 308   }                                                                          \
 309   class MultiThreadDirectNoImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 310
 311 #define MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)        \
 312   TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DirectRenderer_ImplSidePaint) { \
 313     RunTest(true, false, true);                                            \
 314   }                                                                        \
 315   class MultiThreadDirectImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 316
 317 #define MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME)   \
 318   MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 319   MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 320
 321 #define MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME) \
 322   TEST_F(TEST_FIXTURE_NAME,                                               \
 323          RunMultiThread_DelegatingRenderer_MainThreadPaint) {             \
 324     RunTest(true, true, false);                                           \
 325   }                                                                       \
 326   class MultiThreadDelegatingNoImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 327
 328 #define MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)        \
 329   TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DelegatingRenderer_ImplSidePaint) { \
 330     RunTest(true, true, true);                                                 \
 331   }                                                                            \
 332   class MultiThreadDelegatingImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 333
 334 #define MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)   \
 335   MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 336   MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 337
 338 #define MULTI_THREAD_NOIMPL_TEST_F(TEST_FIXTURE_NAME)            \
 339   MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 340   MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
 341
 342 #define MULTI_THREAD_IMPL_TEST_F(TEST_FIXTURE_NAME)            \
 343   MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME); \
 344   MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 345
 346 #define MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)            \
 347   MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME); \
 348   MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 349
 350 #define SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(    \
 351     TEST_FIXTURE_NAME)                                            \
 352   SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 353   MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
 354
 355 #define SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME) \
 356   SINGLE_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME);                \
 357   MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 358
 359 #define SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
 360   SINGLE_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME);                \
 361   MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 362
 363 #define SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(    \
 364     TEST_FIXTURE_NAME)                                                \
 365   SINGLE_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 366   MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
 367
 368 #define SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(    \
 369     TEST_FIXTURE_NAME)                                              \
 370   SINGLE_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME); \
 371   MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 372
 373 #define SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
 374   SINGLE_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME);                \
 375   MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 376
 377 #define SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(TEST_FIXTURE_NAME)            \
 378   SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
 379   SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
 380
 381 #define SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(TEST_FIXTURE_NAME)            \
 382   SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME); \
 383   SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
 384
 385 #define SINGLE_AND_MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)            \
 386   SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME); \
 387   SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 388
 389 // Some tests want to control when notify ready for activation occurs,
 390 // but this is not supported in the single-threaded case.
 391 #define SINGLE_AND_MULTI_THREAD_BLOCKNOTIFY_TEST_F(TEST_FIXTURE_NAME) \
 392   SINGLE_THREAD_NOIMPL_TEST_F(TEST_FIXTURE_NAME);                     \
 393   MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)
 394
 395 #endif  // CC_TEST_LAYER_TREE_TEST_H_