[inspector] introduced memory size limit for console message storage

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"
 #include "src/inspector/v8-console-agent-impl.h"
 #include "src/inspector/v8-inspector-impl.h"
 #include "src/inspector/v8-inspector-session-impl.h"
 #include "src/inspector/v8-runtime-agent-impl.h"
 #include "src/inspector/v8-stack-trace-impl.h"
 
 #include "include/v8-inspector.h"
@@ skipping 34 matching lines @@
       return protocol::Runtime::ConsoleAPICalled::TypeEnum::Assert;
     case ConsoleAPIType::kTimeEnd:
       return protocol::Runtime::ConsoleAPICalled::TypeEnum::Debug;
     case ConsoleAPIType::kCount:
       return protocol::Runtime::ConsoleAPICalled::TypeEnum::Debug;
   }
   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,
                            v8::Local<v8::Context> context) {
     V8ValueStringBuilder builder(context);
     if (!builder.append(value)) return String16();
     return builder.toString();
@@ skipping 293 matching lines @@
   std::unique_ptr<V8ConsoleMessage> message(
       new V8ConsoleMessage(V8MessageOrigin::kConsole, timestamp, String16()));
   if (stackTrace && !stackTrace->isEmpty()) {
     message->m_url = toString16(stackTrace->topSourceURL());
     message->m_lineNumber = stackTrace->topLineNumber();
     message->m_columnNumber = stackTrace->topColumnNumber();
   }
   message->m_stackTrace = std::move(stackTrace);
   message->m_type = type;
   message->m_contextId = contextId;
-  for (size_t i = 0; i < arguments.size(); ++i)
+  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::ValueSize(isolate, arguments.at(i));
+  }
   if (arguments.size())
     message->m_message = V8ValueStringBuilder::toString(arguments[0], context);
 
   V8ConsoleAPIType clientType = V8ConsoleAPIType::kLog;
   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)
@@ skipping 21 matching lines @@
       new V8ConsoleMessage(V8MessageOrigin::kException, timestamp, message));
   consoleMessage->setLocation(url, lineNumber, columnNumber,
                               std::move(stackTrace), scriptId);
   consoleMessage->m_exceptionId = exceptionId;
   consoleMessage->m_detailedMessage = detailedMessage;
   if (contextId && !exception.IsEmpty()) {
     consoleMessage->m_contextId = contextId;
     consoleMessage->m_arguments.push_back(
         std::unique_ptr<v8::Global<v8::Value>>(
             new v8::Global<v8::Value>(isolate, exception)));
+    consoleMessage->m_v8Size += v8::debug::ValueSize(isolate, exception);
   }
   return consoleMessage;
 }
 
 // static
 std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForRevokedException(
     double timestamp, const String16& messageText,
     unsigned revokedExceptionId) {
   std::unique_ptr<V8ConsoleMessage> message(new V8ConsoleMessage(
       V8MessageOrigin::kRevokedException, timestamp, messageText));
   message->m_revokedExceptionId = revokedExceptionId;
   return message;
 }
 
 void V8ConsoleMessage::contextDestroyed(int contextId) {
   if (contextId != m_contextId) return;
   m_contextId = 0;
   if (m_message.isEmpty()) m_message = "<message collected>";
   Arguments empty;
   m_arguments.swap(empty);
+  m_v8Size = 0;
 }
 
 // ------------------------ V8ConsoleMessageStorage ----------------------------
 
 V8ConsoleMessageStorage::V8ConsoleMessageStorage(V8InspectorImpl* inspector,
                                                  int contextGroupId)
-    : m_inspector(inspector),
-      m_contextGroupId(contextGroupId),
-      m_expiredCount(0) {}
+    : m_inspector(inspector), m_contextGroupId(contextGroupId) {}
 
 V8ConsoleMessageStorage::~V8ConsoleMessageStorage() { clear(); }
 
 void V8ConsoleMessageStorage::addMessage(
     std::unique_ptr<V8ConsoleMessage> message) {
   int contextGroupId = m_contextGroupId;
   V8InspectorImpl* inspector = m_inspector;
   if (message->type() == ConsoleAPIType::kClear) clear();
 
   V8InspectorSessionImpl* session =
       inspector->sessionForContextGroup(contextGroupId);
   if (session) {
     if (message->origin() == V8MessageOrigin::kConsole)
       session->consoleAgent()->messageAdded(message.get());
     session->runtimeAgent()->messageAdded(message.get());
   }
   if (!inspector->hasConsoleMessageStorage(contextGroupId)) return;
 
   DCHECK(m_messages.size() <= maxConsoleMessageCount);
   if (m_messages.size() == maxConsoleMessageCount) {
-    ++m_expiredCount;
+    m_estimatedSize -= m_messages.front()->estimatedSize();
     m_messages.pop_front();
   }
+  while (m_estimatedSize + message->estimatedSize() > maxConsoleMessageV8Size &&

[alph, 2017/01/25 23:45:43]

shouldn't you also count current message size?

[kozy, 2017/01/26 02:41:38]

m_estimatedSize is current storage size, messages->estimatedSize is size of new
(current) message.
Looks correct to me.

+         m_messages.size()) {

[alph, 2017/01/25 23:45:43]

nit: !m_messages.empty()

[kozy, 2017/01/26 02:41:38]

Done.

+    m_estimatedSize -= m_messages.front()->estimatedSize();
+    m_messages.pop_front();
+  }
+
   m_messages.push_back(std::move(message));
+  m_estimatedSize += m_messages.back()->estimatedSize();
 }
 
 void V8ConsoleMessageStorage::clear() {
   m_messages.clear();
-  m_expiredCount = 0;
+  m_estimatedSize = 0;
   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_estimatedSize = 0;
+  for (size_t i = 0; i < m_messages.size(); ++i) {
     m_messages[i]->contextDestroyed(contextId);
+    m_estimatedSize += m_messages[i]->estimatedSize();
+  }
 }
 
 }  // namespace v8_inspector