2014-10-31 18:17:05 +00:00
|
|
|
// Copyright (c) 2013 GitHub, Inc.
|
2014-04-25 09:49:37 +00:00
|
|
|
// Use of this source code is governed by the MIT license that can be
|
2013-04-17 12:05:43 +00:00
|
|
|
// found in the LICENSE file.
|
|
|
|
|
2014-04-17 05:45:14 +00:00
|
|
|
#include "atom/common/native_mate_converters/v8_value_converter.h"
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2014-12-17 00:46:23 +00:00
|
|
|
#include <map>
|
2016-07-04 06:08:55 +00:00
|
|
|
#include <memory>
|
2013-04-17 12:05:43 +00:00
|
|
|
#include <string>
|
2014-03-16 01:13:06 +00:00
|
|
|
#include <utility>
|
2018-06-26 22:08:27 +00:00
|
|
|
#include <vector>
|
2013-04-17 12:05:43 +00:00
|
|
|
|
|
|
|
#include "base/logging.h"
|
|
|
|
#include "base/values.h"
|
2015-08-27 07:23:23 +00:00
|
|
|
#include "native_mate/dictionary.h"
|
2016-07-21 06:51:57 +00:00
|
|
|
|
2018-06-13 07:38:31 +00:00
|
|
|
#include "atom/common/node_bindings.h"
|
2016-07-21 06:51:57 +00:00
|
|
|
#include "atom/common/node_includes.h"
|
2013-04-17 12:05:43 +00:00
|
|
|
|
|
|
|
namespace atom {
|
|
|
|
|
2014-12-17 00:46:23 +00:00
|
|
|
namespace {
|
|
|
|
|
2015-08-26 10:22:28 +00:00
|
|
|
const int kMaxRecursionDepth = 100;
|
2014-12-17 00:46:23 +00:00
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
// The state of a call to FromV8Value.
|
|
|
|
class V8ValueConverter::FromV8ValueState {
|
|
|
|
public:
|
|
|
|
// Level scope which updates the current depth of some FromV8ValueState.
|
|
|
|
class Level {
|
|
|
|
public:
|
|
|
|
explicit Level(FromV8ValueState* state) : state_(state) {
|
|
|
|
state_->max_recursion_depth_--;
|
|
|
|
}
|
2018-04-18 01:55:30 +00:00
|
|
|
~Level() { state_->max_recursion_depth_++; }
|
2014-12-17 00:46:23 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
FromV8ValueState* state_;
|
|
|
|
};
|
|
|
|
|
|
|
|
FromV8ValueState() : max_recursion_depth_(kMaxRecursionDepth) {}
|
|
|
|
|
|
|
|
// If |handle| is not in |unique_map_|, then add it to |unique_map_| and
|
|
|
|
// return true.
|
|
|
|
//
|
|
|
|
// Otherwise do nothing and return false. Here "A is unique" means that no
|
|
|
|
// other handle B in the map points to the same object as A. Note that A can
|
|
|
|
// be unique even if there already is another handle with the same identity
|
|
|
|
// hash (key) in the map, because two objects can have the same hash.
|
2016-08-25 16:26:07 +00:00
|
|
|
bool AddToUniquenessCheck(v8::Local<v8::Object> handle) {
|
|
|
|
int hash;
|
|
|
|
auto iter = GetIteratorInMap(handle, &hash);
|
|
|
|
if (iter != unique_map_.end())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unique_map_.insert(std::make_pair(hash, handle));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool RemoveFromUniquenessCheck(v8::Local<v8::Object> handle) {
|
|
|
|
int unused_hash;
|
|
|
|
auto iter = GetIteratorInMap(handle, &unused_hash);
|
|
|
|
if (iter == unique_map_.end())
|
|
|
|
return false;
|
|
|
|
unique_map_.erase(iter);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-04-18 01:55:30 +00:00
|
|
|
bool HasReachedMaxRecursionDepth() { return max_recursion_depth_ < 0; }
|
2016-08-25 16:26:07 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
using HashToHandleMap = std::multimap<int, v8::Local<v8::Object>>;
|
|
|
|
using Iterator = HashToHandleMap::const_iterator;
|
|
|
|
|
|
|
|
Iterator GetIteratorInMap(v8::Local<v8::Object> handle, int* hash) {
|
|
|
|
*hash = handle->GetIdentityHash();
|
2014-12-17 00:46:23 +00:00
|
|
|
// We only compare using == with handles to objects with the same identity
|
|
|
|
// hash. Different hash obviously means different objects, but two objects
|
|
|
|
// in a couple of thousands could have the same identity hash.
|
2016-08-25 16:26:07 +00:00
|
|
|
std::pair<Iterator, Iterator> range = unique_map_.equal_range(*hash);
|
2016-07-10 11:09:55 +00:00
|
|
|
for (auto it = range.first; it != range.second; ++it) {
|
2014-12-17 00:46:23 +00:00
|
|
|
// Operator == for handles actually compares the underlying objects.
|
|
|
|
if (it->second == handle)
|
2016-08-25 16:26:07 +00:00
|
|
|
return it;
|
2014-12-17 00:46:23 +00:00
|
|
|
}
|
2016-08-25 16:26:07 +00:00
|
|
|
// Not found.
|
|
|
|
return unique_map_.end();
|
2014-12-17 00:46:23 +00:00
|
|
|
}
|
|
|
|
|
2016-08-25 16:26:07 +00:00
|
|
|
HashToHandleMap unique_map_;
|
|
|
|
|
|
|
|
int max_recursion_depth_;
|
|
|
|
};
|
|
|
|
|
|
|
|
// A class to ensure that objects/arrays that are being converted by
|
|
|
|
// this V8ValueConverterImpl do not have cycles.
|
|
|
|
//
|
|
|
|
// An example of cycle: var v = {}; v = {key: v};
|
|
|
|
// Not an example of cycle: var v = {}; a = [v, v]; or w = {a: v, b: v};
|
|
|
|
class V8ValueConverter::ScopedUniquenessGuard {
|
|
|
|
public:
|
|
|
|
ScopedUniquenessGuard(V8ValueConverter::FromV8ValueState* state,
|
|
|
|
v8::Local<v8::Object> value)
|
|
|
|
: state_(state),
|
|
|
|
value_(value),
|
|
|
|
is_valid_(state_->AddToUniquenessCheck(value_)) {}
|
|
|
|
~ScopedUniquenessGuard() {
|
|
|
|
if (is_valid_) {
|
|
|
|
bool removed = state_->RemoveFromUniquenessCheck(value_);
|
|
|
|
DCHECK(removed);
|
|
|
|
}
|
2014-12-17 00:46:23 +00:00
|
|
|
}
|
|
|
|
|
2016-08-25 16:26:07 +00:00
|
|
|
bool is_valid() const { return is_valid_; }
|
|
|
|
|
2014-12-17 00:46:23 +00:00
|
|
|
private:
|
2018-04-18 01:55:30 +00:00
|
|
|
typedef std::multimap<int, v8::Local<v8::Object>> HashToHandleMap;
|
2016-08-25 16:26:07 +00:00
|
|
|
V8ValueConverter::FromV8ValueState* state_;
|
|
|
|
v8::Local<v8::Object> value_;
|
|
|
|
bool is_valid_;
|
2014-12-17 00:46:23 +00:00
|
|
|
|
2016-08-25 16:26:07 +00:00
|
|
|
DISALLOW_COPY_AND_ASSIGN(ScopedUniquenessGuard);
|
2014-12-17 00:46:23 +00:00
|
|
|
};
|
|
|
|
|
2018-05-21 22:18:38 +00:00
|
|
|
V8ValueConverter::V8ValueConverter() {}
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2013-12-23 14:42:21 +00:00
|
|
|
void V8ValueConverter::SetRegExpAllowed(bool val) {
|
2013-04-17 12:05:43 +00:00
|
|
|
reg_exp_allowed_ = val;
|
|
|
|
}
|
|
|
|
|
2013-12-23 14:42:21 +00:00
|
|
|
void V8ValueConverter::SetFunctionAllowed(bool val) {
|
2013-04-17 12:05:43 +00:00
|
|
|
function_allowed_ = val;
|
|
|
|
}
|
|
|
|
|
2013-12-23 14:42:21 +00:00
|
|
|
void V8ValueConverter::SetStripNullFromObjects(bool val) {
|
2013-04-17 12:05:43 +00:00
|
|
|
strip_null_from_objects_ = val;
|
|
|
|
}
|
|
|
|
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::Local<v8::Value> V8ValueConverter::ToV8Value(
|
2018-04-18 01:55:30 +00:00
|
|
|
const base::Value* value,
|
|
|
|
v8::Local<v8::Context> context) const {
|
2013-04-17 12:05:43 +00:00
|
|
|
v8::Context::Scope context_scope(context);
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::EscapableHandleScope handle_scope(context->GetIsolate());
|
|
|
|
return handle_scope.Escape(ToV8ValueImpl(context->GetIsolate(), value));
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
std::unique_ptr<base::Value> V8ValueConverter::FromV8Value(
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::Local<v8::Value> val,
|
|
|
|
v8::Local<v8::Context> context) const {
|
2013-04-17 12:05:43 +00:00
|
|
|
v8::Context::Scope context_scope(context);
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::HandleScope handle_scope(context->GetIsolate());
|
2014-12-17 00:46:23 +00:00
|
|
|
FromV8ValueState state;
|
|
|
|
return FromV8ValueImpl(&state, val, context->GetIsolate());
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::Local<v8::Value> V8ValueConverter::ToV8ValueImpl(
|
2018-04-18 01:55:30 +00:00
|
|
|
v8::Isolate* isolate,
|
|
|
|
const base::Value* value) const {
|
2018-04-11 09:21:23 +00:00
|
|
|
switch (value->type()) {
|
2017-04-05 09:02:06 +00:00
|
|
|
case base::Value::Type::NONE:
|
2014-06-28 14:33:00 +00:00
|
|
|
return v8::Null(isolate);
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2017-04-05 08:34:53 +00:00
|
|
|
case base::Value::Type::BOOLEAN: {
|
2018-06-27 21:52:48 +00:00
|
|
|
bool val = value->GetBool();
|
2014-06-28 14:33:00 +00:00
|
|
|
return v8::Boolean::New(isolate, val);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2017-04-05 08:34:53 +00:00
|
|
|
case base::Value::Type::INTEGER: {
|
2018-06-27 21:52:48 +00:00
|
|
|
int val = value->GetInt();
|
2014-06-28 14:33:00 +00:00
|
|
|
return v8::Integer::New(isolate, val);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2017-04-05 08:34:53 +00:00
|
|
|
case base::Value::Type::DOUBLE: {
|
2018-06-27 21:52:48 +00:00
|
|
|
double val = value->GetDouble();
|
2014-06-28 14:33:00 +00:00
|
|
|
return v8::Number::New(isolate, val);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2017-04-05 08:34:53 +00:00
|
|
|
case base::Value::Type::STRING: {
|
2018-06-27 21:52:48 +00:00
|
|
|
std::string val = value->GetString();
|
2018-04-18 01:55:30 +00:00
|
|
|
return v8::String::NewFromUtf8(isolate, val.c_str(),
|
2019-01-21 16:27:11 +00:00
|
|
|
v8::NewStringType::kNormal, val.length())
|
|
|
|
.ToLocalChecked();
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2017-04-05 08:34:53 +00:00
|
|
|
case base::Value::Type::LIST:
|
2014-06-28 14:33:00 +00:00
|
|
|
return ToV8Array(isolate, static_cast<const base::ListValue*>(value));
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2017-04-05 08:34:53 +00:00
|
|
|
case base::Value::Type::DICTIONARY:
|
2014-06-28 14:33:00 +00:00
|
|
|
return ToV8Object(isolate,
|
|
|
|
static_cast<const base::DictionaryValue*>(value));
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2017-04-05 08:34:53 +00:00
|
|
|
case base::Value::Type::BINARY:
|
2018-04-18 01:55:30 +00:00
|
|
|
return ToArrayBuffer(isolate, static_cast<const base::Value*>(value));
|
2015-10-12 19:43:59 +00:00
|
|
|
|
2013-04-17 12:05:43 +00:00
|
|
|
default:
|
2018-04-11 09:21:23 +00:00
|
|
|
LOG(ERROR) << "Unexpected value type: " << value->type();
|
2014-06-28 14:33:00 +00:00
|
|
|
return v8::Null(isolate);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::Local<v8::Value> V8ValueConverter::ToV8Array(
|
2018-04-18 01:55:30 +00:00
|
|
|
v8::Isolate* isolate,
|
|
|
|
const base::ListValue* val) const {
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::Local<v8::Array> result(v8::Array::New(isolate, val->GetSize()));
|
2013-04-17 12:05:43 +00:00
|
|
|
|
|
|
|
for (size_t i = 0; i < val->GetSize(); ++i) {
|
2016-07-10 09:52:28 +00:00
|
|
|
const base::Value* child = nullptr;
|
2016-07-21 07:44:30 +00:00
|
|
|
val->Get(i, &child);
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::Local<v8::Value> child_v8 = ToV8ValueImpl(isolate, child);
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2018-04-12 14:04:32 +00:00
|
|
|
v8::TryCatch try_catch(isolate);
|
2016-03-08 04:40:10 +00:00
|
|
|
result->Set(static_cast<uint32_t>(i), child_v8);
|
2013-04-17 12:05:43 +00:00
|
|
|
if (try_catch.HasCaught())
|
|
|
|
LOG(ERROR) << "Setter for index " << i << " threw an exception.";
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::Local<v8::Value> V8ValueConverter::ToV8Object(
|
2018-04-18 01:55:30 +00:00
|
|
|
v8::Isolate* isolate,
|
|
|
|
const base::DictionaryValue* val) const {
|
2015-08-27 07:23:23 +00:00
|
|
|
mate::Dictionary result = mate::Dictionary::CreateEmpty(isolate);
|
|
|
|
result.SetHidden("simple", true);
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2018-04-18 01:55:30 +00:00
|
|
|
for (base::DictionaryValue::Iterator iter(*val); !iter.IsAtEnd();
|
|
|
|
iter.Advance()) {
|
2013-04-17 12:05:43 +00:00
|
|
|
const std::string& key = iter.key();
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::Local<v8::Value> child_v8 = ToV8ValueImpl(isolate, &iter.value());
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2018-04-12 14:04:32 +00:00
|
|
|
v8::TryCatch try_catch(isolate);
|
2015-08-27 07:23:23 +00:00
|
|
|
result.Set(key, child_v8);
|
2013-04-17 12:05:43 +00:00
|
|
|
if (try_catch.HasCaught()) {
|
|
|
|
LOG(ERROR) << "Setter for property " << key.c_str() << " threw an "
|
|
|
|
<< "exception.";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-27 07:23:23 +00:00
|
|
|
return result.GetHandle();
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2015-10-12 19:43:59 +00:00
|
|
|
v8::Local<v8::Value> V8ValueConverter::ToArrayBuffer(
|
2018-04-18 01:55:30 +00:00
|
|
|
v8::Isolate* isolate,
|
|
|
|
const base::Value* value) const {
|
2018-10-25 19:32:09 +00:00
|
|
|
const auto* data = reinterpret_cast<const char*>(value->GetBlob().data());
|
2017-08-04 09:12:54 +00:00
|
|
|
size_t length = value->GetBlob().size();
|
2017-03-16 16:20:09 +00:00
|
|
|
|
2018-06-13 07:38:31 +00:00
|
|
|
if (NodeBindings::IsInitialized()) {
|
2017-03-16 16:20:09 +00:00
|
|
|
return node::Buffer::Copy(isolate, data, length).ToLocalChecked();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (length > node::Buffer::kMaxLength) {
|
|
|
|
return v8::Local<v8::Object>();
|
|
|
|
}
|
|
|
|
auto context = isolate->GetCurrentContext();
|
|
|
|
auto array_buffer = v8::ArrayBuffer::New(isolate, length);
|
|
|
|
memcpy(array_buffer->GetContents().Data(), data, length);
|
|
|
|
// From this point, if something goes wrong(can't find Buffer class for
|
|
|
|
// example) we'll simply return a Uint8Array based on the created ArrayBuffer.
|
|
|
|
// This can happen if no preload script was specified to the renderer.
|
|
|
|
mate::Dictionary global(isolate, context->Global());
|
|
|
|
v8::Local<v8::Value> buffer_value;
|
|
|
|
|
|
|
|
// Get the Buffer class stored as a hidden value in the global object. We'll
|
|
|
|
// use it return a browserified Buffer.
|
|
|
|
if (!global.GetHidden("Buffer", &buffer_value) ||
|
|
|
|
!buffer_value->IsFunction()) {
|
|
|
|
return v8::Uint8Array::New(array_buffer, 0, length);
|
|
|
|
}
|
|
|
|
|
2018-04-12 15:05:54 +00:00
|
|
|
mate::Dictionary buffer_class(
|
|
|
|
isolate,
|
|
|
|
buffer_value->ToObject(isolate->GetCurrentContext()).ToLocalChecked());
|
2017-03-16 16:20:09 +00:00
|
|
|
v8::Local<v8::Value> from_value;
|
2018-04-18 01:55:30 +00:00
|
|
|
if (!buffer_class.Get("from", &from_value) || !from_value->IsFunction()) {
|
2017-03-16 16:20:09 +00:00
|
|
|
return v8::Uint8Array::New(array_buffer, 0, length);
|
|
|
|
}
|
|
|
|
|
2018-04-18 01:55:30 +00:00
|
|
|
v8::Local<v8::Value> args[] = {array_buffer};
|
2017-03-16 16:20:09 +00:00
|
|
|
auto func = v8::Local<v8::Function>::Cast(from_value);
|
|
|
|
auto result = func->Call(context, v8::Null(isolate), 1, args);
|
|
|
|
if (!result.IsEmpty()) {
|
|
|
|
return result.ToLocalChecked();
|
|
|
|
}
|
|
|
|
|
|
|
|
return v8::Uint8Array::New(array_buffer, 0, length);
|
2015-10-12 19:43:59 +00:00
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
std::unique_ptr<base::Value> V8ValueConverter::FromV8ValueImpl(
|
|
|
|
FromV8ValueState* state,
|
|
|
|
v8::Local<v8::Value> val,
|
|
|
|
v8::Isolate* isolate) const {
|
2014-12-17 00:46:23 +00:00
|
|
|
FromV8ValueState::Level state_level(state);
|
|
|
|
if (state->HasReachedMaxRecursionDepth())
|
2016-07-10 09:52:28 +00:00
|
|
|
return nullptr;
|
2014-12-17 00:46:23 +00:00
|
|
|
|
2016-08-30 15:51:22 +00:00
|
|
|
if (val->IsExternal())
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::make_unique<base::Value>();
|
2016-08-30 15:51:22 +00:00
|
|
|
|
2013-04-17 12:05:43 +00:00
|
|
|
if (val->IsNull())
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::make_unique<base::Value>();
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2018-04-12 15:05:54 +00:00
|
|
|
auto context = isolate->GetCurrentContext();
|
|
|
|
|
2013-04-17 12:05:43 +00:00
|
|
|
if (val->IsBoolean())
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::make_unique<base::Value>(val->ToBoolean(isolate)->Value());
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2016-03-08 14:28:53 +00:00
|
|
|
if (val->IsInt32())
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::make_unique<base::Value>(val.As<v8::Int32>()->Value());
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2017-12-09 17:31:51 +00:00
|
|
|
if (val->IsNumber()) {
|
2019-01-21 16:27:11 +00:00
|
|
|
double val_as_double = val.As<v8::Number>()->Value();
|
2017-12-09 17:31:51 +00:00
|
|
|
if (!std::isfinite(val_as_double))
|
|
|
|
return nullptr;
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::make_unique<base::Value>(val_as_double);
|
2017-12-09 17:31:51 +00:00
|
|
|
}
|
2013-04-17 12:05:43 +00:00
|
|
|
|
|
|
|
if (val->IsString()) {
|
2019-01-21 16:27:11 +00:00
|
|
|
v8::String::Utf8Value utf8(isolate, val);
|
|
|
|
return std::make_unique<base::Value>(std::string(*utf8, utf8.length()));
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (val->IsUndefined())
|
|
|
|
// JSON.stringify ignores undefined.
|
2016-07-10 09:52:28 +00:00
|
|
|
return nullptr;
|
2013-04-17 12:05:43 +00:00
|
|
|
|
|
|
|
if (val->IsDate()) {
|
|
|
|
v8::Date* date = v8::Date::Cast(*val);
|
2016-02-24 10:55:41 +00:00
|
|
|
v8::Local<v8::Value> toISOString =
|
2019-01-21 16:27:11 +00:00
|
|
|
date->Get(v8::String::NewFromUtf8(isolate, "toISOString",
|
|
|
|
v8::NewStringType::kNormal)
|
|
|
|
.ToLocalChecked());
|
2016-02-24 10:55:41 +00:00
|
|
|
if (toISOString->IsFunction()) {
|
2019-01-09 19:17:05 +00:00
|
|
|
v8::Local<v8::Value> result = toISOString.As<v8::Function>()
|
|
|
|
->Call(context, val, 0, nullptr)
|
|
|
|
.ToLocalChecked();
|
2016-02-24 10:55:41 +00:00
|
|
|
if (!result.IsEmpty()) {
|
2019-01-21 16:27:11 +00:00
|
|
|
v8::String::Utf8Value utf8(isolate, result);
|
|
|
|
return std::make_unique<base::Value>(std::string(*utf8, utf8.length()));
|
2016-02-24 10:55:41 +00:00
|
|
|
}
|
|
|
|
}
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (val->IsRegExp()) {
|
|
|
|
if (!reg_exp_allowed_)
|
|
|
|
// JSON.stringify converts to an object.
|
2019-01-21 16:27:11 +00:00
|
|
|
return FromV8Object(val.As<v8::Object>(), state, isolate);
|
|
|
|
return std::make_unique<base::Value>(*v8::String::Utf8Value(isolate, val));
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// v8::Value doesn't have a ToArray() method for some reason.
|
|
|
|
if (val->IsArray())
|
2014-12-17 00:46:23 +00:00
|
|
|
return FromV8Array(val.As<v8::Array>(), state, isolate);
|
2013-04-17 12:05:43 +00:00
|
|
|
|
|
|
|
if (val->IsFunction()) {
|
|
|
|
if (!function_allowed_)
|
|
|
|
// JSON.stringify refuses to convert function(){}.
|
2016-07-10 09:52:28 +00:00
|
|
|
return nullptr;
|
2019-01-21 16:27:11 +00:00
|
|
|
return FromV8Object(val.As<v8::Object>(), state, isolate);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2015-08-12 07:39:33 +00:00
|
|
|
if (node::Buffer::HasInstance(val)) {
|
|
|
|
return FromNodeBuffer(val, state, isolate);
|
|
|
|
}
|
|
|
|
|
2013-04-17 12:05:43 +00:00
|
|
|
if (val->IsObject()) {
|
2019-01-21 16:27:11 +00:00
|
|
|
return FromV8Object(val.As<v8::Object>(), state, isolate);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
LOG(ERROR) << "Unexpected v8 value type encountered.";
|
2016-07-10 09:52:28 +00:00
|
|
|
return nullptr;
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
std::unique_ptr<base::Value> V8ValueConverter::FromV8Array(
|
|
|
|
v8::Local<v8::Array> val,
|
|
|
|
FromV8ValueState* state,
|
|
|
|
v8::Isolate* isolate) const {
|
2016-08-25 16:26:07 +00:00
|
|
|
ScopedUniquenessGuard uniqueness_guard(state, val);
|
|
|
|
if (!uniqueness_guard.is_valid())
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::make_unique<base::Value>();
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2016-05-23 01:59:39 +00:00
|
|
|
std::unique_ptr<v8::Context::Scope> scope;
|
2013-04-17 12:05:43 +00:00
|
|
|
// If val was created in a different context than our current one, change to
|
|
|
|
// that context, but change back after val is converted.
|
|
|
|
if (!val->CreationContext().IsEmpty() &&
|
2014-06-28 14:33:00 +00:00
|
|
|
val->CreationContext() != isolate->GetCurrentContext())
|
2013-04-17 12:05:43 +00:00
|
|
|
scope.reset(new v8::Context::Scope(val->CreationContext()));
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
std::unique_ptr<base::ListValue> result(new base::ListValue());
|
2013-04-17 12:05:43 +00:00
|
|
|
|
|
|
|
// Only fields with integer keys are carried over to the ListValue.
|
2016-03-08 04:40:10 +00:00
|
|
|
for (uint32_t i = 0; i < val->Length(); ++i) {
|
2018-04-12 14:04:32 +00:00
|
|
|
v8::TryCatch try_catch(isolate);
|
2019-01-21 16:27:11 +00:00
|
|
|
v8::Local<v8::Value> child_v8;
|
|
|
|
v8::MaybeLocal<v8::Value> maybe_child =
|
|
|
|
val->Get(isolate->GetCurrentContext(), i);
|
|
|
|
if (try_catch.HasCaught() || !maybe_child.ToLocal(&child_v8)) {
|
2013-04-17 12:05:43 +00:00
|
|
|
LOG(ERROR) << "Getter for index " << i << " threw an exception.";
|
2014-06-28 14:33:00 +00:00
|
|
|
child_v8 = v8::Null(isolate);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
if (!val->HasRealIndexedProperty(isolate->GetCurrentContext(), i)
|
|
|
|
.FromMaybe(false)) {
|
|
|
|
result->Append(std::make_unique<base::Value>());
|
2013-04-17 12:05:43 +00:00
|
|
|
continue;
|
2019-01-21 16:27:11 +00:00
|
|
|
}
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
std::unique_ptr<base::Value> child =
|
|
|
|
FromV8ValueImpl(state, child_v8, isolate);
|
2013-04-17 12:05:43 +00:00
|
|
|
if (child)
|
2019-01-21 16:27:11 +00:00
|
|
|
result->Append(std::move(child));
|
2013-04-17 12:05:43 +00:00
|
|
|
else
|
|
|
|
// JSON.stringify puts null in places where values don't serialize, for
|
|
|
|
// example undefined and functions. Emulate that behavior.
|
2018-04-12 12:48:32 +00:00
|
|
|
result->Append(std::make_unique<base::Value>());
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::move(result);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
std::unique_ptr<base::Value> V8ValueConverter::FromNodeBuffer(
|
|
|
|
v8::Local<v8::Value> value,
|
|
|
|
FromV8ValueState* state,
|
|
|
|
v8::Isolate* isolate) const {
|
|
|
|
std::vector<char> buffer(
|
2018-06-26 22:08:27 +00:00
|
|
|
node::Buffer::Data(value),
|
2019-01-21 16:27:11 +00:00
|
|
|
node::Buffer::Data(value) + node::Buffer::Length(value));
|
|
|
|
return std::make_unique<base::Value>(std::move(buffer));
|
2015-08-12 07:39:33 +00:00
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
std::unique_ptr<base::Value> V8ValueConverter::FromV8Object(
|
|
|
|
v8::Local<v8::Object> val,
|
|
|
|
FromV8ValueState* state,
|
|
|
|
v8::Isolate* isolate) const {
|
2016-08-25 16:26:07 +00:00
|
|
|
ScopedUniquenessGuard uniqueness_guard(state, val);
|
|
|
|
if (!uniqueness_guard.is_valid())
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::make_unique<base::Value>();
|
2014-12-17 00:46:23 +00:00
|
|
|
|
2016-05-23 01:59:39 +00:00
|
|
|
std::unique_ptr<v8::Context::Scope> scope;
|
2013-04-17 12:05:43 +00:00
|
|
|
// If val was created in a different context than our current one, change to
|
|
|
|
// that context, but change back after val is converted.
|
|
|
|
if (!val->CreationContext().IsEmpty() &&
|
2014-06-28 14:33:00 +00:00
|
|
|
val->CreationContext() != isolate->GetCurrentContext())
|
2013-04-17 12:05:43 +00:00
|
|
|
scope.reset(new v8::Context::Scope(val->CreationContext()));
|
|
|
|
|
2018-06-18 07:32:55 +00:00
|
|
|
auto result = std::make_unique<base::DictionaryValue>();
|
2019-01-21 16:27:11 +00:00
|
|
|
v8::Local<v8::Array> property_names;
|
|
|
|
if (!val->GetOwnPropertyNames(isolate->GetCurrentContext())
|
|
|
|
.ToLocal(&property_names)) {
|
|
|
|
return std::move(result);
|
|
|
|
}
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2016-03-08 04:40:10 +00:00
|
|
|
for (uint32_t i = 0; i < property_names->Length(); ++i) {
|
2019-01-21 16:27:11 +00:00
|
|
|
v8::Local<v8::Value> key =
|
|
|
|
property_names->Get(isolate->GetCurrentContext(), i).ToLocalChecked();
|
2013-04-17 12:05:43 +00:00
|
|
|
|
|
|
|
// Extend this test to cover more types as necessary and if sensible.
|
2018-04-18 01:55:30 +00:00
|
|
|
if (!key->IsString() && !key->IsNumber()) {
|
2018-11-27 21:42:02 +00:00
|
|
|
NOTREACHED() << "Key \"" << *v8::String::Utf8Value(isolate, key)
|
2018-04-18 01:55:30 +00:00
|
|
|
<< "\" "
|
2013-04-17 12:05:43 +00:00
|
|
|
"is neither a string nor a number";
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
v8::String::Utf8Value name_utf8(isolate, key);
|
2013-04-17 12:05:43 +00:00
|
|
|
|
2018-04-12 14:04:32 +00:00
|
|
|
v8::TryCatch try_catch(isolate);
|
2019-01-21 16:27:11 +00:00
|
|
|
v8::Local<v8::Value> child_v8;
|
|
|
|
v8::MaybeLocal<v8::Value> maybe_child =
|
|
|
|
val->Get(isolate->GetCurrentContext(), key);
|
|
|
|
if (try_catch.HasCaught() || !maybe_child.ToLocal(&child_v8)) {
|
2013-04-17 12:05:43 +00:00
|
|
|
LOG(ERROR) << "Getter for property " << *name_utf8
|
|
|
|
<< " threw an exception.";
|
2014-06-28 14:33:00 +00:00
|
|
|
child_v8 = v8::Null(isolate);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
std::unique_ptr<base::Value> child =
|
|
|
|
FromV8ValueImpl(state, child_v8, isolate);
|
|
|
|
if (!child)
|
2013-04-17 12:05:43 +00:00
|
|
|
// JSON.stringify skips properties whose values don't serialize, for
|
|
|
|
// example undefined and functions. Emulate that behavior.
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Strip null if asked (and since undefined is turned into null, undefined
|
|
|
|
// too). The use case for supporting this is JSON-schema support,
|
|
|
|
// specifically for extensions, where "optional" JSON properties may be
|
|
|
|
// represented as null, yet due to buggy legacy code elsewhere isn't
|
|
|
|
// treated as such (potentially causing crashes). For example, the
|
|
|
|
// "tabs.create" function takes an object as its first argument with an
|
|
|
|
// optional "windowId" property.
|
|
|
|
//
|
|
|
|
// Given just
|
|
|
|
//
|
|
|
|
// tabs.create({})
|
|
|
|
//
|
|
|
|
// this will work as expected on code that only checks for the existence of
|
|
|
|
// a "windowId" property (such as that legacy code). However given
|
|
|
|
//
|
|
|
|
// tabs.create({windowId: null})
|
|
|
|
//
|
|
|
|
// there *is* a "windowId" property, but since it should be an int, code
|
|
|
|
// on the browser which doesn't additionally check for null will fail.
|
|
|
|
// We can avoid all bugs related to this by stripping null.
|
2018-04-10 14:05:36 +00:00
|
|
|
if (strip_null_from_objects_ && child->is_none())
|
2013-04-17 12:05:43 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
|
2017-08-04 09:39:30 +00:00
|
|
|
std::move(child));
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
2019-01-21 16:27:11 +00:00
|
|
|
return std::move(result);
|
2013-04-17 12:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace atom
|