summaryrefslogtreecommitdiffstats
path: root/webkit/glue/plugins/pepper_var.h
diff options
context:
space:
mode:
Diffstat (limited to 'webkit/glue/plugins/pepper_var.h')
-rw-r--r--webkit/glue/plugins/pepper_var.h251
1 files changed, 0 insertions, 251 deletions
diff --git a/webkit/glue/plugins/pepper_var.h b/webkit/glue/plugins/pepper_var.h
deleted file mode 100644
index 8929448..0000000
--- a/webkit/glue/plugins/pepper_var.h
+++ /dev/null
@@ -1,251 +0,0 @@
-// 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_
-
-#include <string>
-
-#include "webkit/glue/plugins/pepper_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 {
-
-// 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; }
-
- // 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);
-
- // 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.
- static 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.
- static PP_Var NPIdentifierToPPVar(PluginModule* module, NPIdentifier id);
-
- // Provides access to the manual refcounting of a PP_Var from the plugin's
- // perspective. This is different than the AddRef/Release on this scoped
- // object. This uses the ResourceTracker, which keeps a separate "plugin
- // refcount" that prevents the plugin from messing up our refcounting or
- // freeing something out from under us.
- //
- // You should not generally need to use these functions. However, if you
- // call a plugin function that returns a var, it will transfer a ref to us
- // (the caller) which in the case of a string or object var will need to
- // be released.
- //
- // Example, assuming we're expecting the plugin to return a string:
- // PP_Var rv = some_ppp_interface->DoSomething(a, b, c);
- //
- // // Get the string value. This will take a reference to the object which
- // // will prevent it from being deleted out from under us when we call
- // // PluginReleasePPVar().
- // scoped_refptr<StringVar> string(StringVar::FromPPVar(rv));
- //
- // // Release the reference the plugin gave us when returning the value.
- // // This is legal to do for all types of vars.
- // Var::PluginReleasePPVar(rv);
- //
- // // Use the string.
- // if (!string)
- // return false; // It didn't return a proper string.
- // UseTheString(string->value());
- static void PluginAddRefPPVar(PP_Var var);
- static void PluginReleasePPVar(PP_Var var);
-
- // Returns the PPB_Var_Deprecated interface for the plugin to use.
- static const PPB_Var_Deprecated* GetDeprecatedInterface();
-
- // Returns the PPB_Var interface for the plugin to use.
- static const PPB_Var* GetInterface();
-
- protected:
- // This can only be constructed as a StringVar or an ObjectVar.
- explicit Var(PluginModule* module);
-
- private:
- DISALLOW_COPY_AND_ASSIGN(Var);
-};
-
-// StringVar -------------------------------------------------------------------
-
-// Represents a string-based Var.
-//
-// Returning a given string as a PP_Var:
-// return StringVar::StringToPPVar(module, my_string);
-//
-// Converting a PP_Var to a string:
-// scoped_refptr<StringVar> string(StringVar::FromPPVar(var));
-// if (!string)
-// 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; }
-
- // 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,
- const char* str, uint32 len);
-
- // Helper function that converts a PP_Var to a string. This will return NULL
- // if the PP_Var is not of string type or the string is invalid.
- static scoped_refptr<StringVar> FromPPVar(PP_Var var);
-
- private:
- std::string value_;
-
- DISALLOW_COPY_AND_ASSIGN(StringVar);
-};
-
-// ObjectVar -------------------------------------------------------------------
-
-// Represents a JavaScript object Var. By itself, this represents random
-// NPObjects that a given plugin (identified by the resource's module) wants to
-// reference. If two different modules reference the same NPObject (like the
-// "window" object), then there will be different ObjectVar's (and hence PP_Var
-// IDs) for each module. This allows us to track all references owned by a
-// 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; }
-
- // 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.
- //
- // 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.
- static PP_Var NPObjectToPPVar(PluginModule* module, NPObject* object);
-
- // Helper function that converts a PP_Var to an object. This will return NULL
- // if the PP_Var is not of object type or the object is invalid.
- static scoped_refptr<ObjectVar> FromPPVar(PP_Var var);
-
- protected:
- // You should always use FromNPObject to create an ObjectVar. This function
- // guarantees that we maintain the 1:1 mapping between NPObject and
- // ObjectVar.
- ObjectVar(PluginModule* module, NPObject* np_object);
-
- private:
- // Guaranteed non-NULL, this is the underlying object used by WebKit. We
- // hold a reference to this object.
- NPObject* np_object_;
-
- DISALLOW_COPY_AND_ASSIGN(ObjectVar);
-};
-
-// TryCatch --------------------------------------------------------------------
-
-// Instantiate this object on the stack to catch V8 exceptions and pass them
-// to an optional out parameter supplied by the plugin.
-class TryCatch {
- public:
- // The given exception may be NULL if the consumer isn't interested in
- // catching exceptions. If non-NULL, the given var will be updated if any
- // exception is thrown (so it must outlive the TryCatch object).
- //
- // The module associated with the exception is passed so we know which module
- // to associate any exception string with. It may be NULL if you don't know
- // the module at construction time, in which case you should set it later
- // by calling set_module().
- //
- // If an exception is thrown when the module is NULL, setting *any* exception
- // will result in using the InvalidObjectException.
- TryCatch(PluginModule* module, PP_Var* exception);
- ~TryCatch();
-
- // Get and set the module. This may be NULL (see the constructor).
- PluginModule* module() { return module_; }
- void set_module(PluginModule* module) { module_ = module; }
-
- // Returns true is an exception has been thrown. This can be true immediately
- // after construction if the var passed to the constructor is non-void.
- bool has_exception() const { return has_exception_; }
-
- // Sets the given exception. If no module has been set yet, the message will
- // be ignored (since we have no module to associate the string with) and the
- // SetInvalidObjectException() will be used instead.
- //
- // If an exception has been previously set, this function will do nothing
- // (normally you want only the first exception).
- void SetException(const char* message);
-
- // Sets the exception to be a generic message contained in a magic string
- // not associated with any module.
- void SetInvalidObjectException();
-
- private:
- static void Catch(void* self, const char* message);
-
- PluginModule* module_;
-
- // 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
-
-#endif // WEBKIT_GLUE_PLUGINS_PEPPER_VAR_H_