[DevTools] ConsoleMessage storage moved from ConsoleAgent

Source/core/inspector/InspectorConsoleAgent.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 11 matching lines @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 
 #include "config.h"
 #include "core/inspector/InspectorConsoleAgent.h"
 
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptProfiler.h"
+#include "core/frame/FrameConsole.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/ConsoleMessage.h"
+#include "core/inspector/ConsoleMessageStorage.h"
+#include "core/inspector/IdentifiersFactory.h"
+#include "core/inspector/InjectedScript.h"
 #include "core/inspector/InjectedScriptHost.h"
 #include "core/inspector/InjectedScriptManager.h"
-#include "core/inspector/InspectorConsoleMessage.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InspectorTimelineAgent.h"
 #include "core/inspector/InspectorTracingAgent.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/ScriptArguments.h"
+#include "core/inspector/ScriptAsyncCallStack.h"
 #include "core/inspector/ScriptCallFrame.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/Page.h"
 #include "core/workers/WorkerGlobalScopeProxy.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceResponse.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
-static const unsigned maximumConsoleMessages = 1000;
-static const int expireConsoleMessagesStep = 100;
-
 namespace ConsoleAgentState {
 static const char monitoringXHR[] = "monitoringXHR";
 static const char consoleMessagesEnabled[] = "consoleMessagesEnabled";
 static const char tracingBasedTimeline[] = "tracingBasedTimeline";
 }
 
 int InspectorConsoleAgent::s_enabledAgentCount = 0;
 
 InspectorConsoleAgent::InspectorConsoleAgent(InspectorTimelineAgent* timelineAgent, InspectorTracingAgent* tracingAgent, InjectedScriptManager* injectedScriptManager)
     : InspectorBaseAgent<InspectorConsoleAgent>("Console")
     , m_timelineAgent(timelineAgent)
     , m_tracingAgent(tracingAgent)
     , m_injectedScriptManager(injectedScriptManager)
     , m_frontend(0)
-    , m_expiredConsoleMessageCount(0)
     , m_enabled(false)
 {
 }
 
 InspectorConsoleAgent::~InspectorConsoleAgent()
 {
 #if !ENABLE(OILPAN)
     m_instrumentingAgents->setInspectorConsoleAgent(0);
 #endif
 }
