// 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.empty()) \
      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);
}

// TODO(penghuang): refactor common part in all tests to a member function.
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);
  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
            texture_layer.SetTexture(graphics_3d, GL_TEXTURE_2D, 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);
  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);
  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
            texture_layer.SetTexture(graphics_3d, GL_TEXTURE_2D, 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);
  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);
  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
            texture_layer.SetTexture(graphics_3d, GL_TEXTURE_2D, 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);
  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);
  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
            texture_layer.SetTexture(graphics_3d, texture, GL_TEXTURE_2D,
                                     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);
  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();
}

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();
}