[inspector] Build inspector under v8_enable_inspector build flag.

src/inspector/V8Debugger.cpp

 // Copyright 2016 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/V8Debugger.h"
 
 #include "src/inspector/DebuggerScript.h"
 #include "src/inspector/ScriptBreakpoint.h"
 #include "src/inspector/StringUtil.h"
-#include "src/inspector/V8Compat.h"
 #include "src/inspector/V8DebuggerAgentImpl.h"
 #include "src/inspector/V8InspectorImpl.h"
 #include "src/inspector/V8InternalValueType.h"
 #include "src/inspector/V8StackTraceImpl.h"
 #include "src/inspector/V8ValueCopier.h"
 #include "src/inspector/protocol/Protocol.h"
-#include "src/inspector/public/V8InspectorClient.h"
 
 namespace v8_inspector {
 
 namespace {
 const char stepIntoV8MethodName[] = "stepIntoStatement";
 const char stepOutV8MethodName[] = "stepOutOfFunction";
 static const char v8AsyncTaskEventEnqueue[] = "enqueue";
 static const char v8AsyncTaskEventWillHandle[] = "willHandle";
 static const char v8AsyncTaskEventDidHandle[] = "didHandle";
 
@@ skipping 158 matching lines @@
   v8::Context::Scope contextScope(debuggerContext());
 
   v8::Local<v8::Function> clearBreakpoints =
       v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(
           toV8StringInternalized(m_isolate, "clearBreakpoints")));
   v8::Debug::Call(debuggerContext(), clearBreakpoints).ToLocalChecked();
 }
 
 void V8Debugger::setBreakpointsActivated(bool activated) {
   if (!enabled()) {
-    NOTREACHED();
+    UNREACHABLE();
     return;
   }
   v8::HandleScope scope(m_isolate);
   v8::Context::Scope contextScope(debuggerContext());
 
   v8::Local<v8::Object> info = v8::Object::New(m_isolate);
   info->Set(toV8StringInternalized(m_isolate, "enabled"),
             v8::Boolean::New(m_isolate, activated));
   v8::Local<v8::Function> setBreakpointsActivated =
       v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(
@@ skipping 46 matching lines @@
     v8::Local<v8::Array> hitBreakpoints;
     handleProgramBreak(m_pausedContext, m_executionState, exception,
                        hitBreakpoints);
     return;
   }
 
   if (!canBreakProgram()) return;
 
   v8::HandleScope scope(m_isolate);
   v8::Local<v8::Function> breakFunction;
-  if (!V8_FUNCTION_NEW_REMOVE_PROTOTYPE(m_isolate->GetCurrentContext(),
-                                        &V8Debugger::breakProgramCallback,
-                                        v8::External::New(m_isolate, this), 0)
+  if (!v8::Function::New(m_isolate->GetCurrentContext(),
+                         &V8Debugger::breakProgramCallback,
+                         v8::External::New(m_isolate, this), 0,
+                         v8::ConstructorBehavior::kThrow)
            .ToLocal(&breakFunction))
     return;
   v8::Debug::Call(debuggerContext(), breakFunction).ToLocalChecked();
 }
 
 void V8Debugger::continueProgram() {
   if (isPaused()) m_inspector->client()->quitMessageLoopOnPause();
   m_pausedContext.Clear();
   m_executionState.Clear();
 }
@@ skipping 310 matching lines @@
   // The scopes for the ids are defined by the eventData.name namespaces. There
   // are currently two namespaces: "Object." and "Promise.".
   void* ptr = reinterpret_cast<void*>(id * 4 + (name[0] == 'P' ? 2 : 0) + 1);
   if (type == v8AsyncTaskEventEnqueue)
     asyncTaskScheduled(name, ptr, false);
   else if (type == v8AsyncTaskEventWillHandle)
     asyncTaskStarted(ptr);
   else if (type == v8AsyncTaskEventDidHandle)
     asyncTaskFinished(ptr);
   else
-    NOTREACHED();
+    UNREACHABLE();
 }
 
 V8StackTraceImpl* V8Debugger::currentAsyncCallChain() {
   if (!m_currentStacks.size()) return nullptr;
   return m_currentStacks.back().get();
 }
 
 void V8Debugger::compileDebuggerScript() {
   if (!m_debuggerScript.IsEmpty()) {
-    NOTREACHED();
+    UNREACHABLE();
     return;
   }
 
   v8::HandleScope scope(m_isolate);
   v8::Context::Scope contextScope(debuggerContext());
 
   v8::Local<v8::String> scriptValue =
       v8::String::NewFromUtf8(m_isolate, DebuggerScript_js,
                               v8::NewStringType::kInternalized,
                               sizeof(DebuggerScript_js))
           .ToLocalChecked();
   v8::Local<v8::Value> value;
   if (!m_inspector->compileAndRunInternalScript(debuggerContext(), scriptValue)
            .ToLocal(&value)) {
-    NOTREACHED();
+    UNREACHABLE();
     return;
   }
   DCHECK(value->IsObject());
   m_debuggerScript.Reset(m_isolate, value.As<v8::Object>());
 }
 
 v8::Local<v8::Context> V8Debugger::debuggerContext() const {
   DCHECK(!m_debuggerContext.IsEmpty());
   return m_debuggerContext.Get(m_isolate);
 }
 
 v8::MaybeLocal<v8::Value> V8Debugger::functionScopes(
     v8::Local<v8::Context> context, v8::Local<v8::Function> function) {
   if (!enabled()) {
-    NOTREACHED();
+    UNREACHABLE();
     return v8::Local<v8::Value>::New(m_isolate, v8::Undefined(m_isolate));
   }
   v8::Local<v8::Value> argv[] = {function};
   v8::Local<v8::Value> scopesValue;
   if (!callDebuggerMethod("getFunctionScopes", 1, argv).ToLocal(&scopesValue))
     return v8::MaybeLocal<v8::Value>();
   v8::Local<v8::Value> copied;
   if (!copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
                                     scopesValue)
            .ToLocal(&copied) ||
@@ skipping 60 matching lines @@
                          toV8StringInternalized(m_isolate, "[[Scopes]]"));
       createDataProperty(context, properties, properties->Length(), scopes);
     }
   }
   return properties;
 }
 
 v8::Local<v8::Value> V8Debugger::collectionEntries(
     v8::Local<v8::Context> context, v8::Local<v8::Object> object) {
   if (!enabled()) {
-    NOTREACHED();
+    UNREACHABLE();
     return v8::Undefined(m_isolate);
   }
   v8::Local<v8::Value> argv[] = {object};
   v8::Local<v8::Value> entriesValue =
       callDebuggerMethod("getCollectionEntries", 1, argv).ToLocalChecked();
   v8::Local<v8::Value> copied;
   if (!copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
                                     entriesValue)
            .ToLocal(&copied) ||
       !copied->IsArray())
     return v8::Undefined(m_isolate);
   if (!markArrayEntriesAsInternal(context, v8::Local<v8::Array>::Cast(copied),
                                   V8InternalValueType::kEntry))
     return v8::Undefined(m_isolate);
   return copied;
 }
 
 v8::Local<v8::Value> V8Debugger::generatorObjectLocation(
     v8::Local<v8::Context> context, v8::Local<v8::Object> object) {
   if (!enabled()) {
-    NOTREACHED();
+    UNREACHABLE();
     return v8::Null(m_isolate);
   }
   v8::Local<v8::Value> argv[] = {object};
   v8::Local<v8::Value> location =
       callDebuggerMethod("getGeneratorObjectLocation", 1, argv)
           .ToLocalChecked();
   v8::Local<v8::Value> copied;
   if (!copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
                                     location)
            .ToLocal(&copied) ||
@@ skipping 159 matching lines @@
 
   size_t stackSize =
       fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
   if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
     stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
   return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 }  // namespace v8_inspector