[PPAPI] Add browser tests for compositor API

ppapi/tests/test_compositor.cc

Index: ppapi/tests/test_compositor.cc
diff --git a/ppapi/tests/test_compositor.cc b/ppapi/tests/test_compositor.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d5f5366d10a4994c92a5fd196626d12ae0c7d465
--- /dev/null
+++ b/ppapi/tests/test_compositor.cc
@@ -0,0 +1,429 @@
+// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ppapi/tests/test_compositor.h"
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ppapi/c/ppb_opengles2.h"
+#include "ppapi/cpp/compositor.h"
+#include "ppapi/cpp/compositor_layer.h"
+#include "ppapi/cpp/image_data.h"
+#include "ppapi/lib/gl/gles2/gl2ext_ppapi.h"
+#include "ppapi/lib/gl/include/GLES2/gl2.h"
+#include "ppapi/lib/gl/include/GLES2/gl2ext.h"
+#include "ppapi/tests/test_utils.h"
+
+namespace {
+
+const float kMatrix[16] = {
+  1.0f, 0.0f, 0.0f, 0.0f,
+  0.0f, 1.0f, 0.0f, 0.0f,
+  0.0f, 0.0f, 1.0f, 0.0f,
+  0.0f, 0.0f, 0.0f, 1.0f,
+};
+
+}  // namespace
+
+REGISTER_TEST_CASE(Compositor);
+
+#define VERIFY(r) do { \
+    std::string result = (r); \
+    if (result != "") \
+      return result; \
+  } while (false)
+
+bool TestCompositor::Init() {
+  if (!CheckTestingInterface())
+    return false;
+
+  if (!glInitializePPAPI(pp::Module::Get()->get_browser_interface()))
+    return false;
+
+  return true;
+}
+
+void TestCompositor::RunTests(const std::string& filter) {
+  RUN_CALLBACK_TEST(TestCompositor, Release, filter);
+  RUN_CALLBACK_TEST(TestCompositor, ReleaseWithoutCommit, filter);
+  RUN_CALLBACK_TEST(TestCompositor, CommitTwoTimesWithoutChange, filter);
+  RUN_CALLBACK_TEST(TestCompositor, General, filter);
+
+  RUN_CALLBACK_TEST(TestCompositor, ReleaseUnbound, filter);
+  RUN_CALLBACK_TEST(TestCompositor, ReleaseWithoutCommitUnbound, filter);
+  RUN_CALLBACK_TEST(TestCompositor, CommitTwoTimesWithoutChangeUnbound, filter);
+  RUN_CALLBACK_TEST(TestCompositor, GeneralUnbound, filter);
+
+  RUN_CALLBACK_TEST(TestCompositor, BindUnbind, filter);
+}
+
+std::string TestCompositor::TestRelease() {
+  return TestReleaseInternal(true);
+}
+
+std::string TestCompositor::TestReleaseWithoutCommit() {
+  return TestReleaseWithoutCommitInternal(true);
+}
+
+std::string TestCompositor::TestCommitTwoTimesWithoutChange() {
+  return TestCommitTwoTimesWithoutChangeInternal(true);
+}
+
+std::string TestCompositor::TestGeneral() {
+  return TestGeneralInternal(true);
+}
+
+std::string TestCompositor::TestReleaseUnbound() {
+  return TestReleaseInternal(false);
+}
+
+std::string TestCompositor::TestReleaseWithoutCommitUnbound() {
+  return TestReleaseWithoutCommitInternal(false);
+}
+
+std::string TestCompositor::TestCommitTwoTimesWithoutChangeUnbound() {
+  return TestCommitTwoTimesWithoutChangeInternal(false);
+}
+
+std::string TestCompositor::TestGeneralUnbound() {
+  return TestGeneralInternal(false);
+}
+
+std::string TestCompositor::TestBindUnbind() {
+  // Setup GLES2
+  const int32_t attribs[] = {
+    PP_GRAPHICS3DATTRIB_WIDTH, 16,
+    PP_GRAPHICS3DATTRIB_HEIGHT, 16,
+    PP_GRAPHICS3DATTRIB_NONE
+  };
+  pp::Graphics3D graphics_3d(instance_, attribs);
+  ASSERT_FALSE(graphics_3d.is_null());
+  glSetCurrentContextPPAPI(graphics_3d.pp_resource());
+
+  pp::Compositor compositor = pp::Compositor(instance_);
+  ASSERT_FALSE(compositor.is_null());
+
+  // Add layers on an unbound compositor.
+  pp::CompositorLayer color_layer = compositor.AddLayer();
+  ASSERT_FALSE(color_layer.is_null());
+
+  VERIFY(SetColorLayer(color_layer, PP_OK));
+
+  uint32_t texture = 0;
+  VERIFY(CreateTexture(&texture));
+  pp::CompositorLayer texture_layer = compositor.AddLayer();
+  ASSERT_FALSE(texture_layer.is_null());
+  TestCompletionCallback texture_release_callback(instance_->pp_instance(),
+                                          PP_REQUIRED);

[raymes, 2014/06/20 02:57:20]

nit:indentation

[Peng, 2014/06/20 03:18:00]

Done.

+  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
+            texture_layer.SetTexture(graphics_3d, texture, pp::Size(100, 100),
+                                     texture_release_callback.GetCallback()));
+
+  pp::ImageData image;
+  VERIFY(CreateImage(&image));
+  pp::CompositorLayer image_layer = compositor.AddLayer();
+  TestCompletionCallback image_release_callback(instance_->pp_instance(),
+                                          PP_REQUIRED);

[raymes, 2014/06/20 02:57:20]

nit:indentation

[Peng, 2014/06/20 03:18:00]

Done.

+  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
+            image_layer.SetImage(image, pp::Size(100, 100),
+                                 image_release_callback.GetCallback()));
+
+  // Commit layers to the chromium compositor.
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  // Bind the compositor and call CommitLayers() again.
+  ASSERT_TRUE(instance_->BindGraphics(compositor));
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  // Unbind the compositor and call CommitLayers() again.
+  ASSERT_TRUE(instance_->BindGraphics(pp::Compositor()));
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  // Reset layers and call CommitLayers() again.
+  ASSERT_EQ(PP_OK, compositor.ResetLayers());
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(PP_OK, texture_release_callback.result());
+  ReleaseTexture(texture);
+
+  image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(PP_OK, image_release_callback.result());
+
+  // Reset
+  glSetCurrentContextPPAPI(0);
+
+  PASS();
+}
+
+std::string TestCompositor::TestReleaseInternal(bool bind) {
+  // Setup GLES2
+  const int32_t attribs[] = {
+    PP_GRAPHICS3DATTRIB_WIDTH, 16,
+    PP_GRAPHICS3DATTRIB_HEIGHT, 16,
+    PP_GRAPHICS3DATTRIB_NONE
+  };
+  pp::Graphics3D graphics_3d(instance_, attribs);
+  ASSERT_FALSE(graphics_3d.is_null());
+  glSetCurrentContextPPAPI(graphics_3d.pp_resource());
+
+  pp::Compositor compositor = pp::Compositor(instance_);
+  ASSERT_FALSE(compositor.is_null());
+
+  // Bind the compositor to the instance
+  if (bind)
+    ASSERT_TRUE(instance_->BindGraphics(compositor));
+
+  pp::CompositorLayer color_layer = compositor.AddLayer();
+  ASSERT_FALSE(color_layer.is_null());
+
+  VERIFY(SetColorLayer(color_layer, PP_OK));
+
+  uint32_t texture = 0;
+  VERIFY(CreateTexture(&texture));
+  pp::CompositorLayer texture_layer = compositor.AddLayer();
+  ASSERT_FALSE(texture_layer.is_null());
+  TestCompletionCallback texture_release_callback(instance_->pp_instance(),
+                                          PP_REQUIRED);

[raymes, 2014/06/20 02:57:20]

nit:indentation

[Peng, 2014/06/20 03:18:00]

Done.

+  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
+            texture_layer.SetTexture(graphics_3d, texture, pp::Size(100, 100),
+                                     texture_release_callback.GetCallback()));
+
+  pp::ImageData image;
+  VERIFY(CreateImage(&image));
+  pp::CompositorLayer image_layer = compositor.AddLayer();
+  TestCompletionCallback image_release_callback(instance_->pp_instance(),
+                                          PP_REQUIRED);

[raymes, 2014/06/20 02:57:20]

nit:indentation

[Peng, 2014/06/20 03:17:59]

Done.

