[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),
       last_resource_id_(0) {
   SendCreate(RENDERER, PpapiHostMsg_Compositor_Create());
 }
 
+bool CompositorResource::IsInProgress() const {
+  ProxyLock::AssertAcquiredDebugOnly();
+  return TrackedCallback::IsPending(commit_callback_);
+}
+
+int32_t CompositorResource::GenerateResourceId() const {
+  ProxyLock::AssertAcquiredDebugOnly();
+  return ++last_resource_id_;
+}
+
 CompositorResource::~CompositorResource() {
   ResetLayersInternal();
 }
 
 thunk::PPB_Compositor_API* CompositorResource::AsPPB_Compositor_API() {
   return this;
 }
 
 void CompositorResource::OnReplyReceived(
     const ResourceMessageReplyParams& params,
@@ skipping 36 matching lines @@
       base::Bind(&CompositorResource::OnPluginMsgCommitLayersReply,
                  base::Unretained(this)),
       callback);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t CompositorResource::ResetLayers() {
   if (IsInProgress())
     return PP_ERROR_INPROGRESS;
+
   ResetLayersInternal();
   return PP_OK;
 }
 
+void CompositorResource::NotifyLastPluginRefWasDeleted() {
+  PluginResource::NotifyLastPluginRefWasDeleted();
+  ResetLayersInternal();
+  // The resource dtor sends an IPC message to renderer, and then the renderer
+  // will delete the resource host.
+  // But in this case, every callback in |release_callback_map_| holds a
+  // scoped_refptr of the compositor resource, so the compositor will never be

[piman, 2014/06/19 20:44:04]

Well, maybe that is the problem we should fix. Essentially, you're creating
refcount cycles.

It sounds like what you want is not to keep a reference to the compositor in the
callbacks, but instead cancel the callbacks when the compositor is destroyed.

[Peng, 2014/06/19 22:33:41]

Done

+  // deleted. We have to ask the compositor resource host to release all layers,
+  // and then all all release callbacks will be called, and then the compositor
+  // resource will be deleted.
+  Post(RENDERER, PpapiHostMsg_Compositor_Release());
+}
+
 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