Add exports needed for glue to build as a component.

webkit/plugins/ppapi/npapi_glue.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 WEBKIT_PLUGINS_PPAPI_NPAPI_GLUE_H_
 #define WEBKIT_PLUGINS_PPAPI_NPAPI_GLUE_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "ppapi/c/pp_module.h"
 #include "ppapi/c/pp_var.h"
+#include "webkit/plugins/webkit_plugins_export.h"
 
 struct NPObject;
 typedef struct _NPVariant NPVariant;
 typedef void* NPIdentifier;
 
 namespace webkit {
 namespace ppapi {
 
 class PluginInstance;
 class PluginObject;
 
 // Utilities -------------------------------------------------------------------
 
 // Converts the given PP_Var to an NPVariant, returning true on success.
 // False means that the given variant is invalid. In this case, the result
 // NPVariant will be set to a void one.
 //
 // The contents of the PP_Var will be copied unless the PP_Var corresponds to
 // an object.
 bool PPVarToNPVariant(PP_Var var, NPVariant* result);
 
 // Returns a PP_Var that corresponds to the given NPVariant. The contents of
 // the NPVariant will be copied unless the NPVariant corresponds to an
 // object. This will handle all Variant types including POD, strings, and
 // objects.
 //
 // The returned PP_Var will have a refcount of 1, this passing ownership of
 // the reference to the caller. This is suitable for returning to a plugin.
-PP_Var NPVariantToPPVar(PluginInstance* instance, const NPVariant* variant);
+WEBKIT_PLUGINS_EXPORT PP_Var NPVariantToPPVar(PluginInstance* instance,
+                                              const NPVariant* variant);
 
 // Returns a NPIdentifier that corresponds to the given PP_Var. The contents
 // of the PP_Var will be copied. Returns 0 if the given PP_Var is not a a
 // string or integer type.
 NPIdentifier PPVarToNPIdentifier(PP_Var var);
 
 // Returns a PP_Var corresponding to the given identifier. In the case of
 // a string identifier, the string will be allocated associated with the
 // given module. A returned string will have a reference count of 1.
 PP_Var NPIdentifierToPPVar(PP_Module module, NPIdentifier id);
 
 // Helper function to create a PP_Var of type object that contains the given
 // NPObject for use byt he given module. Calling this function multiple times
 // given the same module + NPObject results in the same PP_Var, assuming that
 // there is still a PP_Var with a reference open to it from the previous
 // call.
 //
 // The module is necessary because we can have different modules pointing to
 // the same NPObject, and we want to keep their refs separate.
 //
 // If no ObjectVar currently exists corresponding to the NPObject, one is
 // created associated with the given module.
 //
 // Note: this could easily be changed to take a PP_Instance instead if that
 // makes certain calls in the future easier. Currently all callers have a
 // PluginInstance so that's what we use here.
-PP_Var NPObjectToPPVar(PluginInstance* instance, NPObject* object);
+WEBKIT_PLUGINS_EXPORT PP_Var NPObjectToPPVar(PluginInstance* instance,
+                                             NPObject* object);
 
 // PPResultAndExceptionToNPResult ----------------------------------------------
 
 // Convenience object for converting a PPAPI call that can throw an exception
 // and optionally return a value, back to the NPAPI layer which expects a
 // NPVariant as a result.
 //
 // Normal usage is that you will pass the result of exception() to the
 // PPAPI function as the exception output parameter. Then you will either
 // call SetResult with the result of the PPAPI call, or
@@ skipping 193 matching lines @@
   bool has_exception_;
 
   // May be null if the consumer isn't interesting in catching exceptions.
   PP_Var* exception_;
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_PPAPI_NPAPI_GLUE_H_