Changeset 218603 in webkit


Ignore:
Timestamp:
Jun 20, 2017 11:35:31 AM (7 years ago)
Author:
Devin Rousso
Message:

Web Inspector: add console messages for WebGL shader compile and program link errors/warnings
​https://bugs.webkit.org/show_bug.cgi?id=143236
<rdar://problem/20352149>

Reviewed by Dean Jackson.

Source/WebCore:

Test: fast/canvas/webgl/shader-compile-logging.html

  • html/canvas/WebGLRenderingContextBase.h:
  • html/canvas/WebGLRenderingContextBase.cpp:

(WebCore::WebGLRenderingContextBase::checkFramebufferStatus):
(WebCore::WebGLRenderingContextBase::compileShader):
(WebCore::WebGLRenderingContextBase::recycleContext):
(WebCore::WebGLRenderingContextBase::checkTextureCompleteness):
(WebCore::WebGLRenderingContextBase::printToConsole):
(WebCore::WebGLRenderingContextBase::maybeRestoreContext):
(WebCore::WebGLRenderingContextBase::synthesizeGLError):
(WebCore::WebGLRenderingContextBase::printGLErrorToConsole): Deleted.
(WebCore::WebGLRenderingContextBase::printWarningToConsole): Deleted.
(WebCore::WebGLRenderingContextBase::printGLWarningToConsole): Deleted.
Unify console logging helper functions to all follow the same path. Additionally, errors
now generate stack traces. Shader compilation errors are now logged as well.

  • dom/Document.h:
  • dom/Document.cpp:

(WebCore::Document::addConsoleMessage):

  • dom/ScriptExecutionContext.h:

(WebCore::ScriptExecutionContext::AddConsoleMessageTask::AddConsoleMessageTask):

  • page/PageConsoleClient.h:
  • page/PageConsoleClient.cpp:

(WebCore::PageConsoleClient::addMessage):

  • workers/WorkerGlobalScope.h:

Add new path for logging to the console that accepts a ConsoleMessage.

LayoutTests:

  • fast/canvas/webgl/fragment-shader-assertion.html:
  • fast/canvas/webgl/shader-compile-logging-expected.txt: Added.
  • fast/canvas/webgl/shader-compile-logging.html: Added.
Location:
trunk
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r218600 r218603  
     12017-06-20  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: add console messages for WebGL shader compile and program link errors/warnings
     4        https://bugs.webkit.org/show_bug.cgi?id=143236
     5        <rdar://problem/20352149>
     6
     7        Reviewed by Dean Jackson.
     8
     9        * fast/canvas/webgl/fragment-shader-assertion.html:
     10        * fast/canvas/webgl/shader-compile-logging-expected.txt: Added.
     11        * fast/canvas/webgl/shader-compile-logging.html: Added.
     12
    1132017-06-19  Antoine Quint  <graouts@apple.com>
    214

  • trunk/LayoutTests/fast/canvas/webgl/fragment-shader-assertion.html

    r199340 r218603  
    44if (window.testRunner)
    55        testRunner.dumpAsText();
     6
     7if (window.internals)
     8    window.internals.settings.setWebGLErrorsToConsoleEnabled(false);
    69
    710function runTest() {

  • trunk/Source/WebCore/ChangeLog

    r218602 r218603  
     12017-06-20  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: add console messages for WebGL shader compile and program link errors/warnings
     4        https://bugs.webkit.org/show_bug.cgi?id=143236
     5        <rdar://problem/20352149>
     6
     7        Reviewed by Dean Jackson.
     8
     9        Test: fast/canvas/webgl/shader-compile-logging.html
     10
     11        * html/canvas/WebGLRenderingContextBase.h:
     12        * html/canvas/WebGLRenderingContextBase.cpp:
     13        (WebCore::WebGLRenderingContextBase::checkFramebufferStatus):
     14        (WebCore::WebGLRenderingContextBase::compileShader):
     15        (WebCore::WebGLRenderingContextBase::recycleContext):
     16        (WebCore::WebGLRenderingContextBase::checkTextureCompleteness):
     17        (WebCore::WebGLRenderingContextBase::printToConsole):
     18        (WebCore::WebGLRenderingContextBase::maybeRestoreContext):
     19        (WebCore::WebGLRenderingContextBase::synthesizeGLError):
     20        (WebCore::WebGLRenderingContextBase::printGLErrorToConsole): Deleted.
     21        (WebCore::WebGLRenderingContextBase::printWarningToConsole): Deleted.
     22        (WebCore::WebGLRenderingContextBase::printGLWarningToConsole): Deleted.
     23        Unify console logging helper functions to all follow the same path. Additionally, errors
     24        now generate stack traces. Shader compilation errors are now logged as well.
     25
     26        * dom/Document.h:
     27        * dom/Document.cpp:
     28        (WebCore::Document::addConsoleMessage):
     29        * dom/ScriptExecutionContext.h:
     30        (WebCore::ScriptExecutionContext::AddConsoleMessageTask::AddConsoleMessageTask):
     31        * page/PageConsoleClient.h:
     32        * page/PageConsoleClient.cpp:
     33        (WebCore::PageConsoleClient::addMessage):
     34        * workers/WorkerGlobalScope.h:
     35        Add new path for logging to the console that accepts a ConsoleMessage.
     36
    1372017-06-20  Saam Barati  <sbarati@apple.com>
    238

  • trunk/Source/WebCore/dom/Document.cpp

    r218529 r218603  
    198198#include "XPathResult.h"
    199199#include <ctime>
     200#include <inspector/ConsoleMessage.h>
    200201#include <inspector/ScriptCallStack.h>
    201202#include <wtf/CurrentTime.h>
    … …  
    55465547}
    55475548
     5549void Document::addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage>&& consoleMessage)
     5550{
     5551    if (!isContextThread()) {
     5552        postTask(AddConsoleMessageTask(WTFMove(consoleMessage)));
     5553        return;
     5554    }
     5555
     5556    if (Page* page = this->page())
     5557        page->console().addMessage(WTFMove(consoleMessage));
     5558}
     5559
    55485560void Document::addConsoleMessage(MessageSource source, MessageLevel level, const String& message, unsigned long requestIdentifier)
    55495561{

  • trunk/Source/WebCore/dom/Document.h

    r218602 r218603  
    12601260    void removeDisabledFieldsetElement() { ASSERT(m_disabledFieldsetElementsCount); m_disabledFieldsetElementsCount--; }
    12611261
     1262    WEBCORE_EXPORT void addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage>&&) final;
     1263
     1264    // The following addConsoleMessage function is deprecated.
     1265    // Callers should try to create the ConsoleMessage themselves.
    12621266    WEBCORE_EXPORT void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier = 0) final;
    12631267
    … …  
    14071411    void derefScriptExecutionContext() final { deref(); }
    14081412
     1413    // The following addMessage function is deprecated.
     1414    // Callers should try to create the ConsoleMessage themselves.
    14091415    void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<Inspector::ScriptCallStack>&&, JSC::ExecState* = nullptr, unsigned long requestIdentifier = 0) final;
    14101416

  • trunk/Source/WebCore/dom/ScriptExecutionContext.h

    r218593 r218603  
    4646
    4747namespace Inspector {
     48class ConsoleMessage;
    4849class ScriptCallStack;
    4950}
    … …  
    9899    void reportUnhandledPromiseRejection(JSC::ExecState&, JSC::JSPromise&, RefPtr<Inspector::ScriptCallStack>&&);
    99100
     101    virtual void addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage>&&) = 0;
     102
     103    // The following addConsoleMessage functions are deprecated.
     104    // Callers should try to create the ConsoleMessage themselves.
    100105    void addConsoleMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, JSC::ExecState* = nullptr, unsigned long requestIdentifier = 0);
    101106    virtual void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier = 0) = 0;
    … …  
    224229    class AddConsoleMessageTask : public Task {
    225230    public:
     231        AddConsoleMessageTask(std::unique_ptr<Inspector::ConsoleMessage>&& consoleMessage)
     232            : Task([&consoleMessage](ScriptExecutionContext& context) {
     233                context.addConsoleMessage(WTFMove(consoleMessage));
     234            })
     235        {
     236        }
     237
    226238        AddConsoleMessageTask(MessageSource source, MessageLevel level, const String& message)
    227239            : Task([source, level, message = message.isolatedCopy()](ScriptExecutionContext& context) {
    … …  
    237249
    238250private:
     251    // The following addMessage function is deprecated.
     252    // Callers should try to create the ConsoleMessage themselves.
    239253    virtual void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<Inspector::ScriptCallStack>&&, JSC::ExecState* = nullptr, unsigned long requestIdentifier = 0) = 0;
    240254    virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, RefPtr<Inspector::ScriptCallStack>&&) = 0;

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

    r217298 r218603  
    5353#include "ImageBuffer.h"
    5454#include "ImageData.h"
     55#include "InspectorInstrumentation.h"
    5556#include "IntSize.h"
     57#include "JSMainThreadExecState.h"
    5658#include "Logging.h"
    5759#include "MainFrame.h"
    … …  
    9092#include "WebGLTexture.h"
    9193#include "WebGLUniformLocation.h"
    92 
     94#include <inspector/ConsoleMessage.h>
     95#include <inspector/ScriptCallStack.h>
     96#include <inspector/ScriptCallStackFactory.h>
    9397#include <runtime/JSCInlines.h>
    9498#include <runtime/TypedArrayInlines.h>
    … …  
    345349    {
    346350        if (m_context->m_synthesizedErrorsToConsole)
    347             m_context->printGLErrorToConsole(message);
     351            m_context->printToConsole(MessageLevel::Error, message);
    348352    }
    349353    virtual ~WebGLRenderingContextErrorMessageCallback() { }
    … …  
    12431247    GC3Denum result = m_framebufferBinding->checkStatus(&reason);
    12441248    if (result != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
    1245         printGLWarningToConsole("checkFramebufferStatus", reason);
     1249        String str = "WebGL: checkFramebufferStatus:" + String(reason);
     1250        printToConsole(MessageLevel::Warning, str);
    12461251        return result;
    12471252    }
    … …  
    13041309    m_context->getShaderiv(objectOrZero(shader), GraphicsContext3D::COMPILE_STATUS, &value);
    13051310    shader->setValid(value);
     1311
     1312    if (m_synthesizedErrorsToConsole && !value) {
     1313        Ref<Inspector::ScriptCallStack> stackTrace = Inspector::createScriptCallStack(JSMainThreadExecState::currentState(), Inspector::ScriptCallStack::maxCallStackSizeToCapture);
     1314
     1315        Vector<String> errors;
     1316        getShaderInfoLog(shader).split("\n", errors);
     1317        for (String& error : errors)
     1318            canvas().document().addConsoleMessage(std::make_unique<Inspector::ConsoleMessage>(MessageSource::Rendering, MessageType::Log, MessageLevel::Error, "WebGL: " + error, stackTrace.copyRef()));
     1319    }
    13061320}
    13071321
    … …  
    45734587void WebGLRenderingContextBase::recycleContext()
    45744588{
    4575     printWarningToConsole("There are too many active WebGL contexts on this page, the oldest context will be lost.");
     4589    printToConsole(MessageLevel::Error, "There are too many active WebGL contexts on this page, the oldest context will be lost.");
    45764590    // Using SyntheticLostContext means the developer won't be able to force the restoration
    45774591    // of the context by calling preventDefault() in a "webglcontextlost" event handler.
    … …  
    48304844                + " is not renderable. It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete',"
    48314845                + " or it is a float/half-float type with linear filtering and without the relevant float/half-float linear extension enabled.");
    4832             printGLWarningToConsole(functionName, msg.utf8().data());
     4846            printToConsole(MessageLevel::Error, "WebGL: " + String(functionName) + ": " + msg);
    48334847            tex2D = m_blackTexture2D.get();
    48344848            texCubeMap = m_blackTextureCubeMap.get();
    … …  
    52015215}
    52025216
    5203 void WebGLRenderingContextBase::printGLErrorToConsole(const String& message)
    5204 {
     5217void WebGLRenderingContextBase::printToConsole(MessageLevel level, const String& message)
     5218{
     5219    if (!m_synthesizedErrorsToConsole || !m_numGLErrorsToConsoleAllowed)
     5220        return;
     5221
     5222    std::unique_ptr<Inspector::ConsoleMessage> consoleMessage;
     5223
     5224    // Error messages can occur during function calls, so show stack traces for them.
     5225    if (level == MessageLevel::Error) {
     5226        Ref<Inspector::ScriptCallStack> stackTrace = Inspector::createScriptCallStack(JSMainThreadExecState::currentState(), Inspector::ScriptCallStack::maxCallStackSizeToCapture);
     5227        consoleMessage = std::make_unique<Inspector::ConsoleMessage>(MessageSource::Rendering, MessageType::Log, level, message, WTFMove(stackTrace));
     5228    } else
     5229        consoleMessage = std::make_unique<Inspector::ConsoleMessage>(MessageSource::Rendering, MessageType::Log, level, message);
     5230
     5231    canvas().document().addConsoleMessage(WTFMove(consoleMessage));
     5232
     5233    --m_numGLErrorsToConsoleAllowed;
    52055234    if (!m_numGLErrorsToConsoleAllowed)
    5206         return;
    5207 
    5208     --m_numGLErrorsToConsoleAllowed;
    5209     printWarningToConsole(message);
    5210 
    5211     if (!m_numGLErrorsToConsoleAllowed)
    5212         printWarningToConsole("WebGL: too many errors, no more errors will be reported to the console for this context.");
    5213 }
    5214 
    5215 void WebGLRenderingContextBase::printWarningToConsole(const String& message)
    5216 {
    5217     canvas().document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Warning, message);
     5235        printToConsole(MessageLevel::Warning, "WebGL: too many errors, no more errors will be reported to the console for this context.");
    52185236}
    52195237
    … …  
    55965614        // The rendering context is not restored if this context was
    55975615        // guilty of causing the graphics reset.
    5598         printWarningToConsole("WARNING: WebGL content on the page caused the graphics card to reset; not restoring the context");
     5616        printToConsole(MessageLevel::Warning, "WARNING: WebGL content on the page caused the graphics card to reset; not restoring the context");
    55995617        return;
    56005618    case Extensions3D::INNOCENT_CONTEXT_RESET_ARB:
    … …  
    56075625        // the content. Only if they say "yes" should we start
    56085626        // attempting to restore the context.
    5609         printWarningToConsole("WARNING: WebGL content on the page might have caused the graphics card to reset");
     5627        printToConsole(MessageLevel::Warning, "WARNING: WebGL content on the page might have caused the graphics card to reset");
    56105628        break;
    56115629    }
    … …  
    57295747{
    57305748    if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {
    5731       String str = String("WebGL: ") + GetErrorString(error) +  ": " + String(functionName) + ": " + String(description);
    5732       printGLErrorToConsole(str);
     5749        String str = "WebGL: " + GetErrorString(error) +  ": " + String(functionName) + ": " + String(description);
     5750        printToConsole(MessageLevel::Error, str);
    57335751    }
    57345752    m_context->synthesizeGLError(error);
    5735 }
    5736 
    5737 
    5738 void WebGLRenderingContextBase::printGLWarningToConsole(const char* functionName, const char* description)
    5739 {
    5740     if (m_synthesizedErrorsToConsole) {
    5741         String str = String("WebGL: ") + String(functionName) + ": " + String(description);
    5742         printGLErrorToConsole(str);
    5743     }
    57445753}
    57455754

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.h

    r217298 r218603  
    744744    void texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat parami, GC3Dint paramf, bool isFloat);
    745745
    746     // Helper function to print GL errors to console.
    747     void printGLErrorToConsole(const String&);
    748     void printGLWarningToConsole(const char* function, const char* reason);
    749 
    750     // Helper function to print warnings to console. Currently
    751     // used only to warn about use of obsolete functions.
    752     void printWarningToConsole(const String&);
     746    // Helper function to print errors and warnings to console.
     747    void printToConsole(MessageLevel, const String&);
    753748
    754749    // Helper function to validate input parameters for framebuffer functions.

  • trunk/Source/WebCore/page/PageConsoleClient.cpp

    r212448 r218603  
    106106}
    107107
     108void PageConsoleClient::addMessage(std::unique_ptr<Inspector::ConsoleMessage>&& consoleMessage)
     109{
     110    if (consoleMessage->source() != MessageSource::CSS && !m_page.usesEphemeralSession()) {
     111        m_page.chrome().client().addMessageToConsole(consoleMessage->source(), consoleMessage->level(), consoleMessage->message(), consoleMessage->line(), consoleMessage->column(), consoleMessage->url());
     112
     113        if (m_page.settings().logsPageMessagesToSystemConsoleEnabled() || shouldPrintExceptions())
     114            ConsoleClient::printConsoleMessage(MessageSource::ConsoleAPI, MessageType::Log, consoleMessage->level(), consoleMessage->message(), consoleMessage->url(), consoleMessage->line(), consoleMessage->column());
     115    }
     116
     117    InspectorInstrumentation::addMessageToConsole(m_page, WTFMove(consoleMessage));
     118}
     119
    108120void PageConsoleClient::addMessage(MessageSource source, MessageLevel level, const String& message, unsigned long requestIdentifier, Document* document)
    109121{
    … …  
    133145        message = std::make_unique<Inspector::ConsoleMessage>(source, MessageType::Log, level, messageText, suggestedURL, suggestedLineNumber, suggestedColumnNumber, state, requestIdentifier);
    134146
     147    addMessage(WTFMove(message));
     148}
     149
     150
     151void PageConsoleClient::messageWithTypeAndLevel(MessageType type, MessageLevel level, JSC::ExecState* exec, Ref<Inspector::ScriptArguments>&& arguments)
     152{
     153    String messageText;
     154    bool gotMessage = arguments->getFirstArgumentAsString(messageText);
     155
     156    auto message = std::make_unique<Inspector::ConsoleMessage>(MessageSource::ConsoleAPI, type, level, messageText, arguments.copyRef(), exec);
     157
    135158    String url = message->url();
    136159    unsigned lineNumber = message->line();
    … …  
    139162    InspectorInstrumentation::addMessageToConsole(m_page, WTFMove(message));
    140163
    141     if (source == MessageSource::CSS)
    142         return;
    143 
    144     if (m_page.usesEphemeralSession())
    145         return;
    146 
    147     m_page.chrome().client().addMessageToConsole(source, level, messageText, lineNumber, columnNumber, url);
    148 
    149     if (!m_page.settings().logsPageMessagesToSystemConsoleEnabled() && !shouldPrintExceptions())
    150         return;
    151 
    152     ConsoleClient::printConsoleMessage(MessageSource::ConsoleAPI, MessageType::Log, level, messageText, url, lineNumber, columnNumber);
    153 }
    154 
    155 
    156 void PageConsoleClient::messageWithTypeAndLevel(MessageType type, MessageLevel level, JSC::ExecState* exec, Ref<Inspector::ScriptArguments>&& arguments)
    157 {
    158     String messageText;
    159     bool gotMessage = arguments->getFirstArgumentAsString(messageText);
    160 
    161     auto message = std::make_unique<Inspector::ConsoleMessage>(MessageSource::ConsoleAPI, type, level, messageText, arguments.copyRef(), exec);
    162 
    163     String url = message->url();
    164     unsigned lineNumber = message->line();
    165     unsigned columnNumber = message->column();
    166 
    167     InspectorInstrumentation::addMessageToConsole(m_page, WTFMove(message));
    168 
    169164    if (m_page.usesEphemeralSession())
    170165        return;

  • trunk/Source/WebCore/page/PageConsoleClient.h

    r212448 r218603  
    3333#include <wtf/Forward.h>
    3434
     35namespace Inspector {
     36class ConsoleMessage;
     37}
     38
    3539namespace JSC {
    3640class ExecState;
    … …  
    5458    static void unmute();
    5559
     60    void addMessage(std::unique_ptr<Inspector::ConsoleMessage>&&);
     61
     62    // The following addMessage function are deprecated.
     63    // Callers should try to create the ConsoleMessage themselves.
    5664    void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<Inspector::ScriptCallStack>&& = nullptr, JSC::ExecState* = nullptr, unsigned long requestIdentifier = 0);
    5765    void addMessage(MessageSource, MessageLevel, const String& message, Ref<Inspector::ScriptCallStack>&&);

  • trunk/Source/WebCore/workers/WorkerGlobalScope.h

    r218593 r218603  
    100100    bool isClosing() { return m_closing; }
    101101
    102     void addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage>&&);
     102    void addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage>&&) final;
    103103
    104104    Crypto& crypto();
    … …  
    123123
    124124    void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, RefPtr<Inspector::ScriptCallStack>&&) final;
     125
     126    // The following addMessage and addConsoleMessage functions are deprecated.
     127    // Callers should try to create the ConsoleMessage themselves.
    125128    void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<Inspector::ScriptCallStack>&&, JSC::ExecState*, unsigned long requestIdentifier) final;
    126129    void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier) final;
Note: See TracChangeset for help on using the changeset viewer.