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#ifndef PPAPI_CPP_PRIVATE_VAR_PRIVATE_H_
6#define PPAPI_CPP_PRIVATE_VAR_PRIVATE_H_
7
8#include "ppapi/cpp/var.h"
9
10namespace pp {
11
12class InstanceHandle;
13
14namespace deprecated {
15class ScriptableObject;
16}
17
18// VarPrivate is a version of Var that exposes the private scripting API.
19// It's designed to be mostly interchangeable with Var since most callers will
20// be dealing with Vars from various places.
21class VarPrivate : public Var {
22 public:
23  VarPrivate() : Var() {}
24  VarPrivate(Null) : Var(Null()) {}
25  VarPrivate(bool b) : Var(b) {}
26  VarPrivate(int32_t i) : Var(i) {}
27  VarPrivate(double d) : Var(d) {}
28  VarPrivate(const char* utf8_str) : Var(utf8_str) {}
29  VarPrivate(const std::string& utf8_str) : Var(utf8_str) {}
30  VarPrivate(PassRef, PP_Var var) : Var(PassRef(), var) {}
31  VarPrivate(DontManage, PP_Var var) : Var(DontManage(), var) {}
32  VarPrivate(const InstanceHandle& instance,
33             deprecated::ScriptableObject* object);
34  VarPrivate(const Var& other) : Var(other) {}
35
36  virtual ~VarPrivate() {}
37
38  // This assumes the object is of type object. If it's not, it will assert in
39  // debug mode. If it is not an object or not a ScriptableObject type, returns
40  // NULL.
41  deprecated::ScriptableObject* AsScriptableObject() const;
42
43  bool HasProperty(const Var& name, Var* exception = NULL) const;
44  bool HasMethod(const Var& name, Var* exception = NULL) const;
45  VarPrivate GetProperty(const Var& name, Var* exception = NULL) const;
46  void GetAllPropertyNames(std::vector<Var>* properties,
47                           Var* exception = NULL) const;
48  void SetProperty(const Var& name, const Var& value, Var* exception = NULL);
49  void RemoveProperty(const Var& name, Var* exception = NULL);
50  VarPrivate Call(const Var& method_name, uint32_t argc, Var* argv,
51           Var* exception = NULL);
52  VarPrivate Construct(uint32_t argc, Var* argv, Var* exception = NULL) const;
53
54  // Convenience functions for calling functions with small # of args.
55  VarPrivate Call(const Var& method_name, Var* exception = NULL);
56  VarPrivate Call(const Var& method_name, const Var& arg1,
57                  Var* exception = NULL);
58  VarPrivate Call(const Var& method_name, const Var& arg1, const Var& arg2,
59                  Var* exception = NULL);
60  VarPrivate Call(const Var& method_name, const Var& arg1, const Var& arg2,
61                  const Var& arg3, Var* exception = NULL);
62  VarPrivate Call(const Var& method_name, const Var& arg1, const Var& arg2,
63                  const Var& arg3, const Var& arg4, Var* exception = NULL);
64
65  // For use when calling the raw C PPAPI when using the C++ Var as a possibly
66  // NULL exception. This will handle getting the address of the internal value
67  // out if it's non-NULL and fixing up the reference count.
68  //
69  // Danger: this will only work for things with exception semantics, i.e. that
70  // the value will not be changed if it's a non-undefined exception. Otherwise,
71  // this class will mess up the refcounting.
72  //
73  // This is a bit subtle:
74  // - If NULL is passed, we return NULL from get() and do nothing.
75  //
76  // - If a undefined value is passed, we return the address of a undefined var
77  //   from get and have the output value take ownership of that var.
78  //
79  // - If a non-undefined value is passed, we return the address of that var
80  //   from get, and nothing else should change.
81  //
82  // Example:
83  //   void FooBar(a, b, Var* exception = NULL) {
84  //     foo_interface->Bar(a, b, VarPrivate::OutException(exception).get());
85  //   }
86  class OutException {
87   public:
88    OutException(Var* v)
89        : output_(v),
90          originally_had_exception_(v && !v->is_undefined()) {
91      if (output_) {
92        temp_ = output_->pp_var();
93      } else {
94        temp_.padding = 0;
95        temp_.type = PP_VARTYPE_UNDEFINED;
96      }
97    }
98    ~OutException() {
99      if (output_ && !originally_had_exception_)
100        *output_ = Var(PassRef(), temp_);
101    }
102
103    PP_Var* get() {
104      if (output_)
105        return &temp_;
106      return NULL;
107    }
108
109   private:
110    Var* output_;
111    bool originally_had_exception_;
112    PP_Var temp_;
113  };
114
115 private:
116  // Prevent an arbitrary pointer argument from being implicitly converted to
117  // a bool at Var construction. If somebody makes such a mistake, (s)he will
118  // get a compilation error.
119  VarPrivate(void* non_scriptable_object_pointer);
120};
121
122}  // namespace pp
123
124#endif  // PPAPI_CPP_PRIVATE_VAR_PRIVATE_H_
125