ppapi/cpp/var.cc

   1 // Copyright (c) 2012 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/var.h"
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9
  10 #include <algorithm>
  11
  12 #include "ppapi/c/pp_var.h"
  13 #include "ppapi/c/ppb_var.h"
  14 #include "ppapi/cpp/instance.h"
  15 #include "ppapi/cpp/logging.h"
  16 #include "ppapi/cpp/module.h"
  17 #include "ppapi/cpp/module_impl.h"
  18
  19 // Define equivalent to snprintf on Windows.
  20 #if defined(_MSC_VER)
  21 #  define snprintf sprintf_s
  22 #endif
  23
  24 namespace pp {
  25
  26 namespace {
  27
  28 template <> const char* interface_name<PPB_Var_1_1>() {
  29   return PPB_VAR_INTERFACE_1_1;
  30 }
  31 template <> const char* interface_name<PPB_Var_1_0>() {
  32   return PPB_VAR_INTERFACE_1_0;
  33 }
  34
  35 // Technically you can call AddRef and Release on any Var, but it may involve
  36 // cross-process calls depending on the plugin. This is an optimization so we
  37 // only do refcounting on the necessary objects.
  38 inline bool NeedsRefcounting(const PP_Var& var) {
  39   return var.type > PP_VARTYPE_DOUBLE;
  40 }
  41
  42 // This helper function detects whether PPB_Var version 1.1 is available. If so,
  43 // it uses it to create a PP_Var for the given string. Otherwise it falls back
  44 // to PPB_Var version 1.0.
  45 PP_Var VarFromUtf8Helper(const char* utf8_str, uint32_t len) {
  46   if (has_interface<PPB_Var_1_1>()) {
  47     return get_interface<PPB_Var_1_1>()->VarFromUtf8(utf8_str, len);
  48   } else if (has_interface<PPB_Var_1_0>()) {
  49     return get_interface<PPB_Var_1_0>()->VarFromUtf8(Module::Get()->pp_module(),
  50                                                      utf8_str,
  51                                                      len);
  52   } else {
  53     return PP_MakeNull();
  54   }
  55 }
  56
  57 }  // namespace
  58
  59 Var::Var() {
  60   memset(&var_, 0, sizeof(var_));
  61   var_.type = PP_VARTYPE_UNDEFINED;
  62   is_managed_ = true;
  63 }
  64
  65 Var::Var(Null) {
  66   memset(&var_, 0, sizeof(var_));
  67   var_.type = PP_VARTYPE_NULL;
  68   is_managed_ = true;
  69 }
  70
  71 Var::Var(bool b) {
  72   var_.type = PP_VARTYPE_BOOL;
  73   var_.padding = 0;
  74   var_.value.as_bool = PP_FromBool(b);
  75   is_managed_ = true;
  76 }
  77
  78 Var::Var(int32_t i) {
  79   var_.type = PP_VARTYPE_INT32;
  80   var_.padding = 0;
  81   var_.value.as_int = i;
  82   is_managed_ = true;
  83 }
  84
  85 Var::Var(double d) {
  86   var_.type = PP_VARTYPE_DOUBLE;
  87   var_.padding = 0;
  88   var_.value.as_double = d;
  89   is_managed_ = true;
  90 }
  91
  92 Var::Var(const char* utf8_str) {
  93   uint32_t len = utf8_str ? static_cast<uint32_t>(strlen(utf8_str)) : 0;
  94   var_ = VarFromUtf8Helper(utf8_str, len);
  95   is_managed_ = true;
  96 }
  97
  98 Var::Var(const std::string& utf8_str) {
  99   var_ = VarFromUtf8Helper(utf8_str.c_str(),
 100                            static_cast<uint32_t>(utf8_str.size()));
 101   is_managed_ = true;
 102 }
 103
 104
 105 Var::Var(const PP_Var& var) {
 106   var_ = var;
 107   is_managed_ = true;
 108   if (NeedsRefcounting(var_)) {
 109     if (has_interface<PPB_Var_1_0>())
 110       get_interface<PPB_Var_1_0>()->AddRef(var_);
 111     else
 112       var_.type = PP_VARTYPE_NULL;
 113   }
 114 }
 115
 116 Var::Var(const Var& other) {
 117   var_ = other.var_;
 118   is_managed_ = true;
 119   if (NeedsRefcounting(var_)) {
 120     if (has_interface<PPB_Var_1_0>())
 121       get_interface<PPB_Var_1_0>()->AddRef(var_);
 122     else
 123       var_.type = PP_VARTYPE_NULL;
 124   }
 125 }
 126
 127 Var::~Var() {
 128   if (NeedsRefcounting(var_) &&
 129       is_managed_ &&
 130       has_interface<PPB_Var_1_0>())
 131     get_interface<PPB_Var_1_0>()->Release(var_);
 132 }
 133
 134 Var& Var::operator=(const Var& other) {
 135   // Early return for self-assignment. Note however, that two distinct vars
 136   // can refer to the same object, so we still need to be careful about the
 137   // refcounting below.
 138   if (this == &other)
 139     return *this;
 140
 141   // Be careful to keep the ref alive for cases where we're assigning an
 142   // object to itself by addrefing the new one before releasing the old one.
 143   bool old_is_managed = is_managed_;
 144   is_managed_ = true;
 145   if (NeedsRefcounting(other.var_)) {
 146     // Assume we already has_interface<PPB_Var_1_0> for refcounted vars or else
 147     // we couldn't have created them in the first place.
 148     get_interface<PPB_Var_1_0>()->AddRef(other.var_);
 149   }
 150   if (NeedsRefcounting(var_) && old_is_managed)
 151     get_interface<PPB_Var_1_0>()->Release(var_);
 152
 153   var_ = other.var_;
 154   return *this;
 155 }
 156
 157 bool Var::operator==(const Var& other) const {
 158   if (var_.type != other.var_.type)
 159     return false;
 160   switch (var_.type) {
 161     case PP_VARTYPE_UNDEFINED:
 162     case PP_VARTYPE_NULL:
 163       return true;
 164     case PP_VARTYPE_BOOL:
 165       return AsBool() == other.AsBool();
 166     case PP_VARTYPE_INT32:
 167       return AsInt() == other.AsInt();
 168     case PP_VARTYPE_DOUBLE:
 169       return AsDouble() == other.AsDouble();
 170     case PP_VARTYPE_STRING:
 171       if (var_.value.as_id == other.var_.value.as_id)
 172         return true;
 173       return AsString() == other.AsString();
 174     case PP_VARTYPE_OBJECT:
 175     case PP_VARTYPE_ARRAY:
 176     case PP_VARTYPE_ARRAY_BUFFER:
 177     case PP_VARTYPE_DICTIONARY:
 178     default:  // Objects, arrays, dictionaries.
 179       return var_.value.as_id == other.var_.value.as_id;
 180   }
 181 }
 182
 183 bool Var::AsBool() const {
 184   if (!is_bool()) {
 185     PP_NOTREACHED();
 186     return false;
 187   }
 188   return PP_ToBool(var_.value.as_bool);
 189 }
 190
 191 int32_t Var::AsInt() const {
 192   if (is_int())
 193     return var_.value.as_int;
 194   if (is_double())
 195     return static_cast<int>(var_.value.as_double);
 196   PP_NOTREACHED();
 197   return 0;
 198 }
 199
 200 double Var::AsDouble() const {
 201   if (is_double())
 202     return var_.value.as_double;
 203   if (is_int())
 204     return static_cast<double>(var_.value.as_int);
 205   PP_NOTREACHED();
 206   return 0.0;
 207 }
 208
 209 std::string Var::AsString() const {
 210   if (!is_string()) {
 211     PP_NOTREACHED();
 212     return std::string();
 213   }
 214
 215   if (!has_interface<PPB_Var_1_0>())
 216     return std::string();
 217   uint32_t len;
 218   const char* str = get_interface<PPB_Var_1_0>()->VarToUtf8(var_, &len);
 219   return std::string(str, len);
 220 }
 221
 222 std::string Var::DebugString() const {
 223   char buf[256];
 224   if (is_undefined()) {
 225     snprintf(buf, sizeof(buf), "Var(UNDEFINED)");
 226   } else if (is_null()) {
 227     snprintf(buf, sizeof(buf), "Var(NULL)");
 228   } else if (is_bool()) {
 229     snprintf(buf, sizeof(buf), AsBool() ? "Var(true)" : "Var(false)");
 230   } else if (is_int()) {
 231     snprintf(buf, sizeof(buf), "Var(%d)", static_cast<int>(AsInt()));
 232   } else if (is_double()) {
 233     snprintf(buf, sizeof(buf), "Var(%f)", AsDouble());
 234   } else if (is_string()) {
 235     char format[] = "Var<'%s'>";
 236     size_t decoration = sizeof(format) - 2;  // The %s is removed.
 237     size_t available = sizeof(buf) - decoration;
 238     std::string str = AsString();
 239     if (str.length() > available) {
 240       str.resize(available - 3);  // Reserve space for ellipsis.
 241       str.append("...");
 242     }
 243     snprintf(buf, sizeof(buf), format, str.c_str());
 244   } else if (is_object()) {
 245     snprintf(buf, sizeof(buf), "Var(OBJECT)");
 246   } else if (is_array()) {
 247     snprintf(buf, sizeof(buf), "Var(ARRAY)");
 248   } else if (is_dictionary()) {
 249     snprintf(buf, sizeof(buf), "Var(DICTIONARY)");
 250   } else if (is_array_buffer()) {
 251     snprintf(buf, sizeof(buf), "Var(ARRAY_BUFFER)");
 252   } else {
 253     buf[0] = '\0';
 254   }
 255   return buf;
 256 }
 257
 258 }  // namespace pp