WebCore/inspector/InspectorController.cpp

   1 /*
   2  * Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
   3  * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.com>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "config.h"
  31 #include "InspectorController.h"
  32
  33 #if ENABLE(INSPECTOR)
  34
  35 #include "CString.h"
  36 #include "CachedResource.h"
  37 #include "Console.h"
  38 #include "ConsoleMessage.h"
  39 #include "Cookie.h"
  40 #include "CookieJar.h"
  41 #include "Document.h"
  42 #include "DocumentLoader.h"
  43 #include "DOMWindow.h"
  44 #include "Element.h"
  45 #include "FloatConversion.h"
  46 #include "FloatQuad.h"
  47 #include "FloatRect.h"
  48 #include "Frame.h"
  49 #include "FrameLoader.h"
  50 #include "FrameTree.h"
  51 #include "FrameView.h"
  52 #include "GraphicsContext.h"
  53 #include "HTMLFrameOwnerElement.h"
  54 #include "HitTestResult.h"
  55 #include "InspectorBackend.h"
  56 #include "InjectedScriptHost.h"
  57 #include "InspectorClient.h"
  58 #include "InspectorFrontend.h"
  59 #include "InspectorFrontendHost.h"
  60 #include "InspectorDatabaseResource.h"
  61 #include "InspectorDOMAgent.h"
  62 #include "InspectorDOMStorageResource.h"
  63 #include "InspectorTimelineAgent.h"
  64 #include "InspectorResource.h"
  65 #include "JavaScriptProfile.h"
  66 #include "Page.h"
  67 #include "ProgressTracker.h"
  68 #include "Range.h"
  69 #include "RenderInline.h"
  70 #include "ResourceRequest.h"
  71 #include "ResourceResponse.h"
  72 #include "ScriptCallStack.h"
  73 #include "ScriptFunctionCall.h"
  74 #include "ScriptObject.h"
  75 #include "ScriptString.h"
  76 #include "SecurityOrigin.h"
  77 #include "Settings.h"
  78 #include "SharedBuffer.h"
  79 #include "TextEncoding.h"
  80 #include "TextIterator.h"
  81 #include <wtf/CurrentTime.h>
  82 #include <wtf/ListHashSet.h>
  83 #include <wtf/RefCounted.h>
  84 #include <wtf/StdLibExtras.h>
  85
  86 #if ENABLE(DATABASE)
  87 #include "Database.h"
  88 #endif
  89
  90 #if ENABLE(DOM_STORAGE)
  91 #include "Storage.h"
  92 #include "StorageArea.h"
  93 #endif
  94
  95 #if ENABLE(JAVASCRIPT_DEBUGGER)
  96 #include "JavaScriptCallFrame.h"
  97 #include "JavaScriptDebugServer.h"
  98 #include "JSJavaScriptCallFrame.h"
  99
 100 #include <profiler/Profile.h>
 101 #include <profiler/Profiler.h>
 102 #include <runtime/JSLock.h>
 103 #include <runtime/UString.h>
 104
 105 using namespace JSC;
 106 #endif
 107 using namespace std;
 108
 109 namespace WebCore {
 110
 111 static const char* const UserInitiatedProfileName = "org.webkit.profiles.user-initiated";
 112 static const char* const CPUProfileType = "CPU";
 113 static const char* const resourceTrackingEnabledSettingName = "resourceTrackingEnabled";
 114 static const char* const debuggerEnabledSettingName = "debuggerEnabled";
 115 static const char* const profilerEnabledSettingName = "profilerEnabled";
 116 static const char* const inspectorAttachedHeightName = "inspectorAttachedHeight";
 117 static const char* const lastActivePanelSettingName = "lastActivePanel";
 118
 119 static const unsigned defaultAttachedHeight = 300;
 120 static const float minimumAttachedHeight = 250.0f;
 121 static const float maximumAttachedHeightRatio = 0.75f;
 122
 123 static unsigned s_inspectorControllerCount;
 124
 125 InspectorController::InspectorController(Page* page, InspectorClient* client)
 126     : m_inspectedPage(page)
 127     , m_client(client)
 128     , m_page(0)
 129     , m_scriptState(0)
 130     , m_windowVisible(false)
 131     , m_showAfterVisible(CurrentPanel)
 132     , m_groupLevel(0)
 133     , m_searchingForNode(false)
 134     , m_previousMessage(0)
 135     , m_resourceTrackingEnabled(false)
 136     , m_resourceTrackingSettingsLoaded(false)
 137     , m_inspectorBackend(InspectorBackend::create(this))
 138     , m_inspectorFrontendHost(InspectorFrontendHost::create(this, client))
 139     , m_injectedScriptHost(InjectedScriptHost::create(this))
 140     , m_lastBoundObjectId(1)
 141 #if ENABLE(JAVASCRIPT_DEBUGGER)
 142     , m_debuggerEnabled(false)
 143     , m_attachDebuggerWhenShown(false)
 144     , m_profilerEnabled(false)
 145     , m_recordingUserInitiatedProfile(false)
 146     , m_currentUserInitiatedProfileNumber(-1)
 147     , m_nextUserInitiatedProfileNumber(1)
 148     , m_startProfiling(this, &InspectorController::startUserInitiatedProfiling)
 149 #endif
 150 {
 151     ASSERT_ARG(page, page);
 152     ASSERT_ARG(client, client);
 153     ++s_inspectorControllerCount;
 154 }
 155
 156 InspectorController::~InspectorController()
 157 {
 158     // These should have been cleared in inspectedPageDestroyed().
 159     ASSERT(!m_client);
 160     ASSERT(!m_scriptState);
 161     ASSERT(!m_inspectedPage);
 162     ASSERT(!m_page || (m_page && !m_page->parentInspectorController()));
 163
 164     deleteAllValues(m_frameResources);
 165     deleteAllValues(m_consoleMessages);
 166
 167     ASSERT(s_inspectorControllerCount);
 168     --s_inspectorControllerCount;
 169
 170     releaseDOMAgent();
 171
 172     m_inspectorBackend->disconnectController();
 173     m_inspectorFrontendHost->disconnectController();
 174     m_injectedScriptHost->disconnectController();
 175 }
 176
 177 void InspectorController::inspectedPageDestroyed()
 178 {
 179     close();
 180
 181     if (m_scriptState) {
 182         ScriptGlobalObject::remove(m_scriptState, "InspectorBackend");
 183         ScriptGlobalObject::remove(m_scriptState, "InspectorFrontendHost");
 184         ScriptGlobalObject::remove(m_scriptState, "InjectedScriptHost");
 185     }
 186     ASSERT(m_inspectedPage);
 187     m_inspectedPage = 0;
 188
 189     m_client->inspectorDestroyed();
 190     m_client = 0;
 191 }
 192
 193 bool InspectorController::enabled() const
 194 {
 195     if (!m_inspectedPage)
 196         return false;
 197     return m_inspectedPage->settings()->developerExtrasEnabled();
 198 }
 199
 200 String InspectorController::setting(const String& key) const
 201 {
 202     Settings::iterator it = m_settings.find(key);
 203     if (it != m_settings.end())
 204         return it->second;
 205
 206     String value;
 207     m_client->populateSetting(key, &value);
 208     m_settings.set(key, value);
 209     return value;
 210 }
 211
 212 void InspectorController::setSetting(const String& key, const String& value)
 213 {
 214     m_settings.set(key, value);
 215     m_client->storeSetting(key, value);
 216 }
 217
 218 // Trying to inspect something in a frame with JavaScript disabled would later lead to
 219 // crashes trying to create JavaScript wrappers. Some day we could fix this issue, but
 220 // for now prevent crashes here by never targeting a node in such a frame.
 221 static bool canPassNodeToJavaScript(Node* node)
 222 {
 223     if (!node)
 224         return false;
 225     Frame* frame = node->document()->frame();
 226     return frame && frame->script()->isEnabled();
 227 }
 228
 229 void InspectorController::inspect(Node* node)
 230 {
 231     if (!canPassNodeToJavaScript(node) || !enabled())
 232         return;
 233
 234     show();
 235
 236     if (node->nodeType() != Node::ELEMENT_NODE && node->nodeType() != Node::DOCUMENT_NODE)
 237         node = node->parentNode();
 238     m_nodeToFocus = node;
 239
 240     if (!m_frontend) {
 241         m_showAfterVisible = ElementsPanel;
 242         return;
 243     }
 244
 245     focusNode();
 246 }
 247
 248 void InspectorController::focusNode()
 249 {
 250     if (!enabled())
 251         return;
 252
 253     ASSERT(m_frontend);
 254     ASSERT(m_nodeToFocus);
 255
 256     long id = m_domAgent->pushNodePathToFrontend(m_nodeToFocus.get());
 257     m_frontend->updateFocusedNode(id);
 258     m_nodeToFocus = 0;
 259 }
 260
 261 void InspectorController::highlight(Node* node)
 262 {
 263     if (!enabled())
 264         return;
 265     ASSERT_ARG(node, node);
 266     m_highlightedNode = node;
 267     m_client->highlight(node);
 268 }
 269
 270 void InspectorController::hideHighlight()
 271 {
 272     if (!enabled())
 273         return;
 274     m_highlightedNode = 0;
 275     m_client->hideHighlight();
 276 }
 277
 278 bool InspectorController::windowVisible()
 279 {
 280     return m_windowVisible;
 281 }
 282
 283 void InspectorController::setWindowVisible(bool visible, bool attached)
 284 {
 285     if (visible == m_windowVisible || !m_frontend)
 286         return;
 287
 288     m_windowVisible = visible;
 289
 290     if (m_windowVisible) {
 291         setAttachedWindow(attached);
 292         populateScriptObjects();
 293
 294         if (m_showAfterVisible == CurrentPanel) {
 295           String lastActivePanelSetting = setting(lastActivePanelSettingName);
 296           m_showAfterVisible = specialPanelForJSName(lastActivePanelSetting);
 297         }
 298
 299         if (m_nodeToFocus)
 300             focusNode();
 301 #if ENABLE(JAVASCRIPT_DEBUGGER)
 302         if (m_attachDebuggerWhenShown)
 303             enableDebugger();
 304 #endif
 305         showPanel(m_showAfterVisible);
 306     } else {
 307 #if ENABLE(JAVASCRIPT_DEBUGGER)
 308         // If the window is being closed with the debugger enabled,
 309         // remember this state to re-enable debugger on the next window
 310         // opening.
 311         bool debuggerWasEnabled = m_debuggerEnabled;
 312         disableDebugger();
 313         if (debuggerWasEnabled)
 314             m_attachDebuggerWhenShown = true;
 315 #endif
 316         if (m_searchingForNode)
 317             toggleSearchForNodeInPage();
 318         resetScriptObjects();
 319         stopTimelineProfiler();
 320     }
 321     m_showAfterVisible = CurrentPanel;
 322 }
 323
 324 void InspectorController::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, ScriptCallStack* callStack)
 325 {
 326     if (!enabled())
 327         return;
 328
 329     addConsoleMessage(callStack->state(), new ConsoleMessage(source, type, level, callStack, m_groupLevel, type == TraceMessageType));
 330 }
 331
 332 void InspectorController::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceID)
 333 {
 334     if (!enabled())
 335         return;
 336
 337     addConsoleMessage(0, new ConsoleMessage(source, type, level, message, lineNumber, sourceID, m_groupLevel));
 338 }
 339
 340 void InspectorController::addConsoleMessage(ScriptState* scriptState, ConsoleMessage* consoleMessage)
 341 {
 342     ASSERT(enabled());
 343     ASSERT_ARG(consoleMessage, consoleMessage);
 344
 345     if (m_previousMessage && m_previousMessage->isEqual(scriptState, consoleMessage)) {
 346         m_previousMessage->incrementCount();
 347         delete consoleMessage;
 348         if (windowVisible())
 349             m_previousMessage->updateRepeatCountInConsole(m_frontend.get());
 350     } else {
 351         m_previousMessage = consoleMessage;
 352         m_consoleMessages.append(consoleMessage);
 353         if (windowVisible())
 354             m_previousMessage->addToConsole(m_frontend.get());
 355     }
 356 }
 357
 358 void InspectorController::clearConsoleMessages(bool clearUI)
 359 {
 360     deleteAllValues(m_consoleMessages);
 361     m_consoleMessages.clear();
 362     m_previousMessage = 0;
 363     m_groupLevel = 0;
 364     releaseWrapperObjectGroup("console");
 365     if (m_domAgent)
 366         m_domAgent->releaseDanglingNodes();
 367     if (clearUI && m_frontend)
 368         m_frontend->clearConsoleMessages();
 369 }
 370
 371 void InspectorController::startGroup(MessageSource source, ScriptCallStack* callStack)
 372 {
 373     ++m_groupLevel;
 374
 375     addConsoleMessage(callStack->state(), new ConsoleMessage(source, StartGroupMessageType, LogMessageLevel, callStack, m_groupLevel));
 376 }
 377
 378 void InspectorController::endGroup(MessageSource source, unsigned lineNumber, const String& sourceURL)
 379 {
 380     if (m_groupLevel == 0)
 381         return;
 382
 383     --m_groupLevel;
 384
 385     addConsoleMessage(0, new ConsoleMessage(source, EndGroupMessageType, LogMessageLevel, String(), lineNumber, sourceURL, m_groupLevel));
 386 }
 387
 388 void InspectorController::markTimeline(const String& message)
 389 {
 390     if (timelineAgent())
 391         timelineAgent()->didMarkTimeline(message);
 392 }
 393
 394 static unsigned constrainedAttachedWindowHeight(unsigned preferredHeight, unsigned totalWindowHeight)
 395 {
 396     return roundf(max(minimumAttachedHeight, min<float>(preferredHeight, totalWindowHeight * maximumAttachedHeightRatio)));
 397 }
 398
 399 void InspectorController::attachWindow()
 400 {
 401     if (!enabled())
 402         return;
 403
 404     unsigned inspectedPageHeight = m_inspectedPage->mainFrame()->view()->visibleHeight();
 405
 406     m_client->attachWindow();
 407
 408     String attachedHeight = setting(inspectorAttachedHeightName);
 409     bool success = true;
 410     int height = attachedHeight.toInt(&success);
 411     unsigned preferredHeight = success ? height : defaultAttachedHeight;
 412
 413     // We need to constrain the window height here in case the user has resized the inspected page's window so that
 414     // the user's preferred height would be too big to display.
 415     m_client->setAttachedWindowHeight(constrainedAttachedWindowHeight(preferredHeight, inspectedPageHeight));
 416 }
 417
 418 void InspectorController::detachWindow()
 419 {
 420     if (!enabled())
 421         return;
 422     m_client->detachWindow();
 423 }
 424
 425 void InspectorController::setAttachedWindow(bool attached)
 426 {
 427     if (!enabled() || !m_frontend)
 428         return;
 429
 430     m_frontend->setAttachedWindow(attached);
 431 }
 432
 433 void InspectorController::setAttachedWindowHeight(unsigned height)
 434 {
 435     if (!enabled())
 436         return;
 437
 438     unsigned totalHeight = m_page->mainFrame()->view()->visibleHeight() + m_inspectedPage->mainFrame()->view()->visibleHeight();
 439     unsigned attachedHeight = constrainedAttachedWindowHeight(height, totalHeight);
 440
 441     setSetting(inspectorAttachedHeightName, String::number(attachedHeight));
 442
 443     m_client->setAttachedWindowHeight(attachedHeight);
 444 }
 445
 446 void InspectorController::storeLastActivePanel(const String& panelName)
 447 {
 448     setSetting(lastActivePanelSettingName, panelName);
 449 }
 450
 451 void InspectorController::toggleSearchForNodeInPage()
 452 {
 453     if (!enabled())
 454         return;
 455
 456     m_searchingForNode = !m_searchingForNode;
 457     if (!m_searchingForNode)
 458         hideHighlight();
 459 }
 460
 461 void InspectorController::mouseDidMoveOverElement(const HitTestResult& result, unsigned)
 462 {
 463     if (!enabled() || !m_searchingForNode)
 464         return;
 465
 466     Node* node = result.innerNode();
 467     if (node)
 468         highlight(node);
 469 }
 470
 471 void InspectorController::handleMousePressOnNode(Node* node)
 472 {
 473     if (!enabled())
 474         return;
 475
 476     ASSERT(m_searchingForNode);
 477     ASSERT(node);
 478     if (!node)
 479         return;
 480
 481     // inspect() will implicitly call ElementsPanel's focusedNodeChanged() and the hover feedback will be stopped there.
 482     inspect(node);
 483 }
 484
 485 void InspectorController::inspectedWindowScriptObjectCleared(Frame* frame)
 486 {
 487     if (!enabled() || !m_frontend || frame != m_inspectedPage->mainFrame())
 488         return;
 489     resetInjectedScript();
 490 }
 491
 492 void InspectorController::windowScriptObjectAvailable()
 493 {
 494     if (!m_page || !enabled())
 495         return;
 496
 497     // Grant the inspector the ability to script the inspected page.
 498     m_page->mainFrame()->document()->securityOrigin()->grantUniversalAccess();
 499     m_scriptState = scriptStateFromPage(debuggerWorld(), m_page);
 500     ScriptGlobalObject::set(m_scriptState, "InspectorBackend", m_inspectorBackend.get());
 501     ScriptGlobalObject::set(m_scriptState, "InspectorFrontendHost", m_inspectorFrontendHost.get());
 502     ScriptGlobalObject::set(m_scriptState, "InjectedScriptHost", m_injectedScriptHost.get());
 503 }
 504
 505 void InspectorController::scriptObjectReady()
 506 {
 507     ASSERT(m_scriptState);
 508     if (!m_scriptState)
 509         return;
 510
 511     ScriptObject webInspectorObj;
 512     if (!ScriptGlobalObject::get(m_scriptState, "WebInspector", webInspectorObj))
 513         return;
 514     ScriptObject injectedScriptObj;
 515     if (!ScriptGlobalObject::get(m_scriptState, "InjectedScript", injectedScriptObj))
 516         return;
 517     setFrontendProxyObject(m_scriptState, webInspectorObj, injectedScriptObj);
 518
 519 #if ENABLE(JAVASCRIPT_DEBUGGER)
 520     String debuggerEnabled = setting(debuggerEnabledSettingName);
 521     if (debuggerEnabled == "true")
 522         enableDebugger();
 523     String profilerEnabled = setting(profilerEnabledSettingName);
 524     if (profilerEnabled == "true")
 525         enableProfiler();
 526 #endif
 527
 528     // Make sure our window is visible now that the page loaded
 529     showWindow();
 530
 531     m_client->inspectorWindowObjectCleared();
 532 }
 533
 534 void InspectorController::setFrontendProxyObject(ScriptState* scriptState, ScriptObject webInspectorObj, ScriptObject injectedScriptObj)
 535 {
 536     m_scriptState = scriptState;
 537     m_injectedScriptObj = injectedScriptObj;
 538     m_frontend.set(new InspectorFrontend(this, scriptState, webInspectorObj));
 539     releaseDOMAgent();
 540     m_domAgent = InspectorDOMAgent::create(m_frontend.get());
 541     if (m_timelineAgent)
 542         m_timelineAgent->resetFrontendProxyObject(m_frontend.get());
 543 }
 544
 545 void InspectorController::show()
 546 {
 547     if (!enabled())
 548         return;
 549
 550     if (!m_page) {
 551         if (m_frontend)
 552             return;  // We are using custom frontend - no need to create page.
 553
 554         m_page = m_client->createPage();
 555         if (!m_page)
 556             return;
 557         m_page->setParentInspectorController(this);
 558
 559         // showWindow() will be called after the page loads in scriptObjectReady()
 560         return;
 561     }
 562
 563     showWindow();
 564 }
 565
 566 void InspectorController::showPanel(SpecialPanels panel)
 567 {
 568     if (!enabled())
 569         return;
 570
 571     show();
 572
 573     if (!m_frontend) {
 574         m_showAfterVisible = panel;
 575         return;
 576     }
 577
 578     if (panel == CurrentPanel)
 579         return;
 580
 581     m_frontend->showPanel(panel);
 582 }
 583
 584 void InspectorController::close()
 585 {
 586     if (!enabled())
 587         return;
 588
 589 #if ENABLE(JAVASCRIPT_DEBUGGER)
 590     stopUserInitiatedProfiling();
 591     disableDebugger();
 592 #endif
 593     closeWindow();
 594
 595     m_injectedScriptObj = ScriptObject();
 596     releaseDOMAgent();
 597     m_frontend.set(0);
 598     m_timelineAgent = 0;
 599     m_scriptState = 0;
 600     if (m_page) {
 601         if (!m_page->mainFrame() || !m_page->mainFrame()->loader() || !m_page->mainFrame()->loader()->isLoading()) {
 602             m_page->setParentInspectorController(0);
 603             m_page = 0;
 604         }
 605     }
 606 }
 607
 608 void InspectorController::showWindow()
 609 {
 610     ASSERT(enabled());
 611
 612     unsigned inspectedPageHeight = m_inspectedPage->mainFrame()->view()->visibleHeight();
 613
 614     m_client->showWindow();
 615
 616     String attachedHeight = setting(inspectorAttachedHeightName);
 617     bool success = true;
 618     int height = attachedHeight.toInt(&success);
 619     unsigned preferredHeight = success ? height : defaultAttachedHeight;
 620
 621     // This call might not go through (if the window starts out detached), but if the window is initially created attached,
 622     // InspectorController::attachWindow is never called, so we need to make sure to set the attachedWindowHeight.
 623     // FIXME: Clean up code so we only have to call setAttachedWindowHeight in InspectorController::attachWindow
 624     m_client->setAttachedWindowHeight(constrainedAttachedWindowHeight(preferredHeight, inspectedPageHeight));
 625 }
 626
 627 void InspectorController::closeWindow()
 628 {
 629     m_client->closeWindow();
 630 }
 631
 632 void InspectorController::releaseDOMAgent()
 633 {
 634     // m_domAgent is RefPtr. Remove DOM listeners first to ensure that there are
 635     // no references to the DOM agent from the DOM tree.
 636     if (m_domAgent)
 637         m_domAgent->reset();
 638     m_domAgent = 0;
 639 }
 640
 641 void InspectorController::populateScriptObjects()
 642 {
 643     ASSERT(m_frontend);
 644     if (!m_frontend)
 645         return;
 646
 647     m_domAgent->setDocument(m_inspectedPage->mainFrame()->document());
 648
 649     ResourcesMap::iterator resourcesEnd = m_resources.end();
 650     for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it)
 651         it->second->createScriptObject(m_frontend.get());
 652
 653     unsigned messageCount = m_consoleMessages.size();
 654     for (unsigned i = 0; i < messageCount; ++i)
 655         m_consoleMessages[i]->addToConsole(m_frontend.get());
 656
 657 #if ENABLE(DATABASE)
 658     DatabaseResourcesMap::iterator databasesEnd = m_databaseResources.end();
 659     for (DatabaseResourcesMap::iterator it = m_databaseResources.begin(); it != databasesEnd; ++it)
 660         it->second->bind(m_frontend.get());
 661 #endif
 662 #if ENABLE(DOM_STORAGE)
 663     DOMStorageResourcesMap::iterator domStorageEnd = m_domStorageResources.end();
 664     for (DOMStorageResourcesMap::iterator it = m_domStorageResources.begin(); it != domStorageEnd; ++it)
 665         it->second->bind(m_frontend.get());
 666 #endif
 667
 668     m_frontend->populateInterface();
 669
 670     // Dispatch pending frontend commands
 671     for (Vector<pair<long, String> >::iterator it = m_pendingEvaluateTestCommands.begin(); it != m_pendingEvaluateTestCommands.end(); ++it)
 672         m_frontend->evaluateForTestInFrontend((*it).first, (*it).second);
 673     m_pendingEvaluateTestCommands.clear();
 674 }
 675
 676 void InspectorController::resetScriptObjects()
 677 {
 678     if (!m_frontend)
 679         return;
 680
 681     ResourcesMap::iterator resourcesEnd = m_resources.end();
 682     for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it)
 683         it->second->releaseScriptObject(m_frontend.get(), false);
 684
 685 #if ENABLE(DATABASE)
 686     DatabaseResourcesMap::iterator databasesEnd = m_databaseResources.end();
 687     for (DatabaseResourcesMap::iterator it = m_databaseResources.begin(); it != databasesEnd; ++it)
 688         it->second->unbind();
 689 #endif
 690 #if ENABLE(DOM_STORAGE)
 691     DOMStorageResourcesMap::iterator domStorageEnd = m_domStorageResources.end();
 692     for (DOMStorageResourcesMap::iterator it = m_domStorageResources.begin(); it != domStorageEnd; ++it)
 693         it->second->unbind();
 694 #endif
 695
 696     if (m_timelineAgent)
 697         m_timelineAgent->reset();
 698
 699     m_frontend->reset();
 700     m_domAgent->reset();
 701     m_objectGroups.clear();
 702     m_idToWrappedObject.clear();
 703 }
 704
 705 void InspectorController::pruneResources(ResourcesMap* resourceMap, DocumentLoader* loaderToKeep)
 706 {
 707     ASSERT_ARG(resourceMap, resourceMap);
 708
 709     ResourcesMap mapCopy(*resourceMap);
 710     ResourcesMap::iterator end = mapCopy.end();
 711     for (ResourcesMap::iterator it = mapCopy.begin(); it != end; ++it) {
 712         InspectorResource* resource = (*it).second.get();
 713         if (resource == m_mainResource)
 714             continue;
 715
 716         if (!loaderToKeep || !resource->isSameLoader(loaderToKeep)) {
 717             removeResource(resource);
 718             if (windowVisible())
 719                 resource->releaseScriptObject(m_frontend.get(), true);
 720         }
 721     }
 722 }
 723
 724 void InspectorController::didCommitLoad(DocumentLoader* loader)
 725 {
 726     if (!enabled())
 727         return;
 728
 729     ASSERT(m_inspectedPage);
 730
 731     if (loader->frame() == m_inspectedPage->mainFrame()) {
 732         m_client->inspectedURLChanged(loader->url().string());
 733
 734         clearConsoleMessages(false);
 735
 736         m_times.clear();
 737         m_counts.clear();
 738 #if ENABLE(JAVASCRIPT_DEBUGGER)
 739         m_profiles.clear();
 740         m_currentUserInitiatedProfileNumber = 1;
 741         m_nextUserInitiatedProfileNumber = 1;
 742 #endif
 743         // resetScriptObjects should be called before database and DOM storage
 744         // resources are cleared so that it has a chance to unbind them.
 745         resetScriptObjects();
 746
 747 #if ENABLE(DATABASE)
 748         m_databaseResources.clear();
 749 #endif
 750 #if ENABLE(DOM_STORAGE)
 751         m_domStorageResources.clear();
 752 #endif
 753
 754         if (m_frontend) {
 755             if (!loader->frameLoader()->isLoadingFromCachedPage()) {
 756                 ASSERT(m_mainResource && m_mainResource->isSameLoader(loader));
 757                 // We don't add the main resource until its load is committed. This is
 758                 // needed to keep the load for a user-entered URL from showing up in the
 759                 // list of resources for the page they are navigating away from.
 760                 if (windowVisible())
 761                     m_mainResource->createScriptObject(m_frontend.get());
 762             } else {
 763                 // Pages loaded from the page cache are committed before
 764                 // m_mainResource is the right resource for this load, so we
 765                 // clear it here. It will be re-assigned in
 766                 // identifierForInitialRequest.
 767                 m_mainResource = 0;
 768             }
 769             if (windowVisible()) {
 770                 m_frontend->didCommitLoad();
 771                 m_domAgent->setDocument(m_inspectedPage->mainFrame()->document());
 772             }
 773         }
 774     }
 775
 776     for (Frame* frame = loader->frame(); frame; frame = frame->tree()->traverseNext(loader->frame()))
 777         if (ResourcesMap* resourceMap = m_frameResources.get(frame))
 778             pruneResources(resourceMap, loader);
 779 }
 780
 781 void InspectorController::frameDetachedFromParent(Frame* frame)
 782 {
 783     if (!enabled())
 784         return;
 785     if (ResourcesMap* resourceMap = m_frameResources.get(frame))
 786         removeAllResources(resourceMap);
 787 }
 788
 789 void InspectorController::addResource(InspectorResource* resource)
 790 {
 791     m_resources.set(resource->identifier(), resource);
 792     m_knownResources.add(resource->requestURL());
 793
 794     Frame* frame = resource->frame();
 795     ResourcesMap* resourceMap = m_frameResources.get(frame);
 796     if (resourceMap)
 797         resourceMap->set(resource->identifier(), resource);
 798     else {
 799         resourceMap = new ResourcesMap;
 800         resourceMap->set(resource->identifier(), resource);
 801         m_frameResources.set(frame, resourceMap);
 802     }
 803 }
 804
 805 void InspectorController::removeResource(InspectorResource* resource)
 806 {
 807     m_resources.remove(resource->identifier());
 808     String requestURL = resource->requestURL();
 809     if (!requestURL.isNull())
 810         m_knownResources.remove(requestURL);
 811
 812     Frame* frame = resource->frame();
 813     ResourcesMap* resourceMap = m_frameResources.get(frame);
 814     if (!resourceMap) {
 815         ASSERT_NOT_REACHED();
 816         return;
 817     }
 818
 819     resourceMap->remove(resource->identifier());
 820     if (resourceMap->isEmpty()) {
 821         m_frameResources.remove(frame);
 822         delete resourceMap;
 823     }
 824 }
 825
 826 InspectorResource* InspectorController::getTrackedResource(unsigned long identifier)
 827 {
 828     if (!enabled())
 829         return 0;
 830
 831     if (m_resourceTrackingEnabled)
 832         return m_resources.get(identifier).get();
 833
 834     bool isMainResource = m_mainResource && m_mainResource->identifier() == identifier;
 835     if (isMainResource)
 836         return m_mainResource.get();
 837
 838     return 0;
 839 }
 840
 841 void InspectorController::didLoadResourceFromMemoryCache(DocumentLoader* loader, const CachedResource* cachedResource)
 842 {
 843     if (!enabled())
 844         return;
 845
 846     // If the resource URL is already known, we don't need to add it again since this is just a cached load.
 847     if (m_knownResources.contains(cachedResource->url()))
 848         return;
 849
 850     ASSERT(m_inspectedPage);
 851     bool isMainResource = isMainResourceLoader(loader, KURL(ParsedURLString, cachedResource->url()));
 852     ensureResourceTrackingSettingsLoaded();
 853     if (!isMainResource && !m_resourceTrackingEnabled)
 854         return;
 855
 856     RefPtr<InspectorResource> resource = InspectorResource::createCached(m_inspectedPage->progress()->createUniqueIdentifier() , loader, cachedResource);
 857
 858     if (isMainResource) {
 859         m_mainResource = resource;
 860         resource->markMainResource();
 861     }
 862
 863     addResource(resource.get());
 864
 865     if (windowVisible())
 866         resource->createScriptObject(m_frontend.get());
 867 }
 868
 869 void InspectorController::identifierForInitialRequest(unsigned long identifier, DocumentLoader* loader, const ResourceRequest& request)
 870 {
 871     if (!enabled())
 872         return;
 873     ASSERT(m_inspectedPage);
 874
 875     bool isMainResource = isMainResourceLoader(loader, request.url());
 876     ensureResourceTrackingSettingsLoaded();
 877     if (!isMainResource && !m_resourceTrackingEnabled)
 878         return;
 879
 880     RefPtr<InspectorResource> resource = InspectorResource::create(identifier, loader);
 881
 882     resource->updateRequest(request);
 883
 884     if (isMainResource) {
 885         m_mainResource = resource;
 886         resource->markMainResource();
 887     }
 888
 889     addResource(resource.get());
 890
 891     if (windowVisible() && loader->frameLoader()->isLoadingFromCachedPage() && resource == m_mainResource)
 892         resource->createScriptObject(m_frontend.get());
 893 }
 894
 895 void InspectorController::mainResourceFiredDOMContentEvent(DocumentLoader* loader, const KURL& url)
 896 {
 897     if (!enabled() || !isMainResourceLoader(loader, url))
 898         return;
 899
 900     if (m_mainResource) {
 901         m_mainResource->markDOMContentEventTime();
 902         if (windowVisible())
 903             m_mainResource->updateScriptObject(m_frontend.get());
 904     }
 905 }
 906
 907 void InspectorController::mainResourceFiredLoadEvent(DocumentLoader* loader, const KURL& url)
 908 {
 909     if (!enabled() || !isMainResourceLoader(loader, url))
 910         return;
 911
 912     if (m_mainResource) {
 913         m_mainResource->markLoadEventTime();
 914         if (windowVisible())
 915             m_mainResource->updateScriptObject(m_frontend.get());
 916     }
 917 }
 918
 919 bool InspectorController::isMainResourceLoader(DocumentLoader* loader, const KURL& requestUrl)
 920 {
 921     return loader->frame() == m_inspectedPage->mainFrame() && requestUrl == loader->requestURL();
 922 }
 923
 924 void InspectorController::willSendRequest(unsigned long identifier, const ResourceRequest& request, const ResourceResponse& redirectResponse)
 925 {
 926     bool isMainResource = (m_mainResource && m_mainResource->identifier() == identifier);
 927     if (m_timelineAgent)
 928         m_timelineAgent->willSendResourceRequest(identifier, isMainResource, request);
 929
 930     RefPtr<InspectorResource> resource = getTrackedResource(identifier);
 931     if (!resource)
 932         return;
 933
 934     resource->startTiming();
 935
 936     if (!redirectResponse.isNull()) {
 937         resource->updateRequest(request);
 938         resource->updateResponse(redirectResponse);
 939     }
 940
 941     if (resource != m_mainResource && windowVisible())
 942         resource->createScriptObject(m_frontend.get());
 943 }
 944
 945 void InspectorController::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
 946 {
 947     if (m_timelineAgent)
 948         m_timelineAgent->didReceiveResourceResponse(identifier, response);
 949
 950     RefPtr<InspectorResource> resource = getTrackedResource(identifier);
 951     if (!resource)
 952         return;
 953
 954     resource->updateResponse(response);
 955     resource->markResponseReceivedTime();
 956
 957     if (windowVisible())
 958         resource->updateScriptObject(m_frontend.get());
 959 }
 960
 961 void InspectorController::didReceiveContentLength(unsigned long identifier, int lengthReceived)
 962 {
 963     RefPtr<InspectorResource> resource = getTrackedResource(identifier);
 964     if (!resource)
 965         return;
 966
 967     resource->addLength(lengthReceived);
 968
 969     if (windowVisible())
 970         resource->updateScriptObject(m_frontend.get());
 971 }
 972
 973 void InspectorController::didFinishLoading(unsigned long identifier)
 974 {
 975     if (m_timelineAgent)
 976         m_timelineAgent->didFinishLoadingResource(identifier, false);
 977
 978     RefPtr<InspectorResource> resource = getTrackedResource(identifier);
 979     if (!resource)
 980         return;
 981
 982     removeResource(resource.get());
 983
 984     resource->endTiming();
 985
 986     addResource(resource.get());
 987
 988     if (windowVisible())
 989         resource->updateScriptObject(m_frontend.get());
 990 }
 991
 992 void InspectorController::didFailLoading(unsigned long identifier, const ResourceError& /*error*/)
 993 {
 994     if (m_timelineAgent)
 995         m_timelineAgent->didFinishLoadingResource(identifier, true);
 996
 997     RefPtr<InspectorResource> resource = getTrackedResource(identifier);
 998     if (!resource)
 999         return;
1000
1001     removeResource(resource.get());
1002
1003     resource->markFailed();
1004     resource->endTiming();
1005
1006     addResource(resource.get());
1007
1008     if (windowVisible())
1009         resource->updateScriptObject(m_frontend.get());
1010 }
1011
1012 void InspectorController::resourceRetrievedByXMLHttpRequest(unsigned long identifier, const ScriptString& sourceString)
1013 {
1014     if (!enabled() || !m_resourceTrackingEnabled)
1015         return;
1016
1017     InspectorResource* resource = m_resources.get(identifier).get();
1018     if (!resource)
1019         return;
1020
1021     resource->setXMLHttpResponseText(sourceString);
1022
1023     if (windowVisible())
1024         resource->updateScriptObject(m_frontend.get());
1025 }
1026
1027 void InspectorController::scriptImported(unsigned long identifier, const String& sourceString)
1028 {
1029     if (!enabled() || !m_resourceTrackingEnabled)
1030         return;
1031
1032     InspectorResource* resource = m_resources.get(identifier).get();
1033     if (!resource)
1034         return;
1035
1036     // FIXME: imported script and XHR response are currently viewed as the same
1037     // thing by the Inspector. They should be made into distinct types.
1038     resource->setXMLHttpResponseText(ScriptString(sourceString));
1039
1040     if (windowVisible())
1041         resource->updateScriptObject(m_frontend.get());
1042 }
1043
1044 void InspectorController::enableResourceTracking(bool always, bool reload)
1045 {
1046     if (!enabled())
1047         return;
1048
1049     if (always)
1050         setSetting(resourceTrackingEnabledSettingName, "true");
1051
1052     if (m_resourceTrackingEnabled)
1053         return;
1054
1055     ASSERT(m_inspectedPage);
1056     m_resourceTrackingEnabled = true;
1057     if (m_frontend)
1058         m_frontend->resourceTrackingWasEnabled();
1059
1060     if (reload)
1061         m_inspectedPage->mainFrame()->loader()->reload();
1062 }
1063
1064 void InspectorController::disableResourceTracking(bool always)
1065 {
1066     if (!enabled())
1067         return;
1068
1069     if (always)
1070         setSetting(resourceTrackingEnabledSettingName, "false");
1071
1072     ASSERT(m_inspectedPage);
1073     m_resourceTrackingEnabled = false;
1074     if (m_frontend)
1075         m_frontend->resourceTrackingWasDisabled();
1076 }
1077
1078 void InspectorController::ensureResourceTrackingSettingsLoaded()
1079 {
1080     if (m_resourceTrackingSettingsLoaded)
1081         return;
1082     m_resourceTrackingSettingsLoaded = true;
1083
1084     String resourceTracking = setting(resourceTrackingEnabledSettingName);
1085     if (resourceTracking == "true")
1086         m_resourceTrackingEnabled = true;
1087 }
1088
1089 void InspectorController::startTimelineProfiler()
1090 {
1091     if (!enabled())
1092         return;
1093
1094     if (m_timelineAgent)
1095         return;
1096
1097     m_timelineAgent = new InspectorTimelineAgent(m_frontend.get());
1098     if (m_frontend)
1099         m_frontend->timelineProfilerWasStarted();
1100 }
1101
1102 void InspectorController::stopTimelineProfiler()
1103 {
1104     if (!enabled())
1105         return;
1106
1107     if (!m_timelineAgent)
1108         return;
1109
1110     m_timelineAgent = 0;
1111     if (m_frontend)
1112         m_frontend->timelineProfilerWasStopped();
1113 }
1114
1115 #if ENABLE(DATABASE)
1116 void InspectorController::selectDatabase(Database* database)
1117 {
1118     if (!m_frontend)
1119         return;
1120
1121     for (DatabaseResourcesMap::iterator it = m_databaseResources.begin(); it != m_databaseResources.end(); ++it) {
1122         if (it->second->database() == database) {
1123             m_frontend->selectDatabase(it->first);
1124             break;
1125         }
1126     }
1127 }
1128
1129 Database* InspectorController::databaseForId(int databaseId)
1130 {
1131     DatabaseResourcesMap::iterator it = m_databaseResources.find(databaseId);
1132     if (it == m_databaseResources.end())
1133         return 0;
1134     return it->second->database();
1135 }
1136
1137 void InspectorController::didOpenDatabase(Database* database, const String& domain, const String& name, const String& version)
1138 {
1139     if (!enabled())
1140         return;
1141
1142     RefPtr<InspectorDatabaseResource> resource = InspectorDatabaseResource::create(database, domain, name, version);
1143
1144     m_databaseResources.set(resource->id(), resource);
1145
1146     // Resources are only bound while visible.
1147     if (windowVisible())
1148         resource->bind(m_frontend.get());
1149 }
1150 #endif
1151
1152 void InspectorController::getCookies(long callId)
1153 {
1154     if (!m_frontend)
1155         return;
1156
1157     // If we can get raw cookies.
1158     ListHashSet<Cookie> rawCookiesList;
1159
1160     // If we can't get raw cookies - fall back to String representation
1161     String stringCookiesList;
1162
1163     // Return value to getRawCookies should be the same for every call because
1164     // the return value is platform/network backend specific, and the call will
1165     // always return the same true/false value.
1166     bool rawCookiesImplemented = false;
1167
1168     ResourcesMap::iterator resourcesEnd = m_resources.end();
1169     for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it) {
1170         Document* document = it->second->frame()->document();
1171         Vector<Cookie> docCookiesList;
1172         rawCookiesImplemented = getRawCookies(document, document->cookieURL(), docCookiesList);
1173
1174         if (!rawCookiesImplemented) {
1175             // FIXME: We need duplication checking for the String representation of cookies.
1176             ExceptionCode ec = 0;
1177             stringCookiesList += document->cookie(ec);
1178             // Exceptions are thrown by cookie() in sandboxed frames. That won't happen here
1179             // because "document" is the document of the main frame of the page.
1180             ASSERT(!ec);
1181         } else {
1182             int cookiesSize = docCookiesList.size();
1183             for (int i = 0; i < cookiesSize; i++) {
1184                 if (!rawCookiesList.contains(docCookiesList[i]))
1185                     rawCookiesList.add(docCookiesList[i]);
1186             }
1187         }
1188     }
1189
1190     if (!rawCookiesImplemented)
1191         m_frontend->didGetCookies(callId, m_frontend->newScriptArray(), stringCookiesList);
1192     else
1193         m_frontend->didGetCookies(callId, buildArrayForCookies(rawCookiesList), String());
1194 }
1195
1196 ScriptArray InspectorController::buildArrayForCookies(ListHashSet<Cookie>& cookiesList)
1197 {
1198     ScriptArray cookies = m_frontend->newScriptArray();
1199
1200     ListHashSet<Cookie>::iterator end = cookiesList.end();
1201     ListHashSet<Cookie>::iterator it = cookiesList.begin();
1202     for (int i = 0; it != end; ++it, i++)
1203         cookies.set(i, buildObjectForCookie(*it));
1204
1205     return cookies;
1206 }
1207
1208 ScriptObject InspectorController::buildObjectForCookie(const Cookie& cookie)
1209 {
1210     ScriptObject value = m_frontend->newScriptObject();
1211     value.set("name", cookie.name);
1212     value.set("value", cookie.value);
1213     value.set("domain", cookie.domain);
1214     value.set("path", cookie.path);
1215     value.set("expires", cookie.expires);
1216     value.set("size", (cookie.name.length() + cookie.value.length()));
1217     value.set("httpOnly", cookie.httpOnly);
1218     value.set("secure", cookie.secure);
1219     value.set("session", cookie.session);
1220     return value;
1221 }
1222
1223 #if ENABLE(DOM_STORAGE)
1224 void InspectorController::didUseDOMStorage(StorageArea* storageArea, bool isLocalStorage, Frame* frame)
1225 {
1226     if (!enabled())
1227         return;
1228
1229     DOMStorageResourcesMap::iterator domStorageEnd = m_domStorageResources.end();
1230     for (DOMStorageResourcesMap::iterator it = m_domStorageResources.begin(); it != domStorageEnd; ++it)
1231         if (it->second->isSameHostAndType(frame, isLocalStorage))
1232             return;
1233
1234     RefPtr<Storage> domStorage = Storage::create(frame, storageArea);
1235     RefPtr<InspectorDOMStorageResource> resource = InspectorDOMStorageResource::create(domStorage.get(), isLocalStorage, frame);
1236
1237     m_domStorageResources.set(resource->id(), resource);
1238
1239     // Resources are only bound while visible.
1240     if (windowVisible())
1241         resource->bind(m_frontend.get());
1242 }
1243
1244 void InspectorController::selectDOMStorage(Storage* storage)
1245 {
1246     ASSERT(storage);
1247     if (!m_frontend)
1248         return;
1249
1250     Frame* frame = storage->frame();
1251     bool isLocalStorage = (frame->domWindow()->localStorage() == storage);
1252     int storageResourceId = 0;
1253     DOMStorageResourcesMap::iterator domStorageEnd = m_domStorageResources.end();
1254     for (DOMStorageResourcesMap::iterator it = m_domStorageResources.begin(); it != domStorageEnd; ++it) {
1255         if (it->second->isSameHostAndType(frame, isLocalStorage)) {
1256             storageResourceId = it->first;
1257             break;
1258         }
1259     }
1260     if (storageResourceId)
1261         m_frontend->selectDOMStorage(storageResourceId);
1262 }
1263
1264 void InspectorController::getDOMStorageEntries(int callId, int storageId)
1265 {
1266     if (!m_frontend)
1267         return;
1268
1269     ScriptArray jsonArray = m_frontend->newScriptArray();
1270     InspectorDOMStorageResource* storageResource = getDOMStorageResourceForId(storageId);
1271     if (storageResource) {
1272         storageResource->startReportingChangesToFrontend();
1273         Storage* domStorage = storageResource->domStorage();
1274         for (unsigned i = 0; i < domStorage->length(); ++i) {
1275             String name(domStorage->key(i));
1276             String value(domStorage->getItem(name));
1277             ScriptArray entry = m_frontend->newScriptArray();
1278             entry.set(0, name);
1279             entry.set(1, value);
1280             jsonArray.set(i, entry);
1281         }
1282     }
1283     m_frontend->didGetDOMStorageEntries(callId, jsonArray);
1284 }
1285
1286 void InspectorController::setDOMStorageItem(long callId, long storageId, const String& key, const String& value)
1287 {
1288     if (!m_frontend)
1289         return;
1290
1291     bool success = false;
1292     InspectorDOMStorageResource* storageResource = getDOMStorageResourceForId(storageId);
1293     if (storageResource) {
1294         ExceptionCode exception = 0;
1295         storageResource->domStorage()->setItem(key, value, exception);
1296         success = (exception == 0);
1297     }
1298     m_frontend->didSetDOMStorageItem(callId, success);
1299 }
1300
1301 void InspectorController::removeDOMStorageItem(long callId, long storageId, const String& key)
1302 {
1303     if (!m_frontend)
1304         return;
1305
1306     bool success = false;
1307     InspectorDOMStorageResource* storageResource = getDOMStorageResourceForId(storageId);
1308     if (storageResource) {
1309         storageResource->domStorage()->removeItem(key);
1310         success = true;
1311     }
1312     m_frontend->didRemoveDOMStorageItem(callId, success);
1313 }
1314
1315 InspectorDOMStorageResource* InspectorController::getDOMStorageResourceForId(int storageId)
1316 {
1317     DOMStorageResourcesMap::iterator it = m_domStorageResources.find(storageId);
1318     if (it == m_domStorageResources.end())
1319         return 0;
1320     return it->second.get();
1321 }
1322 #endif
1323
1324 void InspectorController::moveWindowBy(float x, float y) const
1325 {
1326     if (!m_page || !enabled())
1327         return;
1328
1329     FloatRect frameRect = m_page->chrome()->windowRect();
1330     frameRect.move(x, y);
1331     m_page->chrome()->setWindowRect(frameRect);
1332 }
1333
1334 #if ENABLE(JAVASCRIPT_DEBUGGER)
1335 void InspectorController::addProfile(PassRefPtr<Profile> prpProfile, unsigned lineNumber, const UString& sourceURL)
1336 {
1337     if (!enabled())
1338         return;
1339
1340     RefPtr<Profile> profile = prpProfile;
1341     m_profiles.add(profile->uid(), profile);
1342
1343     if (m_frontend) {
1344         JSLock lock(SilenceAssertionsOnly);
1345         m_frontend->addProfileHeader(createProfileHeader(*profile));
1346     }
1347
1348     addProfileFinishedMessageToConsole(profile, lineNumber, sourceURL);
1349 }
1350
1351 void InspectorController::addProfileFinishedMessageToConsole(PassRefPtr<Profile> prpProfile, unsigned lineNumber, const UString& sourceURL)
1352 {
1353     RefPtr<Profile> profile = prpProfile;
1354
1355     UString message = "Profile \"webkit-profile://";
1356     message += encodeWithURLEscapeSequences(CPUProfileType);
1357     message += "/";
1358     message += encodeWithURLEscapeSequences(profile->title());
1359     message += "#";
1360     message += UString::from(profile->uid());
1361     message += "\" finished.";
1362     addMessageToConsole(JSMessageSource, LogMessageType, LogMessageLevel, message, lineNumber, sourceURL);
1363 }
1364
1365 void InspectorController::addStartProfilingMessageToConsole(const UString& title, unsigned lineNumber, const UString& sourceURL)
1366 {
1367     UString message = "Profile \"webkit-profile://";
1368     message += encodeWithURLEscapeSequences(CPUProfileType);
1369     message += "/";
1370     message += encodeWithURLEscapeSequences(title);
1371     message += "#0\" started.";
1372     addMessageToConsole(JSMessageSource, LogMessageType, LogMessageLevel, message, lineNumber, sourceURL);
1373 }
1374
1375 void InspectorController::getProfileHeaders(long callId)
1376 {
1377     if (!m_frontend)
1378         return;
1379     ScriptArray result = m_frontend->newScriptArray();
1380     ProfilesMap::iterator profilesEnd = m_profiles.end();
1381     int i = 0;
1382     for (ProfilesMap::iterator it = m_profiles.begin(); it != profilesEnd; ++it)
1383         result.set(i++, createProfileHeader(*it->second));
1384     m_frontend->didGetProfileHeaders(callId, result);
1385 }
1386
1387 void InspectorController::getProfile(long callId, unsigned uid)
1388 {
1389     if (!m_frontend)
1390         return;
1391     ProfilesMap::iterator it = m_profiles.find(uid);
1392     if (it != m_profiles.end())
1393         m_frontend->didGetProfile(callId, toJS(m_scriptState, it->second.get()));
1394 }
1395
1396 ScriptObject InspectorController::createProfileHeader(const JSC::Profile& profile)
1397 {
1398     ScriptObject header = m_frontend->newScriptObject();
1399     header.set("title", profile.title());
1400     header.set("uid", profile.uid());
1401     header.set("typeId", UString(CPUProfileType));
1402     return header;
1403 }
1404
1405 UString InspectorController::getCurrentUserInitiatedProfileName(bool incrementProfileNumber = false)
1406 {
1407     if (incrementProfileNumber)
1408         m_currentUserInitiatedProfileNumber = m_nextUserInitiatedProfileNumber++;
1409
1410     UString title = UserInitiatedProfileName;
1411     title += ".";
1412     title += UString::from(m_currentUserInitiatedProfileNumber);
1413
1414     return title;
1415 }
1416
1417 void InspectorController::startUserInitiatedProfilingSoon()
1418 {
1419     m_startProfiling.startOneShot(0);
1420 }
1421
1422 void InspectorController::startUserInitiatedProfiling(Timer<InspectorController>*)
1423 {
1424     if (!enabled())
1425         return;
1426
1427     if (!profilerEnabled()) {
1428         enableProfiler(false, true);
1429         JavaScriptDebugServer::shared().recompileAllJSFunctions();
1430     }
1431
1432     m_recordingUserInitiatedProfile = true;
1433
1434     UString title = getCurrentUserInitiatedProfileName(true);
1435
1436     ExecState* scriptState = toJSDOMWindow(m_inspectedPage->mainFrame(), debuggerWorld())->globalExec();
1437     Profiler::profiler()->startProfiling(scriptState, title);
1438
1439     addStartProfilingMessageToConsole(title, 0, UString());
1440
1441     toggleRecordButton(true);
1442 }
1443
1444 void InspectorController::stopUserInitiatedProfiling()
1445 {
1446     if (!enabled())
1447         return;
1448
1449     m_recordingUserInitiatedProfile = false;
1450
1451     UString title = getCurrentUserInitiatedProfileName();
1452
1453     ExecState* scriptState = toJSDOMWindow(m_inspectedPage->mainFrame(), debuggerWorld())->globalExec();
1454     RefPtr<Profile> profile = Profiler::profiler()->stopProfiling(scriptState, title);
1455     if (profile)
1456         addProfile(profile, 0, UString());
1457
1458     toggleRecordButton(false);
1459 }
1460
1461 void InspectorController::toggleRecordButton(bool isProfiling)
1462 {
1463     if (!m_frontend)
1464         return;
1465     m_frontend->setRecordingProfile(isProfiling);
1466 }
1467
1468 void InspectorController::enableProfiler(bool always, bool skipRecompile)
1469 {
1470     if (always)
1471         setSetting(profilerEnabledSettingName, "true");
1472
1473     if (m_profilerEnabled)
1474         return;
1475
1476     m_profilerEnabled = true;
1477
1478     if (!skipRecompile)
1479         JavaScriptDebugServer::shared().recompileAllJSFunctionsSoon();
1480
1481     if (m_frontend)
1482         m_frontend->profilerWasEnabled();
1483 }
1484
1485 void InspectorController::disableProfiler(bool always)
1486 {
1487     if (always)
1488         setSetting(profilerEnabledSettingName, "false");
1489
1490     if (!m_profilerEnabled)
1491         return;
1492
1493     m_profilerEnabled = false;
1494
1495     JavaScriptDebugServer::shared().recompileAllJSFunctionsSoon();
1496
1497     if (m_frontend)
1498         m_frontend->profilerWasDisabled();
1499 }
1500
1501 void InspectorController::enableDebuggerFromFrontend(bool always)
1502 {
1503     if (always)
1504         setSetting(debuggerEnabledSettingName, "true");
1505
1506     ASSERT(m_inspectedPage);
1507
1508     JavaScriptDebugServer::shared().addListener(this, m_inspectedPage);
1509     JavaScriptDebugServer::shared().clearBreakpoints();
1510
1511     m_debuggerEnabled = true;
1512     m_frontend->debuggerWasEnabled();
1513 }
1514
1515 void InspectorController::enableDebugger()
1516 {
1517     if (!enabled())
1518         return;
1519
1520     if (m_debuggerEnabled)
1521         return;
1522
1523     if (!m_scriptState || !m_frontend) {
1524         m_attachDebuggerWhenShown = true;
1525     } else {
1526         m_frontend->attachDebuggerWhenShown();
1527         m_attachDebuggerWhenShown = false;
1528     }
1529 }
1530
1531 void InspectorController::disableDebugger(bool always)
1532 {
1533     if (!enabled())
1534         return;
1535
1536     if (always)
1537         setSetting(debuggerEnabledSettingName, "false");
1538
1539     ASSERT(m_inspectedPage);
1540
1541     JavaScriptDebugServer::shared().removeListener(this, m_inspectedPage);
1542
1543     m_debuggerEnabled = false;
1544     m_attachDebuggerWhenShown = false;
1545
1546     if (m_frontend)
1547         m_frontend->debuggerWasDisabled();
1548 }
1549
1550 void InspectorController::resumeDebugger()
1551 {
1552     if (!m_debuggerEnabled)
1553         return;
1554     JavaScriptDebugServer::shared().continueProgram();
1555 }
1556
1557 // JavaScriptDebugListener functions
1558
1559 void InspectorController::didParseSource(ExecState*, const SourceCode& source)
1560 {
1561     m_frontend->parsedScriptSource(source);
1562 }
1563
1564 void InspectorController::failedToParseSource(ExecState*, const SourceCode& source, int errorLine, const UString& errorMessage)
1565 {
1566     m_frontend->failedToParseScriptSource(source, errorLine, errorMessage);
1567 }
1568
1569 void InspectorController::didPause()
1570 {
1571     ScriptFunctionCall function(m_scriptState, m_injectedScriptObj, "getCallFrames");
1572     ScriptValue callFrames = function.call();
1573     m_frontend->pausedScript(callFrames);
1574 }
1575
1576 void InspectorController::didContinue()
1577 {
1578     m_frontend->resumedScript();
1579 }
1580
1581 #endif
1582
1583 void InspectorController::evaluateForTestInFrontend(long callId, const String& script)
1584 {
1585     if (m_frontend)
1586         m_frontend->evaluateForTestInFrontend(callId, script);
1587     else
1588         m_pendingEvaluateTestCommands.append(pair<long, String>(callId, script));
1589 }
1590
1591 void InspectorController::didEvaluateForTestInFrontend(long callId, const String& jsonResult)
1592 {
1593     ScriptState* scriptState = scriptStateFromPage(debuggerWorld(), m_inspectedPage);
1594     ScriptObject window;
1595     ScriptGlobalObject::get(scriptState, "window", window);
1596     ScriptFunctionCall function(scriptState, window, "didEvaluateForTestInFrontend");
1597     function.appendArgument(callId);
1598     function.appendArgument(jsonResult);
1599     function.call();
1600 }
1601
1602 static Path quadToPath(const FloatQuad& quad)
1603 {
1604     Path quadPath;
1605     quadPath.moveTo(quad.p1());
1606     quadPath.addLineTo(quad.p2());
1607     quadPath.addLineTo(quad.p3());
1608     quadPath.addLineTo(quad.p4());
1609     quadPath.closeSubpath();
1610     return quadPath;
1611 }
1612
1613 static void drawOutlinedQuad(GraphicsContext& context, const FloatQuad& quad, const Color& fillColor)
1614 {
1615     static const int outlineThickness = 2;
1616     static const Color outlineColor(62, 86, 180, 228);
1617
1618     Path quadPath = quadToPath(quad);
1619
1620     // Clip out the quad, then draw with a 2px stroke to get a pixel
1621     // of outline (because inflating a quad is hard)
1622     {
1623         context.save();
1624         context.addPath(quadPath);
1625         context.clipOut(quadPath);
1626
1627         context.addPath(quadPath);
1628         context.setStrokeThickness(outlineThickness);
1629         context.setStrokeColor(outlineColor, DeviceColorSpace);
1630         context.strokePath();
1631
1632         context.restore();
1633     }
1634
1635     // Now do the fill
1636     context.addPath(quadPath);
1637     context.setFillColor(fillColor, DeviceColorSpace);
1638     context.fillPath();
1639 }
1640
1641 static void drawOutlinedQuadWithClip(GraphicsContext& context, const FloatQuad& quad, const FloatQuad& clipQuad, const Color& fillColor)
1642 {
1643     context.save();
1644     Path clipQuadPath = quadToPath(clipQuad);
1645     context.clipOut(clipQuadPath);
1646     drawOutlinedQuad(context, quad, fillColor);
1647     context.restore();
1648 }
1649
1650 static void drawHighlightForBox(GraphicsContext& context, const FloatQuad& contentQuad, const FloatQuad& paddingQuad, const FloatQuad& borderQuad, const FloatQuad& marginQuad)
1651 {
1652     static const Color contentBoxColor(125, 173, 217, 128);
1653     static const Color paddingBoxColor(125, 173, 217, 160);
1654     static const Color borderBoxColor(125, 173, 217, 192);
1655     static const Color marginBoxColor(125, 173, 217, 228);
1656
1657     if (marginQuad != borderQuad)
1658         drawOutlinedQuadWithClip(context, marginQuad, borderQuad, marginBoxColor);
1659     if (borderQuad != paddingQuad)
1660         drawOutlinedQuadWithClip(context, borderQuad, paddingQuad, borderBoxColor);
1661     if (paddingQuad != contentQuad)
1662         drawOutlinedQuadWithClip(context, paddingQuad, contentQuad, paddingBoxColor);
1663
1664     drawOutlinedQuad(context, contentQuad, contentBoxColor);
1665 }
1666
1667 static void drawHighlightForLineBoxes(GraphicsContext& context, const Vector<FloatQuad>& lineBoxQuads)
1668 {
1669     static const Color lineBoxColor(125, 173, 217, 128);
1670
1671     for (size_t i = 0; i < lineBoxQuads.size(); ++i)
1672         drawOutlinedQuad(context, lineBoxQuads[i], lineBoxColor);
1673 }
1674
1675 static inline void convertFromFrameToMainFrame(Frame* frame, IntRect& rect)
1676 {
1677     rect = frame->page()->mainFrame()->view()->windowToContents(frame->view()->contentsToWindow(rect));
1678 }
1679
1680 static inline IntSize frameToMainFrameOffset(Frame* frame)
1681 {
1682     IntPoint mainFramePoint = frame->page()->mainFrame()->view()->windowToContents(frame->view()->contentsToWindow(IntPoint()));
1683     return mainFramePoint - IntPoint();
1684 }
1685
1686 void InspectorController::drawNodeHighlight(GraphicsContext& context) const
1687 {
1688     if (!m_highlightedNode)
1689         return;
1690
1691     RenderObject* renderer = m_highlightedNode->renderer();
1692     Frame* containingFrame = m_highlightedNode->document()->frame();
1693     if (!renderer || !containingFrame)
1694         return;
1695
1696     IntSize mainFrameOffset = frameToMainFrameOffset(containingFrame);
1697     IntRect boundingBox = renderer->absoluteBoundingBoxRect(true);
1698     boundingBox.move(mainFrameOffset);
1699
1700     ASSERT(m_inspectedPage);
1701
1702     FrameView* view = m_inspectedPage->mainFrame()->view();
1703     FloatRect overlayRect = view->visibleContentRect();
1704     if (!overlayRect.contains(boundingBox) && !boundingBox.contains(enclosingIntRect(overlayRect)))
1705         overlayRect = view->visibleContentRect();
1706     context.translate(-overlayRect.x(), -overlayRect.y());
1707
1708     if (renderer->isBox()) {
1709         RenderBox* renderBox = toRenderBox(renderer);
1710
1711         IntRect contentBox = renderBox->contentBoxRect();
1712
1713         IntRect paddingBox(contentBox.x() - renderBox->paddingLeft(), contentBox.y() - renderBox->paddingTop(),
1714                            contentBox.width() + renderBox->paddingLeft() + renderBox->paddingRight(), contentBox.height() + renderBox->paddingTop() + renderBox->paddingBottom());
1715         IntRect borderBox(paddingBox.x() - renderBox->borderLeft(), paddingBox.y() - renderBox->borderTop(),
1716                           paddingBox.width() + renderBox->borderLeft() + renderBox->borderRight(), paddingBox.height() + renderBox->borderTop() + renderBox->borderBottom());
1717         IntRect marginBox(borderBox.x() - renderBox->marginLeft(), borderBox.y() - renderBox->marginTop(),
1718                           borderBox.width() + renderBox->marginLeft() + renderBox->marginRight(), borderBox.height() + renderBox->marginTop() + renderBox->marginBottom());
1719
1720         FloatQuad absContentQuad = renderBox->localToAbsoluteQuad(FloatRect(contentBox));
1721         FloatQuad absPaddingQuad = renderBox->localToAbsoluteQuad(FloatRect(paddingBox));
1722         FloatQuad absBorderQuad = renderBox->localToAbsoluteQuad(FloatRect(borderBox));
1723         FloatQuad absMarginQuad = renderBox->localToAbsoluteQuad(FloatRect(marginBox));
1724
1725         absContentQuad.move(mainFrameOffset);
1726         absPaddingQuad.move(mainFrameOffset);
1727         absBorderQuad.move(mainFrameOffset);
1728         absMarginQuad.move(mainFrameOffset);
1729
1730         drawHighlightForBox(context, absContentQuad, absPaddingQuad, absBorderQuad, absMarginQuad);
1731     } else if (renderer->isRenderInline()) {
1732         RenderInline* renderInline = toRenderInline(renderer);
1733
1734         // FIXME: We should show margins/padding/border for inlines.
1735         Vector<FloatQuad> lineBoxQuads;
1736         renderInline->absoluteQuads(lineBoxQuads);
1737         for (unsigned i = 0; i < lineBoxQuads.size(); ++i)
1738             lineBoxQuads[i] += mainFrameOffset;
1739
1740         drawHighlightForLineBoxes(context, lineBoxQuads);
1741     }
1742 }
1743
1744 void InspectorController::count(const String& title, unsigned lineNumber, const String& sourceID)
1745 {
1746     String identifier = title + String::format("@%s:%d", sourceID.utf8().data(), lineNumber);
1747     HashMap<String, unsigned>::iterator it = m_counts.find(identifier);
1748     int count;
1749     if (it == m_counts.end())
1750         count = 1;
1751     else {
1752         count = it->second + 1;
1753         m_counts.remove(it);
1754     }
1755
1756     m_counts.add(identifier, count);
1757
1758     String message = String::format("%s: %d", title.utf8().data(), count);
1759     addMessageToConsole(JSMessageSource, LogMessageType, LogMessageLevel, message, lineNumber, sourceID);
1760 }
1761
1762 void InspectorController::startTiming(const String& title)
1763 {
1764     m_times.add(title, currentTime() * 1000);
1765 }
1766
1767 bool InspectorController::stopTiming(const String& title, double& elapsed)
1768 {
1769     HashMap<String, double>::iterator it = m_times.find(title);
1770     if (it == m_times.end())
1771         return false;
1772
1773     double startTime = it->second;
1774     m_times.remove(it);
1775
1776     elapsed = currentTime() * 1000 - startTime;
1777     return true;
1778 }
1779
1780 InspectorController::SpecialPanels InspectorController::specialPanelForJSName(const String& panelName)
1781 {
1782     if (panelName == "elements")
1783         return ElementsPanel;
1784     else if (panelName == "resources")
1785         return ResourcesPanel;
1786     else if (panelName == "scripts")
1787         return ScriptsPanel;
1788     else if (panelName == "timeline")
1789         return TimelinePanel;
1790     else if (panelName == "profiles")
1791         return ProfilesPanel;
1792     else if (panelName == "storage" || panelName == "databases")
1793         return StoragePanel;
1794     else if (panelName == "console")
1795         return ConsolePanel;
1796     else
1797         return ElementsPanel;
1798 }
1799
1800 ScriptValue InspectorController::wrapObject(const ScriptValue& quarantinedObject, const String& objectGroup)
1801 {
1802     ScriptFunctionCall function(m_scriptState, m_injectedScriptObj, "createProxyObject");
1803     function.appendArgument(quarantinedObject);
1804     if (quarantinedObject.isObject()) {
1805         long id = m_lastBoundObjectId++;
1806         String objectId = String::format("object#%ld", id);
1807         m_idToWrappedObject.set(objectId, quarantinedObject);
1808         ObjectGroupsMap::iterator it = m_objectGroups.find(objectGroup);
1809         if (it == m_objectGroups.end())
1810             it = m_objectGroups.set(objectGroup, Vector<String>()).first;
1811         it->second.append(objectId);
1812         function.appendArgument(objectId);
1813     }
1814     ScriptValue wrapper = function.call();
1815     return wrapper;
1816 }
1817
1818 ScriptValue InspectorController::unwrapObject(const String& objectId)
1819 {
1820     HashMap<String, ScriptValue>::iterator it = m_idToWrappedObject.find(objectId);
1821     if (it != m_idToWrappedObject.end())
1822         return it->second;
1823     return ScriptValue();
1824 }
1825
1826 void InspectorController::releaseWrapperObjectGroup(const String& objectGroup)
1827 {
1828     ObjectGroupsMap::iterator groupIt = m_objectGroups.find(objectGroup);
1829     if (groupIt == m_objectGroups.end())
1830         return;
1831
1832     Vector<String>& groupIds = groupIt->second;
1833     for (Vector<String>::iterator it = groupIds.begin(); it != groupIds.end(); ++it)
1834         m_idToWrappedObject.remove(*it);
1835     m_objectGroups.remove(groupIt);
1836 }
1837
1838 void InspectorController::resetInjectedScript()
1839 {
1840     ScriptFunctionCall function(m_scriptState, m_injectedScriptObj, "reset");
1841     function.call();
1842 }
1843
1844 void InspectorController::deleteCookie(const String& cookieName, const String& domain)
1845 {
1846     ResourcesMap::iterator resourcesEnd = m_resources.end();
1847     for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it) {
1848         Document* document = it->second->frame()->document();
1849         if (document->url().host() == domain)
1850             WebCore::deleteCookie(document, document->cookieURL(), cookieName);
1851     }
1852 }
1853
1854 } // namespace WebCore
1855
1856 #endif // ENABLE(INSPECTOR)