src/third_party/WebKit/Source/web/WebDevToolsAgentImpl.cpp

   1 /*
   2  * Copyright (C) 2010-2011 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "WebDevToolsAgentImpl.h"
  33
  34 #include "InspectorBackendDispatcher.h"
  35 #include "InspectorFrontend.h"
  36 #include "InspectorProtocolVersion.h"
  37 #include "RuntimeEnabledFeatures.h"
  38 #include "WebDataSource.h"
  39 #include "WebDevToolsAgentClient.h"
  40 #include "WebFrameImpl.h"
  41 #include "WebInputEventConversion.h"
  42 #include "WebMemoryUsageInfo.h"
  43 #include "WebSettings.h"
  44 #include "WebViewClient.h"
  45 #include "WebViewImpl.h"
  46 #include "bindings/v8/PageScriptDebugServer.h"
  47 #include "bindings/v8/ScriptController.h"
  48 #include "bindings/v8/V8Binding.h"
  49 #include "bindings/v8/V8Utilities.h"
  50 #include "core/dom/ExceptionCode.h"
  51 #include "core/fetch/MemoryCache.h"
  52 #include "core/frame/Frame.h"
  53 #include "core/frame/FrameView.h"
  54 #include "core/inspector/InjectedScriptHost.h"
  55 #include "core/inspector/InspectorController.h"
  56 #include "core/page/Page.h"
  57 #include "core/page/PageGroup.h"
  58 #include "core/rendering/RenderView.h"
  59 #include "platform/JSONValues.h"
  60 #include "platform/graphics/GraphicsContext.h"
  61 #include "platform/network/ResourceError.h"
  62 #include "platform/network/ResourceRequest.h"
  63 #include "platform/network/ResourceResponse.h"
  64 #include "public/platform/Platform.h"
  65 #include "public/platform/WebRect.h"
  66 #include "public/platform/WebString.h"
  67 #include "public/platform/WebURL.h"
  68 #include "public/platform/WebURLError.h"
  69 #include "public/platform/WebURLRequest.h"
  70 #include "public/platform/WebURLResponse.h"
  71 #include "wtf/CurrentTime.h"
  72 #include "wtf/MathExtras.h"
  73 #include "wtf/Noncopyable.h"
  74 #include "wtf/text/WTFString.h"
  75
  76 using namespace WebCore;
  77 using namespace std;
  78
  79 namespace OverlayZOrders {
  80 // Use 99 as a big z-order number so that highlight is above other overlays.
  81 static const int highlight = 99;
  82 }
  83
  84 namespace blink {
  85
  86 class ClientMessageLoopAdapter : public PageScriptDebugServer::ClientMessageLoop {
  87 public:
  88     static void ensureClientMessageLoopCreated(WebDevToolsAgentClient* client)
  89     {
  90         if (s_instance)
  91             return;
  92         OwnPtr<ClientMessageLoopAdapter> instance = adoptPtr(new ClientMessageLoopAdapter(adoptPtr(client->createClientMessageLoop())));
  93         s_instance = instance.get();
  94         PageScriptDebugServer::shared().setClientMessageLoop(instance.release());
  95     }
  96
  97     static void inspectedViewClosed(WebViewImpl* view)
  98     {
  99         if (s_instance)
 100             s_instance->m_frozenViews.remove(view);
 101     }
 102
 103     static void didNavigate()
 104     {
 105         // Release render thread if necessary.
 106         if (s_instance && s_instance->m_running)
 107             PageScriptDebugServer::shared().continueProgram();
 108     }
 109
 110 private:
 111     ClientMessageLoopAdapter(PassOwnPtr<blink::WebDevToolsAgentClient::WebKitClientMessageLoop> messageLoop)
 112         : m_running(false)
 113         , m_messageLoop(messageLoop) { }
 114
 115
 116     virtual void run(Page* page)
 117     {
 118         if (m_running)
 119             return;
 120         m_running = true;
 121
 122         Vector<WebViewImpl*> views;
 123
 124         // 1. Disable input events.
 125         HashSet<Page*>::const_iterator end =  page->group().pages().end();
 126         for (HashSet<Page*>::const_iterator it =  page->group().pages().begin(); it != end; ++it) {
 127             WebViewImpl* view = WebViewImpl::fromPage(*it);
 128             if (!view)
 129                 continue;
 130             m_frozenViews.add(view);
 131             views.append(view);
 132             view->setIgnoreInputEvents(true);
 133         }
 134
 135         // 2. Disable active objects
 136         WebView::willEnterModalLoop();
 137
 138         // 3. Process messages until quitNow is called.
 139         m_messageLoop->run();
 140
 141         // 4. Resume active objects
 142         WebView::didExitModalLoop();
 143
 144         // 5. Resume input events.
 145         for (Vector<WebViewImpl*>::iterator it = views.begin(); it != views.end(); ++it) {
 146             if (m_frozenViews.contains(*it)) {
 147                 // The view was not closed during the dispatch.
 148                 (*it)->setIgnoreInputEvents(false);
 149             }
 150         }
 151
 152         // 6. All views have been resumed, clear the set.
 153         m_frozenViews.clear();
 154
 155         m_running = false;
 156     }
 157
 158     virtual void quitNow()
 159     {
 160         m_messageLoop->quitNow();
 161     }
 162
 163     bool m_running;
 164     OwnPtr<blink::WebDevToolsAgentClient::WebKitClientMessageLoop> m_messageLoop;
 165     typedef HashSet<WebViewImpl*> FrozenViewsSet;
 166     FrozenViewsSet m_frozenViews;
 167     // FIXME: The ownership model for s_instance is somewhat complicated. Can we make this simpler?
 168     static ClientMessageLoopAdapter* s_instance;
 169 };
 170
 171 ClientMessageLoopAdapter* ClientMessageLoopAdapter::s_instance = 0;
 172
 173 class DebuggerTask : public PageScriptDebugServer::Task {
 174 public:
 175     DebuggerTask(PassOwnPtr<WebDevToolsAgent::MessageDescriptor> descriptor)
 176         : m_descriptor(descriptor)
 177     {
 178     }
 179
 180     virtual ~DebuggerTask() { }
 181     virtual void run()
 182     {
 183         if (WebDevToolsAgent* webagent = m_descriptor->agent())
 184             webagent->dispatchOnInspectorBackend(m_descriptor->message());
 185     }
 186
 187 private:
 188     OwnPtr<WebDevToolsAgent::MessageDescriptor> m_descriptor;
 189 };
 190
 191 WebDevToolsAgentImpl::WebDevToolsAgentImpl(
 192     WebViewImpl* webViewImpl,
 193     WebDevToolsAgentClient* client)
 194     : m_hostId(client->hostIdentifier())
 195     , m_client(client)
 196     , m_webViewImpl(webViewImpl)
 197     , m_attached(false)
 198     , m_generatingEvent(false)
 199     , m_deviceMetricsEnabled(false)
 200     , m_emulateViewportEnabled(false)
 201     , m_originalViewportEnabled(false)
 202     , m_isOverlayScrollbarsEnabled(false)
 203 {
 204     ASSERT(m_hostId > 0);
 205     ClientMessageLoopAdapter::ensureClientMessageLoopCreated(m_client);
 206 }
 207
 208 WebDevToolsAgentImpl::~WebDevToolsAgentImpl()
 209 {
 210     ClientMessageLoopAdapter::inspectedViewClosed(m_webViewImpl);
 211     if (m_attached)
 212         blink::Platform::current()->currentThread()->removeTaskObserver(this);
 213 }
 214
 215 void WebDevToolsAgentImpl::attach()
 216 {
 217     if (m_attached)
 218         return;
 219
 220     inspectorController()->connectFrontend(this);
 221     inspectorController()->webViewResized(m_webViewImpl->size());
 222     blink::Platform::current()->currentThread()->addTaskObserver(this);
 223     m_attached = true;
 224 }
 225
 226 void WebDevToolsAgentImpl::reattach(const WebString& savedState)
 227 {
 228     if (m_attached)
 229         return;
 230
 231     inspectorController()->reuseFrontend(this, savedState);
 232     blink::Platform::current()->currentThread()->addTaskObserver(this);
 233     m_attached = true;
 234 }
 235
 236 void WebDevToolsAgentImpl::detach()
 237 {
 238     blink::Platform::current()->currentThread()->removeTaskObserver(this);
 239
 240     // Prevent controller from sending messages to the frontend.
 241     InspectorController* ic = inspectorController();
 242     ic->disconnectFrontend();
 243     ic->hideHighlight();
 244     m_attached = false;
 245 }
 246
 247 void WebDevToolsAgentImpl::didNavigate()
 248 {
 249     ClientMessageLoopAdapter::didNavigate();
 250 }
 251
 252 void WebDevToolsAgentImpl::didBeginFrame(int frameId)
 253 {
 254     if (InspectorController* ic = inspectorController())
 255         ic->didBeginFrame(frameId);
 256 }
 257
 258 void WebDevToolsAgentImpl::didCancelFrame()
 259 {
 260     if (InspectorController* ic = inspectorController())
 261         ic->didCancelFrame();
 262 }
 263
 264 void WebDevToolsAgentImpl::willComposite()
 265 {
 266     if (InspectorController* ic = inspectorController())
 267         ic->willComposite();
 268 }
 269
 270 void WebDevToolsAgentImpl::didComposite()
 271 {
 272     if (InspectorController* ic = inspectorController())
 273         ic->didComposite();
 274 }
 275
 276 void WebDevToolsAgentImpl::didCreateScriptContext(WebFrameImpl* webframe, int worldId)
 277 {
 278     // Skip non main world contexts.
 279     if (worldId)
 280         return;
 281     if (WebCore::Frame* frame = webframe->frame())
 282         frame->script().setContextDebugId(m_hostId);
 283 }
 284
 285 void WebDevToolsAgentImpl::webViewResized(const WebSize& size)
 286 {
 287     if (InspectorController* ic = inspectorController())
 288         ic->webViewResized(IntSize());
 289 }
 290
 291 bool WebDevToolsAgentImpl::handleInputEvent(WebCore::Page* page, const WebInputEvent& inputEvent)
 292 {
 293     if (!m_attached && !m_generatingEvent)
 294         return false;
 295
 296     InspectorController* ic = inspectorController();
 297     if (!ic)
 298         return false;
 299
 300     if (WebInputEvent::isGestureEventType(inputEvent.type) && inputEvent.type == WebInputEvent::GestureTap) {
 301         // Only let GestureTab in (we only need it and we know PlatformGestureEventBuilder supports it).
 302         PlatformGestureEvent gestureEvent = PlatformGestureEventBuilder(page->mainFrame()->view(), *static_cast<const WebGestureEvent*>(&inputEvent));
 303         return ic->handleGestureEvent(page->mainFrame(), gestureEvent);
 304     }
 305     if (WebInputEvent::isMouseEventType(inputEvent.type) && inputEvent.type != WebInputEvent::MouseEnter) {
 306         // PlatformMouseEventBuilder does not work with MouseEnter type, so we filter it out manually.
 307         PlatformMouseEvent mouseEvent = PlatformMouseEventBuilder(page->mainFrame()->view(), *static_cast<const WebMouseEvent*>(&inputEvent));
 308         return ic->handleMouseEvent(page->mainFrame(), mouseEvent);
 309     }
 310     if (WebInputEvent::isTouchEventType(inputEvent.type)) {
 311         PlatformTouchEvent touchEvent = PlatformTouchEventBuilder(page->mainFrame()->view(), *static_cast<const WebTouchEvent*>(&inputEvent));
 312         return ic->handleTouchEvent(page->mainFrame(), touchEvent);
 313     }
 314     if (WebInputEvent::isKeyboardEventType(inputEvent.type)) {
 315         PlatformKeyboardEvent keyboardEvent = PlatformKeyboardEventBuilder(*static_cast<const WebKeyboardEvent*>(&inputEvent));
 316         return ic->handleKeyboardEvent(page->mainFrame(), keyboardEvent);
 317     }
 318     return false;
 319 }
 320
 321 void WebDevToolsAgentImpl::overrideDeviceMetrics(int width, int height, float deviceScaleFactor, bool emulateViewport, bool fitWindow)
 322 {
 323     if (!width && !height) {
 324         if (m_deviceMetricsEnabled) {
 325             m_deviceMetricsEnabled = false;
 326             m_webViewImpl->setBackgroundColorOverride(Color::transparent);
 327             RuntimeEnabledFeatures::setOverlayScrollbarsEnabled(m_isOverlayScrollbarsEnabled);
 328             disableViewportEmulation();
 329             m_client->disableDeviceEmulation();
 330         }
 331     } else {
 332         if (!m_deviceMetricsEnabled) {
 333             m_deviceMetricsEnabled = true;
 334             m_webViewImpl->setBackgroundColorOverride(Color::darkGray);
 335             m_isOverlayScrollbarsEnabled = RuntimeEnabledFeatures::overlayScrollbarsEnabled();
 336             RuntimeEnabledFeatures::setOverlayScrollbarsEnabled(true);
 337         }
 338         if (emulateViewport)
 339             enableViewportEmulation();
 340         else
 341             disableViewportEmulation();
 342         m_client->enableDeviceEmulation(IntRect(10, 10, width, height), IntRect(0, 0, width, height), deviceScaleFactor, fitWindow);
 343     }
 344 }
 345
 346 void WebDevToolsAgentImpl::enableViewportEmulation()
 347 {
 348     if (m_emulateViewportEnabled)
 349         return;
 350     m_emulateViewportEnabled = true;
 351     m_originalViewportEnabled = RuntimeEnabledFeatures::cssViewportEnabled();
 352     RuntimeEnabledFeatures::setCSSViewportEnabled(true);
 353     m_webViewImpl->settings()->setViewportEnabled(true);
 354     m_webViewImpl->settings()->setViewportMetaEnabled(true);
 355     m_webViewImpl->setIgnoreViewportTagScaleLimits(true);
 356     m_webViewImpl->setPageScaleFactorLimits(-1, -1);
 357     m_webViewImpl->setZoomFactorOverride(1);
 358 }
 359
 360 void WebDevToolsAgentImpl::disableViewportEmulation()
 361 {
 362     if (!m_emulateViewportEnabled)
 363         return;
 364     RuntimeEnabledFeatures::setCSSViewportEnabled(m_originalViewportEnabled);
 365     m_webViewImpl->settings()->setViewportEnabled(false);
 366     m_webViewImpl->settings()->setViewportMetaEnabled(false);
 367     m_webViewImpl->setIgnoreViewportTagScaleLimits(false);
 368     m_webViewImpl->setPageScaleFactorLimits(1, 1);
 369     m_webViewImpl->setZoomFactorOverride(0);
 370     m_emulateViewportEnabled = false;
 371 }
 372
 373 void WebDevToolsAgentImpl::getAllocatedObjects(HashSet<const void*>& set)
 374 {
 375     class CountingVisitor : public WebDevToolsAgentClient::AllocatedObjectVisitor {
 376     public:
 377         CountingVisitor() : m_totalObjectsCount(0)
 378         {
 379         }
 380
 381         virtual bool visitObject(const void* ptr)
 382         {
 383             ++m_totalObjectsCount;
 384             return true;
 385         }
 386         size_t totalObjectsCount() const
 387         {
 388             return m_totalObjectsCount;
 389         }
 390
 391     private:
 392         size_t m_totalObjectsCount;
 393     };
 394
 395     CountingVisitor counter;
 396     m_client->visitAllocatedObjects(&counter);
 397
 398     class PointerCollector : public WebDevToolsAgentClient::AllocatedObjectVisitor {
 399     public:
 400         explicit PointerCollector(size_t maxObjectsCount)
 401             : m_maxObjectsCount(maxObjectsCount)
 402             , m_index(0)
 403             , m_success(true)
 404             , m_pointers(new const void*[maxObjectsCount])
 405         {
 406         }
 407         virtual ~PointerCollector()
 408         {
 409             delete[] m_pointers;
 410         }
 411         virtual bool visitObject(const void* ptr)
 412         {
 413             if (m_index == m_maxObjectsCount) {
 414                 m_success = false;
 415                 return false;
 416             }
 417             m_pointers[m_index++] = ptr;
 418             return true;
 419         }
 420
 421         bool success() const { return m_success; }
 422
 423         void copyTo(HashSet<const void*>& set)
 424         {
 425             for (size_t i = 0; i < m_index; i++)
 426                 set.add(m_pointers[i]);
 427         }
 428
 429     private:
 430         const size_t m_maxObjectsCount;
 431         size_t m_index;
 432         bool m_success;
 433         const void** m_pointers;
 434     };
 435
 436     // Double size to allow room for all objects that may have been allocated
 437     // since we counted them.
 438     size_t estimatedMaxObjectsCount = counter.totalObjectsCount() * 2;
 439     while (true) {
 440         PointerCollector collector(estimatedMaxObjectsCount);
 441         m_client->visitAllocatedObjects(&collector);
 442         if (collector.success()) {
 443             collector.copyTo(set);
 444             break;
 445         }
 446         estimatedMaxObjectsCount *= 2;
 447     }
 448 }
 449
 450 void WebDevToolsAgentImpl::dumpUncountedAllocatedObjects(const HashMap<const void*, size_t>& map)
 451 {
 452     class InstrumentedObjectSizeProvider : public WebDevToolsAgentClient::InstrumentedObjectSizeProvider {
 453     public:
 454         InstrumentedObjectSizeProvider(const HashMap<const void*, size_t>& map) : m_map(map) { }
 455         virtual size_t objectSize(const void* ptr) const
 456         {
 457             HashMap<const void*, size_t>::const_iterator i = m_map.find(ptr);
 458             return i == m_map.end() ? 0 : i->value;
 459         }
 460
 461     private:
 462         const HashMap<const void*, size_t>& m_map;
 463     };
 464
 465     InstrumentedObjectSizeProvider provider(map);
 466     m_client->dumpUncountedAllocatedObjects(&provider);
 467 }
 468
 469 void WebDevToolsAgentImpl::setTraceEventCallback(TraceEventCallback callback)
 470 {
 471     m_client->setTraceEventCallback(callback);
 472 }
 473
 474 void WebDevToolsAgentImpl::startGPUEventsRecording()
 475 {
 476     m_client->startGPUEventsRecording();
 477 }
 478
 479 void WebDevToolsAgentImpl::stopGPUEventsRecording()
 480 {
 481     m_client->stopGPUEventsRecording();
 482 }
 483
 484 void WebDevToolsAgentImpl::processGPUEvent(double timestamp, int phase, bool foreign)
 485 {
 486     if (InspectorController* ic = inspectorController())
 487         ic->processGPUEvent(timestamp, phase, foreign, 0);
 488 }
 489
 490 void WebDevToolsAgentImpl::processGPUEvent(const GPUEvent& event)
 491 {
 492     if (InspectorController* ic = inspectorController())
 493         ic->processGPUEvent(event.timestamp, event.phase, event.foreign, event.usedGPUMemoryBytes);
 494 }
 495
 496 void WebDevToolsAgentImpl::dispatchKeyEvent(const PlatformKeyboardEvent& event)
 497 {
 498     m_generatingEvent = true;
 499     WebKeyboardEvent webEvent = WebKeyboardEventBuilder(event);
 500     if (!webEvent.keyIdentifier[0] && webEvent.type != WebInputEvent::Char)
 501         webEvent.setKeyIdentifierFromWindowsKeyCode();
 502     m_webViewImpl->handleInputEvent(webEvent);
 503     m_generatingEvent = false;
 504 }
 505
 506 void WebDevToolsAgentImpl::dispatchMouseEvent(const PlatformMouseEvent& event)
 507 {
 508     m_generatingEvent = true;
 509     WebMouseEvent webEvent = WebMouseEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), event);
 510     m_webViewImpl->handleInputEvent(webEvent);
 511     m_generatingEvent = false;
 512 }
 513
 514 void WebDevToolsAgentImpl::dispatchOnInspectorBackend(const WebString& message)
 515 {
 516     inspectorController()->dispatchMessageFromFrontend(message);
 517 }
 518
 519 void WebDevToolsAgentImpl::inspectElementAt(const WebPoint& point)
 520 {
 521     m_webViewImpl->inspectElementAt(point);
 522 }
 523
 524 InspectorController* WebDevToolsAgentImpl::inspectorController()
 525 {
 526     if (Page* page = m_webViewImpl->page())
 527         return &page->inspectorController();
 528     return 0;
 529 }
 530
 531 Frame* WebDevToolsAgentImpl::mainFrame()
 532 {
 533     if (Page* page = m_webViewImpl->page())
 534         return page->mainFrame();
 535     return 0;
 536 }
 537
 538 // WebPageOverlay
 539 void WebDevToolsAgentImpl::paintPageOverlay(WebCanvas* canvas)
 540 {
 541     InspectorController* ic = inspectorController();
 542     if (ic) {
 543         GraphicsContext context(canvas);
 544         context.setCertainlyOpaque(false);
 545         ic->drawHighlight(context);
 546     }
 547 }
 548
 549 void WebDevToolsAgentImpl::highlight()
 550 {
 551     m_webViewImpl->addPageOverlay(this, OverlayZOrders::highlight);
 552 }
 553
 554 void WebDevToolsAgentImpl::hideHighlight()
 555 {
 556     m_webViewImpl->removePageOverlay(this);
 557 }
 558
 559 bool WebDevToolsAgentImpl::sendMessageToFrontend(const String& message)
 560 {
 561     WebDevToolsAgentImpl* devToolsAgent = static_cast<WebDevToolsAgentImpl*>(m_webViewImpl->devToolsAgent());
 562     if (!devToolsAgent)
 563         return false;
 564     m_client->sendMessageToInspectorFrontend(message);
 565     return true;
 566 }
 567
 568 void WebDevToolsAgentImpl::updateInspectorStateCookie(const String& state)
 569 {
 570     m_client->saveAgentRuntimeState(state);
 571 }
 572
 573 void WebDevToolsAgentImpl::clearBrowserCache()
 574 {
 575     m_client->clearBrowserCache();
 576 }
 577
 578 void WebDevToolsAgentImpl::clearBrowserCookies()
 579 {
 580     m_client->clearBrowserCookies();
 581 }
 582
 583 void WebDevToolsAgentImpl::setProcessId(long processId)
 584 {
 585     inspectorController()->setProcessId(processId);
 586 }
 587
 588 void WebDevToolsAgentImpl::setLayerTreeId(int layerTreeId)
 589 {
 590     inspectorController()->setLayerTreeId(layerTreeId);
 591 }
 592
 593 void WebDevToolsAgentImpl::evaluateInWebInspector(long callId, const WebString& script)
 594 {
 595     InspectorController* ic = inspectorController();
 596     ic->evaluateForTestInFrontend(callId, script);
 597 }
 598
 599 void WebDevToolsAgentImpl::willProcessTask()
 600 {
 601     if (InspectorController* ic = inspectorController())
 602         ic->willProcessTask();
 603 }
 604
 605 void WebDevToolsAgentImpl::didProcessTask()
 606 {
 607     if (InspectorController* ic = inspectorController())
 608         ic->didProcessTask();
 609 }
 610
 611 WebString WebDevToolsAgent::inspectorProtocolVersion()
 612 {
 613     return WebCore::inspectorProtocolVersion();
 614 }
 615
 616 bool WebDevToolsAgent::supportsInspectorProtocolVersion(const WebString& version)
 617 {
 618     return WebCore::supportsInspectorProtocolVersion(version);
 619 }
 620
 621 void WebDevToolsAgent::interruptAndDispatch(MessageDescriptor* rawDescriptor)
 622 {
 623     // rawDescriptor can't be a PassOwnPtr because interruptAndDispatch is a WebKit API function.
 624     OwnPtr<MessageDescriptor> descriptor = adoptPtr(rawDescriptor);
 625     OwnPtr<DebuggerTask> task = adoptPtr(new DebuggerTask(descriptor.release()));
 626     PageScriptDebugServer::interruptAndRun(task.release(), v8::Isolate::GetCurrent());
 627 }
 628
 629 bool WebDevToolsAgent::shouldInterruptForMessage(const WebString& message)
 630 {
 631     String commandName;
 632     if (!InspectorBackendDispatcher::getCommandName(message, &commandName))
 633         return false;
 634     return commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_pauseCmd)
 635         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_setBreakpointCmd)
 636         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_setBreakpointByUrlCmd)
 637         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_removeBreakpointCmd)
 638         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_setBreakpointsActiveCmd)
 639         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kProfiler_startCmd)
 640         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kProfiler_stopCmd);
 641 }
 642
 643 void WebDevToolsAgent::processPendingMessages()
 644 {
 645     PageScriptDebugServer::shared().runPendingTasks();
 646 }
 647
 648 } // namespace blink