Changeset 190905 in webkit


Ignore:
Timestamp:
Oct 12, 2015 4:37:51 PM (9 years ago)
Author:
commit-queue@webkit.org
Message:

Web Inspector: Rebaseline Inspector generator tests and make better use of RWIProtocol constant
​https://bugs.webkit.org/show_bug.cgi?id=150044

Patch by Joseph Pecoraro <Joseph Pecoraro> on 2015-10-12
Reviewed by Brian Burg.

  • inspector/scripts/codegen/generate_objc_configuration_header.py:

(ObjCConfigurationHeaderGenerator.generate_output):
(ObjCConfigurationHeaderGenerator._generate_configuration_interface_for_domains):

  • inspector/scripts/codegen/generate_objc_configuration_implementation.py:

(ObjCBackendDispatcherImplementationGenerator._generate_configuration_implementation_for_domains):

  • inspector/scripts/codegen/generate_objc_header.py:

(ObjCHeaderGenerator.generate_output):

  • inspector/scripts/codegen/generate_objc_internal_header.py:

(ObjCInternalHeaderGenerator.generate_output):

  • inspector/scripts/tests/expected/commands-with-async-attribute.json-result:
  • inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result:
  • inspector/scripts/tests/expected/domains-with-varying-command-sizes.json-result:
  • inspector/scripts/tests/expected/enum-values.json-result:
  • inspector/scripts/tests/expected/events-with-optional-parameters.json-result:
  • inspector/scripts/tests/expected/generate-domains-with-feature-guards.json-result:
  • inspector/scripts/tests/expected/same-type-id-different-domain.json-result:
  • inspector/scripts/tests/expected/shadowed-optional-type-setters.json-result:
  • inspector/scripts/tests/expected/type-declaration-aliased-primitive-type.json-result:
  • inspector/scripts/tests/expected/type-declaration-array-type.json-result:
  • inspector/scripts/tests/expected/type-declaration-enum-type.json-result:
  • inspector/scripts/tests/expected/type-declaration-object-type.json-result:
  • inspector/scripts/tests/expected/type-requiring-runtime-casts.json-result:
Location:
trunk/Source/JavaScriptCore
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r190904 r190905  
     12015-10-12  Joseph Pecoraro  <pecoraro@apple.com>
     2
     3        Web Inspector: Rebaseline Inspector generator tests and make better use of RWIProtocol constant
     4        https://bugs.webkit.org/show_bug.cgi?id=150044
     5
     6        Reviewed by Brian Burg.
     7
     8        * inspector/scripts/codegen/generate_objc_configuration_header.py:
     9        (ObjCConfigurationHeaderGenerator.generate_output):
     10        (ObjCConfigurationHeaderGenerator._generate_configuration_interface_for_domains):
     11        * inspector/scripts/codegen/generate_objc_configuration_implementation.py:
     12        (ObjCBackendDispatcherImplementationGenerator._generate_configuration_implementation_for_domains):
     13        * inspector/scripts/codegen/generate_objc_header.py:
     14        (ObjCHeaderGenerator.generate_output):
     15        * inspector/scripts/codegen/generate_objc_internal_header.py:
     16        (ObjCInternalHeaderGenerator.generate_output):
     17        * inspector/scripts/tests/expected/commands-with-async-attribute.json-result:
     18        * inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result:
     19        * inspector/scripts/tests/expected/domains-with-varying-command-sizes.json-result:
     20        * inspector/scripts/tests/expected/enum-values.json-result:
     21        * inspector/scripts/tests/expected/events-with-optional-parameters.json-result:
     22        * inspector/scripts/tests/expected/generate-domains-with-feature-guards.json-result:
     23        * inspector/scripts/tests/expected/same-type-id-different-domain.json-result:
     24        * inspector/scripts/tests/expected/shadowed-optional-type-setters.json-result:
     25        * inspector/scripts/tests/expected/type-declaration-aliased-primitive-type.json-result:
     26        * inspector/scripts/tests/expected/type-declaration-array-type.json-result:
     27        * inspector/scripts/tests/expected/type-declaration-enum-type.json-result:
     28        * inspector/scripts/tests/expected/type-declaration-object-type.json-result:
     29        * inspector/scripts/tests/expected/type-requiring-runtime-casts.json-result:
     30
    1312015-10-12  Myles C. Maxfield  <mmaxfield@apple.com>
    232

  • trunk/Source/JavaScriptCore/inspector/scripts/codegen/generate_objc_configuration_header.py

    r177168 r190905  
    4646    def generate_output(self):
    4747        headers = [
    48             '"%s.h"' % ObjCGenerator.OBJC_PREFIX,
     48            '<WebInspector/%s.h>' % ObjCGenerator.OBJC_PREFIX,
    4949        ]
    5050
    … …  
    6767        lines = []
    6868        lines.append('__attribute__((visibility ("default")))')
    69         lines.append('@interface RWIProtocolConfiguration : NSObject')
     69        lines.append('@interface %sConfiguration : NSObject' % ObjCGenerator.OBJC_PREFIX)
    7070        for domain in domains:
    7171            lines.extend(self._generate_properties_for_domain(domain))

  • trunk/Source/JavaScriptCore/inspector/scripts/codegen/generate_objc_configuration_implementation.py

    r176329 r190905  
    7272    def _generate_configuration_implementation_for_domains(self, domains):
    7373        lines = []
    74         lines.append('@implementation RWIProtocolConfiguration')
     74        lines.append('@implementation %sConfiguration' % ObjCGenerator.OBJC_PREFIX)
    7575        lines.append('{')
    7676        lines.append('    AugmentableInspectorController* _controller;')

  • trunk/Source/JavaScriptCore/inspector/scripts/codegen/generate_objc_header.py

    r177168 r190905  
    5353    def generate_output(self):
    5454        headers = set([
    55             '<WebInspector/RWIProtocolJSONObject.h>',
     55            '<WebInspector/%sJSONObject.h>' % ObjCGenerator.OBJC_PREFIX,
    5656        ])
    5757

  • trunk/Source/JavaScriptCore/inspector/scripts/codegen/generate_objc_internal_header.py

    r176329 r190905  
    4747        headers = set([
    4848            '"%s.h"' % ObjCGenerator.OBJC_PREFIX,
    49             '"RWIProtocolJSONObjectInternal.h"',
     49            '"%sJSONObjectInternal.h"' % ObjCGenerator.OBJC_PREFIX,
    5050            '<JavaScriptCore/InspectorValues.h>',
    5151            '<JavaScriptCore/AugmentableInspectorController.h>',

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/commands-with-async-attribute.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    187188class DatabaseBackendDispatcher final : public SupplementalBackendDispatcher {
    188189public:
    189     static Ref<DatabaseBackendDispatcher> create(BackendDispatcher*, DatabaseBackendDispatcherHandler*);
     190    static Ref<DatabaseBackendDispatcher> create(BackendDispatcher&, DatabaseBackendDispatcherHandler*);
    190191    virtual void dispatch(long requestId, const String& method, Ref<InspectorObject>&& message) override;
    191192private:
    … …  
    244245#include "InspectorBackendDispatchers.h"
    245246
    246 #include <inspector/InspectorFrontendChannel.h>
     247#include <inspector/InspectorFrontendRouter.h>
    247248#include <inspector/InspectorValues.h>
    248249#include <wtf/NeverDestroyed.h>
    … …  
    257258DatabaseBackendDispatcherHandler::~DatabaseBackendDispatcherHandler() { }
    258259
    259 Ref<DatabaseBackendDispatcher> DatabaseBackendDispatcher::create(BackendDispatcher* backendDispatcher, DatabaseBackendDispatcherHandler* agent)
    260 {
    261     return adoptRef(*new DatabaseBackendDispatcher(*backendDispatcher, agent));
     260Ref<DatabaseBackendDispatcher> DatabaseBackendDispatcher::create(BackendDispatcher& backendDispatcher, DatabaseBackendDispatcherHandler* agent)
     261{
     262    return adoptRef(*new DatabaseBackendDispatcher(backendDispatcher, agent));
    262263}
    263264
    … …  
    538539
    539540#include "InspectorProtocolObjects.h"
    540 #include <inspector/InspectorFrontendChannel.h>
    541541#include <inspector/InspectorValues.h>
    542542#include <wtf/text/WTFString.h>
    … …  
    544544namespace Inspector {
    545545
    546 
     546class FrontendRouter;
    547547
    548548} // namespace Inspector
    … …  
    585585#include "InspectorFrontendDispatchers.h"
    586586
     587#include "InspectorFrontendRouter.h"
    587588#include <wtf/text/CString.h>
    588589
    … …  
    932933
    933934    auto alternateDispatcher = std::make_unique<ObjCInspectorDatabaseBackendDispatcher>(handler);
    934     auto alternateAgent = std::make_unique<AlternateDispatchableAgent<DatabaseBackendDispatcher, AlternateDatabaseBackendDispatcher>>(ASCIILiteral("Database"), WTF::move(alternateDispatcher));
     935    auto alternateAgent = std::make_unique<AlternateDispatchableAgent<DatabaseBackendDispatcher, AlternateDatabaseBackendDispatcher>>(ASCIILiteral("Database"), *_controller, WTF::move(alternateDispatcher));
    935936    _controller->appendExtraAgent(WTF::move(alternateAgent));
    936937}
    … …  
    977978// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    978979
    979 #import "RWIProtocol.h"
     980#import <WebInspector/RWIProtocol.h>
    980981
    981982__attribute__((visibility ("default")))
    … …  
    10231024#include "RWIProtocolInternal.h"
    10241025#include "RWIProtocolEnumConversionHelpers.h"
    1025 #include <JavaScriptCore/InspectorFrontendChannel.h>
    10261026#include <JavaScriptCore/InspectorValues.h>
    10271027
    … …  
    14081408
    14091409#import "RWIProtocolEnumConversionHelpers.h"
    1410 #import <JavaScriptCore/InspectorFrontendChannel.h>
    14111410#import <JavaScriptCore/InspectorValues.h>
    14121411

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    170171class DatabaseBackendDispatcher final : public SupplementalBackendDispatcher {
    171172public:
    172     static Ref<DatabaseBackendDispatcher> create(BackendDispatcher*, DatabaseBackendDispatcherHandler*);
     173    static Ref<DatabaseBackendDispatcher> create(BackendDispatcher&, DatabaseBackendDispatcherHandler*);
    173174    virtual void dispatch(long requestId, const String& method, Ref<InspectorObject>&& message) override;
    174175private:
    … …  
    225226#include "InspectorBackendDispatchers.h"
    226227
    227 #include <inspector/InspectorFrontendChannel.h>
     228#include <inspector/InspectorFrontendRouter.h>
    228229#include <inspector/InspectorValues.h>
    229230#include <wtf/NeverDestroyed.h>
    … …  
    238239DatabaseBackendDispatcherHandler::~DatabaseBackendDispatcherHandler() { }
    239240
    240 Ref<DatabaseBackendDispatcher> DatabaseBackendDispatcher::create(BackendDispatcher* backendDispatcher, DatabaseBackendDispatcherHandler* agent)
    241 {
    242     return adoptRef(*new DatabaseBackendDispatcher(*backendDispatcher, agent));
     241Ref<DatabaseBackendDispatcher> DatabaseBackendDispatcher::create(BackendDispatcher& backendDispatcher, DatabaseBackendDispatcherHandler* agent)
     242{
     243    return adoptRef(*new DatabaseBackendDispatcher(backendDispatcher, agent));
    243244}
    244245
    … …  
    439440
    440441#include "InspectorProtocolObjects.h"
    441 #include <inspector/InspectorFrontendChannel.h>
    442442#include <inspector/InspectorValues.h>
    443443#include <wtf/text/WTFString.h>
    … …  
    445445namespace Inspector {
    446446
    447 
     447class FrontendRouter;
    448448
    449449} // namespace Inspector
    … …  
    486486#include "InspectorFrontendDispatchers.h"
    487487
     488#include "InspectorFrontendRouter.h"
    488489#include <wtf/text/CString.h>
    489490
    … …  
    831832
    832833    auto alternateDispatcher = std::make_unique<ObjCInspectorDatabaseBackendDispatcher>(handler);
    833     auto alternateAgent = std::make_unique<AlternateDispatchableAgent<DatabaseBackendDispatcher, AlternateDatabaseBackendDispatcher>>(ASCIILiteral("Database"), WTF::move(alternateDispatcher));
     834    auto alternateAgent = std::make_unique<AlternateDispatchableAgent<DatabaseBackendDispatcher, AlternateDatabaseBackendDispatcher>>(ASCIILiteral("Database"), *_controller, WTF::move(alternateDispatcher));
    834835    _controller->appendExtraAgent(WTF::move(alternateAgent));
    835836}
    … …  
    876877// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    877878
    878 #import "RWIProtocol.h"
     879#import <WebInspector/RWIProtocol.h>
    879880
    880881__attribute__((visibility ("default")))
    … …  
    922923#include "RWIProtocolInternal.h"
    923924#include "RWIProtocolEnumConversionHelpers.h"
    924 #include <JavaScriptCore/InspectorFrontendChannel.h>
    925925#include <JavaScriptCore/InspectorValues.h>
    926926
    … …  
    12651265
    12661266#import "RWIProtocolEnumConversionHelpers.h"
    1267 #import <JavaScriptCore/InspectorFrontendChannel.h>
    12681267#import <JavaScriptCore/InspectorValues.h>
    12691268

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/domains-with-varying-command-sizes.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    188189class Network1BackendDispatcher final : public SupplementalBackendDispatcher {
    189190public:
    190     static Ref<Network1BackendDispatcher> create(BackendDispatcher*, Network1BackendDispatcherHandler*);
     191    static Ref<Network1BackendDispatcher> create(BackendDispatcher&, Network1BackendDispatcherHandler*);
    191192    virtual void dispatch(long requestId, const String& method, Ref<InspectorObject>&& message) override;
    192193private:
    … …  
    205206class Network3BackendDispatcher final : public SupplementalBackendDispatcher {
    206207public:
    207     static Ref<Network3BackendDispatcher> create(BackendDispatcher*, Network3BackendDispatcherHandler*);
     208    static Ref<Network3BackendDispatcher> create(BackendDispatcher&, Network3BackendDispatcherHandler*);
    208209    virtual void dispatch(long requestId, const String& method, Ref<InspectorObject>&& message) override;
    209210private:
    … …  
    265266#include "InspectorBackendDispatchers.h"
    266267
    267 #include <inspector/InspectorFrontendChannel.h>
     268#include <inspector/InspectorFrontendRouter.h>
    268269#include <inspector/InspectorValues.h>
    269270#include <wtf/NeverDestroyed.h>
    … …  
    279280Network3BackendDispatcherHandler::~Network3BackendDispatcherHandler() { }
    280281
    281 Ref<Network1BackendDispatcher> Network1BackendDispatcher::create(BackendDispatcher* backendDispatcher, Network1BackendDispatcherHandler* agent)
    282 {
    283     return adoptRef(*new Network1BackendDispatcher(*backendDispatcher, agent));
     282Ref<Network1BackendDispatcher> Network1BackendDispatcher::create(BackendDispatcher& backendDispatcher, Network1BackendDispatcherHandler* agent)
     283{
     284    return adoptRef(*new Network1BackendDispatcher(backendDispatcher, agent));
    284285}
    285286
    … …  
    326327}
    327328
    328 Ref<Network3BackendDispatcher> Network3BackendDispatcher::create(BackendDispatcher* backendDispatcher, Network3BackendDispatcherHandler* agent)
    329 {
    330     return adoptRef(*new Network3BackendDispatcher(*backendDispatcher, agent));
     329Ref<Network3BackendDispatcher> Network3BackendDispatcher::create(BackendDispatcher& backendDispatcher, Network3BackendDispatcherHandler* agent)
     330{
     331    return adoptRef(*new Network3BackendDispatcher(backendDispatcher, agent));
    331332}
    332333
    … …  
    550551
    551552#include "InspectorProtocolObjects.h"
    552 #include <inspector/InspectorFrontendChannel.h>
    553553#include <inspector/InspectorValues.h>
    554554#include <wtf/text/WTFString.h>
    … …  
    556556namespace Inspector {
    557557
    558 
     558class FrontendRouter;
    559559
    560560} // namespace Inspector
    … …  
    597597#include "InspectorFrontendDispatchers.h"
    598598
     599#include "InspectorFrontendRouter.h"
    599600#include <wtf/text/CString.h>
    600601
    … …  
    872873
    873874    auto alternateDispatcher = std::make_unique<ObjCInspectorNetwork1BackendDispatcher>(handler);
    874     auto alternateAgent = std::make_unique<AlternateDispatchableAgent<Network1BackendDispatcher, AlternateNetwork1BackendDispatcher>>(ASCIILiteral("Network1"), WTF::move(alternateDispatcher));
     875    auto alternateAgent = std::make_unique<AlternateDispatchableAgent<Network1BackendDispatcher, AlternateNetwork1BackendDispatcher>>(ASCIILiteral("Network1"), *_controller, WTF::move(alternateDispatcher));
    875876    _controller->appendExtraAgent(WTF::move(alternateAgent));
    876877}
    … …  
    890891
    891892    auto alternateDispatcher = std::make_unique<ObjCInspectorNetwork3BackendDispatcher>(handler);
    892     auto alternateAgent = std::make_unique<AlternateDispatchableAgent<Network3BackendDispatcher, AlternateNetwork3BackendDispatcher>>(ASCIILiteral("Network3"), WTF::move(alternateDispatcher));
     893    auto alternateAgent = std::make_unique<AlternateDispatchableAgent<Network3BackendDispatcher, AlternateNetwork3BackendDispatcher>>(ASCIILiteral("Network3"), *_controller, WTF::move(alternateDispatcher));
    893894    _controller->appendExtraAgent(WTF::move(alternateAgent));
    894895}
    … …  
    935936// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    936937
    937 #import "RWIProtocol.h"
     938#import <WebInspector/RWIProtocol.h>
    938939
    939940__attribute__((visibility ("default")))
    … …  
    982983#include "RWIProtocolInternal.h"
    983984#include "RWIProtocolEnumConversionHelpers.h"
    984 #include <JavaScriptCore/InspectorFrontendChannel.h>
    985985#include <JavaScriptCore/InspectorValues.h>
    986986
    … …  
    11901190
    11911191#import "RWIProtocolEnumConversionHelpers.h"
    1192 #import <JavaScriptCore/InspectorFrontendChannel.h>
    11931192#import <JavaScriptCore/InspectorValues.h>
    11941193

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/enum-values.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    169170class CommandDomainBackendDispatcher final : public SupplementalBackendDispatcher {
    170171public:
    171     static Ref<CommandDomainBackendDispatcher> create(BackendDispatcher*, CommandDomainBackendDispatcherHandler*);
     172    static Ref<CommandDomainBackendDispatcher> create(BackendDispatcher&, CommandDomainBackendDispatcherHandler*);
    172173    virtual void dispatch(long requestId, const String& method, Ref<InspectorObject>&& message) override;
    173174private:
    … …  
    223224#include "InspectorBackendDispatchers.h"
    224225
    225 #include <inspector/InspectorFrontendChannel.h>
     226#include <inspector/InspectorFrontendRouter.h>
    226227#include <inspector/InspectorValues.h>
    227228#include <wtf/NeverDestroyed.h>
    … …  
    236237CommandDomainBackendDispatcherHandler::~CommandDomainBackendDispatcherHandler() { }
    237238
    238 Ref<CommandDomainBackendDispatcher> CommandDomainBackendDispatcher::create(BackendDispatcher* backendDispatcher, CommandDomainBackendDispatcherHandler* agent)
    239 {
    240     return adoptRef(*new CommandDomainBackendDispatcher(*backendDispatcher, agent));
     239Ref<CommandDomainBackendDispatcher> CommandDomainBackendDispatcher::create(BackendDispatcher& backendDispatcher, CommandDomainBackendDispatcherHandler* agent)
     240{
     241    return adoptRef(*new CommandDomainBackendDispatcher(backendDispatcher, agent));
    241242}
    242243
    … …  
    326327
    327328#include "InspectorProtocolObjects.h"
    328 #include <inspector/InspectorFrontendChannel.h>
    329329#include <inspector/InspectorValues.h>
    330330#include <wtf/text/WTFString.h>
    … …  
    332332namespace Inspector {
    333333
    334 
     334class FrontendRouter;
    335335
    336336class EventDomainFrontendDispatcher {
    337337public:
    338     EventDomainFrontendDispatcher(FrontendChannel* frontendChannel) : m_frontendChannel(frontendChannel) { }
     338    EventDomainFrontendDispatcher(FrontendRouter& frontendRouter) : m_frontendRouter(frontendRouter) { }
    339339        // Named after parameter 'parameter' while generating command/event eventWithEnumParameter.
    340340        enum class Parameter {
    … …  
    345345    void eventWithEnumParameter(Parameter parameter);
    346346private:
    347     FrontendChannel* m_frontendChannel;
     347    FrontendRouter& m_frontendRouter;
    348348};
    349349
    … …  
    387387#include "InspectorFrontendDispatchers.h"
    388388
     389#include "InspectorFrontendRouter.h"
    389390#include <wtf/text/CString.h>
    390391
    … …  
    399400    jsonMessage->setObject(ASCIILiteral("params"), WTF::move(paramsObject));
    400401
    401     m_frontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
     402    m_frontendRouter.sendEvent(jsonMessage->toJSONString());
    402403}
    403404
    … …  
    679680
    680681    auto alternateDispatcher = std::make_unique<ObjCInspectorCommandDomainBackendDispatcher>(handler);
    681     auto alternateAgent = std::make_unique<AlternateDispatchableAgent<CommandDomainBackendDispatcher, AlternateCommandDomainBackendDispatcher>>(ASCIILiteral("CommandDomain"), WTF::move(alternateDispatcher));
     682    auto alternateAgent = std::make_unique<AlternateDispatchableAgent<CommandDomainBackendDispatcher, AlternateCommandDomainBackendDispatcher>>(ASCIILiteral("CommandDomain"), *_controller, WTF::move(alternateDispatcher));
    682683    _controller->appendExtraAgent(WTF::move(alternateAgent));
    683684}
    … …  
    731732// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    732733
    733 #import "RWIProtocol.h"
     734#import <WebInspector/RWIProtocol.h>
    734735
    735736__attribute__((visibility ("default")))
    … …  
    778779#include "RWIProtocolInternal.h"
    779780#include "RWIProtocolEnumConversionHelpers.h"
    780 #include <JavaScriptCore/InspectorFrontendChannel.h>
    781781#include <JavaScriptCore/InspectorValues.h>
    782782
    … …  
    971971
    972972#import "RWIProtocolEnumConversionHelpers.h"
    973 #import <JavaScriptCore/InspectorFrontendChannel.h>
    974973#import <JavaScriptCore/InspectorValues.h>
    975974
    … …  
    997996- (void)eventWithEnumParameterWithParameter:(RWIProtocolEventDomainEventWithEnumParameterParameter)parameter
    998997{
    999     FrontendChannel* frontendChannel = _controller->frontendChannel();
    1000     if (!frontendChannel)
    1001         return;
     998    const FrontendRouter& router = _controller->frontendRouter();
    1002999
    10031000    Ref<InspectorObject> jsonMessage = InspectorObject::create();
    … …  
    10061003    paramsObject->setString(ASCIILiteral("parameter"), toProtocolString(parameter));
    10071004    jsonMessage->setObject(ASCIILiteral("params"), WTF::move(paramsObject));
    1008     frontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
     1005    router.sendEvent(jsonMessage->toJSONString());
    10091006}
    10101007

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/events-with-optional-parameters.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    179180#include "InspectorBackendDispatchers.h"
    180181
    181 #include <inspector/InspectorFrontendChannel.h>
     182#include <inspector/InspectorFrontendRouter.h>
    182183#include <inspector/InspectorValues.h>
    183184#include <wtf/NeverDestroyed.h>
    … …  
    231232
    232233#include "InspectorProtocolObjects.h"
    233 #include <inspector/InspectorFrontendChannel.h>
    234234#include <inspector/InspectorValues.h>
    235235#include <wtf/text/WTFString.h>
    … …  
    237237namespace Inspector {
    238238
    239 
     239class FrontendRouter;
    240240
    241241class DatabaseFrontendDispatcher {
    242242public:
    243     DatabaseFrontendDispatcher(FrontendChannel* frontendChannel) : m_frontendChannel(frontendChannel) { }
     243    DatabaseFrontendDispatcher(FrontendRouter& frontendRouter) : m_frontendRouter(frontendRouter) { }
    244244    void didExecuteOptionalParameters(RefPtr<Inspector::Protocol::Array<String>> columnNames, const String* const notes, const double* const timestamp, RefPtr<Inspector::InspectorObject> values, RefPtr<Inspector::InspectorValue> payload, RefPtr<Inspector::Protocol::Database::Error> sqlError, const Inspector::Protocol::Database::PrimaryColors* const screenColor, RefPtr<Inspector::Protocol::Database::ColorList> alternateColors, const String* const printColor);
    245245    void didExecuteNoOptionalParameters(RefPtr<Inspector::Protocol::Array<String>> columnNames, const String& notes, double timestamp, RefPtr<Inspector::InspectorObject> values, RefPtr<Inspector::InspectorValue> payload, RefPtr<Inspector::Protocol::Database::Error> sqlError, const Inspector::Protocol::Database::PrimaryColors& screenColor, RefPtr<Inspector::Protocol::Database::ColorList> alternateColors, const String& printColor);
    246246private:
    247     FrontendChannel* m_frontendChannel;
     247    FrontendRouter& m_frontendRouter;
    248248};
    249249
    … …  
    287287#include "InspectorFrontendDispatchers.h"
    288288
     289#include "InspectorFrontendRouter.h"
    289290#include <wtf/text/CString.h>
    290291
    … …  
    316317    jsonMessage->setObject(ASCIILiteral("params"), WTF::move(paramsObject));
    317318
    318     m_frontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
     319    m_frontendRouter.sendEvent(jsonMessage->toJSONString());
    319320}
    320321
    … …  
    335336    jsonMessage->setObject(ASCIILiteral("params"), WTF::move(paramsObject));
    336337
    337     m_frontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
     338    m_frontendRouter.sendEvent(jsonMessage->toJSONString());
    338339}
    339340
    … …  
    693694// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    694695
    695 #import "RWIProtocol.h"
     696#import <WebInspector/RWIProtocol.h>
    696697
    697698__attribute__((visibility ("default")))
    … …  
    739740#include "RWIProtocolInternal.h"
    740741#include "RWIProtocolEnumConversionHelpers.h"
    741 #include <JavaScriptCore/InspectorFrontendChannel.h>
    742742#include <JavaScriptCore/InspectorValues.h>
    743743
    … …  
    829829
    830830#import "RWIProtocolEnumConversionHelpers.h"
    831 #import <JavaScriptCore/InspectorFrontendChannel.h>
    832831#import <JavaScriptCore/InspectorValues.h>
    833832
    … …  
    851850- (void)didExecuteOptionalParametersWithColumnNames:(NSArray/*<NSString>*/ **)columnNames notes:(NSString **)notes timestamp:(double *)timestamp values:(RWIProtocolJSONObject **)values payload:(RWIProtocolJSONObject **)payload sqlError:(RWIProtocolDatabaseError **)sqlError screenColor:(NSString **)screenColor alternateColors:(NSArray/*<NSString>*/ **)alternateColors printColor:(NSString **)printColor
    852851{
    853     FrontendChannel* frontendChannel = _controller->frontendChannel();
    854     if (!frontendChannel)
    855         return;
     852    const FrontendRouter& router = _controller->frontendRouter();
    856853
    857854    THROW_EXCEPTION_FOR_BAD_OPTIONAL_PARAMETER(columnNames, @"columnNames");
    … …  
    886883        paramsObject->setString(ASCIILiteral("printColor"), (*printColor));
    887884    jsonMessage->setObject(ASCIILiteral("params"), WTF::move(paramsObject));
    888     frontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
     885    router.sendEvent(jsonMessage->toJSONString());
    889886}
    890887
    891888- (void)didExecuteNoOptionalParametersWithColumnNames:(NSArray/*<NSString>*/ *)columnNames notes:(NSString *)notes timestamp:(double)timestamp values:(RWIProtocolJSONObject *)values payload:(RWIProtocolJSONObject *)payload sqlError:(RWIProtocolDatabaseError *)sqlError screenColor:(NSString *)screenColor alternateColors:(NSArray/*<NSString>*/ *)alternateColors printColor:(NSString *)printColor
    892889{
    893     FrontendChannel* frontendChannel = _controller->frontendChannel();
    894     if (!frontendChannel)
    895         return;
     890    const FrontendRouter& router = _controller->frontendRouter();
    896891
    897892    THROW_EXCEPTION_FOR_REQUIRED_PARAMETER(columnNames, @"columnNames");
    … …  
    917912    paramsObject->setString(ASCIILiteral("printColor"), printColor);
    918913    jsonMessage->setObject(ASCIILiteral("params"), WTF::move(paramsObject));
    919     frontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
     914    router.sendEvent(jsonMessage->toJSONString());
    920915}
    921916

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/generate-domains-with-feature-guards.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    165166class Network1BackendDispatcher final : public SupplementalBackendDispatcher {
    166167public:
    167     static Ref<Network1BackendDispatcher> create(BackendDispatcher*, Network1BackendDispatcherHandler*);
     168    static Ref<Network1BackendDispatcher> create(BackendDispatcher&, Network1BackendDispatcherHandler*);
    168169    virtual void dispatch(long requestId, const String& method, Ref<InspectorObject>&& message) override;
    169170private:
    … …  
    220221#include "InspectorBackendDispatchers.h"
    221222
    222 #include <inspector/InspectorFrontendChannel.h>
     223#include <inspector/InspectorFrontendRouter.h>
    223224#include <inspector/InspectorValues.h>
    224225#include <wtf/NeverDestroyed.h>
    … …  
    236237
    237238#if PLATFORM(WEB_COMMANDS)
    238 Ref<Network1BackendDispatcher> Network1BackendDispatcher::create(BackendDispatcher* backendDispatcher, Network1BackendDispatcherHandler* agent)
    239 {
    240     return adoptRef(*new Network1BackendDispatcher(*backendDispatcher, agent));
     239Ref<Network1BackendDispatcher> Network1BackendDispatcher::create(BackendDispatcher& backendDispatcher, Network1BackendDispatcherHandler* agent)
     240{
     241    return adoptRef(*new Network1BackendDispatcher(backendDispatcher, agent));
    241242}
    242243
    … …  
    323324
    324325#include "InspectorProtocolObjects.h"
    325 #include <inspector/InspectorFrontendChannel.h>
    326326#include <inspector/InspectorValues.h>
    327327#include <wtf/text/WTFString.h>
    … …  
    329329namespace Inspector {
    330330
    331 
     331class FrontendRouter;
    332332
    333333#if PLATFORM(WEB_EVENTS)
    334334class Network3FrontendDispatcher {
    335335public:
    336     Network3FrontendDispatcher(FrontendChannel* frontendChannel) : m_frontendChannel(frontendChannel) { }
     336    Network3FrontendDispatcher(FrontendRouter& frontendRouter) : m_frontendRouter(frontendRouter) { }
    337337    void resourceLoaded();
    338338private:
    339     FrontendChannel* m_frontendChannel;
     339    FrontendRouter& m_frontendRouter;
    340340};
    341341#endif // PLATFORM(WEB_EVENTS)
    … …  
    380380#include "InspectorFrontendDispatchers.h"
    381381
     382#include "InspectorFrontendRouter.h"
    382383#include <wtf/text/CString.h>
    383384
    … …  
    390391    jsonMessage->setString(ASCIILiteral("method"), ASCIILiteral("Network3.resourceLoaded"));
    391392
    392     m_frontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
     393    m_frontendRouter.sendEvent(jsonMessage->toJSONString());
    393394}
    394395#endif // PLATFORM(WEB_EVENTS)
    … …  
    725726
    726727    auto alternateDispatcher = std::make_unique<ObjCInspectorNetwork1BackendDispatcher>(handler);
    727     auto alternateAgent = std::make_unique<AlternateDispatchableAgent<Network1BackendDispatcher, AlternateNetwork1BackendDispatcher>>(ASCIILiteral("Network1"), WTF::move(alternateDispatcher));
     728    auto alternateAgent = std::make_unique<AlternateDispatchableAgent<Network1BackendDispatcher, AlternateNetwork1BackendDispatcher>>(ASCIILiteral("Network1"), *_controller, WTF::move(alternateDispatcher));
    728729    _controller->appendExtraAgent(WTF::move(alternateAgent));
    729730}
    … …  
    777778// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    778779
    779 #import "RWIProtocol.h"
     780#import <WebInspector/RWIProtocol.h>
    780781
    781782__attribute__((visibility ("default")))
    … …  
    824825#include "RWIProtocolInternal.h"
    825826#include "RWIProtocolEnumConversionHelpers.h"
    826 #include <JavaScriptCore/InspectorFrontendChannel.h>
    827827#include <JavaScriptCore/InspectorValues.h>
    828828
    … …  
    937937
    938938#import "RWIProtocolEnumConversionHelpers.h"
    939 #import <JavaScriptCore/InspectorFrontendChannel.h>
    940939#import <JavaScriptCore/InspectorValues.h>
    941940
    … …  
    963962- (void)resourceLoaded
    964963{
    965     FrontendChannel* frontendChannel = _controller->frontendChannel();
    966     if (!frontendChannel)
    967         return;
     964    const FrontendRouter& router = _controller->frontendRouter();
    968965
    969966    Ref<InspectorObject> jsonMessage = InspectorObject::create();
    970967    jsonMessage->setString(ASCIILiteral("method"), ASCIILiteral("Network3.resourceLoaded"));
    971     frontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
     968    router.sendEvent(jsonMessage->toJSONString());
    972969}
    973970

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/same-type-id-different-domain.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    173174#include "InspectorBackendDispatchers.h"
    174175
    175 #include <inspector/InspectorFrontendChannel.h>
     176#include <inspector/InspectorFrontendRouter.h>
    176177#include <inspector/InspectorValues.h>
    177178#include <wtf/NeverDestroyed.h>
    … …  
    225226
    226227#include "InspectorProtocolObjects.h"
    227 #include <inspector/InspectorFrontendChannel.h>
    228228#include <inspector/InspectorValues.h>
    229229#include <wtf/text/WTFString.h>
    … …  
    231231namespace Inspector {
    232232
    233 
     233class FrontendRouter;
    234234
    235235} // namespace Inspector
    … …  
    272272#include "InspectorFrontendDispatchers.h"
    273273
     274#include "InspectorFrontendRouter.h"
    274275#include <wtf/text/CString.h>
    275276
    … …  
    554555// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    555556
    556 #import "RWIProtocol.h"
     557#import <WebInspector/RWIProtocol.h>
    557558
    558559__attribute__((visibility ("default")))
    … …  
    599600#include "RWIProtocolInternal.h"
    600601#include "RWIProtocolEnumConversionHelpers.h"
    601 #include <JavaScriptCore/InspectorFrontendChannel.h>
    602602#include <JavaScriptCore/InspectorValues.h>
    603603
    … …  
    693693
    694694#import "RWIProtocolEnumConversionHelpers.h"
    695 #import <JavaScriptCore/InspectorFrontendChannel.h>
    696695#import <JavaScriptCore/InspectorValues.h>
    697696

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/shadowed-optional-type-setters.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    173174#include "InspectorBackendDispatchers.h"
    174175
    175 #include <inspector/InspectorFrontendChannel.h>
     176#include <inspector/InspectorFrontendRouter.h>
    176177#include <inspector/InspectorValues.h>
    177178#include <wtf/NeverDestroyed.h>
    … …  
    225226
    226227#include "InspectorProtocolObjects.h"
    227 #include <inspector/InspectorFrontendChannel.h>
    228228#include <inspector/InspectorValues.h>
    229229#include <wtf/text/WTFString.h>
    … …  
    231231namespace Inspector {
    232232
    233 
     233class FrontendRouter;
    234234
    235235} // namespace Inspector
    … …  
    272272#include "InspectorFrontendDispatchers.h"
    273273
     274#include "InspectorFrontendRouter.h"
    274275#include <wtf/text/CString.h>
    275276
    … …  
    625626// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    626627
    627 #import "RWIProtocol.h"
     628#import <WebInspector/RWIProtocol.h>
    628629
    629630__attribute__((visibility ("default")))
    … …  
    670671#include "RWIProtocolInternal.h"
    671672#include "RWIProtocolEnumConversionHelpers.h"
    672 #include <JavaScriptCore/InspectorFrontendChannel.h>
    673673#include <JavaScriptCore/InspectorValues.h>
    674674
    … …  
    784784
    785785#import "RWIProtocolEnumConversionHelpers.h"
    786 #import <JavaScriptCore/InspectorFrontendChannel.h>
    787786#import <JavaScriptCore/InspectorValues.h>
    788787

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/type-declaration-aliased-primitive-type.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    173174#include "InspectorBackendDispatchers.h"
    174175
    175 #include <inspector/InspectorFrontendChannel.h>
     176#include <inspector/InspectorFrontendRouter.h>
    176177#include <inspector/InspectorValues.h>
    177178#include <wtf/NeverDestroyed.h>
    … …  
    225226
    226227#include "InspectorProtocolObjects.h"
    227 #include <inspector/InspectorFrontendChannel.h>
    228228#include <inspector/InspectorValues.h>
    229229#include <wtf/text/WTFString.h>
    … …  
    231231namespace Inspector {
    232232
    233 
     233class FrontendRouter;
    234234
    235235} // namespace Inspector
    … …  
    272272#include "InspectorFrontendDispatchers.h"
    273273
     274#include "InspectorFrontendRouter.h"
    274275#include <wtf/text/CString.h>
    275276
    … …  
    547548// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    548549
    549 #import "RWIProtocol.h"
     550#import <WebInspector/RWIProtocol.h>
    550551
    551552__attribute__((visibility ("default")))
    … …  
    592593#include "RWIProtocolInternal.h"
    593594#include "RWIProtocolEnumConversionHelpers.h"
    594 #include <JavaScriptCore/InspectorFrontendChannel.h>
    595595#include <JavaScriptCore/InspectorValues.h>
    596596
    … …  
    682682
    683683#import "RWIProtocolEnumConversionHelpers.h"
    684 #import <JavaScriptCore/InspectorFrontendChannel.h>
    685684#import <JavaScriptCore/InspectorValues.h>
    686685

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/type-declaration-array-type.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    176177#include "InspectorBackendDispatchers.h"
    177178
    178 #include <inspector/InspectorFrontendChannel.h>
     179#include <inspector/InspectorFrontendRouter.h>
    179180#include <inspector/InspectorValues.h>
    180181#include <wtf/NeverDestroyed.h>
    … …  
    228229
    229230#include "InspectorProtocolObjects.h"
    230 #include <inspector/InspectorFrontendChannel.h>
    231231#include <inspector/InspectorValues.h>
    232232#include <wtf/text/WTFString.h>
    … …  
    234234namespace Inspector {
    235235
    236 
     236class FrontendRouter;
    237237
    238238} // namespace Inspector
    … …  
    275275#include "InspectorFrontendDispatchers.h"
    276276
     277#include "InspectorFrontendRouter.h"
    277278#include <wtf/text/CString.h>
    278279
    … …  
    577578// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    578579
    579 #import "RWIProtocol.h"
     580#import <WebInspector/RWIProtocol.h>
    580581
    581582__attribute__((visibility ("default")))
    … …  
    622623#include "RWIProtocolInternal.h"
    623624#include "RWIProtocolEnumConversionHelpers.h"
    624 #include <JavaScriptCore/InspectorFrontendChannel.h>
    625625#include <JavaScriptCore/InspectorValues.h>
    626626
    … …  
    740740
    741741#import "RWIProtocolEnumConversionHelpers.h"
    742 #import <JavaScriptCore/InspectorFrontendChannel.h>
    743742#import <JavaScriptCore/InspectorValues.h>
    744743

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/type-declaration-enum-type.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    177178#include "InspectorBackendDispatchers.h"
    178179
    179 #include <inspector/InspectorFrontendChannel.h>
     180#include <inspector/InspectorFrontendRouter.h>
    180181#include <inspector/InspectorValues.h>
    181182#include <wtf/NeverDestroyed.h>
    … …  
    229230
    230231#include "InspectorProtocolObjects.h"
    231 #include <inspector/InspectorFrontendChannel.h>
    232232#include <inspector/InspectorValues.h>
    233233#include <wtf/text/WTFString.h>
    … …  
    235235namespace Inspector {
    236236
    237 
     237class FrontendRouter;
    238238
    239239} // namespace Inspector
    … …  
    276276#include "InspectorFrontendDispatchers.h"
    277277
     278#include "InspectorFrontendRouter.h"
    278279#include <wtf/text/CString.h>
    279280
    … …  
    576577// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    577578
    578 #import "RWIProtocol.h"
     579#import <WebInspector/RWIProtocol.h>
    579580
    580581__attribute__((visibility ("default")))
    … …  
    621622#include "RWIProtocolInternal.h"
    622623#include "RWIProtocolEnumConversionHelpers.h"
    623 #include <JavaScriptCore/InspectorFrontendChannel.h>
    624624#include <JavaScriptCore/InspectorValues.h>
    625625
    … …  
    768768
    769769#import "RWIProtocolEnumConversionHelpers.h"
    770 #import <JavaScriptCore/InspectorFrontendChannel.h>
    771770#import <JavaScriptCore/InspectorValues.h>
    772771

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/type-declaration-object-type.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    173174#include "InspectorBackendDispatchers.h"
    174175
    175 #include <inspector/InspectorFrontendChannel.h>
     176#include <inspector/InspectorFrontendRouter.h>
    176177#include <inspector/InspectorValues.h>
    177178#include <wtf/NeverDestroyed.h>
    … …  
    225226
    226227#include "InspectorProtocolObjects.h"
    227 #include <inspector/InspectorFrontendChannel.h>
    228228#include <inspector/InspectorValues.h>
    229229#include <wtf/text/WTFString.h>
    … …  
    231231namespace Inspector {
    232232
    233 
     233class FrontendRouter;
    234234
    235235} // namespace Inspector
    … …  
    272272#include "InspectorFrontendDispatchers.h"
    273273
     274#include "InspectorFrontendRouter.h"
    274275#include <wtf/text/CString.h>
    275276
    … …  
    10141015// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    10151016
    1016 #import "RWIProtocol.h"
     1017#import <WebInspector/RWIProtocol.h>
    10171018
    10181019__attribute__((visibility ("default")))
    … …  
    10591060#include "RWIProtocolInternal.h"
    10601061#include "RWIProtocolEnumConversionHelpers.h"
    1061 #include <JavaScriptCore/InspectorFrontendChannel.h>
    10621062#include <JavaScriptCore/InspectorValues.h>
    10631063
    … …  
    11531153
    11541154#import "RWIProtocolEnumConversionHelpers.h"
    1155 #import <JavaScriptCore/InspectorFrontendChannel.h>
    11561155#import <JavaScriptCore/InspectorValues.h>
    11571156

  • trunk/Source/JavaScriptCore/inspector/scripts/tests/expected/type-requiring-runtime-casts.json-result

    r188965 r190905  
    3636
    3737#include "InspectorProtocolTypes.h"
     38#include <inspector/InspectorFrontendRouter.h>
    3839#include <JavaScriptCore/InspectorBackendDispatcher.h>
    3940
    … …  
    177178#include "InspectorBackendDispatchers.h"
    178179
    179 #include <inspector/InspectorFrontendChannel.h>
     180#include <inspector/InspectorFrontendRouter.h>
    180181#include <inspector/InspectorValues.h>
    181182#include <wtf/NeverDestroyed.h>
    … …  
    229230
    230231#include "InspectorProtocolObjects.h"
    231 #include <inspector/InspectorFrontendChannel.h>
    232232#include <inspector/InspectorValues.h>
    233233#include <wtf/text/WTFString.h>
    … …  
    235235namespace Inspector {
    236236
    237 
     237class FrontendRouter;
    238238
    239239} // namespace Inspector
    … …  
    276276#include "InspectorFrontendDispatchers.h"
    277277
     278#include "InspectorFrontendRouter.h"
    278279#include <wtf/text/CString.h>
    279280
    … …  
    903904// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
    904905
    905 #import "RWIProtocol.h"
     906#import <WebInspector/RWIProtocol.h>
    906907
    907908__attribute__((visibility ("default")))
    … …  
    948949#include "RWIProtocolInternal.h"
    949950#include "RWIProtocolEnumConversionHelpers.h"
    950 #include <JavaScriptCore/InspectorFrontendChannel.h>
    951951#include <JavaScriptCore/InspectorValues.h>
    952952
    … …  
    10951095
    10961096#import "RWIProtocolEnumConversionHelpers.h"
    1097 #import <JavaScriptCore/InspectorFrontendChannel.h>
    10981097#import <JavaScriptCore/InspectorValues.h>
    10991098
Note: See TracChangeset for help on using the changeset viewer.