Remember the docked state of the Web Inspector, so it can be reopened docked if it...
[WebKit-https.git] / WebCore / page / InspectorController.cpp
index e2a6d38..021bb55 100644 (file)
 #include "GraphicsContext.h"
 #include "HTMLFrameOwnerElement.h"
 #include "InspectorClient.h"
+#include "JavaScriptCallFrame.h"
 #include "JSDOMWindow.h"
 #include "JSInspectedObjectWrapper.h"
 #include "JSInspectorCallbackWrapper.h"
+#include "JSJavaScriptCallFrame.h"
 #include "JSNode.h"
 #include "JSRange.h"
 #include "JavaScriptDebugServer.h"
+#include "JavaScriptProfile.h"
 #include "Page.h"
 #include "Range.h"
 #include "ResourceRequest.h"
 #include "SystemTime.h"
 #include "TextEncoding.h"
 #include "TextIterator.h"
-#include "kjs_proxy.h"
+#include "ScriptController.h"
 #include <JavaScriptCore/APICast.h>
-#include <JavaScriptCore/JSLock.h>
 #include <JavaScriptCore/JSRetainPtr.h>
 #include <JavaScriptCore/JSStringRef.h>
 #include <kjs/ustring.h>
+#include <profiler/Profile.h>
+#include <profiler/Profiler.h>
 #include <wtf/RefCounted.h>
 
 #if ENABLE(DATABASE)
@@ -79,63 +83,93 @@ 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 SourceProvider& 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()));
 }
 
-#define HANDLE_EXCEPTION(exception) handleException((exception), __LINE__)
+static JSRetainPtr<JSStringRef> jsStringRef(const UString& str)
+{
+    return JSRetainPtr<JSStringRef>(toRef(str.rep()));
+}
+
+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);
 
-    JSValueRef exception = 0;
+    if (exception)
+        return JSValueMakeUndefined(context);
 
     JSValueRef functionProperty = JSObjectGetProperty(context, thisObject, jsStringRef(functionName).get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(context, exception))
         return JSValueMakeUndefined(context);
 
     JSObjectRef function = JSValueToObject(context, functionProperty, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(context, exception))
         return JSValueMakeUndefined(context);
 
-    JSValueRef result = JSObjectCallAsFunction(context, function, thisObject, 0, 0, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    JSValueRef result = JSObjectCallAsFunction(context, function, thisObject, argumentCount, arguments, &exception);
+    if (HANDLE_EXCEPTION(context, exception))
         return JSValueMakeUndefined(context);
 
     return result;
 }
 
-#pragma mark -
-#pragma mark ConsoleMessage Struct
+// ConsoleMessage Struct
 
 struct ConsoleMessage {
-    ConsoleMessage(MessageSource s, MessageLevel l, const String& m, unsigned li, const String& u)
+    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)
     {
     }
 
-    ConsoleMessage(MessageSource s, MessageLevel l, ExecState* exec, const List& args, unsigned li, const String& u)
+    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)
     {
-        JSLock lock;
         for (unsigned i = 0; i < args.size(); ++i)
-            wrappedArguments[i] = JSInspectedObjectWrapper::wrap(exec, args[i]);
+            wrappedArguments[i] = JSInspectedObjectWrapper::wrap(exec, args.at(exec, i));
     }
 
     MessageSource source;
@@ -144,29 +178,26 @@ struct ConsoleMessage {
     Vector<ProtectedPtr<JSValue> > wrappedArguments;
     unsigned line;
     String url;
+    unsigned groupLevel;
 };
 
-#pragma mark -
-#pragma mark XMLHttpRequestResource Class
+// XMLHttpRequestResource Class
 
 struct XMLHttpRequestResource {
     XMLHttpRequestResource(KJS::UString& sourceString)
     {
-        KJS::JSLock lock;
         this->sourceString = sourceString.rep();
     }
 
     ~XMLHttpRequestResource()
     {
-        KJS::JSLock lock;
         sourceString.clear();
     }
 
     RefPtr<KJS::UString::Rep> sourceString;
 };
 
-#pragma mark -
-#pragma mark InspectorResource Struct
+// InspectorResource Struct
 
 struct InspectorResource : public RefCounted<InspectorResource> {
     // Keep these in sync with WebInspector.Resource.Type
@@ -177,6 +208,7 @@ struct InspectorResource : public RefCounted<InspectorResource> {
         Font,
         Script,
         XHR,
+        Media,
         Other
     };
 
@@ -311,8 +343,7 @@ protected:
     }
 };
 
-#pragma mark -
-#pragma mark InspectorDatabaseResource Struct
+// InspectorDatabaseResource Struct
 
 #if ENABLE(DATABASE)
 struct InspectorDatabaseResource : public RefCounted<InspectorDatabaseResource> {
@@ -354,10 +385,45 @@ private:
 };
 #endif
 
-#pragma mark -
-#pragma mark JavaScript Callbacks
+// JavaScript Callbacks
 
-static JSValueRef addSourceToFrame(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
+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);
 
@@ -369,7 +435,7 @@ static JSValueRef addSourceToFrame(JSContextRef ctx, JSObjectRef /*function*/, J
     if (!JSValueIsNumber(ctx, identifierValue))
         return undefined;
 
-    unsigned long identifier = static_cast<unsigned long>(JSValueToNumber(ctx, identifierValue, exception));
+    long long identifier = static_cast<long long>(JSValueToNumber(ctx, identifierValue, exception));
     if (exception && *exception)
         return undefined;
 
@@ -382,36 +448,36 @@ static JSValueRef addSourceToFrame(JSContextRef ctx, JSObjectRef /*function*/, J
     if (sourceString.isEmpty())
         return undefined;
 
-    Node* node = toNode(toJS(arguments[1]));
-    ASSERT(node);
-    if (!node)
-        return undefined;
+    addSourceToFrame(resource->mimeType, sourceString, toNode(toJS(arguments[1])));
 
-    if (!node->attached()) {
-        ASSERT_NOT_REACHED();
+    return undefined;
+}
+
+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;
-    }
 
-    ASSERT(node->isElementNode());
-    if (!node->isElementNode())
+    JSValueRef mimeTypeValue = arguments[0];
+    if (!JSValueIsString(ctx, mimeTypeValue))
         return undefined;
 
-    Element* element = static_cast<Element*>(node);
-    ASSERT(element->isFrameOwnerElement());
-    if (!element->isFrameOwnerElement())
+    JSValueRef sourceValue = arguments[1];
+    if (!JSValueIsString(ctx, sourceValue))
         return undefined;
 
-    HTMLFrameOwnerElement* frameOwner = static_cast<HTMLFrameOwnerElement*>(element);
-    ASSERT(frameOwner->contentFrame());
-    if (!frameOwner->contentFrame())
+    String mimeType = toString(ctx, mimeTypeValue, exception);
+    if (mimeType.isEmpty())
         return undefined;
 
-    FrameLoader* loader = frameOwner->contentFrame()->loader();
+    String source = toString(ctx, sourceValue, exception);
+    if (source.isEmpty())
+        return undefined;
 
-    loader->setResponseMIMEType(resource->mimeType);
-    loader->begin();
-    loader->write(sourceString);
-    loader->end();
+    addSourceToFrame(mimeType, source, toNode(toJS(arguments[2])));
 
     return undefined;
 }
@@ -428,7 +494,7 @@ static JSValueRef getResourceDocumentNode(JSContextRef ctx, JSObjectRef /*functi
     if (!JSValueIsNumber(ctx, identifierValue))
         return undefined;
 
-    unsigned long identifier = static_cast<unsigned long>(JSValueToNumber(ctx, identifierValue, exception));
+    long long identifier = static_cast<long long>(JSValueToNumber(ctx, identifierValue, exception));
     if (exception && *exception)
         return undefined;
 
@@ -443,12 +509,11 @@ static JSValueRef getResourceDocumentNode(JSContextRef ctx, JSObjectRef /*functi
     if (!document)
         return undefined;
 
-    if (document->isPluginDocument() || document->isImageDocument())
+    if (document->isPluginDocument() || document->isImageDocument() || document->isMediaDocument())
         return undefined;
 
-    ExecState* exec = toJSDOMWindowWrapper(resource->frame.get())->window()->globalExec();
+    ExecState* exec = toJSDOMWindowShell(resource->frame.get())->window()->globalExec();
 
-    KJS::JSLock lock;
     JSValueRef documentValue = toRef(JSInspectedObjectWrapper::wrap(exec, toJS(exec, document)));
     return documentValue;
 }
@@ -539,11 +604,7 @@ static JSValueRef search(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef
     if (!node)
         return JSValueMakeUndefined(ctx);
 
-    JSRetainPtr<JSStringRef> searchString(Adopt, JSValueToStringCopy(ctx, arguments[1], exception));
-    if (exception && *exception)
-        return JSValueMakeUndefined(ctx);
-
-    String target(JSStringGetCharactersPtr(searchString.get()), JSStringGetLength(searchString.get()));
+    String target = toString(ctx, arguments[1], exception);
 
     JSObjectRef global = JSContextGetGlobalObject(ctx);
 
@@ -581,7 +642,6 @@ static JSValueRef search(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef
         if (newStart == startVisiblePosition(searchRange.get(), DOWNSTREAM))
             break;
 
-        KJS::JSLock lock;
         JSValueRef arg0 = toRef(toJS(toJS(ctx), resultRange.get()));
         JSObjectCallAsFunction(ctx, pushFunction, result, 1, &arg0, exception);
         if (exception && *exception)
@@ -656,7 +716,6 @@ static JSValueRef inspectedWindow(JSContextRef ctx, JSObjectRef /*function*/, JS
         return JSValueMakeUndefined(ctx);
 
     JSDOMWindow* inspectedWindow = toJSDOMWindow(controller->inspectedPage()->mainFrame());
-    JSLock lock;
     return toRef(JSInspectedObjectWrapper::wrap(inspectedWindow->globalExec(), inspectedWindow));
 }
 
@@ -720,6 +779,24 @@ static JSValueRef moveByUnrestricted(JSContextRef ctx, JSObjectRef /*function*/,
     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));
@@ -729,7 +806,6 @@ static JSValueRef wrapCallback(JSContextRef ctx, JSObjectRef /*function*/, JSObj
     if (argumentCount < 1)
         return JSValueMakeUndefined(ctx);
 
-    JSLock lock;
     return toRef(JSInspectorCallbackWrapper::wrap(toJS(ctx), toJS(arguments[0])));
 }
 
@@ -755,8 +831,240 @@ static JSValueRef stopDebugging(JSContextRef ctx, JSObjectRef /*function*/, JSOb
     return JSValueMakeUndefined(ctx);
 }
 
-#pragma mark -
-#pragma mark InspectorController Class
+static JSValueRef debuggerAttached(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+    return JSValueMakeBoolean(ctx, controller->debuggerAttached());
+}
+
+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();
+
+    return toRef(JSInspectedObjectWrapper::wrap(globalExec, toJS(toJS(ctx), callFrame)));
+}
+
+static JSValueRef pauseOnExceptions(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+    return JSValueMakeBoolean(ctx, controller->pauseOnExceptions());
+}
+
+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 pauseInDebugger(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->pauseInDebugger();
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef resumeDebugger(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->resumeDebugger();
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef stepOverStatementInDebugger(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->stepOverStatementInDebugger();
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef stepIntoStatementInDebugger(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->stepIntoStatementInDebugger();
+
+    return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef stepOutOfFunctionInDebugger(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->stepOutOfFunctionInDebugger();
+
+    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);
+}
+
+static JSValueRef isWindowVisible(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+    return JSValueMakeBoolean(ctx, controller->windowVisible());
+}
+
+static JSValueRef closeWindow(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (!controller)
+        return JSValueMakeUndefined(ctx);
+
+    controller->closeWindow();
+
+    return JSValueMakeUndefined(ctx);
+}
+
+// Profiles
+
+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);
+
+    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;
+}
+
+static JSValueRef clearMessages(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (controller)
+        controller->clearConsoleMessages();
+
+    return JSValueMakeUndefined(ctx);
+}
+
+
+static JSValueRef startProfiling(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (controller)
+        controller->startUserInitiatedProfiling();
+
+   return JSValueMakeUndefined(ctx);
+}
+
+static JSValueRef stopProfiling(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t /*argumentCount*/, const JSValueRef[] /*arguments*/, JSValueRef* /*exception*/)
+{
+    InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
+    if (controller)
+        controller->stopUserInitiatedProfiling();
+
+    return JSValueMakeUndefined(ctx);
+}
+
+// InspectorController Class
 
 InspectorController::InspectorController(Page* page, InspectorClient* client)
     : m_inspectedPage(page)
@@ -766,8 +1074,12 @@ InspectorController::InspectorController(Page* page, InspectorClient* client)
     , m_controllerScriptObject(0)
     , m_scriptContext(0)
     , m_windowVisible(false)
-    , m_showAfterVisible(FocusedNodeDocumentPanel)
+    , m_debuggerAttached(false)
+    , m_attachDebuggerWhenShown(false)
+    , m_recordingUserInitiatedProfile(false)
+    , m_showAfterVisible(ElementsPanel)
     , m_nextIdentifier(-2)
+    , m_groupLevel(0)
 {
     ASSERT_ARG(page, page);
     ASSERT_ARG(client, client);
@@ -782,9 +1094,9 @@ InspectorController::~InspectorController()
 
         JSObjectRef global = JSContextGetGlobalObject(m_scriptContext);
         JSValueRef controllerProperty = JSObjectGetProperty(m_scriptContext, global, jsStringRef("InspectorController").get(), &exception);
-        if (!HANDLE_EXCEPTION(exception)) {
+        if (!HANDLE_EXCEPTION(m_scriptContext, exception)) {
             if (JSObjectRef controller = JSValueToObject(m_scriptContext, controllerProperty, &exception)) {
-                if (!HANDLE_EXCEPTION(exception))
+                if (!HANDLE_EXCEPTION(m_scriptContext, exception))
                     JSObjectSetPrivate(controller, 0);
             }
         }
@@ -793,14 +1105,26 @@ InspectorController::~InspectorController()
     if (m_page)
         m_page->setParentInspectorController(0);
 
-    stopDebugging();
+    // m_inspectedPage should have been cleared in inspectedPageDestroyed().
+    ASSERT(!m_inspectedPage);
 
     deleteAllValues(m_frameResources);
     deleteAllValues(m_consoleMessages);
 }
 
+void InspectorController::inspectedPageDestroyed()
+{
+    close();
+
+    ASSERT(m_inspectedPage);
+    m_inspectedPage = 0;
+}
+
 bool InspectorController::enabled() const
 {
+    if (!m_inspectedPage)
+        return false;
+
     return m_inspectedPage->settings()->developerExtrasEnabled();
 }
 
@@ -819,7 +1143,7 @@ static bool canPassNodeToJavaScript(Node* node)
     if (!node)
         return false;
     Frame* frame = node->document()->frame();
-    return frame && frame->scriptProxy()->isEnabled();
+    return frame && frame->script()->isEnabled();
 }
 
 void InspectorController::inspect(Node* node)
@@ -834,7 +1158,7 @@ void InspectorController::inspect(Node* node)
     m_nodeToFocus = node;
 
     if (!m_scriptObject) {
-        m_showAfterVisible = FocusedNodeDocumentPanel;
+        m_showAfterVisible = ElementsPanel;
         return;
     }
 
@@ -857,29 +1181,12 @@ void InspectorController::focusNode()
 
     ExecState* exec = toJSDOMWindow(frame)->globalExec();
 
-    JSValueRef arg0;
-
-    {
-        KJS::JSLock lock;
-        arg0 = toRef(JSInspectedObjectWrapper::wrap(exec, toJS(exec, m_nodeToFocus.get())));
-    }
+    JSValueRef arg0 = toRef(JSInspectedObjectWrapper::wrap(exec, toJS(exec, m_nodeToFocus.get())));
 
     m_nodeToFocus = 0;
 
     JSValueRef exception = 0;
-
-    JSValueRef functionProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("updateFocusedNode").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return;
-
-    JSObjectRef function = JSValueToObject(m_scriptContext, functionProperty, &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return;
-
-    ASSERT(function);
-
-    JSObjectCallAsFunction(m_scriptContext, function, m_scriptObject, 1, &arg0, &exception);
-    HANDLE_EXCEPTION(exception);
+    callFunction(m_scriptContext, m_scriptObject, "updateFocusedNode", 1, &arg0, exception);
 }
 
 void InspectorController::highlight(Node* node)
@@ -903,7 +1210,7 @@ bool InspectorController::windowVisible()
     return m_windowVisible;
 }
 
-void InspectorController::setWindowVisible(bool visible)
+void InspectorController::setWindowVisible(bool visible, bool attached)
 {
     if (visible == m_windowVisible)
         return;
@@ -914,25 +1221,26 @@ void InspectorController::setWindowVisible(bool visible)
         return;
 
     if (m_windowVisible) {
+        setAttachedWindow(attached);
         populateScriptObjects();
         if (m_nodeToFocus)
             focusNode();
-        if (m_showAfterVisible == ConsolePanel)
-            showConsole();
-        else if (m_showAfterVisible == TimelinePanel)
-            showTimeline();
+        if (m_attachDebuggerWhenShown)
+            startDebuggingAndReloadInspectedPage();
+        if (m_showAfterVisible != CurrentPanel)
+            showPanel(m_showAfterVisible);
     } else
         resetScriptObjects();
 
-    m_showAfterVisible = FocusedNodeDocumentPanel;
+    m_showAfterVisible = CurrentPanel;
 }
 
-void InspectorController::addMessageToConsole(MessageSource source, MessageLevel level, ExecState* exec, const List& arguments, unsigned lineNumber, const String& sourceURL)
+void InspectorController::addMessageToConsole(MessageSource source, MessageLevel level, ExecState* exec, const ArgList& arguments, unsigned lineNumber, const String& sourceURL)
 {
     if (!enabled())
         return;
 
-    addConsoleMessage(new ConsoleMessage(source, level, exec, arguments, lineNumber, sourceURL));
+    addConsoleMessage(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)
@@ -940,7 +1248,7 @@ void InspectorController::addMessageToConsole(MessageSource source, MessageLevel
     if (!enabled())
         return;
 
-    addConsoleMessage(new ConsoleMessage(source, level, message, lineNumber, sourceID));
+    addConsoleMessage(new ConsoleMessage(source, level, message, lineNumber, sourceID, m_groupLevel));
 }
 
 void InspectorController::addConsoleMessage(ConsoleMessage* consoleMessage)
@@ -954,6 +1262,57 @@ void InspectorController::addConsoleMessage(ConsoleMessage* consoleMessage)
         addScriptConsoleMessage(consoleMessage);
 }
 
+void InspectorController::clearConsoleMessages()
+{
+    deleteAllValues(m_consoleMessages);
+    m_consoleMessages.clear();
+}
+
+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()
+{    
+    JSValueRef exception = 0;
+
+    ++m_groupLevel;
+
+    if (windowVisible())
+        callFunction(m_scriptContext, m_scriptObject, "startGroupInConsole", 0, NULL, exception);
+}
+
+void InspectorController::endGroup()
+{
+    JSValueRef exception = 0;
+
+    if (m_groupLevel == 0)
+        return;
+
+    --m_groupLevel;
+
+    if (windowVisible())
+        callFunction(m_scriptContext, m_scriptObject, "endGroupInConsole", 0, NULL, exception);
+}
+
+void InspectorController::addProfile(PassRefPtr<Profile> prpProfile)
+{
+    if (!enabled())
+        return;
+
+    RefPtr<Profile> profile = prpProfile;
+    m_profiles.append(profile);
+
+    if (windowVisible())
+        addScriptProfile(profile.get());
+}
+
 void InspectorController::attachWindow()
 {
     if (!enabled())
@@ -968,17 +1327,50 @@ void InspectorController::detachWindow()
     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::inspectedWindowScriptObjectCleared(Frame* frame)
+{
+    if (!enabled() || !m_scriptContext || !m_scriptObject)
+        return;
+
+    JSDOMWindow* win = toJSDOMWindow(frame);
+    ExecState* exec = win->globalExec();
+
+    JSValueRef 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()->scriptProxy()->globalObject()->globalExec());
+    m_scriptContext = toRef(m_page->mainFrame()->script()->globalObject()->globalExec());
 
     JSObjectRef global = JSContextGetGlobalObject(m_scriptContext);
     ASSERT(global);
 
     static JSStaticFunction staticFunctions[] = {
+        { "addResourceSourceToFrame", addResourceSourceToFrame, kJSPropertyAttributeNone },
         { "addSourceToFrame", addSourceToFrame, kJSPropertyAttributeNone },
         { "getResourceDocumentNode", getResourceDocumentNode, kJSPropertyAttributeNone },
         { "highlightDOMNode", highlightDOMNode, kJSPropertyAttributeNone },
@@ -995,9 +1387,27 @@ void InspectorController::windowScriptObjectAvailable()
         { "localizedStringsURL", localizedStrings, kJSPropertyAttributeNone },
         { "platform", platform, kJSPropertyAttributeNone },
         { "moveByUnrestricted", moveByUnrestricted, kJSPropertyAttributeNone },
+        { "setAttachedWindowHeight", WebCore::setAttachedWindowHeight, kJSPropertyAttributeNone },
         { "wrapCallback", wrapCallback, kJSPropertyAttributeNone },
         { "startDebuggingAndReloadInspectedPage", WebCore::startDebuggingAndReloadInspectedPage, kJSPropertyAttributeNone },
         { "stopDebugging", WebCore::stopDebugging, kJSPropertyAttributeNone },
+        { "debuggerAttached", WebCore::debuggerAttached, kJSPropertyAttributeNone },
+        { "profiles", WebCore::profiles, kJSPropertyAttributeNone },
+        { "currentCallFrame", WebCore::currentCallFrame, kJSPropertyAttributeNone },
+        { "pauseOnExceptions", WebCore::pauseOnExceptions, kJSPropertyAttributeNone },
+        { "setPauseOnExceptions", WebCore::setPauseOnExceptions, kJSPropertyAttributeNone },
+        { "pauseInDebugger", WebCore::pauseInDebugger, kJSPropertyAttributeNone },
+        { "resumeDebugger", WebCore::resumeDebugger, kJSPropertyAttributeNone },
+        { "stepOverStatementInDebugger", WebCore::stepOverStatementInDebugger, kJSPropertyAttributeNone },
+        { "stepIntoStatementInDebugger", WebCore::stepIntoStatementInDebugger, kJSPropertyAttributeNone },
+        { "stepOutOfFunctionInDebugger", WebCore::stepOutOfFunctionInDebugger, kJSPropertyAttributeNone },
+        { "addBreakpoint", WebCore::addBreakpoint, kJSPropertyAttributeNone },
+        { "removeBreakpoint", WebCore::removeBreakpoint, kJSPropertyAttributeNone },
+        { "isWindowVisible", WebCore::isWindowVisible, kJSPropertyAttributeNone },
+        { "closeWindow", WebCore::closeWindow, kJSPropertyAttributeNone },
+        { "startProfiling", WebCore::startProfiling, kJSPropertyAttributeNone },
+        { "stopProfiling", WebCore::stopProfiling, kJSPropertyAttributeNone },
+        { "clearMessages", clearMessages, kJSPropertyAttributeNone },
         { 0, 0, 0 }
     };
 
@@ -1027,7 +1437,7 @@ void InspectorController::scriptObjectReady()
     JSValueRef exception = 0;
 
     JSValueRef inspectorValue = JSObjectGetProperty(m_scriptContext, global, jsStringRef("WebInspector").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     ASSERT(inspectorValue);
@@ -1035,7 +1445,7 @@ void InspectorController::scriptObjectReady()
         return;
 
     m_scriptObject = JSValueToObject(m_scriptContext, inspectorValue, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     ASSERT(m_scriptObject);
@@ -1064,7 +1474,7 @@ void InspectorController::show()
     showWindow();
 }
 
-void InspectorController::showConsole()
+void InspectorController::showPanel(SpecialPanels panel)
 {
     if (!enabled())
         return;
@@ -1072,26 +1482,40 @@ void InspectorController::showConsole()
     show();
 
     if (!m_scriptObject) {
-        m_showAfterVisible = ConsolePanel;
+        m_showAfterVisible = panel;
         return;
     }
 
-    callSimpleFunction(m_scriptContext, m_scriptObject, "showConsole");
-}
-
-void InspectorController::showTimeline()
-{
-    if (!enabled())
+    if (panel == CurrentPanel)
         return;
 
-    show();
-
-    if (!m_scriptObject) {
-        m_showAfterVisible = TimelinePanel;
-        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;
     }
 
-    callSimpleFunction(m_scriptContext, m_scriptObject, "showTimeline");
+    if (showFunctionName)
+        callSimpleFunction(m_scriptContext, m_scriptObject, showFunctionName);
 }
 
 void InspectorController::close()
@@ -1099,14 +1523,13 @@ void InspectorController::close()
     if (!enabled())
         return;
 
+    stopUserInitiatedProfiling();
+    stopDebugging();
     closeWindow();
-    if (m_page)
-        m_page->setParentInspectorController(0);
 
-    ASSERT(m_scriptContext && m_scriptObject);
-    JSValueUnprotect(m_scriptContext, m_scriptObject);
+    if (m_scriptContext && m_scriptObject)
+        JSValueUnprotect(m_scriptContext, m_scriptObject);
 
-    m_page = 0;
     m_scriptObject = 0;
     m_scriptContext = 0;
 }
@@ -1114,16 +1537,44 @@ void InspectorController::close()
 void InspectorController::showWindow()
 {
     ASSERT(enabled());
-
     m_client->showWindow();
 }
 
 void InspectorController::closeWindow()
 {
-    stopDebugging();
     m_client->closeWindow();
 }
 
+void InspectorController::startUserInitiatedProfiling()
+{
+    if (!enabled())
+        return;
+
+    m_recordingUserInitiatedProfile = true;
+
+    ExecState* exec = toJSDOMWindow(m_inspectedPage->mainFrame())->globalExec();
+    Profiler::profiler()->startProfiling(exec, UserInitiatedProfileName, this);
+    toggleRecordButton(true);
+}
+
+void InspectorController::stopUserInitiatedProfiling()
+{
+    if (!enabled())
+        return;
+
+    m_recordingUserInitiatedProfile = false;
+
+    ExecState* exec = toJSDOMWindow(m_inspectedPage->mainFrame())->globalExec();
+    Profiler::profiler()->stopProfiling(exec, UserInitiatedProfileName);
+    Profiler::profiler()->didFinishAllExecution(exec);
+    toggleRecordButton(false);
+}
+
+void InspectorController::finishedProfiling(PassRefPtr<Profile> prpProfile)
+{
+    addProfile(prpProfile);
+}
+
 static void addHeaders(JSContextRef context, JSObjectRef object, const HTTPHeaderMap& headers, JSValueRef* exception)
 {
     ASSERT_ARG(context, context);
@@ -1171,11 +1622,11 @@ JSObjectRef InspectorController::addScriptResource(InspectorResource* resource)
         JSValueRef exception = 0;
 
         JSValueRef resourceProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("Resource").get(), &exception);
-        if (HANDLE_EXCEPTION(exception))
+        if (HANDLE_EXCEPTION(m_scriptContext, exception))
             return 0;
 
         JSObjectRef resourceConstructor = JSValueToObject(m_scriptContext, resourceProperty, &exception);
-        if (HANDLE_EXCEPTION(exception))
+        if (HANDLE_EXCEPTION(m_scriptContext, exception))
             return 0;
 
         JSValueRef urlValue = JSValueMakeString(m_scriptContext, jsStringRef(resource->requestURL.string()).get());
@@ -1188,12 +1639,12 @@ JSObjectRef InspectorController::addScriptResource(InspectorResource* resource)
         JSValueRef cached = JSValueMakeBoolean(m_scriptContext, resource->cached);
 
         JSObjectRef scriptObject = scriptObjectForRequest(m_scriptContext, resource, &exception);
-        if (HANDLE_EXCEPTION(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(exception))
+        if (HANDLE_EXCEPTION(m_scriptContext, exception))
             return 0;
 
         ASSERT(result);
@@ -1202,18 +1653,9 @@ JSObjectRef InspectorController::addScriptResource(InspectorResource* resource)
     }
 
     JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "addResource", 1, &resource->scriptObject, exception);
 
-    JSValueRef addResourceProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("addResource").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return 0;
-
-    JSObjectRef addResourceFunction = JSValueToObject(m_scriptContext, addResourceProperty, &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return 0;
-
-    JSValueRef addArguments[] = { resource->scriptObject };
-    JSObjectCallAsFunction(m_scriptContext, addResourceFunction, m_scriptObject, 1, addArguments, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (exception)
         return 0;
 
     return resource->scriptObject;
@@ -1250,18 +1692,7 @@ void InspectorController::removeScriptResource(InspectorResource* resource)
     resource->setScriptObject(0, 0);
 
     JSValueRef exception = 0;
-
-    JSValueRef removeResourceProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("removeResource").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return;
-
-    JSObjectRef removeResourceFunction = JSValueToObject(m_scriptContext, removeResourceProperty, &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return;
-
-    JSValueRef arguments[] = { scriptObject };
-    JSObjectCallAsFunction(m_scriptContext, removeResourceFunction, m_scriptObject, 1, arguments, &exception);
-    HANDLE_EXCEPTION(exception);
+    callFunction(m_scriptContext, m_scriptObject, "removeResource", 1, &scriptObject, exception);
 }
 
 static void updateResourceRequest(InspectorResource* resource, const ResourceRequest& request)
@@ -1296,31 +1727,31 @@ void InspectorController::updateScriptResourceRequest(InspectorResource* resourc
     JSValueRef exception = 0;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("url").get(), urlValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("domain").get(), domainValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("path").get(), pathValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("lastPathComponent").get(), lastPathComponentValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectRef scriptObject = scriptObjectForRequest(m_scriptContext, resource, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("requestHeaders").get(), scriptObject, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("mainResource").get(), mainResourceValue, kJSPropertyAttributeNone, &exception);
-    HANDLE_EXCEPTION(exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
 }
 
 void InspectorController::updateScriptResourceResponse(InspectorResource* resource)
@@ -1340,32 +1771,44 @@ void InspectorController::updateScriptResourceResponse(InspectorResource* resour
     JSValueRef exception = 0;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("mimeType").get(), mimeTypeValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("suggestedFilename").get(), suggestedFilenameValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("expectedContentLength").get(), expectedContentLengthValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("statusCode").get(), statusCodeValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectRef scriptObject = scriptObjectForResponse(m_scriptContext, resource, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("responseHeaders").get(), scriptObject, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(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(exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
 }
 
 void InspectorController::updateScriptResource(InspectorResource* resource, int length)
@@ -1380,7 +1823,7 @@ void InspectorController::updateScriptResource(InspectorResource* resource, int
     JSValueRef exception = 0;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("contentLength").get(), lengthValue, kJSPropertyAttributeNone, &exception);
-    HANDLE_EXCEPTION(exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
 }
 
 void InspectorController::updateScriptResource(InspectorResource* resource, bool finished, bool failed)
@@ -1396,11 +1839,11 @@ void InspectorController::updateScriptResource(InspectorResource* resource, bool
     JSValueRef exception = 0;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("failed").get(), failedValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("finished").get(), finishedValue, kJSPropertyAttributeNone, &exception);
-    HANDLE_EXCEPTION(exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
 }
 
 void InspectorController::updateScriptResource(InspectorResource* resource, double startTime, double responseReceivedTime, double endTime)
@@ -1417,15 +1860,15 @@ void InspectorController::updateScriptResource(InspectorResource* resource, doub
     JSValueRef exception = 0;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("startTime").get(), startTimeValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("responseReceivedTime").get(), responseReceivedTimeValue, kJSPropertyAttributeNone, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectSetProperty(m_scriptContext, resource->scriptObject, jsStringRef("endTime").get(), endTimeValue, kJSPropertyAttributeNone, &exception);
-    HANDLE_EXCEPTION(exception);
+    HANDLE_EXCEPTION(m_scriptContext, exception);
 }
 
 void InspectorController::populateScriptObjects()
@@ -1447,6 +1890,8 @@ void InspectorController::populateScriptObjects()
     for (DatabaseResourcesSet::iterator it = m_databaseResources.begin(); it != databasesEnd; ++it)
         addDatabaseScriptResource((*it).get());
 #endif
+
+    callSimpleFunction(m_scriptContext, m_scriptObject, "populateInterface");
 }
 
 #if ENABLE(DATABASE)
@@ -1469,44 +1914,30 @@ JSObjectRef InspectorController::addDatabaseScriptResource(InspectorDatabaseReso
     JSValueRef exception = 0;
 
     JSValueRef databaseProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("Database").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return 0;
 
     JSObjectRef databaseConstructor = JSValueToObject(m_scriptContext, databaseProperty, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return 0;
 
     ExecState* exec = toJSDOMWindow(frame)->globalExec();
 
-    JSValueRef database;
-
-    {
-        KJS::JSLock lock;
-        database = toRef(JSInspectedObjectWrapper::wrap(exec, toJS(exec, resource->database.get())));
-    }
-
+    JSValueRef 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(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return 0;
 
     ASSERT(result);
 
-    JSValueRef addDatabaseProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("addDatabase").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return 0;
-
-    JSObjectRef addDatabaseFunction = JSValueToObject(m_scriptContext, addDatabaseProperty, &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return 0;
+    callFunction(m_scriptContext, m_scriptObject, "addDatabase", 1, &result, exception);
 
-    JSValueRef addArguments[] = { result };
-    JSObjectCallAsFunction(m_scriptContext, addDatabaseFunction, m_scriptObject, 1, addArguments, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (exception)
         return 0;
 
     resource->setScriptObject(m_scriptContext, result);
@@ -1530,18 +1961,7 @@ void InspectorController::removeDatabaseScriptResource(InspectorDatabaseResource
     resource->setScriptObject(0, 0);
 
     JSValueRef exception = 0;
-
-    JSValueRef removeDatabaseProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("removeDatabase").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return;
-
-    JSObjectRef removeDatabaseFunction = JSValueToObject(m_scriptContext, removeDatabaseProperty, &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return;
-
-    JSValueRef arguments[] = { scriptObject };
-    JSObjectCallAsFunction(m_scriptContext, removeDatabaseFunction, m_scriptObject, 1, arguments, &exception);
-    HANDLE_EXCEPTION(exception);
+    callFunction(m_scriptContext, m_scriptObject, "removeDatabase", 1, &scriptObject, exception);
 }
 #endif
 
@@ -1552,25 +1972,18 @@ void InspectorController::addScriptConsoleMessage(const ConsoleMessage* message)
     JSValueRef exception = 0;
 
     JSValueRef messageConstructorProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("ConsoleMessage").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
     JSObjectRef messageConstructor = JSValueToObject(m_scriptContext, messageConstructorProperty, &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return;
-
-    JSValueRef addMessageProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("addMessageToConsole").get(), &exception);
-    if (HANDLE_EXCEPTION(exception))
-        return;
-
-    JSObjectRef addMessage = JSValueToObject(m_scriptContext, addMessageProperty, &exception);
-    if (HANDLE_EXCEPTION(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);
 
     static const unsigned maximumMessageArguments = 256;
     JSValueRef arguments[maximumMessageArguments];
@@ -1579,6 +1992,7 @@ void InspectorController::addScriptConsoleMessage(const ConsoleMessage* message)
     arguments[argumentCount++] = levelValue;
     arguments[argumentCount++] = lineValue;
     arguments[argumentCount++] = urlValue;
+    arguments[argumentCount++] = groupLevelValue;
 
     if (!message->wrappedArguments.isEmpty()) {
         unsigned remainingSpaceInArguments = maximumMessageArguments - argumentCount;
@@ -1591,11 +2005,17 @@ void InspectorController::addScriptConsoleMessage(const ConsoleMessage* message)
     }
 
     JSObjectRef messageObject = JSObjectCallAsConstructor(m_scriptContext, messageConstructor, argumentCount, arguments, &exception);
-    if (HANDLE_EXCEPTION(exception))
+    if (HANDLE_EXCEPTION(m_scriptContext, exception))
         return;
 
-    JSObjectCallAsFunction(m_scriptContext, addMessage, m_scriptObject, 1, &messageObject, &exception);
-    HANDLE_EXCEPTION(exception);
+    callFunction(m_scriptContext, m_scriptObject, "addMessageToConsole", 1, &messageObject, exception);
+}
+
+void InspectorController::addScriptProfile(Profile* profile)
+{
+    JSValueRef exception = 0;
+    JSValueRef profileObject = toRef(toJS(toJS(m_scriptContext), profile));
+    callFunction(m_scriptContext, m_scriptObject, "addProfile", 1, &profileObject, exception);
 }
 
 void InspectorController::resetScriptObjects()
@@ -1644,11 +2064,16 @@ void InspectorController::didCommitLoad(DocumentLoader* loader)
     if (!enabled())
         return;
 
+    ASSERT(m_inspectedPage);
+
     if (loader->frame() == m_inspectedPage->mainFrame()) {
         m_client->inspectedURLChanged(loader->url().string());
 
         deleteAllValues(m_consoleMessages);
         m_consoleMessages.clear();
+        m_groupLevel = 0;
+
+        m_profiles.clear();
 
 #if ENABLE(DATABASE)
         m_databaseResources.clear();
@@ -1689,6 +2114,7 @@ void InspectorController::frameDetachedFromParent(Frame* frame)
 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);
@@ -1704,6 +2130,7 @@ void InspectorController::addResource(InspectorResource* resource)
 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);
@@ -1724,6 +2151,10 @@ void InspectorController::didLoadResourceFromMemoryCache(DocumentLoader* loader,
     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;
 
@@ -1736,6 +2167,8 @@ void InspectorController::didLoadResourceFromMemoryCache(DocumentLoader* loader,
     resource->responseReceivedTime = resource->startTime;
     resource->endTime = resource->startTime;
 
+    ASSERT(m_inspectedPage);
+
     if (loader->frame() == m_inspectedPage->mainFrame() && request.url() == loader->requestURL())
         m_mainResource = resource;
 
@@ -1754,6 +2187,8 @@ void InspectorController::identifierForInitialRequest(unsigned long identifier,
 
     updateResourceRequest(resource.get(), request);
 
+    ASSERT(m_inspectedPage);
+
     if (loader->frame() == m_inspectedPage->mainFrame() && request.url() == loader->requestURL())
         m_mainResource = resource;
 
@@ -1881,6 +2316,9 @@ void InspectorController::resourceRetrievedByXMLHttpRequest(unsigned long identi
         return;
 
     resource->setXMLHttpRequestProperties(sourceString);
+
+    if (windowVisible() && resource->scriptObject)
+        updateScriptResourceType(resource);
 }
 
 
@@ -1911,13 +2349,99 @@ void InspectorController::moveWindowBy(float x, float y) const
 
 void InspectorController::startDebuggingAndReloadInspectedPage()
 {
+    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_debuggerAttached = true;
+    m_attachDebuggerWhenShown = false;
+
+    callSimpleFunction(m_scriptContext, m_scriptObject, "debuggerAttached");
+
     m_inspectedPage->mainFrame()->loader()->reload();
 }
 
 void InspectorController::stopDebugging()
 {
+    if (!enabled())
+        return;
+
+    ASSERT(m_inspectedPage);
+
     JavaScriptDebugServer::shared().removeListener(this, m_inspectedPage);
+    m_debuggerAttached = false;
+
+    if (m_scriptContext && m_scriptObject)
+        callSimpleFunction(m_scriptContext, m_scriptObject, "debuggerDetached");
+}
+
+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_debuggerAttached)
+        return;
+    JavaScriptDebugServer::shared().pauseProgram();
+}
+
+void InspectorController::resumeDebugger()
+{
+    if (!m_debuggerAttached)
+        return;
+    JavaScriptDebugServer::shared().continueProgram();
+}
+
+void InspectorController::stepOverStatementInDebugger()
+{
+    if (!m_debuggerAttached)
+        return;
+    JavaScriptDebugServer::shared().stepOverStatement();
+}
+
+void InspectorController::stepIntoStatementInDebugger()
+{
+    if (!m_debuggerAttached)
+        return;
+    JavaScriptDebugServer::shared().stepIntoStatement();
+}
+
+void InspectorController::stepOutOfFunctionInDebugger()
+{
+    if (!m_debuggerAttached)
+        return;
+    JavaScriptDebugServer::shared().stepOutOfFunction();
+}
+
+void InspectorController::addBreakpoint(int sourceID, unsigned lineNumber)
+{
+    JavaScriptDebugServer::shared().addBreakpoint(sourceID, lineNumber);
+}
+
+void InspectorController::removeBreakpoint(int sourceID, unsigned lineNumber)
+{
+    JavaScriptDebugServer::shared().removeBreakpoint(sourceID, lineNumber);
 }
 
 static void drawOutlinedRect(GraphicsContext& context, const IntRect& rect, const Color& fillColor)
@@ -1960,28 +2484,44 @@ static void drawHighlightForBoxes(GraphicsContext& context, const Vector<IntRect
     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();
-    if (!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());
 
-    IntRect boundingBox = renderer->absoluteBoundingBoxRect();
+    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">.
@@ -1990,6 +2530,8 @@ void InspectorController::drawNodeHighlight(GraphicsContext& context) const
         lineBoxRects.append(boundingBox);
     }
 
+    ASSERT(m_inspectedPage);
+
     FrameView* view = m_inspectedPage->mainFrame()->view();
     FloatRect overlayRect = view->visibleContentRect();
 
@@ -2008,7 +2550,25 @@ void InspectorController::drawNodeHighlight(GraphicsContext& context) const
     drawHighlightForBoxes(context, lineBoxRects, contentBox, paddingBox, borderBox, marginBox);
 }
 
-bool InspectorController::handleException(JSValueRef exception, unsigned lineNumber) const
+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;
@@ -2016,38 +2576,54 @@ bool InspectorController::handleException(JSValueRef exception, unsigned lineNum
     if (!m_page)
         return true;
 
-    JSRetainPtr<JSStringRef> messageString(Adopt, JSValueToStringCopy(m_scriptContext, exception, 0));
-    String message(JSStringGetCharactersPtr(messageString.get()), JSStringGetLength(messageString.get()));
+    String message = toString(context, exception, 0);
+    String file(__FILE__);
 
-    m_page->mainFrame()->domWindow()->console()->addMessage(JSMessageSource, ErrorMessageLevel, message, lineNumber, __FILE__);
-    return true;
-}
+    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));
 
-#pragma mark -
-#pragma mark JavaScriptDebugListener functions
+        JSValueRef fileValue = JSObjectGetProperty(context, exceptionObject, jsStringRef("sourceURL").get(), NULL);
+        if (fileValue)
+            file = toString(context, fileValue, 0);
+    }
 
-void InspectorController::didParseSource(ExecState*, const String& /*source*/, int /*startingLineNumber*/, const String& /*sourceURL*/, int /*sourceID*/)
-{
+    m_page->mainFrame()->domWindow()->console()->addMessage(JSMessageSource, ErrorMessageLevel, message, lineNumber, file);
+    return true;
 }
 
-void InspectorController::failedToParseSource(ExecState*, const String& /*source*/, int /*startingLineNumber*/, const String& /*sourceURL*/, int /*errorLine*/, const String& /*errorMessage*/)
-{
-}
+// JavaScriptDebugListener functions
 
-void InspectorController::didEnterCallFrame(ExecState*, int /*sourceID*/, int /*lineNumber*/)
+void InspectorController::didParseSource(ExecState*, const SourceProvider& source, int startingLineNumber, const UString& sourceURL, int sourceID)
 {
-}
+    JSValueRef sourceIDValue = JSValueMakeNumber(m_scriptContext, sourceID);
+    JSValueRef sourceURLValue = JSValueMakeString(m_scriptContext, jsStringRef(sourceURL).get());
+    JSValueRef sourceValue = JSValueMakeString(m_scriptContext, jsStringRef(source).get());
+    JSValueRef startingLineNumberValue = JSValueMakeNumber(m_scriptContext, startingLineNumber);
 
-void InspectorController::willExecuteStatement(ExecState*, int /*sourceID*/, int /*lineNumber*/)
-{
+    JSValueRef exception = 0;
+    JSValueRef arguments[] = { sourceIDValue, sourceURLValue, sourceValue, startingLineNumberValue };
+    callFunction(m_scriptContext, m_scriptObject, "parsedScriptSource", 4, arguments, exception);
 }
 
-void InspectorController::willLeaveCallFrame(ExecState*, int /*sourceID*/, int /*lineNumber*/)
+void InspectorController::failedToParseSource(ExecState*, const SourceProvider& source, int startingLineNumber, const UString& sourceURL, int errorLine, const UString& errorMessage)
 {
+    JSValueRef sourceURLValue = JSValueMakeString(m_scriptContext, jsStringRef(sourceURL).get());
+    JSValueRef sourceValue = JSValueMakeString(m_scriptContext, jsStringRef(source.data()).get());
+    JSValueRef startingLineNumberValue = JSValueMakeNumber(m_scriptContext, startingLineNumber);
+    JSValueRef errorLineValue = JSValueMakeNumber(m_scriptContext, errorLine);
+    JSValueRef errorMessageValue = JSValueMakeString(m_scriptContext, jsStringRef(errorMessage).get());
+
+    JSValueRef exception = 0;
+    JSValueRef arguments[] = { sourceURLValue, sourceValue, startingLineNumberValue, errorLineValue, errorMessageValue };
+    callFunction(m_scriptContext, m_scriptObject, "failedToParseScriptSource", 5, arguments, exception);
 }
 
-void InspectorController::exceptionWasRaised(ExecState*, int /*sourceID*/, int /*lineNumber*/)
+void InspectorController::didPause()
 {
+    JSValueRef exception = 0;
+    callFunction(m_scriptContext, m_scriptObject, "pausedScript", 0, 0, exception);
 }
 
 } // namespace WebCore