From 9b6db26fcc22a7a4ec0510a93733b2e190d9e649 Mon Sep 17 00:00:00 2001 From: "brettw@chromium.org" Date: Mon, 11 Apr 2011 04:27:47 +0000 Subject: Create a VarPrivate interface to contain the scripting helper functions of Var. Currently, the old functions are left in Var. When people have a chance to move to this new API, we can delete them from Var. This also adds new enums for ARRAY and DICTIONARY vars, and makes the var C++ wrapper forward-compatible with them by refcounting any enums that it doesn't know about. Review URL: http://codereview.chromium.org/6823016 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@81068 0039d316-1c4b-4281-b951-d872f2087c98 --- ppapi/cpp/private/var_private.cc | 186 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 186 insertions(+) create mode 100644 ppapi/cpp/private/var_private.cc (limited to 'ppapi/cpp/private/var_private.cc') diff --git a/ppapi/cpp/private/var_private.cc b/ppapi/cpp/private/var_private.cc new file mode 100644 index 0000000..c3da55d --- /dev/null +++ b/ppapi/cpp/private/var_private.cc @@ -0,0 +1,186 @@ +// 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. + +#include "ppapi/cpp/private/var_private.h" + +#include "ppapi/c/dev/ppb_var_deprecated.h" +#include "ppapi/cpp/instance.h" +#include "ppapi/cpp/logging.h" +#include "ppapi/cpp/module_impl.h" +#include "ppapi/cpp/dev/scriptable_object_deprecated.h" + +namespace pp { + +namespace { + +template <> const char* interface_name() { + return PPB_VAR_DEPRECATED_INTERFACE; +} + +} // namespace + +using namespace deprecated; + +VarPrivate::VarPrivate(Instance* instance, ScriptableObject* object) { + if (has_interface()) { + var_ = get_interface()->CreateObject( + instance->pp_instance(), object->GetClass(), object); + needs_release_ = true; + } else { + var_.type = PP_VARTYPE_NULL; + var_.padding = 0; + needs_release_ = false; + } +} + +ScriptableObject* VarPrivate::AsScriptableObject() const { + if (!is_object()) { + PP_NOTREACHED(); + } else if (has_interface()) { + void* object = NULL; + if (get_interface()->IsInstanceOf( + var_, ScriptableObject::GetClass(), &object)) { + return reinterpret_cast(object); + } + } + return NULL; +} + +bool VarPrivate::HasProperty(const Var& name, Var* exception) const { + if (!has_interface()) + return false; + return get_interface()->HasProperty( + var_, name.pp_var(), OutException(exception).get()); +} + +bool VarPrivate::HasMethod(const Var& name, Var* exception) const { + if (!has_interface()) + return false; + return get_interface()->HasMethod( + var_, name.pp_var(), OutException(exception).get()); +} + +VarPrivate VarPrivate::GetProperty(const Var& name, Var* exception) const { + if (!has_interface()) + return Var(); + return Var(PassRef(), get_interface()->GetProperty( + var_, name.pp_var(), OutException(exception).get())); +} + +void VarPrivate::GetAllPropertyNames(std::vector* properties, + Var* exception) const { + if (!has_interface()) + return; + PP_Var* props = NULL; + uint32_t prop_count = 0; + get_interface()->GetAllPropertyNames( + var_, &prop_count, &props, OutException(exception).get()); + if (!prop_count) + return; + properties->resize(prop_count); + for (uint32_t i = 0; i < prop_count; ++i) { + Var temp(PassRef(), props[i]); + (*properties)[i] = temp; + } + Module::Get()->core()->MemFree(props); +} + +void VarPrivate::SetProperty(const Var& name, const Var& value, + Var* exception) { + if (!has_interface()) + return; + get_interface()->SetProperty( + var_, name.pp_var(), value.pp_var(), OutException(exception).get()); +} + +void VarPrivate::RemoveProperty(const Var& name, Var* exception) { + if (!has_interface()) + return; + get_interface()->RemoveProperty( + var_, name.pp_var(), OutException(exception).get()); +} + +VarPrivate VarPrivate::Call(const Var& method_name, uint32_t argc, Var* argv, + Var* exception) { + if (!has_interface()) + return Var(); + if (argc > 0) { + std::vector args; + args.reserve(argc); + for (size_t i = 0; i < argc; i++) + args.push_back(argv[i].pp_var()); + return Var(PassRef(), get_interface()->Call( + var_, method_name.pp_var(), argc, &args[0], + OutException(exception).get())); + } else { + // Don't try to get the address of a vector if it's empty. + return Var(PassRef(), get_interface()->Call( + var_, method_name.pp_var(), 0, NULL, + OutException(exception).get())); + } +} + +VarPrivate VarPrivate::Construct(uint32_t argc, Var* argv, + Var* exception) const { + if (!has_interface()) + return Var(); + if (argc > 0) { + std::vector args; + args.reserve(argc); + for (size_t i = 0; i < argc; i++) + args.push_back(argv[i].pp_var()); + return Var(PassRef(), get_interface()->Construct( + var_, argc, &args[0], OutException(exception).get())); + } else { + // Don't try to get the address of a vector if it's empty. + return Var(PassRef(), get_interface()->Construct( + var_, 0, NULL, OutException(exception).get())); + } +} + +VarPrivate VarPrivate::Call(const Var& method_name, Var* exception) { + if (!has_interface()) + return Var(); + return Var(PassRef(), get_interface()->Call( + var_, method_name.pp_var(), 0, NULL, OutException(exception).get())); +} + +VarPrivate VarPrivate::Call(const Var& method_name, const Var& arg1, + Var* exception) { + if (!has_interface()) + return Var(); + PP_Var args[1] = {arg1.pp_var()}; + return Var(PassRef(), get_interface()->Call( + var_, method_name.pp_var(), 1, args, OutException(exception).get())); +} + +VarPrivate VarPrivate::Call(const Var& method_name, const Var& arg1, + const Var& arg2, Var* exception) { + if (!has_interface()) + return Var(); + PP_Var args[2] = {arg1.pp_var(), arg2.pp_var()}; + return Var(PassRef(), get_interface()->Call( + var_, method_name.pp_var(), 2, args, OutException(exception).get())); +} + +VarPrivate VarPrivate::Call(const Var& method_name, const Var& arg1, + const Var& arg2, const Var& arg3, Var* exception) { + if (!has_interface()) + return Var(); + PP_Var args[3] = {arg1.pp_var(), arg2.pp_var(), arg3.pp_var()}; + return Var(PassRef(), get_interface()->Call( + var_, method_name.pp_var(), 3, args, OutException(exception).get())); +} + +VarPrivate VarPrivate::Call(const Var& method_name, const Var& arg1, + const Var& arg2, const Var& arg3, const Var& arg4, + Var* exception) { + if (!has_interface()) + return Var(); + PP_Var args[4] = {arg1.pp_var(), arg2.pp_var(), arg3.pp_var(), arg4.pp_var()}; + return Var(PassRef(), get_interface()->Call( + var_, method_name.pp_var(), 4, args, OutException(exception).get())); +} + +} // namespace pp -- cgit v1.1