[api] Add PropertyDescriptor and DefineProperty().

src/api.cc

Index: src/api.cc
diff --git a/src/api.cc b/src/api.cc
index 514ff08183a0a4464afd6a37974c2476da1cc44a..e79b011173e0bf571b23cce96e0f70801a435626 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -3771,6 +3771,94 @@ Maybe<bool> v8::Object::CreateDataProperty(v8::Local<v8::Context> context,
   return result;
 }
 
+struct v8::PropertyDescriptor::PrivateData {
+  PrivateData() : desc() {}
+  i::PropertyDescriptor desc;
+};
+
+v8::PropertyDescriptor::PropertyDescriptor() : private_(new PrivateData()) {}
+
+// DataDescriptor
+v8::PropertyDescriptor::PropertyDescriptor(
+    v8::Local<v8::Value> value, v8::PropertyDescriptor::State writable)
+    : private_(new PrivateData()) {
+  private_->desc.set_value(Utils::OpenHandle(*value, true));
+  if (writable == v8::PropertyDescriptor::State::kTrue) {
+    private_->desc.set_writable(true);
+  } else if (writable == v8::PropertyDescriptor::State::kFalse) {
+    private_->desc.set_writable(false);
+  }
+}
+
+// AccessorDescriptor
+v8::PropertyDescriptor::PropertyDescriptor(v8::Local<v8::Value> get,
+                                           v8::Local<v8::Value> set)
+    : private_(new PrivateData()) {
+  DCHECK(get.IsEmpty() || get->IsUndefined() || get->IsFunction());
+  DCHECK(set.IsEmpty() || set->IsUndefined() || set->IsFunction());
+  private_->desc.set_get(Utils::OpenHandle(*get, true));
+  private_->desc.set_set(Utils::OpenHandle(*set, true));
+}
+
+v8::PropertyDescriptor::~PropertyDescriptor() { delete private_; }
+
+v8::Local<Value> v8::PropertyDescriptor::value() const {
+  return Utils::ToLocal(private_->desc.value());
+}
+
+v8::Local<Value> v8::PropertyDescriptor::get() const {
+  return Utils::ToLocal(private_->desc.get());
+}
+
+v8::Local<Value> v8::PropertyDescriptor::set() const {
+  return Utils::ToLocal(private_->desc.set());
+}
+
+bool v8::PropertyDescriptor::has_value() const {
+  return private_->desc.has_value();
+}
+bool v8::PropertyDescriptor::has_get() const {
+  return private_->desc.has_get();
+}
+bool v8::PropertyDescriptor::has_set() const {
+  return private_->desc.has_set();
+}
+
+PropertyDescriptor::State v8::PropertyDescriptor::writable() const {
+  if (!private_->desc.has_writable()) {
+    return PropertyDescriptor::State::kNotSet;
+  }
+  if (private_->desc.writable()) {
+    return PropertyDescriptor::State::kTrue;
+  }
+  return PropertyDescriptor::State::kFalse;
+}
+
+void v8::PropertyDescriptor::set_enumerable(bool enumerable) {
+  private_->desc.set_enumerable(enumerable);
+}
+PropertyDescriptor::State v8::PropertyDescriptor::enumerable() const {
+  if (!private_->desc.has_enumerable()) {
+    return PropertyDescriptor::State::kNotSet;
+  }
+  if (private_->desc.enumerable()) {
+    return PropertyDescriptor::State::kTrue;
+  }
+  return PropertyDescriptor::State::kFalse;
+}
+
+void v8::PropertyDescriptor::set_configurable(bool configurable) {
+  private_->desc.set_configurable(configurable);
+}
+PropertyDescriptor::State v8::PropertyDescriptor::configurable() const {
+  if (!private_->desc.has_configurable()) {
+    return PropertyDescriptor::State::kNotSet;
+  }
+  if (private_->desc.configurable()) {
+    return PropertyDescriptor::State::kTrue;
+  }
+  return PropertyDescriptor::State::kFalse;
+}
 
 Maybe<bool> v8::Object::DefineOwnProperty(v8::Local<v8::Context> context,
                                           v8::Local<Name> key,
@@ -3781,13 +3869,6 @@ Maybe<bool> v8::Object::DefineOwnProperty(v8::Local<v8::Context> context,
   i::Handle<i::Name> key_obj = Utils::OpenHandle(*key);
   i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
 
-  if (self->IsAccessCheckNeeded() &&
-      !isolate->MayAccess(handle(isolate->context()),
-                          i::Handle<i::JSObject>::cast(self))) {
-    isolate->ReportFailedAccessCheck(i::Handle<i::JSObject>::cast(self));
-    return Nothing<bool>();
-  }
-
   i::PropertyDescriptor desc;
   desc.set_writable(!(attributes & v8::ReadOnly));
   desc.set_enumerable(!(attributes & v8::DontEnum));
@@ -3800,6 +3881,38 @@ Maybe<bool> v8::Object::DefineOwnProperty(v8::Local<v8::Context> context,
   return success;
 }
 
+Maybe<bool> v8::Object::DefineProperty(v8::Local<v8::Context> context,
+                                       v8::Local<Name> key,
+                                       const PropertyDescriptor& descriptor) {
+  PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, DefineProperty, bool);
+  auto self = Utils::OpenHandle(this);

[Jakob Kummerow, 2016/08/29 12:32:24]

nit: no "auto" please

[Franzi, 2016/08/31 09:44:13]

Done. 

+  auto key_obj = Utils::OpenHandle(*key);
+
+  i::PropertyDescriptor desc;
+  desc.set_value(Utils::OpenHandle(*descriptor.value(), true));
+  desc.set_get(Utils::OpenHandle(*descriptor.get(), true));
+  desc.set_set(Utils::OpenHandle(*descriptor.set(), true));
+  if (descriptor.enumerable() == PropertyDescriptor::State::kTrue) {
+    desc.set_enumerable(true);
+  } else if (descriptor.enumerable() == PropertyDescriptor::State::kFalse) {
+    desc.set_enumerable(false);
+  }
+  if (descriptor.configurable() == PropertyDescriptor::State::kTrue) {
+    desc.set_configurable(true);
+  } else if (descriptor.configurable() == PropertyDescriptor::State::kFalse) {
+    desc.set_configurable(false);
+  }
+  if (descriptor.writable() == PropertyDescriptor::State::kTrue) {
+    desc.set_writable(true);
+  } else if (descriptor.writable() == PropertyDescriptor::State::kFalse) {
+    desc.set_writable(false);
+  }
+
+  auto success = i::JSReceiver::DefineOwnProperty(isolate, self, key_obj, &desc,
+                                                  i::Object::DONT_THROW);
+  RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
+  return success;
+}
 
 MUST_USE_RESULT
 static i::MaybeHandle<i::Object> DefineObjectProperty(