[PPAPI] Add browser tests for compositor API

ppapi/examples/compositor/compositor.cc

 // Copyright 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.
 
 // Needed on Windows to get |M_PI| from math.h.
 #ifdef _WIN32
 #define _USE_MATH_DEFINES
 #endif
 
 #include <math.h>
@@ skipping 54 matching lines @@
   virtual bool HandleInputEvent(const pp::InputEvent& event);
 
   // pp::Graphics3DClient implementation.
   virtual void Graphics3DContextLost();
 
  private:
   // GL-related functions.
   void InitGL(int32_t result);
   GLuint PrepareFramebuffer();
   pp::ImageData PrepareImage();
+  void PrepareLayers(int32_t frame);
   void Paint(int32_t result, int32_t frame);
   void OnTextureReleased(int32_t result, GLuint texture);
   void OnImageReleased(int32_t result, const pp::ImageData& image);
 
   pp::CompletionCallbackFactory<DemoInstance> callback_factory_;
 
   // Owned data.
   pp::Graphics3D* context_;
 
   GLuint fbo_;
@@ skipping 14 matching lines @@
   SpinningCube* cube_;
 };
 
 DemoInstance::DemoInstance(PP_Instance instance)
     : pp::Instance(instance),
       pp::Graphics3DClient(this),
       callback_factory_(this),
       context_(NULL),
       fbo_(0),
       rbo_(0),
-      compositor_(this),
-      rebuild_layers_(false),
+      rebuild_layers_(true),
       total_resource_(0),
       cube_(new SpinningCube()) {
   RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
 }
 
 DemoInstance::~DemoInstance() {
   delete cube_;
   assert(glTerminatePPAPI());
   delete context_;
 }
@@ skipping 19 matching lines @@
       return true;
     default:
       break;
   }
   return false;
 }
 
 void DemoInstance::Graphics3DContextLost() {
   fbo_ = 0;
   rbo_ = 0;
-  compositor_.ResetLayers();
-  color_layer_ = pp::CompositorLayer();
-  stable_texture_layer_ = pp::CompositorLayer();
-  texture_layer_ = pp::CompositorLayer();
-  image_layer_ = pp::CompositorLayer();
+  rebuild_layers_ = true;
   total_resource_ -= static_cast<int32_t>(textures_.size());
   textures_.clear();
   delete context_;
   context_ = NULL;
   cube_->OnGLContextLost();
   pp::CompletionCallback cb = callback_factory_.NewCallback(
       &DemoInstance::InitGL);
   pp::Module::Get()->core()->CallOnMainThread(0, cb, 0);
 }
 
@@ skipping 88 matching lines @@
                          pp::Size(kImageWidth, kImageHeight),
                          false);
   }
   pp::ImageData image = images_.back();
   images_.pop_back();
   return image;
 }
 
 void DemoInstance::Paint(int32_t result, int32_t frame) {
   assert(result == PP_OK);
-
   if (result != PP_OK || !context_)
     return;
 
-  int32_t rv;
-
   if (rebuild_layers_) {
-    compositor_.ResetLayers();
+    compositor_ = pp::Compositor(this);
+    assert(BindGraphics(compositor_));
     color_layer_ = pp::CompositorLayer();
     stable_texture_layer_ = pp::CompositorLayer();
     texture_layer_ = pp::CompositorLayer();
     image_layer_ = pp::CompositorLayer();
     frame = 0;
     rebuild_layers_ = false;
   }
 
+  PrepareLayers(frame);
+
+  int32_t rv = compositor_.CommitLayers(
+      callback_factory_.NewCallback(&DemoInstance::Paint, ++frame));
+  assert(rv == PP_OK_COMPLETIONPENDING);
+
+  pp::VarDictionary dict;
+  dict.Set("total_resource", total_resource_);
+  size_t free_resource = textures_.size() + images_.size();
+  dict.Set("free_resource", static_cast<int32_t>(free_resource));
+  PostMessage(dict);
+}
+
+void DemoInstance::PrepareLayers(int32_t frame) {
+  int32_t rv;
   float factor_sin = sin(M_PI / 180 * frame);
   float factor_cos = cos(M_PI / 180 * frame);
   {
     // Set the background color layer.
     if (color_layer_.is_null()) {
       color_layer_ = compositor_.AddLayer();
       assert(!color_layer_.is_null());
       static const float transform[16] = {
         1.0f, 0.0f, 0.0f, 0.0f,
         0.0f, 1.0f, 0.0f, 0.0f,
@@ skipping 99 matching lines @@
     GLuint texture = PrepareFramebuffer();
     cube_->UpdateForTimeDelta(0.02f);
     cube_->Draw();
     rv = texture_layer_.SetTexture(*context_, texture, pp::Size(400, 400),
         callback_factory_.NewCallback(&DemoInstance::OnTextureReleased,
                                       texture));
     assert(rv == PP_OK_COMPLETIONPENDING);
     rv = texture_layer_.SetPremultipliedAlpha(PP_FALSE);
     assert(rv == PP_OK);
   }
-
-  rv = compositor_.CommitLayers(
-      callback_factory_.NewCallback(&DemoInstance::Paint, ++frame));
-  assert(rv == PP_OK_COMPLETIONPENDING);
-
-  pp::VarDictionary dict;
-  dict.Set(pp::Var("total_resource"), pp::Var(total_resource_));
-  dict.Set(pp::Var("free_resource"),
-      pp::Var((int32_t)(textures_.size() + images_.size())));
-  PostMessage(dict);
 }
 
 void DemoInstance::OnTextureReleased(int32_t result, GLuint texture) {
-  if (result == PP_OK)
+  if (result == PP_OK) {
     textures_.push_back(texture);
+  } else {
+    glDeleteTextures(1, &texture);
+    total_resource_--;
+  }
 }
 
 void DemoInstance::OnImageReleased(int32_t result, const pp::ImageData& image) {
-  if (result == PP_OK)
+  if (result == PP_OK) {
     images_.push_back(image);
+  } else {
+    total_resource_--;
+  }
 }
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class DemoModule : public pp::Module {
  public:
   DemoModule() : Module() {}
   virtual ~DemoModule() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new DemoInstance(instance);
   }
 };
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new DemoModule();
 }
 }  // namespace pp