PPAPI: Initialize CompletionCallbackWithOutput storage

ppapi/tests/test_utils.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_TESTS_TEST_UTILS_H_
 #define PPAPI_TESTS_TEST_UTILS_H_
 
 #include <string>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
@@ skipping 170 matching lines @@
   Delegate* delegate_;
   pp::MessageLoop target_loop_;
 };
 
 namespace internal {
 
 template <typename OutputT, typename CallbackT>
 class TestCompletionCallbackWithOutputBase {
  public:
   explicit TestCompletionCallbackWithOutputBase(PP_Instance instance)
-      : callback_(instance) {
+      : callback_(instance),
+        output_storage_() {
+    CallbackT::TraitsType::Initialize(&output_storage_);
   }
 
   TestCompletionCallbackWithOutputBase(PP_Instance instance, bool force_async)
-      : callback_(instance, force_async) {
+      : callback_(instance, force_async),
+        output_storage_() {
+    CallbackT::TraitsType::Initialize(&output_storage_);
   }
 
   TestCompletionCallbackWithOutputBase(PP_Instance instance,
                                        CallbackType callback_type)
-      : callback_(instance, callback_type) {
+      : callback_(instance, callback_type),
+        output_storage_() {
+    CallbackT::TraitsType::Initialize(&output_storage_);
   }
 
   CallbackT GetCallback();
   OutputT output() {
     return CallbackT::TraitsType::StorageToPluginArg(
         output_storage_);
   }
 
   // Delegate functions to TestCompletionCallback
   void SetDelegate(TestCompletionCallback::Delegate* delegate) {
     callback_.SetDelegate(delegate);
   }
   void WaitForResult(int32_t result) { callback_.WaitForResult(result); }
   void WaitForAbortResult(int32_t result) {
     callback_.WaitForAbortResult(result);
   }
   bool failed() { return callback_.failed(); }
   const std::string& errors() { return callback_.errors(); }
   int32_t result() const { return callback_.result(); }
-  void Reset() { return callback_.Reset(); }
+  void Reset() {
+    CallbackT::TraitsType::Initialize(&output_storage_);
+    return callback_.Reset();
+  }
 
  private:
   TestCompletionCallback callback_;
   typename CallbackT::OutputStorageType output_storage_;
 };
 
 template <typename OutputT, typename CallbackT>
 CallbackT
 TestCompletionCallbackWithOutputBase<OutputT, CallbackT>::GetCallback() {
-  callback_.Reset();
+  this->Reset();
   if (callback_.callback_type() == PP_BLOCKING) {
     CallbackT cc(&output_storage_);
     return cc;
   }
 
   callback_.set_target_loop(pp::MessageLoop::GetCurrent());
   CallbackT cc(&TestCompletionCallback::Handler, this, &output_storage_);
   if (callback_.callback_type() == PP_OPTIONAL)
     cc.set_flags(PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
   return cc;
@@ skipping 81 matching lines @@
 #error Please add support for your platform in ppapi/tests/test_utils.h
 #endif
 
 /* These are used to determine POSIX-like implementations vs Windows. */
 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
     defined(__OpenBSD__) || defined(__sun) || defined(__native_client__)
 #define PPAPI_POSIX 1
 #endif
 
 #endif  // PPAPI_TESTS_TEST_UTILS_H_