1// Copyright (c) 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 "ppapi/tests/test_compositor.h"
6
7#include <GLES2/gl2.h>
8#include <GLES2/gl2ext.h>
9#include <stdio.h>
10#include <stdlib.h>
11#include <string.h>
12
13#include "ppapi/c/ppb_opengles2.h"
14#include "ppapi/cpp/compositor.h"
15#include "ppapi/cpp/compositor_layer.h"
16#include "ppapi/cpp/image_data.h"
17#include "ppapi/lib/gl/gles2/gl2ext_ppapi.h"
18#include "ppapi/lib/gl/include/GLES2/gl2.h"
19#include "ppapi/lib/gl/include/GLES2/gl2ext.h"
20#include "ppapi/tests/test_utils.h"
21
22namespace {
23
24const float kMatrix[16] = {
25  1.0f, 0.0f, 0.0f, 0.0f,
26  0.0f, 1.0f, 0.0f, 0.0f,
27  0.0f, 0.0f, 1.0f, 0.0f,
28  0.0f, 0.0f, 0.0f, 1.0f,
29};
30
31}  // namespace
32
33REGISTER_TEST_CASE(Compositor);
34
35#define VERIFY(r) do { \
36    std::string result = (r); \
37    if (result != "") \
38      return result; \
39  } while (false)
40
41bool TestCompositor::Init() {
42  if (!CheckTestingInterface())
43    return false;
44
45  if (!glInitializePPAPI(pp::Module::Get()->get_browser_interface()))
46    return false;
47
48  return true;
49}
50
51void TestCompositor::RunTests(const std::string& filter) {
52  RUN_CALLBACK_TEST(TestCompositor, Release, filter);
53  RUN_CALLBACK_TEST(TestCompositor, ReleaseWithoutCommit, filter);
54  RUN_CALLBACK_TEST(TestCompositor, CommitTwoTimesWithoutChange, filter);
55  RUN_CALLBACK_TEST(TestCompositor, General, filter);
56
57  RUN_CALLBACK_TEST(TestCompositor, ReleaseUnbound, filter);
58  RUN_CALLBACK_TEST(TestCompositor, ReleaseWithoutCommitUnbound, filter);
59  RUN_CALLBACK_TEST(TestCompositor, CommitTwoTimesWithoutChangeUnbound, filter);
60  RUN_CALLBACK_TEST(TestCompositor, GeneralUnbound, filter);
61
62  RUN_CALLBACK_TEST(TestCompositor, BindUnbind, filter);
63}
64
65std::string TestCompositor::TestRelease() {
66  return TestReleaseInternal(true);
67}
68
69std::string TestCompositor::TestReleaseWithoutCommit() {
70  return TestReleaseWithoutCommitInternal(true);
71}
72
73std::string TestCompositor::TestCommitTwoTimesWithoutChange() {
74  return TestCommitTwoTimesWithoutChangeInternal(true);
75}
76
77std::string TestCompositor::TestGeneral() {
78  return TestGeneralInternal(true);
79}
80
81std::string TestCompositor::TestReleaseUnbound() {
82  return TestReleaseInternal(false);
83}
84
85std::string TestCompositor::TestReleaseWithoutCommitUnbound() {
86  return TestReleaseWithoutCommitInternal(false);
87}
88
89std::string TestCompositor::TestCommitTwoTimesWithoutChangeUnbound() {
90  return TestCommitTwoTimesWithoutChangeInternal(false);
91}
92
93std::string TestCompositor::TestGeneralUnbound() {
94  return TestGeneralInternal(false);
95}
96
97// TODO(penghuang): refactor common part in all tests to a member function.
98std::string TestCompositor::TestBindUnbind() {
99  // Setup GLES2
100  const int32_t attribs[] = {
101    PP_GRAPHICS3DATTRIB_WIDTH, 16,
102    PP_GRAPHICS3DATTRIB_HEIGHT, 16,
103    PP_GRAPHICS3DATTRIB_NONE
104  };
105  pp::Graphics3D graphics_3d(instance_, attribs);
106  ASSERT_FALSE(graphics_3d.is_null());
107  glSetCurrentContextPPAPI(graphics_3d.pp_resource());
108
109  pp::Compositor compositor = pp::Compositor(instance_);
110  ASSERT_FALSE(compositor.is_null());
111
112  // Add layers on an unbound compositor.
113  pp::CompositorLayer color_layer = compositor.AddLayer();
114  ASSERT_FALSE(color_layer.is_null());
115
116  VERIFY(SetColorLayer(color_layer, PP_OK));
117
118  uint32_t texture = 0;
119  VERIFY(CreateTexture(&texture));
120  pp::CompositorLayer texture_layer = compositor.AddLayer();
121  ASSERT_FALSE(texture_layer.is_null());
122  TestCompletionCallback texture_release_callback(instance_->pp_instance(),
123                                                  PP_REQUIRED);
124  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
125            texture_layer.SetTexture(graphics_3d, GL_TEXTURE_2D, texture,
126                                     pp::Size(100, 100),
127                                     texture_release_callback.GetCallback()));
128
129  pp::ImageData image;
130  VERIFY(CreateImage(&image));
131  pp::CompositorLayer image_layer = compositor.AddLayer();
132  TestCompletionCallback image_release_callback(instance_->pp_instance(),
133                                                PP_REQUIRED);
134  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
135            image_layer.SetImage(image, pp::Size(100, 100),
136                                 image_release_callback.GetCallback()));
137
138  // Commit layers to the chromium compositor.
139  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
140  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
141  CHECK_CALLBACK_BEHAVIOR(callback);
142  ASSERT_EQ(PP_OK, callback.result());
143
144  // Bind the compositor and call CommitLayers() again.
145  ASSERT_TRUE(instance_->BindGraphics(compositor));
146  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
147  CHECK_CALLBACK_BEHAVIOR(callback);
148  ASSERT_EQ(PP_OK, callback.result());
149
150  // Unbind the compositor and call CommitLayers() again.
151  ASSERT_TRUE(instance_->BindGraphics(pp::Compositor()));
152  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
153  CHECK_CALLBACK_BEHAVIOR(callback);
154  ASSERT_EQ(PP_OK, callback.result());
155
156  // Reset layers and call CommitLayers() again.
157  ASSERT_EQ(PP_OK, compositor.ResetLayers());
158  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
159  CHECK_CALLBACK_BEHAVIOR(callback);
160  ASSERT_EQ(PP_OK, callback.result());
161
162  texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
163  ASSERT_EQ(PP_OK, texture_release_callback.result());
164  ReleaseTexture(texture);
165
166  image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
167  ASSERT_EQ(PP_OK, image_release_callback.result());
168
169  // Reset
170  glSetCurrentContextPPAPI(0);
171
172  PASS();
173}
174
175std::string TestCompositor::TestReleaseInternal(bool bind) {
176  // Setup GLES2
177  const int32_t attribs[] = {
178    PP_GRAPHICS3DATTRIB_WIDTH, 16,
179    PP_GRAPHICS3DATTRIB_HEIGHT, 16,
180    PP_GRAPHICS3DATTRIB_NONE
181  };
182  pp::Graphics3D graphics_3d(instance_, attribs);
183  ASSERT_FALSE(graphics_3d.is_null());
184  glSetCurrentContextPPAPI(graphics_3d.pp_resource());
185
186  pp::Compositor compositor = pp::Compositor(instance_);
187  ASSERT_FALSE(compositor.is_null());
188
189  // Bind the compositor to the instance
190  if (bind)
191    ASSERT_TRUE(instance_->BindGraphics(compositor));
192
193  pp::CompositorLayer color_layer = compositor.AddLayer();
194  ASSERT_FALSE(color_layer.is_null());
195
196  VERIFY(SetColorLayer(color_layer, PP_OK));
197
198  uint32_t texture = 0;
199  VERIFY(CreateTexture(&texture));
200  pp::CompositorLayer texture_layer = compositor.AddLayer();
201  ASSERT_FALSE(texture_layer.is_null());
202  TestCompletionCallback texture_release_callback(instance_->pp_instance(),
203                                                  PP_REQUIRED);
204  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
205            texture_layer.SetTexture(graphics_3d, GL_TEXTURE_2D, texture,
206                                     pp::Size(100, 100),
207                                     texture_release_callback.GetCallback()));
208
209  pp::ImageData image;
210  VERIFY(CreateImage(&image));
211  pp::CompositorLayer image_layer = compositor.AddLayer();
212  TestCompletionCallback image_release_callback(instance_->pp_instance(),
213                                                PP_REQUIRED);
214  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
215            image_layer.SetImage(image, pp::Size(100, 100),
216                                 image_release_callback.GetCallback()));
217
218  // Commit layers to the chromium compositor.
219  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
220  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
221  CHECK_CALLBACK_BEHAVIOR(callback);
222  ASSERT_EQ(PP_OK, callback.result());
223
224  // Release the compositor, and then release_callback will be aborted.
225  compositor = pp::Compositor();
226
227  texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
228  ASSERT_EQ(PP_ERROR_ABORTED, texture_release_callback.result());
229  ReleaseTexture(texture);
230
231  image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
232  ASSERT_EQ(PP_ERROR_ABORTED, image_release_callback.result());
233
234  // Reset
235  glSetCurrentContextPPAPI(0);
236
237  PASS();
238}
239
240std::string TestCompositor::TestReleaseWithoutCommitInternal(bool bind) {
241  // Setup GLES2
242  const int32_t attribs[] = {
243    PP_GRAPHICS3DATTRIB_WIDTH, 16,
244    PP_GRAPHICS3DATTRIB_HEIGHT, 16,
245    PP_GRAPHICS3DATTRIB_NONE
246  };
247  pp::Graphics3D graphics_3d(instance_, attribs);
248  ASSERT_FALSE(graphics_3d.is_null());
249  glSetCurrentContextPPAPI(graphics_3d.pp_resource());
250
251  pp::Compositor compositor = pp::Compositor(instance_);
252  ASSERT_FALSE(compositor.is_null());
253
254  // Bind the compositor to the instance
255  if (bind)
256    ASSERT_TRUE(instance_->BindGraphics(compositor));
257
258  pp::CompositorLayer color_layer = compositor.AddLayer();
259  ASSERT_FALSE(color_layer.is_null());
260
261  VERIFY(SetColorLayer(color_layer, PP_OK));
262
263  uint32_t texture = 0;
264  VERIFY(CreateTexture(&texture));
265  pp::CompositorLayer texture_layer = compositor.AddLayer();
266  ASSERT_FALSE(texture_layer.is_null());
267  TestCompletionCallback texture_release_callback(instance_->pp_instance(),
268                                                  PP_REQUIRED);
269  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
270            texture_layer.SetTexture(graphics_3d, GL_TEXTURE_2D, texture,
271                                     pp::Size(100, 100),
272                                     texture_release_callback.GetCallback()));
273
274  pp::ImageData image;
275  VERIFY(CreateImage(&image));
276  pp::CompositorLayer image_layer = compositor.AddLayer();
277  TestCompletionCallback image_release_callback(instance_->pp_instance(),
278                                                PP_REQUIRED);
279  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
280            image_layer.SetImage(image, pp::Size(100, 100),
281                                 image_release_callback.GetCallback()));
282
283  // Release the compositor, and then release_callback will be aborted.
284  compositor = pp::Compositor();
285
286  // All release_callbacks should be called.
287  texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
288  ASSERT_EQ(PP_ERROR_ABORTED, texture_release_callback.result());
289  ReleaseTexture(texture);
290
291  image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
292  ASSERT_EQ(PP_ERROR_ABORTED, image_release_callback.result());
293
294  // The layer associated to the compositor will become invalidated.
295  VERIFY(SetColorLayer(color_layer, PP_ERROR_BADRESOURCE));
296
297  // Reset
298  glSetCurrentContextPPAPI(0);
299
300  PASS();
301}
302
303std::string TestCompositor::TestCommitTwoTimesWithoutChangeInternal(bool bind) {
304  pp::Compositor compositor(instance_);
305  ASSERT_FALSE(compositor.is_null());
306  if (bind)
307    ASSERT_TRUE(instance_->BindGraphics(compositor));
308  pp::CompositorLayer layer = compositor.AddLayer();
309  ASSERT_FALSE(layer.is_null());
310  VERIFY(SetColorLayer(layer, PP_OK));
311
312  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
313  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
314  CHECK_CALLBACK_BEHAVIOR(callback);
315  ASSERT_EQ(PP_OK, callback.result());
316
317  // CommitLayers() without any change.
318  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
319  CHECK_CALLBACK_BEHAVIOR(callback);
320  ASSERT_EQ(PP_OK, callback.result());
321
322  PASS();
323}
324
325std::string TestCompositor::TestGeneralInternal(bool bind) {
326  // Setup GLES2
327  const int32_t attribs[] = {
328    PP_GRAPHICS3DATTRIB_WIDTH, 16,
329    PP_GRAPHICS3DATTRIB_HEIGHT, 16,
330    PP_GRAPHICS3DATTRIB_NONE
331  };
332  pp::Graphics3D graphics_3d(instance_, attribs);
333  ASSERT_FALSE(graphics_3d.is_null());
334  glSetCurrentContextPPAPI(graphics_3d.pp_resource());
335
336  // All functions should work with a bound compositor
337  pp::Compositor compositor(instance_);
338  ASSERT_FALSE(compositor.is_null());
339  if (bind)
340    ASSERT_TRUE(instance_->BindGraphics(compositor));
341
342  pp::CompositorLayer color_layer = compositor.AddLayer();
343  ASSERT_FALSE(color_layer.is_null());
344  VERIFY(SetColorLayer(color_layer, PP_OK));
345
346  uint32_t texture = 0;
347  VERIFY(CreateTexture(&texture));
348  pp::CompositorLayer texture_layer = compositor.AddLayer();
349  ASSERT_FALSE(texture_layer.is_null());
350  TestCompletionCallback texture_release_callback(instance_->pp_instance(),
351                                                  PP_REQUIRED);
352  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
353            texture_layer.SetTexture(graphics_3d, texture, GL_TEXTURE_2D,
354                                     pp::Size(100, 100),
355                                     texture_release_callback.GetCallback()));
356
357  pp::ImageData image;
358  VERIFY(CreateImage(&image));
359  pp::CompositorLayer image_layer = compositor.AddLayer();
360  TestCompletionCallback image_release_callback(instance_->pp_instance(),
361                                                PP_REQUIRED);
362  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
363            image_layer.SetImage(image, pp::Size(100, 100),
364                                 image_release_callback.GetCallback()));
365
366  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
367  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
368  CHECK_CALLBACK_BEHAVIOR(callback);
369  ASSERT_EQ(PP_OK, callback.result());
370
371  // After ResetLayers(), all layers should be invalidated.
372  ASSERT_EQ(PP_OK, compositor.ResetLayers());
373  VERIFY(SetColorLayer(color_layer, PP_ERROR_BADRESOURCE));
374
375  // Commit empty layer stack to the chromium compositor, and then the texture
376  // and the image will be released by the chromium compositor soon.
377  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
378  CHECK_CALLBACK_BEHAVIOR(callback);
379  ASSERT_EQ(PP_OK, callback.result());
380
381  texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
382  ASSERT_EQ(PP_OK, texture_release_callback.result());
383  ReleaseTexture(texture);
384
385  image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
386  ASSERT_EQ(PP_OK, image_release_callback.result());
387
388  // Reset
389  glSetCurrentContextPPAPI(0);
390
391  PASS();
392}
393
394std::string TestCompositor::CreateTexture(uint32_t* texture) {
395  glGenTextures(1, texture);
396  ASSERT_NE(0, *texture);
397  glBindTexture(GL_TEXTURE_2D, *texture);
398  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 400, 400, 0,
399               GL_RGBA, GL_UNSIGNED_BYTE, NULL);
400  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
401  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
402  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
403  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
404  glBindTexture(GL_TEXTURE_2D, 0);
405
406  return std::string();
407}
408
409std::string TestCompositor::ReleaseTexture(uint32_t texture) {
410  ASSERT_NE(0u, texture);
411  glDeleteTextures(1, &texture);
412
413  return std::string();
414}
415
416std::string TestCompositor::CreateImage(pp::ImageData* image) {
417  *image = pp::ImageData(instance_, PP_IMAGEDATAFORMAT_RGBA_PREMUL,
418                         pp::Size(400, 400), false);
419  ASSERT_FALSE(image->is_null());
420
421  return std::string();
422}
423
424std::string TestCompositor::SetColorLayer(
425    pp::CompositorLayer layer, int32_t result) {
426  ASSERT_EQ(result, layer.SetColor(255, 255, 255, 255, pp::Size(100, 100)));
427  ASSERT_EQ(result, layer.SetClipRect(pp::Rect(0, 0, 50, 50)));
428  ASSERT_EQ(result, layer.SetTransform(kMatrix));
429  ASSERT_EQ(result, layer.SetOpacity(128));
430
431  return std::string();
432}
433
434
435