auto import from //depot/cupcake/@135843

1 files changed, 2841 insertions, 0 deletions

diff --git a/WebCore/inspector/InspectorController.cpp b/WebCore/inspector/InspectorController.cpp
new file mode 100644
index 0000000..8476b98
--- /dev/null
+++ b/WebCore/inspector/InspectorController.cpp
@@ -0,0 +1,2841 @@
+/*
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.com>
+ *
+ * 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 "Console.h"
+#include "DOMWindow.h"
+#include "DocLoader.h"
+#include "Document.h"
+#include "DocumentLoader.h"
+#include "Element.h"
+#include "FloatConversion.h"
+#include "FloatRect.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "FrameTree.h"
+#include "FrameView.h"
+#include "GraphicsContext.h"
+#include "HitTestResult.h"
+#include "HTMLFrameOwnerElement.h"
+#include "InspectorClient.h"
+#include "JSDOMWindow.h"
+#include "JSInspectedObjectWrapper.h"
+#include "JSInspectorCallbackWrapper.h"
+#include "JSNode.h"
+#include "JSRange.h"
+#include "JavaScriptProfile.h"
+#include "Page.h"
+#include "Range.h"
+#include "ResourceRequest.h"
+#include "ResourceResponse.h"
+#include "Settings.h"
+#include "SharedBuffer.h"
+#include "SystemTime.h"
+#include "TextEncoding.h"
+#include "TextIterator.h"
+#include "ScriptController.h"
+#include <JavaScriptCore/APICast.h>
+#include <JavaScriptCore/JSRetainPtr.h>
+#include <JavaScriptCore/JSStringRef.h>
+#include <JavaScriptCore/OpaqueJSString.h>
+#include <runtime/JSLock.h>
+#include <kjs/ustring.h>
+#include <runtime/CollectorHeapIterator.h>
+#include <profiler/Profile.h>
+#include <profiler/Profiler.h>
+#include <wtf/RefCounted.h>
+
+#if ENABLE(DATABASE)
+#include "Database.h"
+#include "JSDatabase.h"
+#endif
+
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+#include "JavaScriptCallFrame.h"
+#include "JavaScriptDebugServer.h"
+#include "JSJavaScriptCallFrame.h"
+#endif
+
+using namespace JSC;
+using namespace std;
+
+namespace WebCore {
+
+static const char* const UserInitiatedProfileName = "org.webkit.profiles.user-initiated";
+
+static JSRetainPtr<JSStringRef> jsStringRef(const char* str)
+{
+    return JSRetainPtr<JSStringRef>(Adopt, JSStringCreateWithUTF8CString(str));
+}
+
+static JSRetainPtr<JSStringRef> jsStringRef(const SourceCode& str)
+{
+    return JSRetainPtr<JSStringRef>(Adopt, JSStringCreateWithCharacters(str.data(), str.length()));
+}
+
+static JSRetainPtr<JSStringRef> jsStringRef(const String& str)
+{
+    return JSRetainPtr<JSStringRef>(Adopt, JSStringCreateWithCharacters(str.characters(), str.length()));
+}
+
+static JSRetainPtr<JSStringRef> jsStringRef(const UString& str)
+{
+    return JSRetainPtr<JSStringRef>(Adopt, OpaqueJSString::create(str).releaseRef());
+}
+
+static String toString(JSContextRef context, JSValueRef value, JSValueRef* exception)
+{
+    ASSERT_ARG(value, value);
+    if (!value)
+        return String();
+    JSRetainPtr<JSStringRef> scriptString(Adopt, JSValueToStringCopy(context, value, exception));
+    if (exception && *exception)
+        return String();
+    return String(JSStringGetCharactersPtr(scriptString.get()), JSStringGetLength(scriptString.get()));
+}
+
+#define HANDLE_EXCEPTION(context, exception) handleException((context), (exception), __LINE__)
+
+JSValueRef InspectorController::callSimpleFunction(JSContextRef context, JSObjectRef thisObject, const char* functionName) const
+{
+    JSValueRef exception = 0;
+    return callFunction(context, thisObject, functionName, 0, 0, exception);
+}
+
+JSValueRef InspectorController::callFunction(JSContextRef context, JSObjectRef thisObject, const char* functionName, size_t argumentCount, const JSValueRef arguments[], JSValueRef& exception) const
+{
+    ASSERT_ARG(context, context);
+    ASSERT_ARG(thisObject, thisObject);
+
+    if (exception)
+        return JSValueMakeUndefined(context);
+
+    JSValueRef functionProperty = JSObjectGetProperty(context, thisObject, jsStringRef(functionName).get(), &exception);
+    if (HANDLE_EXCEPTION(context, exception))
+        return JSValueMakeUndefined(context);
+
+    JSObjectRef function = JSValueToObject(context, functionProperty, &exception);
+    if (HANDLE_EXCEPTION(context, exception))
+        return JSValueMakeUndefined(context);
+
+    JSValueRef result = JSObjectCallAsFunction(context, function, thisObject, argumentCount, arguments, &exception);
+    if (HANDLE_EXCEPTION(context, exception))
+        return JSValueMakeUndefined(context);
+
+    return result;
+}
+
+// ConsoleMessage Struct
+
+struct ConsoleMessage {
+    ConsoleMessage(MessageSource s, MessageLevel l, const String& m, unsigned li, const String& u, unsigned g)
+        : source(s)
+        , level(l)
+        , message(m)
+        , line(li)
+        , url(u)
+        , groupLevel(g)
+        , repeatCount(1)
+    {
+    }
+
+    ConsoleMessage(MessageSource s, MessageLevel l, ExecState* exec, const ArgList& args, unsigned li, const String& u, unsigned g)
+        : source(s)
+        , level(l)
+        , wrappedArguments(args.size())
+        , line(li)
+        , url(u)
+        , groupLevel(g)
+        , repeatCount(1)
+    {
+        JSLock lock(false);
+        for (unsigned i = 0; i < args.size(); ++i)
+            wrappedArguments[i] = JSInspectedObjectWrapper::wrap(exec, args.at(exec, i));
+    }
+    
+    bool isEqual(ExecState* exec, ConsoleMessage* msg) const
+    {
+        if (msg->wrappedArguments.size() != this->wrappedArguments.size() ||
+           (!exec && msg->wrappedArguments.size()))
+            return false;
+        
+        for (size_t i = 0; i < msg->wrappedArguments.size(); ++i) {
+            ASSERT_ARG(exec, exec);
+            if (!JSValueIsEqual(toRef(exec), toRef(msg->wrappedArguments[i].get()), toRef(this->wrappedArguments[i].get()), 0))
+                return false;
+        }
+    
+        return msg->source == this->source
+            && msg->level == this->level
+            && msg->message == this->message
+            && msg->line == this->line
+            && msg->url == this->url
+            && msg->groupLevel == this->groupLevel;
+    }
+
+    MessageSource source;
+    MessageLevel level;
+    String message;
+    Vector<ProtectedPtr<JSValue> > wrappedArguments;
+    unsigned line;
+    String url;
+    unsigned groupLevel;
+    unsigned repeatCount;
+};
+
+// XMLHttpRequestResource Class
+
+struct XMLHttpRequestResource {
+    XMLHttpRequestResource(JSC::UString& sourceString)
+    {
+        JSC::JSLock lock(false);
+        this->sourceString = sourceString.rep();
+    }
+
+    ~XMLHttpRequestResource()
+    {
+        JSC::JSLock lock(false);
+        sourceString.clear();
+    }
+
+    RefPtr<JSC::UString::Rep> sourceString;
+};
+
+// InspectorResource Struct
+
+struct InspectorResource : public RefCounted<InspectorResource> {
+    // Keep these in sync with WebInspector.Resource.Type
+    enum Type {
+        Doc,
+        Stylesheet,
+        Image,
+        Font,
+        Script,
+        XHR,
+        Media,
+        Other
+    };
+
+    static PassRefPtr<InspectorResource> create(long long identifier, DocumentLoader* documentLoader, Frame* frame)
+    {
+        return adoptRef(new InspectorResource(identifier, documentLoader, frame));
+    }
+    
+    ~InspectorResource()
+    {
+        setScriptObject(0, 0);
+    }
+
+    Type type() const
+    {
+        if (xmlHttpRequestResource)
+            return XHR;
+
+        if (requestURL == loader->requestURL())
+            return Doc;
+
+        if (loader->frameLoader() && requestURL == loader->frameLoader()->iconURL())
+            return Image;
+
+        CachedResource* cachedResource = frame->document()->docLoader()->cachedResource(requestURL.string());
+        if (!cachedResource)
+            return Other;
+
+        switch (cachedResource->type()) {
+            case CachedResource::ImageResource:
+                return Image;
+            case CachedResource::FontResource:
+                return Font;
+            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);
+    }
+
+    void setXMLHttpRequestProperties(JSC::UString& data)
+    {
+        xmlHttpRequestResource.set(new XMLHttpRequestResource(data));
+    }
+    
+    String sourceString() const
+     {
+         if (xmlHttpRequestResource)
+            return JSC::UString(xmlHttpRequestResource->sourceString);
+
+        RefPtr<SharedBuffer> buffer;
+        String textEncodingName;
+
+        if (requestURL == loader->requestURL()) {
+            buffer = loader->mainResourceData();
+            textEncodingName = frame->document()->inputEncoding();
+        } else {
+            CachedResource* cachedResource = frame->document()->docLoader()->cachedResource(requestURL.string());
+            if (!cachedResource)
+                return String();
+
+            buffer = cachedResource->data();
+            textEncodingName = cachedResource->encoding();
+        }
+
+        if (!buffer)
+            return String();
+
+        TextEncoding encoding(textEncodingName);
+        if (!encoding.isValid())
+            encoding = WindowsLatin1Encoding();
+        return encoding.decode(buffer->data(), buffer->size());
+     }
+
+    long long identifier;
+    RefPtr<DocumentLoader> loader;
+    RefPtr<Frame> frame;
+    OwnPtr<XMLHttpRequestResource> xmlHttpRequestResource;
+    KURL requestURL;
+    HTTPHeaderMap requestHeaderFields;
+    HTTPHeaderMap responseHeaderFields;
+    String mimeType;
+    String suggestedFilename;
+    JSContextRef scriptContext;
+    JSObjectRef scriptObject;
+    long long expectedContentLength;
+    bool cached;
+    bool finished;
+    bool failed;
+    int length;
+    int responseStatusCode;
+    double startTime;
+    double responseReceivedTime;
+    double endTime;
+
+protected:
+    InspectorResource(long long identifier, DocumentLoader* documentLoader, Frame* frame)
+        : identifier(identifier)
+        , loader(documentLoader)
+        , frame(frame)
+        , xmlHttpRequestResource(0)
+        , 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)
+    {
+    }
+};
+
+// InspectorDatabaseResource Struct
+
+#if ENABLE(DATABASE)
+struct InspectorDatabaseResource : public RefCounted<InspectorDatabaseResource> {
+    static PassRefPtr<InspectorDatabaseResource> create(Database* database, const String& domain, const String& name, const String& version)
+    {
+        return adoptRef(new InspectorDatabaseResource(database, domain, name, version));
+    }
+
+    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);
+    }
+
+    RefPtr<Database> database;
+    String domain;
+    String name;
+    String version;
+    JSContextRef scriptContext;
+    JSObjectRef scriptObject;
+    
+private:
+    InspectorDatabaseResource(Database* database, const String& domain, const String& name, const String& version)
+        : database(database)
+        , domain(domain)
+        , name(name)
+        , version(version)
+        , scriptContext(0)
+        , scriptObject(0)
+    {
+    }
+};
+#endif
+
+// JavaScript Callbacks
+
+#define SIMPLE_INSPECTOR_CALLBACK(jsFunction, inspectorControllerMethod) \
+static JSValueRef jsFunction(JSContextRef ctx, JSObjectRef, JSObjectRef thisObject, size_t, const JSValueRef[], JSValueRef*) \
+{ \
+    if (InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject))) \
+        controller->inspectorControllerMethod(); \
+    return JSValueMakeUndefined(ctx); \
+}
+
+SIMPLE_INSPECTOR_CALLBACK(hideDOMNodeHighlight, hideHighlight);
+SIMPLE_INSPECTOR_CALLBACK(loaded, scriptObjectReady);
+SIMPLE_INSPECTOR_CALLBACK(unloading, close);
+SIMPLE_INSPECTOR_CALLBACK(attach, attachWindow);
+SIMPLE_INSPECTOR_CALLBACK(detach, detachWindow);
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+SIMPLE_INSPECTOR_CALLBACK(enableDebugger, enableDebugger);
+SIMPLE_INSPECTOR_CALLBACK(disableDebugger, disableDebugger);
+SIMPLE_INSPECTOR_CALLBACK(pauseInDebugger, pauseInDebugger);
+SIMPLE_INSPECTOR_CALLBACK(resumeDebugger, resumeDebugger);
+SIMPLE_INSPECTOR_CALLBACK(stepOverStatementInDebugger, stepOverStatementInDebugger);
+SIMPLE_INSPECTOR_CALLBACK(stepIntoStatementInDebugger, stepIntoStatementInDebugger);
+SIMPLE_INSPECTOR_CALLBACK(stepOutOfFunctionInDebugger, stepOutOfFunctionInDebugger);
+#endif
+SIMPLE_INSPECTOR_CALLBACK(closeWindow, closeWindow);
+SIMPLE_INSPECTOR_CALLBACK(clearMessages, clearConsoleMessages);
+SIMPLE_INSPECTOR_CALLBACK(startProfiling, startUserInitiatedProfilingSoon);
+SIMPLE_INSPECTOR_CALLBACK(stopProfiling, stopUserInitiatedProfiling);
+SIMPLE_INSPECTOR_CALLBACK(enableProfiler, enableProfiler);
+SIMPLE_INSPECTOR_CALLBACK(disableProfiler, disableProfiler);
+SIMPLE_INSPECTOR_CALLBACK(toggleNodeSearch, toggleSearchForNodeInPage);
+
+#define BOOL_INSPECTOR_CALLBACK(jsFunction, inspectorControllerMethod) \
+static JSValueRef jsFunction(JSContextRef ctx, JSObjectRef, JSObjectRef thisObject, size_t, const JSValueRef[], JSValueRef*) \
+{ \
+    if (InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject))) \
+        return JSValueMakeBoolean(ctx, controller->inspectorControllerMethod()); \
+    return JSValueMakeUndefined(ctx); \
+}
+
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+BOOL_INSPECTOR_CALLBACK(debuggerEnabled, debuggerEnabled);
+BOOL_INSPECTOR_CALLBACK(pauseOnExceptions, pauseOnExceptions);
+#endif
+BOOL_INSPECTOR_CALLBACK(profilerEnabled, profilerEnabled);
+BOOL_INSPECTOR_CALLBACK(isWindowVisible, windowVisible);
+BOOL_INSPECTOR_CALLBACK(searchingForNode, searchingForNodeInPage);
+
+static bool addSourceToFrame(const String& mimeType, const String& source, Node* frameNode)
+{
+    ASSERT_ARG(frameNode, frameNode);
+
+    if (!frameNode)
+        return false;
+
+    if (!frameNode->attached()) {
+        ASSERT_NOT_REACHED();
+        return false;
+    }
+
+    ASSERT(frameNode->isElementNode());
+    if (!frameNode->isElementNode())
+        return false;
+
+    Element* element = static_cast<Element*>(frameNode);
+    ASSERT(element->isFrameOwnerElement());
+    if (!element->isFrameOwnerElement())
+        return false;
+
+    HTMLFrameOwnerElement* frameOwner = static_cast<HTMLFrameOwnerElement*>(element);
+    ASSERT(frameOwner->contentFrame());
+    if (!frameOwner->contentFrame())
+        return false;
+
+    FrameLoader* loader = frameOwner->contentFrame()->loader();
+
+    loader->setResponseMIMEType(mimeType);
+    loader->begin();
+    loader->write(source);
+    loader->end();
+
+    return true;
+}
+
+static JSValueRef addResourceSourceToFrame(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;
+
+    long long identifier = static_cast<long long>(JSValueToNumber(ctx, identifierValue, exception));
+    if (exception && *exception)
+        return undefined;
+
+    RefPtr<InspectorResource> resource = controller->resources().get(identifier);
+    ASSERT(resource);
+    if (!resource)
+        return undefined;
+
+    String sourceString = resource->sourceString();
+    if (sourceString.isEmpty())
+        return undefined;
+
+    bool successfullyAddedSource = addSourceToFrame(resource->mimeType, sourceString, toNode(toJS(arguments[1])));
+    return JSValueMakeBoolean(ctx, successfullyAddedSource);
+}
+
+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 < 3 || !controller)
+        return undefined;
+
+    JSValueRef mimeTypeValue = arguments[0];
+    if (!JSValueIsString(ctx, mimeTypeValue))
+        return undefined;
+
+    JSValueRef sourceValue = arguments[1];
+    if (!JSValueIsString(ctx, sourceValue))
+        return undefined;
+
+    String mimeType = toString(ctx, mimeTypeValue, exception);
+    if (mimeType.isEmpty())
+        return undefined;
+
+    String source = toString(ctx, sourceValue, exception);
+    if (source.isEmpty())
+        return undefined;
+
+    bool successfullyAddedSource = addSourceToFrame(mimeType, source, toNode(toJS(arguments[2])));
+    return JSValueMakeBoolean(ctx, successfullyAddedSource);
+}
+
+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;
+
+    long long identifier = static_cast<long long>(JSValueToNumber(ctx, identifierValue, exception));
+    if (exception && *exception)
+        return undefined;
+
+    RefPtr<InspectorResource> resource = controller->resources().get(identifier);
+    ASSERT(resource);
+    if (!resource)
+        return undefined;
+
+    Frame* frame = resource->frame.get();
+
+    Document* document = frame->document();
+    if (!document)
+        return undefined;
+
+    if (document->isPluginDocument() || document->isImageDocument() || document->isMediaDocument())
+        return undefined;
+
+    ExecState* exec = toJSDOMWindowShell(resource->frame.get())->window()->globalExec();
+
+    JSC::JSLock lock(false);
+    JSValueRef documentValue = toRef(JSInspectedObjectWrapper::wrap(exec, toJS(exec, 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;
+
+    JSQuarantinedObjectWrapper* wrapper = JSQuarantinedObjectWrapper::asWrapper(toJS(arguments[0]));
+    if (!wrapper)
+        return undefined;
+    Node* node = toNode(wrapper->unwrappedObject());
+    if (!node)
+        return undefined;
+
+    controller->highlight(node);
+
+    return undefined;
+}
+
+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);
+
+    String target = toString(ctx, arguments[1], exception);
+
+    JSObjectRef global = JSContextGetGlobalObject(ctx);
+
+    JSValueRef arrayProperty = JSObjectGetProperty(ctx, global, jsStringRef("Array").get(), exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef arrayConstructor = JSValueToObject(ctx, arrayProperty, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef result = JSObjectCallAsConstructor(ctx, arrayConstructor, 0, 0, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSValueRef pushProperty = JSObjectGetProperty(ctx, result, jsStringRef("push").get(), exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef pushFunction = JSValueToObject(ctx, pushProperty, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    RefPtr<Range> searchRange(rangeOfContents(node));
+
+    ExceptionCode ec = 0;
+    do {
+        RefPtr<Range> resultRange(findPlainText(searchRange.get(), target, true, false));
+        if (resultRange->collapsed(ec))
+            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;
+
+        JSC::JSLock lock(false);
+        JSValueRef arg0 = toRef(toJS(toJS(ctx), resultRange.get()));
+        JSObjectCallAsFunction(ctx, pushFunction, result, 1, &arg0, exception);
+        if (exception && *exception)
+            return JSValueMakeUndefined(ctx);
+
+        setStart(searchRange.get(), newStart);
+    } while (true);
+
+    return result;
+}
+
+#if ENABLE(DATABASE)
+static JSValueRef databaseTableNames(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 < 1)
+        return JSValueMakeUndefined(ctx);
+
+    JSQuarantinedObjectWrapper* wrapper = JSQuarantinedObjectWrapper::asWrapper(toJS(arguments[0]));
+    if (!wrapper)
+        return JSValueMakeUndefined(ctx);
+
+    Database* database = toDatabase(wrapper->unwrappedObject());
+    if (!database)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef global = JSContextGetGlobalObject(ctx);
+
+    JSValueRef arrayProperty = JSObjectGetProperty(ctx, global, jsStringRef("Array").get(), exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef arrayConstructor = JSValueToObject(ctx, arrayProperty, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef result = JSObjectCallAsConstructor(ctx, arrayConstructor, 0, 0, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSValueRef pushProperty = JSObjectGetProperty(ctx, result, jsStringRef("push").get(), exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef pushFunction = JSValueToObject(ctx, pushProperty, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    Vector<String> tableNames = database->tableNames();
+    unsigned length = tableNames.size();
+    for (unsigned i = 0; i < length; ++i) {
+        String tableName = tableNames[i];
+        JSValueRef tableNameValue = JSValueMakeString(ctx, jsStringRef(tableName).get());
+
+        JSValueRef pushArguments[] = { tableNameValue };
+        JSObjectCallAsFunction(ctx, pushFunction, result, 1, pushArguments, exception);
+        if (exception && *exception)
+            return JSValueMakeUndefined(ctx);
+    }
+
+    return result;
+}
+#endif
+
+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);
+
+    JSDOMWindow* inspectedWindow = toJSDOMWindow(controller->inspectedPage()->mainFrame());
+    JSLock lock(false);
+    return toRef(JSInspectedObjectWrapper::wrap(inspectedWindow->globalExec(), inspectedWindow));
+}
+
+static JSValueRef setting(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);
+
+    JSValueRef keyValue = arguments[0];
+    if (!JSValueIsString(ctx, keyValue))
+        return JSValueMakeUndefined(ctx);
+
+    const InspectorController::Setting& setting = controller->setting(toString(ctx, keyValue, exception));
+
+    switch (setting.type()) {
+        default:
+        case InspectorController::Setting::NoType:
+            return JSValueMakeUndefined(ctx);
+        case InspectorController::Setting::StringType:
+            return JSValueMakeString(ctx, jsStringRef(setting.string()).get());
+        case InspectorController::Setting::DoubleType:
+            return JSValueMakeNumber(ctx, setting.doubleValue());
+        case InspectorController::Setting::IntegerType:
+            return JSValueMakeNumber(ctx, setting.integerValue());
+        case InspectorController::Setting::BooleanType:
+            return JSValueMakeBoolean(ctx, setting.booleanValue());
+        case InspectorController::Setting::StringVectorType: {
+            Vector<JSValueRef> stringValues;
+            const Vector<String>& strings = setting.stringVector();
+            const unsigned length = strings.size();
+            for (unsigned i = 0; i < length; ++i)
+                stringValues.append(JSValueMakeString(ctx, jsStringRef(strings[i]).get()));
+
+            JSObjectRef stringsArray = JSObjectMakeArray(ctx, stringValues.size(), stringValues.data(), exception);
+            if (exception && *exception)
+                return JSValueMakeUndefined(ctx);
+            return stringsArray;
+        }
+    }
+}
+
+static JSValueRef setSetting(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);
+
+    JSValueRef keyValue = arguments[0];
+    if (!JSValueIsString(ctx, keyValue))
+        return JSValueMakeUndefined(ctx);
+
+    InspectorController::Setting setting;
+
+    JSValueRef value = arguments[1];
+    switch (JSValueGetType(ctx, value)) {
+        default:
+        case kJSTypeUndefined:
+        case kJSTypeNull:
+            // Do nothing. The setting is already NoType.
+            ASSERT(setting.type() == InspectorController::Setting::NoType);
+            break;
+        case kJSTypeString:
+            setting.set(toString(ctx, value, exception));
+            break;
+        case kJSTypeNumber:
+            setting.set(JSValueToNumber(ctx, value, exception));
+            break;
+        case kJSTypeBoolean:
+            setting.set(JSValueToBoolean(ctx, value));
+            break;
+        case kJSTypeObject: {
+            JSObjectRef object = JSValueToObject(ctx, value, 0);
+            JSValueRef lengthValue = JSObjectGetProperty(ctx, object, jsStringRef("length").get(), exception);
+            if (exception && *exception)
+                return JSValueMakeUndefined(ctx);
+
+            Vector<String> strings;
+            const unsigned length = static_cast<unsigned>(JSValueToNumber(ctx, lengthValue, 0));
+            for (unsigned i = 0; i < length; ++i) {
+                JSValueRef itemValue = JSObjectGetPropertyAtIndex(ctx, object, i, exception);
+                if (exception && *exception)
+                    return JSValueMakeUndefined(ctx);
+                strings.append(toString(ctx, itemValue, exception));
+                if (exception && *exception)
+                    return JSValueMakeUndefined(ctx);
+            }
+
+            setting.set(strings);
+            break;
+        }
+    }
+
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    controller->setSetting(toString(ctx, keyValue, exception), setting);
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef localizedStrings(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);
+
+    String url = controller->localizedStringsURL();
+    if (url.isNull())
+        return JSValueMakeNull(ctx);
+
+    return JSValueMakeString(ctx, jsStringRef(url).get());
+}
+
+static JSValueRef platform(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments[]*/, JSValueRef* /*exception*/)
+{
+#if PLATFORM(MAC)
+#ifdef BUILDING_ON_TIGER
+    static const String platform = "mac-tiger";
+#else
+    static const String platform = "mac-leopard";
+#endif
+#elif PLATFORM(WIN_OS)
+    static const String platform = "windows";
+#elif PLATFORM(QT)
+    static const String platform = "qt";
+#elif PLATFORM(GTK)
+    static const String platform = "gtk";
+#elif PLATFORM(WX)
+    static const String platform = "wx";
+#else
+    static const String platform = "unknown";
+#endif
+
+    JSValueRef platformValue = JSValueMakeString(ctx, jsStringRef(platform).get());
+
+    return platformValue;
+}
+
+static JSValueRef moveByUnrestricted(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)
+        return JSValueMakeUndefined(ctx);
+
+    double x = JSValueToNumber(ctx, arguments[0], exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    double y = JSValueToNumber(ctx, arguments[1], exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    controller->moveWindowBy(narrowPrecisionToFloat(x), narrowPrecisionToFloat(y));
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef setAttachedWindowHeight(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 < 1)
+        return JSValueMakeUndefined(ctx);
+
+    unsigned height = static_cast<unsigned>(JSValueToNumber(ctx, arguments[0], exception));
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    controller->setAttachedWindowHeight(height);
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef wrapCallback(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 < 1)
+        return JSValueMakeUndefined(ctx);
+
+    JSLock lock(false);
+    return toRef(JSInspectorCallbackWrapper::wrap(toJS(ctx), toJS(arguments[0])));
+}
+
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+static JSValueRef currentCallFrame(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);
+
+    JavaScriptCallFrame* callFrame = controller->currentCallFrame();
+    if (!callFrame || !callFrame->isValid())
+        return JSValueMakeNull(ctx);
+
+    ExecState* globalExec = callFrame->scopeChain()->globalObject()->globalExec();
+
+    JSLock lock(false);
+    return toRef(JSInspectedObjectWrapper::wrap(globalExec, toJS(toJS(ctx), callFrame)));
+}
+
+static JSValueRef setPauseOnExceptions(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 < 1)
+        return JSValueMakeUndefined(ctx);
+
+    controller->setPauseOnExceptions(JSValueToBoolean(ctx, arguments[0]));
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef addBreakpoint(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)
+        return JSValueMakeUndefined(ctx);
+
+    double sourceID = JSValueToNumber(ctx, arguments[0], exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    double lineNumber = JSValueToNumber(ctx, arguments[1], exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    controller->addBreakpoint(static_cast<int>(sourceID), static_cast<unsigned>(lineNumber));
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef removeBreakpoint(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)
+        return JSValueMakeUndefined(ctx);
+
+    double sourceID = JSValueToNumber(ctx, arguments[0], exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    double lineNumber = JSValueToNumber(ctx, arguments[1], exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    controller->removeBreakpoint(static_cast<int>(sourceID), static_cast<unsigned>(lineNumber));
+
+    return JSValueMakeUndefined(ctx);
+}
+#endif
+
+static JSValueRef profiles(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);
+
+    JSLock lock(false);
+
+    const Vector<RefPtr<Profile> >& profiles = controller->profiles();
+
+    JSObjectRef global = JSContextGetGlobalObject(ctx);
+
+    JSValueRef arrayProperty = JSObjectGetProperty(ctx, global, jsStringRef("Array").get(), exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef arrayConstructor = JSValueToObject(ctx, arrayProperty, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef result = JSObjectCallAsConstructor(ctx, arrayConstructor, 0, 0, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSValueRef pushProperty = JSObjectGetProperty(ctx, result, jsStringRef("push").get(), exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    JSObjectRef pushFunction = JSValueToObject(ctx, pushProperty, exception);
+    if (exception && *exception)
+        return JSValueMakeUndefined(ctx);
+
+    for (size_t i = 0; i < profiles.size(); ++i) {
+        JSValueRef arg0 = toRef(toJS(toJS(ctx), profiles[i].get()));
+        JSObjectCallAsFunction(ctx, pushFunction, result, 1, &arg0, exception);
+        if (exception && *exception)
+            return JSValueMakeUndefined(ctx);
+    }
+
+    return result;
+}
+
+// InspectorController Class
+
+static unsigned s_inspectorControllerCount;
+static HashMap<String, InspectorController::Setting*>* s_settingCache;
+
+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)
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+    , m_debuggerEnabled(false)
+    , m_attachDebuggerWhenShown(false)
+#endif
+    , m_profilerEnabled(false)
+    , m_recordingUserInitiatedProfile(false)
+    , m_showAfterVisible(ElementsPanel)
+    , m_nextIdentifier(-2)
+    , m_groupLevel(0)
+    , m_searchingForNode(false)
+    , m_currentUserInitiatedProfileNumber(-1)
+    , m_nextUserInitiatedProfileNumber(1)
+    , m_previousMessage(0)
+    , m_startProfiling(this, &InspectorController::startUserInitiatedProfiling)
+{
+    ASSERT_ARG(page, page);
+    ASSERT_ARG(client, client);
+    ++s_inspectorControllerCount;
+}
+
+InspectorController::~InspectorController()
+{
+    m_client->inspectorDestroyed();
+
+    if (m_scriptContext) {
+        JSValueRef exception = 0;
+
+        JSObjectRef global = JSContextGetGlobalObject(m_scriptContext);
+        JSValueRef controllerProperty = JSObjectGetProperty(m_scriptContext, global, jsStringRef("InspectorController").get(), &exception);
+        if (!HANDLE_EXCEPTION(m_scriptContext, exception)) {
+            if (JSObjectRef controller = JSValueToObject(m_scriptContext, controllerProperty, &exception)) {
+                if (!HANDLE_EXCEPTION(m_scriptContext, exception))
+                    JSObjectSetPrivate(controller, 0);
+            }
+        }
+    }
+
+    if (m_page)
+        m_page->setParentInspectorController(0);
+
+    // m_inspectedPage should have been cleared in inspectedPageDestroyed().
+    ASSERT(!m_inspectedPage);
+
+    deleteAllValues(m_frameResources);
+    deleteAllValues(m_consoleMessages);
+
+    ASSERT(s_inspectorControllerCount);
+    --s_inspectorControllerCount;
+
+    if (!s_inspectorControllerCount && s_settingCache) {
+        deleteAllValues(*s_settingCache);
+        delete s_settingCache;
+        s_settingCache = 0;
+    }
+}
+
+void InspectorController::inspectedPageDestroyed()
+{
+    close();
+
+    ASSERT(m_inspectedPage);
+    m_inspectedPage = 0;
+}
+
+bool InspectorController::enabled() const
+{
+    if (!m_inspectedPage)
+        return false;
+    return m_inspectedPage->settings()->developerExtrasEnabled();
+}
+
+const InspectorController::Setting& InspectorController::setting(const String& key) const
+{
+    if (!s_settingCache)
+        s_settingCache = new HashMap<String, Setting*>;
+
+    if (Setting* cachedSetting = s_settingCache->get(key))
+        return *cachedSetting;
+
+    Setting* newSetting = new Setting;
+    s_settingCache->set(key, newSetting);
+
+    m_client->populateSetting(key, *newSetting);
+
+    return *newSetting;
+}
+
+void InspectorController::setSetting(const String& key, const Setting& setting)
+{
+    if (setting.type() == Setting::NoType) {
+        if (s_settingCache) {
+            Setting* cachedSetting = s_settingCache->get(key);
+            if (cachedSetting) {
+                s_settingCache->remove(key);
+                delete cachedSetting;
+            }
+        }
+
+        m_client->removeSetting(key);
+        return;
+    }
+
+    if (!s_settingCache)
+        s_settingCache = new HashMap<String, Setting*>;
+
+    if (Setting* cachedSetting = s_settingCache->get(key))
+        *cachedSetting = setting;
+    else
+        s_settingCache->set(key, new Setting(setting));
+
+    m_client->storeSetting(key, setting);
+}
+
+String InspectorController::localizedStringsURL()
+{
+    if (!enabled())
+        return String();
+    return m_client->localizedStringsURL();
+}
+
+// Trying to inspect something in a frame with JavaScript disabled would later lead to
+// crashes trying to create JavaScript wrappers. Some day we could fix this issue, but
+// for now prevent crashes here by never targeting a node in such a frame.
+static bool canPassNodeToJavaScript(Node* node)
+{
+    if (!node)
+        return false;
+    Frame* frame = node->document()->frame();
+    return frame && frame->script()->isEnabled();
+}
+
+void InspectorController::inspect(Node* node)
+{
+    if (!canPassNodeToJavaScript(node) || !enabled())
+        return;
+
+    show();
+
+    if (node->nodeType() != Node::ELEMENT_NODE && node->nodeType() != Node::DOCUMENT_NODE)
+        node = node->parentNode();
+    m_nodeToFocus = node;
+
+    if (!m_scriptObject) {
+        m_showAfterVisible = ElementsPanel;
+        return;
+    }
+
+    if (windowVisible())
+        focusNode();
+}
+
+void InspectorController::focusNode()
+{
+    if (!enabled())
+        return;
+
+    ASSERT(m_scriptContext);
+    ASSERT(m_scriptObject);
+    ASSERT(m_nodeToFocus);
+
+    Frame* frame = m_nodeToFocus->document()->frame();
+    if (!frame)
+        return;
+
+    ExecState* exec = toJSDOMWindow(frame)->globalExec();
+
+    JSValueRef arg0;
+
+    {
+        JSC::JSLock lock(false);
+        arg0 = toRef(JSInspectedObjectWrapper::wrap(exec, toJS(exec, m_nodeToFocus.get())));
+    }
+
+    m_nodeToFocus = 0;
+
+    JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "updateFocusedNode", 1, &arg0, exception);
+}
+
+void InspectorController::highlight(Node* node)
+{
+    if (!enabled())
+        return;
+    ASSERT_ARG(node, node);
+    m_highlightedNode = 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, bool attached)
+{
+    if (visible == m_windowVisible)
+        return;
+
+    m_windowVisible = visible;
+
+    if (!m_scriptContext || !m_scriptObject)
+        return;
+
+    if (m_windowVisible) {
+        setAttachedWindow(attached);
+        populateScriptObjects();
+        if (m_nodeToFocus)
+            focusNode();
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+        if (m_attachDebuggerWhenShown)
+            enableDebugger();
+#endif
+        if (m_showAfterVisible != CurrentPanel)
+            showPanel(m_showAfterVisible);
+    } else {
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+        disableDebugger();
+#endif
+        resetScriptObjects();
+    }
+
+    m_showAfterVisible = CurrentPanel;
+}
+
+void InspectorController::addMessageToConsole(MessageSource source, MessageLevel level, ExecState* exec, const ArgList& arguments, unsigned lineNumber, const String& sourceURL)
+{
+    if (!enabled())
+        return;
+
+    addConsoleMessage(exec, new ConsoleMessage(source, level, exec, arguments, lineNumber, sourceURL, m_groupLevel));
+}
+
+void InspectorController::addMessageToConsole(MessageSource source, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceID)
+{
+    if (!enabled())
+        return;
+
+    addConsoleMessage(0, new ConsoleMessage(source, level, message, lineNumber, sourceID, m_groupLevel));
+}
+
+void InspectorController::addConsoleMessage(ExecState* exec, ConsoleMessage* consoleMessage)
+{
+    ASSERT(enabled());
+    ASSERT_ARG(consoleMessage, consoleMessage);
+
+    if (m_previousMessage && m_previousMessage->isEqual(exec, consoleMessage)) {
+        ++m_previousMessage->repeatCount;
+        delete consoleMessage;
+    } else {
+        m_previousMessage = consoleMessage;
+        m_consoleMessages.append(consoleMessage);
+    }
+
+    if (windowVisible())
+        addScriptConsoleMessage(m_previousMessage);
+}
+
+void InspectorController::clearConsoleMessages()
+{
+    deleteAllValues(m_consoleMessages);
+    m_consoleMessages.clear();
+    m_previousMessage = 0;
+    m_groupLevel = 0;
+}
+
+void InspectorController::toggleRecordButton(bool isProfiling)
+{
+    if (!m_scriptContext)
+        return;
+
+    JSValueRef exception = 0;
+    JSValueRef isProvingValue = JSValueMakeBoolean(m_scriptContext, isProfiling);
+    callFunction(m_scriptContext, m_scriptObject, "setRecordingProfile", 1, &isProvingValue, exception);
+}
+
+void InspectorController::startGroup(MessageSource source, ExecState* exec, const ArgList& arguments, unsigned lineNumber, const String& sourceURL)
+{    
+    ++m_groupLevel;
+
+    addConsoleMessage(exec, new ConsoleMessage(source, StartGroupMessageLevel, exec, arguments, lineNumber, sourceURL, m_groupLevel));
+}
+
+void InspectorController::endGroup(MessageSource source, unsigned lineNumber, const String& sourceURL)
+{
+    if (m_groupLevel == 0)
+        return;
+
+    --m_groupLevel;
+
+    addConsoleMessage(0, new ConsoleMessage(source, EndGroupMessageLevel, String(), lineNumber, sourceURL, m_groupLevel));
+}
+
+void InspectorController::addProfile(PassRefPtr<Profile> prpProfile, unsigned lineNumber, const UString& sourceURL)
+{
+    if (!enabled())
+        return;
+
+    RefPtr<Profile> profile = prpProfile;
+    m_profiles.append(profile);
+
+    if (windowVisible())
+        addScriptProfile(profile.get());
+
+    addProfileMessageToConsole(profile, lineNumber, sourceURL);
+}
+
+void InspectorController::addProfileMessageToConsole(PassRefPtr<Profile> prpProfile, unsigned lineNumber, const UString& sourceURL)
+{
+    RefPtr<Profile> profile = prpProfile;
+
+    UString message = "Profile \"webkit-profile://";
+    message += encodeWithURLEscapeSequences(profile->title());
+    message += "/";
+    message += UString::from(profile->uid());
+    message += "\" finished.";
+    addMessageToConsole(JSMessageSource, LogMessageLevel, message, lineNumber, sourceURL);
+}
+
+void InspectorController::attachWindow()
+{
+    if (!enabled())
+        return;
+    m_client->attachWindow();
+}
+
+void InspectorController::detachWindow()
+{
+    if (!enabled())
+        return;
+    m_client->detachWindow();
+}
+
+void InspectorController::setAttachedWindow(bool attached)
+{
+    if (!enabled() || !m_scriptContext || !m_scriptObject)
+        return;
+
+    JSValueRef attachedValue = JSValueMakeBoolean(m_scriptContext, attached);
+
+    JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "setAttachedWindow", 1, &attachedValue, exception);
+}
+
+void InspectorController::setAttachedWindowHeight(unsigned height)
+{
+    if (!enabled())
+        return;
+    m_client->setAttachedWindowHeight(height);
+}
+
+void InspectorController::toggleSearchForNodeInPage()
+{
+    if (!enabled())
+        return;
+
+    m_searchingForNode = !m_searchingForNode;
+    if (!m_searchingForNode)
+        hideHighlight();
+}
+
+void InspectorController::mouseDidMoveOverElement(const HitTestResult& result, unsigned modifierFlags)
+{
+    if (!enabled() || !m_searchingForNode)
+        return;
+
+    Node* node = result.innerNode();
+    if (node)
+        highlight(node);
+}
+
+void InspectorController::handleMousePressOnNode(Node* node)
+{
+    if (!enabled())
+        return;
+
+    ASSERT(m_searchingForNode);
+    ASSERT(node);
+    if (!node)
+        return;
+
+    // inspect() will implicitly call ElementsPanel's focusedNodeChanged() and the hover feedback will be stopped there.
+    inspect(node);
+}
+
+void InspectorController::inspectedWindowScriptObjectCleared(Frame* frame)
+{
+    if (!enabled() || !m_scriptContext || !m_scriptObject)
+        return;
+
+    JSDOMWindow* win = toJSDOMWindow(frame);
+    ExecState* exec = win->globalExec();
+
+    JSValueRef arg0;
+
+    {
+        JSC::JSLock lock(false);
+        arg0 = toRef(JSInspectedObjectWrapper::wrap(exec, win));
+    }
+
+    JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "inspectedWindowCleared", 1, &arg0, exception);
+}
+
+void InspectorController::windowScriptObjectAvailable()
+{
+    if (!m_page || !enabled())
+        return;
+
+    m_scriptContext = toRef(m_page->mainFrame()->script()->globalObject()->globalExec());
+
+    JSObjectRef global = JSContextGetGlobalObject(m_scriptContext);
+    ASSERT(global);
+
+    static JSStaticFunction staticFunctions[] = {
+        // SIMPLE_INSPECTOR_CALLBACK
+        { "hideDOMNodeHighlight", WebCore::hideDOMNodeHighlight, kJSPropertyAttributeNone },
+        { "loaded", WebCore::loaded, kJSPropertyAttributeNone },
+        { "windowUnloading", WebCore::unloading, kJSPropertyAttributeNone },
+        { "attach", WebCore::attach, kJSPropertyAttributeNone },
+        { "detach", WebCore::detach, kJSPropertyAttributeNone },
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+        { "enableDebugger", WebCore::enableDebugger, kJSPropertyAttributeNone },
+        { "disableDebugger", WebCore::disableDebugger, kJSPropertyAttributeNone },
+        { "pauseInDebugger", WebCore::pauseInDebugger, kJSPropertyAttributeNone },
+        { "resumeDebugger", WebCore::resumeDebugger, kJSPropertyAttributeNone },
+        { "stepOverStatementInDebugger", WebCore::stepOverStatementInDebugger, kJSPropertyAttributeNone },
+        { "stepIntoStatementInDebugger", WebCore::stepIntoStatementInDebugger, kJSPropertyAttributeNone },
+        { "stepOutOfFunctionInDebugger", WebCore::stepOutOfFunctionInDebugger, kJSPropertyAttributeNone },
+#endif
+        { "closeWindow", WebCore::closeWindow, kJSPropertyAttributeNone },
+        { "clearMessages", WebCore::clearMessages, kJSPropertyAttributeNone },
+        { "startProfiling", WebCore::startProfiling, kJSPropertyAttributeNone },
+        { "stopProfiling", WebCore::stopProfiling, kJSPropertyAttributeNone },
+        { "enableProfiler", WebCore::enableProfiler, kJSPropertyAttributeNone },
+        { "disableProfiler", WebCore::disableProfiler, kJSPropertyAttributeNone },
+        { "toggleNodeSearch", WebCore::toggleNodeSearch, kJSPropertyAttributeNone },
+
+        // BOOL_INSPECTOR_CALLBACK
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+        { "debuggerEnabled", WebCore::debuggerEnabled, kJSPropertyAttributeNone },
+        { "pauseOnExceptions", WebCore::pauseOnExceptions, kJSPropertyAttributeNone },
+#endif
+        { "profilerEnabled", WebCore::profilerEnabled, kJSPropertyAttributeNone },
+        { "isWindowVisible", WebCore::isWindowVisible, kJSPropertyAttributeNone },
+        { "searchingForNode", WebCore::searchingForNode, kJSPropertyAttributeNone },
+
+        // Custom callbacks
+        { "addResourceSourceToFrame", WebCore::addResourceSourceToFrame, kJSPropertyAttributeNone },
+        { "addSourceToFrame", WebCore::addSourceToFrame, kJSPropertyAttributeNone },
+        { "getResourceDocumentNode", WebCore::getResourceDocumentNode, kJSPropertyAttributeNone },
+        { "highlightDOMNode", WebCore::highlightDOMNode, kJSPropertyAttributeNone },
+        { "search", WebCore::search, kJSPropertyAttributeNone },
+#if ENABLE(DATABASE)
+        { "databaseTableNames", WebCore::databaseTableNames, kJSPropertyAttributeNone },
+#endif
+        { "setting", WebCore::setting, kJSPropertyAttributeNone },
+        { "setSetting", WebCore::setSetting, kJSPropertyAttributeNone },
+        { "inspectedWindow", WebCore::inspectedWindow, kJSPropertyAttributeNone },
+        { "localizedStringsURL", WebCore::localizedStrings, kJSPropertyAttributeNone },
+        { "platform", WebCore::platform, kJSPropertyAttributeNone },
+        { "moveByUnrestricted", WebCore::moveByUnrestricted, kJSPropertyAttributeNone },
+        { "setAttachedWindowHeight", WebCore::setAttachedWindowHeight, kJSPropertyAttributeNone },
+        { "wrapCallback", WebCore::wrapCallback, kJSPropertyAttributeNone },
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+        { "currentCallFrame", WebCore::currentCallFrame, kJSPropertyAttributeNone },
+        { "setPauseOnExceptions", WebCore::setPauseOnExceptions, kJSPropertyAttributeNone },
+        { "addBreakpoint", WebCore::addBreakpoint, kJSPropertyAttributeNone },
+        { "removeBreakpoint", WebCore::removeBreakpoint, kJSPropertyAttributeNone },
+#endif
+        { "profiles", WebCore::profiles, 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);
+
+    JSObjectSetProperty(m_scriptContext, global, jsStringRef("InspectorController").get(), m_controllerScriptObject, kJSPropertyAttributeNone, 0);
+}
+
+void InspectorController::scriptObjectReady()
+{
+    ASSERT(m_scriptContext);
+    if (!m_scriptContext)
+        return;
+
+    JSObjectRef global = JSContextGetGlobalObject(m_scriptContext);
+    ASSERT(global);
+
+    JSValueRef exception = 0;
+
+    JSValueRef inspectorValue = JSObjectGetProperty(m_scriptContext, global, jsStringRef("WebInspector").get(), &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    ASSERT(inspectorValue);
+    if (!inspectorValue)
+        return;
+
+    m_scriptObject = JSValueToObject(m_scriptContext, inspectorValue, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    ASSERT(m_scriptObject);
+
+    JSValueProtect(m_scriptContext, m_scriptObject);
+
+    // Make sure our window is visible now that the page loaded
+    showWindow();
+}
+
+void InspectorController::show()
+{
+    if (!enabled())
+        return;
+
+    if (!m_page) {
+        m_page = m_client->createPage();
+        if (!m_page)
+            return;
+        m_page->setParentInspectorController(this);
+
+        // showWindow() will be called after the page loads in scriptObjectReady()
+        return;
+    }
+
+    showWindow();
+}
+
+void InspectorController::showPanel(SpecialPanels panel)
+{
+    if (!enabled())
+        return;
+
+    show();
+
+    if (!m_scriptObject) {
+        m_showAfterVisible = panel;
+        return;
+    }
+
+    if (panel == CurrentPanel)
+        return;
+
+    const char* showFunctionName;
+    switch (panel) {
+        case ConsolePanel:
+            showFunctionName = "showConsole";
+            break;
+        case DatabasesPanel:
+            showFunctionName = "showDatabasesPanel";
+            break;
+        case ElementsPanel:
+            showFunctionName = "showElementsPanel";
+            break;
+        case ProfilesPanel:
+            showFunctionName = "showProfilesPanel";
+            break;
+        case ResourcesPanel:
+            showFunctionName = "showResourcesPanel";
+            break;
+        case ScriptsPanel:
+            showFunctionName = "showScriptsPanel";
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+            showFunctionName = 0;
+    }
+
+    if (showFunctionName)
+        callSimpleFunction(m_scriptContext, m_scriptObject, showFunctionName);
+}
+
+void InspectorController::close()
+{
+    if (!enabled())
+        return;
+
+    stopUserInitiatedProfiling();
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+    disableDebugger();
+#endif
+    closeWindow();
+
+    if (m_scriptContext && m_scriptObject)
+        JSValueUnprotect(m_scriptContext, m_scriptObject);
+
+    m_scriptObject = 0;
+    m_scriptContext = 0;
+}
+
+void InspectorController::showWindow()
+{
+    ASSERT(enabled());
+    m_client->showWindow();
+}
+
+void InspectorController::closeWindow()
+{
+    m_client->closeWindow();
+}
+
+void InspectorController::startUserInitiatedProfilingSoon()
+{
+    m_startProfiling.startOneShot(0);
+}
+
+void InspectorController::startUserInitiatedProfiling(Timer<InspectorController>*)
+{
+    if (!enabled())
+        return;
+
+    if (!profilerEnabled()) {
+        enableProfiler(true);
+        JavaScriptDebugServer::shared().recompileAllJSFunctions();
+    }
+
+    m_recordingUserInitiatedProfile = true;
+    m_currentUserInitiatedProfileNumber = m_nextUserInitiatedProfileNumber++;
+
+    UString title = UserInitiatedProfileName;
+    title += ".";
+    title += UString::from(m_currentUserInitiatedProfileNumber);
+
+    ExecState* exec = toJSDOMWindow(m_inspectedPage->mainFrame())->globalExec();
+    Profiler::profiler()->startProfiling(exec, title);
+
+    toggleRecordButton(true);
+}
+
+void InspectorController::stopUserInitiatedProfiling()
+{
+    if (!enabled())
+        return;
+
+    m_recordingUserInitiatedProfile = false;
+
+    UString title =  UserInitiatedProfileName;
+    title += ".";
+    title += UString::from(m_currentUserInitiatedProfileNumber);
+
+    ExecState* exec = toJSDOMWindow(m_inspectedPage->mainFrame())->globalExec();
+    RefPtr<Profile> profile = Profiler::profiler()->stopProfiling(exec, title);
+    if (profile)
+        addProfile(profile, 0, UString());
+
+    toggleRecordButton(false);
+}
+
+void InspectorController::enableProfiler(bool skipRecompile)
+{
+    if (m_profilerEnabled)
+        return;
+
+    m_profilerEnabled = true;
+
+    if (!skipRecompile)
+        JavaScriptDebugServer::shared().recompileAllJSFunctionsSoon();
+
+    if (m_scriptContext && m_scriptObject)
+        callSimpleFunction(m_scriptContext, m_scriptObject, "profilerWasEnabled");
+}
+
+void InspectorController::disableProfiler()
+{
+    if (!m_profilerEnabled)
+        return;
+
+    m_profilerEnabled = false;
+
+    JavaScriptDebugServer::shared().recompileAllJSFunctionsSoon();
+
+    if (m_scriptContext && m_scriptObject)
+        callSimpleFunction(m_scriptContext, m_scriptObject, "profilerWasDisabled");
+}
+
+static void addHeaders(JSContextRef context, JSObjectRef object, const HTTPHeaderMap& headers, JSValueRef* exception)
+{
+    ASSERT_ARG(context, context);
+    ASSERT_ARG(object, object);
+
+    HTTPHeaderMap::const_iterator end = headers.end();
+    for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) {
+        JSValueRef value = JSValueMakeString(context, jsStringRef(it->second).get());
+        JSObjectSetProperty(context, object, jsStringRef(it->first).get(), value, kJSPropertyAttributeNone, exception);
+        if (exception && *exception)
+            return;
+    }
+}
+
+static JSObjectRef scriptObjectForRequest(JSContextRef context, const InspectorResource* resource, JSValueRef* exception)
+{
+    ASSERT_ARG(context, context);
+
+    JSObjectRef object = JSObjectMake(context, 0, 0);
+    addHeaders(context, object, resource->requestHeaderFields, exception);
+
+    return object;
+}
+
+static JSObjectRef scriptObjectForResponse(JSContextRef context, const InspectorResource* resource, JSValueRef* exception)
+{
+    ASSERT_ARG(context, context);
+
+    JSObjectRef object = JSObjectMake(context, 0, 0);
+    addHeaders(context, object, resource->responseHeaderFields, exception);
+
+    return object;
+}
+
+JSObjectRef InspectorController::addScriptResource(InspectorResource* resource)
+{
+    ASSERT_ARG(resource, resource);
+
+    ASSERT(m_scriptContext);
+    ASSERT(m_scriptObject);
+    if (!m_scriptContext || !m_scriptObject)
+        return 0;
+
+    if (!resource->scriptObject) {
+        JSValueRef exception = 0;
+
+        JSValueRef resourceProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("Resource").get(), &exception);
+        if (HANDLE_EXCEPTION(m_scriptContext, exception))
+            return 0;
+
+        JSObjectRef resourceConstructor = JSValueToObject(m_scriptContext, resourceProperty, &exception);
+        if (HANDLE_EXCEPTION(m_scriptContext, exception))
+            return 0;
+
+        JSValueRef urlValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.string()).get());
+        JSValueRef domainValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.host()).get());
+        JSValueRef pathValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.path()).get());
+        JSValueRef lastPathComponentValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.lastPathComponent()).get());
+
+        JSValueRef identifier = JSValueMakeNumber(m_scriptContext, resource->identifier);
+        JSValueRef mainResource = JSValueMakeBoolean(m_scriptContext, m_mainResource == resource);
+        JSValueRef cached = JSValueMakeBoolean(m_scriptContext, resource->cached);
+
+        JSObjectRef scriptObject = scriptObjectForRequest(m_scriptContext, resource, &exception);
+        if (HANDLE_EXCEPTION(m_scriptContext, exception))
+            return 0;
+
+        JSValueRef arguments[] = { scriptObject, urlValue, domainValue, pathValue, lastPathComponentValue, identifier, mainResource, cached };
+        JSObjectRef result = JSObjectCallAsConstructor(m_scriptContext, resourceConstructor, 8, arguments, &exception);
+        if (HANDLE_EXCEPTION(m_scriptContext, exception))
+            return 0;
+
+        ASSERT(result);
+
+        resource->setScriptObject(m_scriptContext, result);
+    }
+
+    JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "addResource", 1, &resource->scriptObject, exception);
+
+    if (exception)
+        return 0;
+
+    return resource->scriptObject;
+}
+
+JSObjectRef InspectorController::addAndUpdateScriptResource(InspectorResource* resource)
+{
+    ASSERT_ARG(resource, resource);
+
+    JSObjectRef scriptResource = addScriptResource(resource);
+    if (!scriptResource)
+        return 0;
+
+    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;
+
+    JSObjectRef scriptObject = resource->scriptObject;
+    resource->setScriptObject(0, 0);
+
+    JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "removeResource", 1, &scriptObject, exception);
+}
+
+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();
+}
+
+void InspectorController::updateScriptResourceRequest(InspectorResource* resource)
+{
+    ASSERT(resource->scriptObject);
+    ASSERT(m_scriptContext);
+    if (!resource->scriptObject || !m_scriptContext)
+        return;
+
+    JSValueRef urlValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.string()).get());
+    JSValueRef domainValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.host()).get());
+    JSValueRef pathValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.path()).get());
+    JSValueRef lastPathComponentValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.lastPathComponent()).get());
+
+    JSValueRef mainResourceValue = JSValueMakeBoolean(m_scriptContext, m_mainResource == resource);
+
+    JSValueRef exception = 0;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("url").get(), urlValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("domain").get(), domainValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("path").get(), pathValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("lastPathComponent").get(), lastPathComponentValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectRef scriptObject = scriptObjectForRequest(m_scriptContext, resource, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("requestHeaders").get(), scriptObject, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("mainResource").get(), mainResourceValue, kJSPropertyAttributeNone, &exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
+}
+
+void InspectorController::updateScriptResourceResponse(InspectorResource* resource)
+{
+    ASSERT(resource->scriptObject);
+    ASSERT(m_scriptContext);
+    if (!resource->scriptObject || !m_scriptContext)
+        return;
+
+    JSValueRef mimeTypeValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->mimeType).get());
+
+    JSValueRef suggestedFilenameValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->suggestedFilename).get());
+
+    JSValueRef expectedContentLengthValue = JSValueMakeNumber(m_scriptContext, static_cast<double>(resource->expectedContentLength));
+    JSValueRef statusCodeValue = JSValueMakeNumber(m_scriptContext, resource->responseStatusCode);
+
+    JSValueRef exception = 0;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("mimeType").get(), mimeTypeValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("suggestedFilename").get(), suggestedFilenameValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("expectedContentLength").get(), expectedContentLengthValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("statusCode").get(), statusCodeValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectRef scriptObject = scriptObjectForResponse(m_scriptContext, resource, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("responseHeaders").get(), scriptObject, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    updateScriptResourceType(resource);
+}
+
+void InspectorController::updateScriptResourceType(InspectorResource* resource)
+{
+    ASSERT(resource->scriptObject);
+    ASSERT(m_scriptContext);
+    if (!resource->scriptObject || !m_scriptContext)
+        return;
+
+    JSValueRef exception = 0;
+
+    JSValueRef typeValue = JSValueMakeNumber(m_scriptContext, resource->type());
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("type").get(), typeValue, kJSPropertyAttributeNone, &exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
+}
+
+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);
+
+    JSValueRef exception = 0;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("contentLength").get(), lengthValue, kJSPropertyAttributeNone, &exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
+}
+
+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);
+
+    JSValueRef exception = 0;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("failed").get(), failedValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("finished").get(), finishedValue, kJSPropertyAttributeNone, &exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
+}
+
+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);
+
+    JSValueRef exception = 0;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("startTime").get(), startTimeValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("responseReceivedTime").get(), responseReceivedTimeValue, kJSPropertyAttributeNone, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("endTime").get(), endTimeValue, kJSPropertyAttributeNone, &exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
+}
+
+void InspectorController::populateScriptObjects()
+{
+    ASSERT(m_scriptContext);
+    if (!m_scriptContext)
+        return;
+
+    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]);
+
+#if ENABLE(DATABASE)
+    DatabaseResourcesSet::iterator databasesEnd = m_databaseResources.end();
+    for (DatabaseResourcesSet::iterator it = m_databaseResources.begin(); it != databasesEnd; ++it)
+        addDatabaseScriptResource((*it).get());
+#endif
+
+    callSimpleFunction(m_scriptContext, m_scriptObject, "populateInterface");
+}
+
+#if ENABLE(DATABASE)
+JSObjectRef InspectorController::addDatabaseScriptResource(InspectorDatabaseResource* resource)
+{
+    ASSERT_ARG(resource, resource);
+
+    if (resource->scriptObject)
+        return resource->scriptObject;
+
+    ASSERT(m_scriptContext);
+    ASSERT(m_scriptObject);
+    if (!m_scriptContext || !m_scriptObject)
+        return 0;
+
+    Frame* frame = resource->database->document()->frame();
+    if (!frame)
+        return 0;
+
+    JSValueRef exception = 0;
+
+    JSValueRef databaseProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("Database").get(), &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return 0;
+
+    JSObjectRef databaseConstructor = JSValueToObject(m_scriptContext, databaseProperty, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return 0;
+
+    ExecState* exec = toJSDOMWindow(frame)->globalExec();
+
+    JSValueRef database;
+
+    {
+        JSC::JSLock lock(false);
+        database = toRef(JSInspectedObjectWrapper::wrap(exec, toJS(exec, resource->database.get())));
+    }
+
+    JSValueRef domainValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->domain).get());
+    JSValueRef nameValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->name).get());
+    JSValueRef versionValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->version).get());
+
+    JSValueRef arguments[] = { database, domainValue, nameValue, versionValue };
+    JSObjectRef result = JSObjectCallAsConstructor(m_scriptContext, databaseConstructor, 4, arguments, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return 0;
+
+    ASSERT(result);
+
+    callFunction(m_scriptContext, m_scriptObject, "addDatabase", 1, &result, exception);
+
+    if (exception)
+        return 0;
+
+    resource->setScriptObject(m_scriptContext, result);
+
+    return result;
+}
+
+void InspectorController::removeDatabaseScriptResource(InspectorDatabaseResource* resource)
+{
+    ASSERT(m_scriptContext);
+    ASSERT(m_scriptObject);
+    if (!m_scriptContext || !m_scriptObject)
+        return;
+
+    ASSERT(resource);
+    ASSERT(resource->scriptObject);
+    if (!resource || !resource->scriptObject)
+        return;
+
+    JSObjectRef scriptObject = resource->scriptObject;
+    resource->setScriptObject(0, 0);
+
+    JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "removeDatabase", 1, &scriptObject, exception);
+}
+#endif
+
+void InspectorController::addScriptConsoleMessage(const ConsoleMessage* message)
+{
+    ASSERT_ARG(message, message);
+
+    JSValueRef exception = 0;
+
+    JSValueRef messageConstructorProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("ConsoleMessage").get(), &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSObjectRef messageConstructor = JSValueToObject(m_scriptContext, messageConstructorProperty, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    JSValueRef sourceValue = JSValueMakeNumber(m_scriptContext, message->source);
+    JSValueRef levelValue = JSValueMakeNumber(m_scriptContext, message->level);
+    JSValueRef lineValue = JSValueMakeNumber(m_scriptContext, message->line);
+    JSValueRef urlValue = JSValueMakeString(m_scriptContext, jsStringRef(message->url).get());
+    JSValueRef groupLevelValue = JSValueMakeNumber(m_scriptContext, message->groupLevel);
+    JSValueRef repeatCountValue = JSValueMakeNumber(m_scriptContext, message->repeatCount);
+
+    static const unsigned maximumMessageArguments = 256;
+    JSValueRef arguments[maximumMessageArguments];
+    unsigned argumentCount = 0;
+    arguments[argumentCount++] = sourceValue;
+    arguments[argumentCount++] = levelValue;
+    arguments[argumentCount++] = lineValue;
+    arguments[argumentCount++] = urlValue;
+    arguments[argumentCount++] = groupLevelValue;
+    arguments[argumentCount++] = repeatCountValue;
+
+    if (!message->wrappedArguments.isEmpty()) {
+        unsigned remainingSpaceInArguments = maximumMessageArguments - argumentCount;
+        unsigned argumentsToAdd = min(remainingSpaceInArguments, static_cast<unsigned>(message->wrappedArguments.size()));
+        for (unsigned i = 0; i < argumentsToAdd; ++i)
+            arguments[argumentCount++] = toRef(message->wrappedArguments[i]);
+    } else {
+        JSValueRef messageValue = JSValueMakeString(m_scriptContext, jsStringRef(message->message).get());
+        arguments[argumentCount++] = messageValue;
+    }
+
+    JSObjectRef messageObject = JSObjectCallAsConstructor(m_scriptContext, messageConstructor, argumentCount, arguments, &exception);
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
+        return;
+
+    callFunction(m_scriptContext, m_scriptObject, "addMessageToConsole", 1, &messageObject, exception);
+}
+
+void InspectorController::addScriptProfile(Profile* profile)
+{
+    JSLock lock(false);
+    JSValueRef exception = 0;
+    JSValueRef profileObject = toRef(toJS(toJS(m_scriptContext), profile));
+    callFunction(m_scriptContext, m_scriptObject, "addProfile", 1, &profileObject, exception);
+}
+
+void InspectorController::resetScriptObjects()
+{
+    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);
+    }
+
+#if ENABLE(DATABASE)
+    DatabaseResourcesSet::iterator databasesEnd = m_databaseResources.end();
+    for (DatabaseResourcesSet::iterator it = m_databaseResources.begin(); it != databasesEnd; ++it) {
+        InspectorDatabaseResource* resource = (*it).get();
+        resource->setScriptObject(0, 0);
+    }
+#endif
+
+    callSimpleFunction(m_scriptContext, m_scriptObject, "reset");
+}
+
+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;
+
+    ASSERT(m_inspectedPage);
+
+    if (loader->frame() == m_inspectedPage->mainFrame()) {
+        m_client->inspectedURLChanged(loader->url().string());
+
+        clearConsoleMessages();
+
+        m_times.clear();
+        m_counts.clear();
+        m_profiles.clear();
+
+#if ENABLE(DATABASE)
+        m_databaseResources.clear();
+#endif
+
+        if (windowVisible()) {
+            resetScriptObjects();
+
+            if (!loader->isLoadingFromCachedPage()) {
+                ASSERT(m_mainResource && m_mainResource->loader == loader);
+                // 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());
+            } else {
+                // Pages loaded from the page cache are committed before
+                // m_mainResource is the right resource for this load, so we
+                // clear it here. It will be re-assigned in
+                // identifierForInitialRequest.
+                m_mainResource = 0;
+            }
+        }
+    }
+
+    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);
+    m_knownResources.add(resource->requestURL.string());
+
+    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);
+    m_knownResources.remove(resource->requestURL.string());
+
+    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;
+
+    // If the resource URL is already known, we don't need to add it again since this is just a cached load.
+    if (m_knownResources.contains(request.url().string()))
+        return;
+
+    RefPtr<InspectorResource> resource = InspectorResource::create(m_nextIdentifier--, loader, loader->frame());
+    resource->finished = true;
+
+    updateResourceRequest(resource.get(), request);
+    updateResourceResponse(resource.get(), response);
+
+    resource->length = length;
+    resource->cached = true;
+    resource->startTime = currentTime();
+    resource->responseReceivedTime = resource->startTime;
+    resource->endTime = resource->startTime;
+
+    ASSERT(m_inspectedPage);
+
+    if (loader->frame() == m_inspectedPage->mainFrame() && request.url() == loader->requestURL())
+        m_mainResource = resource;
+
+    addResource(resource.get());
+
+    if (windowVisible())
+        addAndUpdateScriptResource(resource.get());
+}
+
+void InspectorController::identifierForInitialRequest(unsigned long identifier, DocumentLoader* loader, const ResourceRequest& request)
+{
+    if (!enabled())
+        return;
+
+    RefPtr<InspectorResource> resource = InspectorResource::create(identifier, loader, loader->frame());
+
+    updateResourceRequest(resource.get(), request);
+
+    ASSERT(m_inspectedPage);
+
+    if (loader->frame() == m_inspectedPage->mainFrame() && request.url() == loader->requestURL())
+        m_mainResource = resource;
+
+    addResource(resource.get());
+
+    if (windowVisible() && loader->isLoadingFromCachedPage() && resource == m_mainResource)
+        addAndUpdateScriptResource(resource.get());
+}
+
+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);
+    }
+}
+
+void InspectorController::resourceRetrievedByXMLHttpRequest(unsigned long identifier, JSC::UString& sourceString)
+{
+    if (!enabled())
+        return;
+
+    InspectorResource* resource = m_resources.get(identifier).get();
+    if (!resource)
+        return;
+
+    resource->setXMLHttpRequestProperties(sourceString);
+
+    if (windowVisible() && resource->scriptObject)
+        updateScriptResourceType(resource);
+}
+
+
+#if ENABLE(DATABASE)
+void InspectorController::didOpenDatabase(Database* database, const String& domain, const String& name, const String& version)
+{
+    if (!enabled())
+        return;
+
+    RefPtr<InspectorDatabaseResource> resource = InspectorDatabaseResource::create(database, domain, name, version);
+
+    m_databaseResources.add(resource);
+
+    if (windowVisible())
+        addDatabaseScriptResource(resource.get());
+}
+#endif
+
+void InspectorController::moveWindowBy(float x, float y) const
+{
+    if (!m_page || !enabled())
+        return;
+
+    FloatRect frameRect = m_page->chrome()->windowRect();
+    frameRect.move(x, y);
+    m_page->chrome()->setWindowRect(frameRect);
+}
+
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+void InspectorController::enableDebugger()
+{
+    if (!enabled())
+        return;
+
+    if (!m_scriptContext || !m_scriptObject) {
+        m_attachDebuggerWhenShown = true;
+        return;
+    }
+
+    ASSERT(m_inspectedPage);
+
+    JavaScriptDebugServer::shared().addListener(this, m_inspectedPage);
+    JavaScriptDebugServer::shared().clearBreakpoints();
+
+    m_debuggerEnabled = true;
+    m_attachDebuggerWhenShown = false;
+
+    callSimpleFunction(m_scriptContext, m_scriptObject, "debuggerWasEnabled");
+}
+
+void InspectorController::disableDebugger()
+{
+    if (!enabled())
+        return;
+
+    ASSERT(m_inspectedPage);
+
+    JavaScriptDebugServer::shared().removeListener(this, m_inspectedPage);
+
+    m_debuggerEnabled = false;
+    m_attachDebuggerWhenShown = false;
+
+    if (m_scriptContext && m_scriptObject)
+        callSimpleFunction(m_scriptContext, m_scriptObject, "debuggerWasDisabled");
+}
+
+JavaScriptCallFrame* InspectorController::currentCallFrame() const
+{
+    return JavaScriptDebugServer::shared().currentCallFrame();
+}
+
+bool InspectorController::pauseOnExceptions()
+{
+    return JavaScriptDebugServer::shared().pauseOnExceptions();
+}
+
+void InspectorController::setPauseOnExceptions(bool pause)
+{
+    JavaScriptDebugServer::shared().setPauseOnExceptions(pause);
+}
+
+void InspectorController::pauseInDebugger()
+{
+    if (!m_debuggerEnabled)
+        return;
+    JavaScriptDebugServer::shared().pauseProgram();
+}
+
+void InspectorController::resumeDebugger()
+{
+    if (!m_debuggerEnabled)
+        return;
+    JavaScriptDebugServer::shared().continueProgram();
+}
+
+void InspectorController::stepOverStatementInDebugger()
+{
+    if (!m_debuggerEnabled)
+        return;
+    JavaScriptDebugServer::shared().stepOverStatement();
+}
+
+void InspectorController::stepIntoStatementInDebugger()
+{
+    if (!m_debuggerEnabled)
+        return;
+    JavaScriptDebugServer::shared().stepIntoStatement();
+}
+
+void InspectorController::stepOutOfFunctionInDebugger()
+{
+    if (!m_debuggerEnabled)
+        return;
+    JavaScriptDebugServer::shared().stepOutOfFunction();
+}
+
+void InspectorController::addBreakpoint(intptr_t sourceID, unsigned lineNumber)
+{
+    JavaScriptDebugServer::shared().addBreakpoint(sourceID, lineNumber);
+}
+
+void InspectorController::removeBreakpoint(intptr_t sourceID, unsigned lineNumber)
+{
+    JavaScriptDebugServer::shared().removeBreakpoint(sourceID, lineNumber);
+}
+#endif
+
+static void drawOutlinedRect(GraphicsContext& context, const IntRect& rect, const Color& fillColor)
+{
+    static const int outlineThickness = 1;
+    static const Color outlineColor(62, 86, 180, 228);
+
+    IntRect outline = rect;
+    outline.inflate(outlineThickness);
+
+    context.clearRect(outline);
+
+    context.save();
+    context.clipOut(rect);
+    context.fillRect(outline, outlineColor);
+    context.restore();
+
+    context.fillRect(rect, fillColor);
+}
+
+static void drawHighlightForBoxes(GraphicsContext& context, const Vector<IntRect>& lineBoxRects, const IntRect& contentBox, const IntRect& paddingBox, const IntRect& borderBox, const IntRect& marginBox)
+{
+    static const Color contentBoxColor(125, 173, 217, 128);
+    static const Color paddingBoxColor(125, 173, 217, 160);
+    static const Color borderBoxColor(125, 173, 217, 192);
+    static const Color marginBoxColor(125, 173, 217, 228);
+
+    if (!lineBoxRects.isEmpty()) {
+        for (size_t i = 0; i < lineBoxRects.size(); ++i)
+            drawOutlinedRect(context, lineBoxRects[i], contentBoxColor);
+        return;
+    }
+
+    if (marginBox != borderBox)
+        drawOutlinedRect(context, marginBox, marginBoxColor);
+    if (borderBox != paddingBox)
+        drawOutlinedRect(context, borderBox, borderBoxColor);
+    if (paddingBox != contentBox)
+        drawOutlinedRect(context, paddingBox, paddingBoxColor);
+    drawOutlinedRect(context, contentBox, contentBoxColor);
+}
+
+static inline void convertFromFrameToMainFrame(Frame* frame, IntRect& rect)
+{
+    rect = frame->page()->mainFrame()->view()->windowToContents(frame->view()->contentsToWindow(rect));
+}
+
+void InspectorController::drawNodeHighlight(GraphicsContext& context) const
+{
+    if (!m_highlightedNode)
+        return;
+
+    RenderObject* renderer = m_highlightedNode->renderer();
+    Frame* containingFrame = m_highlightedNode->document()->frame();
+    if (!renderer || !containingFrame)
+        return;
+
+    IntRect contentBox = renderer->absoluteContentBox();
+    IntRect boundingBox = renderer->absoluteBoundingBoxRect();
+
+    // FIXME: Should we add methods to RenderObject to obtain these rects?
+    IntRect paddingBox(contentBox.x() - renderer->paddingLeft(), contentBox.y() - renderer->paddingTop(), contentBox.width() + renderer->paddingLeft() + renderer->paddingRight(), contentBox.height() + renderer->paddingTop() + renderer->paddingBottom());
+    IntRect borderBox(paddingBox.x() - renderer->borderLeft(), paddingBox.y() - renderer->borderTop(), paddingBox.width() + renderer->borderLeft() + renderer->borderRight(), paddingBox.height() + renderer->borderTop() + renderer->borderBottom());
+    IntRect marginBox(borderBox.x() - renderer->marginLeft(), borderBox.y() - renderer->marginTop(), borderBox.width() + renderer->marginLeft() + renderer->marginRight(), borderBox.height() + renderer->marginTop() + renderer->marginBottom());
+
+    convertFromFrameToMainFrame(containingFrame, contentBox);
+    convertFromFrameToMainFrame(containingFrame, paddingBox);
+    convertFromFrameToMainFrame(containingFrame, borderBox);
+    convertFromFrameToMainFrame(containingFrame, marginBox);
+    convertFromFrameToMainFrame(containingFrame, boundingBox);
+
+    Vector<IntRect> lineBoxRects;
+    if (renderer->isInline() || (renderer->isText() && !m_highlightedNode->isSVGElement())) {
+        // FIXME: We should show margins/padding/border for inlines.
+        renderer->addLineBoxRects(lineBoxRects);
+    }
+
+    for (unsigned i = 0; i < lineBoxRects.size(); ++i)
+        convertFromFrameToMainFrame(containingFrame, lineBoxRects[i]);
+
+    if (lineBoxRects.isEmpty() && contentBox.isEmpty()) {
+        // If we have no line boxes and our content box is empty, we'll just draw our bounding box.
+        // This can happen, e.g., with an <a> enclosing an <img style="float:right">.
+        // FIXME: Can we make this better/more accurate? The <a> in the above case has no
+        // width/height but the highlight makes it appear to be the size of the <img>.
+        lineBoxRects.append(boundingBox);
+    }
+
+    ASSERT(m_inspectedPage);
+
+    FrameView* view = m_inspectedPage->mainFrame()->view();
+    FloatRect overlayRect = view->visibleContentRect();
+
+    if (!overlayRect.contains(boundingBox) && !boundingBox.contains(enclosingIntRect(overlayRect))) {
+        Element* element;
+        if (m_highlightedNode->isElementNode())
+            element = static_cast<Element*>(m_highlightedNode.get());
+        else
+            element = static_cast<Element*>(m_highlightedNode->parent());
+        overlayRect = view->visibleContentRect();
+    }
+
+    context.translate(-overlayRect.x(), -overlayRect.y());
+
+    drawHighlightForBoxes(context, lineBoxRects, contentBox, paddingBox, borderBox, marginBox);
+}
+
+void InspectorController::count(const UString& title, unsigned lineNumber, const String& sourceID)
+{
+    String identifier = String(title) + String::format("@%s:%d", sourceID.utf8().data(), lineNumber);
+    HashMap<String, unsigned>::iterator it = m_counts.find(identifier);
+    int count;
+    if (it == m_counts.end())
+        count = 1;
+    else {
+        count = it->second + 1;
+        m_counts.remove(it);
+    }
+
+    m_counts.add(identifier, count);
+
+    String message = String::format("%s: %d", title.UTF8String().c_str(), count);
+    addMessageToConsole(JSMessageSource, LogMessageLevel, message, lineNumber, sourceID);
+}
+
+void InspectorController::startTiming(const UString& title)
+{
+    m_times.add(title, currentTime() * 1000);
+}
+
+bool InspectorController::stopTiming(const UString& title, double& elapsed)
+{
+    HashMap<String, double>::iterator it = m_times.find(title);
+    if (it == m_times.end())
+        return false;
+
+    double startTime = it->second;
+    m_times.remove(it);
+    
+    elapsed = currentTime() * 1000 - startTime;
+    return true;
+}
+
+bool InspectorController::handleException(JSContextRef context, JSValueRef exception, unsigned lineNumber) const
+{
+    if (!exception)
+        return false;
+
+    if (!m_page)
+        return true;
+
+    String message = toString(context, exception, 0);
+    String file(__FILE__);
+
+    if (JSObjectRef exceptionObject = JSValueToObject(context, exception, 0)) {
+        JSValueRef lineValue = JSObjectGetProperty(context, exceptionObject, jsStringRef("line").get(), NULL);
+        if (lineValue)
+            lineNumber = static_cast<unsigned>(JSValueToNumber(context, lineValue, 0));
+
+        JSValueRef fileValue = JSObjectGetProperty(context, exceptionObject, jsStringRef("sourceURL").get(), NULL);
+        if (fileValue)
+            file = toString(context, fileValue, 0);
+    }
+
+    m_page->mainFrame()->domWindow()->console()->addMessage(JSMessageSource, ErrorMessageLevel, message, lineNumber, file);
+    return true;
+}
+
+#if ENABLE(JAVASCRIPT_DEBUGGER)
+// JavaScriptDebugListener functions
+
+void InspectorController::didParseSource(ExecState* exec, const SourceCode& source)
+{
+    JSValueRef sourceIDValue = JSValueMakeNumber(m_scriptContext, source.provider()->asID());
+    JSValueRef sourceURLValue = JSValueMakeString(m_scriptContext, jsStringRef(source.provider()->url()).get());
+    JSValueRef sourceValue = JSValueMakeString(m_scriptContext, jsStringRef(source).get());
+    JSValueRef firstLineValue = JSValueMakeNumber(m_scriptContext, source.firstLine());
+
+    JSValueRef exception = 0;
+    JSValueRef arguments[] = { sourceIDValue, sourceURLValue, sourceValue, firstLineValue };
+    callFunction(m_scriptContext, m_scriptObject, "parsedScriptSource", 4, arguments, exception);
+}
+
+void InspectorController::failedToParseSource(ExecState* exec, const SourceCode& source, int errorLine, const UString& errorMessage)
+{
+    JSValueRef sourceURLValue = JSValueMakeString(m_scriptContext, jsStringRef(source.provider()->url()).get());
+    JSValueRef sourceValue = JSValueMakeString(m_scriptContext, jsStringRef(source.data()).get());
+    JSValueRef firstLineValue = JSValueMakeNumber(m_scriptContext, source.firstLine());
+    JSValueRef errorLineValue = JSValueMakeNumber(m_scriptContext, errorLine);
+    JSValueRef errorMessageValue = JSValueMakeString(m_scriptContext, jsStringRef(errorMessage).get());
+
+    JSValueRef exception = 0;
+    JSValueRef arguments[] = { sourceURLValue, sourceValue, firstLineValue, errorLineValue, errorMessageValue };
+    callFunction(m_scriptContext, m_scriptObject, "failedToParseScriptSource", 5, arguments, exception);
+}
+
+void InspectorController::didPause()
+{
+    JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "pausedScript", 0, 0, exception);
+}
+#endif
+
+} // namespace WebCore