[PPAPI] Compositor API implementation

ppapi/proxy/compositor_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_resource.h"
 
+#include "base/logging.h"
+#include "ppapi/proxy/ppapi_messages.h"
+
 namespace ppapi {
 namespace proxy {
 
 CompositorResource::CompositorResource(Connection connection,
                                        PP_Instance instance)
-    : PluginResource(connection, instance) {
+    : PluginResource(connection, instance),
+      layer_reset_(true),
+      last_resource_id_(0) {
+  SendCreate(RENDERER, PpapiHostMsg_Compositor_Create());
 }
 
 CompositorResource::~CompositorResource() {
+  ResetLayers();
 }
 
 thunk::PPB_Compositor_API* CompositorResource::AsPPB_Compositor_API() {
   return this;
 }
 
+void CompositorResource::OnReplyReceived(
+    const ResourceMessageReplyParams& params,
+    const IPC::Message& msg) {
+   PPAPI_BEGIN_MESSAGE_MAP(CompositorResource, msg)
+     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+         PpapiPluginMsg_Compositor_ReleaseResource,
+         OnPluginMsgReleaseResource)
+     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(
+          PluginResource::OnReplyReceived(params, msg))
+   PPAPI_END_MESSAGE_MAP()
+}
+
 PP_Resource CompositorResource::AddLayer() {
-  return 0;
+  scoped_refptr<CompositorLayerResource> resource(new CompositorLayerResource(
+      connection(), pp_instance(), this));
+  layers_.push_back(resource);
+  return resource->GetReference();
 }
 
 int32_t CompositorResource::CommitLayers(
     const scoped_refptr<ppapi::TrackedCallback>& callback) {
-  return PP_ERROR_NOTSUPPORTED;
+  if (IsInProgress())
+    return PP_ERROR_INPROGRESS;
+
+  std::vector<CompositorLayerData> layers;
+  layers.reserve(layers_.size());
+
+  for (LayerList::const_iterator it = layers_.begin();
+       it != layers_.end(); ++it) {
+    switch ((*it)->data().type) {
+      case CompositorLayerData::TYPE_UNKNOWN:
+        return PP_ERROR_FAILED;
+      case CompositorLayerData::TYPE_COLOR:
+      case CompositorLayerData::TYPE_TEXTURE:
+      case CompositorLayerData::TYPE_IMAGE:
+        layers.push_back((*it)->data());
+        continue;
+      default:
+        NOTREACHED();

[piman, 2014/06/04 13:19:43]

No default case, just omit it to get compiler warnings if a value is added to
the enum and this code is not updated.

[Peng, 2014/06/05 00:50:38]

Done.

+    }
+  }
+
+  commit_callback_ = callback;
+  Call<PpapiPluginMsg_Compositor_CommitLayersReply>(
+      RENDERER,
+      PpapiHostMsg_Compositor_CommitLayers(layers, layer_reset_),
+      base::Bind(&CompositorResource::OnPluginMsgCommitLayersReply,
+                 base::Unretained(this)),
+      callback);
+
+  return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t CompositorResource::ResetLayers() {
-  return PP_ERROR_NOTSUPPORTED;
+  if (IsInProgress())
+    return PP_ERROR_INPROGRESS;
+
+  for (LayerList::iterator it = layers_.begin();
+       it != layers_.end(); ++it) {
+    ReleaseCallback release_callback = (*it)->release_callback();
+    if (!release_callback.is_null())
+      release_callback.Run(0, false);
+    (*it)->Invalidate();

[raymes, 2014/06/04 01:11:38]

One problem here is that if IsInProgress() returns true, we won't properly
invalidate the layers on destruction. This could result in a UAF in the layer.
We should always invalidate the layers on destruction.

[Peng, 2014/06/05 00:50:38]

Good catch. Done

+  }
+
+  layers_.clear();
+  layer_reset_ = true;
+  return PP_OK;
+}
+
+void CompositorResource::OnPluginMsgCommitLayersReply(
+    const ResourceMessageReplyParams& params) {
+  if (!TrackedCallback::IsPending(commit_callback_))
+    return;
+
+  // On success, we put layers' release_callbacks into a map,
+  // otherwise we will do nothing. So plugin may change layers and
+  // call CommitLayers() again.
+  if (params.result() == PP_OK) {
+    layer_reset_ = false;
+    for (LayerList::iterator it = layers_.begin();
+         it != layers_.end(); ++it) {
+      switch ((*it)->data().type) {
+        case CompositorLayerData::TYPE_TEXTURE:
+        case CompositorLayerData::TYPE_IMAGE: {
+          ReleaseCallback release_callback = (*it)->release_callback();
+          (*it)->ResetReleaseCallback();
+          if (!release_callback.is_null()) {
+            release_callback_map_.insert(ReleaseCallbackMap::value_type(
+                (*it)->data().resource_id, release_callback));

[raymes, 2014/06/04 01:11:38]

Note that the ReleaseCallback holds a reference to the CompositorLayerResource.
So how about we just hold a reference to the CompositorLayerResource directly?
This way we wouldn't have to expose ReleaseCallback at all.
CompositorLayerResource could release the resource in its destructor.

So release_callback_map_ here would become live_layers_map_ here.

[Peng, 2014/06/05 00:50:38]

Actually, the ReleaseCallback does not need hold a ref to the CLR. Because for a
single Layer, it could generate several ReleaseCallbacks. For example:(see below
steps)

1) layer.SetImage(image1);
2) compositor.CommitLayers();
3) layer.SetImage(image2);
4) compositor.CommitLayers();

2) and 3) will generate two different release_callbacks for image1 and image2.
So we can not only keep a layer in map.

Done. Do not hold a ref of CLR in release_callback.

+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(commit_callback_);
+  callback->Run(params.result());
+}
+
+void CompositorResource::OnPluginMsgReleaseResource(
+    const ResourceMessageReplyParams& params,
+    int32_t id,
+    uint32_t sync_point,
+    bool is_lost) {
+  ReleaseCallbackMap::iterator it = release_callback_map_.find(id);
+  DCHECK(it != release_callback_map_.end()) <<
+      "Can not found release_callback_ by id(" << id << ")!";
+  it->second.Run(sync_point, is_lost);
+  release_callback_map_.erase(it);
 }
 
 }  // namespace proxy
 }  // namespace ppapi