+  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
+            image_layer.SetImage(image, pp::Size(100, 100),
+                                 image_release_callback.GetCallback()));
+
+  // Commit layers to the chromium compositor.
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  // Release the compositor, and then release_callback will be aborted.
+  compositor = pp::Compositor();
+
+  texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(PP_ERROR_ABORTED, texture_release_callback.result());
+  ReleaseTexture(texture);
+
+  image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(PP_ERROR_ABORTED, image_release_callback.result());
+
+  // Reset
+  glSetCurrentContextPPAPI(0);
+
+  PASS();
+}
+
+std::string TestCompositor::TestReleaseWithoutCommitInternal(bool bind) {
+  // Setup GLES2
+  const int32_t attribs[] = {
+    PP_GRAPHICS3DATTRIB_WIDTH, 16,
+    PP_GRAPHICS3DATTRIB_HEIGHT, 16,
+    PP_GRAPHICS3DATTRIB_NONE
+  };
+  pp::Graphics3D graphics_3d(instance_, attribs);
+  ASSERT_FALSE(graphics_3d.is_null());
+  glSetCurrentContextPPAPI(graphics_3d.pp_resource());
+
+  pp::Compositor compositor = pp::Compositor(instance_);
+  ASSERT_FALSE(compositor.is_null());
+
+  // Bind the compositor to the instance
+  if (bind)
+    ASSERT_TRUE(instance_->BindGraphics(compositor));
+
+  pp::CompositorLayer color_layer = compositor.AddLayer();
+  ASSERT_FALSE(color_layer.is_null());
+
+  VERIFY(SetColorLayer(color_layer, PP_OK));
+
+  uint32_t texture = 0;
+  VERIFY(CreateTexture(&texture));
+  pp::CompositorLayer texture_layer = compositor.AddLayer();
+  ASSERT_FALSE(texture_layer.is_null());
+  TestCompletionCallback texture_release_callback(instance_->pp_instance(),
+                                          PP_REQUIRED);

[raymes, 2014/06/20 02:57:20]

nit:indentation

[Peng, 2014/06/20 03:18:00]

Done.

+  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
+            texture_layer.SetTexture(graphics_3d, texture, pp::Size(100, 100),
+                                     texture_release_callback.GetCallback()));
+
+  pp::ImageData image;
+  VERIFY(CreateImage(&image));
+  pp::CompositorLayer image_layer = compositor.AddLayer();
+  TestCompletionCallback image_release_callback(instance_->pp_instance(),
+                                          PP_REQUIRED);

[raymes, 2014/06/20 02:57:20]

nit:indentation

[Peng, 2014/06/20 03:17:59]

Done.

+  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
+            image_layer.SetImage(image, pp::Size(100, 100),
+                                 image_release_callback.GetCallback()));
+
+  // Release the compositor, and then release_callback will be aborted.
+  compositor = pp::Compositor();
+
+  // All release_callbacks should be called.
+  texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(PP_ERROR_ABORTED, texture_release_callback.result());
+  ReleaseTexture(texture);
+
+  image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(PP_ERROR_ABORTED, image_release_callback.result());
+
+  // The layer associated to the compositor will become invalidated.
+  VERIFY(SetColorLayer(color_layer, PP_ERROR_BADRESOURCE));
+
+  // Reset
+  glSetCurrentContextPPAPI(0);
+
+  PASS();
+}
+
+std::string TestCompositor::TestCommitTwoTimesWithoutChangeInternal(bool bind) {
+  pp::Compositor compositor(instance_);
+  ASSERT_FALSE(compositor.is_null());
+  if (bind)
+    ASSERT_TRUE(instance_->BindGraphics(compositor));
+  pp::CompositorLayer layer = compositor.AddLayer();
+  ASSERT_FALSE(layer.is_null());
+  VERIFY(SetColorLayer(layer, PP_OK));
+
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  // CommitLayers() without any change.
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  PASS();
+}
+
+std::string TestCompositor::TestGeneralInternal(bool bind) {
+  // Setup GLES2
+  const int32_t attribs[] = {
+    PP_GRAPHICS3DATTRIB_WIDTH, 16,
+    PP_GRAPHICS3DATTRIB_HEIGHT, 16,
+    PP_GRAPHICS3DATTRIB_NONE
+  };
+  pp::Graphics3D graphics_3d(instance_, attribs);
+  ASSERT_FALSE(graphics_3d.is_null());
+  glSetCurrentContextPPAPI(graphics_3d.pp_resource());
+
+  // All functions should work with a bound compositor
+  pp::Compositor compositor(instance_);
+  ASSERT_FALSE(compositor.is_null());
+  if (bind)
+    ASSERT_TRUE(instance_->BindGraphics(compositor));
+
+  pp::CompositorLayer color_layer = compositor.AddLayer();
+  ASSERT_FALSE(color_layer.is_null());
+  VERIFY(SetColorLayer(color_layer, PP_OK));
+
+  uint32_t texture = 0;
+  VERIFY(CreateTexture(&texture));
+  pp::CompositorLayer texture_layer = compositor.AddLayer();
+  ASSERT_FALSE(texture_layer.is_null());
+  TestCompletionCallback texture_release_callback(instance_->pp_instance(),
+                                          PP_REQUIRED);

[raymes, 2014/06/20 02:57:20]

nit:indentation

[Peng, 2014/06/20 03:18:00]

Done.

+  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
+            texture_layer.SetTexture(graphics_3d, texture, pp::Size(100, 100),
+                                     texture_release_callback.GetCallback()));
+
+  pp::ImageData image;
+  VERIFY(CreateImage(&image));
+  pp::CompositorLayer image_layer = compositor.AddLayer();
+  TestCompletionCallback image_release_callback(instance_->pp_instance(),
+                                          PP_REQUIRED);

