[PPAPI] Add browser tests for compositor API

ppapi/proxy/compositor_layer_resource.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.
 
 #include "ppapi/proxy/compositor_layer_resource.h"
 
 #include "base/logging.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "ppapi/proxy/compositor_resource.h"
@@ skipping 27 matching lines @@
  private:
   GLES2Implementation* gl_;
   int32_t old_id_;
 };
 
 float clamp(float value) {
   return std::min(std::max(value, 0.0f), 1.0f);
 }
 
 void OnTextureReleased(
+    const scoped_refptr<CompositorResource> compositor,
     const ScopedPPResource& layer,
     const ScopedPPResource& context,
     uint32_t texture,
     const scoped_refptr<TrackedCallback>& release_callback,
     uint32_t sync_point,
     bool is_lost) {
   if (!TrackedCallback::IsPending(release_callback))
     return;
 
   do {
     if (!sync_point)
       break;
 
     EnterResourceNoLock<PPB_Graphics3D_API> enter(context.get(), true);
     if (enter.failed())
       break;
 
     PPB_Graphics3D_Shared* graphics =
         static_cast<PPB_Graphics3D_Shared*>(enter.object());
 
     GLES2Implementation* gl = graphics->gles2_impl();
     gl->WaitSyncPointCHROMIUM(sync_point);
   } while (false);
 
   release_callback->Run(is_lost ? PP_ERROR_FAILED : PP_OK);
 }
 
 void OnImageReleased(
+    const scoped_refptr<CompositorResource> compositor,
     const ScopedPPResource& layer,
     const ScopedPPResource& image,
     const scoped_refptr<TrackedCallback>& release_callback,
     uint32_t sync_point,
     bool is_lost) {
   if (!TrackedCallback::IsPending(release_callback))
     return;
   release_callback->Run(PP_OK);
 }
 
 }  // namespace
 
 CompositorLayerResource::CompositorLayerResource(
     Connection connection,
     PP_Instance instance,
-    const CompositorResource* compositor)
+    scoped_refptr<CompositorResource> compositor)
     : PluginResource(connection, instance),
       compositor_(compositor),
       source_size_(PP_MakeFloatSize(0.0f, 0.0f)) {
 }
 
 CompositorLayerResource::~CompositorLayerResource() {
   DCHECK(!compositor_);
   DCHECK(release_callback_.is_null());
 }
 
 thunk::PPB_CompositorLayer_API*
 CompositorLayerResource::AsPPB_CompositorLayer_API() {
   return this;
 }
 
 int32_t CompositorLayerResource::SetColor(float red,
                                           float green,
                                           float blue,
                                           float alpha,
                                           const PP_Size* size) {
   if (!compositor_)
     return PP_ERROR_BADRESOURCE;
 
+  CHECK(compositor_->bound_to_instance());

[piman, 2014/06/18 00:55:24]

no CHECK. Use DCHECK.

I don't think this DCHECK is valid - why can't you set the color before the
compositor is bound to the instance?

[Peng, 2014/06/18 02:35:03]

If we allow an unbound compositor to have valid layers, it will cause another
issue. For example:
If a bound compositor has several committed layers, and then it is detached from
the instance. all textures will be released by the chromium compositor, and then
the release callbacks in the plugin will be called. and then those textures will
be reused by the plugin.

After that, if the plugin does not change layers of the compositor, and bind the
compositor to the instance again, what should we do? Should we rebuild
cc::Layers in renderer? But all textures may have been released.

So to make the thing easier, I decided to not allow unbound compositor to  have
valid layers. So compositor_->bound_to_instance() must be true here. WDYT?

[piman, 2014/06/18 20:30:55]

This should not happen. TextureLayer keeps a reference to the texture so that
you can move the layer between trees without releasing the texture.

+
   if (compositor_->IsInProgress())
     return PP_ERROR_INPROGRESS;
 
   if (!SetType(TYPE_COLOR))
     return PP_ERROR_BADARGUMENT;
   DCHECK(data_.color);
 
   if (!size)
     return PP_ERROR_BADARGUMENT;
 
-
   data_.color->red = clamp(red);
   data_.color->green = clamp(green);
   data_.color->blue = clamp(blue);
   data_.color->alpha = clamp(alpha);
   data_.common.size = *size;
 
   return PP_OK;
 }
 
 int32_t CompositorLayerResource::SetTexture(
@@ skipping 34 matching lines @@
   data_.common.resource_id = compositor_->GenerateResourceId();
   data_.texture->sync_point = gl->InsertSyncPointCHROMIUM();
   data_.texture->source_rect.point = PP_MakeFloatPoint(0.0f, 0.0f);
   data_.texture->source_rect.size = source_size_;
 
   // If the PP_Resource of this layer is released by the plugin, the
   // release_callback will be aborted immediately, but the texture or image
   // in this layer may still being used by chromium compositor. So we have to
   // use ScopedPPResource to keep this resource alive until the texture or image
   // is released by the chromium compositor.
+  // We also need keep the compositor alive, otherwise we will not receive
+  // the release IPC message for the texture.
   release_callback_ = base::Bind(
       &OnTextureReleased,
+      compositor_, // Keep compositor alive.
       ScopedPPResource(pp_resource()), // Keep layer alive.
       ScopedPPResource(context), // Keep context alive
       texture,
       release_callback);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t CompositorLayerResource::SetImage(
     PP_Resource image_data,
@@ skipping 26 matching lines @@
   // Set the source size to image's size. It will be used to verify
   // the source_rect passed to SetSourceRect().
   source_size_ = PP_MakeFloatSize(desc.size.width, desc.size.height);
 
   data_.common.size = size ? *size : desc.size;
   data_.common.resource_id = compositor_->GenerateResourceId();
   data_.image->resource = enter.resource()->host_resource().host_resource();
   data_.image->source_rect.point = PP_MakeFloatPoint(0.0f, 0.0f);
   data_.image->source_rect.size = source_size_;
 
+  // If the PP_Resource of this layer is released by the plugin, the
+  // release_callback will be aborted immediately, but the texture or image
+  // in this layer may still being used by chromium compositor. So we have to
+  // use ScopedPPResource to keep this resource alive until the texture or image
+  // is released by the chromium compositor.
+  // We also need keep the compositor alive, otherwise we will not receive
+  // the release IPC message for the image.
   release_callback_ = base::Bind(
       &OnImageReleased,
+      compositor_, // Keep compositor alive.
       ScopedPPResource(pp_resource()), // Keep layer alive.
       ScopedPPResource(image_data), // Keep image_data alive.
       release_callback);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t CompositorLayerResource::SetClipRect(const PP_Rect* rect) {
   if (!compositor_)
     return PP_ERROR_BADRESOURCE;
 
+  CHECK(compositor_->bound_to_instance());

[piman, 2014/06/18 00:55:24]

Same here, and other below.

[Peng, 2014/06/18 02:35:03]

Same reason.

+
   if (compositor_->IsInProgress())
     return PP_ERROR_INPROGRESS;
 
   data_.common.clip_rect = rect ? *rect : PP_MakeRectFromXYWH(0, 0, 0, 0);
   return PP_OK;
 }
 
 int32_t CompositorLayerResource::SetTransform(const float matrix[16]) {
   if (!compositor_)
     return PP_ERROR_BADRESOURCE;
 
+  CHECK(compositor_->bound_to_instance());
+
   if (compositor_->IsInProgress())
     return PP_ERROR_INPROGRESS;
 
   std::copy(matrix, matrix + 16, data_.common.transform.matrix);
   return PP_OK;
 }
 
 int32_t CompositorLayerResource::SetOpacity(float opacity) {
   if (!compositor_)
     return PP_ERROR_BADRESOURCE;
 
+  CHECK(compositor_->bound_to_instance());
+
   if (compositor_->IsInProgress())
     return PP_ERROR_INPROGRESS;
 
   data_.common.opacity = clamp(opacity);
   return PP_OK;
 }
 
 int32_t CompositorLayerResource::SetBlendMode(PP_BlendMode mode) {
   if (!compositor_)
     return PP_ERROR_BADRESOURCE;
 
+  CHECK(compositor_->bound_to_instance());
+
   if (compositor_->IsInProgress())
     return PP_ERROR_INPROGRESS;
 
   switch (mode) {
     case PP_BLENDMODE_NONE:
     case PP_BLENDMODE_SRC_OVER:
       data_.common.blend_mode = mode;
       return PP_OK;
   }
   return PP_ERROR_BADARGUMENT;
 }
 
 int32_t CompositorLayerResource::SetSourceRect(
     const PP_FloatRect* rect) {
   if (!compositor_)
     return PP_ERROR_BADRESOURCE;
 
+  CHECK(compositor_->bound_to_instance());
+
   if (compositor_->IsInProgress())
     return PP_ERROR_INPROGRESS;
 
   if (!rect ||
       rect->point.x < 0.0f ||
       rect->point.y < 0.0f ||
       rect->point.x + rect->size.width > source_size_.width ||
       rect->point.y + rect->size.height > source_size_.height) {
     return PP_ERROR_BADARGUMENT;
   }
 
   if (data_.texture) {
     data_.texture->source_rect = *rect;
     return PP_OK;
   }
   if (data_.image) {
     data_.image->source_rect = *rect;
     return PP_OK;
   }
   return PP_ERROR_BADARGUMENT;
 }
 
 int32_t CompositorLayerResource::SetPremultipliedAlpha(PP_Bool premult) {
   if (!compositor_)
     return PP_ERROR_BADRESOURCE;
 
+  CHECK(compositor_->bound_to_instance());
+
   if (compositor_->IsInProgress())
     return PP_ERROR_INPROGRESS;
 
   if (data_.texture) {
     data_.texture->premult_alpha = PP_ToBool(premult);
     return PP_OK;
   }
   return PP_ERROR_BADARGUMENT;
 }
 
@@ skipping 17 matching lines @@
   }
 
   // Should not be reached.
   DCHECK(false);
   return false;
 }
 
 int32_t CompositorLayerResource::CheckForSetTextureAndImage(
     LayerType type,
     const scoped_refptr<TrackedCallback>& release_callback) {
- if (!compositor_)
+  if (!compositor_)
     return PP_ERROR_BADRESOURCE;
 
+  CHECK(compositor_->bound_to_instance());
+
   if (compositor_->IsInProgress())
     return PP_ERROR_INPROGRESS;
 
   if (!SetType(type))
     return PP_ERROR_BADARGUMENT;
 
   // The layer's image has been set and it is not committed.
   if (!release_callback_.is_null())
     return PP_ERROR_INPROGRESS;
 
   // Do not allow using a block callback as a release callback.
   if (release_callback->is_blocking())
     return PP_ERROR_BADARGUMENT;
 
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace ppapi