Use all of the arguments to build the console messages

src/inspector/v8-console-message.cc

 // 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/v8-console-message.h"
 
 #include "src/debug/debug-interface.h"
 #include "src/inspector/inspected-context.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/string-util.h"
@@ skipping 47 matching lines @@
   return protocol::Runtime::ConsoleAPICalled::TypeEnum::Log;
 }
 
 const unsigned maxConsoleMessageCount = 1000;
 const int maxConsoleMessageV8Size = 10 * 1024 * 1024;
 const unsigned maxArrayItemsLimit = 10000;
 const unsigned maxStackDepthLimit = 32;
 
 class V8ValueStringBuilder {
  public:
-  static String16 toString(v8::Local<v8::Value> value,
+  static String16 toString(const std::vector<v8::Local<v8::Value>>& arguments,
                            v8::Local<v8::Context> context) {
     V8ValueStringBuilder builder(context);
-    if (!builder.append(value)) return String16();
+    for (size_t i = 0; i < arguments.size(); ++i) {
+      if (i > 0) builder.append(" ");
+      if (!builder.append(arguments.at(i))) return String16();
+    }
     return builder.toString();
   }
 
  private:
   enum {
     IgnoreNull = 1 << 0,
     IgnoreUndefined = 1 << 1,
   };
 
   explicit V8ValueStringBuilder(v8::Local<v8::Context> context)
@@ skipping 72 matching lines @@
     m_builder.append(')');
     return result;
   }
 
   bool append(v8::Local<v8::String> string) {
     if (m_tryCatch.HasCaught()) return false;
     if (!string.IsEmpty()) m_builder.append(toProtocolString(string));
     return true;
   }
 
+  bool append(const String16& string) {
+    m_builder.append(string);
+    return true;
+  }
+
   String16 toString() {
     if (m_tryCatch.HasCaught()) return String16();
     return m_builder.toString();
   }
 
   uint32_t m_arrayLimit;
   v8::Isolate* m_isolate;
   String16Builder m_builder;
   std::vector<v8::Local<v8::Array>> m_visitedArrays;
   v8::TryCatch m_tryCatch;
@@ skipping 195 matching lines @@
   message->m_stackTrace = std::move(stackTrace);
   message->m_type = type;
   message->m_contextId = contextId;
   for (size_t i = 0; i < arguments.size(); ++i) {
     message->m_arguments.push_back(std::unique_ptr<v8::Global<v8::Value>>(
         new v8::Global<v8::Value>(isolate, arguments.at(i))));
     message->m_v8Size +=
         v8::debug::EstimatedValueSize(isolate, arguments.at(i));
   }
   if (arguments.size())
-    message->m_message =
-        V8ValueStringBuilder::toString(arguments[0], v8Context);
+    message->m_message = V8ValueStringBuilder::toString(arguments, v8Context);
 
   v8::Isolate::MessageErrorLevel clientLevel = v8::Isolate::kMessageInfo;
   if (type == ConsoleAPIType::kDebug || type == ConsoleAPIType::kCount ||
       type == ConsoleAPIType::kTimeEnd) {
     clientLevel = v8::Isolate::kMessageDebug;
   } else if (type == ConsoleAPIType::kError ||
              type == ConsoleAPIType::kAssert) {
     clientLevel = v8::Isolate::kMessageError;
   } else if (type == ConsoleAPIType::kWarning) {
     clientLevel = v8::Isolate::kMessageWarning;
@@ skipping 133 matching lines @@
   m_estimatedSize = 0;
   for (size_t i = 0; i < m_messages.size(); ++i) {
     m_messages[i]->contextDestroyed(contextId);
     m_estimatedSize += m_messages[i]->estimatedSize();
   }
   auto it = m_data.find(contextId);
   if (it != m_data.end()) m_data.erase(contextId);
 }
 
 }  // namespace v8_inspector