[inspector] Build inspector under v8_enable_inspector build flag.

src/inspector/V8Console.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/V8Console.h"
 
+#include "src/base/macros.h"
 #include "src/inspector/InjectedScript.h"
 #include "src/inspector/InspectedContext.h"
 #include "src/inspector/StringUtil.h"
-#include "src/inspector/V8Compat.h"
 #include "src/inspector/V8ConsoleMessage.h"
 #include "src/inspector/V8DebuggerAgentImpl.h"
 #include "src/inspector/V8InspectorImpl.h"
 #include "src/inspector/V8InspectorSessionImpl.h"
 #include "src/inspector/V8ProfilerAgentImpl.h"
 #include "src/inspector/V8RuntimeAgentImpl.h"
 #include "src/inspector/V8StackTraceImpl.h"
 #include "src/inspector/V8ValueCopier.h"
-#include "src/inspector/public/V8InspectorClient.h"
+
+#include "include/v8-inspector.h"
 
 namespace v8_inspector {
 
 namespace {
 
 v8::Local<v8::Private> inspectedContextPrivateKey(v8::Isolate* isolate) {
   return v8::Private::ForApi(
       isolate, toV8StringInternalized(isolate, "V8Console#InspectedContext"));
 }
 
@@ skipping 217 matching lines @@
 }
 
 void createBoundFunctionProperty(v8::Local<v8::Context> context,
                                  v8::Local<v8::Object> console,
                                  const char* name,
                                  v8::FunctionCallback callback,
                                  const char* description = nullptr) {
   v8::Local<v8::String> funcName =
       toV8StringInternalized(context->GetIsolate(), name);
   v8::Local<v8::Function> func;
-  if (!V8_FUNCTION_NEW_REMOVE_PROTOTYPE(context, callback, console, 0)
+  if (!v8::Function::New(context, callback, console, 0,
+                         v8::ConstructorBehavior::kThrow)
            .ToLocal(&func))
     return;
   func->SetName(funcName);
   if (description) {
     v8::Local<v8::String> returnValue =
         toV8String(context->GetIsolate(), description);
     v8::Local<v8::Function> toStringFunction;
-    if (V8_FUNCTION_NEW_REMOVE_PROTOTYPE(context, returnDataCallback,
-                                         returnValue, 0)
+    if (v8::Function::New(context, returnDataCallback, returnValue, 0,
+                          v8::ConstructorBehavior::kThrow)
             .ToLocal(&toStringFunction))
       createDataProperty(context, func, toV8StringInternalized(
                                             context->GetIsolate(), "toString"),
                          toStringFunction);
   }
   createDataProperty(context, console, funcName, func);
 }
 
 }  // namespace
 
@@ skipping 377 matching lines @@
   v8::Local<v8::Context> context = inspectedContext->context();
   v8::Context::Scope contextScope(context);
   v8::Isolate* isolate = context->GetIsolate();
   v8::MicrotasksScope microtasksScope(isolate,
                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
 
   v8::Local<v8::Object> console = v8::Object::New(isolate);
   bool success =
       console->SetPrototype(context, v8::Object::New(isolate)).FromMaybe(false);
   DCHECK(success);
+  USE(success);
 
   createBoundFunctionProperty(context, console, "debug",
                               V8Console::debugCallback);
   createBoundFunctionProperty(context, console, "error",
                               V8Console::errorCallback);
   createBoundFunctionProperty(context, console, "info",
                               V8Console::infoCallback);
   createBoundFunctionProperty(context, console, "log", V8Console::logCallback);
   createBoundFunctionProperty(context, console, "warn",
                               V8Console::warnCallback);
@@ skipping 29 matching lines @@
   createBoundFunctionProperty(context, console, "time",
                               V8Console::timeCallback);
   createBoundFunctionProperty(context, console, "timeEnd",
                               V8Console::timeEndCallback);
   createBoundFunctionProperty(context, console, "timeStamp",
                               V8Console::timeStampCallback);
 
   if (hasMemoryAttribute)
     console->SetAccessorProperty(
         toV8StringInternalized(isolate, "memory"),
-        V8_FUNCTION_NEW_REMOVE_PROTOTYPE(
-            context, V8Console::memoryGetterCallback, console, 0)
+        v8::Function::New(context, V8Console::memoryGetterCallback, console, 0,
+                          v8::ConstructorBehavior::kThrow)
             .ToLocalChecked(),
-        V8_FUNCTION_NEW_REMOVE_PROTOTYPE(
-            context, V8Console::memorySetterCallback, v8::Local<v8::Value>(), 0)
+        v8::Function::New(context, V8Console::memorySetterCallback,
+                          v8::Local<v8::Value>(), 0,
+                          v8::ConstructorBehavior::kThrow)
             .ToLocalChecked(),
         static_cast<v8::PropertyAttribute>(v8::None), v8::DEFAULT);
 
   console->SetPrivate(context, inspectedContextPrivateKey(isolate),
                       v8::External::New(isolate, inspectedContext));
   return console;
 }
 
 void V8Console::clearInspectedContextIfNeeded(v8::Local<v8::Context> context,
                                               v8::Local<v8::Object> console) {
   v8::Isolate* isolate = context->GetIsolate();
   console->SetPrivate(context, inspectedContextPrivateKey(isolate),
                       v8::External::New(isolate, nullptr));
 }
 
 v8::Local<v8::Object> V8Console::createCommandLineAPI(
     InspectedContext* inspectedContext) {
   v8::Local<v8::Context> context = inspectedContext->context();
   v8::Isolate* isolate = context->GetIsolate();
   v8::MicrotasksScope microtasksScope(isolate,
                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
 
   v8::Local<v8::Object> commandLineAPI = v8::Object::New(isolate);
   bool success =
       commandLineAPI->SetPrototype(context, v8::Null(isolate)).FromMaybe(false);
   DCHECK(success);
+  USE(success);
 
   createBoundFunctionProperty(context, commandLineAPI, "dir",
                               V8Console::dirCallback,
                               "function dir(value) { [Command Line API] }");
   createBoundFunctionProperty(context, commandLineAPI, "dirxml",
                               V8Console::dirxmlCallback,
                               "function dirxml(value) { [Command Line API] }");
   createBoundFunctionProperty(context, commandLineAPI, "profile",
                               V8Console::profileCallback,
                               "function profile(title) { [Command Line API] }");
@@ skipping 63 matching lines @@
 void V8Console::CommandLineAPIScope::accessorGetterCallback(
     v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
   CommandLineAPIScope* scope = static_cast<CommandLineAPIScope*>(
       info.Data().As<v8::External>()->Value());
   DCHECK(scope);
 
   v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
   if (scope->m_cleanup) {
     bool removed = info.Holder()->Delete(context, name).FromMaybe(false);
     DCHECK(removed);
+    USE(removed);
     return;
   }
   v8::Local<v8::Object> commandLineAPI = scope->m_commandLineAPI;
 
   v8::Local<v8::Value> value;
   if (!commandLineAPI->Get(context, name).ToLocal(&value)) return;
   if (isCommandLineAPIGetter(toProtocolStringWithTypeCheck(name))) {
     DCHECK(value->IsFunction());
     v8::MicrotasksScope microtasks(info.GetIsolate(),
                                    v8::MicrotasksScope::kDoNotRunMicrotasks);
@@ skipping 11 matching lines @@
     const v8::PropertyCallbackInfo<void>& info) {
   CommandLineAPIScope* scope = static_cast<CommandLineAPIScope*>(
       info.Data().As<v8::External>()->Value());
   v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
   if (!info.Holder()->Delete(context, name).FromMaybe(false)) return;
   if (!info.Holder()->CreateDataProperty(context, name, value).FromMaybe(false))
     return;
   bool removed =
       scope->m_installedMethods->Delete(context, name).FromMaybe(false);
   DCHECK(removed);
+  USE(removed);
 }
 
 V8Console::CommandLineAPIScope::CommandLineAPIScope(
     v8::Local<v8::Context> context, v8::Local<v8::Object> commandLineAPI,
     v8::Local<v8::Object> global)
     : m_context(context),
       m_commandLineAPI(commandLineAPI),
       m_global(global),
       m_installedMethods(v8::Set::New(context->GetIsolate())),
       m_cleanup(false) {
   v8::Local<v8::Array> names;
   if (!m_commandLineAPI->GetOwnPropertyNames(context).ToLocal(&names)) return;
   v8::Local<v8::External> externalThis =
       v8::External::New(context->GetIsolate(), this);
   for (size_t i = 0; i < names->Length(); ++i) {
     v8::Local<v8::Value> name;
     if (!names->Get(context, i).ToLocal(&name) || !name->IsName()) continue;
     if (m_global->Has(context, name).FromMaybe(true)) continue;
     if (!m_installedMethods->Add(context, name).ToLocal(&m_installedMethods))
       continue;
     if (!m_global
              ->SetAccessor(context, v8::Local<v8::Name>::Cast(name),
                            CommandLineAPIScope::accessorGetterCallback,
                            CommandLineAPIScope::accessorSetterCallback,
                            externalThis, v8::DEFAULT, v8::DontEnum)
              .FromMaybe(false)) {
       bool removed = m_installedMethods->Delete(context, name).FromMaybe(false);
       DCHECK(removed);
+      USE(removed);
       continue;
     }
   }
 }
 
 V8Console::CommandLineAPIScope::~CommandLineAPIScope() {
   m_cleanup = true;
   v8::Local<v8::Array> names = m_installedMethods->AsArray();
   for (size_t i = 0; i < names->Length(); ++i) {
     v8::Local<v8::Value> name;
     if (!names->Get(m_context, i).ToLocal(&name) || !name->IsName()) continue;
     if (name->IsString()) {
       v8::Local<v8::Value> descriptor;
       bool success = m_global
                          ->GetOwnPropertyDescriptor(
                              m_context, v8::Local<v8::String>::Cast(name))
                          .ToLocal(&descriptor);
       DCHECK(success);
+      USE(success);
     }
   }
 }
 
 }  // namespace v8_inspector