[PPAPI] Compositor API implementation

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 <algorithm>
 
 #include "base/logging.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppb_graphics_3d_shared.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_graphics_3d_api.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Graphics3D_API;
 
 namespace ppapi {
 namespace proxy {
 
-CompositorLayerResource::CompositorLayerResource(Connection connection,
-                                       PP_Instance instance)
-    : PluginResource(connection, instance) {
+CompositorLayerResource::CompositorLayerResource(
+    Connection connection,
+    PP_Instance instance,
+    base::WeakPtr<CompositorResource::Layer> layer)
+    : PluginResource(connection, instance),
+      layer_(layer) {
 }
 
 CompositorLayerResource::~CompositorLayerResource() {
 }
 
 thunk::PPB_CompositorLayer_API*
 CompositorLayerResource::AsPPB_CompositorLayer_API() {
   return this;
 }
 
 int32_t CompositorLayerResource::SetColor(uint8_t red,
                                           uint8_t green,
                                           uint8_t blue,
                                           uint8_t alpha,
                                           const struct PP_Size* size) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetColor(red, green, blue, alpha, size);
 }
 
 int32_t CompositorLayerResource::SetTexture(
     PP_Resource context,
     uint32_t texture,
     const struct PP_Size* size,
     const scoped_refptr<ppapi::TrackedCallback>& callback) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetTexture(context, texture, size, callback);
 }
 
 int32_t CompositorLayerResource::SetImage(
     PP_Resource image_data,
     const struct PP_Size* size,
     const scoped_refptr<ppapi::TrackedCallback>& callback) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetImage(image_data, size, callback);
 }
 
 int32_t CompositorLayerResource::SetClipRect(const struct PP_Rect* rect) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetClipRect(rect);
 }
 
 int32_t CompositorLayerResource::SetTransform(const float matrix[16]) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetTransform(matrix);
 }
 
 int32_t CompositorLayerResource::SetOpacity(uint8_t opacity) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetOpacity(opacity);
 }
 
 int32_t CompositorLayerResource::SetBlendMode(PP_BlendMode mode) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetBlendMode(mode);
 }
 
 int32_t CompositorLayerResource::SetSourceRect(
     const struct PP_FloatRect* rect) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetSourceRect(rect);
 }
 
 int32_t CompositorLayerResource::SetPremultipliedAlpha(PP_Bool premult) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (!layer_)
+    return PP_ERROR_BADARGUMENT;
+  return layer_->SetPremultipliedAlpha(premult);
 }
 
 }  // namespace proxy
 }  // namespace ppapi