Move the Pepper implementation from webkit/glue/plugins/pepper_* to...

webkit/plugins/ppapi/var.h

 // Copyright (c) 2010 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_GLUE_PLUGINS_PEPPER_VAR_H_
-#define WEBKIT_GLUE_PLUGINS_PEPPER_VAR_H_
+#ifndef WEBKIT_PLUGINS_PPAPI_VAR_H_
+#define WEBKIT_PLUGINS_PPAPI_VAR_H_
 
 #include <string>
 
-#include "webkit/glue/plugins/pepper_resource.h"
+#include "webkit/plugins/ppapi/resource.h"
 
 struct PP_Var;
 struct PPB_Var;
 struct PPB_Var_Deprecated;
 typedef struct NPObject NPObject;
 typedef struct _NPVariant NPVariant;
 typedef void* NPIdentifier;
 
-namespace pepper {
+namespace webkit {
+namespace plugins {
+namespace ppapi {
 
 // Var -------------------------------------------------------------------------
 
 // Represents a non-POD var. This is derived from a resource even though it
 // isn't a resource from the plugin's perspective. This allows us to re-use
 // the refcounting and the association with the module from the resource code.
 class Var : public Resource {
  public:
   virtual ~Var();
 
   // Resource overrides.
-  virtual Var* AsVar() { return this; }
+  virtual Var* AsVar();
 
   // 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.
   static PP_Var NPVariantToPPVar(PluginModule* module,
                                  const NPVariant* variant);
@@ skipping 65 matching lines @@
 //     return false;  // Not a string or an invalid var.
 //   DoSomethingWithTheString(string->value());
 class StringVar : public Var {
  public:
   StringVar(PluginModule* module, const char* str, uint32 len);
   virtual ~StringVar();
 
   const std::string& value() const { return value_; }
 
   // Resource overrides.
-  virtual StringVar* AsStringVar() { return this; }
+  virtual StringVar* AsStringVar();
 
   // Helper function to create a PP_Var of type string that contains a copy of
   // the given string. The input data must be valid UTF-8 encoded text, if it
   // is not valid UTF-8, a NULL var will be returned.
   //
   // The return value will have a reference count of 1. Internally, this will
   // create a StringVar, associate it with a module, and return the reference
   // to it in the var.
   static PP_Var StringToPPVar(PluginModule* module, const std::string& str);
   static PP_Var StringToPPVar(PluginModule* module,
@@ skipping 19 matching lines @@
 // given module and free them when the plugin exits independently of other
 // plugins that may be running at the same time.
 //
 // See StringVar for examples, except obviously using NPObjects instead of
 // strings.
 class ObjectVar : public Var {
  public:
   virtual ~ObjectVar();
 
   // Resource overrides.
-  virtual ObjectVar* AsObjectVar() { return this; }
+  virtual ObjectVar* AsObjectVar();
 
   // Returns the underlying NPObject corresponding to this ObjectVar.
   // Guaranteed non-NULL.
   NPObject* np_object() const { return np_object_; }
 
   // 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.
@@ skipping 71 matching lines @@
   // True if an exception has been thrown. Since the exception itself may be
   // NULL if the plugin isn't interested in getting the exception, this will
   // always indicate if SetException has been called, regardless of whether
   // 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 pepper
+}  // namespace ppapi
+}  // namespace plugins
+}  // namespace webkit
 
-#endif  // WEBKIT_GLUE_PLUGINS_PEPPER_VAR_H_
+#endif  // WEBKIT_PLUGINS_PPAPI_VAR_H_