[PPAPI] Add browser tests for compositor API

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"
+#include "ppapi/thunk/enter.h"
 
 namespace ppapi {
 namespace proxy {
 
 CompositorResource::CompositorResource(Connection connection,
                                        PP_Instance instance)
     : PluginResource(connection, instance),
       layer_reset_(true),
+      bound_to_instance_(false),
       last_resource_id_(0) {
   SendCreate(RENDERER, PpapiHostMsg_Compositor_Create());
 }
 
 CompositorResource::~CompositorResource() {
   ResetLayersInternal();
 }
 
 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() {
+  if (!bound_to_instance_)
+    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) {
+  if (!bound_to_instance_)
+    return PP_ERROR_FAILED;
+
   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) {
     if ((*it)->data().is_null())
       return PP_ERROR_FAILED;
     layers.push_back((*it)->data());
   }
 
   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() {
+  if (!bound_to_instance_)
+    return PP_ERROR_FAILED;
+
   if (IsInProgress())
     return PP_ERROR_INPROGRESS;
+
   ResetLayersInternal();
   return PP_OK;
 }
 
+void CompositorResource::BindToInstance(bool bound) {
+  ProxyLock::AssertAcquiredDebugOnly();
+
+  if (bound == bound_to_instance_)
+    return;
+  bound_to_instance_ = bound;
+
+  // Reset layers when the compositor is un bound from the instance.
+  if (!bound_to_instance_)
+    ResetLayersInternal();
+}
+
+void CompositorResource::NotifyLastPluginRefWasDeleted() {
+  ProxyLock::AssertAcquiredDebugOnly();
+
+  PluginResource::NotifyLastPluginRefWasDeleted();
+  if (bound_to_instance_) {
+    ppapi::thunk::EnterInstanceNoLock enter(pp_instance());
+    DCHECK(enter.succeeded());
+    enter.functions()->BindGraphics(pp_instance(), 0);
+    // BindToInstance(0) should be called by PPB_Instance_Proxy::BindGraphics().
+    DCHECK(!bound_to_instance_);
+   }

[raymes, 2014/06/18 05:58:44]

Why do we need to do this?

[Peng, 2014/06/18 11:14:37]

Because the plugin instance holds a scoped_refptr of this bound compositor. When
the PP_Resource ref reduce to 0, the compositor will be still alive. So we have
to use BindGraphics(0), so the plugin instance will release the scoped_refptr,
and then the compositor will be deleted from memory. And then the dtor of
PluginResource will send a notification to the host in render side, so the host
can be deleted too.

[raymes, 2014/06/19 00:39:13]

I think this would be much simpler if we didn't manage the bind state on the
plugin side.

[Peng, 2014/06/19 17:35:11]

In the recent patchset, we do not manage the bind state anymore.

+}
+
 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;
@@ skipping 35 matching lines @@
     }
     (*it)->Invalidate();
   }
 
   layers_.clear();
   layer_reset_ = true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi