Home | History | Annotate | Download | only in private 
      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 
     10 namespace pp {
     11 
     12 class InstanceHandle;
     13 
     14 namespace deprecated {
     15 class 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.
     21 class 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