[DevTools] Rename V8Debugger to V8Inspector.

third_party/WebKit/Source/platform/v8_inspector/V8ConsoleMessage.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/V8ConsoleMessage.h"
 
 #include "platform/v8_inspector/InspectedContext.h"
 #include "platform/v8_inspector/V8ConsoleAgentImpl.h"
-#include "platform/v8_inspector/V8DebuggerImpl.h"
+#include "platform/v8_inspector/V8InspectorImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.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 {
 
 String16 consoleAPITypeValue(ConsoleAPIType type)
 {
     switch (type) {
     case ConsoleAPIType::kLog: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Log;
     case ConsoleAPIType::kDebug: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Debug;
@@ skipping 187 matching lines @@
     result->setLine(static_cast<int>(m_lineNumber));
     result->setColumn(static_cast<int>(m_columnNumber));
     result->setUrl(m_url);
     frontend->messageAdded(std::move(result));
 }
 
 std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> V8ConsoleMessage::wrapArguments(V8InspectorSessionImpl* session, bool generatePreview) const
 {
     if (!m_arguments.size() || !m_contextId)
         return nullptr;
-    InspectedContext* inspectedContext = session->debugger()->getContext(session->contextGroupId(), m_contextId);
+    InspectedContext* inspectedContext = session->inspector()->getContext(session->contextGroupId(), m_contextId);
     if (!inspectedContext)
         return nullptr;
 
     v8::Isolate* isolate = inspectedContext->isolate();
     v8::HandleScope handles(isolate);
     v8::Local<v8::Context> context = inspectedContext->context();
 
     std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> args = protocol::Array<protocol::Runtime::RemoteObject>::create();
     if (m_type == ConsoleAPIType::kTable && generatePreview) {
         v8::Local<v8::Value> table = m_arguments[0]->Get(isolate);
@@ skipping 56 matching lines @@
         return;
     }
     NOTREACHED();
 }
 
 std::unique_ptr<protocol::Runtime::RemoteObject> V8ConsoleMessage::wrapException(V8InspectorSessionImpl* session, bool generatePreview) const
 {
     if (!m_arguments.size() || !m_contextId)
         return nullptr;
     DCHECK_EQ(1u, m_arguments.size());
-    InspectedContext* inspectedContext = session->debugger()->getContext(session->contextGroupId(), m_contextId);
+    InspectedContext* inspectedContext = session->inspector()->getContext(session->contextGroupId(), m_contextId);
     if (!inspectedContext)
         return nullptr;
 
     v8::Isolate* isolate = inspectedContext->isolate();
     v8::HandleScope handles(isolate);
     // TODO(dgozman): should we use different object group?
     return session->wrapObject(inspectedContext->context(), m_arguments[0]->Get(isolate), "console", generatePreview);
 }
 
 V8MessageOrigin V8ConsoleMessage::origin() const
@@ skipping 27 matching lines @@
     if (type == ConsoleAPIType::kDebug || type == ConsoleAPIType::kCount || type == ConsoleAPIType::kTimeEnd)
         clientType = V8ConsoleAPIType::kDebug;
     else if (type == ConsoleAPIType::kError || type == ConsoleAPIType::kAssert)
         clientType = V8ConsoleAPIType::kError;
     else if (type == ConsoleAPIType::kWarning)
         clientType = V8ConsoleAPIType::kWarning;
     else if (type == ConsoleAPIType::kInfo)
         clientType = V8ConsoleAPIType::kInfo;
     else if (type == ConsoleAPIType::kClear)
         clientType = V8ConsoleAPIType::kClear;
-    context->debugger()->client()->consoleAPIMessage(context->contextGroupId(), clientType, message->m_message, message->m_url, message->m_lineNumber, message->m_columnNumber, message->m_stackTrace.get());
+    context->inspector()->client()->consoleAPIMessage(context->contextGroupId(), clientType, message->m_message, message->m_url, message->m_lineNumber, message->m_columnNumber, message->m_stackTrace.get());
 
     return message;
 }
 
 // static
 std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForException(double timestamp, const String16& detailedMessage, const String16& url, unsigned lineNumber, unsigned columnNumber, std::unique_ptr<V8StackTraceImpl> stackTrace, int scriptId, v8::Isolate* isolate, const String16& message, int contextId, v8::Local<v8::Value> exception, unsigned exceptionId)
 {
     std::unique_ptr<V8ConsoleMessage> consoleMessage = wrapUnique(new V8ConsoleMessage(V8MessageOrigin::kException, timestamp, message));
     consoleMessage->setLocation(url, lineNumber, columnNumber, std::move(stackTrace), scriptId);
     consoleMessage->m_exceptionId = exceptionId;
@@ skipping 19 matching lines @@
         return;
     m_contextId = 0;
     if (m_message.isEmpty())
         m_message = "<message collected>";
     Arguments empty;
     m_arguments.swap(empty);
 }
 
 // ------------------------ V8ConsoleMessageStorage ----------------------------
 
-V8ConsoleMessageStorage::V8ConsoleMessageStorage(V8DebuggerImpl* debugger, int contextGroupId)
-    : m_debugger(debugger)
+V8ConsoleMessageStorage::V8ConsoleMessageStorage(V8InspectorImpl* inspector, int contextGroupId)
+    : m_inspector(inspector)
     , m_contextGroupId(contextGroupId)
     , m_expiredCount(0)
 {
 }
 
 V8ConsoleMessageStorage::~V8ConsoleMessageStorage()
 {
     clear();
 }
 
 void V8ConsoleMessageStorage::addMessage(std::unique_ptr<V8ConsoleMessage> message)
 {
     if (message->type() == ConsoleAPIType::kClear)
         clear();
 
-    V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId);
+    V8InspectorSessionImpl* session = m_inspector->sessionForContextGroup(m_contextGroupId);
     if (session) {
         if (message->origin() == V8MessageOrigin::kConsole)
             session->consoleAgent()->messageAdded(message.get());
         session->runtimeAgent()->messageAdded(message.get());
     }
 
     DCHECK(m_messages.size() <= maxConsoleMessageCount);
     if (m_messages.size() == maxConsoleMessageCount) {
         ++m_expiredCount;
         m_messages.pop_front();
     }
     m_messages.push_back(std::move(message));
 }
 
 void V8ConsoleMessageStorage::clear()
 {
     m_messages.clear();
     m_expiredCount = 0;
-    if (V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId))
+    if (V8InspectorSessionImpl* session = m_inspector->sessionForContextGroup(m_contextGroupId))
         session->releaseObjectGroup("console");
 }
 
 void V8ConsoleMessageStorage::contextDestroyed(int contextId)
 {
     for (size_t i = 0; i < m_messages.size(); ++i)
         m_messages[i]->contextDestroyed(contextId);
 }
 
 } // namespace blink