Create ppapi_proxy.dll.

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>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "ppapi/c/pp_var.h"
+#include "ppapi/proxy/ppapi_proxy_export.h"
 
 namespace IPC {
 class Message;
 }
 
 namespace ppapi {
 namespace proxy {
 
 class Dispatcher;
 class VarSerializationRules;
@@ skipping 30 matching lines @@
 // Constness
 // ---------
 // SerializedVar basically doesn't support const. Everything is mutable and
 // most functions are declared const. This unfortunateness is because of the
 // way the IPC system works. When deserializing, it will have a const
 // SerializedVar in a Tuple and this will be given to the function. We kind of
 // want to modify that to convert strings and do refcounting.
 //
 // The helper classes used for accessing the SerializedVar have more reasonable
 // behavior and will enforce that you don't do stupid things.
-class SerializedVar {
+class PPAPI_PROXY_EXPORT SerializedVar {
  public:
   SerializedVar();
   ~SerializedVar();
 
   // Backend implementation for IPC::ParamTraits<SerializedVar>.
   void WriteToMessage(IPC::Message* m) const {
     inner_->WriteToMessage(m);
   }
   bool ReadFromMessage(const IPC::Message* m, void** iter) {
     return inner_->ReadFromMessage(m, iter);
   }
 
  protected:
   friend class SerializedVarReceiveInput;
   friend class SerializedVarReturnValue;
   friend class SerializedVarOutParam;
   friend class SerializedVarSendInput;
   friend class SerializedVarTestConstructor;
   friend class SerializedVarVectorReceiveInput;
 
-  class Inner : public base::RefCounted<Inner> {
+  class PPAPI_PROXY_EXPORT Inner : public base::RefCounted<Inner> {
    public:
     Inner();
     Inner(VarSerializationRules* serialization_rules);
     Inner(VarSerializationRules* serialization_rules, const PP_Var& var);
     ~Inner();
 
     VarSerializationRules* serialization_rules() {
       return serialization_rules_;
     }
     void set_serialization_rules(VarSerializationRules* serialization_rules) {
@@ skipping 109 matching lines @@
 // Example for API:
 //   PP_Var MyFunction()
 // IPC message:
 //   IPC_SYNC_MESSAGE_ROUTED0_1(MyFunction, SerializedVar);
 // Message handler would be:
 //   PP_Var MyFunctionProxy() {
 //     ReceiveSerializedVarReturnValue result;
 //     Send(new MyFunctionMsg(&result));
 //     return result.Return(dispatcher());
 //   }
-class ReceiveSerializedVarReturnValue : public SerializedVar {
+class PPAPI_PROXY_EXPORT ReceiveSerializedVarReturnValue
+    : public SerializedVar {
  public:
   // Note that we can't set the dispatcher in the constructor because the
   // data will be overridden when the return value is set. This constructor is
   // normally used in the pattern above (operator= will be implicitly invoked
   // when the sync message writes the output values).
   ReceiveSerializedVarReturnValue();
 
   // This constructor can be used when deserializing manually. This is useful
   // when you're getting strings "returned" via a struct and need to manually
   // get the PP_Vars out. In this case just do:
@@ skipping 70 matching lines @@
 // For receiving a value from the remote side.
 //
 // Example for API:
 //   void MyFunction(PP_Var)
 // IPC message:
 //   IPC_MESSAGE_ROUTED1(MyFunction, SerializedVar);
 // Message handler would be:
 //   void OnMsgMyFunction(SerializedVarReceiveInput param) {
 //     MyFunction(param.Get());
 //   }
-class SerializedVarReceiveInput {
+class PPAPI_PROXY_EXPORT SerializedVarReceiveInput {
  public:
   // We rely on the implicit constructor here since the IPC layer will call
   // us with a SerializedVar. Pass this object by value, the copy constructor
   // will pass along the pointer (as cheap as passing a pointer arg).
   SerializedVarReceiveInput(const SerializedVar& serialized);
   ~SerializedVarReceiveInput();
 
   PP_Var Get(Dispatcher* dispatcher);
 
  private:
@@ skipping 35 matching lines @@
 // ReceiveSerializedVarReturnValue.
 //
 // Example for API:
 //   PP_Var MyFunction()
 // IPC message:
 //   IPC_SYNC_MESSAGE_ROUTED0_1(MyFunction, SerializedVar);
 // Message handler would be:
 //   void OnMsgMyFunction(SerializedVarReturnValue result) {
 //     result.Return(dispatcher(), MyFunction());
 //   }
-class SerializedVarReturnValue {
+class PPAPI_PROXY_EXPORT SerializedVarReturnValue {
  public:
   // We rely on the implicit constructor here since the IPC layer will call
   // us with a SerializedVar*. Pass this object by value, the copy constructor
   // will pass along the pointer (as cheap as passing a pointer arg).
   SerializedVarReturnValue(SerializedVar* serialized);
 
   void Return(Dispatcher* dispatcher, const PP_Var& var);
 
   // Helper function for code that doesn't use the pattern above, but gets
   // a return value from the remote side via a struct. You can pass in the
   // SerializedVar and a PP_Var will be created with return value semantics.
   static SerializedVar Convert(Dispatcher* dispatcher, const PP_Var& var);
 
  private:
   SerializedVar* serialized_;
 };
 
 // For writing an out param to the remote side.
 //
 // Example for API:
 //   "void MyFunction(PP_Var* out);"
 // IPC message:
 //   IPC_SYNC_MESSAGE_ROUTED0_1(MyFunction, SerializedVar);
 // Message handler would be:
 //   void OnMsgMyFunction(SerializedVarOutParam out_param) {
 //     MyFunction(out_param.OutParam(dispatcher()));
 //   }
-class SerializedVarOutParam {
+class PPAPI_PROXY_EXPORT SerializedVarOutParam {
  public:
   // We rely on the implicit constructor here since the IPC layer will call
   // us with a SerializedVar*. Pass this object by value, the copy constructor
   // will pass along the pointer (as cheap as passing a pointer arg).
   SerializedVarOutParam(SerializedVar* serialized);
   ~SerializedVarOutParam();
 
   // Call this function only once. The caller should write its result to the
   // returned var pointer before this class goes out of scope. The var's
   // initial value will be VARTYPE_UNDEFINED.
@@ skipping 24 matching lines @@
   Dispatcher* dispatcher_;
   std::vector<SerializedVar>* serialized_;
 
   uint32_t count_;
   PP_Var* array_;
 };
 
 // For tests that just want to construct a SerializedVar for giving it to one
 // of the other classes. This emulates a SerializedVar just received over the
 // wire from another process.
-class SerializedVarTestConstructor : public SerializedVar {
+class PPAPI_PROXY_EXPORT SerializedVarTestConstructor : public SerializedVar {
  public:
   // For POD-types and objects.
   explicit SerializedVarTestConstructor(const PP_Var& pod_var);
 
   // For strings.
   explicit SerializedVarTestConstructor(const std::string& str);
 };
 
 // For tests that want to read what's in a SerializedVar.
-class SerializedVarTestReader : public SerializedVar {
+class PPAPI_PROXY_EXPORT SerializedVarTestReader : public SerializedVar {
  public:
   explicit SerializedVarTestReader(const SerializedVar& var);
 
   // The "incomplete" var is the one sent over the wire. Strings and object
   // IDs have not yet been converted, so this is the thing that tests will
   // actually want to check.
   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_