diff -r 000000000000 -r dd21522fd290 webengine/osswebengine/WebCore/page/InspectorController.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebCore/page/InspectorController.cpp	Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,1314 @@
+/*
+ * Copyright (C) 2007 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer. 
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution. 
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "InspectorController.h"
+
+#include "CString.h"
+#include "CachedResource.h"
+#include "DocLoader.h"
+#include "Document.h"
+#include "DocumentLoader.h"
+#include "Element.h"
+#include "FloatRect.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "FrameTree.h"
+#include "HTMLFrameOwnerElement.h"
+#include "InspectorClient.h"
+#include "JSRange.h"
+#include "Page.h"
+#include "Range.h"
+#include "ResourceRequest.h"
+#include "ResourceResponse.h"
+#include "Settings.h"
+#include "Shared.h"
+#include "SharedBuffer.h"
+#include "SystemTime.h"
+#include "TextEncoding.h"
+#include "TextIterator.h"
+#include "kjs_dom.h"
+#include "kjs_proxy.h"
+#include "kjs_window.h"
+#include <JavaScriptCore/APICast.h>
+#include <JavaScriptCore/JSLock.h>
+#include <JavaScriptCore/JSStringRef.h>
+
+namespace WebCore {
+
+struct ConsoleMessage {
+    ConsoleMessage(MessageSource s, MessageLevel l, const String& m, unsigned li, const String& u)
+        : source(s)
+        , level(l)
+        , message(m)
+        , line(li)
+        , url(u)
+    {
+    }
+
+    MessageSource source;
+    MessageLevel level;
+    String message;
+    unsigned line;
+    String url;
+};
+
+struct InspectorResource : public Shared<InspectorResource> {
+    // Keep these in sync with WebInspector.Resource.Type
+    enum Type {
+        Doc,
+        Stylesheet,
+        Image,
+        Script,
+        Other
+    };
+
+    InspectorResource(long long identifier, DocumentLoader* documentLoader, Frame* frame)
+        : identifier(identifier)
+        , loader(documentLoader)
+        , frame(frame)
+        , scriptContext(0)
+        , scriptObject(0)
+        , expectedContentLength(0)
+        , cached(false)
+        , finished(false)
+        , failed(false)
+        , length(0)
+        , responseStatusCode(0)
+        , startTime(-1.0)
+        , responseReceivedTime(-1.0)
+        , endTime(-1.0)
+    {
+    }
+
+    ~InspectorResource()
+    {
+        setScriptObject(0, 0);
+    }
+
+    Type type() const
+    {
+        if (requestURL == loader->requestURL())
+            return Doc;
+
+        FrameLoader* frameLoader = loader->frameLoader();
+        if (!frameLoader)
+            return Other;
+
+        if (requestURL == frameLoader->iconURL())
+            return Image;
+
+        Document* doc = frameLoader->frame()->document();
+        if (!doc)
+            return Other;
+
+        CachedResource* cachedResource = doc->docLoader()->cachedResource(requestURL.url());
+        if (!cachedResource)
+            return Other;
+
+        switch (cachedResource->type()) {
+            case CachedResource::ImageResource:
+                return Image;
+            case CachedResource::CSSStyleSheet:
+#if ENABLE(XSLT)
+            case CachedResource::XSLStyleSheet:
+#endif
+                return Stylesheet;
+            case CachedResource::Script:
+                return Script;
+            default:
+                return Other;
+        }
+    }
+
+    void setScriptObject(JSContextRef context, JSObjectRef newScriptObject)
+    {
+        if (scriptContext && scriptObject)
+            JSValueUnprotect(scriptContext, scriptObject);
+
+        scriptObject = newScriptObject;
+        scriptContext = context;
+
+        ASSERT((context && newScriptObject) || (!context && !newScriptObject));
+        if (context && newScriptObject)
+            JSValueProtect(context, newScriptObject);
+    }
+
+    long long identifier;
+    RefPtr<DocumentLoader> loader;
+    RefPtr<Frame> frame;
+    KURL requestURL;
+    HTTPHeaderMap requestHeaderFields;
+    HTTPHeaderMap responseHeaderFields;
+    String mimeType;
+    String suggestedFilename;
+    String textEncodingName;
+    JSContextRef scriptContext;
+    JSObjectRef scriptObject;
+    long long expectedContentLength;
+    bool cached;
+    bool finished;
+    bool failed;
+    int length;
+    int responseStatusCode;
+    double startTime;
+    double responseReceivedTime;
+    double endTime;
+};
+
+static JSValueRef addSourceToFrame(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
+{
+    JSValueRef undefined = JSValueMakeUndefined(ctx);
+
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (argumentCount < 2 || !controller)
+        return undefined;
+
+    JSValueRef identifierValue = arguments[0];
+    if (!JSValueIsNumber(ctx, identifierValue))
+        return undefined;
+
+    unsigned long identifier = static_cast<unsigned long>(JSValueToNumber(ctx, identifierValue, 0));
+    RefPtr<InspectorResource> resource = controller->resources().get(identifier);
+    ASSERT(resource);
+    if (!resource)
+        return undefined;
+
+    RefPtr<SharedBuffer> buffer;
+    if (resource->requestURL == resource->loader->requestURL())
+        buffer = resource->loader->mainResourceData();
+    else {
+        FrameLoader* frameLoader = resource->loader->frameLoader();
+        if (!frameLoader)
+            return undefined;
+
+        Document* doc = frameLoader->frame()->document();
+        if (!doc)
+            return undefined;
+
+        CachedResource* cachedResource = doc->docLoader()->cachedResource(resource->requestURL.url());
+        if (!cachedResource)
+            return undefined;
+
+        buffer = cachedResource->data();
+    }
+
+    if (!buffer)
+        return undefined;
+
+    String textEncodingName = resource->loader->overrideEncoding();
+    if (!textEncodingName)
+        textEncodingName = resource->textEncodingName;
+
+    TextEncoding encoding(textEncodingName);
+    if (!encoding.isValid())
+        encoding = WindowsLatin1Encoding();
+    String sourceString = encoding.decode(buffer->data(), buffer->size());
+
+    Node* node = toNode(toJS(arguments[1]));
+    ASSERT(node);
+    if (!node)
+        return undefined;
+
+    if (!node->attached()) {
+        ASSERT_NOT_REACHED();
+        return undefined;
+    }
+
+    ASSERT(node->isElementNode());
+    if (!node->isElementNode())
+        return undefined;
+
+    Element* element = static_cast<Element*>(node);
+    ASSERT(element->isFrameOwnerElement());
+    if (!element->isFrameOwnerElement())
+        return undefined;
+
+    HTMLFrameOwnerElement* frameOwner = static_cast<HTMLFrameOwnerElement*>(element);
+    ASSERT(frameOwner->contentFrame());
+    if (!frameOwner->contentFrame())
+        return undefined;
+
+    FrameLoader* loader = frameOwner->contentFrame()->loader();
+
+    loader->setResponseMIMEType(resource->mimeType);
+    loader->begin();
+    loader->write(sourceString);
+    loader->end();
+
+    return undefined;
+}
+
+static JSValueRef getResourceDocumentNode(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
+{
+    JSValueRef undefined = JSValueMakeUndefined(ctx);
+
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!argumentCount || argumentCount > 1 || !controller)
+        return undefined;
+
+    JSValueRef identifierValue = arguments[0];
+    if (!JSValueIsNumber(ctx, identifierValue))
+        return undefined;
+
+    unsigned long identifier = static_cast<unsigned long>(JSValueToNumber(ctx, identifierValue, 0));
+    RefPtr<InspectorResource> resource = controller->resources().get(identifier);
+    ASSERT(resource);
+    if (!resource)
+        return undefined;
+
+    FrameLoader* frameLoader = resource->loader->frameLoader();
+    if (!frameLoader)
+        return undefined;
+
+    Document* document = frameLoader->frame()->document();
+    if (!document)
+        return undefined;
+
+    if (document->isPluginDocument() || document->isImageDocument())
+        return undefined;
+
+    KJS::JSLock lock;
+    JSValueRef documentValue = toRef(toJS(toJS(controller->scriptContext()), document));
+    return documentValue;
+}
+
+static JSValueRef highlightDOMNode(JSContextRef context, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
+{
+    JSValueRef undefined = JSValueMakeUndefined(context);
+
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (argumentCount < 1 || !controller)
+        return undefined;
+
+    Node* node = toNode(toJS(arguments[0]));
+    if (!node)
+        return undefined;
+
+    controller->highlight(node);
+
+    return undefined;
+}
+
+static JSValueRef hideDOMNodeHighlight(JSContextRef context, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
+{
+    JSValueRef undefined = JSValueMakeUndefined(context);
+
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (argumentCount || !controller)
+        return undefined;
+
+    controller->hideHighlight();
+
+    return undefined;
+}
+
+static JSValueRef loaded(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments[]*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->scriptObjectReady();
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef unloading(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments[]*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->windowUnloading();
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef attach(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments[]*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->attachWindow();
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef detach(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments[]*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->detachWindow();
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef log(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef /*thisObject*/, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
+{
+    if (argumentCount < 1 || !JSValueIsString(ctx, arguments[0]))
+        return JSValueMakeUndefined(ctx);
+
+#ifndef NDEBUG
+    JSStringRef string = JSValueToStringCopy(ctx, arguments[0], 0);
+    String message(JSStringGetCharactersPtr(string), JSStringGetLength(string));
+    JSStringRelease(string);
+
+    fprintf(stderr, "%s\n", message.latin1().data());
+#endif
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef search(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    if (argumentCount < 2 || !JSValueIsString(ctx, arguments[1]))
+        return JSValueMakeUndefined(ctx);
+
+    Node* node = toNode(toJS(arguments[0]));
+    if (!node)
+        return JSValueMakeUndefined(ctx);
+
+    JSStringRef string = JSValueToStringCopy(ctx, arguments[1], 0);
+    String target(JSStringGetCharactersPtr(string), JSStringGetLength(string));
+    JSStringRelease(string);
+
+    JSObjectRef globalObject = JSContextGetGlobalObject(ctx);
+    JSStringRef constructorString = JSStringCreateWithUTF8CString("Array");
+    JSObjectRef arrayConstructor = JSValueToObject(ctx, JSObjectGetProperty(ctx, globalObject, constructorString, 0), 0);
+    JSStringRelease(constructorString);
+    JSObjectRef array = JSObjectCallAsConstructor(ctx, arrayConstructor, 0, 0, 0);
+
+    JSStringRef pushString = JSStringCreateWithUTF8CString("push");
+    JSValueRef pushValue = JSObjectGetProperty(ctx, array, pushString, 0);
+    JSStringRelease(pushString);
+    JSObjectRef push = JSValueToObject(ctx, pushValue, 0);
+
+    RefPtr<Range> searchRange(rangeOfContents(node));
+
+    int exception = 0;
+    do {
+        RefPtr<Range> resultRange(findPlainText(searchRange.get(), target, true, false));
+        if (resultRange->collapsed(exception))
+            break;
+
+        // A non-collapsed result range can in some funky whitespace cases still not
+        // advance the range's start position (4509328). Break to avoid infinite loop.
+        VisiblePosition newStart = endVisiblePosition(resultRange.get(), DOWNSTREAM);
+        if (newStart == startVisiblePosition(searchRange.get(), DOWNSTREAM))
+            break;
+
+        KJS::JSLock lock;
+        JSValueRef arg0 = toRef(toJS(toJS(ctx), resultRange.get()));
+        JSObjectCallAsFunction(ctx, push, array, 1, &arg0, 0);
+
+        setStart(searchRange.get(), newStart);
+    } while (true);
+
+    return array;
+}
+
+static JSValueRef inspectedWindow(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments[]*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    return toRef(KJS::Window::retrieve(controller->inspectedPage()->mainFrame()));
+}
+
+InspectorController::InspectorController(Page* page, InspectorClient* client)
+    : m_inspectedPage(page)
+    , m_client(client)
+    , m_page(0)
+    , m_scriptObject(0)
+    , m_controllerScriptObject(0)
+    , m_scriptContext(0)
+    , m_windowVisible(false)
+    , m_nextIdentifier(-2)
+{
+    ASSERT_ARG(page, page);
+    ASSERT_ARG(client, client);
+}
+
+InspectorController::~InspectorController()
+{
+    if (m_scriptContext) {
+        JSObjectRef global = JSContextGetGlobalObject(m_scriptContext);
+        JSStringRef controllerProperty = JSStringCreateWithUTF8CString("InspectorController");
+        JSObjectRef controller = JSValueToObject(m_scriptContext, JSObjectGetProperty(m_scriptContext, global, controllerProperty, 0), 0);
+        JSStringRelease(controllerProperty);
+        JSObjectSetPrivate(controller, 0);
+    }
+
+    m_client->closeWindow();
+    m_client->inspectorDestroyed();
+
+    if (m_page)
+        m_page->setParentInspectorController(0);
+
+    deleteAllValues(m_frameResources);
+    deleteAllValues(m_consoleMessages);
+}
+
+bool InspectorController::enabled() const
+{
+    return m_inspectedPage->settings()->developerExtrasEnabled();
+}
+
+void InspectorController::inspect(Node* node)
+{
+    if (!node || !enabled())
+        return;
+
+    if (!m_page) {
+        m_page = m_client->createPage();
+        if (!m_page)
+            return;
+
+        m_page->setParentInspectorController(this);
+    }
+
+    if (node->nodeType() != Node::ELEMENT_NODE && node->nodeType() != Node::DOCUMENT_NODE)
+        node = node->parentNode();
+    m_nodeToFocus = node;
+
+    if (!m_scriptObject)
+        return;
+
+    if (windowVisible())
+        focusNode();
+    else
+        m_client->showWindow();
+}
+
+void InspectorController::focusNode()
+{
+    if (!enabled())
+        return;
+
+    ASSERT(m_scriptContext);
+    ASSERT(m_scriptObject);
+    ASSERT(m_nodeToFocus);
+
+    JSValueRef arg0;
+
+    {
+        KJS::JSLock lock;
+        arg0 = toRef(toJS(toJS(m_scriptContext), m_nodeToFocus.get()));
+    }
+
+    m_nodeToFocus = 0;
+
+    JSStringRef functionProperty = JSStringCreateWithUTF8CString("updateFocusedNode");
+    JSObjectRef function = JSValueToObject(m_scriptContext, JSObjectGetProperty(m_scriptContext, m_scriptObject, functionProperty, 0), 0);
+    JSStringRelease(functionProperty);
+    ASSERT(function);
+
+    JSObjectCallAsFunction(m_scriptContext, function, m_scriptObject, 1, &arg0, 0);
+}
+
+void InspectorController::highlight(Node* node)
+{
+    if (!enabled())
+        return;
+    ASSERT_ARG(node, node);
+    m_client->highlight(node);
+}
+
+void InspectorController::hideHighlight()
+{
+    if (!enabled())
+        return;
+    m_client->hideHighlight();
+}
+
+bool InspectorController::windowVisible()
+{
+    return m_windowVisible;
+}
+
+void InspectorController::setWindowVisible(bool visible)
+{
+    if (visible == m_windowVisible)
+        return;
+
+    m_windowVisible = visible;
+
+    if (!m_scriptContext || !m_scriptObject)
+        return;
+
+    if (m_windowVisible) {
+        populateScriptResources();
+        if (m_nodeToFocus)
+            focusNode();
+    } else {
+        clearScriptResources();
+        clearScriptConsoleMessages();
+        clearNetworkTimeline();
+    }
+}
+
+void InspectorController::addMessageToConsole(MessageSource source, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceID)
+{
+    if (!enabled())
+        return;
+
+    ConsoleMessage* consoleMessage = new ConsoleMessage(source, level, message, lineNumber, sourceID);
+    m_consoleMessages.append(consoleMessage);
+
+    if (windowVisible())
+        addScriptConsoleMessage(consoleMessage);
+}
+
+void InspectorController::attachWindow()
+{
+    if (!enabled())
+        return;
+    m_client->attachWindow();
+}
+
+void InspectorController::detachWindow()
+{
+    if (!enabled())
+        return;
+    m_client->detachWindow();
+}
+
+void InspectorController::windowScriptObjectAvailable()
+{
+    if (!m_page || !enabled())
+        return;
+
+    m_scriptContext = toRef(m_page->mainFrame()->scriptProxy()->interpreter()->globalExec());
+
+    JSObjectRef global = JSContextGetGlobalObject(m_scriptContext);
+    ASSERT(global);
+
+    static JSStaticFunction staticFunctions[] = {
+        { "addSourceToFrame", addSourceToFrame, kJSPropertyAttributeNone },
+        { "getResourceDocumentNode", getResourceDocumentNode, kJSPropertyAttributeNone },
+        { "highlightDOMNode", highlightDOMNode, kJSPropertyAttributeNone },
+        { "hideDOMNodeHighlight", hideDOMNodeHighlight, kJSPropertyAttributeNone },
+        { "loaded", loaded, kJSPropertyAttributeNone },
+        { "windowUnloading", unloading, kJSPropertyAttributeNone },
+        { "attach", attach, kJSPropertyAttributeNone },
+        { "detach", detach, kJSPropertyAttributeNone },
+        { "log", log, kJSPropertyAttributeNone },
+        { "search", search, kJSPropertyAttributeNone },
+        { "inspectedWindow", inspectedWindow, kJSPropertyAttributeNone },
+        { 0, 0, 0 }
+    };
+
+    JSClassDefinition inspectorControllerDefinition = {
+        0, kJSClassAttributeNone, "InspectorController", 0, 0, staticFunctions,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+
+    JSClassRef controllerClass = JSClassCreate(&inspectorControllerDefinition);
+    ASSERT(controllerClass);
+
+    m_controllerScriptObject = JSObjectMake(m_scriptContext, controllerClass, reinterpret_cast<void*>(this));
+    ASSERT(m_controllerScriptObject);
+
+    JSStringRef controllerObjectString = JSStringCreateWithUTF8CString("InspectorController");
+    JSObjectSetProperty(m_scriptContext, global, controllerObjectString, m_controllerScriptObject, kJSPropertyAttributeNone, 0);
+    JSStringRelease(controllerObjectString);
+}
+
+void InspectorController::scriptObjectReady()
+{
+    ASSERT(m_scriptContext);
+    if (!m_scriptContext)
+        return;
+
+    JSObjectRef global = JSContextGetGlobalObject(m_scriptContext);
+    ASSERT(global);
+
+    JSStringRef inspectorString = JSStringCreateWithUTF8CString("WebInspector");
+    JSValueRef inspectorValue = JSObjectGetProperty(m_scriptContext, global, inspectorString, 0);
+    JSStringRelease(inspectorString);
+
+    ASSERT(inspectorValue);
+    if (!inspectorValue)
+        return;
+
+    m_scriptObject = JSValueToObject(m_scriptContext, inspectorValue, 0);
+    ASSERT(m_scriptObject);
+
+    JSValueProtect(m_scriptContext, m_scriptObject);
+
+    // Make sure our window is visible now that the page loaded
+    m_client->showWindow();
+}
+
+void InspectorController::windowUnloading()
+{
+    m_client->closeWindow();
+    if (m_page)
+        m_page->setParentInspectorController(0);
+
+    ASSERT(m_scriptContext && m_scriptObject);
+    JSValueUnprotect(m_scriptContext, m_scriptObject);
+
+    m_page = 0;
+    m_scriptObject = 0;
+    m_scriptContext = 0;
+}
+
+static void addHeaders(JSContextRef context, JSObjectRef object, const HTTPHeaderMap& headers)
+{
+    ASSERT_ARG(context, context);
+    ASSERT_ARG(object, object);
+    
+    HTTPHeaderMap::const_iterator end = headers.end();
+    for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) {
+        JSStringRef field = JSStringCreateWithCharacters(it->first.characters(), it->first.length());
+        JSStringRef valueString = JSStringCreateWithCharacters(it->second.characters(), it->second.length());
+        JSValueRef value = JSValueMakeString(context, valueString);
+        JSObjectSetProperty(context, object, field, value, kJSPropertyAttributeNone, 0);
+        JSStringRelease(field);
+        JSStringRelease(valueString);
+    }
+}
+
+static JSObjectRef scriptObjectForRequest(JSContextRef context, const InspectorResource* resource)
+{
+    ASSERT_ARG(context, context);
+
+    JSObjectRef object = JSObjectMake(context, 0, 0);
+    addHeaders(context, object, resource->requestHeaderFields);
+
+    return object;
+}
+
+static JSObjectRef scriptObjectForResponse(JSContextRef context, const InspectorResource* resource)
+{
+    ASSERT_ARG(context, context);
+
+    JSObjectRef object = JSObjectMake(context, 0, 0);
+    addHeaders(context, object, resource->responseHeaderFields);
+
+    return object;
+}
+
+JSObjectRef InspectorController::addScriptResource(InspectorResource* resource)
+{
+    ASSERT_ARG(resource, resource);
+
+    // This happens for pages loaded from the back/forward cache.
+    if (resource->scriptObject)
+        return resource->scriptObject;
+
+    ASSERT(m_scriptContext);
+    ASSERT(m_scriptObject);
+    if (!m_scriptContext || !m_scriptObject)
+        return 0;
+
+    JSStringRef resourceString = JSStringCreateWithUTF8CString("Resource");
+    JSObjectRef resourceConstructor = JSValueToObject(m_scriptContext, JSObjectGetProperty(m_scriptContext, m_scriptObject, resourceString, 0), 0);
+    JSStringRelease(resourceString);
+
+    String urlString = resource->requestURL.url();
+    JSStringRef url = JSStringCreateWithCharacters(urlString.characters(), urlString.length());
+    JSValueRef urlValue = JSValueMakeString(m_scriptContext, url);
+    JSStringRelease(url);
+
+    urlString = resource->requestURL.host();
+    JSStringRef domain = JSStringCreateWithCharacters(urlString.characters(), urlString.length());
+    JSValueRef domainValue = JSValueMakeString(m_scriptContext, domain);
+    JSStringRelease(domain);
+
+    urlString = resource->requestURL.path();
+    JSStringRef path = JSStringCreateWithCharacters(urlString.characters(), urlString.length());
+    JSValueRef pathValue = JSValueMakeString(m_scriptContext, path);
+    JSStringRelease(path);
+
+    urlString = resource->requestURL.lastPathComponent();
+    JSStringRef lastPathComponent = JSStringCreateWithCharacters(urlString.characters(), urlString.length());
+    JSValueRef lastPathComponentValue = JSValueMakeString(m_scriptContext, lastPathComponent);
+    JSStringRelease(lastPathComponent);
+
+    JSValueRef identifier = JSValueMakeNumber(m_scriptContext, resource->identifier);
+    JSValueRef mainResource = JSValueMakeBoolean(m_scriptContext, m_mainResource == resource);
+    JSValueRef cached = JSValueMakeBoolean(m_scriptContext, resource->cached);
+
+    JSValueRef arguments[] = { scriptObjectForRequest(m_scriptContext, resource), urlValue, domainValue, pathValue, lastPathComponentValue, identifier, mainResource, cached };
+    JSObjectRef result = JSObjectCallAsConstructor(m_scriptContext, resourceConstructor, 8, arguments, 0);
+
+    resource->setScriptObject(m_scriptContext, result);
+
+    ASSERT(result);
+
+    JSStringRef addResourceString = JSStringCreateWithUTF8CString("addResource");
+    JSObjectRef addResourceFunction = JSValueToObject(m_scriptContext, JSObjectGetProperty(m_scriptContext, m_scriptObject, addResourceString, 0), 0);
+    JSStringRelease(addResourceString);
+
+    JSValueRef addArguments[] = { result };
+    JSObjectCallAsFunction(m_scriptContext, addResourceFunction, m_scriptObject, 1, addArguments, 0);
+
+    return result;
+}
+
+JSObjectRef InspectorController::addAndUpdateScriptResource(InspectorResource* resource)
+{
+    ASSERT_ARG(resource, resource);
+
+    JSObjectRef scriptResource = addScriptResource(resource);
+    updateScriptResourceResponse(resource);
+    updateScriptResource(resource, resource->length);
+    updateScriptResource(resource, resource->startTime, resource->responseReceivedTime, resource->endTime);
+    updateScriptResource(resource, resource->finished, resource->failed);
+    return scriptResource;
+}
+
+void InspectorController::removeScriptResource(InspectorResource* resource)
+{
+    ASSERT(m_scriptContext);
+    ASSERT(m_scriptObject);
+    if (!m_scriptContext || !m_scriptObject)
+        return;
+
+    ASSERT(resource);
+    ASSERT(resource->scriptObject);
+    if (!resource || !resource->scriptObject)
+        return;
+
+    JSStringRef removeResourceString = JSStringCreateWithUTF8CString("removeResource");
+    JSObjectRef removeResourceFunction = JSValueToObject(m_scriptContext, JSObjectGetProperty(m_scriptContext, m_scriptObject, removeResourceString, 0), 0);
+    JSStringRelease(removeResourceString);
+
+    JSValueRef arguments[] = { resource->scriptObject };
+    JSObjectCallAsFunction(m_scriptContext, removeResourceFunction, m_scriptObject, 1, arguments, 0);
+
+    resource->setScriptObject(0, 0);
+}
+
+static void updateResourceRequest(InspectorResource* resource, const ResourceRequest& request)
+{
+    resource->requestHeaderFields = request.httpHeaderFields();
+    resource->requestURL = request.url();
+}
+
+static void updateResourceResponse(InspectorResource* resource, const ResourceResponse& response)
+{
+    resource->expectedContentLength = response.expectedContentLength();
+    resource->mimeType = response.mimeType();
+    resource->responseHeaderFields = response.httpHeaderFields();
+    resource->responseStatusCode = response.httpStatusCode();
+    resource->suggestedFilename = response.suggestedFilename();
+    resource->textEncodingName = response.textEncodingName();
+}
+
+void InspectorController::updateScriptResourceRequest(InspectorResource* resource)
+{
+    ASSERT(resource->scriptObject);
+    ASSERT(m_scriptContext);
+    if (!resource->scriptObject || !m_scriptContext)
+        return;
+
+    String urlString = resource->requestURL.url();
+    JSStringRef url = JSStringCreateWithCharacters(urlString.characters(), urlString.length());
+    JSValueRef urlValue = JSValueMakeString(m_scriptContext, url);
+    JSStringRelease(url);
+
+    urlString = resource->requestURL.host();
+    JSStringRef domain = JSStringCreateWithCharacters(urlString.characters(), urlString.length());
+    JSValueRef domainValue = JSValueMakeString(m_scriptContext, domain);
+    JSStringRelease(domain);
+
+    urlString = resource->requestURL.path();
+    JSStringRef path = JSStringCreateWithCharacters(urlString.characters(), urlString.length());
+    JSValueRef pathValue = JSValueMakeString(m_scriptContext, path);
+    JSStringRelease(path);
+
+    urlString = resource->requestURL.lastPathComponent();
+    JSStringRef lastPathComponent = JSStringCreateWithCharacters(urlString.characters(), urlString.length());
+    JSValueRef lastPathComponentValue = JSValueMakeString(m_scriptContext, lastPathComponent);
+    JSStringRelease(lastPathComponent);
+
+    JSValueRef mainResourceValue = JSValueMakeBoolean(m_scriptContext, m_mainResource == resource);
+
+    JSStringRef propertyName = JSStringCreateWithUTF8CString("url");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, urlValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("domain");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, domainValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("path");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, pathValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("lastPathComponent");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, lastPathComponentValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("requestHeaders");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, scriptObjectForRequest(m_scriptContext, resource), kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("mainResource");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, mainResourceValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+}
+
+void InspectorController::updateScriptResourceResponse(InspectorResource* resource)
+{
+    ASSERT(resource->scriptObject);
+    ASSERT(m_scriptContext);
+    if (!resource->scriptObject || !m_scriptContext)
+        return;
+
+    JSStringRef mimeType = JSStringCreateWithCharacters(resource->mimeType.characters(), resource->mimeType.length());
+    JSValueRef mimeTypeValue = JSValueMakeString(m_scriptContext, mimeType);
+    JSStringRelease(mimeType);
+
+    JSStringRef suggestedFilename = JSStringCreateWithCharacters(resource->suggestedFilename.characters(), resource->suggestedFilename.length());
+    JSValueRef suggestedFilenameValue = JSValueMakeString(m_scriptContext, suggestedFilename);
+    JSStringRelease(suggestedFilename);
+
+    JSValueRef expectedContentLengthValue = JSValueMakeNumber(m_scriptContext, static_cast<double>(resource->expectedContentLength));
+    JSValueRef statusCodeValue = JSValueMakeNumber(m_scriptContext, resource->responseStatusCode);
+
+    JSStringRef propertyName = JSStringCreateWithUTF8CString("mimeType");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, mimeTypeValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("suggestedFilename");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, suggestedFilenameValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("expectedContentLength");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, expectedContentLengthValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("statusCode");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, statusCodeValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+    
+    propertyName = JSStringCreateWithUTF8CString("responseHeaders");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, scriptObjectForResponse(m_scriptContext, resource), kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    JSValueRef typeValue = JSValueMakeNumber(m_scriptContext, resource->type());
+    propertyName = JSStringCreateWithUTF8CString("type");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, typeValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+}
+
+void InspectorController::updateScriptResource(InspectorResource* resource, int length)
+{
+    ASSERT(resource->scriptObject);
+    ASSERT(m_scriptContext);
+    if (!resource->scriptObject || !m_scriptContext)
+        return;
+
+    JSValueRef lengthValue = JSValueMakeNumber(m_scriptContext, length);
+
+    JSStringRef propertyName = JSStringCreateWithUTF8CString("contentLength");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, lengthValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+}
+
+void InspectorController::updateScriptResource(InspectorResource* resource, bool finished, bool failed)
+{
+    ASSERT(resource->scriptObject);
+    ASSERT(m_scriptContext);
+    if (!resource->scriptObject || !m_scriptContext)
+        return;
+
+    JSValueRef failedValue = JSValueMakeBoolean(m_scriptContext, failed);
+    JSValueRef finishedValue = JSValueMakeBoolean(m_scriptContext, finished);
+
+    JSStringRef propertyName = JSStringCreateWithUTF8CString("failed");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, failedValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("finished");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, finishedValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+}
+
+void InspectorController::updateScriptResource(InspectorResource* resource, double startTime, double responseReceivedTime, double endTime)
+{
+    ASSERT(resource->scriptObject);
+    ASSERT(m_scriptContext);
+    if (!resource->scriptObject || !m_scriptContext)
+        return;
+
+    JSValueRef startTimeValue = JSValueMakeNumber(m_scriptContext, startTime);
+    JSValueRef responseReceivedTimeValue = JSValueMakeNumber(m_scriptContext, responseReceivedTime);
+    JSValueRef endTimeValue = JSValueMakeNumber(m_scriptContext, endTime);
+
+    JSStringRef propertyName = JSStringCreateWithUTF8CString("startTime");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, startTimeValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("responseReceivedTime");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, responseReceivedTimeValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+
+    propertyName = JSStringCreateWithUTF8CString("endTime");
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, propertyName, endTimeValue, kJSPropertyAttributeNone, 0);
+    JSStringRelease(propertyName);
+}
+
+void InspectorController::populateScriptResources()
+{
+    ASSERT(m_scriptContext);
+    if (!m_scriptContext)
+        return;
+
+    clearScriptResources();
+    clearScriptConsoleMessages();
+    clearNetworkTimeline();
+
+    ResourcesMap::iterator resourcesEnd = m_resources.end();
+    for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it)
+        addAndUpdateScriptResource(it->second.get());
+
+    unsigned messageCount = m_consoleMessages.size();
+    for (unsigned i = 0; i < messageCount; ++i)
+        addScriptConsoleMessage(m_consoleMessages[i]);
+}
+
+void InspectorController::addScriptConsoleMessage(const ConsoleMessage* message)
+{
+    ASSERT_ARG(message, message);
+
+    JSStringRef messageConstructorString = JSStringCreateWithUTF8CString("ConsoleMessage");
+    JSObjectRef messageConstructor = JSValueToObject(m_scriptContext, JSObjectGetProperty(m_scriptContext, m_scriptObject, messageConstructorString, 0), 0);
+    JSStringRelease(messageConstructorString);
+
+    JSStringRef addMessageString = JSStringCreateWithUTF8CString("addMessageToConsole");
+    JSObjectRef addMessage = JSValueToObject(m_scriptContext, JSObjectGetProperty(m_scriptContext, m_scriptObject, addMessageString, 0), 0);
+    JSStringRelease(addMessageString);
+
+    JSValueRef sourceValue = JSValueMakeNumber(m_scriptContext, message->source);
+    JSValueRef levelValue = JSValueMakeNumber(m_scriptContext, message->level);
+    JSStringRef messageString = JSStringCreateWithCharacters(message->message.characters(), message->message.length());
+    JSValueRef messageValue = JSValueMakeString(m_scriptContext, messageString);
+    JSValueRef lineValue = JSValueMakeNumber(m_scriptContext, message->line);
+    JSStringRef urlString = JSStringCreateWithCharacters(message->url.characters(), message->url.length());
+    JSValueRef urlValue = JSValueMakeString(m_scriptContext, urlString);
+
+    JSValueRef args[] = { sourceValue, levelValue, messageValue, lineValue, urlValue };
+    JSObjectRef messageObject = JSObjectCallAsConstructor(m_scriptContext, messageConstructor, 5, args, 0);
+    JSStringRelease(messageString);
+    JSStringRelease(urlString);
+
+    JSObjectCallAsFunction(m_scriptContext, addMessage, m_scriptObject, 1, &messageObject, 0);
+}
+
+static void callClearFunction(JSContextRef context, JSObjectRef thisObject, const char* functionName)
+{
+    ASSERT_ARG(context, context);
+    ASSERT_ARG(thisObject, thisObject);
+
+    JSStringRef string = JSStringCreateWithUTF8CString(functionName);
+    JSObjectRef function = JSValueToObject(context, JSObjectGetProperty(context, thisObject, string, 0), 0);
+    JSStringRelease(string);
+
+    JSObjectCallAsFunction(context, function, thisObject, 0, 0, 0);
+}
+
+void InspectorController::clearScriptResources()
+{
+    if (!m_scriptContext || !m_scriptObject)
+        return;
+
+    ResourcesMap::iterator resourcesEnd = m_resources.end();
+    for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it) {
+        InspectorResource* resource = it->second.get();
+        resource->setScriptObject(0, 0);
+    }
+
+    callClearFunction(m_scriptContext, m_scriptObject, "clearResources");
+}
+
+void InspectorController::clearScriptConsoleMessages()
+{
+    if (!m_scriptContext || !m_scriptObject)
+        return;
+
+    callClearFunction(m_scriptContext, m_scriptObject, "clearConsoleMessages");
+}
+
+void InspectorController::clearNetworkTimeline()
+{
+    if (!m_scriptContext || !m_scriptObject)
+        return;
+
+    callClearFunction(m_scriptContext, m_scriptObject, "clearNetworkTimeline");
+}
+
+void InspectorController::pruneResources(ResourcesMap* resourceMap, DocumentLoader* loaderToKeep)
+{
+    ASSERT_ARG(resourceMap, resourceMap);
+
+    ResourcesMap mapCopy(*resourceMap);
+    ResourcesMap::iterator end = mapCopy.end();
+    for (ResourcesMap::iterator it = mapCopy.begin(); it != end; ++it) {
+        InspectorResource* resource = (*it).second.get();
+        if (resource == m_mainResource)
+            continue;
+
+        if (!loaderToKeep || resource->loader != loaderToKeep) {
+            removeResource(resource);
+            if (windowVisible() && resource->scriptObject)
+                removeScriptResource(resource);
+        }
+    }
+}
+
+void InspectorController::didCommitLoad(DocumentLoader* loader)
+{
+    if (!enabled())
+        return;
+
+    if (loader->frame() == m_inspectedPage->mainFrame()) {
+        ASSERT(m_mainResource);
+        // FIXME: Should look into asserting that m_mainResource->loader == loader here.
+
+        m_client->inspectedURLChanged(loader->URL().url());
+        deleteAllValues(m_consoleMessages);
+        m_consoleMessages.clear();
+        if (windowVisible()) {
+            clearScriptConsoleMessages();
+            clearNetworkTimeline();
+
+            // We don't add the main resource until its load is committed. This
+            // is needed to keep the load for a user-entered URL from showing
+            // up in the list of resources for the page they are navigating
+            // away from.
+            addAndUpdateScriptResource(m_mainResource.get());
+        }
+    }
+
+    for (Frame* frame = loader->frame(); frame; frame = frame->tree()->traverseNext(loader->frame()))
+        if (ResourcesMap* resourceMap = m_frameResources.get(frame))
+            pruneResources(resourceMap, loader);
+}
+
+void InspectorController::frameDetachedFromParent(Frame* frame)
+{
+    if (!enabled())
+        return;
+    if (ResourcesMap* resourceMap = m_frameResources.get(frame))
+        removeAllResources(resourceMap);
+}
+
+void InspectorController::addResource(InspectorResource* resource)
+{
+    m_resources.set(resource->identifier, resource);
+
+    Frame* frame = resource->frame.get();
+    ResourcesMap* resourceMap = m_frameResources.get(frame);
+    if (resourceMap)
+        resourceMap->set(resource->identifier, resource);
+    else {
+        resourceMap = new ResourcesMap;
+        resourceMap->set(resource->identifier, resource);
+        m_frameResources.set(frame, resourceMap);
+    }
+}
+
+void InspectorController::removeResource(InspectorResource* resource)
+{
+    m_resources.remove(resource->identifier);
+
+    Frame* frame = resource->frame.get();
+    ResourcesMap* resourceMap = m_frameResources.get(frame);
+    if (!resourceMap) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    resourceMap->remove(resource->identifier);
+    if (resourceMap->isEmpty()) {
+        m_frameResources.remove(frame);
+        delete resourceMap;
+    }
+}
+
+void InspectorController::didLoadResourceFromMemoryCache(DocumentLoader* loader, const ResourceRequest& request, const ResourceResponse& response, int length)
+{
+    if (!enabled())
+        return;
+
+    InspectorResource* resource = new InspectorResource(m_nextIdentifier--, loader, loader->frame());
+    resource->finished = true;
+
+    updateResourceRequest(resource, request);
+    updateResourceResponse(resource, response);
+
+    resource->length = length;
+    resource->cached = true;
+    resource->startTime = currentTime();
+    resource->responseReceivedTime = resource->startTime;
+    resource->endTime = resource->startTime;
+
+    if (loader->frame() == m_inspectedPage->mainFrame() && request.url() == loader->requestURL())
+        m_mainResource = resource;
+
+    addResource(resource);
+
+    if (windowVisible())
+        addAndUpdateScriptResource(resource);
+}
+
+void InspectorController::identifierForInitialRequest(unsigned long identifier, DocumentLoader* loader, const ResourceRequest& request)
+{
+    if (!enabled())
+        return;
+
+    InspectorResource* resource = new InspectorResource(identifier, loader, loader->frame());
+
+    updateResourceRequest(resource, request);
+
+    if (loader->frame() == m_inspectedPage->mainFrame() && request.url() == loader->requestURL())
+        m_mainResource = resource;
+
+    addResource(resource);
+}
+
+void InspectorController::willSendRequest(DocumentLoader* loader, unsigned long identifier, ResourceRequest& request, const ResourceResponse& redirectResponse)
+{
+    if (!enabled())
+        return;
+
+    InspectorResource* resource = m_resources.get(identifier).get();
+    if (!resource)
+        return;
+
+    resource->startTime = currentTime();
+
+    if (!redirectResponse.isNull()) {
+        updateResourceRequest(resource, request);
+        updateResourceResponse(resource, redirectResponse);
+    }
+
+    if (resource != m_mainResource && windowVisible()) {
+        if (!resource->scriptObject)
+            addScriptResource(resource);
+        else
+            updateScriptResourceRequest(resource);
+
+        updateScriptResource(resource, resource->startTime, resource->responseReceivedTime, resource->endTime);
+
+        if (!redirectResponse.isNull())
+            updateScriptResourceResponse(resource);
+    }
+}
+
+void InspectorController::didReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse& response)
+{
+    if (!enabled())
+        return;
+
+    InspectorResource* resource = m_resources.get(identifier).get();
+    if (!resource)
+        return;
+
+    updateResourceResponse(resource, response);
+
+    resource->responseReceivedTime = currentTime();
+
+    if (windowVisible() && resource->scriptObject) {
+        updateScriptResourceResponse(resource);
+        updateScriptResource(resource, resource->startTime, resource->responseReceivedTime, resource->endTime);
+    }
+}
+
+void InspectorController::didReceiveContentLength(DocumentLoader*, unsigned long identifier, int lengthReceived)
+{
+    if (!enabled())
+        return;
+
+    InspectorResource* resource = m_resources.get(identifier).get();
+    if (!resource)
+        return;
+
+    resource->length += lengthReceived;
+
+    if (windowVisible() && resource->scriptObject)
+        updateScriptResource(resource, resource->length);
+}
+
+void InspectorController::didFinishLoading(DocumentLoader* loader, unsigned long identifier)
+{
+    if (!enabled())
+        return;
+
+    RefPtr<InspectorResource> resource = m_resources.get(identifier);
+    if (!resource)
+        return;
+
+    removeResource(resource.get());
+
+    resource->finished = true;
+    resource->endTime = currentTime();
+
+    addResource(resource.get());
+
+    if (windowVisible() && resource->scriptObject) {
+        updateScriptResource(resource.get(), resource->startTime, resource->responseReceivedTime, resource->endTime);
+        updateScriptResource(resource.get(), resource->finished);
+    }
+}
+
+void InspectorController::didFailLoading(DocumentLoader* loader, unsigned long identifier, const ResourceError& /*error*/)
+{
+    if (!enabled())
+        return;
+
+    RefPtr<InspectorResource> resource = m_resources.get(identifier);
+    if (!resource)
+        return;
+
+    removeResource(resource.get());
+
+    resource->finished = true;
+    resource->failed = true;
+    resource->endTime = currentTime();
+
+    addResource(resource.get());
+
+    if (windowVisible() && resource->scriptObject) {
+        updateScriptResource(resource.get(), resource->startTime, resource->responseReceivedTime, resource->endTime);
+        updateScriptResource(resource.get(), resource->finished, resource->failed);
+    }
+}
+
+} // namespace WebCore