1// Copyright 2013 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 "gin/object_template_builder.h"
6
7#include "gin/interceptor.h"
8#include "gin/per_isolate_data.h"
9#include "gin/public/wrapper_info.h"
10
11namespace gin {
12
13namespace {
14
15WrappableBase* WrappableFromV8(v8::Isolate* isolate,
16                               v8::Handle<v8::Value> val) {
17  if (!val->IsObject())
18    return NULL;
19  v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(val);
20  WrapperInfo* info = WrapperInfo::From(obj);
21
22  // If this fails, the object is not managed by Gin.
23  if (!info)
24    return NULL;
25
26  // We don't further validate the type of the object, but assume it's derived
27  // from WrappableBase. We look up the pointer in a global registry, to make
28  // sure it's actually pointed to a valid life object.
29  return static_cast<WrappableBase*>(
30      obj->GetAlignedPointerFromInternalField(kEncodedValueIndex));
31}
32
33NamedPropertyInterceptor* NamedInterceptorFromV8(v8::Isolate* isolate,
34                                                 v8::Handle<v8::Value> val) {
35  WrappableBase* base = WrappableFromV8(isolate, val);
36  if (!base)
37    return NULL;
38  return PerIsolateData::From(isolate)->GetNamedPropertyInterceptor(base);
39}
40
41IndexedPropertyInterceptor* IndexedInterceptorFromV8(
42    v8::Isolate* isolate,
43    v8::Handle<v8::Value> val) {
44  WrappableBase* base = WrappableFromV8(isolate, val);
45  if (!base)
46    return NULL;
47  return PerIsolateData::From(isolate)->GetIndexedPropertyInterceptor(base);
48}
49
50void NamedPropertyGetter(v8::Local<v8::String> property,
51                         const v8::PropertyCallbackInfo<v8::Value>& info) {
52  v8::Isolate* isolate = info.GetIsolate();
53  NamedPropertyInterceptor* interceptor =
54      NamedInterceptorFromV8(isolate, info.Holder());
55  if (!interceptor)
56    return;
57  std::string name;
58  ConvertFromV8(isolate, property, &name);
59  info.GetReturnValue().Set(interceptor->GetNamedProperty(isolate, name));
60}
61
62void NamedPropertySetter(v8::Local<v8::String> property,
63                         v8::Local<v8::Value> value,
64                         const v8::PropertyCallbackInfo<v8::Value>& info) {
65  v8::Isolate* isolate = info.GetIsolate();
66  NamedPropertyInterceptor* interceptor =
67      NamedInterceptorFromV8(isolate, info.Holder());
68  if (!interceptor)
69    return;
70  std::string name;
71  ConvertFromV8(isolate, property, &name);
72  if (interceptor->SetNamedProperty(isolate, name, value))
73    info.GetReturnValue().Set(value);
74}
75
76void NamedPropertyQuery(v8::Local<v8::String> property,
77                        const v8::PropertyCallbackInfo<v8::Integer>& info) {
78  v8::Isolate* isolate = info.GetIsolate();
79  NamedPropertyInterceptor* interceptor =
80      NamedInterceptorFromV8(isolate, info.Holder());
81  if (!interceptor)
82    return;
83  std::string name;
84  ConvertFromV8(isolate, property, &name);
85  if (interceptor->GetNamedProperty(isolate, name).IsEmpty())
86    return;
87  info.GetReturnValue().Set(0);
88}
89
90void NamedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) {
91  v8::Isolate* isolate = info.GetIsolate();
92  NamedPropertyInterceptor* interceptor =
93      NamedInterceptorFromV8(isolate, info.Holder());
94  if (!interceptor)
95    return;
96  info.GetReturnValue().Set(v8::Handle<v8::Array>::Cast(
97      ConvertToV8(isolate, interceptor->EnumerateNamedProperties(isolate))));
98}
99
100void IndexedPropertyGetter(uint32_t index,
101                           const v8::PropertyCallbackInfo<v8::Value>& info) {
102  v8::Isolate* isolate = info.GetIsolate();
103  IndexedPropertyInterceptor* interceptor =
104      IndexedInterceptorFromV8(isolate, info.Holder());
105  if (!interceptor)
106    return;
107  info.GetReturnValue().Set(interceptor->GetIndexedProperty(isolate, index));
108}
109
110void IndexedPropertySetter(uint32_t index,
111                           v8::Local<v8::Value> value,
112                           const v8::PropertyCallbackInfo<v8::Value>& info) {
113  v8::Isolate* isolate = info.GetIsolate();
114  IndexedPropertyInterceptor* interceptor =
115      IndexedInterceptorFromV8(isolate, info.Holder());
116  if (!interceptor)
117    return;
118  if (interceptor->SetIndexedProperty(isolate, index, value))
119    info.GetReturnValue().Set(value);
120}
121
122void IndexedPropertyEnumerator(
123    const v8::PropertyCallbackInfo<v8::Array>& info) {
124  v8::Isolate* isolate = info.GetIsolate();
125  IndexedPropertyInterceptor* interceptor =
126      IndexedInterceptorFromV8(isolate, info.Holder());
127  if (!interceptor)
128    return;
129  info.GetReturnValue().Set(v8::Handle<v8::Array>::Cast(
130      ConvertToV8(isolate, interceptor->EnumerateIndexedProperties(isolate))));
131}
132
133}  // namespace
134
135ObjectTemplateBuilder::ObjectTemplateBuilder(v8::Isolate* isolate)
136    : isolate_(isolate), template_(v8::ObjectTemplate::New(isolate)) {
137  template_->SetInternalFieldCount(kNumberOfInternalFields);
138}
139
140ObjectTemplateBuilder::~ObjectTemplateBuilder() {
141}
142
143ObjectTemplateBuilder& ObjectTemplateBuilder::AddNamedPropertyInterceptor() {
144  template_->SetNamedPropertyHandler(&NamedPropertyGetter,
145                                     &NamedPropertySetter,
146                                     &NamedPropertyQuery,
147                                     NULL,
148                                     &NamedPropertyEnumerator);
149  return *this;
150}
151
152ObjectTemplateBuilder& ObjectTemplateBuilder::AddIndexedPropertyInterceptor() {
153  template_->SetIndexedPropertyHandler(&IndexedPropertyGetter,
154                                       &IndexedPropertySetter,
155                                       NULL,
156                                       NULL,
157                                       &IndexedPropertyEnumerator);
158  return *this;
159}
160
161ObjectTemplateBuilder& ObjectTemplateBuilder::SetImpl(
162    const base::StringPiece& name, v8::Handle<v8::Data> val) {
163  template_->Set(StringToSymbol(isolate_, name), val);
164  return *this;
165}
166
167ObjectTemplateBuilder& ObjectTemplateBuilder::SetPropertyImpl(
168    const base::StringPiece& name, v8::Handle<v8::FunctionTemplate> getter,
169    v8::Handle<v8::FunctionTemplate> setter) {
170  template_->SetAccessorProperty(StringToSymbol(isolate_, name), getter,
171                                 setter);
172  return *this;
173}
174
175v8::Local<v8::ObjectTemplate> ObjectTemplateBuilder::Build() {
176  v8::Local<v8::ObjectTemplate> result = template_;
177  template_.Clear();
178  return result;
179}
180
181}  // namespace gin
182