Changeset 64534 in webkit


Ignore:
Timestamp:
Aug 3, 2010 12:36:44 AM (14 years ago)
Author:
pfeldman@chromium.org
Message:

2010-08-02 Pavel Feldman <​pfeldman@chromium.org>

Reviewed by Yury Semikhatsky.

Chromium DevTools: Get rid of DevTools RPC.

​https://bugs.webkit.org/show_bug.cgi?id=43335

  • bindings/js/ScriptProfiler.h: (WebCore::ScriptProfiler::getProfilerLogLines):
  • bindings/v8/ScriptProfiler.cpp: (WebCore::ScriptProfiler::getProfilerLogLines):
  • bindings/v8/ScriptProfiler.h:
  • inspector/Inspector.idl:
  • inspector/InspectorBackend.cpp: (WebCore::InspectorBackend::takeHeapSnapshot): (WebCore::InspectorBackend::getProfilerLogLines):
  • inspector/InspectorBackend.h:
  • inspector/InspectorController.cpp: (WebCore::InspectorController::disableProfiler):
  • inspector/InspectorController.h:
  • inspector/InspectorFrontend.h:
  • inspector/front-end/InspectorBackendStub.js: (WebInspector.InspectorBackendStub):

2010-08-02 Pavel Feldman <​pfeldman@chromium.org>

Reviewed by Yury Semikhatsky.

Chromium DevTools: Get rid of DevTools RPC.

​https://bugs.webkit.org/show_bug.cgi?id=43335

  • WebKit.gyp:
  • public/WebDevToolsAgent.h:
  • public/WebDevToolsAgentClient.h: (WebKit::WebDevToolsAgentClient::sendMessageToInspectorFrontend): (WebKit::WebDevToolsAgentClient::sendDebuggerOutput): (WebKit::WebDevToolsAgentClient::sendDispatchToAPU):
  • public/WebDevToolsFrontend.h:
  • public/WebDevToolsFrontendClient.h: (WebKit::WebDevToolsFrontendClient::sendMessageToBackend):
  • public/WebDevToolsMessageData.h: Removed.
  • public/WebDevToolsMessageTransport.h: Removed.
  • src/APUAgentDelegate.h: Removed.
  • src/DebuggerAgent.h: Removed.
  • src/DebuggerAgentImpl.cpp: (WebKit::DebuggerAgentImpl::DebuggerAgentImpl): (WebKit::DebuggerAgentImpl::debuggerOutput):
  • src/DebuggerAgentImpl.h:
  • src/DebuggerAgentManager.cpp: (WebKit::DebuggerAgentManager::debugDetach): (WebKit::DebuggerAgentManager::onV8DebugMessage): (WebKit::DebuggerAgentManager::executeDebuggerCommand): (WebKit::DebuggerAgentManager::sendCommandToV8): (WebKit::DebuggerAgentManager::sendContinueCommandToV8):
  • src/DevToolsRPC.h: Removed.
  • src/DevToolsRPCJS.h: Removed.
  • src/InspectorClientImpl.cpp:
  • src/InspectorFrontendClientImpl.cpp: (WebKit::InspectorFrontendClientImpl::sendMessageToBackend):
  • src/ProfilerAgent.h: Removed.
  • src/ProfilerAgentImpl.cpp: Removed.
  • src/ProfilerAgentImpl.h: Removed.
  • src/ToolsAgent.h: Removed.
  • src/WebDevToolsAgentImpl.cpp: (WebKit::): (WebKit::WebDevToolsAgentImpl::WebDevToolsAgentImpl): (WebKit::WebDevToolsAgentImpl::attach): (WebKit::WebDevToolsAgentImpl::didClearWindowObject): (WebKit::WebDevToolsAgentImpl::dispatchOnInspectorBackend): (WebKit::WebDevToolsAgentImpl::jsDispatchOnClient): (WebKit::WebDevToolsAgentImpl::sendMessageToFrontend):
  • src/WebDevToolsAgentImpl.h:
  • src/WebDevToolsFrontendImpl.cpp: (WebKit::WebDevToolsFrontendImpl::WebDevToolsFrontendImpl): (WebKit::WebDevToolsFrontendImpl::dispatchOnInspectorFrontend): (WebKit::WebDevToolsFrontendImpl::frontendLoaded): (WebKit::WebDevToolsFrontendImpl::executeScript):
  • src/WebDevToolsFrontendImpl.h:
  • src/js/DevTools.js: (devtools.dispatch): (devtools.ToolsAgent):
  • src/js/DevToolsHostStub.js:
  • src/js/ProfilerAgent.js: (devtools.ProfilerAgent):

2010-08-02 Pavel Feldman <​pfeldman@chromium.org>

Reviewed by Yury Semikhatsky.

Chromium DevTools: Get rid of DevTools RPC.

​https://bugs.webkit.org/show_bug.cgi?id=43335

  • DumpRenderTree/chromium/DRTDevToolsAgent.cpp: (DRTDevToolsAgent::sendMessageToInspectorFrontend): (DRTDevToolsAgent::call):
  • DumpRenderTree/chromium/DRTDevToolsAgent.h:
  • DumpRenderTree/chromium/DRTDevToolsCallArgs.h: (DRTDevToolsCallArgs::DRTDevToolsCallArgs):
  • DumpRenderTree/chromium/DRTDevToolsClient.cpp: (DRTDevToolsClient::sendMessageToBackend): (DRTDevToolsClient::call):
  • DumpRenderTree/chromium/DRTDevToolsClient.h:
