ppapi/tests/test_compositor.cc

   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
  22 namespace {
  23
  24 const 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
  33 REGISTER_TEST_CASE(Compositor);
  34
  35 #define VERIFY(r) do { \
  36     std::string result = (r); \
  37     if (!result.empty()) \
  38       return result; \
  39   } while (false)
  40
  41 bool 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
  51 void 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
  65 std::string TestCompositor::TestRelease() {
  66   return TestReleaseInternal(true);
  67 }
  68
  69 std::string TestCompositor::TestReleaseWithoutCommit() {
  70   return TestReleaseWithoutCommitInternal(true);
  71 }
  72
  73 std::string TestCompositor::TestCommitTwoTimesWithoutChange() {
  74   return TestCommitTwoTimesWithoutChangeInternal(true);
  75 }
  76
  77 std::string TestCompositor::TestGeneral() {
  78   return TestGeneralInternal(true);
  79 }
  80
  81 std::string TestCompositor::TestReleaseUnbound() {
  82   return TestReleaseInternal(false);
  83 }
  84
  85 std::string TestCompositor::TestReleaseWithoutCommitUnbound() {
  86   return TestReleaseWithoutCommitInternal(false);
  87 }
  88
  89 std::string TestCompositor::TestCommitTwoTimesWithoutChangeUnbound() {
  90   return TestCommitTwoTimesWithoutChangeInternal(false);
  91 }
  92
  93 std::string TestCompositor::TestGeneralUnbound() {
  94   return TestGeneralInternal(false);
  95 }
  96
  97 // TODO(penghuang): refactor common part in all tests to a member function.
  98 std::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
 175 std::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
 240 std::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
 303 std::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
 325 std::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
 394 std::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
 409 std::string TestCompositor::ReleaseTexture(uint32_t texture) {
 410   ASSERT_NE(0u, texture);
 411   glDeleteTextures(1, &texture);
 412
 413   return std::string();
 414 }
 415
 416 std::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
 424 std::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