[DevTools] Rename V8Debugger to V8Inspector.

third_party/WebKit/Source/platform/v8_inspector/V8InjectedScriptHost.cpp

 // 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 "platform/v8_inspector/V8InjectedScriptHost.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/v8_inspector/InjectedScriptNative.h"
 #include "platform/v8_inspector/V8Compat.h"
-#include "platform/v8_inspector/V8DebuggerImpl.h"
+#include "platform/v8_inspector/V8InspectorImpl.h"
 #include "platform/v8_inspector/V8InternalValueType.h"
 #include "platform/v8_inspector/V8StringUtil.h"
-#include "platform/v8_inspector/public/V8DebuggerClient.h"
+#include "platform/v8_inspector/public/V8InspectorClient.h"
 
 namespace blink {
 
 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(context, callback, external, 0, v8::ConstructorBehavior::kThrow).ToLocal(&func))
         return;
     func->SetName(funcName);
     if (!obj->Set(context, funcName, func).FromMaybe(false))
         return;
 }
 
-V8DebuggerImpl* unwrapDebugger(const v8::FunctionCallbackInfo<v8::Value>& info)
+V8InspectorImpl* unwrapInspector(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     DCHECK(!info.Data().IsEmpty());
     DCHECK(info.Data()->IsExternal());
-    V8DebuggerImpl* debugger = static_cast<V8DebuggerImpl*>(info.Data().As<v8::External>()->Value());
-    DCHECK(debugger);
-    return debugger;
+    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, V8DebuggerImpl* debugger)
+v8::Local<v8::Object> V8InjectedScriptHost::create(v8::Local<v8::Context> context, V8InspectorImpl* inspector)
 {
-    v8::Isolate* isolate = debugger->isolate();
+    v8::Isolate* isolate = inspector->isolate();
     v8::Local<v8::Object> injectedScriptHost = v8::Object::New(isolate);
-    v8::Local<v8::External> debuggerExternal = v8::External::New(isolate, debugger);
+    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, "isTypedArray", V8InjectedScriptHost::isTypedArrayCallback, debuggerExternal);
     setFunctionProperty(context, injectedScriptHost, "subtype", V8InjectedScriptHost::subtypeCallback, debuggerExternal);
     setFunctionProperty(context, injectedScriptHost, "getInternalProperties", V8InjectedScriptHost::getInternalPropertiesCallback, debuggerExternal);
     setFunctionProperty(context, injectedScriptHost, "objectHasOwnProperty", V8InjectedScriptHost::objectHasOwnPropertyCallback, debuggerExternal);
     setFunctionProperty(context, injectedScriptHost, "bind", V8InjectedScriptHost::bindCallback, debuggerExternal);
     setFunctionProperty(context, injectedScriptHost, "proxyTargetValue", V8InjectedScriptHost::proxyTargetValueCallback, debuggerExternal);
     setFunctionProperty(context, injectedScriptHost, "prototype", V8InjectedScriptHost::prototypeCallback, debuggerExternal);
     return injectedScriptHost;
@@ skipping 10 matching lines @@
 
 void V8InjectedScriptHost::formatAccessorsAsProperties(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     DCHECK_EQ(info.Length(), 2);
     info.GetReturnValue().Set(false);
     if (!info[1]->IsFunction())
         return;
     // Check that function is user-defined.
     if (info[1].As<v8::Function>()->ScriptId() != v8::UnboundScript::kNoScriptId)
         return;
-    info.GetReturnValue().Set(unwrapDebugger(info)->client()->formatAccessorsAsProperties(info[0]));
+    info.GetReturnValue().Set(unwrapInspector(info)->client()->formatAccessorsAsProperties(info[0]));
 }
 
 void V8InjectedScriptHost::isTypedArrayCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
 
     info.GetReturnValue().Set(info[0]->IsTypedArray());
 }
 
@@ skipping 40 matching lines @@
         return;
     }
     if (value->IsNativeError()) {
         info.GetReturnValue().Set(toV8StringInternalized(isolate, "error"));
         return;
     }
     if (value->IsProxy()) {
         info.GetReturnValue().Set(toV8StringInternalized(isolate, "proxy"));
         return;
     }
-    String16 subtype = unwrapDebugger(info)->client()->valueSubtype(value);
+    String16 subtype = unwrapInspector(info)->client()->valueSubtype(value);
     if (!subtype.isEmpty()) {
         info.GetReturnValue().Set(toV8String(isolate, subtype));
         return;
     }
 }
 
 void V8InjectedScriptHost::getInternalPropertiesCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
     v8::Local<v8::Array> properties;
-    if (unwrapDebugger(info)->internalProperties(info.GetIsolate()->GetCurrentContext(), info[0]).ToLocal(&properties))
+    if (unwrapInspector(info)->internalProperties(info.GetIsolate()->GetCurrentContext(), info[0]).ToLocal(&properties))
         info.GetReturnValue().Set(properties);
 }
 
 void V8InjectedScriptHost::objectHasOwnPropertyCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 2 || !info[0]->IsObject() || !info[1]->IsString())
         return;
     bool result = info[0].As<v8::Object>()->HasOwnProperty(info.GetIsolate()->GetCurrentContext(), v8::Local<v8::String>::Cast(info[1])).FromMaybe(false);
     info.GetReturnValue().Set(v8::Boolean::New(info.GetIsolate(), result));
 }
@@ skipping 24 matching lines @@
     info.GetReturnValue().Set(target);
 }
 
 void V8InjectedScriptHost::prototypeCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     DCHECK(info.Length() > 0 && info[0]->IsObject());
     info.GetReturnValue().Set(info[0].As<v8::Object>()->GetPrototype());
 }
 
 } // namespace blink