Move webkit/plugins/ppapi to content/renderer/pepper.

content/renderer/pepper/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_
+#ifndef CONTENT_RENDERER_PEPPER_NPAPI_GLUE_H_
+#define CONTENT_RENDERER_PEPPER_NPAPI_GLUE_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "content/common/content_export.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 PluginInstanceImpl;
 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.
-WEBKIT_PLUGINS_EXPORT PP_Var NPVariantToPPVar(PluginInstanceImpl* instance,
-                                              const NPVariant* variant);
+PP_Var NPVariantToPPVar(PluginInstanceImpl* 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 returned string will have a reference count of 1.
 PP_Var NPIdentifierToPPVar(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 instance is necessary because we can have different instances 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.
-WEBKIT_PLUGINS_EXPORT PP_Var NPObjectToPPVar(PluginInstanceImpl* instance,
-                                             NPObject* object);
+CONTENT_EXPORT PP_Var NPObjectToPPVar(PluginInstanceImpl* instance,
+                                      NPObject* object);
 
 // This version creates a default v8::Context rather than using the one from
 // the container of |instance|. It is only for use in unit tests, where we don't
 // have a real container for |instance|.
-WEBKIT_PLUGINS_EXPORT PP_Var NPObjectToPPVarForTest(
-    PluginInstanceImpl* instance,
-    NPObject* object);
+CONTENT_EXPORT PP_Var NPObjectToPPVarForTest(PluginInstanceImpl* 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 170 matching lines @@
   // the exception itself has been stored.
   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_
+#endif  // CONTENT_RENDERER_PEPPER_NPAPI_GLUE_H_