PPAPI: Make blocking completion callbacks work.

ppapi/proxy/enter_proxy.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
 #ifndef PPAPI_PROXY_ENTER_PROXY_H_
 #define PPAPI_PROXY_ENTER_PROXY_H_
 
 #include "base/logging.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
@@ skipping 26 matching lines @@
     DCHECK(this->failed() ||
            PluginDispatcher::GetForInstance(host_resource.instance()));
   }
 };
 
 template<typename ResourceT>
 class EnterHostFromHostResource
     : public thunk::EnterResourceNoLock<ResourceT> {
  public:
   explicit EnterHostFromHostResource(const HostResource& host_resource)
-      : thunk::EnterResourceNoLock<ResourceT>(
-            host_resource.host_resource(), false) {
+      : thunk::EnterResourceNoLock<ResourceT>(host_resource.host_resource(),
+                                              false) {
     // Validate that we're in the host rather than the plugin. Otherwise this
     // object will do the wrong thing. In the host, the instance should have
     // a corresponding host disptacher (assuming the resource is valid).
+    DCHECK(this->failed() ||
+           HostDispatcher::GetForInstance(host_resource.instance()));
+  }
+
+  EnterHostFromHostResource(const HostResource& host_resource,
+                            const pp::CompletionCallback& callback)
+      : thunk::EnterResourceNoLock<ResourceT>(host_resource.host_resource(),
+                                              callback.pp_completion_callback(),
+                                              false) {
+    // Validate that we're in the host rather than the plugin. Otherwise this
+    // object will do the wrong thing. In the host, the instance should have
+    // a corresponding host disptacher (assuming the resource is valid).
     DCHECK(this->failed() ||
            HostDispatcher::GetForInstance(host_resource.instance()));
   }
 };
 
 // Enters a resource and forces a completion callback to be issued.
 //
 // This is used when implementing the host (renderer) side of a resource
 // function that issues a completion callback. In all cases, we need to issue
 // the callback to avoid hanging the plugin.
@@ skipping 22 matching lines @@
 //   void MyClass::SendResult(int32_t result, const HostResource& res) {
 //     Send(new FooMsg_FooComplete(..., result, res));
 //   }
 template<typename ResourceT>
 class EnterHostFromHostResourceForceCallback
     : public EnterHostFromHostResource<ResourceT> {
  public:
   EnterHostFromHostResourceForceCallback(
       const HostResource& host_resource,
       const pp::CompletionCallback& callback)
-      : EnterHostFromHostResource<ResourceT>(host_resource),
-        needs_running_(true),
-        callback_(callback) {
+      : EnterHostFromHostResource<ResourceT>(host_resource, callback),
+        needs_running_(true) {
   }
 
   // For callbacks that take no parameters except the "int32_t result". Most
   // implementations will use the 1-extra-argument constructor below.
   template<class CallbackFactory, typename Method>
   EnterHostFromHostResourceForceCallback(
       const HostResource& host_resource,
       CallbackFactory& factory,
       Method method)
-      : EnterHostFromHostResource<ResourceT>(host_resource),
-        needs_running_(true),
-        callback_(factory.NewOptionalCallback(method)) {
+      : EnterHostFromHostResource<ResourceT>(host_resource,
+            factory.NewOptionalCallback(method)),
+        needs_running_(true) {
     if (this->failed())
       RunCallback(PP_ERROR_BADRESOURCE);
   }
 
   // For callbacks that take an extra parameter as a closure.
   template<class CallbackFactory, typename Method, typename A>
   EnterHostFromHostResourceForceCallback(
       const HostResource& host_resource,
       CallbackFactory& factory,
       Method method,
       const A& a)
-      : EnterHostFromHostResource<ResourceT>(host_resource),
-        needs_running_(true),
-        callback_(factory.NewOptionalCallback(method, a)) {
+      : EnterHostFromHostResource<ResourceT>(host_resource,
+            factory.NewOptionalCallback(method, a)),
+        needs_running_(true) {
     if (this->failed())
       RunCallback(PP_ERROR_BADRESOURCE);
   }
 
   // For callbacks that take two extra parameters as a closure.
   template<class CallbackFactory, typename Method, typename A, typename B>
   EnterHostFromHostResourceForceCallback(
       const HostResource& host_resource,
       CallbackFactory& factory,
       Method method,
       const A& a,
       const B& b)
-      : EnterHostFromHostResource<ResourceT>(host_resource),
-        needs_running_(true),
-        callback_(factory.NewOptionalCallback(method, a, b)) {
+      : EnterHostFromHostResource<ResourceT>(host_resource,
+            factory.NewOptionalCallback(method, a, b)),
+        needs_running_(true) {
     if (this->failed())
       RunCallback(PP_ERROR_BADRESOURCE);
   }
 
   ~EnterHostFromHostResourceForceCallback() {
     if (needs_running_) {
       NOTREACHED() << "Should always call SetResult except in the "
                       "initialization failed case.";
       RunCallback(PP_ERROR_FAILED);
     }
   }
 
   void SetResult(int32_t result) {
     DCHECK(needs_running_) << "Don't call SetResult when there already is one.";
+    if (result != PP_OK_COMPLETIONPENDING)
+      RunCallback(result);
     needs_running_ = false;
-    if (result != PP_OK_COMPLETIONPENDING)
-      callback_.Run(result);
-  }
-
-  PP_CompletionCallback callback() {
-    return callback_.pp_completion_callback();
+    // Either we already ran the callback, or it will be run asynchronously. We
+    // clear the callback so it isn't accidentally run again (and because
+    // EnterBase checks that the callback has been cleared).
+    this->ClearCallback();
   }
 
  private:
   void RunCallback(int32_t result) {
     DCHECK(needs_running_);
     needs_running_ = false;
-    callback_.Run(result);
+    this->callback()->Run(result);
+    this->ClearCallback();
   }
 
   bool needs_running_;
-  pp::CompletionCallback callback_;
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_ENTER_PROXY_H_