diff options
Diffstat (limited to 'chromium/ppapi/shared_impl/var_value_conversions.cc')
| -rw-r--r-- | chromium/ppapi/shared_impl/var_value_conversions.cc | 394 |
1 files changed, 0 insertions, 394 deletions
diff --git a/chromium/ppapi/shared_impl/var_value_conversions.cc b/chromium/ppapi/shared_impl/var_value_conversions.cc deleted file mode 100644 index e3a5bddc4f0..00000000000 --- a/chromium/ppapi/shared_impl/var_value_conversions.cc +++ /dev/null @@ -1,394 +0,0 @@ -// Copyright (c) 2013 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "ppapi/shared_impl/var_value_conversions.h" - -#include <limits> -#include <set> -#include <stack> - -#include "base/logging.h" -#include "base/memory/ref_counted.h" -#include "base/memory/scoped_ptr.h" -#include "base/stl_util.h" -#include "base/values.h" -#include "ppapi/c/pp_bool.h" -#include "ppapi/c/pp_stdint.h" -#include "ppapi/shared_impl/array_var.h" -#include "ppapi/shared_impl/dictionary_var.h" -#include "ppapi/shared_impl/ppapi_globals.h" -#include "ppapi/shared_impl/scoped_pp_var.h" -#include "ppapi/shared_impl/var.h" -#include "ppapi/shared_impl/var_tracker.h" - -namespace ppapi { - -namespace { - -// In CreateValueFromVar(), a stack is used to keep track of conversion progress -// of array and dictionary vars. VarNode represents elements of that stack. -struct VarNode { - VarNode(const PP_Var& in_var, base::Value* in_value) - : var(in_var), - value(in_value), - sentinel(false) { - } - - // This object doesn't hold a reference to it. - PP_Var var; - // It is not owned by this object. - base::Value* value; - // When this is set to true for a node in the stack, it means that we have - // finished processing the node itself. However, we keep it in the stack as - // a sentinel. When it becomes the top element of the stack again, we know - // that we have processed all the descendants of this node. - bool sentinel; -}; - -// In CreateVarFromValue(), a stack is used to keep track of conversion progress -// of list and dictionary values. ValueNode represents elements of that stack. -struct ValueNode { - ValueNode(const PP_Var& in_var, const base::Value* in_value) - : var(in_var), - value(in_value) { - } - - // This object doesn't hold a reference to it. - PP_Var var; - // It is not owned by this object. - const base::Value* value; -}; - -// Helper function for CreateValueFromVar(). It only looks at |var| but not its -// descendants. The conversion result is stored in |value|. If |var| is array or -// dictionary, a new node is pushed onto |state|. -// -// Returns false on failure. -bool CreateValueFromVarHelper(const std::set<int64_t>& parent_ids, - const PP_Var& var, - scoped_ptr<base::Value>* value, - std::stack<VarNode>* state) { - switch (var.type) { - case PP_VARTYPE_UNDEFINED: - case PP_VARTYPE_NULL: { - value->reset(base::Value::CreateNullValue()); - return true; - } - case PP_VARTYPE_BOOL: { - value->reset(new base::FundamentalValue(PP_ToBool(var.value.as_bool))); - return true; - } - case PP_VARTYPE_INT32: { - value->reset(new base::FundamentalValue(var.value.as_int)); - return true; - } - case PP_VARTYPE_DOUBLE: { - value->reset(new base::FundamentalValue(var.value.as_double)); - return true; - } - case PP_VARTYPE_STRING: { - StringVar* string_var = StringVar::FromPPVar(var); - if (!string_var) - return false; - - value->reset(new base::StringValue(string_var->value())); - return true; - } - case PP_VARTYPE_OBJECT: { - return false; - } - case PP_VARTYPE_ARRAY: { - if (ContainsKey(parent_ids, var.value.as_id)) { - // A circular reference is found. - return false; - } - - value->reset(new base::ListValue()); - state->push(VarNode(var, value->get())); - return true; - } - case PP_VARTYPE_DICTIONARY: { - if (ContainsKey(parent_ids, var.value.as_id)) { - // A circular reference is found. - return false; - } - - value->reset(new base::DictionaryValue()); - state->push(VarNode(var, value->get())); - return true; - } - case PP_VARTYPE_ARRAY_BUFFER: { - ArrayBufferVar* array_buffer = ArrayBufferVar::FromPPVar(var); - if (!array_buffer) - return false; - - base::BinaryValue* binary_value = - base::BinaryValue::CreateWithCopiedBuffer( - static_cast<const char*>(array_buffer->Map()), - array_buffer->ByteLength()); - array_buffer->Unmap(); - value->reset(binary_value); - return true; - } - case PP_VARTYPE_RESOURCE: { - return false; - } - } - NOTREACHED(); - return false; -} - -// Helper function for CreateVarFromValue(). It only looks at |value| but not -// its descendants. The conversion result is stored in |var|. If |value| is list -// or dictionary, a new node is pushed onto |state|. -// -// Returns false on failure. -bool CreateVarFromValueHelper(const base::Value& value, - ScopedPPVar* var, - std::stack<ValueNode>* state) { - switch (value.GetType()) { - case base::Value::TYPE_NULL: { - *var = PP_MakeNull(); - return true; - } - case base::Value::TYPE_BOOLEAN: { - bool result = false; - if (value.GetAsBoolean(&result)) { - *var = PP_MakeBool(PP_FromBool(result)); - return true; - } - return false; - } - case base::Value::TYPE_INTEGER: { - int result = 0; - if (value.GetAsInteger(&result)) { - *var = PP_MakeInt32(result); - return true; - } - return false; - } - case base::Value::TYPE_DOUBLE: { - double result = 0; - if (value.GetAsDouble(&result)) { - *var = PP_MakeDouble(result); - return true; - } - return false; - } - case base::Value::TYPE_STRING: { - std::string result; - if (value.GetAsString(&result)) { - *var = ScopedPPVar(ScopedPPVar::PassRef(), - StringVar::StringToPPVar(result)); - return true; - } - return false; - } - case base::Value::TYPE_BINARY: { - const base::BinaryValue& binary_value = - static_cast<const base::BinaryValue&>(value); - - size_t size = binary_value.GetSize(); - if (size > std::numeric_limits<uint32>::max()) - return false; - - ScopedPPVar temp( - ScopedPPVar::PassRef(), - PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar( - static_cast<uint32>(size), binary_value.GetBuffer())); - if (temp.get().type == PP_VARTYPE_ARRAY_BUFFER) { - *var = temp; - return true; - } - return false; - } - case base::Value::TYPE_DICTIONARY: { - scoped_refptr<DictionaryVar> dict_var(new DictionaryVar()); - *var = ScopedPPVar(ScopedPPVar::PassRef(), dict_var->GetPPVar()); - state->push(ValueNode(var->get(), &value)); - return true; - } - case base::Value::TYPE_LIST: { - scoped_refptr<ArrayVar> array_var(new ArrayVar()); - *var = ScopedPPVar(ScopedPPVar::PassRef(), array_var->GetPPVar()); - state->push(ValueNode(var->get(), &value)); - return true; - } - } - NOTREACHED(); - return false; -} - -} // namespace - -base::Value* CreateValueFromVar(const PP_Var& var) { - // Used to detect circular references. - std::set<int64_t> parent_ids; - std::stack<VarNode> state; - scoped_ptr<base::Value> root_value; - - if (!CreateValueFromVarHelper(parent_ids, var, &root_value, &state)) - return NULL; - - while (!state.empty()) { - VarNode& top = state.top(); - if (top.sentinel) { - parent_ids.erase(top.var.value.as_id); - state.pop(); - } else if (top.var.type == PP_VARTYPE_DICTIONARY) { - parent_ids.insert(top.var.value.as_id); - top.sentinel = true; - - DictionaryVar* dict_var = DictionaryVar::FromPPVar(top.var); - if (!dict_var) - return NULL; - - DCHECK(top.value->GetType() == base::Value::TYPE_DICTIONARY); - base::DictionaryValue* dict_value = - static_cast<base::DictionaryValue*>(top.value); - - for (DictionaryVar::KeyValueMap::const_iterator iter = - dict_var->key_value_map().begin(); - iter != dict_var->key_value_map().end(); - ++iter) { - // Skip the key-value pair if the value is undefined or null. - if (iter->second.get().type == PP_VARTYPE_UNDEFINED || - iter->second.get().type == PP_VARTYPE_NULL) { - continue; - } - - scoped_ptr<base::Value> child_value; - if (!CreateValueFromVarHelper(parent_ids, iter->second.get(), - &child_value, &state)) { - return NULL; - } - - dict_value->SetWithoutPathExpansion(iter->first, child_value.release()); - } - } else if (top.var.type == PP_VARTYPE_ARRAY) { - parent_ids.insert(top.var.value.as_id); - top.sentinel = true; - - ArrayVar* array_var = ArrayVar::FromPPVar(top.var); - if (!array_var) - return NULL; - - DCHECK(top.value->GetType() == base::Value::TYPE_LIST); - base::ListValue* list_value = static_cast<base::ListValue*>(top.value); - - for (ArrayVar::ElementVector::const_iterator iter = - array_var->elements().begin(); - iter != array_var->elements().end(); - ++iter) { - scoped_ptr<base::Value> child_value; - if (!CreateValueFromVarHelper(parent_ids, iter->get(), &child_value, - &state)) { - return NULL; - } - - list_value->Append(child_value.release()); - } - } else { - NOTREACHED(); - return NULL; - } - } - DCHECK(parent_ids.empty()); - return root_value.release(); -} - -PP_Var CreateVarFromValue(const base::Value& value) { - std::stack<ValueNode> state; - ScopedPPVar root_var; - - if (!CreateVarFromValueHelper(value, &root_var, &state)) - return PP_MakeUndefined(); - - while (!state.empty()) { - ValueNode top = state.top(); - state.pop(); - - if (top.value->GetType() == base::Value::TYPE_DICTIONARY) { - const base::DictionaryValue* dict_value = - static_cast<const base::DictionaryValue*>(top.value); - DictionaryVar* dict_var = DictionaryVar::FromPPVar(top.var); - DCHECK(dict_var); - for (base::DictionaryValue::Iterator iter(*dict_value); - !iter.IsAtEnd(); - iter.Advance()) { - ScopedPPVar child_var; - if (!CreateVarFromValueHelper(iter.value(), &child_var, &state) || - !dict_var->SetWithStringKey(iter.key(), child_var.get())) { - return PP_MakeUndefined(); - } - } - } else if (top.value->GetType() == base::Value::TYPE_LIST) { - const base::ListValue* list_value = - static_cast<const base::ListValue*>(top.value); - ArrayVar* array_var = ArrayVar::FromPPVar(top.var); - DCHECK(array_var); - for (base::ListValue::const_iterator iter = list_value->begin(); - iter != list_value->end(); - ++iter) { - ScopedPPVar child_var; - if (!CreateVarFromValueHelper(**iter, &child_var, &state)) - return PP_MakeUndefined(); - - array_var->elements().push_back(child_var); - } - } else { - NOTREACHED(); - return PP_MakeUndefined(); - } - } - - return root_var.Release(); -} - -base::ListValue* CreateListValueFromVarVector( - const std::vector<PP_Var>& vars) { - scoped_ptr<base::ListValue> list_value(new base::ListValue()); - - for (std::vector<PP_Var>::const_iterator iter = vars.begin(); - iter != vars.end(); - ++iter) { - base::Value* value = CreateValueFromVar(*iter); - if (!value) - return NULL; - list_value->Append(value); - } - return list_value.release(); -} - -bool CreateVarVectorFromListValue(const base::ListValue& list_value, - std::vector<PP_Var>* vars) { - if (!vars) - return false; - - std::vector<ScopedPPVar> result; - result.reserve(list_value.GetSize()); - for (base::ListValue::const_iterator iter = list_value.begin(); - iter != list_value.end(); - ++iter) { - ScopedPPVar child_var(ScopedPPVar::PassRef(), - CreateVarFromValue(**iter)); - if (child_var.get().type == PP_VARTYPE_UNDEFINED) - return false; - - result.push_back(child_var); - } - - vars->clear(); - vars->reserve(result.size()); - for (std::vector<ScopedPPVar>::iterator iter = result.begin(); - iter != result.end(); - ++iter) { - vars->push_back(iter->Release()); - } - - return true; -} - -} // namespace ppapi - |