[DevTools] Fix v8_inspector compilation with node

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/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"
 
 namespace blink {
 
 namespace {
 
-String messageSourceValue(MessageSource source)
+String16 messageSourceValue(MessageSource source)
 {
     switch (source) {
     case XMLMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Xml;
     case JSMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Javascript;
     case NetworkMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Network;
     case ConsoleAPIMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::ConsoleApi;
     case StorageMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Storage;
     case AppCacheMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Appcache;
     case RenderingMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Rendering;
     case SecurityMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Security;
     case OtherMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Other;
     case DeprecationMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Deprecation;
     }
     return protocol::Console::ConsoleMessage::SourceEnum::Other;
 }
 
 
-String messageTypeValue(MessageType type)
+String16 messageTypeValue(MessageType type)
 {
     switch (type) {
     case LogMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Log;
     case ClearMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Clear;
     case DirMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Dir;
     case DirXMLMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Dirxml;
     case TableMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Table;
     case TraceMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Trace;
     case StartGroupMessageType: return protocol::Console::ConsoleMessage::TypeEnum::StartGroup;
     case StartGroupCollapsedMessageType: return protocol::Console::ConsoleMessage::TypeEnum::StartGroupCollapsed;
     case EndGroupMessageType: return protocol::Console::ConsoleMessage::TypeEnum::EndGroup;
     case AssertMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Assert;
     case TimeEndMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Log;
     case CountMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Log;
     }
     return protocol::Console::ConsoleMessage::TypeEnum::Log;
 }
 
-String messageLevelValue(MessageLevel level)
+String16 messageLevelValue(MessageLevel level)
 {
     switch (level) {
     case DebugMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Debug;
     case LogMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Log;
     case WarningMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Warning;
     case ErrorMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Error;
     case InfoMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Info;
     }
     return protocol::Console::ConsoleMessage::LevelEnum::Log;
 }
@@ skipping 66 matching lines @@
                 return append(stringValue);
         }
         v8::Local<v8::String> stringValue;
         if (!value->ToString(m_isolate->GetCurrentContext()).ToLocal(&stringValue))
             return false;
         return append(stringValue);
     }
 
     bool append(v8::Local<v8::Array> array)
     {
-        if (m_visitedArrays.contains(array))
-            return true;
+        for (const auto& it : m_visitedArrays) {
+            if (it == array)
+                return true;
+        }
         uint32_t length = array->Length();
         if (length > m_arrayLimit)
             return false;
         if (m_visitedArrays.size() > maxStackDepthLimit)
             return false;
 
         bool result = true;
         m_arrayLimit -= length;
-        m_visitedArrays.append(array);
+        m_visitedArrays.push_back(array);
         for (uint32_t i = 0; i < length; ++i) {
             if (i)
                 m_builder.append(',');
             if (!append(array->Get(i), IgnoreNull | IgnoreUndefined)) {
                 result = false;
                 break;
             }
         }
-        m_visitedArrays.removeLast();
+        m_visitedArrays.pop_back();
         return result;
     }
 
     bool append(v8::Local<v8::Symbol> symbol)
     {
         m_builder.append("Symbol(");
         bool result = append(symbol->Name(), IgnoreUndefined);
         m_builder.append(')');
         return result;
     }
@@ skipping 10 matching lines @@
     String16 toString()
     {
         if (m_tryCatch.HasCaught())
             return String16();
         return m_builder.toString();
     }
 
     uint32_t m_arrayLimit;
     v8::Isolate* m_isolate;
     String16Builder m_builder;
-    Vector<v8::Local<v8::Array>> m_visitedArrays;
+    std::vector<v8::Local<v8::Array>> m_visitedArrays;
     v8::TryCatch m_tryCatch;
 };
 
 } // namespace
 
 V8ConsoleMessage::V8ConsoleMessage(
     double timestamp,
     MessageSource source,
     MessageLevel level,
     const String16& message,
@@ skipping 32 matching lines @@
         protocol::Console::ConsoleMessage::create()
         .setSource(messageSourceValue(m_source))
         .setLevel(messageLevelValue(m_level))
         .setText(m_message)
         .setTimestamp(m_timestamp / 1000) // TODO(dgozman): migrate this to milliseconds.
         .build();
     result->setType(messageTypeValue(m_type));
     result->setLine(static_cast<int>(m_lineNumber));
     result->setColumn(static_cast<int>(m_columnNumber));
     if (m_scriptId)
-        result->setScriptId(String::number(m_scriptId));
+        result->setScriptId(String16::number(m_scriptId));
     result->setUrl(m_url);
     if (m_source == NetworkMessageSource && !m_requestIdentifier.isEmpty())
         result->setNetworkRequestId(m_requestIdentifier);
     if (m_contextId)
         result->setExecutionContextId(m_contextId);
     std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> args = wrapArguments(session, generatePreview);
     if (args)
         result->setParameters(std::move(args));
     if (m_stackTrace)
         result->setStack(m_stackTrace->buildInspectorObject());
@@ skipping 38 matching lines @@
 {
     if (m_origin == V8MessageOrigin::kException) {
         // TODO(dgozman): unify with InjectedScript::createExceptionDetails.
         std::unique_ptr<protocol::Runtime::ExceptionDetails> details = protocol::Runtime::ExceptionDetails::create().setText(m_message).build();
         details->setUrl(m_url);
         if (m_lineNumber)
             details->setLineNumber(static_cast<int>(m_lineNumber) - 1);
         if (m_columnNumber)
             details->setColumnNumber(static_cast<int>(m_columnNumber) - 1);
         if (m_scriptId)
-            details->setScriptId(String::number(m_scriptId));
+            details->setScriptId(String16::number(m_scriptId));
         if (m_stackTrace)
             details->setStack(m_stackTrace->buildInspectorObject());
 
         std::unique_ptr<protocol::Runtime::RemoteObject> exception = wrapException(session, generatePreview);
 
         if (exception)
             frontend->exceptionThrown(m_exceptionId, m_timestamp, std::move(details), std::move(exception), m_contextId);
         else
             frontend->exceptionThrown(m_exceptionId, m_timestamp, std::move(details));
         return;
@@ skipping 148 matching lines @@
     }
 }
 
 void V8ConsoleMessageStorage::contextDestroyed(int contextId)
 {
     for (size_t i = 0; i < m_messages.size(); ++i)
         m_messages[i]->contextDestroyed(contextId);
 }
 
 } // namespace blink