Significado de “DebuggeeWouldRun: debuggee 'auto-hospedado: XXX' seria executado” no console do Firefox / Firebug

Question

Estou vendo muitas mensagens como esta no meu console do Firebug em vários sites, incluindo um que estou tentando depurar. breakOnError.js parece ser algum arquivo do sistema / Firebug, nada a ver com os sites para os quais isso aparece. Não há nada óbvio que eu possa ver que o número 674 aqui possa estar relacionado, embora pareça mostrar para várias páginas (incluindo essa mesma página de perguntas):

DebuggeeWouldRun: debuggee 'self-hosted:674' would run        breakOnError.js (line 105, col 13)'
                                                                       <system>

O console do Firebug é preenchido apenas se eu tiver Break on Exceptions ativado na janela Script, às vezes, mesmo se eu ligá-lo após a página já ter sido carregada, a uma taxa um pouco maior que um por segundo. É amarelo, como uma mensagem de aviso (não é um erro), mas eu não sei o que poderia me alertar.

Nãoconsigoencontrarnenhumainformaçãointeligívelsobreoqueéissoouoquesignifica.TudooqueérelevanteéumpardeproblemasdesuportedoFirefox/Mozilla( 1249469 e 1252945 ) discutindo alguns detalhes muito bons da implementação de ... o que quer que seja. Não há pistas que eu possa entender sobre o que isso realmente significa.

O que isso e o que isso significa?

Encontrei o que parece uma possível explicação de alguém que acredito ser um desenvolvedor Mozilla , mas é muito técnico (público-alvo = outros desenvolvedores do firefox) e eu realmente não entendo o que isso realmente significa. Eu acho que talvez isso signifique que o Firefox está reclamando porque não gosta da maneira como o Firebug está tentando assumir o controle de falhas, e o Firebug está respondendo a essas mensagens do sistema como avisos de console e continua fazendo o que estava fazendo?

I recently landed an implementation of Debugger.DebuggeeWouldRun, which is an error that's thrown when debugger code attempts to re-enter debuggee code without going through a blessed "invocation function" (currently D.F.p.eval and D.O.p.executeInGlobal) 1. These re-entries are the cause of the debugger not truly able to pause the debuggee.

Currently it is not an error but a warning instead, and is to help pinpoint sites in debugger code that attempts to re-enter debuggee code. The intention is that once all sites are fixed, it will be an error.

... então tem esse comentário, o que me faz pensar que talvez seja algum sintoma de uma peculiaridade do Firefox que eu não precise me preocupar, mas de novo eu não entendo o que isso significa, particularmente o que isso significa "código auto-hospedado" neste contexto (uma extensão como o Firebug contaria como auto-hospedada porque está na minha máquina?), e não tenho ideia do que "o compartimento de depuração" é:

One current shortcoming is that all self-hosted code in the debuggee compartment is banned. This means some operations that should in fact be allowed are warned against/disallowed.

O Ramhound nos comentários sugeriu que pode ser um bug do Firebug (ugghhh) e perguntou sobre a linha de código mencionada na mensagem.

Obviamente, se houver um bug, isso é uma questão para os desenvolvedores do Firebug, este não é o lugar para tentar consertá-lo. Estou postando no caso de ajudar alguém a explicar o que o conteúdo da mensagem ('debugee', 'auto-hospedado: 674', 'rodaria') realmente significa. Esta é a função em torno da linha, eu marquei a linha 105 com um comentário:

onDebuggerPaused: function(context, event, packet)
{
    // Check the packet type, only "exception" is interesting in this case.
    var type = packet.why.type;
    if (type != "exception")
        return;

    // Reset the break-on-next-error flag after an exception break happens.
    // xxxHonza: this is how the other BON implementations work, but we could reconsider it.
    // Another problem is that the debugger breaks in every frame by default, which
    // is avoided by reseting of the flag.
    this.breakOnNext(context, false);

    // At this point, the BON flag is reset and can't be used anymore in |shouldResumeDebugger|.
    // So add a custom flag in packet.why so we know that the debugger is paused because of
    // either the Console's "Break On Next" or the Script's "Break On Exceptions" option.
    packet.why.fbPauseDueToBONError = true;

    // Get the exception object.
    var exc = DebuggerLib.getObject(context, packet.why.exception.actor);
    if (!exc)
        return;

    Trace.sysout("BreakOnError.onDebuggerPaused;", {exc: exc, packet: packet});

    // Convert to known structure, so FirebugReps.ErrorMessage.copyError() works.
    var error = {
        message: exc + "", // <<<<<<<<<<<<<<<<<<<<<<<<<<<< THIS IS LINE 105 <<<<<<<<<<<<<<<<
        href: exc.fileName,
        lineNo: exc.lineNumber
    };

    var lineNo = exc.lineNumber - 1;
    var url = exc.fileName;

    // Make sure the break notification popup appears.
    context.breakingCause =
    {
        message: error.message,
        copyAction: Obj.bindFixed(ErrorMessage.copyError, ErrorMessage, error),
        skipAction: function addSkipperAndGo()
        {
            // Create a breakpoint that never hits, but prevents BON for the error.
            var bp = BreakpointStore.addBreakpoint(url, lineNo);
            BreakpointStore.disableBreakpoint(url, lineNo);

            Debugger.resume(context);
        },
    };
},

    

Answer 1

O "debuggee" é a coisa que é depurada. No caso do Firefox, o código JavaScript é executado no depurador, mais especificamente no código JavaScript do site. (Também pode ser um código JavaScript interno do navegador.)

A API do Firefox Debugger é descrita no MDN , embora também seja muito técnica e não explica a terminologia. Há também alguma descrição da Debugger.DebuggeeWouldRun Exception , que esclarece as coisas um pouco se você mantiver a definição de cima em mente:

Some debugger operations that appear to simply inspect the debuggee’s state may actually cause debuggee code to run. For example, reading a variable might run a getter function on the global or on a with expression’s operand; and getting an object’s property descriptor will run a handler trap if the object is a proxy. To protect the debugger’s integrity, only methods whose stated purpose is to run debuggee code can do so. These methods are called invocation functions, and they follow certain common conventions to report the debuggee’s behavior safely. For other methods, if their normal operation would cause debuggee code to run, they throw an instance of the Debugger.DebuggeeWouldRun exception.

Portanto, aplicando isso ao Firebug, significa que o código do depurador do Firebug não inspeciona apenas o código de uma página, mas pode, na verdade, (acidentalmente) executar o código da página. Exemplo simples:

<script>
var obj = {
  i: 0,  
  get counter() {
    return this.i++;
  }
}
</script>

Isso aumenta a i everytime obj.counter getter é chamado. Se você inspecionar a variável obj no painel lateral do Watch do Firebug, por exemplo, você verá que o contador get aumentou apenas porque é acessado pelo Firebug:

Ditoisto,nãovejoasexceçõesmencionadasporvocêmesmoquandoaspreferênciasjavascript.options.throw_on_debuggee_would_runejavascript.options.dump_stack_on_debuggee_would_run,comomencionado no tópico do grupo de discussão do Mozilla , estão definidos como true (que são definidos como false por padrão).
E sugiro que você defina essas duas preferências para false se você não quiser ver essas exceções sendo registradas no console.