Location:
trunk
Files:
10 deleted
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r64532 r64534  
     12010-08-02  Pavel Feldman  <pfeldman@chromium.org>
     2
     3        Reviewed by Yury Semikhatsky.
     4
     5        Chromium DevTools: Get rid of DevTools RPC.
     6
     7        https://bugs.webkit.org/show_bug.cgi?id=43335
     8
     9        * bindings/js/ScriptProfiler.h:
     10        (WebCore::ScriptProfiler::getProfilerLogLines):
     11        * bindings/v8/ScriptProfiler.cpp:
     12        (WebCore::ScriptProfiler::getProfilerLogLines):
     13        * bindings/v8/ScriptProfiler.h:
     14        * inspector/Inspector.idl:
     15        * inspector/InspectorBackend.cpp:
     16        (WebCore::InspectorBackend::takeHeapSnapshot):
     17        (WebCore::InspectorBackend::getProfilerLogLines):
     18        * inspector/InspectorBackend.h:
     19        * inspector/InspectorController.cpp:
     20        (WebCore::InspectorController::disableProfiler):
     21        * inspector/InspectorController.h:
     22        * inspector/InspectorFrontend.h:
     23        * inspector/front-end/InspectorBackendStub.js:
     24        (WebInspector.InspectorBackendStub):
     25
    1262010-08-02  Dan Bernstein  <mitz@apple.com>
    227

  • trunk/WebCore/bindings/js/ScriptProfiler.h

    r61411 r64534  
    4141    static PassRefPtr<ScriptProfile> stop(ScriptState* state, const String& title);
    4242    static void takeHeapSnapshot() { }
     43    static long getProfilerLogLines(long, String*) { return 0; }
    4344};
    4445

  • trunk/WebCore/bindings/v8/ScriptProfiler.cpp

    r61411 r64534  
    6060}
    6161
     62long ScriptProfiler::getProfilerLogLines(long position, String* data)
     63{
     64    static char buffer[65536];
     65    const int readSize = v8::V8::GetLogLines(position, buffer, sizeof(buffer) - 1);
     66    buffer[readSize] = '\0';
     67    position += readSize;
     68    *data = buffer;
     69    return position;
     70}
     71
    6272} // namespace WebCore

  • trunk/WebCore/bindings/v8/ScriptProfiler.h

    r61411 r64534  
    4545    static PassRefPtr<ScriptProfile> stop(ScriptState* state, const String& title);
    4646    static void takeHeapSnapshot();
     47    static long getProfilerLogLines(long position, String* data);
    4748};
    4849

  • trunk/WebCore/inspector/Inspector.idl

    r63891 r64534  
    9999
    100100        void takeHeapSnapshot();
     101        void getProfilerLogLines(in long callId, in long inPosition, out long outPosition, out String log);
    101102#endif
    102103        void setInjectedScriptSource(in String scriptSource);
    … …  
    158159        void removeDOMStorageItem(in long callId, in long storageId, in String key);
    159160#endif
     161
    160162    };
    161163}

  • trunk/WebCore/inspector/InspectorBackend.cpp

    r63891 r64534  
    5353#include "ScriptArray.h"
    5454#include "ScriptBreakpoint.h"
     55#include "ScriptProfiler.h"
    5556#include "SerializedScriptValue.h"
    5657
    … …  
    293294void InspectorBackend::takeHeapSnapshot()
    294295{
    295     if (m_inspectorController)
    296         m_inspectorController->takeHeapSnapshot();
     296    ScriptProfiler::takeHeapSnapshot();
     297}
     298
     299void InspectorBackend::getProfilerLogLines(long callId, long position)
     300{
     301    // FIXME: we should make inspector dispatcher pluggable, so that embedders could contribute APIs instead of polluting the core one
     302    // https://bugs.webkit.org/show_bug.cgi?id=43357
     303    if (RemoteInspectorFrontend* frontend = remoteFrontend()) {
     304        String data;
     305        int outPosition = ScriptProfiler::getProfilerLogLines(position, &data);
     306        frontend->didGetProfilerLogLines(callId, outPosition, data);
     307    }
    297308}
    298309#endif

  • trunk/WebCore/inspector/InspectorBackend.h

    r63891 r64534  
    113113
    114114    void takeHeapSnapshot();
     115    void getProfilerLogLines(long callId, long position);
    115116#endif
    116117

  • trunk/WebCore/inspector/InspectorController.cpp

    r64458 r64534  
    16891689        m_frontend->profilerWasDisabled();
    16901690}
    1691 
    1692 void InspectorController::takeHeapSnapshot()
    1693 {
    1694     if (!enabled())
    1695         return;
    1696 
    1697     ScriptProfiler::takeHeapSnapshot();
    1698 }
    16991691#endif
    17001692

  • trunk/WebCore/inspector/InspectorController.h

    r64142 r64534  
    261261    bool profilerEnabled() const { return enabled() && m_profilerEnabled; }
    262262
    263     void takeHeapSnapshot();
    264 
    265263    void enableDebugger();
    266264    void disableDebugger(bool always = false);

  • trunk/WebCore/inspector/front-end/InspectorBackendStub.js

    r64204 r64534  
    8282    this._registerDelegate("storeLastActivePanel");
    8383    this._registerDelegate("takeHeapSnapshot");
     84    this._registerDelegate("getProfilerLogLines");
    8485
    8586    this._registerDelegate("getAllStyles");

  • trunk/WebKit/chromium/ChangeLog

    r64530 r64534  
     12010-08-02  Pavel Feldman  <pfeldman@chromium.org>
     2
     3        Reviewed by Yury Semikhatsky.
     4
     5        Chromium DevTools: Get rid of DevTools RPC.
     6
     7        https://bugs.webkit.org/show_bug.cgi?id=43335
     8
     9        * WebKit.gyp:
     10        * public/WebDevToolsAgent.h:
     11        * public/WebDevToolsAgentClient.h:
     12        (WebKit::WebDevToolsAgentClient::sendMessageToInspectorFrontend):
     13        (WebKit::WebDevToolsAgentClient::sendDebuggerOutput):
     14        (WebKit::WebDevToolsAgentClient::sendDispatchToAPU):
     15        * public/WebDevToolsFrontend.h:
     16        * public/WebDevToolsFrontendClient.h:
     17        (WebKit::WebDevToolsFrontendClient::sendMessageToBackend):
     18        * public/WebDevToolsMessageData.h: Removed.
     19        * public/WebDevToolsMessageTransport.h: Removed.
     20        * src/APUAgentDelegate.h: Removed.
     21        * src/DebuggerAgent.h: Removed.
     22        * src/DebuggerAgentImpl.cpp:
     23        (WebKit::DebuggerAgentImpl::DebuggerAgentImpl):
     24        (WebKit::DebuggerAgentImpl::debuggerOutput):
     25        * src/DebuggerAgentImpl.h:
     26        * src/DebuggerAgentManager.cpp:
     27        (WebKit::DebuggerAgentManager::debugDetach):
     28        (WebKit::DebuggerAgentManager::onV8DebugMessage):
     29        (WebKit::DebuggerAgentManager::executeDebuggerCommand):
     30        (WebKit::DebuggerAgentManager::sendCommandToV8):
     31        (WebKit::DebuggerAgentManager::sendContinueCommandToV8):
     32        * src/DevToolsRPC.h: Removed.
     33        * src/DevToolsRPCJS.h: Removed.
     34        * src/InspectorClientImpl.cpp:
     35        * src/InspectorFrontendClientImpl.cpp:
     36        (WebKit::InspectorFrontendClientImpl::sendMessageToBackend):
     37        * src/ProfilerAgent.h: Removed.
     38        * src/ProfilerAgentImpl.cpp: Removed.
     39        * src/ProfilerAgentImpl.h: Removed.
     40        * src/ToolsAgent.h: Removed.
     41        * src/WebDevToolsAgentImpl.cpp:
     42        (WebKit::):
     43        (WebKit::WebDevToolsAgentImpl::WebDevToolsAgentImpl):
     44        (WebKit::WebDevToolsAgentImpl::attach):
     45        (WebKit::WebDevToolsAgentImpl::didClearWindowObject):
     46        (WebKit::WebDevToolsAgentImpl::dispatchOnInspectorBackend):
     47        (WebKit::WebDevToolsAgentImpl::jsDispatchOnClient):
     48        (WebKit::WebDevToolsAgentImpl::sendMessageToFrontend):
     49        * src/WebDevToolsAgentImpl.h:
     50        * src/WebDevToolsFrontendImpl.cpp:
     51        (WebKit::WebDevToolsFrontendImpl::WebDevToolsFrontendImpl):
     52        (WebKit::WebDevToolsFrontendImpl::dispatchOnInspectorFrontend):
     53        (WebKit::WebDevToolsFrontendImpl::frontendLoaded):
     54        (WebKit::WebDevToolsFrontendImpl::executeScript):
     55        * src/WebDevToolsFrontendImpl.h:
     56        * src/js/DevTools.js:
     57        (devtools.dispatch):
     58        (devtools.ToolsAgent):
     59        * src/js/DevToolsHostStub.js:
     60        * src/js/ProfilerAgent.js:
     61        (devtools.ProfilerAgent):
     62        (devtools.ProfilerAgent.prototype._getNextLogLines.else.delayedRequest):
     63        (devtools.ProfilerAgent.prototype._getNextLogLines):
     64        (devtools.ProfilerAgent.prototype._didGetProfilerLogLines):
     65        * src/js/ProfilerProcessor.js:
     66        (devtools.profiler.Processor.prototype.printError):
     67
    1682010-08-02  Kent Tamura  <tkent@chromium.org>
    269

  • trunk/WebKit/chromium/WebKit.gyp

    r64463 r64534  
    143143                'public/WebDevToolsFrontend.h',
    144144                'public/WebDevToolsFrontendClient.h',
    145                 'public/WebDevToolsMessageData.h',
    146                 'public/WebDevToolsMessageTransport.h',
    147145                'public/WebDocument.h',
    148146                'public/WebDocumentType.h',
    … …  
    272270                'public/win/WebScreenInfoFactory.h',
    273271                'public/win/WebScreenInfoFactory.h',
    274                 'src/APUAgentDelegate.h',
    275272                'src/ApplicationCacheHost.cpp',
    276273                'src/ApplicationCacheHostInternal.h',
    … …  
    293290                'src/ContextMenuClientImpl.h',
    294291                'src/DatabaseObserver.cpp',
    295                 'src/DebuggerAgent.h',
    296292                'src/DebuggerAgentImpl.cpp',
    297293                'src/DebuggerAgentImpl.h',
    298294                'src/DebuggerAgentManager.cpp',
    299295                'src/DebuggerAgentManager.h',
    300                 'src/DevToolsRPC.h',
    301                 'src/DevToolsRPCJS.h',
    302296                'src/DOMUtilitiesPrivate.cpp',
    303297                'src/DOMUtilitiesPrivate.h',
    … …  
    344338                'src/PlatformMessagePortChannel.cpp',
    345339                'src/PlatformMessagePortChannel.h',
    346                 'src/ProfilerAgent.h',
    347                 'src/ProfilerAgentImpl.cpp',
    348                 'src/ProfilerAgentImpl.h',
    349340                'src/ResourceHandle.cpp',
    350341                'src/SharedWorkerRepository.cpp',
    … …  
    360351                'src/StorageNamespaceProxy.h',
    361352                'src/TemporaryGlue.h',
    362                 'src/ToolsAgent.h',
    363353                'src/WebAccessibilityCache.cpp',
    364354                'src/WebAccessibilityCacheImpl.cpp',

  • trunk/WebKit/chromium/public/WebDevToolsAgent.h

    r62927 r64534  
    5555    virtual void didNavigate() = 0;
    5656
    57     virtual void dispatchMessageFromFrontend(const WebDevToolsMessageData&) = 0;
     57    virtual void dispatchOnInspectorBackend(const WebString& message) = 0;
    5858
    5959    virtual void inspectElementAt(const WebPoint&) = 0;
    … …  
    7272    // Asynchronously request debugger to pause immediately.
    7373    WEBKIT_API static void debuggerPauseScript();
    74 
    75     WEBKIT_API static bool dispatchMessageFromFrontendOnIOThread(WebDevToolsMessageTransport*, const WebDevToolsMessageData&);
    7674
    7775    typedef void (*MessageLoopDispatchHandler)();

  • trunk/WebKit/chromium/public/WebDevToolsAgentClient.h

    r61616 r64534  
    4141class WebDevToolsAgentClient {
    4242public:
    43     virtual void sendMessageToFrontend(const WebDevToolsMessageData&) { }
     43    virtual void sendMessageToInspectorFrontend(const WebString&) { }
     44    virtual void sendDebuggerOutput(const WebString&) { }
     45    virtual void sendDispatchToAPU(const WebString&) { }
    4446
    4547    // Invalidates widget which leads to the repaint.

  • trunk/WebKit/chromium/public/WebDevToolsFrontend.h

    r51984 r64534  
    3939class WebString;
    4040class WebView;
    41 struct WebDevToolsMessageData;
    4241
    4342// WebDevToolsFrontend represents DevTools client sitting in the Glue. It provides
    … …  
    5150    virtual ~WebDevToolsFrontend() {}
    5251
    53     virtual void dispatchMessageFromAgent(const WebDevToolsMessageData&) = 0;
     52    virtual void dispatchOnInspectorFrontend(const WebString&) = 0;
    5453};
    5554

  • trunk/WebKit/chromium/public/WebDevToolsFrontendClient.h

    r60436 r64534  
    4141    WebDevToolsFrontendClient() { }
    4242
    43     virtual void sendMessageToAgent(const WebDevToolsMessageData&) { }
     43    virtual void sendMessageToBackend(const WebString&) { }
    4444    virtual void sendDebuggerCommandToAgent(const WebString& command) { }
    4545    virtual void sendDebuggerPauseScript() { }

  • trunk/WebKit/chromium/src/DebuggerAgentImpl.cpp

    r60893 r64534  
    3838#include "ScriptDebugServer.h"
    3939#include "V8Binding.h"
     40#include "WebDevToolsAgentClient.h"
    4041#include "WebDevToolsAgentImpl.h"
    4142#include "WebViewImpl.h"
    … …  
    5455DebuggerAgentImpl::DebuggerAgentImpl(
    5556    WebViewImpl* webViewImpl,
    56     DebuggerAgentDelegate* delegate,
    57     WebDevToolsAgentImpl* webdevtoolsAgent)
     57    WebDevToolsAgentImpl* webdevtoolsAgent,
     58    WebDevToolsAgentClient* webdevtoolsAgentClient)
    5859    : m_webViewImpl(webViewImpl)
    59     , m_delegate(delegate)
    6060    , m_webdevtoolsAgent(webdevtoolsAgent)
     61    , m_webdevtoolsAgentClient(webdevtoolsAgentClient)
    6162    , m_autoContinueOnException(false)
    6263{
    … …  
    6970}
    7071
    71 void DebuggerAgentImpl::getContextId()
    72 {
    73     m_delegate->setContextId(m_webdevtoolsAgent->hostId());
    74 }
    75 
    76 void DebuggerAgentImpl::processDebugCommands()
    77 {
    78     DebuggerAgentManager::UtilityContextScope utilityScope;
    79     v8::Debug::ProcessDebugMessages();
    80 }
    81 
    8272void DebuggerAgentImpl::debuggerOutput(const String& command)
    8373{
    84     m_delegate->debuggerOutput(command);
     74    m_webdevtoolsAgentClient->sendDebuggerOutput(command);
    8575    m_webdevtoolsAgent->forceRepaint();
    8676}

  • trunk/WebKit/chromium/src/DebuggerAgentImpl.h

    r60893 r64534  
    3232#define DebuggerAgentImpl_h
    3333
    34 #include "DebuggerAgent.h"
    35 
    3634#include <v8.h>
    3735#include <wtf/HashSet.h>
    … …  
    4846namespace WebKit {
    4947
     48class WebDevToolsAgentClient;
    5049class WebDevToolsAgentImpl;
    5150class WebViewImpl;
    5251
    53 class DebuggerAgentImpl : public DebuggerAgent {
     52class DebuggerAgentImpl {
    5453public:
    5554    DebuggerAgentImpl(WebKit::WebViewImpl* webViewImpl,
    56                       DebuggerAgentDelegate* delegate,
    57                       WebDevToolsAgentImpl* webdevtoolsAgent);
     55                      WebDevToolsAgentImpl* webdevtoolsAgent,
     56                      WebDevToolsAgentClient* webdevtoolsAgentClient);
    5857    virtual ~DebuggerAgentImpl();
    59 
    60     // DebuggerAgent implementation.
    61     virtual void getContextId();
    62     virtual void processDebugCommands();
    6358
    6459    void debuggerOutput(const WebCore::String& out);
    … …  
    8883private:
    8984    WebKit::WebViewImpl* m_webViewImpl;
    90     DebuggerAgentDelegate* m_delegate;
    9185    WebDevToolsAgentImpl* m_webdevtoolsAgent;
     86    WebDevToolsAgentClient* m_webdevtoolsAgentClient;
    9287    bool m_autoContinueOnException;
    9388};

  • trunk/WebKit/chromium/src/DebuggerAgentManager.cpp

    r63311 r64534  
    158158    } else {
    159159      // Remove all breakpoints set by the agent.
    160       String clearBreakpointGroupCmd = String::format(
     160      WebCore::String clearBreakpointGroupCmd = WebCore::String::format(
    161161          "{\"seq\":1,\"type\":\"request\",\"command\":\"clearbreakpointgroup\","
    162162              "\"arguments\":{\"groupId\":%d}}",
    … …  
    177177    v8::HandleScope scope;
    178178    v8::String::Value value(message.GetJSON());
    179     String out(reinterpret_cast<const UChar*>(*value), value.length());
     179    WebCore::String out(reinterpret_cast<const UChar*>(*value), value.length());
    180180
    181181    // If callerData is not 0 the message is a response to a debugger command.
    … …  
    249249}
    250250
    251 void DebuggerAgentManager::executeDebuggerCommand(const String& command, int callerId)
     251void DebuggerAgentManager::executeDebuggerCommand(const WebCore::String& command, int callerId)
    252252{
    253253    sendCommandToV8(command, new CallerIdWrapper(callerId));
    … …  
    287287}
    288288
    289 void DebuggerAgentManager::sendCommandToV8(const String& cmd, v8::Debug::ClientData* data)
     289void DebuggerAgentManager::sendCommandToV8(const WebCore::String& cmd, v8::Debug::ClientData* data)
    290290{
    291291    v8::Debug::SendCommand(reinterpret_cast<const uint16_t*>(cmd.characters()), cmd.length(), data);
    … …  
    294294void DebuggerAgentManager::sendContinueCommandToV8()
    295295{
    296     String continueCmd("{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}");
     296    WebCore::String continueCmd("{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}");
    297297    sendCommandToV8(continueCmd, new CallerIdWrapper());
    298298}

  • trunk/WebKit/chromium/src/InspectorClientImpl.cpp

    r61772 r64534  
    3737#include "Page.h"
    3838#include "WebDevToolsAgentImpl.h"
    39 #include "WebDevToolsMessageData.h"
    4039#include "WebRect.h"
    4140#include "WebURL.h"

  • trunk/WebKit/chromium/src/InspectorFrontendClientImpl.cpp

    r64124 r64534  
    4141#include "WebDevToolsFrontendClient.h"
    4242#include "WebDevToolsFrontendImpl.h"
     43#include "WebString.h"
    4344
    4445using namespace WebCore;
    … …  
    127128void InspectorFrontendClientImpl::sendMessageToBackend(const String& message)
    128129{
    129     WebDevToolsMessageData messageData;
    130     messageData.className = "ToolsAgent";
    131     messageData.methodName = "dispatchOnInspectorController";
    132     WebVector<WebString> args(static_cast<size_t>(1));
    133     args[0] = message;
    134     messageData.arguments.swap(args);
    135     m_client->sendMessageToAgent(messageData);
     130    m_client->sendMessageToBackend(message);
    136131}
    137132

  • trunk/WebKit/chromium/src/WebDevToolsAgentImpl.cpp

    r64124 r64534  
    4747#include "PageGroup.h"
    4848#include "PlatformString.h"
    49 #include "ProfilerAgentImpl.h"
    5049#include "ResourceError.h"
    5150#include "ResourceRequest.h"
    … …  
    6059#include "WebDataSource.h"
    6160#include "WebDevToolsAgentClient.h"
    62 #include "WebDevToolsMessageData.h"
    63 #include "WebDevToolsMessageTransport.h"
    6461#include "WebFrameImpl.h"
    6562#include "WebRect.h"
    … …  
    110107static const char kApuAgentFeatureName[] = "apu-agent";
    111108
    112 class IORPCDelegate : public DevToolsRPC::Delegate, public Noncopyable {
    113 public:
    114     IORPCDelegate() : m_transport(0) { }
    115     explicit IORPCDelegate(WebDevToolsMessageTransport* transport) : m_transport(transport) { }
    116     virtual ~IORPCDelegate() { }
    117     virtual void sendRpcMessage(const WebDevToolsMessageData& data)
    118     {
    119         if (m_transport)
    120             m_transport->sendMessageToFrontendOnIOThread(data);
    121     }
    122 
    123 private:
    124     WebDevToolsMessageTransport* m_transport;
    125 };
    126 
    127109class ClientMessageLoopAdapter : public WebCore::ScriptDebugServer::ClientMessageLoop {
    128110public:
    … …  
    223205    DebuggerAgentManager::setExposeV8DebuggerProtocol(
    224206        client->exposeV8DebuggerProtocol());
    225     m_debuggerAgentDelegateStub.set(new DebuggerAgentDelegateStub(this));
    226     m_toolsAgentDelegateStub.set(new ToolsAgentDelegateStub(this));
    227     m_apuAgentDelegateStub.set(new ApuAgentDelegateStub(this));
    228207}
    229208
    … …  
    252231
    253232    m_debuggerAgentImpl.set(
    254         new DebuggerAgentImpl(m_webViewImpl,
    255                               m_debuggerAgentDelegateStub.get(),
    256                               this));
     233        new DebuggerAgentImpl(m_webViewImpl, this, m_client));
    257234    createInspectorFrontendProxy();
    258235
    … …  
    297274{
    298275    DebuggerAgentManager::setHostId(webframe, m_hostId);
    299     if (m_attached) {
    300         // Push context id into the client if it is already attached.
    301         m_debuggerAgentDelegateStub->setContextId(m_hostId);
    302     }
    303276}
    304277
    … …  
    308281}
    309282
    310 void WebDevToolsAgentImpl::dispatchOnInspectorController(const String& message)
     283void WebDevToolsAgentImpl::dispatchOnInspectorBackend(const WebString& message)
    311284{
    312285    inspectorController()->inspectorBackendDispatcher()->dispatch(message);
    313 }
    314 
    315 void WebDevToolsAgentImpl::dispatchMessageFromFrontend(const WebDevToolsMessageData& data)
    316 {
    317     if (ToolsAgentDispatch::dispatch(this, data))
    318         return;
    319 
    320     if (!m_attached)
    321         return;
    322 
    323     if (m_debuggerAgentImpl.get() && DebuggerAgentDispatch::dispatch(m_debuggerAgentImpl.get(), data))
    324         return;
    325286}
    326287
    … …  
    343304          ic->disableResourceTracking(false /* not sticky */);
    344305    }
    345 }
    346 
    347 void WebDevToolsAgentImpl::sendRpcMessage(const WebDevToolsMessageData& data)
    348 {
    349     m_client->sendMessageToFrontend(data);
    350306}
    351307
    … …  
    429385
    430386    if (!agent->m_apuAgentEnabled) {
    431         agent->m_toolsAgentDelegateStub->dispatchOnClient(message);
     387        agent->m_client->sendMessageToInspectorFrontend(message);
    432388        return v8::Undefined();
    433389    }
    … …  
    437393        return v8::Undefined();
    438394
    439     if (method != "addRecordToTimeline" && method != "updateResource" && method != "addResource")
     395    if (method != "updateResource" && method != "addResource")
    440396        return v8::Undefined();
    441397
    442     agent->m_apuAgentDelegateStub->dispatchToApu(message);
     398    agent->m_client->sendDispatchToAPU(message);
    443399    return v8::Undefined();
    444400}
    … …  
    544500        return false;
    545501
    546     if (devToolsAgent->m_apuAgentEnabled && devToolsAgent->m_apuAgentDelegateStub) {
    547         devToolsAgent->m_apuAgentDelegateStub->dispatchToApu(message);
     502    if (devToolsAgent->m_apuAgentEnabled) {
     503        m_client->sendDispatchToAPU(message);
    548504        return true;
    549505    }
    550506
    551     WebVector<WebString> arguments(size_t(1));
    552     arguments[0] = message;
    553     WebDevToolsMessageData data;
    554     data.className = "ToolsAgentDelegate";
    555     data.methodName = "dispatchOnClient";
    556     data.arguments.swap(arguments);
    557     devToolsAgent->sendRpcMessage(data);
     507    m_client->sendMessageToInspectorFrontend(message);
    558508    return true;
    559509}
    … …  
    609559}
    610560
    611 bool WebDevToolsAgent::dispatchMessageFromFrontendOnIOThread(WebDevToolsMessageTransport* transport, const WebDevToolsMessageData& data)
    612 {
    613     IORPCDelegate delegate(transport);
    614     ProfilerAgentDelegateStub stub(&delegate);
    615     ProfilerAgentImpl agent(&stub);
    616     return ProfilerAgentDispatch::dispatch(&agent, data);
    617 }
    618 
    619561} // namespace WebKit

  • trunk/WebKit/chromium/src/WebDevToolsAgentImpl.h

    r64124 r64534  
    3434#include "InspectorClient.h"
    3535
    36 #include "APUAgentDelegate.h"
    37 #include "DevToolsRPC.h"
    38 #include "ToolsAgent.h"
    3936#include "WebDevToolsAgentPrivate.h"
    4037
    … …  
    5249namespace WebKit {
    5350
    54 class DebuggerAgentDelegateStub;
    5551class DebuggerAgentImpl;
    5652class WebDevToolsAgentClient;
    … …  
    6561
    6662class WebDevToolsAgentImpl : public WebDevToolsAgentPrivate,
    67                              public ToolsAgent,
    68                              public DevToolsRPC::Delegate,
    6963                             public WebCore::InspectorClient {
    7064public:
    7165    WebDevToolsAgentImpl(WebViewImpl* webViewImpl, WebDevToolsAgentClient* client);
    7266    virtual ~WebDevToolsAgentImpl();
    73 
    74     // ToolsAgent implementation.
    75     virtual void dispatchOnInspectorController(const WebCore::String& message);
    7667
    7768    // WebDevToolsAgentPrivate implementation.
    … …  
    8273    virtual void detach();
    8374    virtual void didNavigate();
    84     virtual void dispatchMessageFromFrontend(const WebDevToolsMessageData& data);
     75    virtual void dispatchOnInspectorBackend(const WebString& message);
    8576    virtual void inspectElementAt(const WebPoint& point);
    8677    virtual void evaluateInWebInspector(long callId, const WebString& script);
    … …  
    10899    virtual bool sendMessageToFrontend(const WebCore::String&);
    109100
    110     // DevToolsRPC::Delegate implementation.
    111     virtual void sendRpcMessage(const WebDevToolsMessageData& data);
    112 
    113101    void forceRepaint();
    114102
    … …  
    131119    WebDevToolsAgentClient* m_client;
    132120    WebViewImpl* m_webViewImpl;
    133     OwnPtr<DebuggerAgentDelegateStub> m_debuggerAgentDelegateStub;
    134     OwnPtr<ToolsAgentDelegateStub> m_toolsAgentDelegateStub;
    135121    OwnPtr<DebuggerAgentImpl> m_debuggerAgentImpl;
    136     OwnPtr<ApuAgentDelegateStub> m_apuAgentDelegateStub;
    137122    bool m_apuAgentEnabled;
    138123    bool m_resourceTrackingWasEnabled;

  • trunk/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp

    r63896 r64534  
    3636#include "ContextMenuItem.h"
    3737#include "DOMWindow.h"
    38 #include "DebuggerAgent.h"
    39 #include "DevToolsRPCJS.h"
    4038#include "Document.h"
    4139#include "Event.h"
    … …  
    4947#include "Pasteboard.h"
    5048#include "PlatformString.h"
    51 #include "ProfilerAgent.h"
    5249#include "SecurityOrigin.h"
    5350#include "Settings.h"
    54 #include "ToolsAgent.h"
    5551#include "V8Binding.h"
    5652#include "V8DOMWrapper.h"
    … …  
    7874    return v8::String::New(reinterpret_cast<const uint16_t*>(s.characters()), s.length());
    7975}
    80 
    81 DEFINE_RPC_JS_BOUND_OBJ(DebuggerAgent, DEBUGGER_AGENT_STRUCT, DebuggerAgentDelegate, DEBUGGER_AGENT_DELEGATE_STRUCT)
    82 DEFINE_RPC_JS_BOUND_OBJ(ProfilerAgent, PROFILER_AGENT_STRUCT, ProfilerAgentDelegate, PROFILER_AGENT_DELEGATE_STRUCT)
    83 DEFINE_RPC_JS_BOUND_OBJ(ToolsAgent, TOOLS_AGENT_STRUCT, ToolsAgentDelegate, TOOLS_AGENT_DELEGATE_STRUCT)
    8476
    8577WebDevToolsFrontend* WebDevToolsFrontend::create(
    … …  
    114106    v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame());
    115107
    116     m_debuggerAgentObj.set(new JSDebuggerAgentBoundObj(this, frameContext, "RemoteDebuggerAgent"));
    117     m_profilerAgentObj.set(new JSProfilerAgentBoundObj(this, frameContext, "RemoteProfilerAgent"));
    118     m_toolsAgentObj.set(new JSToolsAgentBoundObj(this, frameContext, "RemoteToolsAgent"));
    119 
    120108    // Debugger commands should be sent using special method.
    121109    BoundObject debuggerCommandExecutorObj(frameContext, this, "RemoteDebuggerCommandExecutor");
    122     debuggerCommandExecutorObj.addProtoFunction(
    123         "DebuggerCommand",
    124         WebDevToolsFrontendImpl::jsDebuggerCommand);
    125110    debuggerCommandExecutorObj.addProtoFunction(
    126111        "DebuggerPauseScript",
    … …  
    133118}
    134119
    135 void WebDevToolsFrontendImpl::dispatchMessageFromAgent(const WebDevToolsMessageData& data)
     120void WebDevToolsFrontendImpl::dispatchOnInspectorFrontend(const WebString& message)
    136121{
    137     Vector<String> v;
    138     v.append(data.className);
    139     v.append(data.methodName);
    140     for (size_t i = 0; i < data.arguments.size(); i++)
    141         v.append(data.arguments[i]);
    142122    if (!m_loaded) {
    143         m_pendingIncomingMessages.append(v);
     123        m_pendingIncomingMessages.append(message);
    144124        return;
    145125    }
    146     executeScript(v);
     126    executeScript(message);
    147127}
    148128
    … …  
    151131    m_loaded = true;
    152132
    153     for (Vector<Vector<String> >::iterator it = m_pendingIncomingMessages.begin();
     133    for (Vector<WebString>::iterator it = m_pendingIncomingMessages.begin();
    154134         it != m_pendingIncomingMessages.end();
    155135         ++it) {
    … …  
    159139}
    160140
    161 void WebDevToolsFrontendImpl::executeScript(const Vector<String>& v)
     141void WebDevToolsFrontendImpl::executeScript(const WebString& message)
    162142{
    163143    WebFrameImpl* frame = m_webViewImpl->mainFrameImpl();
    … …  
    169149    v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction);
    170150    Vector< v8::Handle<v8::Value> > args;
    171     for (size_t i = 0; i < v.size(); i++)
    172         args.append(ToV8String(v.at(i)));
     151    args.append(ToV8String(message));
    173152    v8::TryCatch tryCatch;
    174153    tryCatch.SetVerbose(true);
    175154    function->Call(frameContext->Global(), args.size(), args.data());
    176 }
    177 
    178 void WebDevToolsFrontendImpl::sendRpcMessage(const WebDevToolsMessageData& data)
    179 {
    180     m_client->sendMessageToAgent(data);
    181 }
    182 
    183 v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsDebuggerCommand(const v8::Arguments& args)
    184 {
    185     WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
    186     WebString command = WebCore::toWebCoreStringWithNullCheck(args[0]);
    187     frontend->m_client->sendDebuggerCommandToAgent(command);
    188     return v8::Undefined();
    189155}
    190156

  • trunk/WebKit/chromium/src/WebDevToolsFrontendImpl.h

    r56999 r64534  
    3232#define WebDevToolsFrontendImpl_h
    3333
    34 #include "DevToolsRPC.h"
     34#include "PlatformString.h"
    3535#include "WebDevToolsFrontend.h"
    3636#include <v8.h>
    … …  
    5050namespace WebKit {
    5151
    52 class JSDebuggerAgentBoundObj;
    53 class JSProfilerAgentBoundObj;
    54 class JSToolsAgentBoundObj;
    5552class WebDevToolsClientDelegate;
    5653class WebViewImpl;
    5754struct WebDevToolsMessageData;
    5855
     56using WebCore::String;
     57
    5958class WebDevToolsFrontendImpl : public WebKit::WebDevToolsFrontend
    60                               , public DevToolsRPC::Delegate
    6159                              , public Noncopyable {
    6260public:
    … …  
    6765    virtual ~WebDevToolsFrontendImpl();
    6866
    69     // DevToolsRPC::Delegate implementation.
    70     virtual void sendRpcMessage(const WebKit::WebDevToolsMessageData& data);
    71 
    7267    // WebDevToolsFrontend implementation.
    73     virtual void dispatchMessageFromAgent(const WebKit::WebDevToolsMessageData& data);
     68    virtual void dispatchOnInspectorFrontend(const WebString& message);
    7469
    7570    void frontendLoaded();
    7671
    7772private:
    78     void executeScript(const Vector<String>& v);
     73    void executeScript(const WebString& message);
    7974
    80     static v8::Handle<v8::Value> jsDebuggerCommand(const v8::Arguments& args);
    8175    static v8::Handle<v8::Value> jsDebuggerPauseScript(const v8::Arguments& args);
    8276
    … …  
    8478    WebKit::WebDevToolsFrontendClient* m_client;
    8579    String m_applicationLocale;
    86     OwnPtr<JSDebuggerAgentBoundObj> m_debuggerAgentObj;
    87     OwnPtr<JSProfilerAgentBoundObj> m_profilerAgentObj;
    88     OwnPtr<JSToolsAgentBoundObj> m_toolsAgentObj;
    8980    bool m_loaded;
    90     Vector<Vector<String> > m_pendingIncomingMessages;
     81    Vector<WebString> m_pendingIncomingMessages;
    9182};
    9283

  • trunk/WebKit/chromium/src/js/DevTools.js

    r64265 r64534  
    4242 * @param {string} param1, param2, param3 Arguments to dispatch.
    4343 */
    44 devtools$$dispatch = function(remoteName, methodName, param1, param2, param3)
    45 {
    46     remoteName = "Remote" + remoteName.substring(0, remoteName.length - 8);
    47     var agent = window[remoteName];
    48     if (!agent) {
    49         debugPrint("No remote agent '" + remoteName + "' found.");
    50         return;
    51     }
    52     var method = agent[methodName];
    53     if (!method) {
    54         debugPrint("No method '" + remoteName + "." + methodName + "' found.");
    55         return;
    56     }
    57     method.call(this, param1, param2, param3);
    58 };
    59 
    60 
    61 devtools.ToolsAgent = function()
    62 {
    63     RemoteToolsAgent.didDispatchOn = WebInspector.Callback.processCallback;
    64     RemoteToolsAgent.dispatchOnClient = this.dispatchOnClient_.bind(this);
    65     this.profilerAgent_ = new devtools.ProfilerAgent();
    66 };
    67 
    68 
    69 /**
    70  * @param {string} script Script exression to be evaluated in the context of the
    71  *     inspected page.
    72  * @param {function(Object|string, boolean):undefined} opt_callback Function to
    73  *     call with the result.
    74  */
    75 devtools.ToolsAgent.prototype.evaluateJavaScript = function(script, opt_callback)
    76 {
    77     InspectorBackend.evaluate(script, opt_callback || function() {});
    78 };
    79 
    80 
    81 /**
    82  * @return {devtools.ProfilerAgent} Profiler agent instance.
    83  */
    84 devtools.ToolsAgent.prototype.getProfilerAgent = function()
    85 {
    86     return this.profilerAgent_;
    87 };
    88 
    89 
    90 /**
    91  * @param {string} message Serialized call to be dispatched on WebInspector.
    92  * @private
    93  */
    94 devtools.ToolsAgent.prototype.dispatchOnClient_ = function(message)
     44devtools$$dispatch = function(message)
    9545{
    9646    var args = typeof message === "string" ? JSON.parse(message) : message;
    … …  
    10151
    10252
    103 /**
    104  * Evaluates js expression.
    105  * @param {string} expr
    106  */
    107 devtools.ToolsAgent.prototype.evaluate = function(expr)
    108 {
    109     RemoteToolsAgent.evaluate(expr);
    110 };
    111 
    112 
    113 /**
    114  * Prints string  to the inspector console or shows alert if the console doesn't
    115  * exist.
    116  * @param {string} text
    117  */
    118 function debugPrint(text) {
    119     WebInspector.log(text);
    120 }
     53devtools.ToolsAgent = function()
     54{
     55    this.profilerAgent_ = new devtools.ProfilerAgent();
     56};
     57
     58
     59/**
     60 * @return {devtools.ProfilerAgent} Profiler agent instance.
     61 */
     62devtools.ToolsAgent.prototype.getProfilerAgent = function()
     63{
     64    return this.profilerAgent_;
     65};
     66
    12167
    12268

  • trunk/WebKit/chromium/src/js/DevToolsHostStub.js

    r63965 r64534  
    3636if (!window["RemoteDebuggerCommandExecutor"]) {
    3737    window["RemoteDebuggerCommandExecutor"] = {};
    38     window["RemoteProfilerAgent"] = {};
    39     window["RemoteToolsAgent"] = {
    40         dispatchOnInspectorController: function() {}
    41     };
    4238}

  • trunk/WebKit/chromium/src/js/ProfilerAgent.js

    r61411 r64534  
    3838devtools.ProfilerAgent = function()
    3939{
    40     RemoteProfilerAgent.didGetActiveProfilerModules = this._didGetActiveProfilerModules.bind(this);
    41     RemoteProfilerAgent.didGetLogLines = this._didGetLogLines.bind(this);
    4240
    4341    /**
    … …  
    9391        return;
    9492    var pos = this._lastRequestedLogPosition = this._logPosition;
     93
     94    var callId = WebInspector.Callback.wrap(this._didGetProfilerLogLines.bind(this));
    9595    if (immediately)
    96         RemoteProfilerAgent.getLogLines(pos);
    97     else
    98         setTimeout(function() { RemoteProfilerAgent.getLogLines(pos); }, 500);
     96        InspectorBackend.getProfilerLogLines(callId, pos);
     97    else {
     98        function delayedRequest()
     99        {
     100            InspectorBackend.getProfilerLogLines(callId, pos);
     101        }
     102        setTimeout(delayedRequest, 500);
     103    }
    99104};
    100105
    … …  
    115120
    116121/**
    117  * Handles current profiler status.
    118  * @param {number} modules List of active (started) modules.
    119  */
    120 devtools.ProfilerAgent.prototype._didGetActiveProfilerModules = function(modules)
    121 {
    122 };
    123 
    124 
    125 /**
    126122 * Handles a portion of a profiler log retrieved by getLogLines call.
    127123 * @param {number} pos Current position in log.
    128124 * @param {string} log A portion of profiler log.
    129125 */
    130 devtools.ProfilerAgent.prototype._didGetLogLines = function(pos, log)
     126devtools.ProfilerAgent.prototype._didGetProfilerLogLines = function(pos, log)
    131127{
    132128    this._logPosition = pos;
    … …  
    139135    }
    140136};
     137
     138WebInspector.didGetProfilerLogLines = WebInspector.Callback.processCallback;

  • trunk/WebKit/chromium/src/js/ProfilerProcessor.js

    r54547 r64534  
    282282devtools.profiler.Processor.prototype.printError = function(str)
    283283{
    284     debugPrint(str);
     284    WebInspector.log(str);
    285285};
    286286

  • trunk/WebKitTools/ChangeLog

    r64530 r64534  
     12010-08-02  Pavel Feldman  <pfeldman@chromium.org>
     2
     3        Reviewed by Yury Semikhatsky.
     4
     5        Chromium DevTools: Get rid of DevTools RPC.
     6
     7        https://bugs.webkit.org/show_bug.cgi?id=43335
     8
     9        * DumpRenderTree/chromium/DRTDevToolsAgent.cpp:
     10        (DRTDevToolsAgent::sendMessageToInspectorFrontend):
     11        (DRTDevToolsAgent::call):
     12        * DumpRenderTree/chromium/DRTDevToolsAgent.h:
     13        * DumpRenderTree/chromium/DRTDevToolsCallArgs.h:
     14        (DRTDevToolsCallArgs::DRTDevToolsCallArgs):
     15        * DumpRenderTree/chromium/DRTDevToolsClient.cpp:
     16        (DRTDevToolsClient::sendMessageToBackend):
     17        (DRTDevToolsClient::call):
     18        * DumpRenderTree/chromium/DRTDevToolsClient.h:
     19
    1202010-08-02  Kent Tamura  <tkent@chromium.org>
    221

  • trunk/WebKitTools/DumpRenderTree/chromium/DRTDevToolsAgent.cpp

    r62545 r64534  
    3737#include "public/WebCString.h"
    3838#include "public/WebDevToolsAgent.h"
    39 #include "public/WebDevToolsMessageData.h"
    4039#include "public/WebString.h"
    4140#include "public/WebView.h"
    … …  
    6160}
    6261
    63 void DRTDevToolsAgent::sendMessageToFrontend(const WebDevToolsMessageData& data)
     62void DRTDevToolsAgent::sendMessageToInspectorFrontend(const WebKit::WebString& data)
    6463{
    6564    if (m_drtDevToolsClient)
    … …  
    101100    WebDevToolsAgent* agent = webDevToolsAgent();
    102101    if (agent)
    103         agent->dispatchMessageFromFrontend(args.m_data);
     102        agent->dispatchOnInspectorBackend(args.m_data);
    104103    if (DRTDevToolsCallArgs::callsCount() == 1 && m_drtDevToolsClient)
    105104        m_drtDevToolsClient->allMessagesProcessed();

  • trunk/WebKitTools/DumpRenderTree/chromium/DRTDevToolsAgent.h

    r62545 r64534  
    5757
    5858    // WebDevToolsAgentClient implementation.
    59     virtual void sendMessageToFrontend(const WebKit::WebDevToolsMessageData&);
     59    virtual void sendMessageToInspectorFrontend(const WebKit::WebString&);
    6060    virtual int hostIdentifier() { return m_routingID; }
    6161    virtual void forceRepaint();

  • trunk/WebKitTools/DumpRenderTree/chromium/DRTDevToolsCallArgs.h

    r62545 r64534  
    3232#define DRTDevToolsCallArgs_h
    3333
    34 #include "public/WebDevToolsMessageData.h"
    3534#include "public/WebString.h"
    3635#include <wtf/Assertions.h>
    … …  
    3837class DRTDevToolsCallArgs {
    3938public:
    40     DRTDevToolsCallArgs(const WebKit::WebDevToolsMessageData& data)
     39    DRTDevToolsCallArgs(const WebKit::WebString& data)
    4140        : m_data(data)
    4241    {
    4342        ++m_callsCount;
    44 
    45         // The same behaviour as we have in case of IPC.
    46         for (size_t i = 0; i < m_data.arguments.size(); ++i) {
    47             if (m_data.arguments[i].isNull())
    48                 m_data.arguments[i] = WebKit::WebString::fromUTF8("");
    49         }
    5043    }
    5144
    … …  
    6457    static int callsCount() { return m_callsCount; }
    6558
    66     WebKit::WebDevToolsMessageData m_data;
     59    WebKit::WebString m_data;
    6760
    6861private:

  • trunk/WebKitTools/DumpRenderTree/chromium/DRTDevToolsClient.cpp

    r62740 r64534  
    6565}
    6666
    67 void DRTDevToolsClient::sendMessageToAgent(const WebDevToolsMessageData& data)
     67void DRTDevToolsClient::sendMessageToBackend(const WebString& data)
    6868{
    6969    if (m_drtDevToolsAgent)
    … …  
    104104void DRTDevToolsClient::call(const DRTDevToolsCallArgs& args)
    105105{
    106     m_webDevToolsFrontend->dispatchMessageFromAgent(args.m_data);
     106    m_webDevToolsFrontend->dispatchOnInspectorFrontend(args.m_data);
    107107    if (DRTDevToolsCallArgs::callsCount() == 1)
    108108        allMessagesProcessed();

  • trunk/WebKitTools/DumpRenderTree/chromium/DRTDevToolsClient.h

    r62545 r64534  
    5656
    5757    // WebDevToolsFrontendClient implementation
    58     virtual void sendMessageToAgent(const WebKit::WebDevToolsMessageData&);
     58    virtual void sendMessageToBackend(const WebKit::WebString&);
    5959    virtual void sendDebuggerCommandToAgent(const WebKit::WebString& command);
    6060
Note: See TracChangeset for help on using the changeset viewer.