[DevTools] Rename V8Debugger to V8Inspector.

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

 // Copyright 2016 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/V8Console.h"
 
 #include "platform/inspector_protocol/Platform.h"
 #include "platform/inspector_protocol/String16.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
 #include "platform/v8_inspector/V8Compat.h"
 #include "platform/v8_inspector/V8ConsoleMessage.h"
 #include "platform/v8_inspector/V8DebuggerAgentImpl.h"
-#include "platform/v8_inspector/V8DebuggerImpl.h"
+#include "platform/v8_inspector/V8InspectorImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8ProfilerAgentImpl.h"
 #include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
-#include "platform/v8_inspector/public/V8DebuggerClient.h"
+#include "platform/v8_inspector/public/V8InspectorClient.h"
 
 namespace blink {
 
 namespace {
 
 v8::Local<v8::Private> inspectedContextPrivateKey(v8::Isolate* isolate)
 {
     return v8::Private::ForApi(isolate, toV8StringInternalized(isolate, "V8Console#InspectedContext"));
 }
 
 class ConsoleHelper {
     PROTOCOL_DISALLOW_COPY(ConsoleHelper);
 public:
     ConsoleHelper(const v8::FunctionCallbackInfo<v8::Value>& info)
         : m_info(info)
         , m_isolate(info.GetIsolate())
         , m_context(info.GetIsolate()->GetCurrentContext())
         , m_inspectedContext(nullptr)
-        , m_debuggerClient(nullptr)
+        , m_inspectorClient(nullptr)
     {
     }
 
     v8::Local<v8::Object> ensureConsole()
     {
         if (m_console.IsEmpty()) {
             DCHECK(!m_info.Data().IsEmpty());
             DCHECK(!m_info.Data()->IsUndefined());
             m_console = m_info.Data().As<v8::Object>();
         }
         return m_console;
     }
 
     InspectedContext* ensureInspectedContext()
     {
         if (m_inspectedContext)
             return m_inspectedContext;
         v8::Local<v8::Object> console = ensureConsole();
 
         v8::Local<v8::Private> key = inspectedContextPrivateKey(m_isolate);
         v8::Local<v8::Value> inspectedContextValue;
         if (!console->GetPrivate(m_context, key).ToLocal(&inspectedContextValue))
             return nullptr;
         DCHECK(inspectedContextValue->IsExternal());
         m_inspectedContext = static_cast<InspectedContext*>(inspectedContextValue.As<v8::External>()->Value());
         return m_inspectedContext;
     }
 
-    V8DebuggerClient* ensureDebuggerClient()
+    V8InspectorClient* ensureDebuggerClient()
     {
-        if (m_debuggerClient)
-            return m_debuggerClient;
+        if (m_inspectorClient)
+            return m_inspectorClient;
         InspectedContext* inspectedContext = ensureInspectedContext();
         if (!inspectedContext)
             return nullptr;
-        m_debuggerClient = inspectedContext->debugger()->client();
-        return m_debuggerClient;
+        m_inspectorClient = inspectedContext->inspector()->client();
+        return m_inspectorClient;
     }
 
     void reportCall(ConsoleAPIType type)
     {
         if (!m_info.Length())
             return;
         std::vector<v8::Local<v8::Value>> arguments;
         for (int i = 0; i < m_info.Length(); ++i)
             arguments.push_back(m_info[i]);
         reportCall(type, arguments);
@@ skipping 13 matching lines @@
     {
         std::vector<v8::Local<v8::Value>> arguments(1, toV8String(m_isolate, message));
         reportCall(type, arguments);
     }
 
     void reportCall(ConsoleAPIType type, const std::vector<v8::Local<v8::Value>>& arguments)
     {
         InspectedContext* inspectedContext = ensureInspectedContext();
         if (!inspectedContext)
             return;
-        V8DebuggerImpl* debugger = inspectedContext->debugger();
-        std::unique_ptr<V8ConsoleMessage> message = V8ConsoleMessage::createForConsoleAPI(debugger->client()->currentTimeMS(), type, arguments, debugger->captureStackTraceImpl(false), inspectedContext);
-        debugger->ensureConsoleMessageStorage(inspectedContext->contextGroupId())->addMessage(std::move(message));
+        V8InspectorImpl* inspector = inspectedContext->inspector();
+        std::unique_ptr<V8ConsoleMessage> message = V8ConsoleMessage::createForConsoleAPI(inspector->client()->currentTimeMS(), type, arguments, inspector->captureStackTraceImpl(false), inspectedContext);
+        inspector->ensureConsoleMessageStorage(inspectedContext->contextGroupId())->addMessage(std::move(message));
     }
 
     void reportDeprecatedCall(const char* id, const String16& message)
     {
         if (checkAndSetPrivateFlagOnConsole(id, false))
             return;
         std::vector<v8::Local<v8::Value>> arguments(1, toV8String(m_isolate, message));
         reportCall(ConsoleAPIType::kWarning, arguments);
     }
 
@@ skipping 103 matching lines @@
                 return session->debuggerAgent();
         }
         return nullptr;
     }
 
     V8InspectorSessionImpl* currentSession()
     {
         InspectedContext* inspectedContext = ensureInspectedContext();
         if (!inspectedContext)
             return nullptr;
-        return inspectedContext->debugger()->sessionForContextGroup(inspectedContext->contextGroupId());
+        return inspectedContext->inspector()->sessionForContextGroup(inspectedContext->contextGroupId());
     }
 
 private:
     const v8::FunctionCallbackInfo<v8::Value>& m_info;
     v8::Isolate* m_isolate;
     v8::Local<v8::Context> m_context;
     v8::Local<v8::Object> m_console;
     InspectedContext* m_inspectedContext;
-    V8DebuggerClient* m_debuggerClient;
+    V8InspectorClient* m_inspectorClient;
 
     bool checkAndSetPrivateFlagOnConsole(const char* name, bool defaultValue)
     {
         v8::Local<v8::Object> console = ensureConsole();
         v8::Local<v8::Private> key = v8::Private::ForApi(m_isolate, toV8StringInternalized(m_isolate, name));
         v8::Local<v8::Value> flagValue;
         if (!console->GetPrivate(m_context, key).ToLocal(&flagValue))
             return defaultValue;
         DCHECK(flagValue->IsUndefined() || flagValue->IsBoolean());
         if (flagValue->IsBoolean()) {
@@ skipping 150 matching lines @@
 void V8Console::profileEndCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ConsoleHelper helper(info);
     if (V8ProfilerAgentImpl* profilerAgent = helper.profilerAgent())
         profilerAgent->consoleProfileEnd(helper.firstArgToString(String16()));
 }
 
 static void timeFunction(const v8::FunctionCallbackInfo<v8::Value>& info, bool timelinePrefix)
 {
     ConsoleHelper helper(info);
-    if (V8DebuggerClient* client = helper.ensureDebuggerClient()) {
+    if (V8InspectorClient* client = helper.ensureDebuggerClient()) {
         String16 protocolTitle = helper.firstArgToString("default");
         if (timelinePrefix)
             protocolTitle = "Timeline '" + protocolTitle + "'";
         client->consoleTime(protocolTitle);
 
         v8::Local<v8::Map> timeMap;
         if (!helper.privateMap("V8Console#timeMap").ToLocal(&timeMap))
             return;
         helper.setDoubleOnMap(timeMap, protocolTitle, client->currentTimeMS());
     }
 }
 
 static void timeEndFunction(const v8::FunctionCallbackInfo<v8::Value>& info, bool timelinePrefix)
 {
     ConsoleHelper helper(info);
-    if (V8DebuggerClient* client = helper.ensureDebuggerClient()) {
+    if (V8InspectorClient* client = helper.ensureDebuggerClient()) {
         String16 protocolTitle = helper.firstArgToString("default");
         if (timelinePrefix)
             protocolTitle = "Timeline '" + protocolTitle + "'";
         client->consoleTimeEnd(protocolTitle);
 
         v8::Local<v8::Map> timeMap;
         if (!helper.privateMap("V8Console#timeMap").ToLocal(&timeMap))
             return;
         double elapsed = client->currentTimeMS() - helper.getDoubleFromMap(timeMap, protocolTitle, 0.0);
         String16 message = protocolTitle + ": " + String16::fromDoubleFixedPrecision(elapsed, 3) + "ms";
@@ skipping 19 matching lines @@
 }
 
 void V8Console::timeEndCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     timeEndFunction(info, false);
 }
 
 void V8Console::timeStampCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ConsoleHelper helper(info);
-    if (V8DebuggerClient* client = helper.ensureDebuggerClient())
+    if (V8InspectorClient* client = helper.ensureDebuggerClient())
         client->consoleTimeStamp(helper.firstArgToString(String16()));
 }
 
 void V8Console::memoryGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    if (V8DebuggerClient* client = ConsoleHelper(info).ensureDebuggerClient()) {
+    if (V8InspectorClient* client = ConsoleHelper(info).ensureDebuggerClient()) {
         v8::Local<v8::Value> memoryValue;
         if (!client->memoryInfo(info.GetIsolate(), info.GetIsolate()->GetCurrentContext()).ToLocal(&memoryValue))
             return;
         info.GetReturnValue().Set(memoryValue);
     }
 }
 
 void V8Console::memorySetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     // We can't make the attribute readonly as it breaks existing code that relies on being able to assign to console.memory in strict mode. Instead, the setter just ignores the passed value.  http://crbug.com/468611
@@ skipping 235 matching lines @@
     createBoundFunctionProperty(context, commandLineAPI, "unmonitor", V8Console::unmonitorFunctionCallback, "function unmonitor(function) { [Command Line API] }");
     createBoundFunctionProperty(context, commandLineAPI, "inspect", V8Console::inspectCallback, "function inspect(object) { [Command Line API] }");
     createBoundFunctionProperty(context, commandLineAPI, "copy", V8Console::copyCallback, "function copy(value) { [Command Line API] }");
     createBoundFunctionProperty(context, commandLineAPI, "$_", V8Console::lastEvaluationResultCallback);
     createBoundFunctionProperty(context, commandLineAPI, "$0", V8Console::inspectedObject0);
     createBoundFunctionProperty(context, commandLineAPI, "$1", V8Console::inspectedObject1);
     createBoundFunctionProperty(context, commandLineAPI, "$2", V8Console::inspectedObject2);
     createBoundFunctionProperty(context, commandLineAPI, "$3", V8Console::inspectedObject3);
     createBoundFunctionProperty(context, commandLineAPI, "$4", V8Console::inspectedObject4);
 
-    inspectedContext->debugger()->client()->installAdditionalCommandLineAPI(context, commandLineAPI);
+    inspectedContext->inspector()->client()->installAdditionalCommandLineAPI(context, commandLineAPI);
 
     commandLineAPI->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, inspectedContext));
     return commandLineAPI;
 }
 
 static bool isCommandLineAPIGetter(const String16& name)
 {
     if (name.length() != 2)
         return false;
     // $0 ... $4, $_
@@ skipping 77 matching lines @@
             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);
         }
     }
 }
 
 } // namespace blink