1// Copyright (c) 2011 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "ppapi/cpp/dev/scriptable_object_deprecated.h"
6#include "ppapi/c/dev/ppb_memory_dev.h"
7#include "ppapi/c/dev/ppp_class_deprecated.h"
8#include "ppapi/cpp/module.h"
9#include "ppapi/cpp/var.h"
10
11namespace pp {
12
13namespace deprecated {
14
15namespace {
16
17// Allows converting an output param of a Var to an output param of a PP_Var
18// for exceptions. The object is only copied if it is not void, which we
19// take to mean an exception occurred.
20class ExceptionConverter {
21 public:
22  ExceptionConverter(PP_Var* out) : out_(out) {
23  }
24  ~ExceptionConverter() {
25    if (!exception_.is_undefined())
26      *out_ = exception_.Detach();
27  }
28
29  Var* Get() { return &exception_; }
30
31 private:
32  PP_Var* out_;
33  Var exception_;
34};
35
36// Used internally to convert a C-style array of PP_Var to a vector of Var.
37void ArgListToVector(uint32_t argc, PP_Var* argv, std::vector<Var>* output) {
38  output->reserve(argc);
39  for (size_t i = 0; i < argc; i++)
40    output->push_back(Var(Var::DontManage(), argv[i]));
41}
42
43bool HasProperty(void* object, PP_Var name, PP_Var* exception) {
44  ExceptionConverter e(exception);
45  return static_cast<ScriptableObject*>(object)->HasProperty(
46      Var(Var::DontManage(), name), e.Get());
47}
48
49bool HasMethod(void* object, PP_Var name, PP_Var* exception) {
50  ExceptionConverter e(exception);
51  return static_cast<ScriptableObject*>(object)->HasMethod(
52      Var(Var::DontManage(), name), e.Get());
53}
54
55PP_Var GetProperty(void* object,
56                   PP_Var name,
57                   PP_Var* exception) {
58  ExceptionConverter e(exception);
59  return static_cast<ScriptableObject*>(object)->GetProperty(
60      Var(Var::DontManage(), name), e.Get()).Detach();
61}
62
63void GetAllPropertyNames(void* object,
64                         uint32_t* property_count,
65                         PP_Var** properties,
66                         PP_Var* exception) {
67  ExceptionConverter e(exception);
68  std::vector<Var> props;
69  static_cast<ScriptableObject*>(object)->GetAllPropertyNames(&props, e.Get());
70  if (props.empty())
71    return;
72  *property_count = static_cast<uint32_t>(props.size());
73
74  const PPB_Memory_Dev* memory_if = static_cast<const PPB_Memory_Dev*>(
75      pp::Module::Get()->GetBrowserInterface(PPB_MEMORY_DEV_INTERFACE));
76  *properties = static_cast<PP_Var*>(
77      memory_if->MemAlloc(sizeof(PP_Var) * props.size()));
78
79  for (size_t i = 0; i < props.size(); ++i)
80    (*properties)[i] = props[i].Detach();
81}
82
83void SetProperty(void* object,
84                 PP_Var name,
85                 PP_Var value,
86                 PP_Var* exception) {
87  ExceptionConverter e(exception);
88  static_cast<ScriptableObject*>(object)->SetProperty(
89      Var(Var::DontManage(), name), Var(Var::DontManage(), value), e.Get());
90}
91
92void RemoveProperty(void* object,
93                    PP_Var name,
94                    PP_Var* exception) {
95  ExceptionConverter e(exception);
96  static_cast<ScriptableObject*>(object)->RemoveProperty(
97      Var(Var::DontManage(), name), e.Get());
98}
99
100PP_Var Call(void* object,
101            PP_Var method_name,
102            uint32_t argc,
103            PP_Var* argv,
104            PP_Var* exception) {
105  ExceptionConverter e(exception);
106
107  std::vector<Var> args;
108  ArgListToVector(argc, argv, &args);
109  return static_cast<ScriptableObject*>(object)->Call(
110      Var(Var::DontManage(), method_name), args, e.Get()).Detach();
111}
112
113PP_Var Construct(void* object,
114                 uint32_t argc,
115                 PP_Var* argv,
116                 PP_Var* exception) {
117  ExceptionConverter e(exception);
118
119  std::vector<Var> args;
120  ArgListToVector(argc, argv, &args);
121  return static_cast<ScriptableObject*>(object)->Construct(
122      args, e.Get()).Detach();
123}
124
125void Deallocate(void* object) {
126  delete static_cast<ScriptableObject*>(object);
127}
128
129PPP_Class_Deprecated plugin_class = {
130  &HasProperty,
131  &HasMethod,
132  &GetProperty,
133  &GetAllPropertyNames,
134  &SetProperty,
135  &RemoveProperty,
136  &Call,
137  &Construct,
138  &Deallocate
139};
140
141}  // namespace
142
143bool ScriptableObject::HasProperty(const Var& /*name*/, Var* /*exception*/) {
144  return false;
145}
146
147bool ScriptableObject::HasMethod(const Var& /*name*/, Var* /*exception*/) {
148  return false;
149}
150
151Var ScriptableObject::GetProperty(const Var& /*name*/, Var* exception) {
152  *exception = Var("Property does not exist on ScriptableObject");
153  return Var();
154}
155
156void ScriptableObject::GetAllPropertyNames(std::vector<Var>* /*properties*/,
157                                           Var* /*exception*/) {
158}
159
160void ScriptableObject::SetProperty(const Var& /*name*/,
161                                   const Var& /*value*/,
162                                   Var* exception) {
163  *exception = Var("Property can not be set on ScriptableObject");
164}
165
166void ScriptableObject::RemoveProperty(const Var& /*name*/,
167                                      Var* exception) {
168  *exception = Var(
169      "Property does does not exist to be removed in ScriptableObject");
170}
171
172Var ScriptableObject::Call(const Var& /*method_name*/,
173                           const std::vector<Var>& /*args*/,
174                           Var* exception) {
175  *exception = Var("Method does not exist to call in ScriptableObject");
176  return Var();
177}
178
179Var ScriptableObject::Construct(const std::vector<Var>& /*args*/,
180                                Var* exception) {
181  *exception = Var("Construct method does not exist in ScriptableObject");
182  return Var();
183}
184
185// static
186const PPP_Class_Deprecated* ScriptableObject::GetClass() {
187  return &plugin_class;
188}
189
190}  // namespace deprecated
191
192}  // namespace pp
193