Convert to new enter method

ppapi/thunk/enter.cc

 // Copyright (c) 2011 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/thunk/enter.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
@@ skipping 65 matching lines @@
   return PpapiGlobals::Get()->GetResourceTracker()->GetResource(resource);
 }
 
 void EnterBase::SetStateForResourceError(PP_Resource pp_resource,
                                          Resource* resource_base,
                                          void* object,
                                          bool report_error) {
   if (object)
     return;  // Everything worked.
 
-  retval_ = PP_ERROR_BADRESOURCE;
+  if (callback_.func) {
+    // Required callback, issue the async completion.
+    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+        callback_.func, callback_.user_data,
+        static_cast<int32_t>(PP_ERROR_BADRESOURCE)));
+    callback_ = PP_BlockUntilComplete();
+    retval_ = PP_OK_COMPLETIONPENDING;
+  } else {
+    retval_ = PP_ERROR_BADRESOURCE;
+  }
 
   // We choose to silently ignore the error when the pp_resource is null
   // because this is a pretty common case and we don't want to have lots
   // of errors in the log. This should be an obvious case to debug.
   if (report_error && pp_resource) {
     std::string message;
     if (resource_base) {
       message = base::StringPrintf(
           "0x%X is not the correct type for this function.",
           pp_resource);
     } else {
       message = base::StringPrintf(
           "0x%X is not a valid resource ID.",
           pp_resource);
     }
     PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR,
                                                 std::string(), message);
   }
 }
 
+void EnterBase::SetStateForFunctionError(PP_Instance pp_instance,
+                                         void* object,
+                                         bool report_error) {
+  if (object)
+    return;  // Everything worked.
+
+  if (callback_.func) {
+    // Required callback, issue the async completion.
+    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+        callback_.func, callback_.user_data,
+        static_cast<int32_t>(PP_ERROR_BADARGUMENT)));
+    callback_ = PP_BlockUntilComplete();
+    retval_ = PP_OK_COMPLETIONPENDING;
+  } else {
+    retval_ = PP_ERROR_BADARGUMENT;
+  }
+
+  // We choose to silently ignore the error when the pp_instance is null as
+  // for PP_Resources above.
+  if (report_error && pp_instance) {
+    std::string message;
+    message = base::StringPrintf(
+        "0x%X is not a valid instance ID.",
+        pp_instance);
+    PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR,
+                                                std::string(), message);
+  }
+}
+
 }  // namespace subtle
 
 EnterResourceCreation::EnterResourceCreation(PP_Instance instance)
     : EnterFunctionNoLock<ResourceCreationAPI>(instance, true) {
 }
 
 EnterResourceCreation::~EnterResourceCreation() {
 }
 
 EnterInstance::EnterInstance(PP_Instance instance)
-    : EnterFunctionNoLock<PPB_Instance_FunctionAPI>(instance, true) {
+    : EnterFunction<PPB_Instance_FunctionAPI>(instance, true) {
+}
+
+EnterInstance::EnterInstance(PP_Instance instance,
+                             const PP_CompletionCallback& callback)
+    : EnterFunction<PPB_Instance_FunctionAPI>(instance, callback, true) {
 }
 
 EnterInstance::~EnterInstance() {
 }
 
 }  // namespace thunk
 }  // namespace ppapi