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 != "") \ 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, texture, pp::Size(100, 100), 126 texture_release_callback.GetCallback())); 127 128 pp::ImageData image; 129 VERIFY(CreateImage(&image)); 130 pp::CompositorLayer image_layer = compositor.AddLayer(); 131 TestCompletionCallback image_release_callback(instance_->pp_instance(), 132 PP_REQUIRED); 133 ASSERT_EQ(PP_OK_COMPLETIONPENDING, 134 image_layer.SetImage(image, pp::Size(100, 100), 135 image_release_callback.GetCallback())); 136 137 // Commit layers to the chromium compositor. 138 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 139 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 140 CHECK_CALLBACK_BEHAVIOR(callback); 141 ASSERT_EQ(PP_OK, callback.result()); 142 143 // Bind the compositor and call CommitLayers() again. 144 ASSERT_TRUE(instance_->BindGraphics(compositor)); 145 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 146 CHECK_CALLBACK_BEHAVIOR(callback); 147 ASSERT_EQ(PP_OK, callback.result()); 148 149 // Unbind the compositor and call CommitLayers() again. 150 ASSERT_TRUE(instance_->BindGraphics(pp::Compositor())); 151 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 152 CHECK_CALLBACK_BEHAVIOR(callback); 153 ASSERT_EQ(PP_OK, callback.result()); 154 155 // Reset layers and call CommitLayers() again. 156 ASSERT_EQ(PP_OK, compositor.ResetLayers()); 157 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 158 CHECK_CALLBACK_BEHAVIOR(callback); 159 ASSERT_EQ(PP_OK, callback.result()); 160 161 texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING); 162 ASSERT_EQ(PP_OK, texture_release_callback.result()); 163 ReleaseTexture(texture); 164 165 image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING); 166 ASSERT_EQ(PP_OK, image_release_callback.result()); 167 168 // Reset 169 glSetCurrentContextPPAPI(0); 170 171 PASS(); 172 } 173 174 std::string TestCompositor::TestReleaseInternal(bool bind) { 175 // Setup GLES2 176 const int32_t attribs[] = { 177 PP_GRAPHICS3DATTRIB_WIDTH, 16, 178 PP_GRAPHICS3DATTRIB_HEIGHT, 16, 179 PP_GRAPHICS3DATTRIB_NONE 180 }; 181 pp::Graphics3D graphics_3d(instance_, attribs); 182 ASSERT_FALSE(graphics_3d.is_null()); 183 glSetCurrentContextPPAPI(graphics_3d.pp_resource()); 184 185 pp::Compositor compositor = pp::Compositor(instance_); 186 ASSERT_FALSE(compositor.is_null()); 187 188 // Bind the compositor to the instance 189 if (bind) 190 ASSERT_TRUE(instance_->BindGraphics(compositor)); 191 192 pp::CompositorLayer color_layer = compositor.AddLayer(); 193 ASSERT_FALSE(color_layer.is_null()); 194 195 VERIFY(SetColorLayer(color_layer, PP_OK)); 196 197 uint32_t texture = 0; 198 VERIFY(CreateTexture(&texture)); 199 pp::CompositorLayer texture_layer = compositor.AddLayer(); 200 ASSERT_FALSE(texture_layer.is_null()); 201 TestCompletionCallback texture_release_callback(instance_->pp_instance(), 202 PP_REQUIRED); 203 ASSERT_EQ(PP_OK_COMPLETIONPENDING, 204 texture_layer.SetTexture(graphics_3d, texture, pp::Size(100, 100), 205 texture_release_callback.GetCallback())); 206 207 pp::ImageData image; 208 VERIFY(CreateImage(&image)); 209 pp::CompositorLayer image_layer = compositor.AddLayer(); 210 TestCompletionCallback image_release_callback(instance_->pp_instance(), 211 PP_REQUIRED); 212 ASSERT_EQ(PP_OK_COMPLETIONPENDING, 213 image_layer.SetImage(image, pp::Size(100, 100), 214 image_release_callback.GetCallback())); 215 216 // Commit layers to the chromium compositor. 217 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 218 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 219 CHECK_CALLBACK_BEHAVIOR(callback); 220 ASSERT_EQ(PP_OK, callback.result()); 221 222 // Release the compositor, and then release_callback will be aborted. 223 compositor = pp::Compositor(); 224 225 texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING); 226 ASSERT_EQ(PP_ERROR_ABORTED, texture_release_callback.result()); 227 ReleaseTexture(texture); 228 229 image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING); 230 ASSERT_EQ(PP_ERROR_ABORTED, image_release_callback.result()); 231 232 // Reset 233 glSetCurrentContextPPAPI(0); 234 235 PASS(); 236 } 237 238 std::string TestCompositor::TestReleaseWithoutCommitInternal(bool bind) { 239 // Setup GLES2 240 const int32_t attribs[] = { 241 PP_GRAPHICS3DATTRIB_WIDTH, 16, 242 PP_GRAPHICS3DATTRIB_HEIGHT, 16, 243 PP_GRAPHICS3DATTRIB_NONE 244 }; 245 pp::Graphics3D graphics_3d(instance_, attribs); 246 ASSERT_FALSE(graphics_3d.is_null()); 247 glSetCurrentContextPPAPI(graphics_3d.pp_resource()); 248 249 pp::Compositor compositor = pp::Compositor(instance_); 250 ASSERT_FALSE(compositor.is_null()); 251 252 // Bind the compositor to the instance 253 if (bind) 254 ASSERT_TRUE(instance_->BindGraphics(compositor)); 255 256 pp::CompositorLayer color_layer = compositor.AddLayer(); 257 ASSERT_FALSE(color_layer.is_null()); 258 259 VERIFY(SetColorLayer(color_layer, PP_OK)); 260 261 uint32_t texture = 0; 262 VERIFY(CreateTexture(&texture)); 263 pp::CompositorLayer texture_layer = compositor.AddLayer(); 264 ASSERT_FALSE(texture_layer.is_null()); 265 TestCompletionCallback texture_release_callback(instance_->pp_instance(), 266 PP_REQUIRED); 267 ASSERT_EQ(PP_OK_COMPLETIONPENDING, 268 texture_layer.SetTexture(graphics_3d, texture, pp::Size(100, 100), 269 texture_release_callback.GetCallback())); 270 271 pp::ImageData image; 272 VERIFY(CreateImage(&image)); 273 pp::CompositorLayer image_layer = compositor.AddLayer(); 274 TestCompletionCallback image_release_callback(instance_->pp_instance(), 275 PP_REQUIRED); 276 ASSERT_EQ(PP_OK_COMPLETIONPENDING, 277 image_layer.SetImage(image, pp::Size(100, 100), 278 image_release_callback.GetCallback())); 279 280 // Release the compositor, and then release_callback will be aborted. 281 compositor = pp::Compositor(); 282 283 // All release_callbacks should be called. 284 texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING); 285 ASSERT_EQ(PP_ERROR_ABORTED, texture_release_callback.result()); 286 ReleaseTexture(texture); 287 288 image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING); 289 ASSERT_EQ(PP_ERROR_ABORTED, image_release_callback.result()); 290 291 // The layer associated to the compositor will become invalidated. 292 VERIFY(SetColorLayer(color_layer, PP_ERROR_BADRESOURCE)); 293 294 // Reset 295 glSetCurrentContextPPAPI(0); 296 297 PASS(); 298 } 299 300 std::string TestCompositor::TestCommitTwoTimesWithoutChangeInternal(bool bind) { 301 pp::Compositor compositor(instance_); 302 ASSERT_FALSE(compositor.is_null()); 303 if (bind) 304 ASSERT_TRUE(instance_->BindGraphics(compositor)); 305 pp::CompositorLayer layer = compositor.AddLayer(); 306 ASSERT_FALSE(layer.is_null()); 307 VERIFY(SetColorLayer(layer, PP_OK)); 308 309 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 310 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 311 CHECK_CALLBACK_BEHAVIOR(callback); 312 ASSERT_EQ(PP_OK, callback.result()); 313 314 // CommitLayers() without any change. 315 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 316 CHECK_CALLBACK_BEHAVIOR(callback); 317 ASSERT_EQ(PP_OK, callback.result()); 318 319 PASS(); 320 } 321 322 std::string TestCompositor::TestGeneralInternal(bool bind) { 323 // Setup GLES2 324 const int32_t attribs[] = { 325 PP_GRAPHICS3DATTRIB_WIDTH, 16, 326 PP_GRAPHICS3DATTRIB_HEIGHT, 16, 327 PP_GRAPHICS3DATTRIB_NONE 328 }; 329 pp::Graphics3D graphics_3d(instance_, attribs); 330 ASSERT_FALSE(graphics_3d.is_null()); 331 glSetCurrentContextPPAPI(graphics_3d.pp_resource()); 332 333 // All functions should work with a bound compositor 334 pp::Compositor compositor(instance_); 335 ASSERT_FALSE(compositor.is_null()); 336 if (bind) 337 ASSERT_TRUE(instance_->BindGraphics(compositor)); 338 339 pp::CompositorLayer color_layer = compositor.AddLayer(); 340 ASSERT_FALSE(color_layer.is_null()); 341 VERIFY(SetColorLayer(color_layer, PP_OK)); 342 343 uint32_t texture = 0; 344 VERIFY(CreateTexture(&texture)); 345 pp::CompositorLayer texture_layer = compositor.AddLayer(); 346 ASSERT_FALSE(texture_layer.is_null()); 347 TestCompletionCallback texture_release_callback(instance_->pp_instance(), 348 PP_REQUIRED); 349 ASSERT_EQ(PP_OK_COMPLETIONPENDING, 350 texture_layer.SetTexture(graphics_3d, texture, pp::Size(100, 100), 351 texture_release_callback.GetCallback())); 352 353 pp::ImageData image; 354 VERIFY(CreateImage(&image)); 355 pp::CompositorLayer image_layer = compositor.AddLayer(); 356 TestCompletionCallback image_release_callback(instance_->pp_instance(), 357 PP_REQUIRED); 358 ASSERT_EQ(PP_OK_COMPLETIONPENDING, 359 image_layer.SetImage(image, pp::Size(100, 100), 360 image_release_callback.GetCallback())); 361 362 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 363 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 364 CHECK_CALLBACK_BEHAVIOR(callback); 365 ASSERT_EQ(PP_OK, callback.result()); 366 367 // After ResetLayers(), all layers should be invalidated. 368 ASSERT_EQ(PP_OK, compositor.ResetLayers()); 369 VERIFY(SetColorLayer(color_layer, PP_ERROR_BADRESOURCE)); 370 371 // Commit empty layer stack to the chromium compositor, and then the texture 372 // and the image will be released by the chromium compositor soon. 373 callback.WaitForResult(compositor.CommitLayers(callback.GetCallback())); 374 CHECK_CALLBACK_BEHAVIOR(callback); 375 ASSERT_EQ(PP_OK, callback.result()); 376 377 texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING); 378 ASSERT_EQ(PP_OK, texture_release_callback.result()); 379 ReleaseTexture(texture); 380 381 image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING); 382 ASSERT_EQ(PP_OK, image_release_callback.result()); 383 384 // Reset 385 glSetCurrentContextPPAPI(0); 386 387 PASS(); 388 } 389 390 std::string TestCompositor::CreateTexture(uint32_t* texture) { 391 glGenTextures(1, texture); 392 ASSERT_NE(0, *texture); 393 glBindTexture(GL_TEXTURE_2D, *texture); 394 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 400, 400, 0, 395 GL_RGBA, GL_UNSIGNED_BYTE, NULL); 396 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 397 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 398 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 399 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 400 glBindTexture(GL_TEXTURE_2D, 0); 401 402 return std::string(); 403 } 404 405 std::string TestCompositor::ReleaseTexture(uint32_t texture) { 406 ASSERT_NE(0u, texture); 407 glDeleteTextures(1, &texture); 408 409 return std::string(); 410 } 411 412 std::string TestCompositor::CreateImage(pp::ImageData* image) { 413 *image = pp::ImageData(instance_, PP_IMAGEDATAFORMAT_RGBA_PREMUL, 414 pp::Size(400, 400), false); 415 ASSERT_FALSE(image->is_null()); 416 417 return std::string(); 418 } 419 420 std::string TestCompositor::SetColorLayer( 421 pp::CompositorLayer layer, int32_t result) { 422 ASSERT_EQ(result, layer.SetColor(255, 255, 255, 255, pp::Size(100, 100))); 423 ASSERT_EQ(result, layer.SetClipRect(pp::Rect(0, 0, 50, 50))); 424 ASSERT_EQ(result, layer.SetTransform(kMatrix)); 425 ASSERT_EQ(result, layer.SetOpacity(128)); 426 427 return std::string(); 428 } 429 430 431
