1// Copyright 2012 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_TEST_COMMON_H_
6#define CC_TEST_LAYER_TEST_COMMON_H_
7
8#include "base/basictypes.h"
9#include "base/memory/scoped_ptr.h"
10#include "cc/quads/render_pass.h"
11#include "cc/test/fake_layer_tree_host.h"
12#include "cc/test/mock_occlusion_tracker.h"
13#include "cc/trees/layer_tree_host_impl.h"
14
15#define EXPECT_SET_NEEDS_COMMIT(expect, code_to_test)                 \
16  do {                                                                \
17    EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times((expect)); \
18    code_to_test;                                                     \
19    Mock::VerifyAndClearExpectations(layer_tree_host_.get());         \
20  } while (false)
21
22#define EXPECT_SET_NEEDS_UPDATE(expect, code_to_test)                       \
23  do {                                                                      \
24    EXPECT_CALL(*layer_tree_host_, SetNeedsUpdateLayers()).Times((expect)); \
25    code_to_test;                                                           \
26    Mock::VerifyAndClearExpectations(layer_tree_host_.get());               \
27  } while (false)
28
29namespace gfx { class Rect; }
30
31namespace cc {
32class LayerImpl;
33class OutputSurface;
34class QuadList;
35class RenderSurfaceImpl;
36class ResourceProvider;
37
38class LayerTestCommon {
39 public:
40  static const char* quad_string;
41
42  static void VerifyQuadsExactlyCoverRect(const QuadList& quads,
43                                          const gfx::Rect& rect);
44
45  static void VerifyQuadsAreOccluded(const QuadList& quads,
46                                     const gfx::Rect& occluded,
47                                     size_t* partially_occluded_count);
48
49  class LayerImplTest {
50   public:
51    LayerImplTest();
52    ~LayerImplTest();
53
54    template <typename T>
55    T* AddChildToRoot() {
56      scoped_ptr<T> layer = T::Create(host_->host_impl()->active_tree(), 2);
57      T* ptr = layer.get();
58      root_layer_impl_->AddChild(layer.template PassAs<LayerImpl>());
59      return ptr;
60    }
61
62    template <typename T, typename A>
63    T* AddChildToRoot(const A& a) {
64      scoped_ptr<T> layer = T::Create(host_->host_impl()->active_tree(), 2, a);
65      T* ptr = layer.get();
66      root_layer_impl_->AddChild(layer.template PassAs<LayerImpl>());
67      return ptr;
68    }
69
70    template <typename T, typename A, typename B>
71    T* AddChildToRoot(const A& a, const B& b) {
72      scoped_ptr<T> layer =
73          T::Create(host_->host_impl()->active_tree(), 2, a, b);
74      T* ptr = layer.get();
75      root_layer_impl_->AddChild(layer.template PassAs<LayerImpl>());
76      return ptr;
77    }
78
79    template <typename T, typename A, typename B, typename C, typename D>
80    T* AddChildToRoot(const A& a, const B& b, const C& c, const D& d) {
81      scoped_ptr<T> layer =
82          T::Create(host_->host_impl()->active_tree(), 2, a, b, c, d);
83      T* ptr = layer.get();
84      root_layer_impl_->AddChild(layer.template PassAs<LayerImpl>());
85      return ptr;
86    }
87
88    template <typename T,
89              typename A,
90              typename B,
91              typename C,
92              typename D,
93              typename E>
94    T* AddChildToRoot(const A& a,
95                      const B& b,
96                      const C& c,
97                      const D& d,
98                      const E& e) {
99      scoped_ptr<T> layer =
100          T::Create(host_->host_impl()->active_tree(), 2, a, b, c, d, e);
101      T* ptr = layer.get();
102      root_layer_impl_->AddChild(layer.template PassAs<LayerImpl>());
103      return ptr;
104    }
105
106    void CalcDrawProps(const gfx::Size& viewport_size);
107    void AppendQuadsWithOcclusion(LayerImpl* layer_impl,
108                                  const gfx::Rect& occluded);
109    void AppendQuadsForPassWithOcclusion(LayerImpl* layer_impl,
110                                         const RenderPassId& id,
111                                         const gfx::Rect& occluded);
112    void AppendSurfaceQuadsWithOcclusion(RenderSurfaceImpl* surface_impl,
113                                         const gfx::Rect& occluded);
114
115    OutputSurface* output_surface() const {
116      return host_->host_impl()->output_surface();
117    }
118    ResourceProvider* resource_provider() const {
119      return host_->host_impl()->resource_provider();
120    }
121    LayerImpl* root_layer() const { return root_layer_impl_.get(); }
122    FakeLayerTreeHostImpl* host_impl() const { return host_->host_impl(); }
123    Proxy* proxy() const { return host_->host_impl()->proxy(); }
124    const QuadList& quad_list() const { return render_pass_->quad_list; }
125
126   private:
127    FakeLayerTreeHostClient client_;
128    scoped_ptr<FakeLayerTreeHost> host_;
129    scoped_ptr<LayerImpl> root_layer_impl_;
130    scoped_ptr<RenderPass> render_pass_;
131    MockOcclusionTracker<LayerImpl> occlusion_tracker_;
132  };
133};
134
135}  // namespace cc
136
137#endif  // CC_TEST_LAYER_TEST_COMMON_H_
138