[inspector] Build inspector under v8_enable_inspector build flag.

src/inspector/V8InjectedScriptHost.cpp

 // Copyright 2015 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 "src/inspector/V8InjectedScriptHost.h"
 
+#include "src/base/macros.h"
 #include "src/inspector/InjectedScriptNative.h"
 #include "src/inspector/StringUtil.h"
-#include "src/inspector/V8Compat.h"
 #include "src/inspector/V8Debugger.h"
 #include "src/inspector/V8InspectorImpl.h"
 #include "src/inspector/V8InternalValueType.h"
 #include "src/inspector/V8ValueCopier.h"
-#include "src/inspector/public/V8InspectorClient.h"
+
+#include "include/v8-inspector.h"
 
 namespace v8_inspector {
 
 namespace {
 
 void setFunctionProperty(v8::Local<v8::Context> context,
                          v8::Local<v8::Object> obj, const char* name,
                          v8::FunctionCallback callback,
                          v8::Local<v8::External> external) {
   v8::Local<v8::String> funcName =
       toV8StringInternalized(context->GetIsolate(), name);
   v8::Local<v8::Function> func;
-  if (!V8_FUNCTION_NEW_REMOVE_PROTOTYPE(context, callback, external, 0)
+  if (!v8::Function::New(context, callback, external, 0,
+                         v8::ConstructorBehavior::kThrow)
            .ToLocal(&func))
     return;
   func->SetName(funcName);
   createDataProperty(context, obj, funcName, func);
 }
 
 V8InspectorImpl* unwrapInspector(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   DCHECK(!info.Data().IsEmpty());
   DCHECK(info.Data()->IsExternal());
   V8InspectorImpl* inspector =
       static_cast<V8InspectorImpl*>(info.Data().As<v8::External>()->Value());
   DCHECK(inspector);
   return inspector;
 }
 
 }  // namespace
 
 v8::Local<v8::Object> V8InjectedScriptHost::create(
     v8::Local<v8::Context> context, V8InspectorImpl* inspector) {
   v8::Isolate* isolate = inspector->isolate();
   v8::Local<v8::Object> injectedScriptHost = v8::Object::New(isolate);
   bool success = injectedScriptHost->SetPrototype(context, v8::Null(isolate))
                      .FromMaybe(false);
   DCHECK(success);
+  USE(success);
   v8::Local<v8::External> debuggerExternal =
       v8::External::New(isolate, inspector);
   setFunctionProperty(context, injectedScriptHost, "internalConstructorName",
                       V8InjectedScriptHost::internalConstructorNameCallback,
                       debuggerExternal);
   setFunctionProperty(
       context, injectedScriptHost, "formatAccessorsAsProperties",
       V8InjectedScriptHost::formatAccessorsAsProperties, debuggerExternal);
   setFunctionProperty(context, injectedScriptHost, "subtype",
                       V8InjectedScriptHost::subtypeCallback, debuggerExternal);
@@ skipping 128 matching lines @@
 
   v8::Local<v8::String> v8groupName = info[1]->ToString(info.GetIsolate());
   String16 groupName = toProtocolStringWithTypeCheck(v8groupName);
   int id = injectedScriptNative->bind(info[0], groupName);
   info.GetReturnValue().Set(id);
 }
 
 void V8InjectedScriptHost::proxyTargetValueCallback(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   if (info.Length() != 1 || !info[0]->IsProxy()) {
-    NOTREACHED();
+    UNREACHABLE();
     return;
   }
   v8::Local<v8::Object> target = info[0].As<v8::Proxy>();
   while (target->IsProxy())
     target = v8::Local<v8::Proxy>::Cast(target)->GetTarget();
   info.GetReturnValue().Set(target);
 }
 
 }  // namespace v8_inspector