1// Copyright 2014 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 <set>
6
7#include "cc/test/test_context_provider.h"
8#include "cc/test/test_web_graphics_context_3d.h"
9#include "content/browser/compositor/buffer_queue.h"
10#include "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
11#include "gpu/GLES2/gl2extchromium.h"
12#include "testing/gmock/include/gmock/gmock.h"
13#include "testing/gtest/include/gtest/gtest.h"
14#include "third_party/khronos/GLES2/gl2ext.h"
15
16using ::testing::_;
17using ::testing::Expectation;
18using ::testing::Ne;
19using ::testing::Return;
20
21namespace content {
22class MockBufferQueue : public BufferQueue {
23 public:
24  MockBufferQueue(scoped_refptr<cc::ContextProvider> context_provider,
25                  unsigned int internalformat)
26      : BufferQueue(context_provider, internalformat) {}
27  MOCK_METHOD4(CopyBufferDamage,
28               void(int, int, const gfx::Rect&, const gfx::Rect&));
29};
30
31class BufferQueueTest : public ::testing::Test {
32 public:
33  BufferQueueTest() : doublebuffering_(true), first_frame_(true) {}
34
35  virtual void SetUp() OVERRIDE {
36    scoped_refptr<cc::TestContextProvider> context_provider =
37        cc::TestContextProvider::Create(cc::TestWebGraphicsContext3D::Create());
38    context_provider->BindToCurrentThread();
39    output_surface_.reset(new MockBufferQueue(context_provider, GL_RGBA8_OES));
40    output_surface_->Initialize();
41  }
42
43  unsigned current_surface() { return output_surface_->current_surface_.image; }
44  const std::vector<BufferQueue::AllocatedSurface>& available_surfaces() {
45    return output_surface_->available_surfaces_;
46  }
47  const std::deque<BufferQueue::AllocatedSurface>& in_flight_surfaces() {
48    return output_surface_->in_flight_surfaces_;
49  }
50
51  const BufferQueue::AllocatedSurface& last_frame() {
52    return output_surface_->in_flight_surfaces_.back();
53  }
54  const BufferQueue::AllocatedSurface& next_frame() {
55    return output_surface_->available_surfaces_.back();
56  }
57  const gfx::Size size() { return output_surface_->size_; }
58
59  int CountBuffers() {
60    int n = available_surfaces().size() + in_flight_surfaces().size();
61    if (current_surface())
62      n++;
63    return n;
64  }
65
66  // Check that each buffer is unique if present.
67  void CheckUnique() {
68    std::set<unsigned> buffers;
69    EXPECT_TRUE(InsertUnique(&buffers, current_surface()));
70    for (size_t i = 0; i < available_surfaces().size(); i++)
71      EXPECT_TRUE(InsertUnique(&buffers, available_surfaces()[i].image));
72    for (std::deque<BufferQueue::AllocatedSurface>::const_iterator it =
73             in_flight_surfaces().begin();
74         it != in_flight_surfaces().end();
75         ++it)
76      EXPECT_TRUE(InsertUnique(&buffers, it->image));
77  }
78
79  void SwapBuffers() {
80    output_surface_->SwapBuffers(gfx::Rect(output_surface_->size_));
81  }
82
83  void SendDamagedFrame(const gfx::Rect& damage) {
84    // We don't care about the GL-level implementation here, just how it uses
85    // damage rects.
86    output_surface_->BindFramebuffer();
87    output_surface_->SwapBuffers(damage);
88    if (doublebuffering_ || !first_frame_)
89      output_surface_->PageFlipComplete();
90    first_frame_ = false;
91  }
92
93  void SendFullFrame() { SendDamagedFrame(gfx::Rect(output_surface_->size_)); }
94
95 protected:
96  bool InsertUnique(std::set<unsigned>* set, unsigned value) {
97    if (!value)
98      return true;
99    if (set->find(value) != set->end())
100      return false;
101    set->insert(value);
102    return true;
103  }
104
105  scoped_ptr<MockBufferQueue> output_surface_;
106  bool doublebuffering_;
107  bool first_frame_;
108};
109
110namespace {
111const gfx::Size screen_size = gfx::Size(30, 30);
112const gfx::Rect screen_rect = gfx::Rect(screen_size);
113const gfx::Rect small_damage = gfx::Rect(gfx::Size(10, 10));
114const gfx::Rect large_damage = gfx::Rect(gfx::Size(20, 20));
115const gfx::Rect overlapping_damage = gfx::Rect(gfx::Size(5, 20));
116
117class MockedContext : public cc::TestWebGraphicsContext3D {
118 public:
119  MOCK_METHOD2(bindFramebuffer, void(GLenum, GLuint));
120  MOCK_METHOD2(bindTexture, void(GLenum, GLuint));
121  MOCK_METHOD2(bindTexImage2DCHROMIUM, void(GLenum, GLint));
122  MOCK_METHOD4(createImageCHROMIUM, GLuint(GLsizei, GLsizei, GLenum, GLenum));
123  MOCK_METHOD1(destroyImageCHROMIUM, void(GLuint));
124  MOCK_METHOD5(framebufferTexture2D,
125               void(GLenum, GLenum, GLenum, GLuint, GLint));
126};
127
128scoped_ptr<BufferQueue> CreateOutputSurfaceWithMock(MockedContext** context) {
129  *context = new MockedContext();
130  scoped_refptr<cc::TestContextProvider> context_provider =
131      cc::TestContextProvider::Create(
132          scoped_ptr<cc::TestWebGraphicsContext3D>(*context));
133  context_provider->BindToCurrentThread();
134  scoped_ptr<BufferQueue> buffer_queue(
135      new BufferQueue(context_provider, GL_RGBA8_OES));
136  buffer_queue->Initialize();
137  return buffer_queue.Pass();
138}
139
140TEST(BufferQueueStandaloneTest, FboInitialization) {
141  MockedContext* context;
142  scoped_ptr<BufferQueue> output_surface =
143      CreateOutputSurfaceWithMock(&context);
144
145  EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
146  ON_CALL(*context, framebufferTexture2D(_, _, _, _, _))
147      .WillByDefault(Return());
148
149  output_surface->Reshape(gfx::Size(10, 20), 1.0f);
150}
151
152TEST(BufferQueueStandaloneTest, FboBinding) {
153  MockedContext* context;
154  scoped_ptr<BufferQueue> output_surface =
155      CreateOutputSurfaceWithMock(&context);
156  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, Ne(0U)));
157  EXPECT_CALL(*context, destroyImageCHROMIUM(1));
158  Expectation image =
159      EXPECT_CALL(
160          *context,
161          createImageCHROMIUM(0, 0, GL_RGBA8_OES, GL_IMAGE_SCANOUT_CHROMIUM))
162          .WillOnce(Return(1));
163  Expectation fb =
164      EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
165  Expectation tex = EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, Ne(0U)));
166  Expectation bind_tex =
167      EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1))
168          .After(tex, image);
169  EXPECT_CALL(
170      *context,
171      framebufferTexture2D(
172          GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, Ne(0U), _))
173      .After(fb, bind_tex);
174
175  output_surface->BindFramebuffer();
176}
177
178TEST_F(BufferQueueTest, PartialSwapReuse) {
179  // Check that
180  output_surface_->Reshape(screen_size, 1.0f);
181  ASSERT_TRUE(doublebuffering_);
182  EXPECT_CALL(*output_surface_,
183              CopyBufferDamage(_, _, small_damage, screen_rect)).Times(1);
184  EXPECT_CALL(*output_surface_,
185              CopyBufferDamage(_, _, small_damage, small_damage)).Times(1);
186  EXPECT_CALL(*output_surface_,
187              CopyBufferDamage(_, _, large_damage, small_damage)).Times(1);
188  SendFullFrame();
189  SendDamagedFrame(small_damage);
190  SendDamagedFrame(small_damage);
191  SendDamagedFrame(large_damage);
192  // Verify that the damage has propagated.
193  EXPECT_EQ(next_frame().damage, large_damage);
194}
195
196TEST_F(BufferQueueTest, PartialSwapFullFrame) {
197  output_surface_->Reshape(screen_size, 1.0f);
198  ASSERT_TRUE(doublebuffering_);
199  EXPECT_CALL(*output_surface_,
200              CopyBufferDamage(_, _, small_damage, screen_rect)).Times(1);
201  SendFullFrame();
202  SendDamagedFrame(small_damage);
203  SendFullFrame();
204  SendFullFrame();
205  EXPECT_EQ(next_frame().damage, screen_rect);
206}
207
208TEST_F(BufferQueueTest, PartialSwapOverlapping) {
209  output_surface_->Reshape(screen_size, 1.0f);
210  ASSERT_TRUE(doublebuffering_);
211  EXPECT_CALL(*output_surface_,
212              CopyBufferDamage(_, _, small_damage, screen_rect)).Times(1);
213  EXPECT_CALL(*output_surface_,
214              CopyBufferDamage(_, _, overlapping_damage, small_damage))
215      .Times(1);
216
217  SendFullFrame();
218  SendDamagedFrame(small_damage);
219  SendDamagedFrame(overlapping_damage);
220  EXPECT_EQ(next_frame().damage, overlapping_damage);
221}
222
223TEST_F(BufferQueueTest, MultipleBindCalls) {
224  // Check that multiple bind calls do not create or change surfaces.
225  output_surface_->BindFramebuffer();
226  EXPECT_EQ(1, CountBuffers());
227  unsigned int fb = current_surface();
228  output_surface_->BindFramebuffer();
229  EXPECT_EQ(1, CountBuffers());
230  EXPECT_EQ(fb, current_surface());
231}
232
233TEST_F(BufferQueueTest, CheckDoubleBuffering) {
234  // Check buffer flow through double buffering path.
235  EXPECT_EQ(0, CountBuffers());
236  output_surface_->BindFramebuffer();
237  EXPECT_EQ(1, CountBuffers());
238  EXPECT_NE(0U, current_surface());
239  SwapBuffers();
240  EXPECT_EQ(1U, in_flight_surfaces().size());
241  output_surface_->PageFlipComplete();
242  EXPECT_EQ(1U, in_flight_surfaces().size());
243  output_surface_->BindFramebuffer();
244  EXPECT_EQ(2, CountBuffers());
245  CheckUnique();
246  EXPECT_NE(0U, current_surface());
247  EXPECT_EQ(1U, in_flight_surfaces().size());
248  SwapBuffers();
249  CheckUnique();
250  EXPECT_EQ(2U, in_flight_surfaces().size());
251  output_surface_->PageFlipComplete();
252  CheckUnique();
253  EXPECT_EQ(1U, in_flight_surfaces().size());
254  EXPECT_EQ(1U, available_surfaces().size());
255  output_surface_->BindFramebuffer();
256  EXPECT_EQ(2, CountBuffers());
257  CheckUnique();
258  EXPECT_TRUE(available_surfaces().empty());
259}
260
261TEST_F(BufferQueueTest, CheckTripleBuffering) {
262  // Check buffer flow through triple buffering path.
263
264  // This bit is the same sequence tested in the doublebuffering case.
265  output_surface_->BindFramebuffer();
266  SwapBuffers();
267  output_surface_->PageFlipComplete();
268  output_surface_->BindFramebuffer();
269  SwapBuffers();
270
271  EXPECT_EQ(2, CountBuffers());
272  CheckUnique();
273  EXPECT_EQ(2U, in_flight_surfaces().size());
274  output_surface_->BindFramebuffer();
275  EXPECT_EQ(3, CountBuffers());
276  CheckUnique();
277  EXPECT_NE(0U, current_surface());
278  EXPECT_EQ(2U, in_flight_surfaces().size());
279  output_surface_->PageFlipComplete();
280  EXPECT_EQ(3, CountBuffers());
281  CheckUnique();
282  EXPECT_NE(0U, current_surface());
283  EXPECT_EQ(1U, in_flight_surfaces().size());
284  EXPECT_EQ(1U, available_surfaces().size());
285}
286
287}  // namespace
288}  // namespace content
289