PPAPI: Initialize CompletionCallbackWithOutput storage

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"
@@ skipping 67 matching lines @@
 
   // Converts a "storage type" to a value that can be passed to the browser as
   // an output parameter. This just takes the address to convert the value to
   // a pointer.
   static inline APIArgType StorageToAPIArg(StorageType& t) { return &t; }
 
   // Converts the "storage type" to the value we pass to the plugin for
   // callbacks. This doesn't actually need to do anything in this case,
   // it's needed for some of more complex template specializations below.
   static inline T& StorageToPluginArg(StorageType& t) { return t; }
+
+  // Initializes the "storage type" to a default value, if necessary. Here,
+  // we do nothing, assuming that the default constructor for T suffices.
+  static inline void Initialize(StorageType* /* t */) {}
 };
 
 // Output traits for all resource types. It is implemented to pass a
 // PP_Resource* as an output parameter to the browser, and convert to the
 // given resource object type T when passing to the plugin.
 //
 // Note that this class is parameterized by the resource object, for example
 // ResourceCallbackOutputTraits<pp::FileRef>. This is used as a base class for
 // CallbackOutputTraits below for the case where T is a derived class of
 // pp::Resource.
 template<typename T>
 struct ResourceCallbackOutputTraits {
   // To call the browser, we just pass a PP_Resource pointer as the out param.
   typedef PP_Resource* APIArgType;
   typedef PP_Resource StorageType;
 
   static inline APIArgType StorageToAPIArg(StorageType& t) {
     return &t;
   }
 
   // Converts the PP_Resource to a pp::* object, passing any reference counted
   // object along with it. This must only be called once since there will only
   // be one reference that the browser has assigned to us for the out param!
   // When calling into the plugin, convert the PP_Resource into the requested
   // resource object type.
   static inline T StorageToPluginArg(StorageType& t) {
     return T(PASS_REF, t);
   }
+
+  static inline void Initialize(StorageType* t) {
+    *t = 0;
+  }
 };
 
 // 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.
 template<typename T>
 struct CallbackOutputTraits
     : public InheritIf<GenericCallbackOutputTraits<T>,
@@ skipping 14 matching lines @@
   static inline APIArgType StorageToAPIArg(StorageType& t) {
     return &t;
   }
 
   // Converts the PP_Var to a pp::Var object, passing any reference counted
   // object along with it. This must only be called once since there will only
   // be one reference that the browser has assigned to us for the out param!
   static inline pp::Var StorageToPluginArg(StorageType& t) {
     return Var(PASS_REF, t);
   }
+
+  static inline void Initialize(StorageType* t) {
+    *t = PP_MakeUndefined();
+  }
 };
 
 // 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.
   typedef PP_ArrayOutput APIArgType;
 
   // We store the array as this adapter which combines the PP_ArrayOutput
   // structure with the underlying std::vector that it will write into.
   typedef ArrayOutputAdapterWithStorage<T> StorageType;
 
   // Retrieves the PP_ArrayOutput interface for our vector object that the
   // browser will use to write into our code.
   static inline APIArgType StorageToAPIArg(StorageType& t) {
     return t.pp_array_output();
   }
 
   // Retrieves the underlying vector that can be passed to the plugin.
   static inline std::vector<T>& StorageToPluginArg(StorageType& t) {
     return t.output();
   }
+
+  static inline void Initialize(StorageType* /* t */) {}
 };
 
 // Output traits for all vectors of resource types. It is implemented to pass
 // a PP_ArrayOutput parameter to the browser, and convert the returned resources
 // to a vector of the given resource object type T when passing to the plugin.
 //
 // Note that this class is parameterized by the resource object, for example
 // ResourceVectorCallbackOutputTraits<pp::FileRef>. This is used as a base
 // class for CallbackOutputTraits below for the case where T is a derived
 // class of pp::Resource.
 template<typename T>
 struct ResourceVectorCallbackOutputTraits {
   typedef PP_ArrayOutput APIArgType;
   typedef ResourceArrayOutputAdapterWithStorage<T> StorageType;
 
   static inline APIArgType StorageToAPIArg(StorageType& t) {
     return t.pp_array_output();
   }
   static inline std::vector<T>& StorageToPluginArg(StorageType& t) {
     return t.output();
   }
+
+  static inline void Initialize(StorageType* /* t */) {}
 };
 
 // Specialization of CallbackOutputTraits for vectors. This struct covers both
 // arrays of resources and arrays of 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.
 template<typename T>
 struct CallbackOutputTraits< std::vector<T> >
     : public InheritIf<GenericVectorCallbackOutputTraits<T>,
@@ skipping 17 matching lines @@
   // Retrieves the PP_ArrayOutput interface for our vector object that the
   // browser will use to write into our code.
   static inline APIArgType StorageToAPIArg(StorageType& t) {
     return t.pp_array_output();
   }
 
   // Retrieves the underlying vector that can be passed to the plugin.
   static inline std::vector<pp::Var>& StorageToPluginArg(StorageType& t) {
     return t.output();
   }
+
+  static inline void Initialize(StorageType* /* t */) {}
 };
 
 }  // namespace internal
 }  // namespace pp
 
 #endif  // PPAPI_CPP_OUTPUT_TRAITS_H_