[raymes, 2014/06/20 02:57:20]

nit:indentation

[Peng, 2014/06/20 03:18:00]

Done.

+  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
+            image_layer.SetImage(image, pp::Size(100, 100),
+                                 image_release_callback.GetCallback()));
+
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  // After ResetLayers(), all layers should be invalidated.
+  ASSERT_EQ(PP_OK, compositor.ResetLayers());
+  VERIFY(SetColorLayer(color_layer, PP_ERROR_BADRESOURCE));
+
+  // Commit empty layer stack to the chromium compositor, and then the texture
+  // and the image will be released by the chromium compositor soon.
+  callback.WaitForResult(compositor.CommitLayers(callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  texture_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(PP_OK, texture_release_callback.result());
+  ReleaseTexture(texture);
+
+  image_release_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(PP_OK, image_release_callback.result());
+
+  // Reset
+  glSetCurrentContextPPAPI(0);
+
+  PASS();

[raymes, 2014/06/20 02:57:20]

Most of the code up to and including comitting the layers to the compositor is
setup code and is almost identical across TestGeneralInternal,
TestReleaseWithoutCommitInternal, TestReleaseInternal and TestBindUnbind. Can we
factor that code into a separate function or class?

[Peng, 2014/06/20 03:18:00]

Yes. The code of those testes are similar. There are just slight different. If
we factor common code into a separate function, we need pass in and out many
arguments. :( It looks not good.

Probably the best way is to have a super class for all tests, and use member
variables to store all callbacks, texture, image, and share them between
methods.

Since it is just for testing, I think it is not necessary to make the code
perfect. Especially the branch day is very close. :( This CL includes some fixes
and logic change. I think it is better to have them in M37.

WDYT?  

+}
+
+std::string TestCompositor::CreateTexture(uint32_t* texture) {
+  glGenTextures(1, texture);
+  ASSERT_NE(0, *texture);
+  glBindTexture(GL_TEXTURE_2D, *texture);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 400, 400, 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  return std::string();
+}
+
+std::string TestCompositor::ReleaseTexture(uint32_t texture) {
+  ASSERT_NE(0u, texture);
+  glDeleteTextures(1, &texture);
+
+  return std::string();
+}
+
+std::string TestCompositor::CreateImage(pp::ImageData* image) {
+  *image = pp::ImageData(instance_, PP_IMAGEDATAFORMAT_RGBA_PREMUL,
+                         pp::Size(400, 400), false);
+  ASSERT_FALSE(image->is_null());
+
+  return std::string();
+}
+
+std::string TestCompositor::SetColorLayer(
+    pp::CompositorLayer layer, int32_t result) {
+  ASSERT_EQ(result, layer.SetColor(255, 255, 255, 255, pp::Size(100, 100)));
+  ASSERT_EQ(result, layer.SetClipRect(pp::Rect(0, 0, 50, 50)));
+  ASSERT_EQ(result, layer.SetTransform(kMatrix));
+  ASSERT_EQ(result, layer.SetOpacity(128));
+
+  return std::string();
+}
+
+