DevTools: remove InjectedScriptHost.idl, implement the binding without generator

Source/bindings/core/v8/inspector/V8InjectedScriptHost.cpp

-/*
- * Copyright (C) 2007-2011 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Copyright 2015 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 "config.h"
-#include "bindings/core/v8/V8InjectedScriptHost.h"
+#include "bindings/core/v8/inspector/V8InjectedScriptHost.h"
 
 #include "bindings/core/v8/BindingSecurity.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8AbstractEventListener.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8DOMTokenList.h"
 #include "bindings/core/v8/V8Debugger.h"
 #include "bindings/core/v8/V8Event.h"
 #include "bindings/core/v8/V8EventTarget.h"
-#include "bindings/core/v8/V8EventTarget.h"
 #include "bindings/core/v8/V8HTMLAllCollection.h"
 #include "bindings/core/v8/V8HTMLCollection.h"
 #include "bindings/core/v8/V8Node.h"
 #include "bindings/core/v8/V8NodeList.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/events/EventTarget.h"
 #include "core/inspector/EventListenerInfo.h"
 #include "core/inspector/InjectedScript.h"
 #include "core/inspector/InjectedScriptHost.h"
 #include "core/inspector/JavaScriptCallFrame.h"
 #include "platform/JSONValues.h"
+#include "wtf/RefPtr.h"
 
 namespace blink {
 
 Node* InjectedScriptHost::scriptValueAsNode(ScriptState* scriptState, ScriptValue value)
 {
     ScriptState::Scope scope(scriptState);
     if (!value.isObject() || value.isNull())
         return 0;
     return V8Node::toImpl(v8::Local<v8::Object>::Cast(value.v8Value()));
 }
@@ skipping 20 matching lines @@
 }
 
 EventTarget* InjectedScriptHost::scriptValueAsEventTarget(ScriptState* scriptState, ScriptValue value)
 {
     ScriptState::Scope scope(scriptState);
     if (value.isNull() || !value.isObject())
         return nullptr;
     return eventTargetFromScriptValue(scriptState->isolate(), value.v8Value());
 }
 
-void V8InjectedScriptHost::inspectedObjectMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::clearConsoleMessagesCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    InjectedScriptHost* impl = V8InjectedScriptHost::toImpl(info.Holder());
+    impl->clearConsoleMessages();
+}
+
+void V8InjectedScriptHost::inspectedObjectCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
 
     if (!info[0]->IsInt32()) {
         V8ThrowException::throwTypeError(info.GetIsolate(), "argument has to be an integer");
         return;
     }
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
@@ skipping 11 matching lines @@
     if (value->IsString() && v8::Local<v8::String>::Cast(value)->Length())
         return v8::Local<v8::String>::Cast(value);
 
     value = function->GetInferredName();
     if (value->IsString() && v8::Local<v8::String>::Cast(value)->Length())
         return v8::Local<v8::String>::Cast(value);
 
     return v8::Local<v8::String>();
 }
 
-void V8InjectedScriptHost::internalConstructorNameMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::internalConstructorNameCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsObject())
         return;
 
     v8::Local<v8::Object> object = info[0].As<v8::Object>();
     v8::Local<v8::String> result = object->GetConstructorName();
 
     if (!result.IsEmpty() && toCoreStringWithUndefinedOrNullCheck(result) == "Object") {
         v8::Local<v8::String> constructorSymbol = v8AtomicString(info.GetIsolate(), "constructor");
         if (object->HasRealNamedProperty(constructorSymbol) && !object->HasRealNamedCallbackProperty(constructorSymbol)) {
             v8::TryCatch tryCatch;
             v8::Local<v8::Value> constructor = object->GetRealNamedProperty(constructorSymbol);
             if (!constructor.IsEmpty() && constructor->IsFunction()) {
                 v8::Local<v8::String> constructorName = functionDisplayName(v8::Local<v8::Function>::Cast(constructor));
                 if (!constructorName.IsEmpty() && !tryCatch.HasCaught())
                     result = constructorName;
             }
         }
         if (toCoreStringWithUndefinedOrNullCheck(result) == "Object" && object->IsFunction())
             result = v8AtomicString(info.GetIsolate(), "Function");
     }
 
     v8SetReturnValue(info, result);
 }
 
-void V8InjectedScriptHost::isDOMWrapperMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::isDOMWrapperCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
 
     v8SetReturnValue(info, V8DOMWrapper::isWrapper(info.GetIsolate(), info[0]));
 }
 
-void V8InjectedScriptHost::isHTMLAllCollectionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::isHTMLAllCollectionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
 
     if (!info[0]->IsObject()) {
         v8SetReturnValue(info, false);
         return;
     }
 
     v8SetReturnValue(info, V8HTMLAllCollection::hasInstance(info[0], info.GetIsolate()));
 }
 
-void V8InjectedScriptHost::isTypedArrayMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::isTypedArrayCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
     v8SetReturnValue(info, info[0]->IsTypedArray());
 }
 
-void V8InjectedScriptHost::subtypeMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::subtypeCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
     v8::Isolate* isolate = info.GetIsolate();
 
     v8::Local<v8::Value> value = info[0];
     if (value->IsArray() || value->IsTypedArray() || value->IsArgumentsObject()) {
         v8SetReturnValue(info, v8AtomicString(isolate, "array"));
         return;
     }
@@ skipping 31 matching lines @@
         || V8HTMLAllCollection::hasInstance(value, isolate)) {
         v8SetReturnValue(info, v8AtomicString(isolate, "array"));
         return;
     }
     if (value->IsNativeError() || V8DOMException::hasInstance(value, isolate)) {
         v8SetReturnValue(info, v8AtomicString(isolate, "error"));
         return;
     }
 }
 
-void V8InjectedScriptHost::functionDetailsMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::functionDetailsCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsFunction())
         return;
 
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(info[0]);
     int lineNumber = function->GetScriptLineNumber();
     int columnNumber = function->GetScriptColumnNumber();
 
     v8::Isolate* isolate = info.GetIsolate();
     v8::Local<v8::Object> location = v8::Object::New(isolate);
@@ skipping 11 matching lines @@
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     V8Debugger& debugger = host->debugger();
     v8::Local<v8::Value> scopes = debugger.functionScopes(function);
     if (!scopes.IsEmpty() && scopes->IsArray())
         result->Set(v8AtomicString(isolate, "rawScopes"), scopes);
 
     v8SetReturnValue(info, result);
 }
 
-void V8InjectedScriptHost::generatorObjectDetailsMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::generatorObjectDetailsCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsObject())
         return;
 
     v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(info[0]);
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     V8Debugger& debugger = host->debugger();
     v8SetReturnValue(info, debugger.generatorObjectDetails(object));
 }
 
-void V8InjectedScriptHost::collectionEntriesMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::collectionEntriesCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsObject())
         return;
 
     v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(info[0]);
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     V8Debugger& debugger = host->debugger();
     v8SetReturnValue(info, debugger.collectionEntries(object));
 }
 
-void V8InjectedScriptHost::getInternalPropertiesMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::getInternalPropertiesCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsObject())
         return;
 
     v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(info[0]);
     v8::MaybeLocal<v8::Array> properties = v8::Debug::GetInternalProperties(info.GetIsolate(), object);
     v8SetReturnValue(info, properties);
 }
 
 static v8::Local<v8::Array> getJSListenerFunctions(v8::Isolate* isolate, ExecutionContext* executionContext, const EventListenerInfo& listenerInfo)
@@ skipping 21 matching lines @@
         }
         ASSERT(!function.IsEmpty());
         v8::Local<v8::Object> listenerEntry = v8::Object::New(isolate);
         listenerEntry->Set(v8AtomicString(isolate, "listener"), function);
         listenerEntry->Set(v8AtomicString(isolate, "useCapture"), v8::Boolean::New(isolate, listenerInfo.eventListenerVector[i].useCapture));
         result->Set(v8::Number::New(isolate, outputIndex++), listenerEntry);
     }
     return result;
 }
 
-void V8InjectedScriptHost::getEventListenersMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::getEventListenersCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
 
     EventTarget* target = eventTargetFromScriptValue(info.GetIsolate(), info[0]);
     if (!target)
         return;
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     Vector<EventListenerInfo> listenersArray;
     host->getEventListenersImpl(target, listenersArray);
 
     v8::Local<v8::Object> result = v8::Object::New(info.GetIsolate());
     for (size_t i = 0; i < listenersArray.size(); ++i) {
         v8::Local<v8::Array> listeners = getJSListenerFunctions(info.GetIsolate(), target->executionContext(), listenersArray[i]);
         if (!listeners->Length())
             continue;
         AtomicString eventType = listenersArray[i].eventType;
         result->Set(v8String(info.GetIsolate(), eventType), listeners);
     }
 
     v8SetReturnValue(info, result);
 }
 
-void V8InjectedScriptHost::inspectMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::inspectCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 2)
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     ScriptState* scriptState = ScriptState::current(info.GetIsolate());
     ScriptValue object(scriptState, info[0]);
     ScriptValue hints(scriptState, info[1]);
     host->inspectImpl(toJSONValue(object), toJSONValue(hints));
 }
 
-void V8InjectedScriptHost::evalMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::evalCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Isolate* isolate = info.GetIsolate();
     if (info.Length() < 1) {
         isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "One argument expected.")));
         return;
     }
 
     v8::Local<v8::String> expression = info[0]->ToString(isolate);
     if (expression.IsEmpty()) {
         isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "The argument must be a string.")));
@@ skipping 11 matching lines @@
 }
 
 static void setExceptionAsReturnValue(const v8::FunctionCallbackInfo<v8::Value>& info, v8::Local<v8::Object> returnValue, v8::TryCatch& tryCatch)
 {
     v8::Isolate* isolate = info.GetIsolate();
     returnValue->Set(v8::String::NewFromUtf8(isolate, "result"), tryCatch.Exception());
     returnValue->Set(v8::String::NewFromUtf8(isolate, "exceptionDetails"), JavaScriptCallFrame::createExceptionDetails(isolate, tryCatch.Message()));
     v8SetReturnValue(info, returnValue);
 }
 
-void V8InjectedScriptHost::evaluateWithExceptionDetailsMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::evaluateWithExceptionDetailsCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Isolate* isolate = info.GetIsolate();
     if (info.Length() < 1) {
         isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "One argument expected.")));
         return;
     }
 
     v8::Local<v8::String> expression = info[0]->ToString(isolate);
     if (expression.IsEmpty()) {
         isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "The argument must be a string.")));
@@ skipping 14 matching lines @@
     if (!v8Call(V8ScriptRunner::runCompiledScript(isolate, script, currentExecutionContext(isolate)), result, tryCatch)) {
         setExceptionAsReturnValue(info, wrappedResult, tryCatch);
         return;
     }
 
     wrappedResult->Set(v8::String::NewFromUtf8(isolate, "result"), result);
     wrappedResult->Set(v8::String::NewFromUtf8(isolate, "exceptionDetails"), v8::Undefined(isolate));
     v8SetReturnValue(info, wrappedResult);
 }
 
-void V8InjectedScriptHost::setFunctionVariableValueMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::setFunctionVariableValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 4 || !info[0]->IsFunction() || !info[1]->IsInt32() || !info[2]->IsString())
         return;
 
     v8::Local<v8::Value> functionValue = info[0];
     int scopeIndex = info[1].As<v8::Int32>()->Value();
     String variableName = toCoreStringWithUndefinedOrNullCheck(info[2]);
     v8::Local<v8::Value> newValue = info[3];
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     V8Debugger& debugger = host->debugger();
     v8SetReturnValue(info, debugger.setFunctionVariableValue(functionValue, scopeIndex, variableName, newValue));
 }
 
 static bool getFunctionLocation(const v8::FunctionCallbackInfo<v8::Value>& info, String* scriptId, int* lineNumber, int* columnNumber)
 {
     if (info.Length() < 1 || !info[0]->IsFunction())
         return false;
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(info[0]);
     *lineNumber = function->GetScriptLineNumber();
     *columnNumber = function->GetScriptColumnNumber();
     if (*lineNumber == v8::Function::kLineOffsetNotFound || *columnNumber == v8::Function::kLineOffsetNotFound)
         return false;
     *scriptId = String::number(function->ScriptId());
     return true;
 }
 
-void V8InjectedScriptHost::debugFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::debugFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->debugFunction(scriptId, lineNumber, columnNumber);
 }
 
-void V8InjectedScriptHost::undebugFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::undebugFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->undebugFunction(scriptId, lineNumber, columnNumber);
 }
 
-void V8InjectedScriptHost::monitorFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::monitorFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     v8::Local<v8::Value> name;
     if (info.Length() > 0 && info[0]->IsFunction()) {
         v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(info[0]);
         name = function->GetName();
         if (!name->IsString() || !v8::Local<v8::String>::Cast(name)->Length())
             name = function->GetInferredName();
     }
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->monitorFunction(scriptId, lineNumber, columnNumber, toCoreStringWithUndefinedOrNullCheck(name));
 }
 
-void V8InjectedScriptHost::unmonitorFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::unmonitorFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->unmonitorFunction(scriptId, lineNumber, columnNumber);
 }
 
-void V8InjectedScriptHost::callFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::callFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 2 || info.Length() > 3 || !info[0]->IsFunction()) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(info[0]);
     v8::Local<v8::Value> receiver = info[1];
 
     if (info.Length() < 3 || info[2]->IsUndefined()) {
@@ skipping 12 matching lines @@
     OwnPtr<v8::Local<v8::Value>[]> argv = adoptArrayPtr(new v8::Local<v8::Value>[argc]);
     for (size_t i = 0; i < argc; ++i) {
         if (!arguments->Get(info.GetIsolate()->GetCurrentContext(), v8::Integer::New(info.GetIsolate(), i)).ToLocal(&argv[i]))
             return;
     }
 
     v8::Local<v8::Value> result = function->Call(receiver, argc, argv.get());
     v8SetReturnValue(info, result);
 }
 
-void V8InjectedScriptHost::suppressWarningsAndCallFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::suppressWarningsAndCallFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->client()->muteWarningsAndDeprecations();
 
-    callFunctionMethodCustom(info);
+    callFunctionCallback(info);
 
     host->client()->unmuteWarningsAndDeprecations();
 }
 
-void V8InjectedScriptHost::setNonEnumPropertyMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::setNonEnumPropertyCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 3 || !info[0]->IsObject() || !info[1]->IsString())
         return;
 
     v8::Local<v8::Object> object = info[0].As<v8::Object>();
     object->ForceSet(info.GetIsolate()->GetCurrentContext(), info[1], info[2], v8::DontEnum);
 }
 
-void V8InjectedScriptHost::bindMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::bindCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 2 || !info[1]->IsString())
         return;
     InjectedScriptNative* injectedScriptNative = InjectedScriptNative::fromInjectedScriptHost(info.Holder());
     if (!injectedScriptNative)
         return;
 
     v8::Local<v8::String> v8groupName = info[1]->ToString(info.GetIsolate());
     String groupName = toCoreStringWithUndefinedOrNullCheck(v8groupName);
     int id = injectedScriptNative->bind(info[0], groupName);
     info.GetReturnValue().Set(id);
 }
 
-void V8InjectedScriptHost::objectForIdMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::objectForIdCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsInt32())
         return;
     InjectedScriptNative* injectedScriptNative = InjectedScriptNative::fromInjectedScriptHost(info.Holder());
     if (!injectedScriptNative)
         return;
     int id = info[0].As<v8::Int32>()->Value();
     v8::Local<v8::Value> value = injectedScriptNative->objectForId(id);
     if (!value.IsEmpty())
         info.GetReturnValue().Set(value);
 }
 
-void V8InjectedScriptHost::idToObjectGroupNameMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+void V8InjectedScriptHost::idToObjectGroupNameCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsInt32())
         return;
     InjectedScriptNative* injectedScriptNative = InjectedScriptNative::fromInjectedScriptHost(info.Holder());
     if (!injectedScriptNative)
         return;
     int id = info[0].As<v8::Int32>()->Value();
     String groupName = injectedScriptNative->groupName(id);
     if (!groupName.isEmpty())
         info.GetReturnValue().Set(v8String(info.GetIsolate(), groupName));
 }
 
+namespace {
+
+struct V8MethodConfiguration {
+    const char* name;
+    v8::FunctionCallback callback;
+};
+
+const V8MethodConfiguration V8InjectedScriptHostMethods[] = {
+    {"clearConsoleMessages", V8InjectedScriptHost::clearConsoleMessagesCallback},
+    {"inspect", V8InjectedScriptHost::inspectCallback},
+    {"inspectedObject", V8InjectedScriptHost::inspectedObjectCallback},
+    {"internalConstructorName", V8InjectedScriptHost::internalConstructorNameCallback},
+    {"isDOMWrapper", V8InjectedScriptHost::isDOMWrapperCallback},
+    {"isHTMLAllCollection", V8InjectedScriptHost::isHTMLAllCollectionCallback},
+    {"isTypedArray", V8InjectedScriptHost::isTypedArrayCallback},
+    {"subtype", V8InjectedScriptHost::subtypeCallback},
+    {"functionDetails", V8InjectedScriptHost::functionDetailsCallback},
+    {"generatorObjectDetails", V8InjectedScriptHost::generatorObjectDetailsCallback},
+    {"collectionEntries", V8InjectedScriptHost::collectionEntriesCallback},
+    {"getInternalProperties", V8InjectedScriptHost::getInternalPropertiesCallback},
+    {"getEventListeners", V8InjectedScriptHost::getEventListenersCallback},
+    {"eval", V8InjectedScriptHost::evalCallback},
+    {"evaluateWithExceptionDetails", V8InjectedScriptHost::evaluateWithExceptionDetailsCallback},
+    {"debugFunction", V8InjectedScriptHost::debugFunctionCallback},
+    {"undebugFunction", V8InjectedScriptHost::undebugFunctionCallback},
+    {"monitorFunction", V8InjectedScriptHost::monitorFunctionCallback},
+    {"unmonitorFunction", V8InjectedScriptHost::unmonitorFunctionCallback},
+    {"callFunction", V8InjectedScriptHost::callFunctionCallback},
+    {"suppressWarningsAndCallFunction", V8InjectedScriptHost::suppressWarningsAndCallFunctionCallback},
+    {"setNonEnumProperty", V8InjectedScriptHost::setNonEnumPropertyCallback},
+    {"setFunctionVariableValue", V8InjectedScriptHost::setFunctionVariableValueCallback},
+    {"bind", V8InjectedScriptHost::bindCallback},
+    {"objectForId", V8InjectedScriptHost::objectForIdCallback},
+    {"idToObjectGroupName", V8InjectedScriptHost::idToObjectGroupNameCallback},
+};
+
+class WeakCallbackData final {
+public:
+    WeakCallbackData(v8::Isolate* isolate, PassRefPtr<InjectedScriptHost> host, v8::Local<v8::Object> wrapper)
+        : m_host(host)
+        , m_persistent(isolate, wrapper)
+    {
+        m_persistent.SetWeak(this, &WeakCallbackData::weakCallback, v8::WeakCallbackType::kParameter);
+    }
+
+    RefPtr<InjectedScriptHost> m_host;
+
+private:
+    static void weakCallback(const v8::WeakCallbackInfo<WeakCallbackData>& info)
+    {
+        delete info.GetParameter();
+    }
+
+    v8::Global<v8::Object> m_persistent;
+};
+
+} // namespace
+
+v8::Local<v8::FunctionTemplate> V8InjectedScriptHost::createWrapperTemplate(v8::Isolate* isolate)
+{
+    v8::Local<v8::FunctionTemplate> functionTemplate = v8::FunctionTemplate::New(isolate);
+
+    functionTemplate->SetClassName(v8::String::NewFromUtf8(isolate, "InjectedScriptHost", v8::NewStringType::kInternalized).ToLocalChecked());
+    v8::Local<v8::ObjectTemplate> instanceTemplate = functionTemplate->InstanceTemplate();
+
+    for (auto& config : V8InjectedScriptHostMethods) {
+        v8::Local<v8::Name> v8name = v8::String::NewFromUtf8(isolate, config.name, v8::NewStringType::kInternalized).ToLocalChecked();
+        v8::Local<v8::FunctionTemplate> functionTemplate = v8::FunctionTemplate::New(isolate, config.callback);
+        functionTemplate->RemovePrototype();
+        instanceTemplate->Set(v8name, functionTemplate, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::DontEnum | v8::ReadOnly));
+    }
+
+    return functionTemplate;
+}
+
+v8::Local<v8::Object> V8InjectedScriptHost::wrap(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> constructorTemplate, PassRefPtr<InjectedScriptHost> host)
+{
+    RefPtr<InjectedScriptHost> impl(host);
+    v8::Local<v8::Function> function;
+    if (!constructorTemplate->GetFunction(isolate->GetCurrentContext()).ToLocal(&function))
+        return v8::Local<v8::Object>();
+
+    // FIXME: don't depend on V8ScriptRunner
+    v8::MaybeLocal<v8::Object> maybeResult = V8ScriptRunner::instantiateObject(isolate, function);
+    v8::Local<v8::Object> result;
+    if (!maybeResult.ToLocal(&result))
+        return v8::Local<v8::Object>();
+
+    v8::Local<v8::External> objectReference = v8::External::New(isolate, new WeakCallbackData(isolate, impl, result));
+    result->SetHiddenValue(hiddenPropertyName(isolate), objectReference);
+
+    return result;
+}
+
+InjectedScriptHost* V8InjectedScriptHost::toImpl(v8::Local<v8::Object> object)
+{
+    v8::Isolate* isolate = object->GetIsolate();
+    v8::Local<v8::Value> value = object->GetHiddenValue(hiddenPropertyName(isolate));
+    if (value.IsEmpty())
+        return nullptr;
+    if (!value->IsExternal())
+        return nullptr;
+    void* data = value.As<v8::External>()->Value();
+    return reinterpret_cast<WeakCallbackData*>(data)->m_host.get();
+}
+
+v8::Local<v8::String> V8InjectedScriptHost::hiddenPropertyName(v8::Isolate* isolate)
+{
+    return v8::String::NewFromUtf8(isolate, "v8inspector::InjectedScriptHost", v8::NewStringType::kInternalized).ToLocalChecked();
+}
+
 } // namespace blink