NOT FOR COMMIT: test that interceptors work with the inspector.

src/d8.cc

 // Copyright 2012 the V8 project 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 <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
@@ skipping 1419 matching lines @@
         isolate, script->Run(context).ToLocalChecked().As<Function>());
   }
   Local<Function> fun = Local<Function>::New(isolate, stringify_function_);
   Local<Value> argv[1] = {value};
   v8::TryCatch try_catch(isolate);
   MaybeLocal<Value> result = fun->Call(context, Undefined(isolate), 1, argv);
   if (result.IsEmpty()) return String::Empty(isolate);
   return result.ToLocalChecked().As<String>();
 }
 
+void NamedGetter(Local<String> property,
+                 const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = Isolate::GetCurrent();
+  EscapableHandleScope scope(isolate);
+  Local<Object> selfObj = info.Holder();
+  info.GetReturnValue().Set(
+      scope.Escape(String::NewFromUtf8(isolate, "value")));
+}
+
+void NamedSetter(Local<String> property, Local<Value> value,
+                 const PropertyCallbackInfo<Value>& info) {
+  Isolate* isolate = Isolate::GetCurrent();
+  EscapableHandleScope scope(isolate);
+  Local<Object> selfObj = info.Holder();
+}
+
+void NamedEnumerator(const PropertyCallbackInfo<Array>& info) {
+  Isolate* isolate = Isolate::GetCurrent();
+  EscapableHandleScope scope(isolate);
+  Local<Object> selfObj = info.Holder();
+  Handle<Array> array = Array::New(isolate);
+  array->Set(0, String::NewFromUtf8(isolate, "one"));
+  array->Set(1, String::NewFromUtf8(isolate, "two"));
+  array->Set(2, String::NewFromUtf8(isolate, "three"));
+  array->Set(3, String::NewFromUtf8(isolate, "four"));
+  info.GetReturnValue().Set(scope.Escape(array));
+}
 
 Local<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
   Local<ObjectTemplate> global_template = ObjectTemplate::New(isolate);
   global_template->Set(
       String::NewFromUtf8(isolate, "print", NewStringType::kNormal)
           .ToLocalChecked(),
       FunctionTemplate::New(isolate, Print));
   global_template->Set(
       String::NewFromUtf8(isolate, "printErr", NewStringType::kNormal)
           .ToLocalChecked(),
@@ skipping 123 matching lines @@
           .ToLocalChecked(),
       worker_fun_template);
 
   Local<ObjectTemplate> os_templ = ObjectTemplate::New(isolate);
   AddOSMethods(isolate, os_templ);
   global_template->Set(
       String::NewFromUtf8(isolate, "os", NewStringType::kNormal)
           .ToLocalChecked(),
       os_templ);
 
+  Local<FunctionTemplate> funTem = FunctionTemplate::New(isolate);
+  Local<ObjectTemplate> inst = funTem->InstanceTemplate();
+  inst->SetNamedPropertyHandler(NamedGetter, NamedSetter, 0, 0,
+                                NamedEnumerator);
+
+  global_template->Set(String::NewFromUtf8(isolate, "NamedObject"), funTem,
+                       v8::PropertyAttribute(v8::DontDelete | v8::ReadOnly));
+
   return global_template;
 }
 
 static void PrintNonErrorsMessageCallback(Local<Message> message,
                                           Local<Value> error) {
   // Nothing to do here for errors, exceptions thrown up to the shell will be
   // reported
   // separately by {Shell::ReportException} after they are caught.
   // Do print other kinds of messages.
   switch (message->ErrorLevel()) {
@@ skipping 1450 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif