Draft: apps APIs in Pepper

ppapi/cpp/output_traits.h

 // 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_CPP_OUTPUT_TRAITS_H_
 #define PPAPI_CPP_OUTPUT_TRAITS_H_
 
 #include <vector>
 
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/cpp/array_output.h"
+#include "ppapi/cpp/dev/array_dev.h"
+#include "ppapi/cpp/dev/from_c_type_converter_dev.h"
+#include "ppapi/cpp/dev/struct_wrapper_base_dev.h"
 #include "ppapi/cpp/resource.h"
 
 /// @file
 /// This file defines internal templates for defining how data is passed to the
 /// browser via output parameters and how to convert that data to the
 /// corresponding C++ object types.
 ///
 /// It is used by the callback system, it should not be necessary for end-users
 /// to use these templates directly.
 
@@ skipping 94 matching lines @@
   // resource object type.
   static inline T StorageToPluginArg(StorageType& t) {
     return T(PASS_REF, t);
   }
 
   static inline void Initialize(StorageType* t) {
     *t = 0;
   }
 };
 
+template<typename T>
+struct StructWrapperCallbackOutputTraits {
+  typedef typename T::COutputType APIArgType;
+  typedef FromCTypeConverter<T> StorageType;
+
+  static inline APIArgType StorageToAPIArg(StorageType& t) {
+    return t.StartRawUpdate();
+  }
+
+  static inline T& StorageToPluginArg(StorageType& t) {
+    t.EndRawUpdate();
+    return t.value();
+  }
+
+  static inline void Initialize(StorageType* /* t */) {}
+};
+
 // The general templatized base class for all CallbackOutputTraits. This class
-// covers both resources and POD (ints, structs, etc.) by inheriting from the
-// appropriate base class depending on whether the given type derives from
-// pp::Resource. This trick allows us to do this once rather than writing
-// specializations for every resource object type.
+// covers resources, struct wrapper objects and POD (ints, structs, etc.)
+// by inheriting from the appropriate base class depending on whether the given
+// type derives from pp::Resource or StructWrapperIdentifier. This trick
+// allows us to do this once rather than writing specializations for every
+// object type.
+// TODO(yzshen): I will need to add specializtion for Optional<T>. Other than
+// that I think it should be fine.
 template<typename T>
 struct CallbackOutputTraits
-    : public InheritIf<GenericCallbackOutputTraits<T>,
-                       !IsBaseOf<Resource, T>::value>,
-      public InheritIf<ResourceCallbackOutputTraits<T>,
-                       IsBaseOf<Resource, T>::value> {
+    : public InheritIf<ResourceCallbackOutputTraits<T>,
+                       IsBaseOf<Resource, T>::value>,
+      public InheritIf<StructWrapperCallbackOutputTraits<T>,
+                       IsBaseOf<StructWrapperIdentifier, T>::value>,
+      public InheritIf<GenericCallbackOutputTraits<T>,
+                       !IsBaseOf<Resource, T>::value &&
+                       !IsBaseOf<StructWrapperIdentifier, T>::value> {
 };
 
 // A specialization of CallbackOutputTraits for pp::Var output parameters.
 // It passes a PP_Var* to the browser and converts to a pp::Var when passing
 // to the plugin.
 template<>
 struct CallbackOutputTraits<Var> {
   // To call the browser, we just pass a PP_Var* as an output param.
   typedef PP_Var* APIArgType;
   typedef PP_Var StorageType;
@@ skipping 30 matching lines @@
   // Converts the PP_Bool to a bool object.
   static inline bool StorageToPluginArg(StorageType& t) {
     return PP_ToBool(t);
   }
 
   static inline void Initialize(StorageType* t) {
     *t = PP_FALSE;
   }
 };
 
+template<typename T>
+struct CallbackOutputTraits<Array<T> > {
+  typedef typename Array<T>::COutputType APIArgType;
+  typedef Array<T> StorageType;
+
+  static inline APIArgType StorageToAPIArg(StorageType& t) {
+    return t.StartRawUpdate();
+  }
+
+  static inline Array<T>& StorageToPluginArg(StorageType& t) {
+    t.EndRawUpdate();
+    return t;
+  }
+
+  static inline void Initialize(StorageType* t) {
+  }
+};
+
 // Array output parameters -----------------------------------------------------
 
 // Output traits for vectors of all "plain old data" (POD) types. It is
 // implemented to pass a pointer to the browser as an output parameter.
 //
 // This is used as a base class for the general vector CallbackOutputTraits
 // below in the case where T is not a resource.
 template<typename T>
 struct GenericVectorCallbackOutputTraits {
   // All arrays are output via a PP_ArrayOutput type.
@@ skipping 76 matching lines @@
     return t.output();
   }
 
   static inline void Initialize(StorageType* /* t */) {}
 };
 
 }  // namespace internal
 }  // namespace pp
 
 #endif  // PPAPI_CPP_OUTPUT_TRAITS_H_