[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();
+  ResetLayersInternal(true);
+
+  // Abort all release callbacks.
+  for (ReleaseCallbackMap::iterator it = release_callback_map_.begin();
+       it != release_callback_map_.end(); ++it) {
+    if (!it->second.is_null())
+      it->second.Run(PP_ERROR_ABORTED, 0, false);
+  }
 }
 
 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)
@@ skipping 34 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();
+
+  ResetLayersInternal(false);
   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
@@ skipping 17 matching lines @@
 }
 
 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);
+  it->second.Run(PP_OK, sync_point, is_lost);
   release_callback_map_.erase(it);
 }
 
-void CompositorResource::ResetLayersInternal() {
+void CompositorResource::ResetLayersInternal(bool is_aborted) {
   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);
+      release_callback.Run(is_aborted ? PP_ERROR_ABORTED : PP_OK, 0, false);

[piman, 2014/06/19 23:18:32]

Actually, why do we run the callback now when we call ResetLayers?

We should wait and commit the new layers (or none), and once the renderer layers
call their respective callbacks, this will flow back to the plugin and call
OnPluginMsgReleaseResource with the correct sync point.

If we send the callback early (in a non abort case), we'll have synchronization
issues.

[piman, 2014/06/20 01:24:56]

Ok, this can only happen for layers that haven't been committed yet, so ok.

       (*it)->ResetReleaseCallback();
     }
     (*it)->Invalidate();
   }
 
   layers_.clear();
   layer_reset_ = true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi