Add GetLiveVars to PPB_Testing_Dev. Fix leaks it uncovered.

ppapi/proxy/serialized_var.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_SERIALIZED_VAR_H_
 #define PPAPI_PROXY_SERIALIZED_VAR_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 166 matching lines @@
 // For sending a value to the remote side.
 //
 // Example for API:
 //   void MyFunction(PP_Var)
 // IPC message:
 //   IPC_MESSAGE_ROUTED1(MyFunction, SerializedVar);
 // Sender would be:
 //   void MyFunctionProxy(PP_Var param) {
 //     Send(new MyFunctionMsg(SerializedVarSendInput(dispatcher, param));
 //   }
-class SerializedVarSendInput : public SerializedVar {
+class PPAPI_PROXY_EXPORT SerializedVarSendInput : public SerializedVar {
  public:
   SerializedVarSendInput(Dispatcher* dispatcher, const PP_Var& var);
 
   // Helper function for serializing a vector of input vars for serialization.
   static void ConvertVector(Dispatcher* dispatcher,
                             const PP_Var* input,
                             size_t input_count,
                             std::vector<SerializedVar>* output);
 
  private:
@@ skipping 38 matching lines @@
 
 // Example for API:
 //   "void MyFunction(PP_Var* exception);"
 // IPC message:
 //   IPC_SYNC_MESSAGE_ROUTED0_1(MyFunction, SerializedVar);
 // Message handler would be:
 //   void OnMsgMyFunction(PP_Var* exception) {
 //     ReceiveSerializedException se(dispatcher(), exception)
 //     Send(new PpapiHostMsg_Foo(&se));
 //   }
-class ReceiveSerializedException : public SerializedVar {
+class PPAPI_PROXY_EXPORT ReceiveSerializedException : public SerializedVar {
  public:
   ReceiveSerializedException(Dispatcher* dispatcher, PP_Var* exception);
   ~ReceiveSerializedException();
 
   // Returns true if the exception passed in the constructor is set. Check
   // this before actually issuing the IPC.
   bool IsThrown() const;
 
  private:
   Dispatcher* dispatcher_;
@@ skipping 10 matching lines @@
 //
 // Example for API:
 //   "void MyFunction(uint32_t* count, PP_Var** vars);"
 // IPC message:
 //   IPC_SYNC_MESSAGE_ROUTED0_1(MyFunction, std::vector<SerializedVar>);
 // Proxy function:
 //   void MyFunction(uint32_t* count, PP_Var** vars) {
 //     ReceiveSerializedVarVectorOutParam vect(dispatcher, count, vars);
 //     Send(new MyMsg(vect.OutParam()));
 //   }
-class ReceiveSerializedVarVectorOutParam {
+class PPAPI_PROXY_EXPORT ReceiveSerializedVarVectorOutParam {
  public:
   ReceiveSerializedVarVectorOutParam(Dispatcher* dispatcher,
                                      uint32_t* output_count,
                                      PP_Var** output);
   ~ReceiveSerializedVarVectorOutParam();
 
   std::vector<SerializedVar>* OutParam();
 
  private:
   Dispatcher* dispatcher_;
@@ skipping 38 matching lines @@
 };
 
 // For receiving an input vector of vars from the remote side.
 //
 // Example:
 //   OnMsgMyFunction(SerializedVarVectorReceiveInput vector) {
 //     uint32_t size;
 //     PP_Var* array = vector.Get(dispatcher, &size);
 //     MyFunction(size, array);
 //   }
-class SerializedVarVectorReceiveInput {
+class PPAPI_PROXY_EXPORT SerializedVarVectorReceiveInput {
  public:
   SerializedVarVectorReceiveInput(const std::vector<SerializedVar>& serialized);
   ~SerializedVarVectorReceiveInput();
 
   // Only call Get() once. It will return a pointer to the converted array and
   // place the array size in the out param. Will return NULL when the array is
   // empty.
   PP_Var* Get(Dispatcher* dispatcher, uint32_t* array_size);
 
  private:
@@ skipping 61 matching lines @@
   // This is the value actually written by the code and returned by OutParam.
   // We'll write this into serialized_ in our destructor.
   PP_Var writable_var_;
 
   Dispatcher* dispatcher_;
 };
 
 // For returning an array of PP_Vars to the other side and transferring
 // ownership.
 //
-class SerializedVarVectorOutParam {
+class PPAPI_PROXY_EXPORT SerializedVarVectorOutParam {
  public:
   SerializedVarVectorOutParam(std::vector<SerializedVar>* serialized);
   ~SerializedVarVectorOutParam();
 
   uint32_t* CountOutParam() { return &count_; }
   PP_Var** ArrayOutParam(Dispatcher* dispatcher);
 
  private:
   Dispatcher* dispatcher_;
   std::vector<SerializedVar>* serialized_;
@@ skipping 25 matching lines @@
   PP_Var GetIncompleteVar() const { return inner_->GetIncompleteVar(); }
 
   const std::string& GetString() const { return inner_->GetString(); }
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_SERIALIZED_VAR_H_