@@ skipping 15 matching lines @@
 {
     if (m_enabled)
         return;
     m_enabled = true;
     if (!s_enabledAgentCount)
         ScriptController::setCaptureCallStackForUncaughtExceptions(true);
     ++s_enabledAgentCount;
 
     m_state->setBoolean(ConsoleAgentState::consoleMessagesEnabled, true);
 
-    if (m_expiredConsoleMessageCount) {
-        InspectorConsoleMessage expiredMessage(OtherMessageSource, LogMessageType, WarningMessageLevel, String::format("%d console messages are not shown.", m_expiredConsoleMessageCount));
-        expiredMessage.setTimestamp(0);
-        expiredMessage.addToFrontend(m_frontend, m_injectedScriptManager, false);
+    ConsoleMessageStorage* storage = messageStorage();
+    if (storage) {
+        if (storage->expiredCount()) {
+            RefPtr<ConsoleMessage> expiredMessage = ConsoleMessage::create(OtherMessageSource, WarningMessageLevel, String::format("%d console messages are not shown.", storage->expiredCount()));
+            expiredMessage->setTimestamp(0);
+            sendConsoleMessageToFrontend(expiredMessage, false);
+        }
+        size_t messageCount = storage->size();
+        for (size_t i = 0; i < messageCount; ++i)
+            sendConsoleMessageToFrontend(storage->at(i), false);
     }
-
-    size_t messageCount = m_consoleMessages.size();
-    for (size_t i = 0; i < messageCount; ++i)
-        m_consoleMessages[i]->addToFrontend(m_frontend, m_injectedScriptManager, false);
 }
 
 void InspectorConsoleAgent::disable(ErrorString*)
 {
     if (!m_enabled)
         return;
     m_enabled = false;
     if (!(--s_enabledAgentCount))
         ScriptController::setCaptureCallStackForUncaughtExceptions(false);
     m_state->setBoolean(ConsoleAgentState::consoleMessagesEnabled, false);
     m_state->setBoolean(ConsoleAgentState::tracingBasedTimeline, false);
 }
 
 void InspectorConsoleAgent::clearMessages(ErrorString*)
 {
-    m_consoleMessages.clear();
-    m_expiredConsoleMessageCount = 0;
+    ConsoleMessageStorage* storage = messageStorage();
+    if (storage)
+        storage->clear();
     m_injectedScriptManager->releaseObjectGroup("console");
     if (m_frontend && m_enabled)
         m_frontend->messagesCleared();
 }
 
 void InspectorConsoleAgent::reset()
 {
     ErrorString error;
     clearMessages(&error);
     m_times.clear();
@@ skipping 14 matching lines @@
     m_frontend = frontend->console();
 }
 
 void InspectorConsoleAgent::clearFrontend()
 {
     m_frontend = 0;
     String errorString;
     disable(&errorString);
 }
 
-void InspectorConsoleAgent::addMessageToConsole(ConsoleMessage* consoleMessage)
+void InspectorConsoleAgent::addMessageToConsole(PassRefPtr<ConsoleMessage> consoleMessage)
 {
-    InspectorConsoleMessage* message;
-    if (consoleMessage->callStack()) {
-        message = new InspectorConsoleMessage(consoleMessage->source(), LogMessageType, consoleMessage->level(), consoleMessage->message(), consoleMessage->callStack(), consoleMessage->requestIdentifier());
-    } else {
-        bool shouldGenerateCallStack = m_frontend;
-        message = new InspectorConsoleMessage(shouldGenerateCallStack, consoleMessage->source(), LogMessageType, consoleMessage->level(), consoleMessage->message(), consoleMessage->url(), consoleMessage->lineNumber(), consoleMessage->columnNumber(), consoleMessage->scriptState(), consoleMessage->requestIdentifier());
-    }
-    message->setWorkerGlobalScopeProxy(consoleMessage->workerId());
-    addConsoleMessage(adoptPtr(message));
+    if (m_frontend && m_enabled)
+        sendConsoleMessageToFrontend(consoleMessage, true);
 }
 
 void InspectorConsoleAgent::adoptWorkerConsoleMessages(WorkerGlobalScopeProxy* proxy)
 {
-    for (size_t i = 0; i < m_consoleMessages.size(); i++) {
-        if (m_consoleMessages[i]->workerGlobalScopeProxy() == proxy)
-            m_consoleMessages[i]->setWorkerGlobalScopeProxy(nullptr);
+    ConsoleMessageStorage* storage = messageStorage();
+    if (storage) {
+        size_t messageCount = storage->size();
+        for (size_t i = 0; i < messageCount; i++) {
+            if (storage->at(i)->workerId() == proxy)
+                storage->at(i)->setWorkerId(nullptr);
+        }
     }
 }
 
 void InspectorConsoleAgent::addConsoleAPIMessageToConsole(MessageType type, MessageLevel level, const String& message, ScriptState* scriptState, PassRefPtrWillBeRawPtr<ScriptArguments> arguments, unsigned long requestIdentifier)
 {
     if (type == ClearMessageType) {
         ErrorString error;
         clearMessages(&error);
     }
 
-    addConsoleMessage(adoptPtr(new InspectorConsoleMessage(ConsoleAPIMessageSource, type, level, message, arguments, scriptState, requestIdentifier)));
+    RefPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(ConsoleAPIMessageSource, level, message);

[vsevik, 2014/08/14 08:06:22]

This code belongs to ConsoleBase and we'd better move it there before this
patch.

[kozyatinskiy1, 2014/08/20 13:44:18]

Done.

+    consoleMessage->setType(type);
+    consoleMessage->setScriptState(scriptState);
+    consoleMessage->setScriptArguments(arguments);
+    consoleMessage->setRequestIdentifier(requestIdentifier);
+
+    storeConsoleMessage(consoleMessage);
+    addMessageToConsole(consoleMessage.release());
 }
 
 Vector<unsigned> InspectorConsoleAgent::consoleMessageArgumentCounts()

[vsevik, 2014/08/14 08:06:22]

This method is only used for tests. There is no reason why it should go through
instrumentation to reach console message storage that becomes a core blink
feature after this patch.

[kozyatinskiy1, 2014/08/20 13:44:18]

Done.

 {
-    Vector<unsigned> result(m_consoleMessages.size());
-    for (size_t i = 0; i < m_consoleMessages.size(); i++)
-        result[i] = m_consoleMessages[i]->argumentCount();
-    return result;
+    ConsoleMessageStorage* storage = messageStorage();
+    if (storage)
+        return storage->argumentCounts();
+    return Vector<unsigned>();
 }
 
 void InspectorConsoleAgent::consoleTime(ExecutionContext*, const String& title)
 {
     // Follow Firebug's behavior of requiring a title that is not null or
     // undefined for timing functions
     if (title.isNull())
         return;
 
     m_times.add(title, monotonicallyIncreasingTime());
@@ skipping 51 matching lines @@
     String identifier = title.isEmpty() ? String(lastCaller.sourceURL() + ':' + String::number(lastCaller.lineNumber()))
                                         : String(title + '@');
 
     HashCountedSet<String>::AddResult result = m_counts.add(identifier);
     String message = title + ": " + String::number(result.storedValue->value);
     addConsoleAPIMessageToConsole(LogMessageType, DebugMessageLevel, message, scriptState, nullptr);
 }
 
 void InspectorConsoleAgent::frameWindowDiscarded(LocalDOMWindow* window)
 {
-    size_t messageCount = m_consoleMessages.size();
-    for (size_t i = 0; i < messageCount; ++i)
-        m_consoleMessages[i]->windowCleared(window);
+    ConsoleMessageStorage* storage = messageStorage();
+    if (storage)
+        storage->windowCleared(window);

[vsevik, 2014/08/14 08:06:22]

This is a basic storage functionality and should definitely not go through the
instrumentation.

[kozyatinskiy1, 2014/08/20 13:44:18]

Done.

+
     m_injectedScriptManager->discardInjectedScriptsFor(window);
 }
 
 void InspectorConsoleAgent::didCommitLoad(LocalFrame* frame, DocumentLoader* loader)
 {
     if (loader->frame() != frame->page()->mainFrame())
         return;
     reset();
 }
 
 void InspectorConsoleAgent::didFinishXHRLoading(XMLHttpRequest*, ThreadableLoaderClient*, unsigned long requestIdentifier, ScriptString, const AtomicString& method, const String& url, const String& sendURL, unsigned sendLineNumber)
 {
     if (m_frontend && m_state->getBoolean(ConsoleAgentState::monitoringXHR)) {
         String message = "XHR finished loading: " + method + " \"" + url + "\".";
         RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(NetworkMessageSource, DebugMessageLevel, message, sendURL, sendLineNumber);
         consoleMessage->setRequestIdentifier(requestIdentifier);
-        addMessageToConsole(consoleMessage.get());
+        storeConsoleMessage(consoleMessage);

[vsevik, 2014/08/14 08:06:22]

These two methods are always called together and this is going to be solved by
moving instrumentation call to storage from storage host.

[kozyatinskiy1, 2014/08/20 13:44:18]

Done.

+        addMessageToConsole(consoleMessage.release());

[vsevik, 2014/08/14 08:06:22]

Actually since this storeConsoleMessage approach is a hack to workaround the
fact that we don't want to rebaseline hundreds of tests when all these message
get to embedder, I think that we should only use it when necessary (meaning when
we actually have tests that would need to be rebaselined otherwise). I don't
think we should do that for ConsoleAPI messages and XHR logging.
We could address this in the next patches though.

[kozyatinskiy1, 2014/08/20 13:44:18]

The tests are not broken.

     }
 }
 
-void InspectorConsoleAgent::didReceiveResourceResponse(LocalFrame*, unsigned long requestIdentifier, DocumentLoader* loader, const ResourceResponse& response, ResourceLoader* resourceLoader)
+void InspectorConsoleAgent::didReceiveResourceResponse(LocalFrame* frame, unsigned long requestIdentifier, DocumentLoader* loader, const ResourceResponse& response, ResourceLoader* resourceLoader)

[vsevik, 2014/08/14 08:06:22]

frame is not used

[kozyatinskiy1, 2014/08/20 13:44:18]

Done.

 {
     if (!loader)
         return;
     if (response.httpStatusCode() >= 400) {
         String message = "Failed to load resource: the server responded with a status of " + String::number(response.httpStatusCode()) + " (" + response.httpStatusText() + ')';
         RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(NetworkMessageSource, ErrorMessageLevel, message, response.url().string());
         consoleMessage->setRequestIdentifier(requestIdentifier);
-        addMessageToConsole(consoleMessage.get());
+        storeConsoleMessage(consoleMessage);
+        addMessageToConsole(consoleMessage.release());
     }
 }
 
 void InspectorConsoleAgent::didFailLoading(unsigned long requestIdentifier, const ResourceError& error)
 {
     if (error.isCancellation()) // Report failures only.
         return;
     StringBuilder message;
     message.appendLiteral("Failed to load resource");
     if (!error.localizedDescription().isEmpty()) {
         message.appendLiteral(": ");
         message.append(error.localizedDescription());
     }
     RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(NetworkMessageSource, ErrorMessageLevel, message.toString(), error.failingURL());
     consoleMessage->setRequestIdentifier(requestIdentifier);
-    addMessageToConsole(consoleMessage.get());
+    storeConsoleMessage(consoleMessage);
+    addMessageToConsole(consoleMessage.release());
 }
 
 void InspectorConsoleAgent::setMonitoringXHREnabled(ErrorString*, bool enabled)
 {
     m_state->setBoolean(ConsoleAgentState::monitoringXHR, enabled);
 }
 
-void InspectorConsoleAgent::addConsoleMessage(PassOwnPtr<InspectorConsoleMessage> consoleMessage)
+void InspectorConsoleAgent::storeConsoleMessage(PassRefPtr<ConsoleMessage> consoleMessage)
 {
-    ASSERT_ARG(consoleMessage, consoleMessage);
+    ConsoleMessageStorage* storage = messageStorage();
+    if (storage)
+        storage->addMessage(consoleMessage);
+}
 
-    if (m_frontend && m_enabled)
-        consoleMessage->addToFrontend(m_frontend, m_injectedScriptManager, true);
+static TypeBuilder::Console::ConsoleMessage::Source::Enum messageSourceValue(MessageSource source)
+{
+    switch (source) {
+    case XMLMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Xml;
+    case JSMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Javascript;
+    case NetworkMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Network;
+    case ConsoleAPIMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Console_api;
+    case StorageMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Storage;
+    case AppCacheMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Appcache;
+    case RenderingMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Rendering;
+    case CSSMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Css;
+    case SecurityMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Security;
+    case OtherMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Other;
+    case DeprecationMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Deprecation;
+    }
+    return TypeBuilder::Console::ConsoleMessage::Source::Other;
+}
 
-    m_consoleMessages.append(consoleMessage);
+static TypeBuilder::Console::ConsoleMessage::Type::Enum messageTypeValue(MessageType type)
+{
+    switch (type) {
+    case LogMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Log;
+    case ClearMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Clear;
+    case DirMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Dir;
+    case DirXMLMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Dirxml;
+    case TableMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Table;
+    case TraceMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Trace;
+    case StartGroupMessageType: return TypeBuilder::Console::ConsoleMessage::Type::StartGroup;
+    case StartGroupCollapsedMessageType: return TypeBuilder::Console::ConsoleMessage::Type::StartGroupCollapsed;
+    case EndGroupMessageType: return TypeBuilder::Console::ConsoleMessage::Type::EndGroup;
+    case AssertMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Assert;
+    }
+    return TypeBuilder::Console::ConsoleMessage::Type::Log;
+}
 
-    if (!m_frontend && m_consoleMessages.size() >= maximumConsoleMessages) {
-        m_expiredConsoleMessageCount += expireConsoleMessagesStep;
-        m_consoleMessages.remove(0, expireConsoleMessagesStep);
+static TypeBuilder::Console::ConsoleMessage::Level::Enum messageLevelValue(MessageLevel level)
+{
+    switch (level) {
+    case DebugMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Debug;
+    case LogMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Log;
+    case WarningMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Warning;
+    case ErrorMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Error;
+    case InfoMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Info;
     }
+    return TypeBuilder::Console::ConsoleMessage::Level::Log;
+}
+
+void InspectorConsoleAgent::sendConsoleMessageToFrontend(PassRefPtr<ConsoleMessage> consoleMessage, bool generatePreview)
+{
+    if (consoleMessage->workerId())
+        return;
+
+    RefPtr<TypeBuilder::Console::ConsoleMessage> jsonObj = TypeBuilder::Console::ConsoleMessage::create()
+        .setSource(messageSourceValue(consoleMessage->source()))
+        .setLevel(messageLevelValue(consoleMessage->level()))
+        .setText(consoleMessage->message())
+        .setTimestamp(consoleMessage->timestamp());
+    // FIXME: only send out type for ConsoleAPI source messages.
+    jsonObj->setType(messageTypeValue(consoleMessage->type()));
+    jsonObj->setLine(static_cast<int>(consoleMessage->lineNumber()));
+    jsonObj->setColumn(static_cast<int>(consoleMessage->columnNumber()));
+    jsonObj->setUrl(consoleMessage->url());
+    ScriptState* scriptState = consoleMessage->scriptState();
+    if (scriptState)
+        jsonObj->setExecutionContextId(m_injectedScriptManager->injectedScriptIdFor(scriptState));
+    if (consoleMessage->source() == NetworkMessageSource && consoleMessage->requestIdentifier())
+        jsonObj->setNetworkRequestId(IdentifiersFactory::requestId(consoleMessage->requestIdentifier()));
+
+    RefPtr<ScriptArguments> arguments = consoleMessage->scriptArguments();
+    if (arguments && arguments->argumentCount()) {
+        InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(arguments->scriptState());
+        if (!injectedScript.isEmpty()) {
+            RefPtr<TypeBuilder::Array<TypeBuilder::Runtime::RemoteObject> > jsonArgs = TypeBuilder::Array<TypeBuilder::Runtime::RemoteObject>::create();
+            if (consoleMessage->type() == TableMessageType && generatePreview && arguments->argumentCount()) {
+                ScriptValue table = arguments->argumentAt(0);
+                ScriptValue columns = arguments->argumentCount() > 1 ? arguments->argumentAt(1) : ScriptValue();
+                RefPtr<TypeBuilder::Runtime::RemoteObject> inspectorValue = injectedScript.wrapTable(table, columns);
+                if (!inspectorValue) {
+                    ASSERT_NOT_REACHED();
+                    return;
+                }
+                jsonArgs->addItem(inspectorValue);
+            } else {
+                for (unsigned i = 0; i < arguments->argumentCount(); ++i) {
+                    RefPtr<TypeBuilder::Runtime::RemoteObject> inspectorValue = injectedScript.wrapObject(arguments->argumentAt(i), "console", generatePreview);
+                    if (!inspectorValue) {
+                        ASSERT_NOT_REACHED();
+                        return;
+                    }
+                    jsonArgs->addItem(inspectorValue);
+                }
+            }
+            jsonObj->setParameters(jsonArgs);
+        }
+    }
+    if (consoleMessage->callStack()) {
+        jsonObj->setStackTrace(consoleMessage->callStack()->buildInspectorArray());
+        RefPtrWillBeRawPtr<ScriptAsyncCallStack> asyncCallStack = consoleMessage->callStack()->asyncCallStack();
+        if (asyncCallStack)
+            jsonObj->setAsyncStackTrace(asyncCallStack->buildInspectorObject());
+    }
+    m_frontend->messageAdded(jsonObj);
+    m_frontend->flush();
 }
 
 class InspectableHeapObject FINAL : public InjectedScriptHost::InspectableObject {
 public:
     explicit InspectableHeapObject(int heapObjectId) : m_heapObjectId(heapObjectId) { }
     virtual ScriptValue get(ScriptState*) OVERRIDE
     {
         return ScriptProfiler::objectByHeapObjectId(m_heapObjectId);
     }
 private:
     int m_heapObjectId;
 };
 
 void InspectorConsoleAgent::addInspectedHeapObject(ErrorString*, int inspectedHeapObjectId)
 {
     m_injectedScriptManager->injectedScriptHost()->addInspectedObject(adoptPtr(new InspectableHeapObject(inspectedHeapObjectId)));
 }
 
 } // namespace blink