Convert to new enter method

ppapi/thunk/enter.h

 // 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.
 
 #ifndef PPAPI_THUNK_ENTER_H_
 #define PPAPI_THUNK_ENTER_H_
 
 #include "base/basictypes.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/shared_impl/api_id.h"
@@ skipping 90 matching lines @@
   // passing both resource_base and object is that we can differentiate "bad
   // resource ID" from "valid resource ID not of the currect type."
   //
   // This will set retval_ = PP_ERROR_BADRESOURCE if the object is invalid, and
   // if report_error is set, log a message to the programmer.
   void SetStateForResourceError(PP_Resource pp_resource,
                                 Resource* resource_base,
                                 void* object,
                                 bool report_error);
 
+  // Same as SetStateForResourceError except for function API.
+  void SetStateForFunctionError(PP_Instance pp_instance,
+                                void* object,
+                                bool report_error);
+
  private:
   // Holds the callback. The function will only be non-NULL when the
   // callback is requried. Optional callbacks don't require any special
   // handling from us at this layer.
   PP_CompletionCallback callback_;
 
   int32_t retval_;
 };
 
 }  // namespace subtle
 
+// EnterFunction --------------------------------------------------------------
 
 template<typename FunctionsT, bool lock_on_entry = true>
 class EnterFunction : public subtle::EnterBase,
                       public subtle::LockOnEntry<lock_on_entry> {
  public:
   EnterFunction(PP_Instance instance, bool report_error)
-      : functions_(NULL) {
-    FunctionGroupBase* base = GetFunctions(instance, FunctionsT::kApiID);
-    if (base)
-      functions_ = base->GetAs<FunctionsT>();
-    // TODO(brettw) check error and if report_error is set, do something.
+      : EnterBase() {
+    Init(instance, report_error);
+  }
+  EnterFunction(PP_Instance instance,
+                const PP_CompletionCallback& callback,
+                bool report_error)
+      : EnterBase(callback) {
+    Init(instance, report_error);
   }
 
   ~EnterFunction() {}
 
   bool succeeded() const { return !!functions_; }
   bool failed() const { return !functions_; }
 
   FunctionsT* functions() { return functions_; }
 
  private:
+  void Init(PP_Instance instance, bool report_error) {
+    FunctionGroupBase* base = GetFunctions(instance, FunctionsT::kApiID);
+    if (base)
+      functions_ = base->GetAs<FunctionsT>();
+    else
+      functions_ = NULL;
+    SetStateForFunctionError(instance, functions_, report_error);
+  }
+
   FunctionsT* functions_;
 
   DISALLOW_COPY_AND_ASSIGN(EnterFunction);
 };
 
 // Like EnterFunction but assumes the lock is already held.
 template<typename FunctionsT>
 class EnterFunctionNoLock : public EnterFunction<FunctionsT, false> {
  public:
   EnterFunctionNoLock(PP_Instance instance, bool report_error)
@@ skipping 52 matching lines @@
       object_ = NULL;
     SetStateForResourceError(resource, resource_, object_, report_error);
   }
 
   Resource* resource_;
   ResourceT* object_;
 
   DISALLOW_COPY_AND_ASSIGN(EnterResource);
 };
 
+// ----------------------------------------------------------------------------
+
 // Like EnterResource but assumes the lock is already held.
 template<typename ResourceT>
 class EnterResourceNoLock : public EnterResource<ResourceT, false> {
  public:
   EnterResourceNoLock(PP_Resource resource, bool report_error)
       : EnterResource<ResourceT, false>(resource, report_error) {
   }
 };
 
 // Simpler wrapper to enter the resource creation API. This is used for every
 // class so we have this helper function to save template instantiations and
 // typing.
 class PPAPI_THUNK_EXPORT EnterResourceCreation
     : public EnterFunctionNoLock<ResourceCreationAPI> {
  public:
   EnterResourceCreation(PP_Instance instance);
   ~EnterResourceCreation();
 };
 
 // Simpler wrapper to enter the instance API from proxy code. This is used for
 // many interfaces so we have this helper function to save template
 // instantiations and typing.
 class PPAPI_THUNK_EXPORT EnterInstance
-    : public EnterFunctionNoLock<PPB_Instance_FunctionAPI> {
+    : public EnterFunction<PPB_Instance_FunctionAPI> {
  public:
   EnterInstance(PP_Instance instance);
+  EnterInstance(PP_Instance instance, const PP_CompletionCallback& callback);
   ~EnterInstance();
 };
 
 }  // namespace thunk
 }  // namespace ppapi
 
 #endif  // PPAPI_THUNK_ENTER_H_