[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());
+
   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());
+
   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