Make the file chooser use PP_ArrayOutput

ppapi/proxy/enter_proxy.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_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"
@@ skipping 71 matching lines @@
 // Where DoFoo's signature looks like this:
 //   int32_t DoFoo(PP_CompletionCallback callback);
 // And SendResult's implementation looks like this:
 //   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) {
+  }
+
   // 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)) {
@@ skipping 59 matching lines @@
   bool needs_running_;
   pp::CompletionCallback callback_;
 };
 
 // Like EnterHostFromHostResourceForceCallback but for Function APIs. It takes
 // an instance instead of a resource ID.
 template<typename FunctionT>
 class EnterHostFunctionForceCallback
     : public thunk::EnterFunctionNoLock<FunctionT> {
  public:
-  // 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>
-  EnterHostFunctionForceCallback(PP_Instance instance,
-                                 CallbackFactory& factory,
-                                 Method method)
+  EnterHostFunctionForceCallback(
+      PP_Instance instance,
+      const pp::CompletionCallback& callback)
       : thunk::EnterFunctionNoLock<FunctionT>(instance, false),
         needs_running_(true),
-        callback_(factory.NewOptionalCallback(method)) {
+        callback_(callback) {
     if (this->failed())
       RunCallback(PP_ERROR_BADARGUMENT);
   }
-
-  // For callbacks that take an extra parameter as a closure.
-  template<class CallbackFactory, typename Method, typename A>
-  EnterHostFunctionForceCallback(PP_Instance instance,
-                                 CallbackFactory& factory,
-                                 Method method,
-                                 const A& a)
-      : thunk::EnterFunctionNoLock<FunctionT>(instance, false),
-        needs_running_(true),
-        callback_(factory.NewOptionalCallback(method, a)) {
-    if (this->failed())
-      RunCallback(PP_ERROR_BADARGUMENT);
-  }
-
-  // For callbacks that take two extra parameters as a closure.
-  template<class CallbackFactory, typename Method, typename A, typename B>
-  EnterHostFunctionForceCallback(PP_Instance instance,
-                                 CallbackFactory& factory,
-                                 Method method,
-                                 const A& a,
-                                 const B& b)
-      : thunk::EnterFunctionNoLock<FunctionT>(instance),
-        needs_running_(true),
-        callback_(factory.NewOptionalCallback(method, a, b)) {
-    if (this->failed())
-      RunCallback(PP_ERROR_BADARGUMENT);
-  }
 
   ~EnterHostFunctionForceCallback() {
     if (needs_running_) {
       NOTREACHED() << "Should always call SetResult except in the "
                       "initialization failed case.";
       RunCallback(PP_ERROR_FAILED);
     }
   }
 
   void SetResult(int32_t result) {
@@ skipping 15 matching lines @@
   }
 
   bool needs_running_;
   pp::CompletionCallback callback_;
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_ENTER_PROXY_H_