ppapi/shared_impl/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/shared_impl/var.h"
   6
   7 #include <limits>
   8
   9 #include "base/logging.h"
  10 #include "base/string_number_conversions.h"
  11 #include "base/string_util.h"
  12 #include "ppapi/c/pp_var.h"
  13 #include "ppapi/shared_impl/ppapi_globals.h"
  14 #include "ppapi/shared_impl/var_tracker.h"
  15
  16 namespace ppapi {
  17
  18 // Var -------------------------------------------------------------------------
  19
  20 Var::Var() : var_id_(0) {
  21 }
  22
  23 Var::~Var() {
  24 }
  25
  26 // static
  27 std::string Var::PPVarToLogString(PP_Var var) {
  28   switch (var.type) {
  29     case PP_VARTYPE_UNDEFINED:
  30       return "[Undefined]";
  31     case PP_VARTYPE_NULL:
  32       return "[Null]";
  33     case PP_VARTYPE_BOOL:
  34       return var.value.as_bool ? "[True]" : "[False]";
  35     case PP_VARTYPE_INT32:
  36       return base::IntToString(var.value.as_int);
  37     case PP_VARTYPE_DOUBLE:
  38       return base::DoubleToString(var.value.as_double);
  39     case PP_VARTYPE_STRING: {
  40       StringVar* string(StringVar::FromPPVar(var));
  41       if (!string)
  42         return "[Invalid string]";
  43
  44       // Since this is for logging, escape NULLs, truncate length.
  45       std::string result;
  46       const size_t kTruncateAboveLength = 128;
  47       if (string->value().size() > kTruncateAboveLength)
  48         result = string->value().substr(0, kTruncateAboveLength) + "...";
  49       else
  50         result = string->value();
  51
  52       std::string null;
  53       null.push_back(0);
  54       ReplaceSubstringsAfterOffset(&result, 0, null, "\\0");
  55       return result;
  56     }
  57     case PP_VARTYPE_OBJECT:
  58       return "[Object]";
  59     default:
  60       return "[Invalid var]";
  61   }
  62 }
  63
  64 StringVar* Var::AsStringVar() {
  65   return NULL;
  66 }
  67
  68 ArrayBufferVar* Var::AsArrayBufferVar() {
  69   return NULL;
  70 }
  71
  72 NPObjectVar* Var::AsNPObjectVar() {
  73   return NULL;
  74 }
  75
  76 ProxyObjectVar* Var::AsProxyObjectVar() {
  77   return NULL;
  78 }
  79
  80 PP_Var Var::GetPPVar() {
  81   int32 id = GetOrCreateVarID();
  82   if (!id)
  83     return PP_MakeNull();
  84
  85   PP_Var result;
  86   result.type = GetType();
  87   result.padding = 0;
  88   result.value.as_id = id;
  89   return result;
  90 }
  91
  92 int32 Var::GetExistingVarID() const {
  93   return var_id_;
  94 }
  95
  96 int32 Var::GetOrCreateVarID() {
  97   VarTracker* tracker = PpapiGlobals::Get()->GetVarTracker();
  98   if (var_id_) {
  99     if (!tracker->AddRefVar(var_id_))
 100       return 0;
 101   } else {
 102     var_id_ = tracker->AddVar(this);
 103     if (!var_id_)
 104       return 0;
 105   }
 106   return var_id_;
 107 }
 108
 109 void Var::AssignVarID(int32 id) {
 110   DCHECK(!var_id_);  // Must not have already been generated.
 111   var_id_ = id;
 112 }
 113
 114 // StringVar -------------------------------------------------------------------
 115
 116 StringVar::StringVar() {
 117 }
 118
 119 StringVar::StringVar(const std::string& str)
 120     : value_(str) {
 121 }
 122
 123 StringVar::StringVar(const char* str, uint32 len)
 124     : value_(str, len) {
 125 }
 126
 127 StringVar::~StringVar() {
 128 }
 129
 130 StringVar* StringVar::AsStringVar() {
 131   return this;
 132 }
 133
 134 PP_VarType StringVar::GetType() const {
 135   return PP_VARTYPE_STRING;
 136 }
 137
 138 // static
 139 PP_Var StringVar::StringToPPVar(const std::string& var) {
 140   return StringToPPVar(var.c_str(), var.size());
 141 }
 142
 143 // static
 144 PP_Var StringVar::StringToPPVar(const char* data, uint32 len) {
 145   scoped_refptr<StringVar> str(new StringVar(data, len));
 146   if (!str || !IsStringUTF8(str->value()))
 147     return PP_MakeNull();
 148   return str->GetPPVar();
 149 }
 150
 151 // static
 152 StringVar* StringVar::FromPPVar(PP_Var var) {
 153   if (var.type != PP_VARTYPE_STRING)
 154     return NULL;
 155   scoped_refptr<Var> var_object(
 156       PpapiGlobals::Get()->GetVarTracker()->GetVar(var));
 157   if (!var_object)
 158     return NULL;
 159   return var_object->AsStringVar();
 160 }
 161
 162 // static
 163 PP_Var StringVar::SwapValidatedUTF8StringIntoPPVar(std::string* src) {
 164   scoped_refptr<StringVar> str(new StringVar);
 165   str->value_.swap(*src);
 166   return str->GetPPVar();
 167 }
 168
 169 // ArrayBufferVar --------------------------------------------------------------
 170
 171 ArrayBufferVar::ArrayBufferVar() {
 172 }
 173
 174 ArrayBufferVar::~ArrayBufferVar() {
 175 }
 176
 177 ArrayBufferVar* ArrayBufferVar::AsArrayBufferVar() {
 178   return this;
 179 }
 180
 181 PP_VarType ArrayBufferVar::GetType() const {
 182   return PP_VARTYPE_ARRAY_BUFFER;
 183 }
 184
 185 // static
 186 ArrayBufferVar* ArrayBufferVar::FromPPVar(PP_Var var) {
 187   if (var.type != PP_VARTYPE_ARRAY_BUFFER)
 188     return NULL;
 189   scoped_refptr<Var> var_object(
 190       PpapiGlobals::Get()->GetVarTracker()->GetVar(var));
 191   if (!var_object)
 192     return NULL;
 193   return var_object->AsArrayBufferVar();
 194 }
 195
 196 }  // namespace ppapi
 197