diff --git a/engine/bindings/core/v8/DebuggerScript.js b/engine/bindings/core/v8/DebuggerScript.js
new file mode 100644
index 00000000000..695586874c2
--- /dev/null
+++ b/engine/bindings/core/v8/DebuggerScript.js
@@ -0,0 +1,548 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+(function () {
+
+var DebuggerScript = {};
+
+DebuggerScript.PauseOnExceptionsState = {
+    DontPauseOnExceptions: 0,
+    PauseOnAllExceptions: 1,
+    PauseOnUncaughtExceptions: 2
+};
+
+DebuggerScript.ScopeInfoDetails = {
+    AllScopes: 0,
+    FastAsyncScopes: 1,
+    NoScopes: 2
+};
+
+DebuggerScript._pauseOnExceptionsState = DebuggerScript.PauseOnExceptionsState.DontPauseOnExceptions;
+Debug.clearBreakOnException();
+Debug.clearBreakOnUncaughtException();
+
+DebuggerScript.getAfterCompileScript = function(eventData)
+{
+    return DebuggerScript._formatScript(eventData.script_.script_);
+}
+
+DebuggerScript.getWorkerScripts = function()
+{
+    var result = [];
+    var scripts = Debug.scripts();
+    for (var i = 0; i < scripts.length; ++i) {
+        var script = scripts[i];
+        // Workers don't share same V8 heap now so there is no need to complicate stuff with
+        // the context id like we do to discriminate between scripts from different pages.
+        // However we need to filter out v8 native scripts.
+        if (script.context_data && script.context_data === "worker")
+            result.push(DebuggerScript._formatScript(script));
+    }
+    return result;
+}
+
+DebuggerScript.getFunctionScopes = function(fun)
+{
+    var mirror = MakeMirror(fun);
+    var count = mirror.scopeCount();
+    if (count == 0)
+        return null;
+    var result = [];
+    for (var i = 0; i < count; i++) {
+        var scopeDetails = mirror.scope(i).details();
+        result[i] = {
+            type: scopeDetails.type(),
+            object: DebuggerScript._buildScopeObject(scopeDetails.type(), scopeDetails.object())
+        };
+    }
+    return result;
+}
+
+DebuggerScript.getCollectionEntries = function(object)
+{
+    var mirror = MakeMirror(object, true /* transient */);
+    if (mirror.isMap())
+        return mirror.entries();
+    if (mirror.isSet()) {
+        var result = [];
+        var values = mirror.values();
+        for (var i = 0; i < values.length; ++i)
+            result.push({ value: values[i] });
+        return result;
+    }
+}
+
+DebuggerScript.getInternalProperties = function(value)
+{
+    var properties = ObjectMirror.GetInternalProperties(value);
+    var result = [];
+    for (var i = 0; i < properties.length; i++) {
+        var mirror = properties[i];
+        result.push({
+            name: mirror.name(),
+            value: mirror.value().value()
+        });
+    }
+    return result;
+}
+
+DebuggerScript.setFunctionVariableValue = function(functionValue, scopeIndex, variableName, newValue)
+{
+    var mirror = MakeMirror(functionValue);
+    if (!mirror.isFunction())
+        throw new Error("Function value has incorrect type");
+    return DebuggerScript._setScopeVariableValue(mirror, scopeIndex, variableName, newValue);
+}
+
+DebuggerScript._setScopeVariableValue = function(scopeHolder, scopeIndex, variableName, newValue)
+{
+    var scopeMirror = scopeHolder.scope(scopeIndex);
+    if (!scopeMirror)
+        throw new Error("Incorrect scope index");
+    scopeMirror.setVariableValue(variableName, newValue);
+    return undefined;
+}
+
+DebuggerScript.getScripts = function(contextData)
+{
+    var result = [];
+
+    if (!contextData)
+        return result;
+    var comma = contextData.indexOf(",");
+    if (comma === -1)
+        return result;
+    // Context data is a string in the following format:
+    // ("page"|"injected")","<page id>
+    var idSuffix = contextData.substring(comma); // including the comma
+
+    var scripts = Debug.scripts();
+    for (var i = 0; i < scripts.length; ++i) {
+        var script = scripts[i];
+        if (script.context_data && script.context_data.lastIndexOf(idSuffix) != -1)
+            result.push(DebuggerScript._formatScript(script));
+    }
+    return result;
+}
+
+DebuggerScript._formatScript = function(script)
+{
+    var lineEnds = script.line_ends;
+    var lineCount = lineEnds.length;
+    var endLine = script.line_offset + lineCount - 1;
+    var endColumn;
+    // V8 will not count last line if script source ends with \n.
+    if (script.source[script.source.length - 1] === '\n') {
+        endLine += 1;
+        endColumn = 0;
+    } else {
+        if (lineCount === 1)
+            endColumn = script.source.length + script.column_offset;
+        else
+            endColumn = script.source.length - (lineEnds[lineCount - 2] + 1);
+    }
+
+    return {
+        id: script.id,
+        name: script.nameOrSourceURL(),
+        sourceURL: script.source_url,
+        sourceMappingURL: script.source_mapping_url,
+        source: script.source,
+        startLine: script.line_offset,
+        startColumn: script.column_offset,
+        endLine: endLine,
+        endColumn: endColumn,
+        isContentScript: !!script.context_data && script.context_data.indexOf("injected") == 0
+    };
+}
+
+DebuggerScript.setBreakpoint = function(execState, info)
+{
+    var positionAlignment = info.interstatementLocation ? Debug.BreakPositionAlignment.BreakPosition : Debug.BreakPositionAlignment.Statement;
+    var breakId = Debug.setScriptBreakPointById(info.sourceID, info.lineNumber, info.columnNumber, info.condition, undefined, positionAlignment);
+
+    var locations = Debug.findBreakPointActualLocations(breakId);
+    if (!locations.length)
+        return undefined;
+    info.lineNumber = locations[0].line;
+    info.columnNumber = locations[0].column;
+    return breakId.toString();
+}
+
+DebuggerScript.removeBreakpoint = function(execState, info)
+{
+    Debug.findBreakPoint(info.breakpointId, true);
+}
+
+DebuggerScript.pauseOnExceptionsState = function()
+{
+    return DebuggerScript._pauseOnExceptionsState;
+}
+
+DebuggerScript.setPauseOnExceptionsState = function(newState)
+{
+    DebuggerScript._pauseOnExceptionsState = newState;
+
+    if (DebuggerScript.PauseOnExceptionsState.PauseOnAllExceptions === newState)
+        Debug.setBreakOnException();
+    else
+        Debug.clearBreakOnException();
+
+    if (DebuggerScript.PauseOnExceptionsState.PauseOnUncaughtExceptions === newState)
+        Debug.setBreakOnUncaughtException();
+    else
+        Debug.clearBreakOnUncaughtException();
+}
+
+DebuggerScript.frameCount = function(execState)
+{
+    return execState.frameCount();
+}
+
+DebuggerScript.currentCallFrame = function(execState, data)
+{
+    var maximumLimit = data >> 2;
+    var scopeDetailsLevel = data & 3;
+
+    var frameCount = execState.frameCount();
+    if (maximumLimit && maximumLimit < frameCount)
+        frameCount = maximumLimit;
+    var topFrame = undefined;
+    for (var i = frameCount - 1; i >= 0; i--) {
+        var frameMirror = execState.frame(i);
+        topFrame = DebuggerScript._frameMirrorToJSCallFrame(frameMirror, topFrame, scopeDetailsLevel);
+    }
+    return topFrame;
+}
+
+DebuggerScript.currentCallFrameByIndex = function(execState, index)
+{
+    if (index < 0)
+        return undefined;
+    var frameCount = execState.frameCount();
+    if (index >= frameCount)
+        return undefined;
+    return DebuggerScript._frameMirrorToJSCallFrame(execState.frame(index), undefined, DebuggerScript.ScopeInfoDetails.NoScopes);
+}
+
+DebuggerScript.stepIntoStatement = function(execState)
+{
+    execState.prepareStep(Debug.StepAction.StepIn, 1);
+}
+
+DebuggerScript.stepOverStatement = function(execState, callFrame)
+{
+    execState.prepareStep(Debug.StepAction.StepNext, 1);
+}
+
+DebuggerScript.stepOutOfFunction = function(execState, callFrame)
+{
+    execState.prepareStep(Debug.StepAction.StepOut, 1);
+}
+
+// Returns array in form:
+//      [ 0, <v8_result_report> ] in case of success
+//   or [ 1, <general_error_message>, <compiler_message>, <line_number>, <column_number> ] in case of compile error, numbers are 1-based.
+// or throws exception with message.
+DebuggerScript.liveEditScriptSource = function(scriptId, newSource, preview)
+{
+    var scripts = Debug.scripts();
+    var scriptToEdit = null;
+    for (var i = 0; i < scripts.length; i++) {
+        if (scripts[i].id == scriptId) {
+            scriptToEdit = scripts[i];
+            break;
+        }
+    }
+    if (!scriptToEdit)
+        throw("Script not found");
+
+    var changeLog = [];
+    try {
+        var result = Debug.LiveEdit.SetScriptSource(scriptToEdit, newSource, preview, changeLog);
+        return [0, result];
+    } catch (e) {
+        if (e instanceof Debug.LiveEdit.Failure && "details" in e) {
+            var details = e.details;
+            if (details.type === "liveedit_compile_error") {
+                var startPosition = details.position.start;
+                return [1, String(e), String(details.syntaxErrorMessage), Number(startPosition.line), Number(startPosition.column)];
+            }
+        }
+        throw e;
+    }
+}
+
+DebuggerScript.clearBreakpoints = function(execState, info)
+{
+    Debug.clearAllBreakPoints();
+}
+
+DebuggerScript.setBreakpointsActivated = function(execState, info)
+{
+    Debug.debuggerFlags().breakPointsActive.setValue(info.enabled);
+}
+
+DebuggerScript.getScriptSource = function(eventData)
+{
+    return eventData.script().source();
+}
+
+DebuggerScript.setScriptSource = function(eventData, source)
+{
+    if (eventData.script().data() === "injected-script")
+        return;
+    eventData.script().setSource(source);
+}
+
+DebuggerScript.getScriptName = function(eventData)
+{
+    return eventData.script().script_.nameOrSourceURL();
+}
+
+DebuggerScript.getBreakpointNumbers = function(eventData)
+{
+    var breakpoints = eventData.breakPointsHit();
+    var numbers = [];
+    if (!breakpoints)
+        return numbers;
+
+    for (var i = 0; i < breakpoints.length; i++) {
+        var breakpoint = breakpoints[i];
+        var scriptBreakPoint = breakpoint.script_break_point();
+        numbers.push(scriptBreakPoint ? scriptBreakPoint.number() : breakpoint.number());
+    }
+    return numbers;
+}
+
+DebuggerScript.isEvalCompilation = function(eventData)
+{
+    var script = eventData.script();
+    return (script.compilationType() === Debug.ScriptCompilationType.Eval);
+}
+
+// NOTE: This function is performance critical, as it can be run on every
+// statement that generates an async event (like addEventListener) to support
+// asynchronous call stacks. Thus, when possible, initialize the data lazily.
+DebuggerScript._frameMirrorToJSCallFrame = function(frameMirror, callerFrame, scopeDetailsLevel)
+{
+    // Stuff that can not be initialized lazily (i.e. valid while paused with a valid break_id).
+    // The frameMirror and scopeMirror can be accessed only while paused on the debugger.
+    var frameDetails = frameMirror.details();
+
+    var funcObject = frameDetails.func();
+    var sourcePosition = frameDetails.sourcePosition();
+    var thisObject = frameDetails.receiver();
+
+    var isAtReturn = !!frameDetails.isAtReturn();
+    var returnValue = isAtReturn ? frameDetails.returnValue() : undefined;
+
+    var scopeMirrors = (scopeDetailsLevel === DebuggerScript.ScopeInfoDetails.NoScopes ? [] : frameMirror.allScopes(scopeDetailsLevel === DebuggerScript.ScopeInfoDetails.FastAsyncScopes));
+    var scopeTypes = new Array(scopeMirrors.length);
+    var scopeObjects = new Array(scopeMirrors.length);
+    for (var i = 0; i < scopeMirrors.length; ++i) {
+        var scopeDetails = scopeMirrors[i].details();
+        scopeTypes[i] = scopeDetails.type();
+        scopeObjects[i] = scopeDetails.object();
+    }
+
+    // Calculated lazily.
+    var scopeChain;
+    var funcMirror;
+    var location;
+
+    function lazyScopeChain()
+    {
+        if (!scopeChain) {
+            scopeChain = [];
+            for (var i = 0; i < scopeObjects.length; ++i)
+                scopeChain.push(DebuggerScript._buildScopeObject(scopeTypes[i], scopeObjects[i]));
+            scopeObjects = null; // Free for GC.
+        }
+        return scopeChain;
+    }
+
+    function ensureFuncMirror()
+    {
+        if (!funcMirror) {
+            funcMirror = MakeMirror(funcObject);
+            if (!funcMirror.isFunction())
+                funcMirror = new UnresolvedFunctionMirror(funcObject);
+        }
+        return funcMirror;
+    }
+
+    function ensureLocation()
+    {
+        if (!location) {
+            var script = ensureFuncMirror().script();
+            if (script)
+                location = script.locationFromPosition(sourcePosition, true);
+            if (!location)
+                location = { line: 0, column: 0 };
+        }
+        return location;
+    }
+
+    function line()
+    {
+        return ensureLocation().line;
+    }
+
+    function column()
+    {
+        return ensureLocation().column;
+    }
+
+    function sourceID()
+    {
+        var script = ensureFuncMirror().script();
+        return script && script.id();
+    }
+
+    function scriptName()
+    {
+        var script = ensureFuncMirror().script();
+        return script && script.name();
+    }
+
+    function functionName()
+    {
+        var func = ensureFuncMirror();
+        if (!func.resolved())
+            return undefined;
+        var displayName;
+        var valueMirror = func.property("displayName").value();
+        if (valueMirror && valueMirror.isString())
+            displayName = valueMirror.value();
+        return displayName || func.name() || func.inferredName();
+    }
+
+    function evaluate(expression)
+    {
+        return frameMirror.evaluate(expression, false).value();
+    }
+
+    function restart()
+    {
+        return Debug.LiveEdit.RestartFrame(frameMirror);
+    }
+
+    function setVariableValue(scopeNumber, variableName, newValue)
+    {
+        return DebuggerScript._setScopeVariableValue(frameMirror, scopeNumber, variableName, newValue);
+    }
+
+    function stepInPositions()
+    {
+        var stepInPositionsV8 = frameMirror.stepInPositions();
+        var stepInPositionsProtocol;
+        if (stepInPositionsV8) {
+            stepInPositionsProtocol = [];
+            var script = ensureFuncMirror().script();
+            if (script) {
+                var scriptId = String(script.id());
+                for (var i = 0; i < stepInPositionsV8.length; i++) {
+                    var item = {
+                        scriptId: scriptId,
+                        lineNumber: stepInPositionsV8[i].position.line,
+                        columnNumber: stepInPositionsV8[i].position.column
+                    };
+                    stepInPositionsProtocol.push(item);
+                }
+            }
+        }
+        return JSON.stringify(stepInPositionsProtocol);
+    }
+
+    return {
+        "sourceID": sourceID,
+        "line": line,
+        "column": column,
+        "scriptName": scriptName,
+        "functionName": functionName,
+        "thisObject": thisObject,
+        "scopeChain": lazyScopeChain,
+        "scopeType": scopeTypes,
+        "evaluate": evaluate,
+        "caller": callerFrame,
+        "restart": restart,
+        "setVariableValue": setVariableValue,
+        "stepInPositions": stepInPositions,
+        "isAtReturn": isAtReturn,
+        "returnValue": returnValue
+    };
+}
+
+DebuggerScript._buildScopeObject = function(scopeType, scopeObject)
+{
+    var result;
+    switch (scopeType) {
+    case ScopeType.Local:
+    case ScopeType.Closure:
+    case ScopeType.Catch:
+        // For transient objects we create a "persistent" copy that contains
+        // the same properties.
+        // Reset scope object prototype to null so that the proto properties
+        // don't appear in the local scope section.
+        result = { __proto__: null };
+        var properties = MakeMirror(scopeObject, true /* transient */).properties();
+        for (var j = 0; j < properties.length; j++) {
+            var name = properties[j].name();
+            if (name.charAt(0) === ".")
+                continue; // Skip internal variables like ".arguments"
+            result[name] = properties[j].value_;
+        }
+        break;
+    case ScopeType.Global:
+    case ScopeType.With:
+        result = scopeObject;
+        break;
+    case ScopeType.Block:
+        // Unsupported yet. Mustn't be reachable.
+        break;
+    }
+    return result;
+}
+
+DebuggerScript.getPromiseDetails = function(eventData)
+{
+    return {
+        "promise": eventData.promise().value(),
+        "parentPromise": eventData.parentPromise().value(),
+        "status": eventData.status()
+    };
+}
+
+// We never resolve Mirror by its handle so to avoid memory leaks caused by Mirrors in the cache we disable it.
+ToggleMirrorCache(false);
+
+return DebuggerScript;
+})();
diff --git a/engine/bindings/core/v8/PageScriptDebugServer.cpp b/engine/bindings/core/v8/PageScriptDebugServer.cpp
new file mode 100644
index 00000000000..f5e5937ebf3
--- /dev/null
+++ b/engine/bindings/core/v8/PageScriptDebugServer.cpp
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "bindings/core/v8/PageScriptDebugServer.h"
+
+#include "bindings/core/v8/DOMWrapperWorld.h"
+#include "bindings/core/v8/ScriptController.h"
+#include "bindings/core/v8/ScriptSourceCode.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/V8ScriptRunner.h"
+#include "bindings/core/v8/V8Window.h"
+#include "bindings/core/v8/WindowProxy.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/frame/FrameConsole.h"
+#include "core/frame/FrameHost.h"
+#include "core/frame/LocalFrame.h"
+#include "core/frame/UseCounter.h"
+#include "core/inspector/InspectorTraceEvents.h"
+#include "core/inspector/ScriptDebugListener.h"
+#include "core/page/Page.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnPtr.h"
+#include "wtf/StdLibExtras.h"
+#include "wtf/TemporaryChange.h"
+#include "wtf/text/StringBuilder.h"
+#include "gin/modules/console.h"
+#include "gin/converter.h"
+
+namespace blink {
+
+static LocalFrame* retrieveFrameWithGlobalObjectCheck(v8::Handle<v8::Context> context)
+{
+    if (context.IsEmpty())
+        return 0;
+
+    // FIXME: This is a temporary hack for crbug.com/345014.
+    // Currently it's possible that V8 can trigger Debugger::ProcessDebugEvent for a context
+    // that is being initialized (i.e., inside Context::New() of the context).
+    // We should fix the V8 side so that it won't trigger the event for a half-baked context
+    // because there is no way in the embedder side to check if the context is half-baked or not.
+    if (isMainThread() && DOMWrapperWorld::windowIsBeingInitialized())
+        return 0;
+
+    v8::Handle<v8::Value> global = V8Window::findInstanceInPrototypeChain(context->Global(), context->GetIsolate());
+    if (global.IsEmpty())
+        return 0;
+
+    return toFrameIfNotDetached(context);
+}
+
+void PageScriptDebugServer::setPreprocessorSource(const String& preprocessorSource)
+{
+    if (preprocessorSource.isEmpty())
+        m_preprocessorSourceCode.clear();
+    else
+        m_preprocessorSourceCode = adoptPtr(new ScriptSourceCode(preprocessorSource));
+    m_scriptPreprocessor.clear();
+}
+
+PageScriptDebugServer& PageScriptDebugServer::shared()
+{
+    DEFINE_STATIC_LOCAL(PageScriptDebugServer, server, ());
+    return server;
+}
+
+v8::Isolate* PageScriptDebugServer::s_mainThreadIsolate = 0;
+
+void PageScriptDebugServer::setMainThreadIsolate(v8::Isolate* isolate)
+{
+    s_mainThreadIsolate = isolate;
+}
+
+PageScriptDebugServer::PageScriptDebugServer()
+    : ScriptDebugServer(s_mainThreadIsolate)
+    , m_pausedPage(0)
+{
+}
+
+PageScriptDebugServer::~PageScriptDebugServer()
+{
+}
+
+void PageScriptDebugServer::addListener(ScriptDebugListener* listener, Page* page)
+{
+    ScriptController& scriptController = page->mainFrame()->script();
+
+    v8::HandleScope scope(m_isolate);
+
+    if (!m_listenersMap.size()) {
+        v8::Debug::SetDebugEventListener(&PageScriptDebugServer::v8DebugEventCallback, v8::External::New(m_isolate, this));
+        ensureDebuggerScriptCompiled();
+    }
+
+    v8::Local<v8::Context> debuggerContext = v8::Debug::GetDebugContext();
+    v8::Context::Scope contextScope(debuggerContext);
+
+    v8::Local<v8::Value> console = gin::Console::GetModule(m_isolate);
+    debuggerContext->Global()->Set(gin::StringToV8(m_isolate, "console"), console);
+
+    v8::Local<v8::Object> debuggerScript = m_debuggerScript.newLocal(m_isolate);
+    ASSERT(!debuggerScript->IsUndefined());
+    m_listenersMap.set(page, listener);
+
+    WindowProxy* windowProxy = scriptController.existingWindowProxy(DOMWrapperWorld::mainWorld());
+    if (!windowProxy || !windowProxy->isContextInitialized())
+        return;
+    v8::Local<v8::Context> context = windowProxy->context();
+    v8::Handle<v8::Function> getScriptsFunction = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8AtomicString(m_isolate, "getScripts")));
+    v8::Handle<v8::Value> argv[] = { context->GetEmbedderData(0) };
+    v8::Handle<v8::Value> value = V8ScriptRunner::callInternalFunction(getScriptsFunction, debuggerScript, WTF_ARRAY_LENGTH(argv), argv, m_isolate);
+    if (value.IsEmpty())
+        return;
+    ASSERT(!value->IsUndefined() && value->IsArray());
+    v8::Handle<v8::Array> scriptsArray = v8::Handle<v8::Array>::Cast(value);
+    for (unsigned i = 0; i < scriptsArray->Length(); ++i)
+        dispatchDidParseSource(listener, v8::Handle<v8::Object>::Cast(scriptsArray->Get(v8::Integer::New(m_isolate, i))), CompileSuccess);
+}
+
+void PageScriptDebugServer::removeListener(ScriptDebugListener* listener, Page* page)
+{
+    if (!m_listenersMap.contains(page))
+        return;
+
+    if (m_pausedPage == page)
+        continueProgram();
+
+    m_listenersMap.remove(page);
+
+    if (m_listenersMap.isEmpty()) {
+        discardDebuggerScript();
+        v8::Debug::SetDebugEventListener(0);
+        // FIXME: Remove all breakpoints set by the agent.
+    }
+}
+
+void PageScriptDebugServer::interruptAndRun(PassOwnPtr<Task> task)
+{
+    ScriptDebugServer::interruptAndRun(task, s_mainThreadIsolate);
+}
+
+void PageScriptDebugServer::setClientMessageLoop(PassOwnPtr<ClientMessageLoop> clientMessageLoop)
+{
+    m_clientMessageLoop = clientMessageLoop;
+}
+
+void PageScriptDebugServer::compileScript(ScriptState* scriptState, const String& expression, const String& sourceURL, String* scriptId, String* exceptionDetailsText, int* lineNumber, int* columnNumber, RefPtr<ScriptCallStack>* stackTrace)
+{
+    ExecutionContext* executionContext = scriptState->executionContext();
+    RefPtr<LocalFrame> protect = executionContext->executingWindow()->frame();
+    ScriptDebugServer::compileScript(scriptState, expression, sourceURL, scriptId, exceptionDetailsText, lineNumber, columnNumber, stackTrace);
+    if (!scriptId->isNull())
+        m_compiledScriptURLs.set(*scriptId, sourceURL);
+}
+
+void PageScriptDebugServer::clearCompiledScripts()
+{
+    ScriptDebugServer::clearCompiledScripts();
+    m_compiledScriptURLs.clear();
+}
+
+void PageScriptDebugServer::runScript(ScriptState* scriptState, const String& scriptId, ScriptValue* result, bool* wasThrown, String* exceptionDetailsText, int* lineNumber, int* columnNumber, RefPtr<ScriptCallStack>* stackTrace)
+{
+    String sourceURL = m_compiledScriptURLs.take(scriptId);
+
+    ExecutionContext* executionContext = scriptState->executionContext();
+    LocalFrame* frame = executionContext->executingWindow()->frame();
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "EvaluateScript", "data", InspectorEvaluateScriptEvent::data(frame, sourceURL, TextPosition::minimumPosition().m_line.oneBasedInt()));
+    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", TRACE_EVENT_SCOPE_PROCESS, "stack", InspectorCallStackEvent::currentCallStack());
+
+    RefPtr<LocalFrame> protect = frame;
+    ScriptDebugServer::runScript(scriptState, scriptId, result, wasThrown, exceptionDetailsText, lineNumber, columnNumber, stackTrace);
+
+    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_PROCESS, "data", InspectorUpdateCountersEvent::data());
+}
+
+ScriptDebugListener* PageScriptDebugServer::getDebugListenerForContext(v8::Handle<v8::Context> context)
+{
+    v8::HandleScope scope(m_isolate);
+    LocalFrame* frame = retrieveFrameWithGlobalObjectCheck(context);
+    if (!frame)
+        return 0;
+    return m_listenersMap.get(frame->page());
+}
+
+void PageScriptDebugServer::runMessageLoopOnPause(v8::Handle<v8::Context> context)
+{
+    v8::HandleScope scope(m_isolate);
+    LocalFrame* frame = retrieveFrameWithGlobalObjectCheck(context);
+    m_pausedPage = frame->page();
+
+    // Wait for continue or step command.
+    m_clientMessageLoop->run(m_pausedPage);
+
+    // The listener may have been removed in the nested loop.
+    if (ScriptDebugListener* listener = m_listenersMap.get(m_pausedPage))
+        listener->didContinue();
+
+    m_pausedPage = 0;
+}
+
+void PageScriptDebugServer::quitMessageLoopOnPause()
+{
+    m_clientMessageLoop->quitNow();
+}
+
+void PageScriptDebugServer::preprocessBeforeCompile(const v8::Debug::EventDetails& eventDetails)
+{
+    v8::Handle<v8::Context> eventContext = eventDetails.GetEventContext();
+    LocalFrame* frame = retrieveFrameWithGlobalObjectCheck(eventContext);
+    if (!frame)
+        return;
+
+    if (!canPreprocess(frame))
+        return;
+
+    v8::Handle<v8::Object> eventData = eventDetails.GetEventData();
+    v8::Local<v8::Context> debugContext = v8::Debug::GetDebugContext();
+    v8::Context::Scope contextScope(debugContext);
+    v8::TryCatch tryCatch;
+    // <script> tag source and attribute value source are preprocessed before we enter V8.
+    // Avoid preprocessing any internal scripts by processing only eval source in this V8 event handler.
+    v8::Handle<v8::Value> argvEventData[] = { eventData };
+    v8::Handle<v8::Value> v8Value = callDebuggerMethod("isEvalCompilation", WTF_ARRAY_LENGTH(argvEventData), argvEventData);
+    if (v8Value.IsEmpty() || !v8Value->ToBoolean()->Value())
+        return;
+
+    // The name and source are in the JS event data.
+    String scriptName = toCoreStringWithUndefinedOrNullCheck(callDebuggerMethod("getScriptName", WTF_ARRAY_LENGTH(argvEventData), argvEventData));
+    String script = toCoreStringWithUndefinedOrNullCheck(callDebuggerMethod("getScriptSource", WTF_ARRAY_LENGTH(argvEventData), argvEventData));
+
+    String preprocessedSource  = m_scriptPreprocessor->preprocessSourceCode(script, scriptName);
+
+    v8::Handle<v8::Value> argvPreprocessedScript[] = { eventData, v8String(debugContext->GetIsolate(), preprocessedSource) };
+    callDebuggerMethod("setScriptSource", WTF_ARRAY_LENGTH(argvPreprocessedScript), argvPreprocessedScript);
+}
+
+static bool isCreatingPreprocessor = false;
+
+bool PageScriptDebugServer::canPreprocess(LocalFrame* frame)
+{
+    ASSERT(frame);
+
+    if (!m_preprocessorSourceCode || !frame->page() || isCreatingPreprocessor)
+        return false;
+
+    // We delay the creation of the preprocessor until just before the first JS from the
+    // Web page to ensure that the debugger's console initialization code has completed.
+    if (!m_scriptPreprocessor) {
+        TemporaryChange<bool> isPreprocessing(isCreatingPreprocessor, true);
+        m_scriptPreprocessor = adoptPtr(new ScriptPreprocessor(*m_preprocessorSourceCode.get(), frame));
+    }
+
+    if (m_scriptPreprocessor->isValid())
+        return true;
+
+    m_scriptPreprocessor.clear();
+    // Don't retry the compile if we fail one time.
+    m_preprocessorSourceCode.clear();
+    return false;
+}
+
+// Source to Source processing iff debugger enabled and it has loaded a preprocessor.
+PassOwnPtr<ScriptSourceCode> PageScriptDebugServer::preprocess(LocalFrame* frame, const ScriptSourceCode& sourceCode)
+{
+    if (!canPreprocess(frame))
+        return PassOwnPtr<ScriptSourceCode>();
+
+    String preprocessedSource = m_scriptPreprocessor->preprocessSourceCode(sourceCode.source(), sourceCode.url());
+    return adoptPtr(new ScriptSourceCode(preprocessedSource, sourceCode.url()));
+}
+
+String PageScriptDebugServer::preprocessEventListener(LocalFrame* frame, const String& source, const String& url, const String& functionName)
+{
+    if (!canPreprocess(frame))
+        return source;
+
+    return m_scriptPreprocessor->preprocessSourceCode(source, url, functionName);
+}
+
+void PageScriptDebugServer::clearPreprocessor()
+{
+    m_scriptPreprocessor.clear();
+}
+
+void PageScriptDebugServer::muteWarningsAndDeprecations()
+{
+    FrameConsole::mute();
+    UseCounter::muteForInspector();
+}
+
+void PageScriptDebugServer::unmuteWarningsAndDeprecations()
+{
+    FrameConsole::unmute();
+    UseCounter::unmuteForInspector();
+}
+
+} // namespace blink
diff --git a/engine/bindings/core/v8/PageScriptDebugServer.h b/engine/bindings/core/v8/PageScriptDebugServer.h
new file mode 100644
index 00000000000..097498a116c
--- /dev/null
+++ b/engine/bindings/core/v8/PageScriptDebugServer.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+#ifndef PageScriptDebugServer_h
+#define PageScriptDebugServer_h
+
+#include "bindings/core/v8/ScriptDebugServer.h"
+#include "bindings/core/v8/ScriptPreprocessor.h"
+#include "wtf/Forward.h"
+#include "wtf/RefCounted.h"
+#include <v8.h>
+
+namespace blink {
+
+class Page;
+class ScriptController;
+class ScriptPreprocessor;
+class ScriptSourceCode;
+
+class PageScriptDebugServer final : public ScriptDebugServer {
+    WTF_MAKE_NONCOPYABLE(PageScriptDebugServer);
+public:
+    static PageScriptDebugServer& shared();
+
+    static void setMainThreadIsolate(v8::Isolate*);
+
+    void addListener(ScriptDebugListener*, Page*);
+    void removeListener(ScriptDebugListener*, Page*);
+
+    static void interruptAndRun(PassOwnPtr<Task>);
+
+    class ClientMessageLoop {
+    public:
+        virtual ~ClientMessageLoop() { }
+        virtual void run(Page*) = 0;
+        virtual void quitNow() = 0;
+    };
+    void setClientMessageLoop(PassOwnPtr<ClientMessageLoop>);
+
+    virtual void compileScript(ScriptState*, const String& expression, const String& sourceURL, String* scriptId, String* exceptionDetailsText, int* lineNumber, int* columnNumber, RefPtr<ScriptCallStack>* stackTrace) override;
+    virtual void clearCompiledScripts() override;
+    virtual void runScript(ScriptState*, const String& scriptId, ScriptValue* result, bool* wasThrown, String* exceptionDetailsText, int* lineNumber, int* columnNumber, RefPtr<ScriptCallStack>* stackTrace) override;
+    virtual void setPreprocessorSource(const String&) override;
+    virtual void preprocessBeforeCompile(const v8::Debug::EventDetails&) override;
+    virtual PassOwnPtr<ScriptSourceCode> preprocess(LocalFrame*, const ScriptSourceCode&) override;
+    virtual String preprocessEventListener(LocalFrame*, const String& source, const String& url, const String& functionName) override;
+    virtual void clearPreprocessor() override;
+
+    virtual void muteWarningsAndDeprecations() override;
+    virtual void unmuteWarningsAndDeprecations() override;
+
+private:
+    PageScriptDebugServer();
+    virtual ~PageScriptDebugServer();
+
+    virtual ScriptDebugListener* getDebugListenerForContext(v8::Handle<v8::Context>) override;
+    virtual void runMessageLoopOnPause(v8::Handle<v8::Context>) override;
+    virtual void quitMessageLoopOnPause() override;
+
+    typedef HashMap<Page*, ScriptDebugListener*> ListenersMap;
+    ListenersMap m_listenersMap;
+    OwnPtr<ClientMessageLoop> m_clientMessageLoop;
+    Page* m_pausedPage;
+    HashMap<String, String> m_compiledScriptURLs;
+
+    OwnPtr<ScriptSourceCode> m_preprocessorSourceCode;
+    OwnPtr<ScriptPreprocessor> m_scriptPreprocessor;
+    bool canPreprocess(LocalFrame*);
+    static v8::Isolate* s_mainThreadIsolate;
+};
+
+} // namespace blink
+
+
+#endif // PageScriptDebugServer_h
diff --git a/engine/bindings/core/v8/ScriptDebugServer.cpp b/engine/bindings/core/v8/ScriptDebugServer.cpp
index 564278c839e..b8763549f8b 100644
--- a/engine/bindings/core/v8/ScriptDebugServer.cpp
+++ b/engine/bindings/core/v8/ScriptDebugServer.cpp
@@ -580,7 +580,7 @@ void ScriptDebugServer::ensureDebuggerScriptCompiled()
 
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(v8::Debug::GetDebugContext());
-    const blink::WebData& debuggerScriptSourceResource = blink::Platform::current()->loadResource("DebuggerScriptSource.js");
+    const blink::WebData& debuggerScriptSourceResource = blink::Platform::current()->loadResource("DebuggerScript.js");
     v8::Handle<v8::String> source = v8String(m_isolate, String(debuggerScriptSourceResource.data(), debuggerScriptSourceResource.size()));
     v8::Local<v8::Value> value = V8ScriptRunner::compileAndRunInternalScript(source, m_isolate);
     ASSERT(!value.IsEmpty());
diff --git a/engine/bindings/core/v8/ScriptRegexp.cpp b/engine/bindings/core/v8/ScriptRegexp.cpp
new file mode 100644
index 00000000000..42ec0c7e34a
--- /dev/null
+++ b/engine/bindings/core/v8/ScriptRegexp.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2004, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Collabora Ltd.
+ * Copyright (C) 2011 Peter Varga (pvarga@webkit.org), University of Szeged
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 COMPUTER, INC. OR
+ * 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 "bindings/core/v8/ScriptRegexp.h"
+
+#include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/V8PerIsolateData.h"
+#include "bindings/core/v8/V8ScriptRunner.h"
+#include "platform/ScriptForbiddenScope.h"
+
+namespace blink {
+
+ScriptRegexp::ScriptRegexp(const String& pattern, TextCaseSensitivity caseSensitivity, MultilineMode multilineMode)
+{
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::HandleScope handleScope(isolate);
+    v8::Context::Scope contextScope(V8PerIsolateData::from(isolate)->ensureScriptRegexpContext());
+    v8::TryCatch tryCatch;
+
+    unsigned flags = v8::RegExp::kNone;
+    if (caseSensitivity == TextCaseInsensitive)
+        flags |= v8::RegExp::kIgnoreCase;
+    if (multilineMode == MultilineEnabled)
+        flags |= v8::RegExp::kMultiline;
+
+    v8::Local<v8::RegExp> regex = v8::RegExp::New(v8String(isolate, pattern), static_cast<v8::RegExp::Flags>(flags));
+
+    // If the regex failed to compile we'll get an empty handle.
+    if (!regex.IsEmpty())
+        m_regex.set(isolate, regex);
+}
+
+int ScriptRegexp::match(const String& string, int startFrom, int* matchLength) const
+{
+    if (matchLength)
+        *matchLength = 0;
+
+    if (m_regex.isEmpty() || string.isNull())
+        return -1;
+
+    // v8 strings are limited to int.
+    if (string.length() > INT_MAX)
+        return -1;
+
+    ScriptForbiddenScope::AllowUserAgentScript allowScript;
+
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::HandleScope handleScope(isolate);
+    v8::Context::Scope contextScope(V8PerIsolateData::from(isolate)->ensureScriptRegexpContext());
+    v8::TryCatch tryCatch;
+
+    v8::Local<v8::RegExp> regex = m_regex.newLocal(isolate);
+    v8::Local<v8::Function> exec = regex->Get(v8AtomicString(isolate, "exec")).As<v8::Function>();
+    v8::Handle<v8::Value> argv[] = { v8String(isolate, string.substring(startFrom)) };
+    v8::Local<v8::Value> returnValue = V8ScriptRunner::callInternalFunction(exec, regex, WTF_ARRAY_LENGTH(argv), argv, isolate);
+
+    if (tryCatch.HasCaught())
+        return -1;
+
+    // RegExp#exec returns null if there's no match, otherwise it returns an
+    // Array of strings with the first being the whole match string and others
+    // being subgroups. The Array also has some random properties tacked on like
+    // "index" which is the offset of the match.
+    //
+    // https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/exec
+
+    ASSERT(!returnValue.IsEmpty());
+    if (!returnValue->IsArray())
+        return -1;
+
+    v8::Local<v8::Array> result = returnValue.As<v8::Array>();
+    int matchOffset = result->Get(v8AtomicString(isolate, "index"))->ToInt32()->Value();
+    if (matchLength) {
+        v8::Local<v8::String> match = result->Get(0).As<v8::String>();
+        *matchLength = match->Length();
+    }
+
+    return matchOffset + startFrom;
+}
+
+} // namespace blink
diff --git a/engine/bindings/core/v8/ScriptRegexp.h b/engine/bindings/core/v8/ScriptRegexp.h
new file mode 100644
index 00000000000..4e768e9b969
--- /dev/null
+++ b/engine/bindings/core/v8/ScriptRegexp.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2003, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 COMPUTER, INC. OR
+ * 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.
+ */
+
+#ifndef ScriptRegexp_h
+#define ScriptRegexp_h
+
+#include "bindings/core/v8/ScopedPersistent.h"
+#include "wtf/Noncopyable.h"
+#include "wtf/text/WTFString.h"
+#include <v8.h>
+
+namespace blink {
+
+enum MultilineMode {
+    MultilineDisabled,
+    MultilineEnabled
+};
+
+class ScriptRegexp {
+    WTF_MAKE_FAST_ALLOCATED; WTF_MAKE_NONCOPYABLE(ScriptRegexp);
+public:
+    ScriptRegexp(const String&, TextCaseSensitivity, MultilineMode = MultilineDisabled);
+
+    int match(const String&, int startFrom = 0, int* matchLength = 0) const;
+
+    bool isValid() const { return !m_regex.isEmpty(); }
+
+private:
+    ScopedPersistent<v8::RegExp> m_regex;
+};
+
+} // namespace blink
+
+#endif // ScriptRegexp_h
diff --git a/engine/bindings/core/v8/V8PerIsolateData.cpp b/engine/bindings/core/v8/V8PerIsolateData.cpp
index a0910df7c13..298fd854b4d 100644
--- a/engine/bindings/core/v8/V8PerIsolateData.cpp
+++ b/engine/bindings/core/v8/V8PerIsolateData.cpp
@@ -86,6 +86,8 @@ V8PerIsolateData::V8PerIsolateData()
 
 V8PerIsolateData::~V8PerIsolateData()
 {
+    if (m_scriptRegexpScriptState)
+        m_scriptRegexpScriptState->disposePerContextData();
     if (isMainThread())
         mainThreadPerIsolateData = 0;
 }
@@ -156,6 +158,15 @@ void V8PerIsolateData::setDOMTemplate(void* domTemplateKey, v8::Handle<v8::Funct
     currentDOMTemplateMap().add(domTemplateKey, v8::Eternal<v8::FunctionTemplate>(isolate(), v8::Local<v8::FunctionTemplate>(templ)));
 }
 
+v8::Local<v8::Context> V8PerIsolateData::ensureScriptRegexpContext()
+{
+    if (!m_scriptRegexpScriptState) {
+        v8::Local<v8::Context> context(v8::Context::New(isolate()));
+        m_scriptRegexpScriptState = ScriptState::create(context, DOMWrapperWorld::create());
+    }
+    return m_scriptRegexpScriptState->context();
+}
+
 bool V8PerIsolateData::hasInstance(const WrapperTypeInfo* info, v8::Handle<v8::Value> value)
 {
     return hasInstance(info, value, m_domTemplateMapForMainWorld)
diff --git a/engine/bindings/core/v8/V8PerIsolateData.h b/engine/bindings/core/v8/V8PerIsolateData.h
index 2b0362b856e..06441bd2c11 100644
--- a/engine/bindings/core/v8/V8PerIsolateData.h
+++ b/engine/bindings/core/v8/V8PerIsolateData.h
@@ -94,6 +94,8 @@ public:
     bool hasInstance(const WrapperTypeInfo*, v8::Handle<v8::Value>);
     v8::Handle<v8::Object> findInstanceInPrototypeChain(const WrapperTypeInfo*, v8::Handle<v8::Value>);
 
+    v8::Local<v8::Context> ensureScriptRegexpContext();
+
     const char* previousSamplingState() const { return m_previousSamplingState; }
     void setPreviousSamplingState(const char* name) { m_previousSamplingState = name; }
 
@@ -113,6 +115,7 @@ private:
     OwnPtr<StringCache> m_stringCache;
     OwnPtr<V8HiddenValue> m_hiddenValue;
     ScopedPersistent<v8::Value> m_liveRoot;
+    RefPtr<ScriptState> m_scriptRegexpScriptState;
 
     const char* m_previousSamplingState;
 
diff --git a/engine/bindings/core/v8/custom/V8InjectedScriptHostCustom.cpp b/engine/bindings/core/v8/custom/V8InjectedScriptHostCustom.cpp
new file mode 100644
index 00000000000..91f765b86a1
--- /dev/null
+++ b/engine/bindings/core/v8/custom/V8InjectedScriptHostCustom.cpp
@@ -0,0 +1,429 @@
+/*
+ * Copyright (C) 2007-2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "bindings/core/v8/V8InjectedScriptHost.h"
+
+#include "bindings/core/v8/BindingSecurity.h"
+#include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/ScriptDebugServer.h"
+#include "bindings/core/v8/ScriptValue.h"
+#include "bindings/core/v8/V8AbstractEventListener.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/V8DOMTokenList.h"
+#include "bindings/core/v8/V8EventTarget.h"
+#include "bindings/core/v8/V8Node.h"
+#include "bindings/core/v8/V8NodeList.h"
+#include "bindings/core/v8/V8ScriptRunner.h"
+#include "bindings/core/v8/custom/V8Float32ArrayCustom.h"
+#include "bindings/core/v8/custom/V8Float64ArrayCustom.h"
+#include "bindings/core/v8/custom/V8Int16ArrayCustom.h"
+#include "bindings/core/v8/custom/V8Int32ArrayCustom.h"
+#include "bindings/core/v8/custom/V8Int8ArrayCustom.h"
+#include "bindings/core/v8/custom/V8Uint16ArrayCustom.h"
+#include "bindings/core/v8/custom/V8Uint32ArrayCustom.h"
+#include "bindings/core/v8/custom/V8Uint8ArrayCustom.h"
+#include "bindings/core/v8/custom/V8Uint8ClampedArrayCustom.h"
+#include "core/events/EventTarget.h"
+#include "core/frame/LocalDOMWindow.h"
+#include "core/inspector/InjectedScript.h"
+#include "core/inspector/InjectedScriptHost.h"
+#include "core/inspector/JavaScriptCallFrame.h"
+#include "platform/JSONValues.h"
+
+namespace blink {
+
+Node* InjectedScriptHost::scriptValueAsNode(ScriptState* scriptState, ScriptValue value)
+{
+    ScriptState::Scope scope(scriptState);
+    if (!value.isObject() || value.isNull())
+        return 0;
+    return V8Node::toNative(v8::Handle<v8::Object>::Cast(value.v8Value()));
+}
+
+ScriptValue InjectedScriptHost::nodeAsScriptValue(ScriptState* scriptState, Node* node)
+{
+    ScriptState::Scope scope(scriptState);
+    v8::Isolate* isolate = scriptState->isolate();
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeAsScriptValue", "InjectedScriptHost", scriptState->context()->Global(), isolate);
+    return ScriptValue(scriptState, toV8(node, scriptState->context()->Global(), isolate));
+}
+
+void V8InjectedScriptHost::inspectedObjectMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    if (info.Length() < 1)
+        return;
+
+    if (!info[0]->IsInt32()) {
+        V8ThrowException::throwTypeError("argument has to be an integer", info.GetIsolate());
+        return;
+    }
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost::InspectableObject* object = host->inspectedObject(info[0]->ToInt32()->Value());
+    v8SetReturnValue(info, object->get(ScriptState::current(info.GetIsolate())).v8Value());
+}
+
+static v8::Handle<v8::String> functionDisplayName(v8::Handle<v8::Function> function)
+{
+    v8::Handle<v8::Value> value = function->GetDisplayName();
+    if (value->IsString() && v8::Handle<v8::String>::Cast(value)->Length())
+        return v8::Handle<v8::String>::Cast(value);
+
+    value = function->GetName();
+    if (value->IsString() && v8::Handle<v8::String>::Cast(value)->Length())
+        return v8::Handle<v8::String>::Cast(value);
+
+    value = function->GetInferredName();
+    if (value->IsString() && v8::Handle<v8::String>::Cast(value)->Length())
+        return v8::Handle<v8::String>::Cast(value);
+
+    return v8::Handle<v8::String>();
+}
+
+void V8InjectedScriptHost::internalConstructorNameMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    if (info.Length() < 1 || !info[0]->IsObject())
+        return;
+
+    v8::Local<v8::Object> object = info[0]->ToObject();
+    v8::Local<v8::String> result = object->GetConstructorName();
+
+    if (!result.IsEmpty() && toCoreStringWithUndefinedOrNullCheck(result) == "Object") {
+        v8::Local<v8::String> constructorSymbol = v8AtomicString(info.GetIsolate(), "constructor");
+        if (object->HasRealNamedProperty(constructorSymbol) && !object->HasRealNamedCallbackProperty(constructorSymbol)) {
+            v8::TryCatch tryCatch;
+            v8::Local<v8::Value> constructor = object->GetRealNamedProperty(constructorSymbol);
+            if (!constructor.IsEmpty() && constructor->IsFunction()) {
+                v8::Local<v8::String> constructorName = functionDisplayName(v8::Handle<v8::Function>::Cast(constructor));
+                if (!constructorName.IsEmpty() && !tryCatch.HasCaught())
+                    result = constructorName;
+            }
+        }
+    }
+
+    v8SetReturnValue(info, result);
+}
+
+void V8InjectedScriptHost::isHTMLAllCollectionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    // FIXME(sky): remove
+    v8SetReturnValue(info, false);
+}
+
+void V8InjectedScriptHost::subtypeMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    if (info.Length() < 1)
+        return;
+    v8::Isolate* isolate = info.GetIsolate();
+
+    v8::Handle<v8::Value> value = info[0];
+    if (value->IsArray() || value->IsTypedArray() || value->IsArgumentsObject()) {
+        v8SetReturnValue(info, v8AtomicString(isolate, "array"));
+        return;
+    }
+    if (value->IsDate()) {
+        v8SetReturnValue(info, v8AtomicString(isolate, "date"));
+        return;
+    }
+    if (value->IsRegExp()) {
+        v8SetReturnValue(info, v8AtomicString(isolate, "regexp"));
+        return;
+    }
+    if (value->IsMap() || value->IsWeakMap()) {
+        v8SetReturnValue(info, v8AtomicString(isolate, "map"));
+        return;
+    }
+    if (value->IsSet() || value->IsWeakSet()) {
+        v8SetReturnValue(info, v8AtomicString(isolate, "set"));
+        return;
+    }
+    if (V8Node::hasInstance(value, isolate)) {
+        v8SetReturnValue(info, v8AtomicString(isolate, "node"));
+        return;
+    }
+    if (V8NodeList::hasInstance(value, isolate)
+        || V8DOMTokenList::hasInstance(value, isolate)) {
+        v8SetReturnValue(info, v8AtomicString(isolate, "array"));
+        return;
+    }
+}
+
+void V8InjectedScriptHost::functionDetailsMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    if (info.Length() < 1 || !info[0]->IsFunction())
+        return;
+
+    v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(info[0]);
+    int lineNumber = function->GetScriptLineNumber();
+    int columnNumber = function->GetScriptColumnNumber();
+
+    v8::Isolate* isolate = info.GetIsolate();
+    v8::Local<v8::Object> location = v8::Object::New(isolate);
+    location->Set(v8AtomicString(isolate, "lineNumber"), v8::Integer::New(isolate, lineNumber));
+    location->Set(v8AtomicString(isolate, "columnNumber"), v8::Integer::New(isolate, columnNumber));
+    location->Set(v8AtomicString(isolate, "scriptId"), v8::Integer::New(isolate, function->ScriptId())->ToString());
+
+    v8::Local<v8::Object> result = v8::Object::New(isolate);
+    result->Set(v8AtomicString(isolate, "location"), location);
+
+    v8::Handle<v8::String> name = functionDisplayName(function);
+    result->Set(v8AtomicString(isolate, "functionName"), name.IsEmpty() ? v8AtomicString(isolate, "") : name);
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    ScriptDebugServer& debugServer = host->scriptDebugServer();
+    v8::Handle<v8::Value> scopes = debugServer.functionScopes(function);
+    if (!scopes.IsEmpty() && scopes->IsArray())
+        result->Set(v8AtomicString(isolate, "rawScopes"), scopes);
+
+    v8SetReturnValue(info, result);
+}
+
+void V8InjectedScriptHost::collectionEntriesMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    if (info.Length() < 1 || !info[0]->IsObject())
+        return;
+
+    v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(info[0]);
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    ScriptDebugServer& debugServer = host->scriptDebugServer();
+    v8SetReturnValue(info, debugServer.collectionEntries(object));
+}
+
+void V8InjectedScriptHost::getInternalPropertiesMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    if (info.Length() < 1 || !info[0]->IsObject())
+        return;
+
+    v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(info[0]);
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    ScriptDebugServer& debugServer = host->scriptDebugServer();
+    v8SetReturnValue(info, debugServer.getInternalProperties(object));
+}
+
+void V8InjectedScriptHost::getEventListenersMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    // FIXME(sky): remove
+}
+
+void V8InjectedScriptHost::inspectMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    if (info.Length() < 2)
+        return;
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    ScriptState* scriptState = ScriptState::current(info.GetIsolate());
+    ScriptValue object(scriptState, info[0]);
+    ScriptValue hints(scriptState, info[1]);
+    host->inspectImpl(object.toJSONValue(scriptState), hints.toJSONValue(scriptState));
+}
+
+void V8InjectedScriptHost::evalMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    v8::Isolate* isolate = info.GetIsolate();
+    if (info.Length() < 1) {
+        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "One argument expected.")));
+        return;
+    }
+
+    v8::Handle<v8::String> expression = info[0]->ToString();
+    if (expression.IsEmpty()) {
+        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "The argument must be a string.")));
+        return;
+    }
+
+    ASSERT(isolate->InContext());
+    v8::TryCatch tryCatch;
+    v8::Handle<v8::Value> result = V8ScriptRunner::compileAndRunInternalScript(expression, info.GetIsolate());
+    if (tryCatch.HasCaught()) {
+        v8SetReturnValue(info, tryCatch.ReThrow());
+        return;
+    }
+    v8SetReturnValue(info, result);
+}
+
+void V8InjectedScriptHost::evaluateWithExceptionDetailsMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    v8::Isolate* isolate = info.GetIsolate();
+    if (info.Length() < 1) {
+        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "One argument expected.")));
+        return;
+    }
+
+    v8::Handle<v8::String> expression = info[0]->ToString();
+    if (expression.IsEmpty()) {
+        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "The argument must be a string.")));
+        return;
+    }
+
+    ASSERT(isolate->InContext());
+    v8::TryCatch tryCatch;
+    v8::Handle<v8::Value> result = V8ScriptRunner::compileAndRunInternalScript(expression, info.GetIsolate());
+
+    v8::Local<v8::Object> wrappedResult = v8::Object::New(isolate);
+    if (tryCatch.HasCaught()) {
+        wrappedResult->Set(v8::String::NewFromUtf8(isolate, "result"), tryCatch.Exception());
+        wrappedResult->Set(v8::String::NewFromUtf8(isolate, "exceptionDetails"), JavaScriptCallFrame::createExceptionDetails(tryCatch.Message(), isolate));
+    } else {
+        wrappedResult->Set(v8::String::NewFromUtf8(isolate, "result"), result);
+        wrappedResult->Set(v8::String::NewFromUtf8(isolate, "exceptionDetails"), v8::Undefined(isolate));
+    }
+    v8SetReturnValue(info, wrappedResult);
+}
+
+void V8InjectedScriptHost::setFunctionVariableValueMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    v8::Handle<v8::Value> functionValue = info[0];
+    int scopeIndex = info[1]->Int32Value();
+    String variableName = toCoreStringWithUndefinedOrNullCheck(info[2]);
+    v8::Handle<v8::Value> newValue = info[3];
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    ScriptDebugServer& debugServer = host->scriptDebugServer();
+    v8SetReturnValue(info, debugServer.setFunctionVariableValue(functionValue, scopeIndex, variableName, newValue));
+}
+
+static bool getFunctionLocation(const v8::FunctionCallbackInfo<v8::Value>& info, String* scriptId, int* lineNumber, int* columnNumber)
+{
+    if (info.Length() < 1)
+        return false;
+    v8::Handle<v8::Value> fn = info[0];
+    if (!fn->IsFunction())
+        return false;
+    v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(fn);
+    *lineNumber = function->GetScriptLineNumber();
+    *columnNumber = function->GetScriptColumnNumber();
+    if (*lineNumber == v8::Function::kLineOffsetNotFound || *columnNumber == v8::Function::kLineOffsetNotFound)
+        return false;
+    *scriptId = String::number(function->ScriptId());
+    return true;
+}
+
+void V8InjectedScriptHost::debugFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    String scriptId;
+    int lineNumber;
+    int columnNumber;
+    if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
+        return;
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    host->debugFunction(scriptId, lineNumber, columnNumber);
+}
+
+void V8InjectedScriptHost::undebugFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    String scriptId;
+    int lineNumber;
+    int columnNumber;
+    if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
+        return;
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    host->undebugFunction(scriptId, lineNumber, columnNumber);
+}
+
+void V8InjectedScriptHost::monitorFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    String scriptId;
+    int lineNumber;
+    int columnNumber;
+    if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
+        return;
+
+    v8::Handle<v8::Value> name;
+    if (info.Length() > 0 && info[0]->IsFunction()) {
+        v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(info[0]);
+        name = function->GetName();
+        if (!name->IsString() || !v8::Handle<v8::String>::Cast(name)->Length())
+            name = function->GetInferredName();
+    }
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    host->monitorFunction(scriptId, lineNumber, columnNumber, toCoreStringWithUndefinedOrNullCheck(name));
+}
+
+void V8InjectedScriptHost::unmonitorFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    String scriptId;
+    int lineNumber;
+    int columnNumber;
+    if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
+        return;
+
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    host->unmonitorFunction(scriptId, lineNumber, columnNumber);
+}
+
+void V8InjectedScriptHost::callFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    if (info.Length() < 2 || info.Length() > 3 || !info[0]->IsFunction()) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(info[0]);
+    v8::Handle<v8::Value> receiver = info[1];
+
+    if (info.Length() < 3 || info[2]->IsUndefined()) {
+        v8::Local<v8::Value> result = function->Call(receiver, 0, 0);
+        v8SetReturnValue(info, result);
+        return;
+    }
+
+    if (!info[2]->IsArray()) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    v8::Handle<v8::Array> arguments = v8::Handle<v8::Array>::Cast(info[2]);
+    size_t argc = arguments->Length();
+    OwnPtr<v8::Handle<v8::Value>[]> argv = adoptArrayPtr(new v8::Handle<v8::Value>[argc]);
+    for (size_t i = 0; i < argc; ++i)
+        argv[i] = arguments->Get(i);
+
+    v8::Local<v8::Value> result = function->Call(receiver, argc, argv.get());
+    v8SetReturnValue(info, result);
+}
+
+void V8InjectedScriptHost::suppressWarningsAndCallFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    ScriptDebugServer& debugServer = host->scriptDebugServer();
+    debugServer.muteWarningsAndDeprecations();
+
+    callFunctionMethodCustom(info);
+
+    debugServer.unmuteWarningsAndDeprecations();
+}
+
+} // namespace blink
diff --git a/engine/bindings/core/v8/custom/V8InjectedScriptManager.cpp b/engine/bindings/core/v8/custom/V8InjectedScriptManager.cpp
new file mode 100644
index 00000000000..03857a59006
--- /dev/null
+++ b/engine/bindings/core/v8/custom/V8InjectedScriptManager.cpp
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "core/inspector/InjectedScriptManager.h"
+
+#include "bindings/core/v8/BindingSecurity.h"
+#include "bindings/core/v8/ScopedPersistent.h"
+#include "bindings/core/v8/ScriptDebugServer.h"
+#include "bindings/core/v8/ScriptValue.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/V8InjectedScriptHost.h"
+#include "bindings/core/v8/V8ObjectConstructor.h"
+#include "bindings/core/v8/V8ScriptRunner.h"
+#include "bindings/core/v8/V8Window.h"
+#include "core/frame/LocalDOMWindow.h"
+#include "core/inspector/InjectedScriptHost.h"
+#include "wtf/RefPtr.h"
+
+namespace blink {
+
+InjectedScriptManager::CallbackData* InjectedScriptManager::createCallbackData(InjectedScriptManager* injectedScriptManager)
+{
+    OwnPtr<InjectedScriptManager::CallbackData> callbackData = adoptPtr(new InjectedScriptManager::CallbackData());
+    InjectedScriptManager::CallbackData* callbackDataPtr = callbackData.get();
+    callbackData->injectedScriptManager = injectedScriptManager;
+    m_callbackDataSet.add(callbackData.release());
+    return callbackDataPtr;
+}
+
+void InjectedScriptManager::removeCallbackData(InjectedScriptManager::CallbackData* callbackData)
+{
+    ASSERT(m_callbackDataSet.contains(callbackData));
+    m_callbackDataSet.remove(callbackData);
+}
+
+static v8::Local<v8::Object> createInjectedScriptHostV8Wrapper(PassRefPtr<InjectedScriptHost> host, InjectedScriptManager* injectedScriptManager, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+{
+    ASSERT(host);
+
+    v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, &V8InjectedScriptHost::wrapperTypeInfo, V8InjectedScriptHost::toScriptWrappableBase(host.get()), isolate);
+    if (UNLIKELY(wrapper.IsEmpty()))
+        return wrapper;
+
+    // Create a weak reference to the v8 wrapper of InspectorBackend to deref
+    // InspectorBackend when the wrapper is garbage collected.
+    InjectedScriptManager::CallbackData* callbackData = injectedScriptManager->createCallbackData(injectedScriptManager);
+    callbackData->host = host.get();
+    callbackData->handle.set(isolate, wrapper);
+    callbackData->handle.setWeak(callbackData, &InjectedScriptManager::setWeakCallback);
+
+    V8DOMWrapper::setNativeInfo(wrapper, &V8InjectedScriptHost::wrapperTypeInfo, V8InjectedScriptHost::toScriptWrappableBase(host.get()));
+    ASSERT(V8DOMWrapper::isDOMWrapper(wrapper));
+    return wrapper;
+}
+
+ScriptValue InjectedScriptManager::createInjectedScript(const String& scriptSource, ScriptState* inspectedScriptState, int id)
+{
+    v8::Isolate* isolate = inspectedScriptState->isolate();
+    ScriptState::Scope scope(inspectedScriptState);
+
+    // Call custom code to create InjectedScripHost wrapper specific for the context
+    // instead of calling toV8() that would create the
+    // wrapper in the current context.
+    // FIXME: make it possible to use generic bindings factory for InjectedScriptHost.
+    v8::Local<v8::Object> scriptHostWrapper = createInjectedScriptHostV8Wrapper(m_injectedScriptHost, this, inspectedScriptState->context()->Global(), inspectedScriptState->isolate());
+    if (scriptHostWrapper.IsEmpty())
+        return ScriptValue();
+
+    // Inject javascript into the context. The compiled script is supposed to evaluate into
+    // a single anonymous function(it's anonymous to avoid cluttering the global object with
+    // inspector's stuff) the function is called a few lines below with InjectedScriptHost wrapper,
+    // injected script id and explicit reference to the inspected global object. The function is expected
+    // to create and configure InjectedScript instance that is going to be used by the inspector.
+    v8::Local<v8::Value> value = V8ScriptRunner::compileAndRunInternalScript(v8String(isolate, scriptSource), isolate);
+    ASSERT(!value.IsEmpty());
+    ASSERT(value->IsFunction());
+
+    v8::Local<v8::Object> windowGlobal = inspectedScriptState->context()->Global();
+    v8::Handle<v8::Value> info[] = { scriptHostWrapper, windowGlobal, v8::Number::New(inspectedScriptState->isolate(), id) };
+    v8::Local<v8::Value> injectedScriptValue = V8ScriptRunner::callInternalFunction(v8::Local<v8::Function>::Cast(value), windowGlobal, WTF_ARRAY_LENGTH(info), info, inspectedScriptState->isolate());
+    return ScriptValue(inspectedScriptState, injectedScriptValue);
+}
+
+void InjectedScriptManager::setWeakCallback(const v8::WeakCallbackData<v8::Object, InjectedScriptManager::CallbackData>& data)
+{
+    InjectedScriptManager::CallbackData* callbackData = data.GetParameter();
+    callbackData->injectedScriptManager->removeCallbackData(callbackData);
+}
+
+} // namespace blink
diff --git a/engine/bindings/core/v8/custom/custom.gypi b/engine/bindings/core/v8/custom/custom.gypi
index b50daea5703..b5234118603 100644
--- a/engine/bindings/core/v8/custom/custom.gypi
+++ b/engine/bindings/core/v8/custom/custom.gypi
@@ -26,6 +26,8 @@
             'V8HTMLCanvasElementCustom.cpp',
             'V8HTMLElementCustom.cpp',
             'V8ImageDataCustom.cpp',
+            'V8InjectedScriptHostCustom.cpp',
+            'V8InjectedScriptManager.cpp',
             'V8Int16ArrayCustom.h',
             'V8Int32ArrayCustom.h',
             'V8Int8ArrayCustom.h',
diff --git a/engine/bindings/core/v8/v8.gypi b/engine/bindings/core/v8/v8.gypi
index e2ec6005997..850b3e13810 100644
--- a/engine/bindings/core/v8/v8.gypi
+++ b/engine/bindings/core/v8/v8.gypi
@@ -69,6 +69,8 @@
             'ScriptPromiseProperty.h',
             'ScriptPromisePropertyBase.cpp',
             'ScriptPromisePropertyBase.h',
+            'ScriptRegexp.cpp',
+            'ScriptRegexp.h',
             'ScriptSourceCode.h',
             'ScriptState.cpp',
             'ScriptState.h',
@@ -127,6 +129,8 @@
             'WindowProxy.cpp',
             'WindowProxy.h',
             'WrapperTypeInfo.h',
+            'PageScriptDebugServer.h',
+            'PageScriptDebugServer.cpp',
         ],
     },
 }
diff --git a/engine/core/BUILD.gn b/engine/core/BUILD.gn
index 6f9140ca41a..e525aceff24 100644
--- a/engine/core/BUILD.gn
+++ b/engine/core/BUILD.gn
@@ -12,19 +12,21 @@ rel_sky_core_gen_dir = rebase_path(sky_core_output_dir, root_build_dir)
 
 source_set("libraries") {
   public_deps = [
-    "//base:base",
+    "//base",
     "//gin",
     "//gpu/command_buffer/client:gles2_c_lib",
     "//mojo/application",
     "//mojo/common",
     "//mojo/public/c/system:for_shared_library",
     "//mojo/public/cpp/bindings",
-    "//mojo/public/cpp/utility",
     "//mojo/public/cpp/system",
+    "//mojo/public/cpp/utility",
+    "//mojo/public/interfaces/application",
     "//mojo/services/public/cpp/view_manager",
     "//mojo/services/public/interfaces/navigation",
     "//skia",
     "//sky/engine/wtf",
+    "//sky/services/inspector:bindings",
     "//third_party/angle:translator",
     "//third_party/iccjpeg",
     "//third_party/libpng",
@@ -104,6 +106,11 @@ source_set("core_generated") {
 
     # Additional .cpp files from the make_core_generated rules.
     "$sky_core_output_dir/CSSGrammar.cpp",
+
+    # Additional .cpp files from the inspector_protocol_sources list.
+    "$sky_core_output_dir/InspectorFrontend.cpp",
+    "$sky_core_output_dir/InspectorBackendDispatcher.cpp",
+    "$sky_core_output_dir/InspectorTypeBuilder.cpp",
   ]
 
   configs += [
diff --git a/engine/core/core.gni b/engine/core/core.gni
index e21dd085a5f..2545029c51d 100644
--- a/engine/core/core.gni
+++ b/engine/core/core.gni
@@ -1032,22 +1032,49 @@ sky_core_files = [
   "html/VoidCallback.h",
   "Init.cpp",
   "Init.h",
+  "inspector/AsyncCallStackTracker.cpp",
+  "inspector/AsyncCallStackTracker.h",
   "inspector/BindingVisitors.h",
   "inspector/ConsoleAPITypes.h",
   "inspector/ConsoleMessage.cpp",
   "inspector/ConsoleMessage.h",
   "inspector/ConsoleMessageStorage.cpp",
   "inspector/ConsoleMessageStorage.h",
+  "inspector/ContentSearchUtils.cpp",
+  "inspector/ContentSearchUtils.h",
   "inspector/IdentifiersFactory.cpp",
   "inspector/IdentifiersFactory.h",
+  "inspector/InjectedScript.cpp",
+  "inspector/InjectedScript.h",
+  "inspector/InjectedScriptBase.cpp",
+  "inspector/InjectedScriptBase.h",
+  "inspector/InjectedScriptHost.cpp",
+  "inspector/InjectedScriptHost.h",
+  "inspector/InjectedScriptManager.cpp",
+  "inspector/InjectedScriptManager.h",
+  "inspector/inspector_backend_mojo.cc",
+  "inspector/inspector_backend_mojo.h",
+  "inspector/InspectorBaseAgent.cpp",
+  "inspector/InspectorBaseAgent.h",
   "inspector/InspectorCounters.cpp",
   "inspector/InspectorCounters.h",
+  "inspector/InspectorDebuggerAgent.cpp",
+  "inspector/InspectorDebuggerAgent.h",
+  "inspector/InspectorFrontendChannel.h",
   "inspector/InspectorNodeIds.cpp",
   "inspector/InspectorNodeIds.h",
+  "inspector/InspectorState.cpp",
+  "inspector/InspectorState.h",
   "inspector/InspectorTraceEvents.cpp",
   "inspector/InspectorTraceEvents.h",
   "inspector/JavaScriptCallFrame.cpp",
   "inspector/JavaScriptCallFrame.h",
+  "inspector/JSONParser.cpp",
+  "inspector/JSONParser.h",
+  "inspector/PageDebuggerAgent.cpp",
+  "inspector/PageDebuggerAgent.h",
+  "inspector/PromiseTracker.cpp",
+  "inspector/PromiseTracker.h",
   "inspector/ScriptArguments.cpp",
   "inspector/ScriptArguments.h",
   "inspector/ScriptAsyncCallStack.cpp",
@@ -1467,6 +1494,7 @@ core_idl_files = get_path_info([
   "html/TextMetrics.idl",
   "html/VoidCallback.idl",
   "inspector/JavaScriptCallFrame.idl",
+  "inspector/InjectedScriptHost.idl",
 ], "abspath")
 
 # Files for which bindings (.cpp and .h files) will be generated
diff --git a/engine/core/inspector/AsyncCallStackTracker.cpp b/engine/core/inspector/AsyncCallStackTracker.cpp
new file mode 100644
index 00000000000..43adab66835
--- /dev/null
+++ b/engine/core/inspector/AsyncCallStackTracker.cpp
@@ -0,0 +1,401 @@
+/*
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "core/inspector/AsyncCallStackTracker.h"
+
+#include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/V8RecursionScope.h"
+#include "core/dom/ExecutionContext.h"
+// #include "core/dom/ExecutionContextTask.h"
+#include "core/events/Event.h"
+#include "core/events/EventTarget.h"
+#include "wtf/text/StringBuilder.h"
+#include "wtf/text/StringHash.h"
+#include <v8.h>
+
+namespace {
+
+static const char setTimeoutName[] = "setTimeout";
+static const char setIntervalName[] = "setInterval";
+static const char requestAnimationFrameName[] = "requestAnimationFrame";
+static const char enqueueMutationRecordName[] = "Mutation";
+
+}
+
+namespace blink {
+
+void AsyncCallStackTracker::ExecutionContextData::contextDestroyed()
+{
+    ASSERT(executionContext());
+    OwnPtr<ExecutionContextData> self = m_tracker->m_executionContextDataMap.take(executionContext());
+    ASSERT_UNUSED(self, self == this);
+    ContextLifecycleObserver::contextDestroyed();
+}
+
+int AsyncCallStackTracker::ExecutionContextData::circularSequentialID()
+{
+    ++m_circularSequentialID;
+    if (m_circularSequentialID <= 0)
+        m_circularSequentialID = 1;
+    return m_circularSequentialID;
+}
+
+AsyncCallStackTracker::AsyncCallStack::AsyncCallStack(const String& description, const ScriptValue& callFrames)
+    : m_description(description)
+    , m_callFrames(callFrames)
+{
+}
+
+AsyncCallStackTracker::AsyncCallStack::~AsyncCallStack()
+{
+}
+
+AsyncCallStackTracker::AsyncCallStackTracker()
+    : m_maxAsyncCallStackDepth(0)
+    , m_nestedAsyncCallCount(0)
+{
+}
+
+void AsyncCallStackTracker::setAsyncCallStackDepth(int depth)
+{
+    if (depth <= 0) {
+        m_maxAsyncCallStackDepth = 0;
+        clear();
+    } else {
+        m_maxAsyncCallStackDepth = depth;
+    }
+}
+
+const AsyncCallStackTracker::AsyncCallChain* AsyncCallStackTracker::currentAsyncCallChain() const
+{
+    if (m_currentAsyncCallChain)
+        ensureMaxAsyncCallChainDepth(m_currentAsyncCallChain.get(), m_maxAsyncCallStackDepth);
+    return m_currentAsyncCallChain.get();
+}
+
+void AsyncCallStackTracker::didInstallTimer(ExecutionContext* context, int timerId, bool singleShot, const ScriptValue& callFrames)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (!validateCallFrames(callFrames))
+        return;
+    ASSERT(timerId > 0);
+    ExecutionContextData* data = createContextDataIfNeeded(context);
+    data->m_timerCallChains.set(timerId, createAsyncCallChain(singleShot ? setTimeoutName : setIntervalName, callFrames));
+    if (!singleShot)
+        data->m_intervalTimerIds.add(timerId);
+}
+
+void AsyncCallStackTracker::didRemoveTimer(ExecutionContext* context, int timerId)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (timerId <= 0)
+        return;
+    ExecutionContextData* data = m_executionContextDataMap.get(context);
+    if (!data)
+        return;
+    data->m_intervalTimerIds.remove(timerId);
+    data->m_timerCallChains.remove(timerId);
+}
+
+void AsyncCallStackTracker::willFireTimer(ExecutionContext* context, int timerId)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    ASSERT(timerId > 0);
+    ASSERT(!m_currentAsyncCallChain);
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context)) {
+        if (data->m_intervalTimerIds.contains(timerId))
+            setCurrentAsyncCallChain(context, data->m_timerCallChains.get(timerId));
+        else
+            setCurrentAsyncCallChain(context, data->m_timerCallChains.take(timerId));
+    } else {
+        setCurrentAsyncCallChain(context, nullptr);
+    }
+}
+
+void AsyncCallStackTracker::didRequestAnimationFrame(ExecutionContext* context, int callbackId, const ScriptValue& callFrames)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (!validateCallFrames(callFrames))
+        return;
+    ASSERT(callbackId > 0);
+    ExecutionContextData* data = createContextDataIfNeeded(context);
+    data->m_animationFrameCallChains.set(callbackId, createAsyncCallChain(requestAnimationFrameName, callFrames));
+}
+
+void AsyncCallStackTracker::didCancelAnimationFrame(ExecutionContext* context, int callbackId)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (callbackId <= 0)
+        return;
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        data->m_animationFrameCallChains.remove(callbackId);
+}
+
+void AsyncCallStackTracker::willFireAnimationFrame(ExecutionContext* context, int callbackId)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    ASSERT(callbackId > 0);
+    ASSERT(!m_currentAsyncCallChain);
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        setCurrentAsyncCallChain(context, data->m_animationFrameCallChains.take(callbackId));
+    else
+        setCurrentAsyncCallChain(context, nullptr);
+}
+
+void AsyncCallStackTracker::didEnqueueEvent(EventTarget* eventTarget, Event* event, const ScriptValue& callFrames)
+{
+    ASSERT(eventTarget->executionContext());
+    ASSERT(isEnabled());
+    if (!validateCallFrames(callFrames))
+        return;
+    ExecutionContextData* data = createContextDataIfNeeded(eventTarget->executionContext());
+    data->m_eventCallChains.set(event, createAsyncCallChain(event->type(), callFrames));
+}
+
+void AsyncCallStackTracker::didRemoveEvent(EventTarget* eventTarget, Event* event)
+{
+    ASSERT(eventTarget->executionContext());
+    ASSERT(isEnabled());
+    if (ExecutionContextData* data = m_executionContextDataMap.get(eventTarget->executionContext()))
+        data->m_eventCallChains.remove(event);
+}
+
+void AsyncCallStackTracker::willHandleEvent(EventTarget* eventTarget, Event* event, EventListener* listener, bool useCapture)
+{
+    ASSERT(eventTarget->executionContext());
+    ASSERT(isEnabled());
+    ExecutionContext* context = eventTarget->executionContext();
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        setCurrentAsyncCallChain(context, data->m_eventCallChains.get(event));
+    else
+        setCurrentAsyncCallChain(context, nullptr);
+}
+
+void AsyncCallStackTracker::didEnqueueMutationRecord(ExecutionContext* context, MutationObserver* observer, const ScriptValue& callFrames)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (!validateCallFrames(callFrames))
+        return;
+    ExecutionContextData* data = createContextDataIfNeeded(context);
+    data->m_mutationObserverCallChains.set(observer, createAsyncCallChain(enqueueMutationRecordName, callFrames));
+}
+
+bool AsyncCallStackTracker::hasEnqueuedMutationRecord(ExecutionContext* context, MutationObserver* observer)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        return data->m_mutationObserverCallChains.contains(observer);
+    return false;
+}
+
+void AsyncCallStackTracker::didClearAllMutationRecords(ExecutionContext* context, MutationObserver* observer)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        data->m_mutationObserverCallChains.remove(observer);
+}
+
+void AsyncCallStackTracker::willDeliverMutationRecords(ExecutionContext* context, MutationObserver* observer)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        setCurrentAsyncCallChain(context, data->m_mutationObserverCallChains.take(observer));
+    else
+        setCurrentAsyncCallChain(context, nullptr);
+}
+
+// void AsyncCallStackTracker::didPostExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task, const ScriptValue& callFrames)
+// {
+//     ASSERT(context);
+//     ASSERT(isEnabled());
+//     if (!validateCallFrames(callFrames))
+//         return;
+//     ExecutionContextData* data = createContextDataIfNeeded(context);
+//     data->m_executionContextTaskCallChains.set(task, createAsyncCallChain(task->taskNameForInstrumentation(), callFrames));
+// }
+
+// void AsyncCallStackTracker::didKillAllExecutionContextTasks(ExecutionContext* context)
+// {
+//     ASSERT(context);
+//     ASSERT(isEnabled());
+//     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+//         data->m_executionContextTaskCallChains.clear();
+// }
+
+// void AsyncCallStackTracker::willPerformExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task)
+// {
+//     ASSERT(context);
+//     ASSERT(isEnabled());
+//     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+//         setCurrentAsyncCallChain(context, data->m_executionContextTaskCallChains.take(task));
+//     else
+//         setCurrentAsyncCallChain(context, nullptr);
+// }
+
+static String makeV8AsyncTaskUniqueId(const String& eventName, int id)
+{
+    StringBuilder builder;
+    builder.append(eventName);
+    builder.appendNumber(id);
+    return builder.toString();
+}
+
+void AsyncCallStackTracker::didEnqueueV8AsyncTask(ExecutionContext* context, const String& eventName, int id, const ScriptValue& callFrames)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (!validateCallFrames(callFrames))
+        return;
+    ExecutionContextData* data = createContextDataIfNeeded(context);
+    data->m_v8AsyncTaskCallChains.set(makeV8AsyncTaskUniqueId(eventName, id), createAsyncCallChain(eventName, callFrames));
+}
+
+void AsyncCallStackTracker::willHandleV8AsyncTask(ExecutionContext* context, const String& eventName, int id)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        setCurrentAsyncCallChain(context, data->m_v8AsyncTaskCallChains.take(makeV8AsyncTaskUniqueId(eventName, id)));
+    else
+        setCurrentAsyncCallChain(context, nullptr);
+}
+
+int AsyncCallStackTracker::traceAsyncOperationStarting(ExecutionContext* context, const String& operationName, const ScriptValue& callFrames)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (!validateCallFrames(callFrames))
+        return 0;
+    ExecutionContextData* data = createContextDataIfNeeded(context);
+    int id = data->circularSequentialID();
+    while (data->m_asyncOperationCallChains.contains(id))
+        id = data->circularSequentialID();
+    data->m_asyncOperationCallChains.set(id, createAsyncCallChain(operationName, callFrames));
+    return id;
+}
+
+void AsyncCallStackTracker::traceAsyncOperationCompleted(ExecutionContext* context, int operationId)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (operationId <= 0)
+        return;
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        data->m_asyncOperationCallChains.remove(operationId);
+}
+
+void AsyncCallStackTracker::traceAsyncCallbackStarting(ExecutionContext* context, int operationId)
+{
+    ASSERT(context);
+    ASSERT(isEnabled());
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        setCurrentAsyncCallChain(context, operationId > 0 ? data->m_asyncOperationCallChains.get(operationId) : nullptr);
+    else
+        setCurrentAsyncCallChain(context, nullptr);
+}
+
+void AsyncCallStackTracker::didFireAsyncCall()
+{
+    clearCurrentAsyncCallChain();
+}
+
+PassRefPtr<AsyncCallStackTracker::AsyncCallChain> AsyncCallStackTracker::createAsyncCallChain(const String& description, const ScriptValue& callFrames)
+{
+    if (callFrames.isEmpty()) {
+        ASSERT(m_currentAsyncCallChain);
+        return m_currentAsyncCallChain; // Propogate async call stack chain.
+    }
+    RefPtr<AsyncCallChain> chain = adoptRef(m_currentAsyncCallChain ? new AsyncCallStackTracker::AsyncCallChain(*m_currentAsyncCallChain) : new AsyncCallStackTracker::AsyncCallChain());
+    ensureMaxAsyncCallChainDepth(chain.get(), m_maxAsyncCallStackDepth - 1);
+    chain->m_callStacks.prepend(adoptRef(new AsyncCallStackTracker::AsyncCallStack(description, callFrames)));
+    return chain.release();
+}
+
+void AsyncCallStackTracker::setCurrentAsyncCallChain(ExecutionContext* context, PassRefPtr<AsyncCallChain> chain)
+{
+    if (chain && !V8RecursionScope::recursionLevel(toIsolate(context))) {
+        // Current AsyncCallChain corresponds to the bottommost JS call frame.
+        m_currentAsyncCallChain = chain;
+        m_nestedAsyncCallCount = 1;
+    } else {
+        if (m_currentAsyncCallChain)
+            ++m_nestedAsyncCallCount;
+    }
+}
+
+void AsyncCallStackTracker::clearCurrentAsyncCallChain()
+{
+    if (!m_nestedAsyncCallCount)
+        return;
+    --m_nestedAsyncCallCount;
+    if (!m_nestedAsyncCallCount)
+        m_currentAsyncCallChain.clear();
+}
+
+void AsyncCallStackTracker::ensureMaxAsyncCallChainDepth(AsyncCallChain* chain, unsigned maxDepth)
+{
+    while (chain->m_callStacks.size() > maxDepth)
+        chain->m_callStacks.removeLast();
+}
+
+bool AsyncCallStackTracker::validateCallFrames(const ScriptValue& callFrames)
+{
+    return !callFrames.isEmpty() || m_currentAsyncCallChain;
+}
+
+AsyncCallStackTracker::ExecutionContextData* AsyncCallStackTracker::createContextDataIfNeeded(ExecutionContext* context)
+{
+    ExecutionContextData* data = m_executionContextDataMap.get(context);
+    if (!data) {
+        data = m_executionContextDataMap.set(context, adoptPtr(new AsyncCallStackTracker::ExecutionContextData(this, context)))
+            .storedValue->value.get();
+    }
+    return data;
+}
+
+void AsyncCallStackTracker::clear()
+{
+    m_currentAsyncCallChain.clear();
+    m_nestedAsyncCallCount = 0;
+    m_executionContextDataMap.clear();
+}
+
+} // namespace blink
diff --git a/engine/core/inspector/AsyncCallStackTracker.h b/engine/core/inspector/AsyncCallStackTracker.h
new file mode 100644
index 00000000000..c3f99ff0551
--- /dev/null
+++ b/engine/core/inspector/AsyncCallStackTracker.h
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+#ifndef AsyncCallStackTracker_h
+#define AsyncCallStackTracker_h
+
+#include "bindings/core/v8/ScriptValue.h"
+#include "core/dom/ContextLifecycleObserver.h"
+#include "wtf/Deque.h"
+#include "wtf/HashMap.h"
+#include "wtf/HashSet.h"
+#include "wtf/Noncopyable.h"
+#include "wtf/PassRefPtr.h"
+#include "wtf/RefPtr.h"
+
+namespace blink {
+
+class Event;
+class EventListener;
+class EventTarget;
+class ExecutionContext;
+class MutationObserver;
+
+class AsyncCallStackTracker final {
+    WTF_MAKE_NONCOPYABLE(AsyncCallStackTracker);
+public:
+    class AsyncCallStack final : public RefCounted<AsyncCallStack> {
+    public:
+        AsyncCallStack(const String&, const ScriptValue&);
+        ~AsyncCallStack();
+        String description() const { return m_description; }
+        ScriptValue callFrames() const { return m_callFrames; }
+    private:
+        String m_description;
+        ScriptValue m_callFrames;
+    };
+
+    typedef Deque<RefPtr<AsyncCallStack>, 4> AsyncCallStackVector;
+
+    class AsyncCallChain final : public RefCounted<AsyncCallChain> {
+    public:
+        AsyncCallChain() { }
+        AsyncCallChain(const AsyncCallChain& t) : m_callStacks(t.m_callStacks) { }
+        AsyncCallStackVector callStacks() const { return m_callStacks; }
+    private:
+        friend class AsyncCallStackTracker;
+        AsyncCallStackVector m_callStacks;
+    };
+
+    class ExecutionContextData final : public ContextLifecycleObserver {
+        WTF_MAKE_FAST_ALLOCATED;
+    public:
+        ExecutionContextData(AsyncCallStackTracker* tracker, ExecutionContext* executionContext)
+            : ContextLifecycleObserver(executionContext)
+            , m_circularSequentialID(0)
+            , m_tracker(tracker)
+        {
+        }
+
+        virtual void contextDestroyed() override;
+
+        int circularSequentialID();
+
+    private:
+        int m_circularSequentialID;
+
+    public:
+        RawPtr<AsyncCallStackTracker> m_tracker;
+        HashSet<int> m_intervalTimerIds;
+        HashMap<int, RefPtr<AsyncCallChain> > m_timerCallChains;
+        HashMap<int, RefPtr<AsyncCallChain> > m_animationFrameCallChains;
+        HashMap<RawPtr<Event>, RefPtr<AsyncCallChain> > m_eventCallChains;
+        HashMap<RawPtr<MutationObserver>, RefPtr<AsyncCallChain> > m_mutationObserverCallChains;
+        //HashMap<ExecutionContextTask*, RefPtr<AsyncCallChain> > m_executionContextTaskCallChains;
+        HashMap<String, RefPtr<AsyncCallChain> > m_v8AsyncTaskCallChains;
+        HashMap<int, RefPtr<AsyncCallChain> > m_asyncOperationCallChains;
+    };
+
+    AsyncCallStackTracker();
+
+    bool isEnabled() const { return m_maxAsyncCallStackDepth; }
+    void setAsyncCallStackDepth(int);
+    const AsyncCallChain* currentAsyncCallChain() const;
+
+    void didInstallTimer(ExecutionContext*, int timerId, bool singleShot, const ScriptValue& callFrames);
+    void didRemoveTimer(ExecutionContext*, int timerId);
+    void willFireTimer(ExecutionContext*, int timerId);
+
+    void didRequestAnimationFrame(ExecutionContext*, int callbackId, const ScriptValue& callFrames);
+    void didCancelAnimationFrame(ExecutionContext*, int callbackId);
+    void willFireAnimationFrame(ExecutionContext*, int callbackId);
+
+    void didEnqueueEvent(EventTarget*, Event*, const ScriptValue& callFrames);
+    void didRemoveEvent(EventTarget*, Event*);
+    void willHandleEvent(EventTarget*, Event*, EventListener*, bool useCapture);
+
+    void didEnqueueMutationRecord(ExecutionContext*, MutationObserver*, const ScriptValue& callFrames);
+    bool hasEnqueuedMutationRecord(ExecutionContext*, MutationObserver*);
+    void didClearAllMutationRecords(ExecutionContext*, MutationObserver*);
+    void willDeliverMutationRecords(ExecutionContext*, MutationObserver*);
+
+    // void didPostExecutionContextTask(ExecutionContext*, ExecutionContextTask*, const ScriptValue& callFrames);
+    // void didKillAllExecutionContextTasks(ExecutionContext*);
+    // void willPerformExecutionContextTask(ExecutionContext*, ExecutionContextTask*);
+
+    void didEnqueueV8AsyncTask(ExecutionContext*, const String& eventName, int id, const ScriptValue& callFrames);
+    void willHandleV8AsyncTask(ExecutionContext*, const String& eventName, int id);
+
+    int traceAsyncOperationStarting(ExecutionContext*, const String& operationName, const ScriptValue& callFrames);
+    void traceAsyncOperationCompleted(ExecutionContext*, int operationId);
+    void traceAsyncCallbackStarting(ExecutionContext*, int operationId);
+
+    void didFireAsyncCall();
+    void clear();
+
+private:
+    PassRefPtr<AsyncCallChain> createAsyncCallChain(const String& description, const ScriptValue& callFrames);
+    void setCurrentAsyncCallChain(ExecutionContext*, PassRefPtr<AsyncCallChain>);
+    void clearCurrentAsyncCallChain();
+    static void ensureMaxAsyncCallChainDepth(AsyncCallChain*, unsigned);
+    bool validateCallFrames(const ScriptValue& callFrames);
+
+    ExecutionContextData* createContextDataIfNeeded(ExecutionContext*);
+
+    unsigned m_maxAsyncCallStackDepth;
+    RefPtr<AsyncCallChain> m_currentAsyncCallChain;
+    unsigned m_nestedAsyncCallCount;
+    typedef HashMap<RawPtr<ExecutionContext>, OwnPtr<ExecutionContextData> > ExecutionContextDataMap;
+    ExecutionContextDataMap m_executionContextDataMap;
+};
+
+} // namespace blink
+
+#endif // !defined(AsyncCallStackTracker_h)
diff --git a/engine/core/inspector/ContentSearchUtils.cpp b/engine/core/inspector/ContentSearchUtils.cpp
new file mode 100644
index 00000000000..d84f74dd247
--- /dev/null
+++ b/engine/core/inspector/ContentSearchUtils.cpp
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. 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 GOOGLE INC.
+ * 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 "core/inspector/ContentSearchUtils.h"
+
+#include "bindings/core/v8/ScriptRegexp.h"
+#include "wtf/Vector.h"
+#include "wtf/text/StringBuilder.h"
+
+namespace blink {
+namespace ContentSearchUtils {
+
+namespace {
+// This should be kept the same as the one in front-end/utilities.js
+static const char regexSpecialCharacters[] = "[](){}+-*.,?\\^$|";
+}
+
+static String createSearchRegexSource(const String& text)
+{
+    StringBuilder result;
+    String specials(regexSpecialCharacters);
+
+    for (unsigned i = 0; i < text.length(); i++) {
+        if (specials.find(text[i]) != kNotFound)
+            result.append('\\');
+        result.append(text[i]);
+    }
+
+    return result.toString();
+}
+
+static Vector<pair<int, String> > getScriptRegexpMatchesByLines(const ScriptRegexp* regex, const String& text)
+{
+    Vector<pair<int, String> > result;
+    if (text.isEmpty())
+        return result;
+
+    OwnPtr<Vector<unsigned> > endings(lineEndings(text));
+    unsigned size = endings->size();
+    unsigned start = 0;
+    for (unsigned lineNumber = 0; lineNumber < size; ++lineNumber) {
+        unsigned lineEnd = endings->at(lineNumber);
+        String line = text.substring(start, lineEnd - start);
+        if (line.endsWith('\r'))
+            line = line.left(line.length() - 1);
+
+        int matchLength;
+        if (regex->match(line, 0, &matchLength) != -1)
+            result.append(pair<int, String>(lineNumber, line));
+
+        start = lineEnd + 1;
+    }
+    return result;
+}
+
+static PassRefPtr<TypeBuilder::Page::SearchMatch> buildObjectForSearchMatch(int lineNumber, const String& lineContent)
+{
+    return TypeBuilder::Page::SearchMatch::create()
+        .setLineNumber(lineNumber)
+        .setLineContent(lineContent)
+        .release();
+}
+
+PassOwnPtr<ScriptRegexp> createSearchRegex(const String& query, bool caseSensitive, bool isRegex)
+{
+    String regexSource = isRegex ? query : createSearchRegexSource(query);
+    return adoptPtr(new ScriptRegexp(regexSource, caseSensitive ? TextCaseSensitive : TextCaseInsensitive));
+}
+
+PassRefPtr<TypeBuilder::Array<TypeBuilder::Page::SearchMatch> > searchInTextByLines(const String& text, const String& query, const bool caseSensitive, const bool isRegex)
+{
+    RefPtr<TypeBuilder::Array<TypeBuilder::Page::SearchMatch> > result = TypeBuilder::Array<TypeBuilder::Page::SearchMatch>::create();
+
+    OwnPtr<ScriptRegexp> regex = ContentSearchUtils::createSearchRegex(query, caseSensitive, isRegex);
+    Vector<pair<int, String> > matches = getScriptRegexpMatchesByLines(regex.get(), text);
+
+    for (Vector<pair<int, String> >::const_iterator it = matches.begin(); it != matches.end(); ++it)
+        result->addItem(buildObjectForSearchMatch(it->first, it->second));
+
+    return result;
+}
+
+static String findMagicComment(const String& content, const String& name, MagicCommentType commentType, bool* deprecated = 0)
+{
+    ASSERT(name.find("=") == kNotFound);
+    if (deprecated)
+        *deprecated = false;
+
+    unsigned length = content.length();
+    unsigned nameLength = name.length();
+
+    size_t pos = length;
+    size_t equalSignPos = 0;
+    size_t closingCommentPos = 0;
+    while (true) {
+        pos = content.reverseFind(name, pos);
+        if (pos == kNotFound)
+            return String();
+
+        // Check for a /\/[\/*][@#][ \t]/ regexp (length of 4) before found name.
+        if (pos < 4)
+            return String();
+        pos -= 4;
+        if (content[pos] != '/')
+            continue;
+        if ((content[pos + 1] != '/' || commentType != JavaScriptMagicComment)
+            && (content[pos + 1] != '*' || commentType != CSSMagicComment))
+            continue;
+        if (content[pos + 2] != '#' && content[pos + 2] != '@')
+            continue;
+        if (content[pos + 3] != ' ' && content[pos + 3] != '\t')
+            continue;
+        equalSignPos = pos + 4 + nameLength;
+        if (equalSignPos < length && content[equalSignPos] != '=')
+            continue;
+        if (commentType == CSSMagicComment) {
+            closingCommentPos = content.find("*/", equalSignPos + 1);
+            if (closingCommentPos == kNotFound)
+                return String();
+        }
+
+        break;
+    }
+
+    if (deprecated && content[pos + 2] == '@')
+        *deprecated = true;
+
+    ASSERT(equalSignPos);
+    ASSERT(commentType != CSSMagicComment || closingCommentPos);
+    size_t urlPos = equalSignPos + 1;
+    String match = commentType == CSSMagicComment
+        ? content.substring(urlPos, closingCommentPos - urlPos)
+        : content.substring(urlPos);
+
+    size_t newLine = match.find("\n");
+    if (newLine != kNotFound)
+        match = match.substring(0, newLine);
+    match = match.stripWhiteSpace();
+
+    String disallowedChars("\"' \t");
+    for (unsigned i = 0; i < match.length(); ++i) {
+        if (disallowedChars.find(match[i]) != kNotFound)
+            return "";
+    }
+
+    return match;
+}
+
+String findSourceURL(const String& content, MagicCommentType commentType, bool* deprecated)
+{
+    return findMagicComment(content, "sourceURL", commentType, deprecated);
+}
+
+String findSourceMapURL(const String& content, MagicCommentType commentType, bool* deprecated)
+{
+    return findMagicComment(content, "sourceMappingURL", commentType, deprecated);
+}
+
+} // namespace ContentSearchUtils
+} // namespace blink
+
diff --git a/engine/core/inspector/ContentSearchUtils.h b/engine/core/inspector/ContentSearchUtils.h
new file mode 100644
index 00000000000..da4306d1b26
--- /dev/null
+++ b/engine/core/inspector/ContentSearchUtils.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. 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 GOOGLE INC.
+ * 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.
+ */
+
+#ifndef ContentSearchUtils_h
+#define ContentSearchUtils_h
+
+#include "core/InspectorTypeBuilder.h"
+#include "wtf/PassOwnPtr.h"
+#include "wtf/text/TextPosition.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+class ScriptRegexp;
+
+namespace ContentSearchUtils {
+
+enum MagicCommentType {
+    JavaScriptMagicComment,
+    CSSMagicComment
+};
+
+PassOwnPtr<ScriptRegexp> createSearchRegex(const String& query, bool caseSensitive, bool isRegex);
+PassRefPtr<TypeBuilder::Array<TypeBuilder::Page::SearchMatch> > searchInTextByLines(const String& text, const String& query, const bool caseSensitive, const bool isRegex);
+
+String findSourceURL(const String& content, MagicCommentType, bool* deprecated);
+String findSourceMapURL(const String& content, MagicCommentType, bool* deprecated);
+
+} // namespace ContentSearchUtils
+} // namespace blink
+
+
+#endif // !defined(ContentSearchUtils_h)
diff --git a/engine/core/inspector/InjectedScript.cpp b/engine/core/inspector/InjectedScript.cpp
new file mode 100644
index 00000000000..bfe6f639414
--- /dev/null
+++ b/engine/core/inspector/InjectedScript.cpp
@@ -0,0 +1,341 @@
+/*
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "core/inspector/InjectedScript.h"
+
+#include "bindings/core/v8/ScriptFunctionCall.h"
+#include "core/inspector/InjectedScriptHost.h"
+#include "platform/JSONValues.h"
+#include "wtf/text/WTFString.h"
+
+using blink::TypeBuilder::Array;
+using blink::TypeBuilder::Debugger::CallFrame;
+using blink::TypeBuilder::Debugger::CollectionEntry;
+using blink::TypeBuilder::Debugger::FunctionDetails;
+using blink::TypeBuilder::Runtime::PropertyDescriptor;
+using blink::TypeBuilder::Runtime::InternalPropertyDescriptor;
+using blink::TypeBuilder::Runtime::RemoteObject;
+
+namespace blink {
+
+InjectedScript::InjectedScript()
+    : InjectedScriptBase("InjectedScript")
+{
+}
+
+InjectedScript::InjectedScript(ScriptValue injectedScriptObject)
+    : InjectedScriptBase("InjectedScript", injectedScriptObject)
+{
+}
+
+void InjectedScript::evaluate(ErrorString* errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<TypeBuilder::Runtime::RemoteObject>* result, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "evaluate");
+    function.appendArgument(expression);
+    function.appendArgument(objectGroup);
+    function.appendArgument(includeCommandLineAPI);
+    function.appendArgument(returnByValue);
+    function.appendArgument(generatePreview);
+    makeEvalCall(errorString, function, result, wasThrown, exceptionDetails);
+}
+
+void InjectedScript::callFunctionOn(ErrorString* errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, RefPtr<TypeBuilder::Runtime::RemoteObject>* result, TypeBuilder::OptOutput<bool>* wasThrown)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "callFunctionOn");
+    function.appendArgument(objectId);
+    function.appendArgument(expression);
+    function.appendArgument(arguments);
+    function.appendArgument(returnByValue);
+    function.appendArgument(generatePreview);
+    makeEvalCall(errorString, function, result, wasThrown);
+}
+
+void InjectedScript::evaluateOnCallFrame(ErrorString* errorString, const ScriptValue& callFrames, const Vector<ScriptValue>& asyncCallStacks, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<RemoteObject>* result, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "evaluateOnCallFrame");
+    function.appendArgument(callFrames);
+    function.appendArgument(asyncCallStacks);
+    function.appendArgument(callFrameId);
+    function.appendArgument(expression);
+    function.appendArgument(objectGroup);
+    function.appendArgument(includeCommandLineAPI);
+    function.appendArgument(returnByValue);
+    function.appendArgument(generatePreview);
+    makeEvalCall(errorString, function, result, wasThrown, exceptionDetails);
+}
+
+void InjectedScript::restartFrame(ErrorString* errorString, const ScriptValue& callFrames, const String& callFrameId, RefPtr<JSONObject>* result)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "restartFrame");
+    function.appendArgument(callFrames);
+    function.appendArgument(callFrameId);
+    RefPtr<JSONValue> resultValue;
+    makeCall(function, &resultValue);
+    if (resultValue) {
+        if (resultValue->type() == JSONValue::TypeString) {
+            resultValue->asString(errorString);
+            return;
+        }
+        if (resultValue->type() == JSONValue::TypeObject) {
+            *result = resultValue->asObject();
+            return;
+        }
+    }
+    *errorString = "Internal error";
+}
+
+void InjectedScript::getStepInPositions(ErrorString* errorString, const ScriptValue& callFrames, const String& callFrameId, RefPtr<Array<TypeBuilder::Debugger::Location> >& positions)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "getStepInPositions");
+    function.appendArgument(callFrames);
+    function.appendArgument(callFrameId);
+    RefPtr<JSONValue> resultValue;
+    makeCall(function, &resultValue);
+    if (resultValue) {
+        if (resultValue->type() == JSONValue::TypeString) {
+            resultValue->asString(errorString);
+            return;
+        }
+        if (resultValue->type() == JSONValue::TypeArray) {
+            positions = Array<TypeBuilder::Debugger::Location>::runtimeCast(resultValue);
+            return;
+        }
+    }
+    *errorString = "Internal error";
+}
+
+void InjectedScript::setVariableValue(ErrorString* errorString, const ScriptValue& callFrames, const String* callFrameIdOpt, const String* functionObjectIdOpt, int scopeNumber, const String& variableName, const String& newValueStr)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "setVariableValue");
+    if (callFrameIdOpt) {
+        function.appendArgument(callFrames);
+        function.appendArgument(*callFrameIdOpt);
+    } else {
+        function.appendArgument(false);
+        function.appendArgument(false);
+    }
+    if (functionObjectIdOpt)
+        function.appendArgument(*functionObjectIdOpt);
+    else
+        function.appendArgument(false);
+    function.appendArgument(scopeNumber);
+    function.appendArgument(variableName);
+    function.appendArgument(newValueStr);
+    RefPtr<JSONValue> resultValue;
+    makeCall(function, &resultValue);
+    if (!resultValue) {
+        *errorString = "Internal error";
+        return;
+    }
+    if (resultValue->type() == JSONValue::TypeString) {
+        resultValue->asString(errorString);
+        return;
+    }
+    // Normal return.
+}
+
+void InjectedScript::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<FunctionDetails>* result)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "getFunctionDetails");
+    function.appendArgument(functionId);
+    RefPtr<JSONValue> resultValue;
+    makeCall(function, &resultValue);
+    if (!resultValue || resultValue->type() != JSONValue::TypeObject) {
+        if (!resultValue->asString(errorString))
+            *errorString = "Internal error";
+        return;
+    }
+    *result = FunctionDetails::runtimeCast(resultValue);
+}
+
+void InjectedScript::getCollectionEntries(ErrorString* errorString, const String& objectId, RefPtr<Array<CollectionEntry> >* result)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "getCollectionEntries");
+    function.appendArgument(objectId);
+    RefPtr<JSONValue> resultValue;
+    makeCall(function, &resultValue);
+    if (!resultValue || resultValue->type() != JSONValue::TypeArray) {
+        if (!resultValue->asString(errorString))
+            *errorString = "Internal error";
+        return;
+    }
+    *result = Array<CollectionEntry>::runtimeCast(resultValue);
+}
+
+void InjectedScript::getProperties(ErrorString* errorString, const String& objectId, bool ownProperties, bool accessorPropertiesOnly, RefPtr<Array<PropertyDescriptor> >* properties)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "getProperties");
+    function.appendArgument(objectId);
+    function.appendArgument(ownProperties);
+    function.appendArgument(accessorPropertiesOnly);
+
+    RefPtr<JSONValue> result;
+    makeCall(function, &result);
+    if (!result || result->type() != JSONValue::TypeArray) {
+        *errorString = "Internal error";
+        return;
+    }
+    *properties = Array<PropertyDescriptor>::runtimeCast(result);
+}
+
+void InjectedScript::getInternalProperties(ErrorString* errorString, const String& objectId, RefPtr<Array<InternalPropertyDescriptor> >* properties)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "getInternalProperties");
+    function.appendArgument(objectId);
+
+    RefPtr<JSONValue> result;
+    makeCall(function, &result);
+    if (!result || result->type() != JSONValue::TypeArray) {
+        *errorString = "Internal error";
+        return;
+    }
+    RefPtr<Array<InternalPropertyDescriptor> > array = Array<InternalPropertyDescriptor>::runtimeCast(result);
+    if (array->length() > 0)
+        *properties = array;
+}
+
+Node* InjectedScript::nodeForObjectId(const String& objectId)
+{
+    if (isEmpty())
+        return 0;
+
+    ScriptFunctionCall function(injectedScriptObject(), "nodeForObjectId");
+    function.appendArgument(objectId);
+
+    bool hadException = false;
+    ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
+    ASSERT(!hadException);
+
+    return InjectedScriptHost::scriptValueAsNode(scriptState(), resultValue);
+}
+
+void InjectedScript::releaseObject(const String& objectId)
+{
+    ScriptFunctionCall function(injectedScriptObject(), "releaseObject");
+    function.appendArgument(objectId);
+    RefPtr<JSONValue> result;
+    makeCall(function, &result);
+}
+
+PassRefPtr<Array<CallFrame> > InjectedScript::wrapCallFrames(const ScriptValue& callFrames, int asyncOrdinal)
+{
+    ASSERT(!isEmpty());
+    ScriptFunctionCall function(injectedScriptObject(), "wrapCallFrames");
+    function.appendArgument(callFrames);
+    function.appendArgument(asyncOrdinal);
+    bool hadException = false;
+    ScriptValue callFramesValue = callFunctionWithEvalEnabled(function, hadException);
+    ASSERT(!hadException);
+    RefPtr<JSONValue> result = callFramesValue.toJSONValue(scriptState());
+    if (result && result->type() == JSONValue::TypeArray)
+        return Array<CallFrame>::runtimeCast(result);
+    return Array<CallFrame>::create();
+}
+
+PassRefPtr<TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapObject(const ScriptValue& value, const String& groupName, bool generatePreview) const
+{
+    ASSERT(!isEmpty());
+    ScriptFunctionCall wrapFunction(injectedScriptObject(), "wrapObject");
+    wrapFunction.appendArgument(value);
+    wrapFunction.appendArgument(groupName);
+    wrapFunction.appendArgument(true);
+    wrapFunction.appendArgument(generatePreview);
+    bool hadException = false;
+    ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
+    if (hadException)
+        return nullptr;
+    RefPtr<JSONObject> rawResult = r.toJSONValue(scriptState())->asObject();
+    return TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
+}
+
+PassRefPtr<TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapTable(const ScriptValue& table, const ScriptValue& columns) const
+{
+    ASSERT(!isEmpty());
+    ScriptFunctionCall wrapFunction(injectedScriptObject(), "wrapTable");
+    wrapFunction.appendArgument(true);
+    wrapFunction.appendArgument(table);
+    if (columns.isEmpty())
+        wrapFunction.appendArgument(false);
+    else
+        wrapFunction.appendArgument(columns);
+    bool hadException = false;
+    ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
+    if (hadException)
+        return nullptr;
+    RefPtr<JSONObject> rawResult = r.toJSONValue(scriptState())->asObject();
+    return TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
+}
+
+PassRefPtr<TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapNode(Node* node, const String& groupName)
+{
+    return wrapObject(nodeAsScriptValue(node), groupName);
+}
+
+ScriptValue InjectedScript::findObjectById(const String& objectId) const
+{
+    ASSERT(!isEmpty());
+    ScriptFunctionCall function(injectedScriptObject(), "findObjectById");
+    function.appendArgument(objectId);
+
+    bool hadException = false;
+    ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
+    ASSERT(!hadException);
+    return resultValue;
+}
+
+void InjectedScript::inspectNode(Node* node)
+{
+    ASSERT(!isEmpty());
+    ScriptFunctionCall function(injectedScriptObject(), "inspectNode");
+    function.appendArgument(nodeAsScriptValue(node));
+    RefPtr<JSONValue> result;
+    makeCall(function, &result);
+}
+
+void InjectedScript::releaseObjectGroup(const String& objectGroup)
+{
+    ASSERT(!isEmpty());
+    ScriptFunctionCall releaseFunction(injectedScriptObject(), "releaseObjectGroup");
+    releaseFunction.appendArgument(objectGroup);
+    bool hadException = false;
+    callFunctionWithEvalEnabled(releaseFunction, hadException);
+    ASSERT(!hadException);
+}
+
+ScriptValue InjectedScript::nodeAsScriptValue(Node* node)
+{
+    return InjectedScriptHost::nodeAsScriptValue(scriptState(), node);
+}
+
+} // namespace blink
+
diff --git a/engine/core/inspector/InjectedScript.h b/engine/core/inspector/InjectedScript.h
new file mode 100644
index 00000000000..33ed21c7aad
--- /dev/null
+++ b/engine/core/inspector/InjectedScript.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+#ifndef InjectedScript_h
+#define InjectedScript_h
+
+#include "bindings/core/v8/ScriptValue.h"
+#include "core/InspectorTypeBuilder.h"
+#include "core/inspector/InjectedScriptBase.h"
+#include "core/inspector/InjectedScriptManager.h"
+#include "core/inspector/ScriptArguments.h"
+#include "wtf/Forward.h"
+#include "wtf/Vector.h"
+
+namespace blink {
+
+class InjectedScriptModule;
+class Node;
+class SerializedScriptValue;
+
+class InjectedScript final : public InjectedScriptBase {
+public:
+    InjectedScript();
+    virtual ~InjectedScript() { }
+
+    void evaluate(
+        ErrorString*,
+        const String& expression,
+        const String& objectGroup,
+        bool includeCommandLineAPI,
+        bool returnByValue,
+        bool generatePreview,
+        RefPtr<TypeBuilder::Runtime::RemoteObject>* result,
+        TypeBuilder::OptOutput<bool>* wasThrown,
+        RefPtr<TypeBuilder::Debugger::ExceptionDetails>*);
+    void callFunctionOn(
+        ErrorString*,
+        const String& objectId,
+        const String& expression,
+        const String& arguments,
+        bool returnByValue,
+        bool generatePreview,
+        RefPtr<TypeBuilder::Runtime::RemoteObject>* result,
+        TypeBuilder::OptOutput<bool>* wasThrown);
+    void evaluateOnCallFrame(
+        ErrorString*,
+        const ScriptValue& callFrames,
+        const Vector<ScriptValue>& asyncCallStacks,
+        const String& callFrameId,
+        const String& expression,
+        const String& objectGroup,
+        bool includeCommandLineAPI,
+        bool returnByValue,
+        bool generatePreview,
+        RefPtr<TypeBuilder::Runtime::RemoteObject>* result,
+        TypeBuilder::OptOutput<bool>* wasThrown,
+        RefPtr<TypeBuilder::Debugger::ExceptionDetails>*);
+    void restartFrame(ErrorString*, const ScriptValue& callFrames, const String& callFrameId, RefPtr<JSONObject>* result);
+    void getStepInPositions(ErrorString*, const ScriptValue& callFrames, const String& callFrameId, RefPtr<TypeBuilder::Array<TypeBuilder::Debugger::Location> >& positions);
+    void setVariableValue(ErrorString*, const ScriptValue& callFrames, const String* callFrameIdOpt, const String* functionObjectIdOpt, int scopeNumber, const String& variableName, const String& newValueStr);
+    void getFunctionDetails(ErrorString*, const String& functionId, RefPtr<TypeBuilder::Debugger::FunctionDetails>* result);
+    void getCollectionEntries(ErrorString*, const String& objectId, RefPtr<TypeBuilder::Array<TypeBuilder::Debugger::CollectionEntry> >* result);
+    void getProperties(ErrorString*, const String& objectId, bool ownProperties, bool accessorPropertiesOnly, RefPtr<TypeBuilder::Array<TypeBuilder::Runtime::PropertyDescriptor> >* result);
+    void getInternalProperties(ErrorString*, const String& objectId, RefPtr<TypeBuilder::Array<TypeBuilder::Runtime::InternalPropertyDescriptor> >* result);
+    Node* nodeForObjectId(const String& objectId);
+    void releaseObject(const String& objectId);
+
+    PassRefPtr<TypeBuilder::Array<TypeBuilder::Debugger::CallFrame> > wrapCallFrames(const ScriptValue&, int asyncOrdinal);
+
+    PassRefPtr<TypeBuilder::Runtime::RemoteObject> wrapObject(const ScriptValue&, const String& groupName, bool generatePreview = false) const;
+    PassRefPtr<TypeBuilder::Runtime::RemoteObject> wrapTable(const ScriptValue& table, const ScriptValue& columns) const;
+    PassRefPtr<TypeBuilder::Runtime::RemoteObject> wrapNode(Node*, const String& groupName);
+    ScriptValue findObjectById(const String& objectId) const;
+
+    void inspectNode(Node*);
+    void releaseObjectGroup(const String&);
+
+private:
+    friend class InjectedScriptModule;
+    friend InjectedScript InjectedScriptManager::injectedScriptFor(ScriptState*);
+    explicit InjectedScript(ScriptValue);
+
+    ScriptValue nodeAsScriptValue(Node*);
+};
+
+
+} // namespace blink
+
+#endif
diff --git a/engine/core/inspector/InjectedScriptBase.cpp b/engine/core/inspector/InjectedScriptBase.cpp
new file mode 100644
index 00000000000..a73dade4eb7
--- /dev/null
+++ b/engine/core/inspector/InjectedScriptBase.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "core/inspector/InjectedScriptBase.h"
+
+#include "bindings/core/v8/ScriptFunctionCall.h"
+#include "core/inspector/InspectorTraceEvents.h"
+#include "platform/JSONValues.h"
+#include "wtf/text/WTFString.h"
+
+using blink::TypeBuilder::Array;
+using blink::TypeBuilder::Runtime::RemoteObject;
+
+namespace blink {
+
+static PassRefPtr<TypeBuilder::Debugger::ExceptionDetails> toExceptionDetails(PassRefPtr<JSONObject> object)
+{
+    String text;
+    if (!object->getString("text", &text))
+        return nullptr;
+
+    RefPtr<TypeBuilder::Debugger::ExceptionDetails> exceptionDetails = TypeBuilder::Debugger::ExceptionDetails::create().setText(text);
+    String url;
+    if (object->getString("url", &url))
+        exceptionDetails->setUrl(url);
+    int line = 0;
+    if (object->getNumber("line", &line))
+        exceptionDetails->setLine(line);
+    int column = 0;
+    if (object->getNumber("column", &column))
+        exceptionDetails->setColumn(column);
+    RefPtr<JSONArray> stackTrace = object->getArray("stackTrace");
+    if (stackTrace && stackTrace->length() > 0) {
+        RefPtr<TypeBuilder::Array<TypeBuilder::Console::CallFrame> > frames = TypeBuilder::Array<TypeBuilder::Console::CallFrame>::create();
+        for (unsigned i = 0; i < stackTrace->length(); ++i) {
+            RefPtr<JSONObject> stackFrame = stackTrace->get(i)->asObject();
+            int lineNumber = 0;
+            stackFrame->getNumber("lineNumber", &lineNumber);
+            int column = 0;
+            stackFrame->getNumber("column", &column);
+            int scriptId = 0;
+            stackFrame->getNumber("scriptId", &scriptId);
+            String sourceURL;
+            stackFrame->getString("scriptNameOrSourceURL", &sourceURL);
+            String functionName;
+            stackFrame->getString("functionName", &functionName);
+
+            RefPtr<TypeBuilder::Console::CallFrame> callFrame = TypeBuilder::Console::CallFrame::create()
+                .setFunctionName(functionName)
+                .setScriptId(String::number(scriptId))
+                .setUrl(sourceURL)
+                .setLineNumber(lineNumber)
+                .setColumnNumber(column);
+
+            frames->addItem(callFrame.release());
+        }
+        exceptionDetails->setStackTrace(frames.release());
+    }
+    return exceptionDetails.release();
+}
+
+InjectedScriptBase::InjectedScriptBase(const String& name)
+    : m_name(name)
+{
+}
+
+InjectedScriptBase::InjectedScriptBase(const String& name, ScriptValue injectedScriptObject)
+    : m_name(name)
+    , m_injectedScriptObject(injectedScriptObject)
+{
+}
+
+void InjectedScriptBase::initialize(ScriptValue injectedScriptObject)
+{
+    m_injectedScriptObject = injectedScriptObject;
+}
+
+const ScriptValue& InjectedScriptBase::injectedScriptObject() const
+{
+    return m_injectedScriptObject;
+}
+
+ScriptValue InjectedScriptBase::callFunctionWithEvalEnabled(ScriptFunctionCall& function, bool& hadException) const
+{
+    ASSERT(!isEmpty());
+    ExecutionContext* executionContext = m_injectedScriptObject.scriptState()->executionContext();
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "FunctionCall", "data", InspectorFunctionCallEvent::data(executionContext, 0, name(), 1));
+    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", TRACE_EVENT_SCOPE_PROCESS, "stack", InspectorCallStackEvent::currentCallStack());
+
+    ScriptState* scriptState = m_injectedScriptObject.scriptState();
+    bool evalIsDisabled = false;
+    if (scriptState) {
+        evalIsDisabled = !scriptState->evalEnabled();
+        // Temporarily enable allow evals for inspector.
+        if (evalIsDisabled)
+            scriptState->setEvalEnabled(true);
+    }
+
+    ScriptValue resultValue = function.call(hadException);
+
+    if (evalIsDisabled)
+        scriptState->setEvalEnabled(false);
+
+    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_PROCESS, "data", InspectorUpdateCountersEvent::data());
+    return resultValue;
+}
+
+void InjectedScriptBase::makeCall(ScriptFunctionCall& function, RefPtr<JSONValue>* result)
+{
+    if (isEmpty()) {
+        *result = JSONValue::null();
+        return;
+    }
+
+    bool hadException = false;
+    ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
+
+    ASSERT(!hadException);
+    if (!hadException) {
+        *result = resultValue.toJSONValue(m_injectedScriptObject.scriptState());
+        if (!*result)
+            *result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
+    } else {
+        *result = JSONString::create("Exception while making a call.");
+    }
+}
+
+void InjectedScriptBase::makeEvalCall(ErrorString* errorString, ScriptFunctionCall& function, RefPtr<TypeBuilder::Runtime::RemoteObject>* objectResult, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
+{
+    RefPtr<JSONValue> result;
+    makeCall(function, &result);
+    if (!result) {
+        *errorString = "Internal error: result value is empty";
+        return;
+    }
+    if (result->type() == JSONValue::TypeString) {
+        result->asString(errorString);
+        ASSERT(errorString->length());
+        return;
+    }
+    RefPtr<JSONObject> resultPair = result->asObject();
+    if (!resultPair) {
+        *errorString = "Internal error: result is not an Object";
+        return;
+    }
+    RefPtr<JSONObject> resultObj = resultPair->getObject("result");
+    bool wasThrownVal = false;
+    if (!resultObj || !resultPair->getBoolean("wasThrown", &wasThrownVal)) {
+        *errorString = "Internal error: result is not a pair of value and wasThrown flag";
+        return;
+    }
+    if (wasThrownVal) {
+        RefPtr<JSONObject> objectExceptionDetails = resultPair->getObject("exceptionDetails");
+        if (objectExceptionDetails)
+            *exceptionDetails = toExceptionDetails(objectExceptionDetails.release());
+    }
+    *objectResult = TypeBuilder::Runtime::RemoteObject::runtimeCast(resultObj);
+    *wasThrown = wasThrownVal;
+}
+
+} // namespace blink
+
diff --git a/engine/core/inspector/InjectedScriptBase.h b/engine/core/inspector/InjectedScriptBase.h
new file mode 100644
index 00000000000..22a755ba30a
--- /dev/null
+++ b/engine/core/inspector/InjectedScriptBase.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+#ifndef InjectedScriptBase_h
+#define InjectedScriptBase_h
+
+#include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/ScriptValue.h"
+#include "core/InspectorTypeBuilder.h"
+#include "wtf/Forward.h"
+
+namespace blink {
+
+class JSONValue;
+class ScriptFunctionCall;
+
+typedef String ErrorString;
+
+
+class InjectedScriptBase {
+public:
+    virtual ~InjectedScriptBase() { }
+
+    const String& name() const { return m_name; }
+    bool isEmpty() const { return m_injectedScriptObject.isEmpty(); }
+    ScriptState* scriptState() const
+    {
+        ASSERT(!isEmpty());
+        return m_injectedScriptObject.scriptState();
+    }
+
+protected:
+    explicit InjectedScriptBase(const String& name);
+    InjectedScriptBase(const String& name, ScriptValue);
+
+    void initialize(ScriptValue);
+    const ScriptValue& injectedScriptObject() const;
+    ScriptValue callFunctionWithEvalEnabled(ScriptFunctionCall&, bool& hadException) const;
+    void makeCall(ScriptFunctionCall&, RefPtr<JSONValue>* result);
+    void makeEvalCall(ErrorString*, ScriptFunctionCall&, RefPtr<TypeBuilder::Runtime::RemoteObject>* result, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* = 0);
+
+private:
+    String m_name;
+    ScriptValue m_injectedScriptObject;
+};
+
+
+} // namespace blink
+
+#endif
diff --git a/engine/core/inspector/InjectedScriptHost.cpp b/engine/core/inspector/InjectedScriptHost.cpp
new file mode 100644
index 00000000000..acbc30466d7
--- /dev/null
+++ b/engine/core/inspector/InjectedScriptHost.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.com>
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "core/inspector/InjectedScriptHost.h"
+
+#include "core/inspector/InspectorDebuggerAgent.h"
+#include "core/inspector/InstrumentingAgents.h"
+#include "platform/JSONValues.h"
+
+#include "wtf/RefPtr.h"
+#include "wtf/text/StringBuilder.h"
+
+namespace blink {
+
+PassRefPtr<InjectedScriptHost> InjectedScriptHost::create()
+{
+    return adoptRef(new InjectedScriptHost());
+}
+
+InjectedScriptHost::InjectedScriptHost()
+    : m_instrumentingAgents(nullptr)
+    , m_scriptDebugServer(0)
+{
+    m_defaultInspectableObject = adoptPtr(new InspectableObject());
+}
+
+InjectedScriptHost::~InjectedScriptHost()
+{
+}
+
+void InjectedScriptHost::disconnect()
+{
+    m_instrumentingAgents = nullptr;
+    m_scriptDebugServer = 0;
+}
+
+void InjectedScriptHost::inspectImpl(PassRefPtr<JSONValue> object, PassRefPtr<JSONValue> hints)
+{
+    // FIXME(sky)
+}
+
+void InjectedScriptHost::getEventListenersImpl(EventTarget* target, Vector<EventListenerInfo>& listenersArray)
+{
+    // FIXME(sky)
+}
+
+void InjectedScriptHost::clearConsoleMessages()
+{
+    // FIXME(sky)
+}
+
+ScriptValue InjectedScriptHost::InspectableObject::get(ScriptState*)
+{
+    return ScriptValue();
+};
+
+void InjectedScriptHost::addInspectedObject(PassOwnPtr<InjectedScriptHost::InspectableObject> object)
+{
+    m_inspectedObjects.prepend(object);
+    while (m_inspectedObjects.size() > 5)
+        m_inspectedObjects.removeLast();
+}
+
+void InjectedScriptHost::clearInspectedObjects()
+{
+    m_inspectedObjects.clear();
+}
+
+InjectedScriptHost::InspectableObject* InjectedScriptHost::inspectedObject(unsigned num)
+{
+    if (num >= m_inspectedObjects.size())
+        return m_defaultInspectableObject.get();
+    return m_inspectedObjects[num].get();
+}
+
+void InjectedScriptHost::debugFunction(const String& scriptId, int lineNumber, int columnNumber)
+{
+    if (InspectorDebuggerAgent* debuggerAgent = m_instrumentingAgents ? m_instrumentingAgents->inspectorDebuggerAgent() : 0)
+        debuggerAgent->setBreakpoint(scriptId, lineNumber, columnNumber, InspectorDebuggerAgent::DebugCommandBreakpointSource);
+}
+
+void InjectedScriptHost::undebugFunction(const String& scriptId, int lineNumber, int columnNumber)
+{
+    if (InspectorDebuggerAgent* debuggerAgent = m_instrumentingAgents ? m_instrumentingAgents->inspectorDebuggerAgent() : 0)
+        debuggerAgent->removeBreakpoint(scriptId, lineNumber, columnNumber, InspectorDebuggerAgent::DebugCommandBreakpointSource);
+}
+
+void InjectedScriptHost::monitorFunction(const String& scriptId, int lineNumber, int columnNumber, const String& functionName)
+{
+    StringBuilder builder;
+    builder.appendLiteral("console.log(\"function ");
+    if (functionName.isEmpty())
+        builder.appendLiteral("(anonymous function)");
+    else
+        builder.append(functionName);
+    builder.appendLiteral(" called\" + (arguments.length > 0 ? \" with arguments: \" + Array.prototype.join.call(arguments, \", \") : \"\")) && false");
+    if (InspectorDebuggerAgent* debuggerAgent = m_instrumentingAgents ? m_instrumentingAgents->inspectorDebuggerAgent() : 0)
+        debuggerAgent->setBreakpoint(scriptId, lineNumber, columnNumber, InspectorDebuggerAgent::MonitorCommandBreakpointSource, builder.toString());
+}
+
+void InjectedScriptHost::unmonitorFunction(const String& scriptId, int lineNumber, int columnNumber)
+{
+    if (InspectorDebuggerAgent* debuggerAgent = m_instrumentingAgents ? m_instrumentingAgents->inspectorDebuggerAgent() : 0)
+        debuggerAgent->removeBreakpoint(scriptId, lineNumber, columnNumber, InspectorDebuggerAgent::MonitorCommandBreakpointSource);
+}
+
+} // namespace blink
+
diff --git a/engine/core/inspector/InjectedScriptHost.h b/engine/core/inspector/InjectedScriptHost.h
new file mode 100644
index 00000000000..58706f41e51
--- /dev/null
+++ b/engine/core/inspector/InjectedScriptHost.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2009 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef InjectedScriptHost_h
+#define InjectedScriptHost_h
+
+#include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/ScriptWrappable.h"
+#include "wtf/PassOwnPtr.h"
+#include "wtf/RefCounted.h"
+#include "wtf/Vector.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+class Database;
+class EventTarget;
+class InjectedScript;
+class InstrumentingAgents;
+class JSONValue;
+class Node;
+class ScriptDebugServer;
+class ScriptValue;
+class Storage;
+
+struct EventListenerInfo;
+
+// SECURITY NOTE: Although the InjectedScriptHost is intended for use solely by the inspector,
+// a reference to the InjectedScriptHost may be leaked to the page being inspected. Thus, the
+// InjectedScriptHost must never implemment methods that have more power over the page than the
+// page already has itself (e.g. origin restriction bypasses).
+
+class InjectedScriptHost : public RefCounted<InjectedScriptHost>, public ScriptWrappable {
+    DEFINE_WRAPPERTYPEINFO();
+public:
+    static PassRefPtr<InjectedScriptHost> create();
+    ~InjectedScriptHost();
+
+    void init(InstrumentingAgents* instrumentingAgents, ScriptDebugServer* scriptDebugServer)
+    {
+        m_instrumentingAgents = instrumentingAgents;
+        m_scriptDebugServer = scriptDebugServer;
+    }
+
+    static Node* scriptValueAsNode(ScriptState*, ScriptValue);
+    static ScriptValue nodeAsScriptValue(ScriptState*, Node*);
+
+    void disconnect();
+
+    class InspectableObject {
+        WTF_MAKE_FAST_ALLOCATED;
+    public:
+        virtual ScriptValue get(ScriptState*);
+        virtual ~InspectableObject() { }
+    };
+    void addInspectedObject(PassOwnPtr<InspectableObject>);
+    void clearInspectedObjects();
+    InspectableObject* inspectedObject(unsigned num);
+
+    void inspectImpl(PassRefPtr<JSONValue> objectToInspect, PassRefPtr<JSONValue> hints);
+    void getEventListenersImpl(EventTarget*, Vector<EventListenerInfo>& listenersArray);
+
+    void clearConsoleMessages();
+    void debugFunction(const String& scriptId, int lineNumber, int columnNumber);
+    void undebugFunction(const String& scriptId, int lineNumber, int columnNumber);
+    void monitorFunction(const String& scriptId, int lineNumber, int columnNumber, const String& functionName);
+    void unmonitorFunction(const String& scriptId, int lineNumber, int columnNumber);
+
+    ScriptDebugServer& scriptDebugServer() { return *m_scriptDebugServer; }
+
+private:
+    InjectedScriptHost();
+
+    RawPtr<InstrumentingAgents> m_instrumentingAgents;
+    ScriptDebugServer* m_scriptDebugServer;
+    Vector<OwnPtr<InspectableObject> > m_inspectedObjects;
+    OwnPtr<InspectableObject> m_defaultInspectableObject;
+};
+
+} // namespace blink
+
+#endif // InjectedScriptHost_h
diff --git a/engine/core/inspector/InjectedScriptHost.idl b/engine/core/inspector/InjectedScriptHost.idl
new file mode 100644
index 00000000000..d54691dc89c
--- /dev/null
+++ b/engine/core/inspector/InjectedScriptHost.idl
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.com>
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+[
+    NoInterfaceObject
+] interface InjectedScriptHost {
+    [NotEnumerable, Unforgeable] void clearConsoleMessages();
+
+    [NotEnumerable, Unforgeable, Custom] void inspect(any objectId, any hints);
+    [NotEnumerable, Unforgeable, Custom] any inspectedObject(long num);
+    [NotEnumerable, Unforgeable, Custom] any internalConstructorName(any obj);
+    [NotEnumerable, Unforgeable, Custom] boolean isHTMLAllCollection(any obj);
+    [NotEnumerable, Unforgeable, Custom] DOMString subtype(any obj);
+    [NotEnumerable, Unforgeable, Custom] any functionDetails(any obj);
+    [NotEnumerable, Unforgeable, Custom] any[] collectionEntries(any obj);
+    [NotEnumerable, Unforgeable, Custom] any[] getInternalProperties(any obj);
+    [NotEnumerable, Unforgeable, Custom] EventListener[] getEventListeners(EventTarget target);
+    [NotEnumerable, Unforgeable, Custom] any eval(DOMString text);
+    [NotEnumerable, Unforgeable, Custom] any evaluateWithExceptionDetails(DOMString text);
+    [NotEnumerable, Unforgeable, Custom] void debugFunction(any fn);
+    [NotEnumerable, Unforgeable, Custom] void undebugFunction(any fn);
+    [NotEnumerable, Unforgeable, Custom] void monitorFunction(any fn);
+    [NotEnumerable, Unforgeable, Custom] void unmonitorFunction(any fn);
+    [NotEnumerable, Unforgeable, Custom] any callFunction(any fn, any receiver, any[] argv);
+    [NotEnumerable, Unforgeable, Custom] any suppressWarningsAndCallFunction(any fn, any receiver, any[] argv);
+
+    // Only declarative scope (local, with and catch) is accepted. Returns undefined.
+    [NotEnumerable, Unforgeable, Custom] any setFunctionVariableValue(any functionObject, long scopeIndex, DOMString variableName, any newValue);
+};
diff --git a/engine/core/inspector/InjectedScriptManager.cpp b/engine/core/inspector/InjectedScriptManager.cpp
new file mode 100644
index 00000000000..30a3278cc96
--- /dev/null
+++ b/engine/core/inspector/InjectedScriptManager.cpp
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.com>
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "core/inspector/InjectedScriptManager.h"
+
+#include "bindings/core/v8/ScriptValue.h"
+#include "core/inspector/InjectedScript.h"
+#include "core/inspector/InjectedScriptHost.h"
+#include "core/inspector/JSONParser.h"
+#include "platform/JSONValues.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebData.h"
+#include "wtf/PassOwnPtr.h"
+
+namespace blink {
+
+PassOwnPtr<InjectedScriptManager> InjectedScriptManager::createForPage()
+{
+    return adoptPtr(new InjectedScriptManager);
+}
+
+InjectedScriptManager::InjectedScriptManager()
+    : m_nextInjectedScriptId(1)
+    , m_injectedScriptHost(InjectedScriptHost::create())
+{
+}
+
+InjectedScriptManager::~InjectedScriptManager()
+{
+}
+
+void InjectedScriptManager::disconnect()
+{
+    m_injectedScriptHost->disconnect();
+    m_injectedScriptHost.clear();
+}
+
+InjectedScriptHost* InjectedScriptManager::injectedScriptHost()
+{
+    return m_injectedScriptHost.get();
+}
+
+InjectedScript InjectedScriptManager::injectedScriptForId(int id)
+{
+    IdToInjectedScriptMap::iterator it = m_idToInjectedScript.find(id);
+    if (it != m_idToInjectedScript.end())
+        return it->value;
+    for (ScriptStateToId::iterator it = m_scriptStateToId.begin(); it != m_scriptStateToId.end(); ++it) {
+        if (it->value == id)
+            return injectedScriptFor(it->key.get());
+    }
+    return InjectedScript();
+}
+
+int InjectedScriptManager::injectedScriptIdFor(ScriptState* scriptState)
+{
+    ScriptStateToId::iterator it = m_scriptStateToId.find(scriptState);
+    if (it != m_scriptStateToId.end())
+        return it->value;
+    int id = m_nextInjectedScriptId++;
+    m_scriptStateToId.set(scriptState, id);
+    return id;
+}
+
+InjectedScript InjectedScriptManager::injectedScriptForObjectId(const String& objectId)
+{
+    RefPtr<JSONValue> parsedObjectId = parseJSON(objectId);
+    if (parsedObjectId && parsedObjectId->type() == JSONValue::TypeObject) {
+        long injectedScriptId = 0;
+        bool success = parsedObjectId->asObject()->getNumber("injectedScriptId", &injectedScriptId);
+        if (success)
+            return m_idToInjectedScript.get(injectedScriptId);
+    }
+    return InjectedScript();
+}
+
+void InjectedScriptManager::discardInjectedScripts()
+{
+    m_idToInjectedScript.clear();
+    m_scriptStateToId.clear();
+}
+
+void InjectedScriptManager::discardInjectedScriptsFor(LocalDOMWindow* window)
+{
+    if (m_scriptStateToId.isEmpty())
+        return;
+
+    Vector<long> idsToRemove;
+    IdToInjectedScriptMap::iterator end = m_idToInjectedScript.end();
+    for (IdToInjectedScriptMap::iterator it = m_idToInjectedScript.begin(); it != end; ++it) {
+        ScriptState* scriptState = it->value.scriptState();
+        if (window != scriptState->domWindow())
+            continue;
+        m_scriptStateToId.remove(scriptState);
+        idsToRemove.append(it->key);
+    }
+    m_idToInjectedScript.removeAll(idsToRemove);
+
+    // Now remove script states that have id but no injected script.
+    Vector<ScriptState*> scriptStatesToRemove;
+    for (ScriptStateToId::iterator it = m_scriptStateToId.begin(); it != m_scriptStateToId.end(); ++it) {
+        ScriptState* scriptState = it->key.get();
+        if (window == scriptState->domWindow())
+            scriptStatesToRemove.append(scriptState);
+    }
+    m_scriptStateToId.removeAll(scriptStatesToRemove);
+}
+
+void InjectedScriptManager::releaseObjectGroup(const String& objectGroup)
+{
+    Vector<int> keys;
+    keys.appendRange(m_idToInjectedScript.keys().begin(), m_idToInjectedScript.keys().end());
+    for (Vector<int>::iterator k = keys.begin(); k != keys.end(); ++k) {
+        IdToInjectedScriptMap::iterator s = m_idToInjectedScript.find(*k);
+        if (s != m_idToInjectedScript.end())
+            s->value.releaseObjectGroup(objectGroup); // m_idToInjectedScript may change here.
+    }
+}
+
+String InjectedScriptManager::injectedScriptSource()
+{
+    const blink::WebData& injectedScriptSourceResource = blink::Platform::current()->loadResource("InjectedScriptSource.js");
+    return String(injectedScriptSourceResource.data(), injectedScriptSourceResource.size());
+}
+
+InjectedScript InjectedScriptManager::injectedScriptFor(ScriptState* inspectedScriptState)
+{
+    ScriptStateToId::iterator it = m_scriptStateToId.find(inspectedScriptState);
+    if (it != m_scriptStateToId.end()) {
+        IdToInjectedScriptMap::iterator it1 = m_idToInjectedScript.find(it->value);
+        if (it1 != m_idToInjectedScript.end())
+            return it1->value;
+    }
+
+    int id = injectedScriptIdFor(inspectedScriptState);
+    ScriptValue injectedScriptValue = createInjectedScript(injectedScriptSource(), inspectedScriptState, id);
+    InjectedScript result(injectedScriptValue);
+    m_idToInjectedScript.set(id, result);
+    return result;
+}
+
+} // namespace blink
+
diff --git a/engine/core/inspector/InjectedScriptManager.h b/engine/core/inspector/InjectedScriptManager.h
new file mode 100644
index 00000000000..c42e77674e4
--- /dev/null
+++ b/engine/core/inspector/InjectedScriptManager.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef InjectedScriptManager_h
+#define InjectedScriptManager_h
+
+#include "bindings/core/v8/ScriptState.h"
+#include "wtf/Forward.h"
+#include "wtf/HashMap.h"
+#include "wtf/HashSet.h"
+#include "wtf/text/WTFString.h"
+#include <v8.h>
+
+namespace blink {
+
+class LocalDOMWindow;
+class InjectedScript;
+class InjectedScriptHost;
+class ScriptValue;
+
+class InjectedScriptManager {
+    WTF_MAKE_NONCOPYABLE(InjectedScriptManager);
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    struct CallbackData {
+        ScopedPersistent<v8::Object> handle;
+        RefPtr<InjectedScriptHost> host;
+        InjectedScriptManager* injectedScriptManager;
+    };
+
+    static PassOwnPtr<InjectedScriptManager> createForPage();
+    ~InjectedScriptManager();
+
+    void disconnect();
+
+    InjectedScriptHost* injectedScriptHost();
+
+    InjectedScript injectedScriptFor(ScriptState*);
+    InjectedScript injectedScriptForId(int);
+    int injectedScriptIdFor(ScriptState*);
+    InjectedScript injectedScriptForObjectId(const String& objectId);
+    void discardInjectedScripts();
+    void discardInjectedScriptsFor(LocalDOMWindow*);
+    void releaseObjectGroup(const String& objectGroup);
+
+    static void setWeakCallback(const v8::WeakCallbackData<v8::Object, CallbackData>&);
+    CallbackData* createCallbackData(InjectedScriptManager*);
+    void removeCallbackData(CallbackData*);
+
+private:
+    explicit InjectedScriptManager();
+
+    String injectedScriptSource();
+    ScriptValue createInjectedScript(const String& source, ScriptState*, int id);
+
+    int m_nextInjectedScriptId;
+    typedef HashMap<int, InjectedScript> IdToInjectedScriptMap;
+    IdToInjectedScriptMap m_idToInjectedScript;
+    RefPtr<InjectedScriptHost> m_injectedScriptHost;
+    typedef HashMap<RefPtr<ScriptState>, int> ScriptStateToId;
+    ScriptStateToId m_scriptStateToId;
+    HashSet<OwnPtr<CallbackData> > m_callbackDataSet;
+};
+
+} // namespace blink
+
+#endif // !defined(InjectedScriptManager_h)
diff --git a/engine/core/inspector/InjectedScriptSource.js b/engine/core/inspector/InjectedScriptSource.js
new file mode 100644
index 00000000000..a5054c15c18
--- /dev/null
+++ b/engine/core/inspector/InjectedScriptSource.js
@@ -0,0 +1,1731 @@
+/*
+ * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @param {InjectedScriptHost} InjectedScriptHost
+ * @param {Window} inspectedWindow
+ * @param {number} injectedScriptId
+ */
+(function (InjectedScriptHost, inspectedWindow, injectedScriptId) {
+
+/**
+ * Protect against Object overwritten by the user code.
+ * @suppress {duplicate}
+ */
+var Object = /** @type {function(new:Object, *=)} */ ({}.constructor);
+
+/**
+ * @param {!Array.<T>} array
+ * @param {...} var_args
+ * @template T
+ */
+function push(array, var_args)
+{
+    for (var i = 1; i < arguments.length; ++i)
+        array[array.length] = arguments[i];
+}
+
+/**
+ * @param {!Arguments.<T>} array
+ * @param {number=} index
+ * @return {!Array.<T>}
+ * @template T
+ */
+function slice(array, index)
+{
+    var result = [];
+    for (var i = index || 0, j = 0; i < array.length; ++i, ++j)
+        result[j] = array[i];
+    return result;
+}
+
+/**
+ * @param {!Array.<T>} array1
+ * @param {!Array.<T>} array2
+ * @return {!Array.<T>}
+ * @template T
+ */
+function concat(array1, array2)
+{
+    var result = [];
+    for (var i = 0; i < array1.length; ++i)
+        push(result, array1[i]);
+    for (var i = 0; i < array2.length; ++i)
+        push(result, array2[i]);
+    return result;
+}
+
+/**
+ * @param {*} obj
+ * @return {string}
+ */
+function toString(obj)
+{
+    // We don't use String(obj) because it could be overriden.
+    return "" + obj;
+}
+
+/**
+ * @param {*} obj
+ * @return {string}
+ */
+function toStringDescription(obj)
+{
+    if (typeof obj === "number" && obj === 0 && 1 / obj < 0)
+        return "-0"; // Negative zero.
+    return "" + obj;
+}
+
+/**
+ * Please use this bind, not the one from Function.prototype
+ * @param {function(...)} func
+ * @param {?Object} thisObject
+ * @param {...} var_args
+ * @return {function(...)}
+ */
+function bind(func, thisObject, var_args)
+{
+    var args = slice(arguments, 2);
+
+    /**
+     * @param {...} var_args
+     */
+    function bound(var_args)
+    {
+        return InjectedScriptHost.callFunction(func, thisObject, concat(args, slice(arguments)));
+    }
+    bound.toString = function()
+    {
+        return "bound: " + func;
+    };
+    return bound;
+}
+
+/**
+ * @param {T} obj
+ * @return {T}
+ * @template T
+ */
+function nullifyObjectProto(obj)
+{
+    if (obj && typeof obj === "object")
+        obj.__proto__ = null;
+    return obj;
+}
+
+/**
+ * @param {*} obj
+ * @return {boolean}
+ */
+function isUInt32(obj)
+{
+    return typeof obj === "number" && obj >>> 0 === obj && (obj > 0 || 1 / obj > 0);
+}
+
+/**
+ * FireBug's array detection.
+ * @param {*} obj
+ * @return {boolean}
+ */
+function isArrayLike(obj)
+{
+    if (typeof obj !== "object")
+        return false;
+    try {
+        if (typeof obj.splice === "function")
+            return isUInt32(obj.length);
+    } catch (e) {
+    }
+    return false;
+}
+
+/**
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+function max(a, b)
+{
+    return a > b ? a : b;
+}
+
+/**
+ * FIXME: Remove once ES6 is supported natively by JS compiler.
+ * @param {*} obj
+ * @return {boolean}
+ */
+function isSymbol(obj)
+{
+    var type = typeof obj;
+    return (type === "symbol");
+}
+
+/**
+ * @constructor
+ */
+var InjectedScript = function()
+{
+    /** @type {number} */
+    this._lastBoundObjectId = 1;
+    /** @type {!Object.<number, (!Object|symbol)>} */
+    this._idToWrappedObject = { __proto__: null };
+    /** @type {!Object.<number, string>} */
+    this._idToObjectGroupName = { __proto__: null };
+    /** @type {!Object.<string, !Array.<number>>} */
+    this._objectGroups = { __proto__: null };
+    /** @type {!Object.<string, !Object>} */
+    this._modules = { __proto__: null };
+}
+
+/**
+ * @type {!Object.<string, boolean>}
+ * @const
+ */
+InjectedScript.primitiveTypes = {
+    "undefined": true,
+    "boolean": true,
+    "number": true,
+    "string": true,
+    __proto__: null
+}
+
+InjectedScript.prototype = {
+    /**
+     * @param {*} object
+     * @return {boolean}
+     */
+    isPrimitiveValue: function(object)
+    {
+        // FIXME(33716): typeof document.all is always 'undefined'.
+        return InjectedScript.primitiveTypes[typeof object] && !this._isHTMLAllCollection(object);
+    },
+
+    /**
+     * @param {*} object
+     * @param {string} groupName
+     * @param {boolean} canAccessInspectedWindow
+     * @param {boolean} generatePreview
+     * @return {!RuntimeAgent.RemoteObject}
+     */
+    wrapObject: function(object, groupName, canAccessInspectedWindow, generatePreview)
+    {
+        if (canAccessInspectedWindow)
+            return this._wrapObject(object, groupName, false, generatePreview);
+        return this._fallbackWrapper(object);
+    },
+
+    /**
+     * @param {*} object
+     * @return {!RuntimeAgent.RemoteObject}
+     */
+    _fallbackWrapper: function(object)
+    {
+        var result = { __proto__: null };
+        result.type = typeof object;
+        if (this.isPrimitiveValue(object))
+            result.value = object;
+        else
+            result.description = toString(object);
+        return /** @type {!RuntimeAgent.RemoteObject} */ (result);
+    },
+
+    /**
+     * @param {boolean} canAccessInspectedWindow
+     * @param {!Object} table
+     * @param {!Array.<string>|string|boolean} columns
+     * @return {!RuntimeAgent.RemoteObject}
+     */
+    wrapTable: function(canAccessInspectedWindow, table, columns)
+    {
+        if (!canAccessInspectedWindow)
+            return this._fallbackWrapper(table);
+        var columnNames = null;
+        if (typeof columns === "string")
+            columns = [columns];
+        if (InjectedScriptHost.subtype(columns) === "array") {
+            columnNames = [];
+            for (var i = 0; i < columns.length; ++i)
+                columnNames[i] = toString(columns[i]);
+        }
+        return this._wrapObject(table, "console", false, true, columnNames, true);
+    },
+
+    /**
+     * @param {*} object
+     */
+    inspectNode: function(object)
+    {
+        this._inspect(object);
+    },
+
+    /**
+     * @param {*} object
+     * @return {*}
+     */
+    _inspect: function(object)
+    {
+        if (arguments.length === 0)
+            return;
+
+        var objectId = this._wrapObject(object, "");
+        var hints = { __proto__: null };
+
+        InjectedScriptHost.inspect(objectId, hints);
+        return object;
+    },
+
+    /**
+     * This method cannot throw.
+     * @param {*} object
+     * @param {string=} objectGroupName
+     * @param {boolean=} forceValueType
+     * @param {boolean=} generatePreview
+     * @param {?Array.<string>=} columnNames
+     * @param {boolean=} isTable
+     * @return {!RuntimeAgent.RemoteObject}
+     * @suppress {checkTypes}
+     */
+    _wrapObject: function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable)
+    {
+        try {
+            return new InjectedScript.RemoteObject(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable);
+        } catch (e) {
+            try {
+                var description = injectedScript._describe(e);
+            } catch (ex) {
+                var description = "<failed to convert exception to string>";
+            }
+            return new InjectedScript.RemoteObject(description);
+        }
+    },
+
+    /**
+     * @param {!Object|symbol} object
+     * @param {string=} objectGroupName
+     * @return {string}
+     */
+    _bind: function(object, objectGroupName)
+    {
+        var id = this._lastBoundObjectId++;
+        this._idToWrappedObject[id] = object;
+        var objectId = "{\"injectedScriptId\":" + injectedScriptId + ",\"id\":" + id + "}";
+        if (objectGroupName) {
+            var group = this._objectGroups[objectGroupName];
+            if (!group) {
+                group = [];
+                this._objectGroups[objectGroupName] = group;
+            }
+            push(group, id);
+            this._idToObjectGroupName[id] = objectGroupName;
+        }
+        return objectId;
+    },
+
+    /**
+     * @param {string} objectId
+     * @return {!Object}
+     */
+    _parseObjectId: function(objectId)
+    {
+        return nullifyObjectProto(InjectedScriptHost.eval("(" + objectId + ")"));
+    },
+
+    /**
+     * @param {string} objectGroupName
+     */
+    releaseObjectGroup: function(objectGroupName)
+    {
+        if (objectGroupName === "console")
+            delete this._lastResult;
+        var group = this._objectGroups[objectGroupName];
+        if (!group)
+            return;
+        for (var i = 0; i < group.length; i++)
+            this._releaseObject(group[i]);
+        delete this._objectGroups[objectGroupName];
+    },
+
+    /**
+     * @param {string} methodName
+     * @param {string} args
+     * @return {*}
+     */
+    dispatch: function(methodName, args)
+    {
+        var argsArray = InjectedScriptHost.eval("(" + args + ")");
+        var result = InjectedScriptHost.callFunction(this[methodName], this, argsArray);
+        if (typeof result === "undefined") {
+            inspectedWindow.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
+            result = null;
+        }
+        return result;
+    },
+
+    /**
+     * @param {string} objectId
+     * @param {boolean} ownProperties
+     * @param {boolean} accessorPropertiesOnly
+     * @return {!Array.<!RuntimeAgent.PropertyDescriptor>|boolean}
+     */
+    getProperties: function(objectId, ownProperties, accessorPropertiesOnly)
+    {
+        var parsedObjectId = this._parseObjectId(objectId);
+        var object = this._objectForId(parsedObjectId);
+        var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
+
+        if (!this._isDefined(object) || isSymbol(object))
+            return false;
+        object = /** @type {!Object} */ (object);
+        var descriptors = this._propertyDescriptors(object, ownProperties, accessorPropertiesOnly);
+
+        // Go over properties, wrap object values.
+        for (var i = 0; i < descriptors.length; ++i) {
+            var descriptor = descriptors[i];
+            if ("get" in descriptor)
+                descriptor.get = this._wrapObject(descriptor.get, objectGroupName);
+            if ("set" in descriptor)
+                descriptor.set = this._wrapObject(descriptor.set, objectGroupName);
+            if ("value" in descriptor)
+                descriptor.value = this._wrapObject(descriptor.value, objectGroupName);
+            if (!("configurable" in descriptor))
+                descriptor.configurable = false;
+            if (!("enumerable" in descriptor))
+                descriptor.enumerable = false;
+            if ("symbol" in descriptor)
+                descriptor.symbol = this._wrapObject(descriptor.symbol, objectGroupName);
+        }
+        return descriptors;
+    },
+
+    /**
+     * @param {string} objectId
+     * @return {!Array.<!Object>|boolean}
+     */
+    getInternalProperties: function(objectId)
+    {
+        var parsedObjectId = this._parseObjectId(objectId);
+        var object = this._objectForId(parsedObjectId);
+        var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
+        if (!this._isDefined(object) || isSymbol(object))
+            return false;
+        object = /** @type {!Object} */ (object);
+        var descriptors = [];
+        var internalProperties = InjectedScriptHost.getInternalProperties(object);
+        if (internalProperties) {
+            for (var i = 0; i < internalProperties.length; i++) {
+                var property = internalProperties[i];
+                var descriptor = {
+                    name: property.name,
+                    value: this._wrapObject(property.value, objectGroupName),
+                    __proto__: null
+                };
+                push(descriptors, descriptor);
+            }
+        }
+        return descriptors;
+    },
+
+    /**
+     * @param {string} functionId
+     * @return {!DebuggerAgent.FunctionDetails|string}
+     */
+    getFunctionDetails: function(functionId)
+    {
+        var parsedFunctionId = this._parseObjectId(functionId);
+        var func = this._objectForId(parsedFunctionId);
+        if (typeof func !== "function")
+            return "Cannot resolve function by id.";
+        var details = nullifyObjectProto(InjectedScriptHost.functionDetails(func));
+        if ("rawScopes" in details) {
+            var objectGroupName = this._idToObjectGroupName[parsedFunctionId.id];
+            var rawScopes = details.rawScopes;
+            delete details.rawScopes;
+            var scopes = [];
+            for (var i = 0; i < rawScopes.length; ++i)
+                scopes[i] = InjectedScript.CallFrameProxy._createScopeJson(rawScopes[i].type, rawScopes[i].object, objectGroupName);
+            details.scopeChain = scopes;
+        }
+        return details;
+    },
+
+    /**
+     * @param {string} objectId
+     * @return {!Array.<!Object>|string}
+     */
+    getCollectionEntries: function(objectId)
+    {
+        var parsedObjectId = this._parseObjectId(objectId);
+        var object = this._objectForId(parsedObjectId);
+        if (!object || typeof object !== "object")
+            return "Could not find object with given id";
+        var entries = InjectedScriptHost.collectionEntries(object);
+        if (!entries)
+            return "Object with given id is not a collection";
+        var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
+        for (var i = 0; i < entries.length; ++i) {
+            var entry = nullifyObjectProto(entries[i]);
+            if ("key" in entry)
+                entry.key = this._wrapObject(entry.key, objectGroupName);
+            entry.value = this._wrapObject(entry.value, objectGroupName);
+            entries[i] = entry;
+        }
+        return entries;
+    },
+
+    /**
+     * @param {string} objectId
+     */
+    releaseObject: function(objectId)
+    {
+        var parsedObjectId = this._parseObjectId(objectId);
+        this._releaseObject(parsedObjectId.id);
+    },
+
+    /**
+     * @param {number} id
+     */
+    _releaseObject: function(id)
+    {
+        delete this._idToWrappedObject[id];
+        delete this._idToObjectGroupName[id];
+    },
+
+    /**
+     * @param {!Object} object
+     * @param {boolean=} ownProperties
+     * @param {boolean=} accessorPropertiesOnly
+     * @return {!Array.<!Object>}
+     */
+    _propertyDescriptors: function(object, ownProperties, accessorPropertiesOnly)
+    {
+        var descriptors = [];
+        var propertyProcessed = { __proto__: null };
+
+        /**
+         * @param {?Object} o
+         * @param {!Array.<string|symbol>} properties
+         */
+        function process(o, properties)
+        {
+            for (var i = 0; i < properties.length; ++i) {
+                var property = properties[i];
+                if (propertyProcessed[property])
+                    continue;
+
+                var name = property;
+                if (isSymbol(property))
+                    name = injectedScript._describe(property);
+
+                try {
+                    propertyProcessed[property] = true;
+                    var descriptor = nullifyObjectProto(InjectedScriptHost.suppressWarningsAndCallFunction(Object.getOwnPropertyDescriptor, Object, [o, property]));
+                    if (descriptor) {
+                        if (accessorPropertiesOnly && !("get" in descriptor || "set" in descriptor))
+                            continue;
+                    } else {
+                        // Not all bindings provide proper descriptors. Fall back to the writable, configurable property.
+                        if (accessorPropertiesOnly)
+                            continue;
+                        try {
+                            descriptor = { name: name, value: o[property], writable: false, configurable: false, enumerable: false, __proto__: null };
+                            if (o === object)
+                                descriptor.isOwn = true;
+                            push(descriptors, descriptor);
+                        } catch (e) {
+                            // Silent catch.
+                        }
+                        continue;
+                    }
+                } catch (e) {
+                    if (accessorPropertiesOnly)
+                        continue;
+                    var descriptor = { __proto__: null };
+                    descriptor.value = e;
+                    descriptor.wasThrown = true;
+                }
+
+                descriptor.name = name;
+                if (o === object)
+                    descriptor.isOwn = true;
+                if (isSymbol(property))
+                    descriptor.symbol = property;
+                push(descriptors, descriptor);
+            }
+        }
+
+        for (var o = object; this._isDefined(o); o = o.__proto__) {
+            // First call Object.keys() to enforce ordering of the property descriptors.
+            process(o, Object.keys(/** @type {!Object} */ (o)));
+            process(o, Object.getOwnPropertyNames(/** @type {!Object} */ (o)));
+            if (Object.getOwnPropertySymbols)
+                process(o, Object.getOwnPropertySymbols(/** @type {!Object} */ (o)));
+
+            if (ownProperties) {
+                if (object.__proto__ && !accessorPropertiesOnly)
+                    push(descriptors, { name: "__proto__", value: object.__proto__, writable: true, configurable: true, enumerable: false, isOwn: true, __proto__: null });
+                break;
+            }
+        }
+
+        return descriptors;
+    },
+
+    /**
+     * @param {string} expression
+     * @param {string} objectGroup
+     * @param {boolean} injectCommandLineAPI
+     * @param {boolean} returnByValue
+     * @param {boolean} generatePreview
+     * @return {*}
+     */
+    evaluate: function(expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
+    {
+        return this._evaluateAndWrap(null, null, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview);
+    },
+
+    /**
+     * @param {string} objectId
+     * @param {string} expression
+     * @param {string} args
+     * @param {boolean} returnByValue
+     * @return {!Object|string}
+     */
+    callFunctionOn: function(objectId, expression, args, returnByValue)
+    {
+        var parsedObjectId = this._parseObjectId(objectId);
+        var object = this._objectForId(parsedObjectId);
+        if (!this._isDefined(object))
+            return "Could not find object with given id";
+
+        if (args) {
+            var resolvedArgs = [];
+            args = InjectedScriptHost.eval(args);
+            for (var i = 0; i < args.length; ++i) {
+                try {
+                    resolvedArgs[i] = this._resolveCallArgument(args[i]);
+                } catch (e) {
+                    return toString(e);
+                }
+            }
+        }
+
+        try {
+            var objectGroup = this._idToObjectGroupName[parsedObjectId.id];
+            var func = InjectedScriptHost.eval("(" + expression + ")");
+            if (typeof func !== "function")
+                return "Given expression does not evaluate to a function";
+
+            return { wasThrown: false,
+                     result: this._wrapObject(InjectedScriptHost.callFunction(func, object, resolvedArgs), objectGroup, returnByValue),
+                     __proto__: null };
+        } catch (e) {
+            return this._createThrownValue(e, objectGroup, false);
+        }
+    },
+
+    /**
+     * Resolves a value from CallArgument description.
+     * @param {!RuntimeAgent.CallArgument} callArgumentJson
+     * @return {*} resolved value
+     * @throws {string} error message
+     */
+    _resolveCallArgument: function(callArgumentJson)
+    {
+        callArgumentJson = nullifyObjectProto(callArgumentJson);
+        var objectId = callArgumentJson.objectId;
+        if (objectId) {
+            var parsedArgId = this._parseObjectId(objectId);
+            if (!parsedArgId || parsedArgId["injectedScriptId"] !== injectedScriptId)
+                throw "Arguments should belong to the same JavaScript world as the target object.";
+
+            var resolvedArg = this._objectForId(parsedArgId);
+            if (!this._isDefined(resolvedArg))
+                throw "Could not find object with given id";
+
+            return resolvedArg;
+        } else if ("value" in callArgumentJson) {
+            var value = callArgumentJson.value;
+            if (callArgumentJson.type === "number" && typeof value !== "number")
+                value = Number(value);
+            return value;
+        }
+        return undefined;
+    },
+
+    /**
+     * @param {?function(string):*} evalFunction
+     * @param {?Object} object
+     * @param {string} expression
+     * @param {string} objectGroup
+     * @param {boolean} isEvalOnCallFrame
+     * @param {boolean} injectCommandLineAPI
+     * @param {boolean} returnByValue
+     * @param {boolean} generatePreview
+     * @param {!Array.<!Object>=} scopeChain
+     * @return {!Object}
+     */
+    _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview, scopeChain)
+    {
+        var wrappedResult = this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain);
+        if (!wrappedResult.exceptionDetails) {
+            return { wasThrown: false,
+                     result: this._wrapObject(wrappedResult.result, objectGroup, returnByValue, generatePreview),
+                     __proto__: null };
+        }
+        return this._createThrownValue(wrappedResult.result, objectGroup, generatePreview, wrappedResult.exceptionDetails);
+    },
+
+    /**
+     * @param {*} value
+     * @param {string} objectGroup
+     * @param {boolean} generatePreview
+     * @param {!DebuggerAgent.ExceptionDetails=} exceptionDetails
+     * @return {!Object}
+     */
+    _createThrownValue: function(value, objectGroup, generatePreview, exceptionDetails)
+    {
+        var remoteObject = this._wrapObject(value, objectGroup, false, generatePreview && !(value instanceof Error));
+        if (!remoteObject.description){
+            try {
+                remoteObject.description = toStringDescription(value);
+            } catch (e) {}
+        }
+        return { wasThrown: true, result: remoteObject, exceptionDetails: exceptionDetails, __proto__: null };
+    },
+
+    /**
+     * @param {?function(string):*} evalFunction
+     * @param {?Object} object
+     * @param {string} objectGroup
+     * @param {string} expression
+     * @param {boolean} isEvalOnCallFrame
+     * @param {boolean} injectCommandLineAPI
+     * @param {!Array.<!Object>=} scopeChain
+     * @return {*}
+     */
+    _evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain)
+    {
+        // Only install command line api object for the time of evaluation.
+        // Surround the expression in with statements to inject our command line API so that
+        // the window object properties still take more precedent than our API functions.
+
+        injectCommandLineAPI = injectCommandLineAPI && !("__commandLineAPI" in inspectedWindow);
+        var injectScopeChain = scopeChain && scopeChain.length && !("__scopeChainForEval" in inspectedWindow);
+
+        try {
+            var prefix = "";
+            var suffix = "";
+            if (injectCommandLineAPI) {
+                inspectedWindow.__commandLineAPI = new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
+                prefix = "with (__commandLineAPI || { __proto__: null }) {";
+                suffix = "}";
+            }
+            if (injectScopeChain) {
+                inspectedWindow.__scopeChainForEval = scopeChain;
+                for (var i = 0; i < scopeChain.length; ++i) {
+                    prefix = "with (__scopeChainForEval[" + i + "] || { __proto__: null }) {" + (suffix ? " " : "") + prefix;
+                    if (suffix)
+                        suffix += " }";
+                    else
+                        suffix = "}";
+                }
+            }
+
+            if (prefix)
+                expression = prefix + "\n" + expression + "\n" + suffix;
+            var wrappedResult = evalFunction ? InjectedScriptHost.callFunction(evalFunction, object, [expression]) : InjectedScriptHost.evaluateWithExceptionDetails(expression);
+            if (objectGroup === "console" && !wrappedResult.exceptionDetails)
+                this._lastResult = wrappedResult.result;
+            return wrappedResult;
+        } finally {
+            if (injectCommandLineAPI)
+                delete inspectedWindow.__commandLineAPI;
+            if (injectScopeChain)
+                delete inspectedWindow.__scopeChainForEval;
+        }
+    },
+
+    /**
+     * @param {?Object} callFrame
+     * @param {number} asyncOrdinal
+     * @return {!Array.<!InjectedScript.CallFrameProxy>|boolean}
+     */
+    wrapCallFrames: function(callFrame, asyncOrdinal)
+    {
+        if (!callFrame)
+            return false;
+
+        var result = [];
+        var depth = 0;
+        do {
+            result[depth] = new InjectedScript.CallFrameProxy(depth, callFrame, asyncOrdinal);
+            callFrame = callFrame.caller;
+            ++depth;
+        } while (callFrame);
+        return result;
+    },
+
+    /**
+     * @param {!Object} topCallFrame
+     * @param {!Array.<!Object>} asyncCallStacks
+     * @param {string} callFrameId
+     * @param {string} expression
+     * @param {string} objectGroup
+     * @param {boolean} injectCommandLineAPI
+     * @param {boolean} returnByValue
+     * @param {boolean} generatePreview
+     * @return {*}
+     */
+    evaluateOnCallFrame: function(topCallFrame, asyncCallStacks, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
+    {
+        var parsedCallFrameId = nullifyObjectProto(InjectedScriptHost.eval("(" + callFrameId + ")"));
+        var callFrame = this._callFrameForParsedId(topCallFrame, parsedCallFrameId, asyncCallStacks);
+        if (!callFrame)
+            return "Could not find call frame with given id";
+        if (parsedCallFrameId["asyncOrdinal"])
+            return this._evaluateAndWrap(null, null, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview, callFrame.scopeChain);
+        return this._evaluateAndWrap(callFrame.evaluateWithExceptionDetails, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview);
+    },
+
+    /**
+     * @param {!Object} topCallFrame
+     * @param {string} callFrameId
+     * @return {*}
+     */
+    restartFrame: function(topCallFrame, callFrameId)
+    {
+        var callFrame = this._callFrameForId(topCallFrame, callFrameId);
+        if (!callFrame)
+            return "Could not find call frame with given id";
+        var result = callFrame.restart();
+        if (result === false)
+            result = "Restart frame is not supported";
+        return result;
+    },
+
+    /**
+     * @param {!Object} topCallFrame
+     * @param {string} callFrameId
+     * @return {*} a stepIn position array ready for protocol JSON or a string error
+     */
+    getStepInPositions: function(topCallFrame, callFrameId)
+    {
+        var callFrame = this._callFrameForId(topCallFrame, callFrameId);
+        if (!callFrame)
+            return "Could not find call frame with given id";
+        var stepInPositionsUnpacked = JSON.parse(callFrame.stepInPositions);
+        if (typeof stepInPositionsUnpacked !== "object")
+            return "Step in positions not available";
+        return stepInPositionsUnpacked;
+    },
+
+    /**
+     * Either callFrameId or functionObjectId must be specified.
+     * @param {!Object} topCallFrame
+     * @param {string|boolean} callFrameId or false
+     * @param {string|boolean} functionObjectId or false
+     * @param {number} scopeNumber
+     * @param {string} variableName
+     * @param {string} newValueJsonString RuntimeAgent.CallArgument structure serialized as string
+     * @return {string|undefined} undefined if success or an error message
+     */
+    setVariableValue: function(topCallFrame, callFrameId, functionObjectId, scopeNumber, variableName, newValueJsonString)
+    {
+        var setter;
+        if (typeof callFrameId === "string") {
+            var callFrame = this._callFrameForId(topCallFrame, callFrameId);
+            if (!callFrame)
+                return "Could not find call frame with given id";
+            setter = bind(callFrame.setVariableValue, callFrame);
+        } else {
+            var parsedFunctionId = this._parseObjectId(/** @type {string} */ (functionObjectId));
+            var func = this._objectForId(parsedFunctionId);
+            if (typeof func !== "function")
+                return "Cannot resolve function by id.";
+            setter = bind(InjectedScriptHost.setFunctionVariableValue, InjectedScriptHost, func);
+        }
+        var newValueJson;
+        try {
+            newValueJson = InjectedScriptHost.eval("(" + newValueJsonString + ")");
+        } catch (e) {
+            return "Failed to parse new value JSON " + newValueJsonString + " : " + e;
+        }
+        var resolvedValue;
+        try {
+            resolvedValue = this._resolveCallArgument(newValueJson);
+        } catch (e) {
+            return toString(e);
+        }
+        try {
+            setter(scopeNumber, variableName, resolvedValue);
+        } catch (e) {
+            return "Failed to change variable value: " + e;
+        }
+        return undefined;
+    },
+
+    /**
+     * @param {!Object} topCallFrame
+     * @param {string} callFrameId
+     * @return {?Object}
+     */
+    _callFrameForId: function(topCallFrame, callFrameId)
+    {
+        var parsedCallFrameId = nullifyObjectProto(InjectedScriptHost.eval("(" + callFrameId + ")"));
+        return this._callFrameForParsedId(topCallFrame, parsedCallFrameId, []);
+    },
+
+    /**
+     * @param {!Object} topCallFrame
+     * @param {!Object} parsedCallFrameId
+     * @param {!Array.<!Object>} asyncCallStacks
+     * @return {?Object}
+     */
+    _callFrameForParsedId: function(topCallFrame, parsedCallFrameId, asyncCallStacks)
+    {
+        var asyncOrdinal = parsedCallFrameId["asyncOrdinal"]; // 1-based index
+        if (asyncOrdinal)
+            topCallFrame = asyncCallStacks[asyncOrdinal - 1];
+        var ordinal = parsedCallFrameId["ordinal"];
+        var callFrame = topCallFrame;
+        while (--ordinal >= 0 && callFrame)
+            callFrame = callFrame.caller;
+        return callFrame;
+    },
+
+    /**
+     * @param {!Object} objectId
+     * @return {!Object|symbol}
+     */
+    _objectForId: function(objectId)
+    {
+        return this._idToWrappedObject[objectId.id];
+    },
+
+    /**
+     * @param {string} objectId
+     * @return {!Object|symbol}
+     */
+    findObjectById: function(objectId)
+    {
+        var parsedObjectId = this._parseObjectId(objectId);
+        return this._objectForId(parsedObjectId);
+    },
+
+    /**
+     * @param {string} objectId
+     * @return {?Node}
+     */
+    nodeForObjectId: function(objectId)
+    {
+        var object = this.findObjectById(objectId);
+        if (!object || this._subtype(object) !== "node")
+            return null;
+        return /** @type {!Node} */ (object);
+    },
+
+    /**
+     * @param {string} name
+     * @return {!Object}
+     */
+    module: function(name)
+    {
+        return this._modules[name];
+    },
+
+    /**
+     * @param {string} name
+     * @param {string} source
+     * @return {?Object}
+     */
+    injectModule: function(name, source)
+    {
+        delete this._modules[name];
+        var moduleFunction = InjectedScriptHost.eval("(" + source + ")");
+        if (typeof moduleFunction !== "function") {
+            inspectedWindow.console.error("Web Inspector error: A function was expected for module %s evaluation", name);
+            return null;
+        }
+        var module = InjectedScriptHost.callFunction(moduleFunction, inspectedWindow, [InjectedScriptHost, inspectedWindow, injectedScriptId, this]);
+        this._modules[name] = module;
+        return module;
+    },
+
+    /**
+     * @param {*} object
+     * @return {boolean}
+     */
+    _isDefined: function(object)
+    {
+        return !!object || this._isHTMLAllCollection(object);
+    },
+
+    /**
+     * @param {*} object
+     * @return {boolean}
+     */
+    _isHTMLAllCollection: function(object)
+    {
+        // document.all is reported as undefined, but we still want to process it.
+        return (typeof object === "undefined") && InjectedScriptHost.isHTMLAllCollection(object);
+    },
+
+    /**
+     * @param {*} obj
+     * @return {?string}
+     */
+    _subtype: function(obj)
+    {
+        if (obj === null)
+            return "null";
+
+        if (this.isPrimitiveValue(obj))
+            return null;
+
+        var subtype = InjectedScriptHost.subtype(obj);
+        if (subtype)
+            return subtype;
+
+        if (isArrayLike(obj))
+            return "array";
+
+        // If owning frame has navigated to somewhere else window properties will be undefined.
+        return null;
+    },
+
+    /**
+     * @param {*} obj
+     * @return {?string}
+     */
+    _describe: function(obj)
+    {
+        if (this.isPrimitiveValue(obj))
+            return null;
+
+        var subtype = this._subtype(obj);
+
+        if (subtype === "regexp")
+            return toString(obj);
+
+        if (subtype === "date")
+            return toString(obj);
+
+        if (subtype === "node") {
+            var description = obj.nodeName.toLowerCase();
+            switch (obj.nodeType) {
+            case 1 /* Node.ELEMENT_NODE */:
+                description += obj.id ? "#" + obj.id : "";
+                var className = obj.className;
+                description += (className && typeof className === "string") ? "." + className.trim().replace(/\s+/g, ".") : "";
+                break;
+            case 10 /*Node.DOCUMENT_TYPE_NODE */:
+                description = "<!DOCTYPE " + description + ">";
+                break;
+            }
+            return description;
+        }
+
+        var className = InjectedScriptHost.internalConstructorName(obj);
+        if (subtype === "array") {
+            if (typeof obj.length === "number")
+                className += "[" + obj.length + "]";
+            return className;
+        }
+
+        // NodeList in JSC is a function, check for array prior to this.
+        if (typeof obj === "function")
+            return toString(obj);
+
+        if (isSymbol(obj)) {
+            try {
+                return InjectedScriptHost.callFunction(Symbol.prototype.toString, obj) || "Symbol";
+            } catch (e) {
+                return "Symbol";
+            }
+        }
+
+        if (obj instanceof Error && !!obj.message)
+            return className + ": " + obj.message;
+
+        return className;
+    }
+}
+
+/**
+ * @type {!InjectedScript}
+ * @const
+ */
+var injectedScript = new InjectedScript();
+
+/**
+ * @constructor
+ * @param {*} object
+ * @param {string=} objectGroupName
+ * @param {boolean=} forceValueType
+ * @param {boolean=} generatePreview
+ * @param {?Array.<string>=} columnNames
+ * @param {boolean=} isTable
+ */
+InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable)
+{
+    this.type = typeof object;
+    if (injectedScript.isPrimitiveValue(object) || object === null || forceValueType) {
+        // We don't send undefined values over JSON.
+        if (this.type !== "undefined")
+            this.value = object;
+
+        // Null object is object with 'null' subtype.
+        if (object === null)
+            this.subtype = "null";
+
+        // Provide user-friendly number values.
+        if (this.type === "number") {
+            this.description = toStringDescription(object);
+            // Override "value" property for values that can not be JSON-stringified.
+            switch (this.description) {
+            case "NaN":
+            case "Infinity":
+            case "-Infinity":
+            case "-0":
+                this.value = this.description;
+                break;
+            }
+        }
+
+        return;
+    }
+
+    object = /** @type {!Object} */ (object);
+
+    this.objectId = injectedScript._bind(object, objectGroupName);
+    var subtype = injectedScript._subtype(object);
+    if (subtype)
+        this.subtype = subtype;
+    var className = InjectedScriptHost.internalConstructorName(object);
+    if (className)
+        this.className = className;
+    this.description = injectedScript._describe(object);
+
+    if (generatePreview && (this.type === "object" || injectedScript._isHTMLAllCollection(object)))
+        this.preview = this._generatePreview(object, undefined, columnNames, isTable);
+}
+
+InjectedScript.RemoteObject.prototype = {
+    /**
+     * @param {!Object} object
+     * @param {?Array.<string>=} firstLevelKeys
+     * @param {?Array.<string>=} secondLevelKeys
+     * @param {boolean=} isTable
+     * @return {!RuntimeAgent.ObjectPreview} preview
+     */
+    _generatePreview: function(object, firstLevelKeys, secondLevelKeys, isTable)
+    {
+        var preview = { __proto__: null };
+        preview.lossless = true;
+        preview.overflow = false;
+        preview.properties = [];
+
+        var firstLevelKeysCount = firstLevelKeys ? firstLevelKeys.length : 0;
+
+        var propertiesThreshold = {
+            properties: isTable ? 1000 : max(5, firstLevelKeysCount),
+            indexes: isTable ? 1000 : max(100, firstLevelKeysCount)
+        };
+
+        try {
+            var descriptors = injectedScript._propertyDescriptors(object);
+
+            if (firstLevelKeys) {
+                var nameToDescriptors = { __proto__: null };
+                for (var i = 0; i < descriptors.length; ++i) {
+                    var descriptor = descriptors[i];
+                    nameToDescriptors["#" + descriptor.name] = descriptor;
+                }
+                descriptors = [];
+                for (var i = 0; i < firstLevelKeys.length; ++i)
+                    descriptors[i] = nameToDescriptors["#" + firstLevelKeys[i]];
+            }
+
+            this._appendPropertyDescriptors(preview, descriptors, propertiesThreshold, secondLevelKeys, isTable);
+            if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
+                return preview;
+
+            // Add internal properties to preview.
+            var internalProperties = InjectedScriptHost.getInternalProperties(object) || [];
+            for (var i = 0; i < internalProperties.length; ++i) {
+                internalProperties[i] = nullifyObjectProto(internalProperties[i]);
+                internalProperties[i].enumerable = true;
+            }
+            this._appendPropertyDescriptors(preview, internalProperties, propertiesThreshold, secondLevelKeys, isTable);
+
+        } catch (e) {
+            preview.lossless = false;
+        }
+
+        return preview;
+    },
+
+    /**
+     * @param {!RuntimeAgent.ObjectPreview} preview
+     * @param {!Array.<!Object>} descriptors
+     * @param {!Object} propertiesThreshold
+     * @param {?Array.<string>=} secondLevelKeys
+     * @param {boolean=} isTable
+     */
+    _appendPropertyDescriptors: function(preview, descriptors, propertiesThreshold, secondLevelKeys, isTable)
+    {
+        for (var i = 0; i < descriptors.length; ++i) {
+            if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
+                break;
+
+            var descriptor = descriptors[i];
+            if (!descriptor)
+                continue;
+            if (descriptor.wasThrown) {
+                preview.lossless = false;
+                continue;
+            }
+            if (!descriptor.enumerable && !descriptor.isOwn)
+                continue;
+
+            var name = descriptor.name;
+            if (name === "__proto__")
+                continue;
+            if (this.subtype === "array" && name === "length")
+                continue;
+
+            if (!("value" in descriptor)) {
+                preview.lossless = false;
+                this._appendPropertyPreview(preview, { name: name, type: "accessor", __proto__: null }, propertiesThreshold);
+                continue;
+            }
+
+            var value = descriptor.value;
+            if (value === null) {
+                this._appendPropertyPreview(preview, { name: name, type: "object", subtype: "null", value: "null", __proto__: null }, propertiesThreshold);
+                continue;
+            }
+
+            var type = typeof value;
+            if (!descriptor.enumerable && type === "function")
+                continue;
+            if (type === "undefined" && injectedScript._isHTMLAllCollection(value))
+                type = "object";
+
+            var maxLength = 100;
+            if (InjectedScript.primitiveTypes[type]) {
+                if (type === "string" && value.length > maxLength) {
+                    value = this._abbreviateString(value, maxLength, true);
+                    preview.lossless = false;
+                }
+                this._appendPropertyPreview(preview, { name: name, type: type, value: toStringDescription(value), __proto__: null }, propertiesThreshold);
+                continue;
+            }
+
+            var property = { name: name, type: type, __proto__: null };
+            var subtype = injectedScript._subtype(value);
+            if (subtype)
+                property.subtype = subtype;
+
+            if (secondLevelKeys === null || secondLevelKeys) {
+                var subPreview = this._generatePreview(value, secondLevelKeys || undefined, undefined, isTable);
+                property.valuePreview = subPreview;
+                if (!subPreview.lossless)
+                    preview.lossless = false;
+                if (subPreview.overflow)
+                    preview.overflow = true;
+            } else {
+                var description = "";
+                if (type !== "function")
+                    description = this._abbreviateString(/** @type {string} */ (injectedScript._describe(value)), maxLength, subtype === "regexp");
+                property.value = description;
+                preview.lossless = false;
+            }
+            this._appendPropertyPreview(preview, property, propertiesThreshold);
+        }
+    },
+
+    /**
+     * @param {!RuntimeAgent.ObjectPreview} preview
+     * @param {!Object} property
+     * @param {!Object} propertiesThreshold
+     */
+    _appendPropertyPreview: function(preview, property, propertiesThreshold)
+    {
+        if (toString(property.name >>> 0) === property.name)
+            propertiesThreshold.indexes--;
+        else
+            propertiesThreshold.properties--;
+        if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0) {
+            preview.overflow = true;
+            preview.lossless = false;
+        } else {
+            push(preview.properties, property);
+        }
+    },
+
+    /**
+     * @param {string} string
+     * @param {number} maxLength
+     * @param {boolean=} middle
+     * @return {string}
+     */
+    _abbreviateString: function(string, maxLength, middle)
+    {
+        if (string.length <= maxLength)
+            return string;
+        if (middle) {
+            var leftHalf = maxLength >> 1;
+            var rightHalf = maxLength - leftHalf - 1;
+            return string.substr(0, leftHalf) + "\u2026" + string.substr(string.length - rightHalf, rightHalf);
+        }
+        return string.substr(0, maxLength) + "\u2026";
+    },
+
+    __proto__: null
+}
+/**
+ * @constructor
+ * @param {number} ordinal
+ * @param {!Object} callFrame
+ * @param {number} asyncOrdinal
+ */
+InjectedScript.CallFrameProxy = function(ordinal, callFrame, asyncOrdinal)
+{
+    this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + (asyncOrdinal ? ",\"asyncOrdinal\":" + asyncOrdinal : "") + "}";
+    this.functionName = (callFrame.type === "function" ? callFrame.functionName : "");
+    this.location = { scriptId: toString(callFrame.sourceID), lineNumber: callFrame.line, columnNumber: callFrame.column, __proto__: null };
+    this.scopeChain = this._wrapScopeChain(callFrame);
+    this.this = injectedScript._wrapObject(callFrame.thisObject, "backtrace");
+    if (callFrame.isAtReturn)
+        this.returnValue = injectedScript._wrapObject(callFrame.returnValue, "backtrace");
+}
+
+InjectedScript.CallFrameProxy.prototype = {
+    /**
+     * @param {!Object} callFrame
+     * @return {!Array.<!DebuggerAgent.Scope>}
+     */
+    _wrapScopeChain: function(callFrame)
+    {
+        var scopeChain = callFrame.scopeChain;
+        var scopeChainProxy = [];
+        for (var i = 0; i < scopeChain.length; ++i)
+            scopeChainProxy[i] = InjectedScript.CallFrameProxy._createScopeJson(callFrame.scopeType(i), scopeChain[i], "backtrace");
+        return scopeChainProxy;
+    },
+
+    __proto__: null
+}
+
+/**
+ * @param {number} scopeTypeCode
+ * @param {*} scopeObject
+ * @param {string} groupId
+ * @return {!DebuggerAgent.Scope}
+ */
+InjectedScript.CallFrameProxy._createScopeJson = function(scopeTypeCode, scopeObject, groupId)
+{
+    var GLOBAL_SCOPE = 0;
+    var LOCAL_SCOPE = 1;
+    var WITH_SCOPE = 2;
+    var CLOSURE_SCOPE = 3;
+    var CATCH_SCOPE = 4;
+
+    /** @type {!Object.<number, string>} */
+    var scopeTypeNames = { __proto__: null };
+    scopeTypeNames[GLOBAL_SCOPE] = "global";
+    scopeTypeNames[LOCAL_SCOPE] = "local";
+    scopeTypeNames[WITH_SCOPE] = "with";
+    scopeTypeNames[CLOSURE_SCOPE] = "closure";
+    scopeTypeNames[CATCH_SCOPE] = "catch";
+
+    return {
+        object: injectedScript._wrapObject(scopeObject, groupId),
+        type: /** @type {!DebuggerAgent.ScopeType} */ (scopeTypeNames[scopeTypeCode]),
+        __proto__: null
+    };
+}
+
+/**
+ * @constructor
+ * @param {!CommandLineAPIImpl} commandLineAPIImpl
+ * @param {?Object} callFrame
+ */
+function CommandLineAPI(commandLineAPIImpl, callFrame)
+{
+    /**
+     * @param {string} member
+     * @return {boolean}
+     */
+    function inScopeVariables(member)
+    {
+        if (!callFrame)
+            return false;
+
+        var scopeChain = callFrame.scopeChain;
+        for (var i = 0; i < scopeChain.length; ++i) {
+            if (member in scopeChain[i])
+                return true;
+        }
+        return false;
+    }
+
+    /**
+     * @param {string} name The name of the method for which a toString method should be generated.
+     * @return {function():string}
+     */
+    function customToStringMethod(name)
+    {
+        return function()
+        {
+            var funcArgsSyntax = "";
+            try {
+                var funcSyntax = "" + commandLineAPIImpl[name];
+                funcSyntax = funcSyntax.replace(/\n/g, " ");
+                funcSyntax = funcSyntax.replace(/^function[^\(]*\(([^\)]*)\).*$/, "$1");
+                funcSyntax = funcSyntax.replace(/\s*,\s*/g, ", ");
+                funcSyntax = funcSyntax.replace(/\bopt_(\w+)\b/g, "[$1]");
+                funcArgsSyntax = funcSyntax.trim();
+            } catch (e) {
+            }
+            return "function " + name + "(" + funcArgsSyntax + ") { [Command Line API] }";
+        };
+    }
+
+    for (var i = 0; i < CommandLineAPI.members_.length; ++i) {
+        var member = CommandLineAPI.members_[i];
+        if (member in inspectedWindow || inScopeVariables(member))
+            continue;
+
+        this[member] = bind(commandLineAPIImpl[member], commandLineAPIImpl);
+        this[member].toString = customToStringMethod(member);
+    }
+
+    for (var i = 0; i < 5; ++i) {
+        var member = "$" + i;
+        if (member in inspectedWindow || inScopeVariables(member))
+            continue;
+
+        this.__defineGetter__("$" + i, bind(commandLineAPIImpl._inspectedObject, commandLineAPIImpl, i));
+    }
+
+    this.$_ = injectedScript._lastResult;
+
+    this.__proto__ = null;
+}
+
+// NOTE: Please keep the list of API methods below snchronized to that in WebInspector.RuntimeModel!
+// NOTE: Argument names of these methods will be printed in the console, so use pretty names!
+/**
+ * @type {!Array.<string>}
+ * @const
+ */
+CommandLineAPI.members_ = [
+    "$", "$$", "$x", "dir", "dirxml", "keys", "values", "profile", "profileEnd",
+    "monitorEvents", "unmonitorEvents", "inspect", "copy", "clear", "getEventListeners",
+    "debug", "undebug", "monitor", "unmonitor", "table"
+];
+
+/**
+ * @constructor
+ */
+function CommandLineAPIImpl()
+{
+}
+
+CommandLineAPIImpl.prototype = {
+    /**
+     * @param {string} selector
+     * @param {!Node=} opt_startNode
+     * @return {*}
+     */
+    $: function (selector, opt_startNode)
+    {
+        if (this._canQuerySelectorOnNode(opt_startNode))
+            return opt_startNode.querySelector(selector);
+
+        return inspectedWindow.document.querySelector(selector);
+    },
+
+    /**
+     * @param {string} selector
+     * @param {!Node=} opt_startNode
+     * @return {*}
+     */
+    $$: function (selector, opt_startNode)
+    {
+        if (this._canQuerySelectorOnNode(opt_startNode))
+            return opt_startNode.querySelectorAll(selector);
+        return inspectedWindow.document.querySelectorAll(selector);
+    },
+
+    /**
+     * @param {!Node=} node
+     * @return {boolean}
+     */
+    _canQuerySelectorOnNode: function(node)
+    {
+        return !!node && InjectedScriptHost.subtype(node) === "node" && (node.nodeType === Node.ELEMENT_NODE || node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE);
+    },
+
+    /**
+     * @param {string} xpath
+     * @param {!Node=} opt_startNode
+     * @return {*}
+     */
+    $x: function(xpath, opt_startNode)
+    {
+        var doc = (opt_startNode && opt_startNode.ownerDocument) || inspectedWindow.document;
+        var result = doc.evaluate(xpath, opt_startNode || doc, null, XPathResult.ANY_TYPE, null);
+        switch (result.resultType) {
+        case XPathResult.NUMBER_TYPE:
+            return result.numberValue;
+        case XPathResult.STRING_TYPE:
+            return result.stringValue;
+        case XPathResult.BOOLEAN_TYPE:
+            return result.booleanValue;
+        default:
+            var nodes = [];
+            var node;
+            while (node = result.iterateNext())
+                push(nodes, node);
+            return nodes;
+        }
+    },
+
+    /**
+     * @return {*}
+     */
+    dir: function(var_args)
+    {
+        return InjectedScriptHost.callFunction(inspectedWindow.console.dir, inspectedWindow.console, slice(arguments));
+    },
+
+    /**
+     * @return {*}
+     */
+    dirxml: function(var_args)
+    {
+        return InjectedScriptHost.callFunction(inspectedWindow.console.dirxml, inspectedWindow.console, slice(arguments));
+    },
+
+    /**
+     * @return {!Array.<string>}
+     */
+    keys: function(object)
+    {
+        return Object.keys(object);
+    },
+
+    /**
+     * @return {!Array.<*>}
+     */
+    values: function(object)
+    {
+        var result = [];
+        for (var key in object)
+            push(result, object[key]);
+        return result;
+    },
+
+    /**
+     * @return {*}
+     */
+    profile: function(opt_title)
+    {
+        return InjectedScriptHost.callFunction(inspectedWindow.console.profile, inspectedWindow.console, slice(arguments));
+    },
+
+    /**
+     * @return {*}
+     */
+    profileEnd: function(opt_title)
+    {
+        return InjectedScriptHost.callFunction(inspectedWindow.console.profileEnd, inspectedWindow.console, slice(arguments));
+    },
+
+    /**
+     * @param {!Object} object
+     * @param {!Array.<string>|string=} opt_types
+     */
+    monitorEvents: function(object, opt_types)
+    {
+        if (!object || !object.addEventListener || !object.removeEventListener)
+            return;
+        var types = this._normalizeEventTypes(opt_types);
+        for (var i = 0; i < types.length; ++i) {
+            object.removeEventListener(types[i], this._logEvent, false);
+            object.addEventListener(types[i], this._logEvent, false);
+        }
+    },
+
+    /**
+     * @param {!Object} object
+     * @param {!Array.<string>|string=} opt_types
+     */
+    unmonitorEvents: function(object, opt_types)
+    {
+        if (!object || !object.addEventListener || !object.removeEventListener)
+            return;
+        var types = this._normalizeEventTypes(opt_types);
+        for (var i = 0; i < types.length; ++i)
+            object.removeEventListener(types[i], this._logEvent, false);
+    },
+
+    /**
+     * @param {*} object
+     * @return {*}
+     */
+    inspect: function(object)
+    {
+        return injectedScript._inspect(object);
+    },
+
+    copy: function(object)
+    {
+        var string;
+        if (injectedScript._subtype(object) === "node") {
+            string = object.outerHTML;
+        } else if (injectedScript.isPrimitiveValue(object)) {
+            string = toString(object);
+        } else {
+            try {
+                string = JSON.stringify(object, null, "  ");
+            } catch (e) {
+                string = toString(object);
+            }
+        }
+
+        var hints = { copyToClipboard: true, __proto__: null };
+        var remoteObject = injectedScript._wrapObject(string, "")
+        InjectedScriptHost.inspect(remoteObject, hints);
+    },
+
+    clear: function()
+    {
+        InjectedScriptHost.clearConsoleMessages();
+    },
+
+    /**
+     * @param {!Node} node
+     * @return {!{type: string, listener: function(), useCapture: boolean, remove: function()}|undefined}
+     */
+    getEventListeners: function(node)
+    {
+        var result = nullifyObjectProto(InjectedScriptHost.getEventListeners(node));
+        if (!result)
+            return result;
+        /** @this {{type: string, listener: function(), useCapture: boolean}} */
+        var removeFunc = function()
+        {
+            node.removeEventListener(this.type, this.listener, this.useCapture);
+        }
+        for (var type in result) {
+            var listeners = result[type];
+            for (var i = 0, listener; listener = listeners[i]; ++i) {
+                listener["type"] = type;
+                listener["remove"] = removeFunc;
+            }
+        }
+        return result;
+    },
+
+    debug: function(fn)
+    {
+        InjectedScriptHost.debugFunction(fn);
+    },
+
+    undebug: function(fn)
+    {
+        InjectedScriptHost.undebugFunction(fn);
+    },
+
+    monitor: function(fn)
+    {
+        InjectedScriptHost.monitorFunction(fn);
+    },
+
+    unmonitor: function(fn)
+    {
+        InjectedScriptHost.unmonitorFunction(fn);
+    },
+
+    table: function(data, opt_columns)
+    {
+        InjectedScriptHost.callFunction(inspectedWindow.console.table, inspectedWindow.console, slice(arguments));
+    },
+
+    /**
+     * @param {number} num
+     */
+    _inspectedObject: function(num)
+    {
+        return InjectedScriptHost.inspectedObject(num);
+    },
+
+    /**
+     * @param {!Array.<string>|string=} types
+     * @return {!Array.<string>}
+     */
+    _normalizeEventTypes: function(types)
+    {
+        if (typeof types === "undefined")
+            types = ["mouse", "key", "touch", "control", "load", "unload", "abort", "error", "select", "change", "submit", "reset", "focus", "blur", "resize", "scroll", "search", "devicemotion", "deviceorientation"];
+        else if (typeof types === "string")
+            types = [types];
+
+        var result = [];
+        for (var i = 0; i < types.length; ++i) {
+            if (types[i] === "mouse")
+                push(result, "mousedown", "mouseup", "click", "dblclick", "mousemove", "mouseover", "mouseout", "mousewheel");
+            else if (types[i] === "key")
+                push(result, "keydown", "keyup", "keypress", "textInput");
+            else if (types[i] === "touch")
+                push(result, "touchstart", "touchmove", "touchend", "touchcancel");
+            else if (types[i] === "control")
+                push(result, "resize", "scroll", "zoom", "focus", "blur", "select", "change", "submit", "reset");
+            else
+                push(result, types[i]);
+        }
+        return result;
+    },
+
+    /**
+     * @param {!Event} event
+     */
+    _logEvent: function(event)
+    {
+        inspectedWindow.console.log(event.type, event);
+    }
+}
+
+injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
+return injectedScript;
+})
diff --git a/engine/core/inspector/InspectorBaseAgent.cpp b/engine/core/inspector/InspectorBaseAgent.cpp
new file mode 100644
index 00000000000..86a3f66abc3
--- /dev/null
+++ b/engine/core/inspector/InspectorBaseAgent.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "core/inspector/InspectorBaseAgent.h"
+
+#include "core/inspector/InspectorState.h"
+#include "wtf/PassOwnPtr.h"
+
+namespace blink {
+
+InspectorAgent::InspectorAgent(const String& name)
+    : m_name(name)
+{
+}
+
+InspectorAgent::~InspectorAgent()
+{
+}
+
+void InspectorAgent::init(InstrumentingAgents* agents,
+    InspectorState* inspectorState)
+{
+    m_instrumentingAgents = agents;
+    m_state = inspectorState;
+    virtualInit();
+}
+
+} // namespace blink
+
diff --git a/engine/core/inspector/InspectorBaseAgent.h b/engine/core/inspector/InspectorBaseAgent.h
new file mode 100644
index 00000000000..208c10508d6
--- /dev/null
+++ b/engine/core/inspector/InspectorBaseAgent.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+#ifndef InspectorBaseAgent_h
+#define InspectorBaseAgent_h
+
+#include "core/InspectorBackendDispatcher.h"
+#include "platform/heap/Handle.h"
+#include "wtf/Forward.h"
+#include "wtf/Vector.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+class InspectorFrontend;
+class InspectorCompositeState;
+class InspectorState;
+class InstrumentingAgents;
+
+class InspectorAgent {
+public:
+    explicit InspectorAgent(const String&);
+    virtual ~InspectorAgent();
+
+    void init(InstrumentingAgents* agents, InspectorState* inspectorState);
+
+    virtual void setFrontend(InspectorFrontend*) { }
+    virtual void clearFrontend() { }
+    virtual void restore() { }
+    virtual void discardAgent() { }
+    virtual void didCommitLoadForMainFrame() { }
+    virtual void flushPendingFrontendMessages() { }
+
+private:
+    virtual void virtualInit() { }
+
+    String name() { return m_name; }
+
+protected:
+    RawPtr<InstrumentingAgents> m_instrumentingAgents;
+    RawPtr<InspectorState> m_state;
+
+private:
+    String m_name;
+};
+
+template<typename T>
+class InspectorBaseAgent : public InspectorAgent {
+public:
+    virtual ~InspectorBaseAgent() { }
+
+protected:
+    explicit InspectorBaseAgent(const String& name) : InspectorAgent(name)
+    {
+    }
+};
+
+inline bool asBool(const bool* const b)
+{
+    return b ? *b : false;
+}
+
+} // namespace blink
+
+#endif // !defined(InspectorBaseAgent_h)
diff --git a/engine/core/inspector/InspectorDebuggerAgent.cpp b/engine/core/inspector/InspectorDebuggerAgent.cpp
new file mode 100644
index 00000000000..9bb1413e241
--- /dev/null
+++ b/engine/core/inspector/InspectorDebuggerAgent.cpp
@@ -0,0 +1,1451 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "core/inspector/InspectorDebuggerAgent.h"
+
+#include "bindings/core/v8/ScriptDebugServer.h"
+#include "bindings/core/v8/ScriptRegexp.h"
+#include "bindings/core/v8/ScriptSourceCode.h"
+#include "bindings/core/v8/ScriptValue.h"
+#include "core/dom/Document.h"
+#include "core/fetch/Resource.h"
+#include "core/inspector/ConsoleMessage.h"
+#include "core/inspector/ContentSearchUtils.h"
+#include "core/inspector/InjectedScriptManager.h"
+#include "core/inspector/InspectorState.h"
+#include "core/inspector/JavaScriptCallFrame.h"
+#include "core/inspector/ScriptArguments.h"
+#include "core/inspector/ScriptAsyncCallStack.h"
+#include "core/inspector/ScriptCallFrame.h"
+#include "core/inspector/ScriptCallStack.h"
+#include "platform/JSONValues.h"
+#include "wtf/text/StringBuilder.h"
+#include "wtf/text/WTFString.h"
+
+using blink::TypeBuilder::Array;
+using blink::TypeBuilder::Debugger::BreakpointId;
+using blink::TypeBuilder::Debugger::CallFrame;
+using blink::TypeBuilder::Debugger::CollectionEntry;
+using blink::TypeBuilder::Debugger::ExceptionDetails;
+using blink::TypeBuilder::Debugger::FunctionDetails;
+using blink::TypeBuilder::Debugger::ScriptId;
+using blink::TypeBuilder::Debugger::StackTrace;
+using blink::TypeBuilder::Runtime::RemoteObject;
+
+namespace {
+
+static const char v8AsyncTaskEventEnqueue[] = "enqueue";
+static const char v8AsyncTaskEventWillHandle[] = "willHandle";
+static const char v8AsyncTaskEventDidHandle[] = "didHandle";
+
+}
+
+namespace blink {
+
+namespace DebuggerAgentState {
+static const char debuggerEnabled[] = "debuggerEnabled";
+static const char javaScriptBreakpoints[] = "javaScriptBreakopints";
+static const char pauseOnExceptionsState[] = "pauseOnExceptionsState";
+static const char asyncCallStackDepth[] = "asyncCallStackDepth";
+
+// Breakpoint properties.
+static const char url[] = "url";
+static const char isRegex[] = "isRegex";
+static const char lineNumber[] = "lineNumber";
+static const char columnNumber[] = "columnNumber";
+static const char condition[] = "condition";
+static const char isAnti[] = "isAnti";
+static const char skipStackPattern[] = "skipStackPattern";
+static const char skipAllPauses[] = "skipAllPauses";
+static const char skipAllPausesExpiresOnReload[] = "skipAllPausesExpiresOnReload";
+
+};
+
+static const int maxSkipStepInCount = 20;
+
+const char InspectorDebuggerAgent::backtraceObjectGroup[] = "backtrace";
+
+static String breakpointIdSuffix(InspectorDebuggerAgent::BreakpointSource source)
+{
+    switch (source) {
+    case InspectorDebuggerAgent::UserBreakpointSource:
+        break;
+    case InspectorDebuggerAgent::DebugCommandBreakpointSource:
+        return ":debug";
+    case InspectorDebuggerAgent::MonitorCommandBreakpointSource:
+        return ":monitor";
+    }
+    return String();
+}
+
+static String generateBreakpointId(const String& scriptId, int lineNumber, int columnNumber, InspectorDebuggerAgent::BreakpointSource source)
+{
+    return scriptId + ':' + String::number(lineNumber) + ':' + String::number(columnNumber) + breakpointIdSuffix(source);
+}
+
+InspectorDebuggerAgent::InspectorDebuggerAgent(InjectedScriptManager* injectedScriptManager)
+    : InspectorBaseAgent<InspectorDebuggerAgent>("Debugger")
+    , m_injectedScriptManager(injectedScriptManager)
+    , m_frontend(0)
+    , m_pausedScriptState(nullptr)
+    , m_javaScriptPauseScheduled(false)
+    , m_debuggerStepScheduled(false)
+    , m_steppingFromFramework(false)
+    , m_pausingOnNativeEvent(false)
+    , m_listener(nullptr)
+    , m_skippedStepInCount(0)
+    , m_skipAllPauses(false)
+    , m_asyncCallStackTracker(adoptPtr(new AsyncCallStackTracker()))
+{
+}
+
+InspectorDebuggerAgent::~InspectorDebuggerAgent()
+{
+}
+
+void InspectorDebuggerAgent::virtualInit()
+{
+    // FIXME: make breakReason optional so that there was no need to init it with "other".
+    clearBreakDetails();
+    m_state->setLong(DebuggerAgentState::pauseOnExceptionsState, ScriptDebugServer::DontPauseOnExceptions);
+}
+
+void InspectorDebuggerAgent::enable()
+{
+    startListeningScriptDebugServer();
+    // FIXME(WK44513): breakpoints activated flag should be synchronized between all front-ends
+    scriptDebugServer().setBreakpointsActivated(true);
+
+    if (m_listener)
+        m_listener->debuggerWasEnabled();
+}
+
+void InspectorDebuggerAgent::disable()
+{
+    m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, JSONObject::create());
+    m_state->setLong(DebuggerAgentState::pauseOnExceptionsState, ScriptDebugServer::DontPauseOnExceptions);
+    m_state->setString(DebuggerAgentState::skipStackPattern, "");
+    m_state->setLong(DebuggerAgentState::asyncCallStackDepth, 0);
+
+    scriptDebugServer().clearBreakpoints();
+    scriptDebugServer().clearCompiledScripts();
+    scriptDebugServer().clearPreprocessor();
+    stopListeningScriptDebugServer();
+    clear();
+
+    if (m_listener)
+        m_listener->debuggerWasDisabled();
+
+    m_skipAllPauses = false;
+}
+
+bool InspectorDebuggerAgent::enabled()
+{
+    return m_state->getBoolean(DebuggerAgentState::debuggerEnabled);
+}
+
+void InspectorDebuggerAgent::enable(ErrorString*)
+{
+    if (enabled())
+        return;
+
+    enable();
+    m_state->setBoolean(DebuggerAgentState::debuggerEnabled, true);
+
+    ASSERT(m_frontend);
+}
+
+void InspectorDebuggerAgent::disable(ErrorString*)
+{
+    if (!enabled())
+        return;
+
+    disable();
+    m_state->setBoolean(DebuggerAgentState::debuggerEnabled, false);
+}
+
+static PassOwnPtr<ScriptRegexp> compileSkipCallFramePattern(String patternText)
+{
+    if (patternText.isEmpty())
+        return nullptr;
+    OwnPtr<ScriptRegexp> result = adoptPtr(new ScriptRegexp(patternText, TextCaseSensitive));
+    if (!result->isValid())
+        result.clear();
+    return result.release();
+}
+
+void InspectorDebuggerAgent::restore()
+{
+    if (enabled()) {
+        m_frontend->globalObjectCleared();
+        enable();
+        long pauseState = m_state->getLong(DebuggerAgentState::pauseOnExceptionsState);
+        String error;
+        setPauseOnExceptionsImpl(&error, pauseState);
+        m_cachedSkipStackRegExp = compileSkipCallFramePattern(m_state->getString(DebuggerAgentState::skipStackPattern));
+        m_skipAllPauses = m_state->getBoolean(DebuggerAgentState::skipAllPauses);
+        if (m_skipAllPauses && m_state->getBoolean(DebuggerAgentState::skipAllPausesExpiresOnReload)) {
+            m_skipAllPauses = false;
+            m_state->setBoolean(DebuggerAgentState::skipAllPauses, false);
+        }
+        asyncCallStackTracker().setAsyncCallStackDepth(m_state->getLong(DebuggerAgentState::asyncCallStackDepth));
+    }
+}
+
+void InspectorDebuggerAgent::setFrontend(InspectorFrontend* frontend)
+{
+    m_frontend = frontend->debugger();
+}
+
+void InspectorDebuggerAgent::clearFrontend()
+{
+    m_frontend = 0;
+
+    if (!enabled())
+        return;
+
+    disable();
+
+    // FIXME: due to m_state->mute() hack in InspectorController, debuggerEnabled is actually set to false only
+    // in InspectorState, but not in cookie. That's why after navigation debuggerEnabled will be true,
+    // but after front-end re-open it will still be false.
+    m_state->setBoolean(DebuggerAgentState::debuggerEnabled, false);
+}
+
+void InspectorDebuggerAgent::setBreakpointsActive(ErrorString*, bool active)
+{
+    scriptDebugServer().setBreakpointsActivated(active);
+}
+
+void InspectorDebuggerAgent::setSkipAllPauses(ErrorString*, bool skipped, const bool* untilReload)
+{
+    m_skipAllPauses = skipped;
+    m_state->setBoolean(DebuggerAgentState::skipAllPauses, m_skipAllPauses);
+    m_state->setBoolean(DebuggerAgentState::skipAllPausesExpiresOnReload, asBool(untilReload));
+}
+
+void InspectorDebuggerAgent::pageDidCommitLoad()
+{
+    if (m_state->getBoolean(DebuggerAgentState::skipAllPausesExpiresOnReload)) {
+        m_skipAllPauses = false;
+        m_state->setBoolean(DebuggerAgentState::skipAllPauses, m_skipAllPauses);
+    }
+}
+
+bool InspectorDebuggerAgent::isPaused()
+{
+    return scriptDebugServer().isPaused();
+}
+
+bool InspectorDebuggerAgent::runningNestedMessageLoop()
+{
+    return scriptDebugServer().runningNestedMessageLoop();
+}
+
+void InspectorDebuggerAgent::addMessageToConsole(ConsoleMessage* consoleMessage)
+{
+    if (consoleMessage->type() == AssertMessageType && scriptDebugServer().pauseOnExceptionsState() != ScriptDebugServer::DontPauseOnExceptions)
+        breakProgram(InspectorFrontend::Debugger::Reason::Assert, nullptr);
+}
+
+String InspectorDebuggerAgent::preprocessEventListener(LocalFrame* frame, const String& source, const String& url, const String& functionName)
+{
+    return scriptDebugServer().preprocessEventListener(frame, source, url, functionName);
+}
+
+PassOwnPtr<ScriptSourceCode> InspectorDebuggerAgent::preprocess(LocalFrame* frame, const ScriptSourceCode& sourceCode)
+{
+    return scriptDebugServer().preprocess(frame, sourceCode);
+}
+
+static PassRefPtr<JSONObject> buildObjectForBreakpointCookie(const String& url, int lineNumber, int columnNumber, const String& condition, bool isRegex, bool isAnti)
+{
+    RefPtr<JSONObject> breakpointObject = JSONObject::create();
+    breakpointObject->setString(DebuggerAgentState::url, url);
+    breakpointObject->setNumber(DebuggerAgentState::lineNumber, lineNumber);
+    breakpointObject->setNumber(DebuggerAgentState::columnNumber, columnNumber);
+    breakpointObject->setString(DebuggerAgentState::condition, condition);
+    breakpointObject->setBoolean(DebuggerAgentState::isRegex, isRegex);
+    breakpointObject->setBoolean(DebuggerAgentState::isAnti, isAnti);
+    return breakpointObject;
+}
+
+static String scriptSourceURL(const ScriptDebugListener::Script& script)
+{
+    bool hasSourceURL = !script.sourceURL.isEmpty();
+    return hasSourceURL ? script.sourceURL : script.url;
+}
+
+static bool matches(const String& url, const String& pattern, bool isRegex)
+{
+    if (isRegex) {
+        ScriptRegexp regex(pattern, TextCaseSensitive);
+        return regex.match(url) != -1;
+    }
+    return url == pattern;
+}
+
+void InspectorDebuggerAgent::setBreakpointByUrl(ErrorString* errorString, int lineNumber, const String* const optionalURL, const String* const optionalURLRegex, const int* const optionalColumnNumber, const String* const optionalCondition, const bool* isAntiBreakpoint, BreakpointId* outBreakpointId, RefPtr<Array<TypeBuilder::Debugger::Location> >& locations)
+{
+    locations = Array<TypeBuilder::Debugger::Location>::create();
+    if (!optionalURL == !optionalURLRegex) {
+        *errorString = "Either url or urlRegex must be specified.";
+        return;
+    }
+
+    bool isAntiBreakpointValue = asBool(isAntiBreakpoint);
+
+    String url = optionalURL ? *optionalURL : *optionalURLRegex;
+    int columnNumber;
+    if (optionalColumnNumber) {
+        columnNumber = *optionalColumnNumber;
+        if (columnNumber < 0) {
+            *errorString = "Incorrect column number";
+            return;
+        }
+    } else {
+        columnNumber = isAntiBreakpointValue ? -1 : 0;
+    }
+    String condition = optionalCondition ? *optionalCondition : "";
+    bool isRegex = optionalURLRegex;
+
+    String breakpointId = (isRegex ? "/" + url + "/" : url) + ':' + String::number(lineNumber) + ':' + String::number(columnNumber);
+    RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
+    if (breakpointsCookie->find(breakpointId) != breakpointsCookie->end()) {
+        *errorString = "Breakpoint at specified location already exists.";
+        return;
+    }
+
+    breakpointsCookie->setObject(breakpointId, buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition, isRegex, isAntiBreakpointValue));
+    m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie);
+
+    if (!isAntiBreakpointValue) {
+        ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
+        for (ScriptsMap::iterator it = m_scripts.begin(); it != m_scripts.end(); ++it) {
+            if (!matches(scriptSourceURL(it->value), url, isRegex))
+                continue;
+            RefPtr<TypeBuilder::Debugger::Location> location = resolveBreakpoint(breakpointId, it->key, breakpoint, UserBreakpointSource);
+            if (location)
+                locations->addItem(location);
+        }
+    }
+    *outBreakpointId = breakpointId;
+}
+
+static bool parseLocation(ErrorString* errorString, PassRefPtr<JSONObject> location, String* scriptId, int* lineNumber, int* columnNumber)
+{
+    if (!location->getString("scriptId", scriptId) || !location->getNumber("lineNumber", lineNumber)) {
+        // FIXME: replace with input validation.
+        *errorString = "scriptId and lineNumber are required.";
+        return false;
+    }
+    *columnNumber = 0;
+    location->getNumber("columnNumber", columnNumber);
+    return true;
+}
+
+void InspectorDebuggerAgent::setBreakpoint(ErrorString* errorString, const RefPtr<JSONObject>& location, const String* const optionalCondition, BreakpointId* outBreakpointId, RefPtr<TypeBuilder::Debugger::Location>& actualLocation)
+{
+    String scriptId;
+    int lineNumber;
+    int columnNumber;
+
+    if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
+        return;
+
+    String condition = optionalCondition ? *optionalCondition : emptyString();
+
+    String breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, UserBreakpointSource);
+    if (m_breakpointIdToDebugServerBreakpointIds.find(breakpointId) != m_breakpointIdToDebugServerBreakpointIds.end()) {
+        *errorString = "Breakpoint at specified location already exists.";
+        return;
+    }
+    ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
+    actualLocation = resolveBreakpoint(breakpointId, scriptId, breakpoint, UserBreakpointSource);
+    if (actualLocation)
+        *outBreakpointId = breakpointId;
+    else
+        *errorString = "Could not resolve breakpoint";
+}
+
+void InspectorDebuggerAgent::removeBreakpoint(ErrorString*, const String& breakpointId)
+{
+    RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
+    JSONObject::iterator it = breakpointsCookie->find(breakpointId);
+    bool isAntibreakpoint = false;
+    if (it != breakpointsCookie->end()) {
+        RefPtr<JSONObject> breakpointObject = it->value->asObject();
+        breakpointObject->getBoolean(DebuggerAgentState::isAnti, &isAntibreakpoint);
+        breakpointsCookie->remove(breakpointId);
+        m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie);
+    }
+
+    if (!isAntibreakpoint)
+        removeBreakpoint(breakpointId);
+}
+
+void InspectorDebuggerAgent::removeBreakpoint(const String& breakpointId)
+{
+    BreakpointIdToDebugServerBreakpointIdsMap::iterator debugServerBreakpointIdsIterator = m_breakpointIdToDebugServerBreakpointIds.find(breakpointId);
+    if (debugServerBreakpointIdsIterator == m_breakpointIdToDebugServerBreakpointIds.end())
+        return;
+    for (size_t i = 0; i < debugServerBreakpointIdsIterator->value.size(); ++i) {
+        const String& debugServerBreakpointId = debugServerBreakpointIdsIterator->value[i];
+        scriptDebugServer().removeBreakpoint(debugServerBreakpointId);
+        m_serverBreakpoints.remove(debugServerBreakpointId);
+    }
+    m_breakpointIdToDebugServerBreakpointIds.remove(debugServerBreakpointIdsIterator);
+}
+
+void InspectorDebuggerAgent::continueToLocation(ErrorString* errorString, const RefPtr<JSONObject>& location, const bool* interstateLocationOpt)
+{
+    if (!m_continueToLocationBreakpointId.isEmpty()) {
+        scriptDebugServer().removeBreakpoint(m_continueToLocationBreakpointId);
+        m_continueToLocationBreakpointId = "";
+    }
+
+    String scriptId;
+    int lineNumber;
+    int columnNumber;
+
+    if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
+        return;
+
+    ScriptBreakpoint breakpoint(lineNumber, columnNumber, "");
+    m_continueToLocationBreakpointId = scriptDebugServer().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, asBool(interstateLocationOpt));
+    resume(errorString);
+}
+
+void InspectorDebuggerAgent::getStepInPositions(ErrorString* errorString, const String& callFrameId, RefPtr<Array<TypeBuilder::Debugger::Location> >& positions)
+{
+    if (!isPaused() || m_currentCallStack.isEmpty()) {
+        *errorString = "Attempt to access callframe when debugger is not on pause";
+        return;
+    }
+    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
+    if (injectedScript.isEmpty()) {
+        *errorString = "Inspected frame has gone";
+        return;
+    }
+
+    injectedScript.getStepInPositions(errorString, m_currentCallStack, callFrameId, positions);
+}
+
+void InspectorDebuggerAgent::getBacktrace(ErrorString* errorString, RefPtr<Array<CallFrame> >& callFrames, RefPtr<StackTrace>& asyncStackTrace)
+{
+    if (!assertPaused(errorString))
+        return;
+    m_currentCallStack = scriptDebugServer().currentCallFrames();
+    callFrames = currentCallFrames();
+    asyncStackTrace = currentAsyncStackTrace();
+}
+
+PassRefPtr<JavaScriptCallFrame> InspectorDebuggerAgent::topCallFrameSkipUnknownSources()
+{
+    for (int index = 0; ; ++index) {
+        RefPtr<JavaScriptCallFrame> frame = scriptDebugServer().callFrameNoScopes(index);
+        if (!frame)
+            return nullptr;
+        String scriptIdString = String::number(frame->sourceID());
+        if (m_scripts.contains(scriptIdString))
+            return frame.release();
+    }
+}
+
+String InspectorDebuggerAgent::scriptURL(JavaScriptCallFrame* frame)
+{
+    String scriptIdString = String::number(frame->sourceID());
+    ScriptsMap::iterator it = m_scripts.find(scriptIdString);
+    if (it == m_scripts.end())
+        return String();
+    return scriptSourceURL(it->value);
+}
+
+ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipExceptionPause()
+{
+    if (m_steppingFromFramework)
+        return ScriptDebugListener::NoSkip;
+
+    // FIXME: Fast return: if (!m_cachedSkipStackRegExp && !has_any_anti_breakpoint) return ScriptDebugListener::NoSkip;
+
+    RefPtr<JavaScriptCallFrame> topFrame = topCallFrameSkipUnknownSources();
+    if (!topFrame)
+        return ScriptDebugListener::NoSkip;
+
+    String topFrameScriptUrl = scriptURL(topFrame.get());
+    if (m_cachedSkipStackRegExp && !topFrameScriptUrl.isEmpty() && m_cachedSkipStackRegExp->match(topFrameScriptUrl) != -1)
+        return ScriptDebugListener::Continue;
+
+    // Match against breakpoints.
+    if (topFrameScriptUrl.isEmpty())
+        return ScriptDebugListener::NoSkip;
+
+    // Prepare top frame parameters.
+    int topFrameLineNumber = topFrame->line();
+    int topFrameColumnNumber = topFrame->column();
+
+    RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
+    for (JSONObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) {
+        RefPtr<JSONObject> breakpointObject = it->value->asObject();
+        bool isAntibreakpoint;
+        breakpointObject->getBoolean(DebuggerAgentState::isAnti, &isAntibreakpoint);
+        if (!isAntibreakpoint)
+            continue;
+
+        int breakLineNumber;
+        breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakLineNumber);
+        int breakColumnNumber;
+        breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakColumnNumber);
+
+        if (breakLineNumber != topFrameLineNumber)
+            continue;
+
+        if (breakColumnNumber != -1 && breakColumnNumber != topFrameColumnNumber)
+            continue;
+
+        bool isRegex;
+        breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
+        String url;
+        breakpointObject->getString(DebuggerAgentState::url, &url);
+        if (!matches(topFrameScriptUrl, url, isRegex))
+            continue;
+
+        return ScriptDebugListener::Continue;
+    }
+
+    return ScriptDebugListener::NoSkip;
+}
+
+ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipStepPause()
+{
+    if (!m_cachedSkipStackRegExp || m_steppingFromFramework)
+        return ScriptDebugListener::NoSkip;
+
+    RefPtr<JavaScriptCallFrame> topFrame = topCallFrameSkipUnknownSources();
+    String scriptUrl = scriptURL(topFrame.get());
+    if (scriptUrl.isEmpty() || m_cachedSkipStackRegExp->match(scriptUrl) == -1)
+        return ScriptDebugListener::NoSkip;
+
+    if (m_skippedStepInCount == 0) {
+        m_minFrameCountForSkip = scriptDebugServer().frameCount();
+        m_skippedStepInCount = 1;
+        return ScriptDebugListener::StepInto;
+    }
+
+    if (m_skippedStepInCount < maxSkipStepInCount && topFrame->isAtReturn() && scriptDebugServer().frameCount() <= m_minFrameCountForSkip)
+        m_skippedStepInCount = maxSkipStepInCount;
+
+    if (m_skippedStepInCount >= maxSkipStepInCount) {
+        if (m_pausingOnNativeEvent) {
+            m_pausingOnNativeEvent = false;
+            m_skippedStepInCount = 0;
+            return ScriptDebugListener::Continue;
+        }
+        return ScriptDebugListener::StepOut;
+    }
+
+    ++m_skippedStepInCount;
+    return ScriptDebugListener::StepInto;
+}
+
+bool InspectorDebuggerAgent::isTopCallFrameInFramework()
+{
+    if (!m_cachedSkipStackRegExp)
+        return false;
+
+    RefPtr<JavaScriptCallFrame> topFrame = topCallFrameSkipUnknownSources();
+    if (!topFrame)
+        return false;
+
+    String scriptUrl = scriptURL(topFrame.get());
+    return !scriptUrl.isEmpty() && m_cachedSkipStackRegExp->match(scriptUrl) != -1;
+}
+
+PassRefPtr<TypeBuilder::Debugger::Location> InspectorDebuggerAgent::resolveBreakpoint(const String& breakpointId, const String& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
+{
+    ScriptsMap::iterator scriptIterator = m_scripts.find(scriptId);
+    if (scriptIterator == m_scripts.end())
+        return nullptr;
+    Script& script = scriptIterator->value;
+    if (breakpoint.lineNumber < script.startLine || script.endLine < breakpoint.lineNumber)
+        return nullptr;
+
+    int actualLineNumber;
+    int actualColumnNumber;
+    String debugServerBreakpointId = scriptDebugServer().setBreakpoint(scriptId, breakpoint, &actualLineNumber, &actualColumnNumber, false);
+    if (debugServerBreakpointId.isEmpty())
+        return nullptr;
+
+    m_serverBreakpoints.set(debugServerBreakpointId, std::make_pair(breakpointId, source));
+
+    BreakpointIdToDebugServerBreakpointIdsMap::iterator debugServerBreakpointIdsIterator = m_breakpointIdToDebugServerBreakpointIds.find(breakpointId);
+    if (debugServerBreakpointIdsIterator == m_breakpointIdToDebugServerBreakpointIds.end())
+        m_breakpointIdToDebugServerBreakpointIds.set(breakpointId, Vector<String>()).storedValue->value.append(debugServerBreakpointId);
+    else
+        debugServerBreakpointIdsIterator->value.append(debugServerBreakpointId);
+
+    RefPtr<TypeBuilder::Debugger::Location> location = TypeBuilder::Debugger::Location::create()
+        .setScriptId(scriptId)
+        .setLineNumber(actualLineNumber);
+    location->setColumnNumber(actualColumnNumber);
+    return location;
+}
+
+void InspectorDebuggerAgent::searchInContent(ErrorString* error, const String& scriptId, const String& query, const bool* const optionalCaseSensitive, const bool* const optionalIsRegex, RefPtr<Array<blink::TypeBuilder::Page::SearchMatch> >& results)
+{
+    ScriptsMap::iterator it = m_scripts.find(scriptId);
+    if (it != m_scripts.end())
+        results = ContentSearchUtils::searchInTextByLines(it->value.source, query, asBool(optionalCaseSensitive), asBool(optionalIsRegex));
+    else
+        *error = "No script for id: " + scriptId;
+}
+
+void InspectorDebuggerAgent::setScriptSource(ErrorString* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorData, const String& scriptId, const String& newContent, const bool* const preview, RefPtr<Array<CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, RefPtr<StackTrace>& asyncStackTrace)
+{
+    if (!scriptDebugServer().setScriptSource(scriptId, newContent, asBool(preview), error, errorData, &m_currentCallStack, &result))
+        return;
+
+    newCallFrames = currentCallFrames();
+    asyncStackTrace = currentAsyncStackTrace();
+    // FIXME(sky): Used to tell the page agent.
+}
+
+void InspectorDebuggerAgent::restartFrame(ErrorString* errorString, const String& callFrameId, RefPtr<Array<CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, RefPtr<StackTrace>& asyncStackTrace)
+{
+    if (!isPaused() || m_currentCallStack.isEmpty()) {
+        *errorString = "Attempt to access callframe when debugger is not on pause";
+        return;
+    }
+    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
+    if (injectedScript.isEmpty()) {
+        *errorString = "Inspected frame has gone";
+        return;
+    }
+
+    injectedScript.restartFrame(errorString, m_currentCallStack, callFrameId, &result);
+    m_currentCallStack = scriptDebugServer().currentCallFrames();
+    newCallFrames = currentCallFrames();
+    asyncStackTrace = currentAsyncStackTrace();
+}
+
+void InspectorDebuggerAgent::getScriptSource(ErrorString* error, const String& scriptId, String* scriptSource)
+{
+    ScriptsMap::iterator it = m_scripts.find(scriptId);
+    if (it == m_scripts.end()) {
+        *error = "No script for id: " + scriptId;
+        return;
+    }
+
+    String url = it->value.url;
+    // FIXME(sky): Fetch the script from the page agent?
+    *scriptSource = it->value.source;
+}
+
+void InspectorDebuggerAgent::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<FunctionDetails>& details)
+{
+    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(functionId);
+    if (injectedScript.isEmpty()) {
+        *errorString = "Function object id is obsolete";
+        return;
+    }
+    injectedScript.getFunctionDetails(errorString, functionId, &details);
+}
+
+void InspectorDebuggerAgent::getCollectionEntries(ErrorString* errorString, const String& objectId, RefPtr<TypeBuilder::Array<CollectionEntry> >& entries)
+{
+    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(objectId);
+    if (injectedScript.isEmpty()) {
+        *errorString = "Inspected frame has gone";
+        return;
+    }
+    injectedScript.getCollectionEntries(errorString, objectId, &entries);
+}
+
+void InspectorDebuggerAgent::schedulePauseOnNextStatement(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
+{
+    if (m_javaScriptPauseScheduled || isPaused())
+        return;
+    m_breakReason = breakReason;
+    m_breakAuxData = data;
+    m_pausingOnNativeEvent = true;
+    scriptDebugServer().setPauseOnNextStatement(true);
+}
+
+void InspectorDebuggerAgent::cancelPauseOnNextStatement()
+{
+    if (m_javaScriptPauseScheduled || isPaused())
+        return;
+    clearBreakDetails();
+    m_pausingOnNativeEvent = false;
+    scriptDebugServer().setPauseOnNextStatement(false);
+}
+
+void InspectorDebuggerAgent::didInstallTimer(ExecutionContext* context, int timerId, int timeout, bool singleShot)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didInstallTimer(context, timerId, singleShot, scriptDebugServer().currentCallFramesForAsyncStack());
+}
+
+void InspectorDebuggerAgent::didRemoveTimer(ExecutionContext* context, int timerId)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didRemoveTimer(context, timerId);
+}
+
+bool InspectorDebuggerAgent::willFireTimer(ExecutionContext* context, int timerId)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willFireTimer(context, timerId);
+    return true;
+}
+
+void InspectorDebuggerAgent::didFireTimer()
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
+    cancelPauseOnNextStatement();
+}
+
+void InspectorDebuggerAgent::didRequestAnimationFrame(Document* document, int callbackId)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didRequestAnimationFrame(document, callbackId, scriptDebugServer().currentCallFramesForAsyncStack());
+}
+
+void InspectorDebuggerAgent::didCancelAnimationFrame(Document* document, int callbackId)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didCancelAnimationFrame(document, callbackId);
+}
+
+bool InspectorDebuggerAgent::willFireAnimationFrame(Document* document, int callbackId)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willFireAnimationFrame(document, callbackId);
+    return true;
+}
+
+void InspectorDebuggerAgent::didFireAnimationFrame()
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
+}
+
+void InspectorDebuggerAgent::didEnqueueEvent(EventTarget* eventTarget, Event* event)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didEnqueueEvent(eventTarget, event, scriptDebugServer().currentCallFramesForAsyncStack());
+}
+
+void InspectorDebuggerAgent::didRemoveEvent(EventTarget* eventTarget, Event* event)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didRemoveEvent(eventTarget, event);
+}
+
+void InspectorDebuggerAgent::willHandleEvent(EventTarget* eventTarget, Event* event, EventListener* listener, bool useCapture)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willHandleEvent(eventTarget, event, listener, useCapture);
+}
+
+void InspectorDebuggerAgent::didHandleEvent()
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
+    cancelPauseOnNextStatement();
+}
+
+void InspectorDebuggerAgent::didEnqueueMutationRecord(ExecutionContext* context, MutationObserver* observer)
+{
+    if (asyncCallStackTracker().isEnabled() && !asyncCallStackTracker().hasEnqueuedMutationRecord(context, observer))
+        asyncCallStackTracker().didEnqueueMutationRecord(context, observer, scriptDebugServer().currentCallFramesForAsyncStack());
+}
+
+void InspectorDebuggerAgent::didClearAllMutationRecords(ExecutionContext* context, MutationObserver* observer)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didClearAllMutationRecords(context, observer);
+}
+
+void InspectorDebuggerAgent::willDeliverMutationRecords(ExecutionContext* context, MutationObserver* observer)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willDeliverMutationRecords(context, observer);
+}
+
+void InspectorDebuggerAgent::didDeliverMutationRecords()
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
+}
+
+// void InspectorDebuggerAgent::didPostExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task)
+// {
+//     if (asyncCallStackTracker().isEnabled() && !task->taskNameForInstrumentation().isEmpty())
+//         asyncCallStackTracker().didPostExecutionContextTask(context, task, scriptDebugServer().currentCallFramesForAsyncStack());
+// }
+
+// void InspectorDebuggerAgent::didKillAllExecutionContextTasks(ExecutionContext* context)
+// {
+//     if (asyncCallStackTracker().isEnabled())
+//         asyncCallStackTracker().didKillAllExecutionContextTasks(context);
+// }
+
+// void InspectorDebuggerAgent::willPerformExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task)
+// {
+//     if (asyncCallStackTracker().isEnabled())
+//         asyncCallStackTracker().willPerformExecutionContextTask(context, task);
+// }
+
+// void InspectorDebuggerAgent::didPerformExecutionContextTask()
+// {
+//     if (asyncCallStackTracker().isEnabled())
+//         asyncCallStackTracker().didFireAsyncCall();
+// }
+
+int InspectorDebuggerAgent::traceAsyncOperationStarting(ExecutionContext* context, const String& operationName, int prevOperationId)
+{
+    if (!asyncCallStackTracker().isEnabled())
+        return 0;
+    if (prevOperationId)
+        asyncCallStackTracker().traceAsyncOperationCompleted(context, prevOperationId);
+    return asyncCallStackTracker().traceAsyncOperationStarting(context, operationName, scriptDebugServer().currentCallFramesForAsyncStack());
+}
+
+void InspectorDebuggerAgent::traceAsyncOperationCompleted(ExecutionContext* context, int operationId)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().traceAsyncOperationCompleted(context, operationId);
+}
+
+void InspectorDebuggerAgent::traceAsyncOperationCompletedCallbackStarting(ExecutionContext* context, int operationId)
+{
+    if (!asyncCallStackTracker().isEnabled())
+        return;
+    asyncCallStackTracker().traceAsyncCallbackStarting(context, operationId);
+    asyncCallStackTracker().traceAsyncOperationCompleted(context, operationId);
+}
+
+void InspectorDebuggerAgent::traceAsyncCallbackStarting(ExecutionContext* context, int operationId)
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().traceAsyncCallbackStarting(context, operationId);
+}
+
+void InspectorDebuggerAgent::traceAsyncCallbackCompleted()
+{
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
+}
+
+void InspectorDebuggerAgent::didReceiveV8AsyncTaskEvent(ExecutionContext* context, const String& eventType, const String& eventName, int id)
+{
+    if (!asyncCallStackTracker().isEnabled())
+        return;
+    if (eventType == v8AsyncTaskEventEnqueue)
+        asyncCallStackTracker().didEnqueueV8AsyncTask(context, eventName, id, scriptDebugServer().currentCallFramesForAsyncStack());
+    else if (eventType == v8AsyncTaskEventWillHandle)
+        asyncCallStackTracker().willHandleV8AsyncTask(context, eventName, id);
+    else if (eventType == v8AsyncTaskEventDidHandle)
+        asyncCallStackTracker().didFireAsyncCall();
+    else
+        ASSERT_NOT_REACHED();
+}
+
+void InspectorDebuggerAgent::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status)
+{
+    if (!m_promiseTracker.isEnabled())
+        return;
+    m_promiseTracker.didReceiveV8PromiseEvent(scriptState, promise, parentPromise, status);
+}
+
+void InspectorDebuggerAgent::pause(ErrorString*)
+{
+    if (m_javaScriptPauseScheduled || isPaused())
+        return;
+    clearBreakDetails();
+    m_javaScriptPauseScheduled = true;
+    scriptDebugServer().setPauseOnNextStatement(true);
+}
+
+void InspectorDebuggerAgent::resume(ErrorString* errorString)
+{
+    if (!assertPaused(errorString))
+        return;
+    m_debuggerStepScheduled = false;
+    m_steppingFromFramework = false;
+    m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
+    scriptDebugServer().continueProgram();
+}
+
+void InspectorDebuggerAgent::stepOver(ErrorString* errorString)
+{
+    if (!assertPaused(errorString))
+        return;
+    m_debuggerStepScheduled = true;
+    m_steppingFromFramework = isTopCallFrameInFramework();
+    m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
+    scriptDebugServer().stepOverStatement();
+}
+
+void InspectorDebuggerAgent::stepInto(ErrorString* errorString)
+{
+    if (!assertPaused(errorString))
+        return;
+    m_debuggerStepScheduled = true;
+    m_steppingFromFramework = isTopCallFrameInFramework();
+    m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
+    scriptDebugServer().stepIntoStatement();
+    if (m_listener)
+        m_listener->stepInto();
+}
+
+void InspectorDebuggerAgent::stepOut(ErrorString* errorString)
+{
+    if (!assertPaused(errorString))
+        return;
+    m_debuggerStepScheduled = true;
+    m_steppingFromFramework = isTopCallFrameInFramework();
+    m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
+    scriptDebugServer().stepOutOfFunction();
+}
+
+void InspectorDebuggerAgent::setPauseOnExceptions(ErrorString* errorString, const String& stringPauseState)
+{
+    ScriptDebugServer::PauseOnExceptionsState pauseState;
+    if (stringPauseState == "none")
+        pauseState = ScriptDebugServer::DontPauseOnExceptions;
+    else if (stringPauseState == "all")
+        pauseState = ScriptDebugServer::PauseOnAllExceptions;
+    else if (stringPauseState == "uncaught")
+        pauseState = ScriptDebugServer::PauseOnUncaughtExceptions;
+    else {
+        *errorString = "Unknown pause on exceptions mode: " + stringPauseState;
+        return;
+    }
+    setPauseOnExceptionsImpl(errorString, pauseState);
+}
+
+void InspectorDebuggerAgent::setPauseOnExceptionsImpl(ErrorString* errorString, int pauseState)
+{
+    scriptDebugServer().setPauseOnExceptionsState(static_cast<ScriptDebugServer::PauseOnExceptionsState>(pauseState));
+    if (scriptDebugServer().pauseOnExceptionsState() != pauseState)
+        *errorString = "Internal error. Could not change pause on exceptions state";
+    else
+        m_state->setLong(DebuggerAgentState::pauseOnExceptionsState, pauseState);
+}
+
+void InspectorDebuggerAgent::evaluateOnCallFrame(ErrorString* errorString, const String& callFrameId, const String& expression, const String* const objectGroup, const bool* const includeCommandLineAPI, const bool* const doNotPauseOnExceptionsAndMuteConsole, const bool* const returnByValue, const bool* generatePreview, RefPtr<RemoteObject>& result, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>& exceptionDetails)
+{
+    if (!isPaused() || m_currentCallStack.isEmpty()) {
+        *errorString = "Attempt to access callframe when debugger is not on pause";
+        return;
+    }
+    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
+    if (injectedScript.isEmpty()) {
+        *errorString = "Inspected frame has gone";
+        return;
+    }
+
+    ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
+    if (asBool(doNotPauseOnExceptionsAndMuteConsole)) {
+        if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
+            scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
+        muteConsole();
+    }
+
+    Vector<ScriptValue> asyncCallStacks;
+    const AsyncCallStackTracker::AsyncCallChain* asyncChain = asyncCallStackTracker().isEnabled() ? asyncCallStackTracker().currentAsyncCallChain() : 0;
+    if (asyncChain) {
+        const AsyncCallStackTracker::AsyncCallStackVector& callStacks = asyncChain->callStacks();
+        asyncCallStacks.resize(callStacks.size());
+        AsyncCallStackTracker::AsyncCallStackVector::const_iterator it = callStacks.begin();
+        for (size_t i = 0; it != callStacks.end(); ++it, ++i)
+            asyncCallStacks[i] = (*it)->callFrames();
+    }
+
+    injectedScript.evaluateOnCallFrame(errorString, m_currentCallStack, asyncCallStacks, callFrameId, expression, objectGroup ? *objectGroup : "", asBool(includeCommandLineAPI), asBool(returnByValue), asBool(generatePreview), &result, wasThrown, &exceptionDetails);
+    // V8 doesn't generate afterCompile event when it's in debugger therefore there is no content of evaluated scripts on frontend
+    // therefore contents of the stack does not provide necessary information
+    if (exceptionDetails)
+        exceptionDetails->setStackTrace(TypeBuilder::Array<TypeBuilder::Console::CallFrame>::create());
+    if (asBool(doNotPauseOnExceptionsAndMuteConsole)) {
+        unmuteConsole();
+        if (scriptDebugServer().pauseOnExceptionsState() != previousPauseOnExceptionsState)
+            scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
+    }
+}
+
+void InspectorDebuggerAgent::compileScript(ErrorString* errorString, const String& expression, const String& sourceURL, const int* executionContextId, TypeBuilder::OptOutput<ScriptId>* scriptId, RefPtr<ExceptionDetails>& exceptionDetails)
+{
+    InjectedScript injectedScript = injectedScriptForEval(errorString, executionContextId);
+    if (injectedScript.isEmpty()) {
+        *errorString = "Inspected frame has gone";
+        return;
+    }
+
+    String scriptIdValue;
+    String exceptionDetailsText;
+    int lineNumberValue = 0;
+    int columnNumberValue = 0;
+    RefPtr<ScriptCallStack> stackTraceValue;
+    scriptDebugServer().compileScript(injectedScript.scriptState(), expression, sourceURL, &scriptIdValue, &exceptionDetailsText, &lineNumberValue, &columnNumberValue, &stackTraceValue);
+    if (!scriptIdValue && !exceptionDetailsText) {
+        *errorString = "Script compilation failed";
+        return;
+    }
+    *scriptId = scriptIdValue;
+    if (!scriptIdValue.isEmpty())
+        return;
+
+    exceptionDetails = ExceptionDetails::create().setText(exceptionDetailsText);
+    exceptionDetails->setLine(lineNumberValue);
+    exceptionDetails->setColumn(columnNumberValue);
+    if (stackTraceValue && stackTraceValue->size() > 0)
+        exceptionDetails->setStackTrace(stackTraceValue->buildInspectorArray());
+}
+
+void InspectorDebuggerAgent::runScript(ErrorString* errorString, const ScriptId& scriptId, const int* executionContextId, const String* const objectGroup, const bool* const doNotPauseOnExceptionsAndMuteConsole, RefPtr<RemoteObject>& result, RefPtr<ExceptionDetails>& exceptionDetails)
+{
+    InjectedScript injectedScript = injectedScriptForEval(errorString, executionContextId);
+    if (injectedScript.isEmpty()) {
+        *errorString = "Inspected frame has gone";
+        return;
+    }
+
+    ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
+    if (asBool(doNotPauseOnExceptionsAndMuteConsole)) {
+        if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
+            scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
+        muteConsole();
+    }
+
+    ScriptValue value;
+    bool wasThrownValue;
+    String exceptionDetailsText;
+    int lineNumberValue = 0;
+    int columnNumberValue = 0;
+    RefPtr<ScriptCallStack> stackTraceValue;
+    scriptDebugServer().runScript(injectedScript.scriptState(), scriptId, &value, &wasThrownValue, &exceptionDetailsText, &lineNumberValue, &columnNumberValue, &stackTraceValue);
+    if (value.isEmpty()) {
+        *errorString = "Script execution failed";
+        return;
+    }
+    result = injectedScript.wrapObject(value, objectGroup ? *objectGroup : "");
+    if (wasThrownValue) {
+        exceptionDetails = ExceptionDetails::create().setText(exceptionDetailsText);
+        exceptionDetails->setLine(lineNumberValue);
+        exceptionDetails->setColumn(columnNumberValue);
+        if (stackTraceValue && stackTraceValue->size() > 0)
+            exceptionDetails->setStackTrace(stackTraceValue->buildInspectorArray());
+    }
+
+    if (asBool(doNotPauseOnExceptionsAndMuteConsole)) {
+        unmuteConsole();
+        if (scriptDebugServer().pauseOnExceptionsState() != previousPauseOnExceptionsState)
+            scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
+    }
+}
+
+void InspectorDebuggerAgent::setOverlayMessage(ErrorString*, const String*)
+{
+}
+
+void InspectorDebuggerAgent::setVariableValue(ErrorString* errorString, int scopeNumber, const String& variableName, const RefPtr<JSONObject>& newValue, const String* callFrameId, const String* functionObjectId)
+{
+    InjectedScript injectedScript;
+    if (callFrameId) {
+        if (!isPaused() || m_currentCallStack.isEmpty()) {
+            *errorString = "Attempt to access callframe when debugger is not on pause";
+            return;
+        }
+        injectedScript = m_injectedScriptManager->injectedScriptForObjectId(*callFrameId);
+        if (injectedScript.isEmpty()) {
+            *errorString = "Inspected frame has gone";
+            return;
+        }
+    } else if (functionObjectId) {
+        injectedScript = m_injectedScriptManager->injectedScriptForObjectId(*functionObjectId);
+        if (injectedScript.isEmpty()) {
+            *errorString = "Function object id cannot be resolved";
+            return;
+        }
+    } else {
+        *errorString = "Either call frame or function object must be specified";
+        return;
+    }
+    String newValueString = newValue->toJSONString();
+
+    injectedScript.setVariableValue(errorString, m_currentCallStack, callFrameId, functionObjectId, scopeNumber, variableName, newValueString);
+}
+
+void InspectorDebuggerAgent::skipStackFrames(ErrorString* errorString, const String* pattern)
+{
+    OwnPtr<ScriptRegexp> compiled;
+    String patternValue = pattern ? *pattern : "";
+    if (!patternValue.isEmpty()) {
+        compiled = compileSkipCallFramePattern(patternValue);
+        if (!compiled) {
+            *errorString = "Invalid regular expression";
+            return;
+        }
+    }
+    m_state->setString(DebuggerAgentState::skipStackPattern, patternValue);
+    m_cachedSkipStackRegExp = compiled.release();
+}
+
+void InspectorDebuggerAgent::setAsyncCallStackDepth(ErrorString*, int depth)
+{
+    m_state->setLong(DebuggerAgentState::asyncCallStackDepth, depth);
+    asyncCallStackTracker().setAsyncCallStackDepth(depth);
+}
+
+void InspectorDebuggerAgent::scriptExecutionBlockedByCSP(const String& directiveText)
+{
+    if (scriptDebugServer().pauseOnExceptionsState() != ScriptDebugServer::DontPauseOnExceptions) {
+        RefPtr<JSONObject> directive = JSONObject::create();
+        directive->setString("directiveText", directiveText);
+        breakProgram(InspectorFrontend::Debugger::Reason::CSPViolation, directive.release());
+    }
+}
+
+PassRefPtr<Array<CallFrame> > InspectorDebuggerAgent::currentCallFrames()
+{
+    if (!m_pausedScriptState || m_currentCallStack.isEmpty())
+        return Array<CallFrame>::create();
+    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
+    if (injectedScript.isEmpty()) {
+        ASSERT_NOT_REACHED();
+        return Array<CallFrame>::create();
+    }
+    return injectedScript.wrapCallFrames(m_currentCallStack, 0);
+}
+
+PassRefPtr<StackTrace> InspectorDebuggerAgent::currentAsyncStackTrace()
+{
+    if (!m_pausedScriptState || !asyncCallStackTracker().isEnabled())
+        return nullptr;
+    const AsyncCallStackTracker::AsyncCallChain* chain = asyncCallStackTracker().currentAsyncCallChain();
+    if (!chain)
+        return nullptr;
+    const AsyncCallStackTracker::AsyncCallStackVector& callStacks = chain->callStacks();
+    if (callStacks.isEmpty())
+        return nullptr;
+    RefPtr<StackTrace> result;
+    int asyncOrdinal = callStacks.size();
+    for (AsyncCallStackTracker::AsyncCallStackVector::const_reverse_iterator it = callStacks.rbegin(); it != callStacks.rend(); ++it, --asyncOrdinal) {
+        ScriptValue callFrames = (*it)->callFrames();
+        ScriptState* scriptState = callFrames.scriptState();
+        InjectedScript injectedScript = scriptState ? m_injectedScriptManager->injectedScriptFor(scriptState) : InjectedScript();
+        if (injectedScript.isEmpty()) {
+            result.clear();
+            continue;
+        }
+        RefPtr<StackTrace> next = StackTrace::create()
+            .setCallFrames(injectedScript.wrapCallFrames(callFrames, asyncOrdinal))
+            .release();
+        next->setDescription((*it)->description());
+        if (result)
+            next->setAsyncStackTrace(result.release());
+        result.swap(next);
+    }
+    return result.release();
+}
+
+static PassRefPtr<ScriptCallStack> toScriptCallStack(JavaScriptCallFrame* callFrame)
+{
+    Vector<ScriptCallFrame> frames;
+    for (; callFrame; callFrame = callFrame->caller()) {
+        StringBuilder stringBuilder;
+        stringBuilder.appendNumber(callFrame->sourceID());
+        String scriptId = stringBuilder.toString();
+        // FIXME(WK62725): Debugger line/column are 0-based, while console ones are 1-based.
+        int line = callFrame->line() + 1;
+        int column = callFrame->column() + 1;
+        frames.append(ScriptCallFrame(callFrame->functionName(), scriptId, callFrame->scriptName(), line, column));
+    }
+    return ScriptCallStack::create(frames);
+}
+
+PassRefPtr<ScriptAsyncCallStack> InspectorDebuggerAgent::currentAsyncStackTraceForConsole()
+{
+    if (!asyncCallStackTracker().isEnabled())
+        return nullptr;
+    const AsyncCallStackTracker::AsyncCallChain* chain = asyncCallStackTracker().currentAsyncCallChain();
+    if (!chain)
+        return nullptr;
+    const AsyncCallStackTracker::AsyncCallStackVector& callStacks = chain->callStacks();
+    if (callStacks.isEmpty())
+        return nullptr;
+    RefPtr<ScriptAsyncCallStack> result = nullptr;
+    for (AsyncCallStackTracker::AsyncCallStackVector::const_reverse_iterator it = callStacks.rbegin(); it != callStacks.rend(); ++it) {
+        RefPtr<JavaScriptCallFrame> callFrame = ScriptDebugServer::toJavaScriptCallFrameUnsafe((*it)->callFrames());
+        if (!callFrame)
+            break;
+        result = ScriptAsyncCallStack::create((*it)->description(), toScriptCallStack(callFrame.get()), result.release());
+    }
+    return result.release();
+}
+
+String InspectorDebuggerAgent::sourceMapURLForScript(const Script& script, CompileResult compileResult)
+{
+    bool hasSyntaxError = compileResult != CompileSuccess;
+    if (hasSyntaxError) {
+        bool deprecated;
+        String sourceMapURL = ContentSearchUtils::findSourceMapURL(script.source, ContentSearchUtils::JavaScriptMagicComment, &deprecated);
+        if (!sourceMapURL.isEmpty())
+            return sourceMapURL;
+    }
+
+    if (!script.sourceMappingURL.isEmpty())
+        return script.sourceMappingURL;
+
+    return String();
+    // FIXME(sky): Fetch from page agent.
+}
+
+// ScriptDebugListener functions
+
+void InspectorDebuggerAgent::didParseSource(const String& scriptId, const Script& parsedScript, CompileResult compileResult)
+{
+    Script script = parsedScript;
+    const bool* isContentScript = script.isContentScript ? &script.isContentScript : 0;
+
+    bool hasSyntaxError = compileResult != CompileSuccess;
+    if (!script.startLine && !script.startColumn) {
+        if (hasSyntaxError) {
+            bool deprecated;
+            script.sourceURL = ContentSearchUtils::findSourceURL(script.source, ContentSearchUtils::JavaScriptMagicComment, &deprecated);
+        }
+    } else {
+        script.sourceURL = String();
+    }
+
+    bool hasSourceURL = !script.sourceURL.isEmpty();
+    String scriptURL = hasSourceURL ? script.sourceURL : script.url;
+
+    String sourceMapURL = sourceMapURLForScript(script, compileResult);
+    String* sourceMapURLParam = sourceMapURL.isNull() ? 0 : &sourceMapURL;
+
+    bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : 0;
+    if (!hasSyntaxError)
+        m_frontend->scriptParsed(scriptId, scriptURL, script.startLine, script.startColumn, script.endLine, script.endColumn, isContentScript, sourceMapURLParam, hasSourceURLParam);
+    else
+        m_frontend->scriptFailedToParse(scriptId, scriptURL, script.startLine, script.startColumn, script.endLine, script.endColumn, isContentScript, sourceMapURLParam, hasSourceURLParam);
+
+    m_scripts.set(scriptId, script);
+
+    if (scriptURL.isEmpty() || hasSyntaxError)
+        return;
+
+    RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
+    for (JSONObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) {
+        RefPtr<JSONObject> breakpointObject = it->value->asObject();
+        bool isAntibreakpoint;
+        breakpointObject->getBoolean(DebuggerAgentState::isAnti, &isAntibreakpoint);
+        if (isAntibreakpoint)
+            continue;
+        bool isRegex;
+        breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
+        String url;
+        breakpointObject->getString(DebuggerAgentState::url, &url);
+        if (!matches(scriptURL, url, isRegex))
+            continue;
+        ScriptBreakpoint breakpoint;
+        breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakpoint.lineNumber);
+        breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakpoint.columnNumber);
+        breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition);
+        RefPtr<TypeBuilder::Debugger::Location> location = resolveBreakpoint(it->key, scriptId, breakpoint, UserBreakpointSource);
+        if (location)
+            m_frontend->breakpointResolved(it->key, location);
+    }
+}
+
+// FIXME(sky): This is a hack to make the debugger not break in the js inspector
+// so it works even while v8 is paused. crbug.com/434510
+bool InspectorDebuggerAgent::shouldSkipInspectorInternals()
+{
+    RefPtr<JavaScriptCallFrame> topFrame = topCallFrameSkipUnknownSources();
+    if (!topFrame)
+        return false;
+
+    KURL url = KURL(ParsedURLString, scriptURL(topFrame.get()));
+    return url.path().startsWith("/sky/framework")
+        || url.path().startsWith("/sky/services")
+        || url.path().startsWith("/mojo");
+}
+
+ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::didPause(ScriptState* scriptState, const ScriptValue& callFrames, const ScriptValue& exception, const Vector<String>& hitBreakpoints)
+{
+    ScriptDebugListener::SkipPauseRequest result;
+    if (callFrames.isEmpty() || shouldSkipInspectorInternals())
+        result = ScriptDebugListener::Continue; // Skip pauses inside V8 internal scripts and on syntax errors.
+    else if (m_javaScriptPauseScheduled)
+        result = ScriptDebugListener::NoSkip; // Don't skip explicit pause requests from front-end.
+    else if (m_skipAllPauses)
+        result = ScriptDebugListener::Continue;
+    else if (!hitBreakpoints.isEmpty())
+        result = ScriptDebugListener::NoSkip; // Don't skip explicit breakpoints even if set in frameworks.
+    else if (!exception.isEmpty())
+        result = shouldSkipExceptionPause();
+    else if (m_debuggerStepScheduled || m_pausingOnNativeEvent)
+        result = shouldSkipStepPause();
+    else
+        result = ScriptDebugListener::NoSkip;
+
+    if (result != ScriptDebugListener::NoSkip)
+        return result;
+
+    ASSERT(scriptState && !m_pausedScriptState);
+    m_pausedScriptState = scriptState;
+    m_currentCallStack = callFrames;
+
+    if (!exception.isEmpty()) {
+        InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(scriptState);
+        if (!injectedScript.isEmpty()) {
+            m_breakReason = InspectorFrontend::Debugger::Reason::Exception;
+            m_breakAuxData = injectedScript.wrapObject(exception, InspectorDebuggerAgent::backtraceObjectGroup)->openAccessors();
+            // m_breakAuxData might be null after this.
+        }
+    }
+
+    RefPtr<Array<String> > hitBreakpointIds = Array<String>::create();
+
+    for (Vector<String>::const_iterator i = hitBreakpoints.begin(); i != hitBreakpoints.end(); ++i) {
+        DebugServerBreakpointToBreakpointIdAndSourceMap::iterator breakpointIterator = m_serverBreakpoints.find(*i);
+        if (breakpointIterator != m_serverBreakpoints.end()) {
+            const String& localId = breakpointIterator->value.first;
+            hitBreakpointIds->addItem(localId);
+
+            BreakpointSource source = breakpointIterator->value.second;
+            if (m_breakReason == InspectorFrontend::Debugger::Reason::Other && source == DebugCommandBreakpointSource)
+                m_breakReason = InspectorFrontend::Debugger::Reason::DebugCommand;
+        }
+    }
+
+    m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData, hitBreakpointIds, currentAsyncStackTrace());
+    m_javaScriptPauseScheduled = false;
+    m_debuggerStepScheduled = false;
+    m_steppingFromFramework = false;
+    m_pausingOnNativeEvent = false;
+    m_skippedStepInCount = 0;
+
+    if (!m_continueToLocationBreakpointId.isEmpty()) {
+        scriptDebugServer().removeBreakpoint(m_continueToLocationBreakpointId);
+        m_continueToLocationBreakpointId = "";
+    }
+    if (m_listener)
+        m_listener->didPause();
+    return result;
+}
+
+void InspectorDebuggerAgent::didContinue()
+{
+    m_pausedScriptState = nullptr;
+    m_currentCallStack = ScriptValue();
+    clearBreakDetails();
+    m_frontend->resumed();
+}
+
+bool InspectorDebuggerAgent::canBreakProgram()
+{
+    return scriptDebugServer().canBreakProgram();
+}
+
+void InspectorDebuggerAgent::breakProgram(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
+{
+    if (m_skipAllPauses)
+        return;
+    m_breakReason = breakReason;
+    m_breakAuxData = data;
+    m_debuggerStepScheduled = false;
+    m_steppingFromFramework = false;
+    m_pausingOnNativeEvent = false;
+    scriptDebugServer().breakProgram();
+}
+
+void InspectorDebuggerAgent::clear()
+{
+    m_pausedScriptState = nullptr;
+    m_currentCallStack = ScriptValue();
+    m_scripts.clear();
+    m_breakpointIdToDebugServerBreakpointIds.clear();
+    asyncCallStackTracker().clear();
+    m_promiseTracker.clear();
+    m_continueToLocationBreakpointId = String();
+    clearBreakDetails();
+    m_javaScriptPauseScheduled = false;
+    m_debuggerStepScheduled = false;
+    m_steppingFromFramework = false;
+    m_pausingOnNativeEvent = false;
+    ErrorString error;
+    setOverlayMessage(&error, 0);
+}
+
+bool InspectorDebuggerAgent::assertPaused(ErrorString* errorString)
+{
+    if (!m_pausedScriptState) {
+        *errorString = "Can only perform operation while paused.";
+        return false;
+    }
+    return true;
+}
+
+void InspectorDebuggerAgent::clearBreakDetails()
+{
+    m_breakReason = InspectorFrontend::Debugger::Reason::Other;
+    m_breakAuxData = nullptr;
+}
+
+void InspectorDebuggerAgent::setBreakpoint(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source, const String& condition)
+{
+    String breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, source);
+    ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
+    resolveBreakpoint(breakpointId, scriptId, breakpoint, source);
+}
+
+void InspectorDebuggerAgent::removeBreakpoint(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source)
+{
+    removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
+}
+
+void InspectorDebuggerAgent::reset()
+{
+    m_scripts.clear();
+    m_breakpointIdToDebugServerBreakpointIds.clear();
+    asyncCallStackTracker().clear();
+    m_promiseTracker.clear();
+    if (m_frontend)
+        m_frontend->globalObjectCleared();
+}
+
+} // namespace blink
+
diff --git a/engine/core/inspector/InspectorDebuggerAgent.h b/engine/core/inspector/InspectorDebuggerAgent.h
new file mode 100644
index 00000000000..e6679355288
--- /dev/null
+++ b/engine/core/inspector/InspectorDebuggerAgent.h
@@ -0,0 +1,275 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2010-2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef InspectorDebuggerAgent_h
+#define InspectorDebuggerAgent_h
+
+#include "bindings/core/v8/ScriptState.h"
+#include "core/InspectorFrontend.h"
+#include "core/frame/ConsoleTypes.h"
+#include "core/inspector/AsyncCallStackTracker.h"
+#include "core/inspector/ConsoleAPITypes.h"
+#include "core/inspector/InjectedScript.h"
+#include "core/inspector/InspectorBaseAgent.h"
+#include "core/inspector/PromiseTracker.h"
+#include "core/inspector/ScriptBreakpoint.h"
+#include "core/inspector/ScriptDebugListener.h"
+#include "wtf/Forward.h"
+#include "wtf/HashMap.h"
+#include "wtf/PassRefPtr.h"
+#include "wtf/Vector.h"
+#include "wtf/text/StringHash.h"
+
+namespace blink {
+
+class ConsoleMessage;
+class Document;
+class Event;
+class EventListener;
+class EventTarget;
+class FormData;
+class HTTPHeaderMap;
+class InjectedScriptManager;
+class InspectorFrontend;
+class InstrumentingAgents;
+class JavaScriptCallFrame;
+class JSONObject;
+class KURL;
+class MutationObserver;
+class ScriptArguments;
+class ScriptAsyncCallStack;
+class ScriptCallStack;
+class ScriptDebugServer;
+class ScriptRegexp;
+class ScriptSourceCode;
+class ScriptValue;
+class ThreadableLoaderClient;
+class XMLHttpRequest;
+
+typedef String ErrorString;
+
+class InspectorDebuggerAgent : public InspectorBaseAgent<InspectorDebuggerAgent>, public ScriptDebugListener, public InspectorBackendDispatcher::DebuggerCommandHandler {
+    WTF_MAKE_NONCOPYABLE(InspectorDebuggerAgent);
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    enum BreakpointSource {
+        UserBreakpointSource,
+        DebugCommandBreakpointSource,
+        MonitorCommandBreakpointSource
+    };
+
+    static const char backtraceObjectGroup[];
+
+    virtual ~InspectorDebuggerAgent();
+
+    virtual void canSetScriptSource(ErrorString*, bool* result) override final { *result = true; }
+
+    virtual void virtualInit() override final;
+    virtual void setFrontend(InspectorFrontend*) override final;
+    virtual void clearFrontend() override final;
+    virtual void restore() override final;
+
+    bool isPaused();
+    bool runningNestedMessageLoop();
+    void addMessageToConsole(ConsoleMessage*);
+
+    String preprocessEventListener(LocalFrame*, const String& source, const String& url, const String& functionName);
+    PassOwnPtr<ScriptSourceCode> preprocess(LocalFrame*, const ScriptSourceCode&);
+
+    // Part of the protocol.
+    virtual void enable(ErrorString*) override final;
+    virtual void disable(ErrorString*) override final;
+    virtual void setBreakpointsActive(ErrorString*, bool active) override final;
+    virtual void setSkipAllPauses(ErrorString*, bool skipped, const bool* untilReload) override final;
+
+    virtual void setBreakpointByUrl(ErrorString*, int lineNumber, const String* optionalURL, const String* optionalURLRegex, const int* optionalColumnNumber, const String* optionalCondition, const bool* isAntiBreakpoint, TypeBuilder::Debugger::BreakpointId*, RefPtr<TypeBuilder::Array<TypeBuilder::Debugger::Location> >& locations) override final;
+    virtual void setBreakpoint(ErrorString*, const RefPtr<JSONObject>& location, const String* optionalCondition, TypeBuilder::Debugger::BreakpointId*, RefPtr<TypeBuilder::Debugger::Location>& actualLocation) override final;
+    virtual void removeBreakpoint(ErrorString*, const String& breakpointId) override final;
+    virtual void continueToLocation(ErrorString*, const RefPtr<JSONObject>& location, const bool* interstateLocationOpt) override final;
+    virtual void getStepInPositions(ErrorString*, const String& callFrameId, RefPtr<TypeBuilder::Array<TypeBuilder::Debugger::Location> >& positions) override final;
+    virtual void getBacktrace(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::Debugger::CallFrame> >&, RefPtr<TypeBuilder::Debugger::StackTrace>&) override final;
+
+    virtual void searchInContent(ErrorString*, const String& scriptId, const String& query, const bool* optionalCaseSensitive, const bool* optionalIsRegex, RefPtr<TypeBuilder::Array<TypeBuilder::Page::SearchMatch> >&) override final;
+    virtual void setScriptSource(ErrorString*, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>&, const String& scriptId, const String& newContent, const bool* preview, RefPtr<TypeBuilder::Array<TypeBuilder::Debugger::CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, RefPtr<TypeBuilder::Debugger::StackTrace>& asyncStackTrace) override final;
+    virtual void restartFrame(ErrorString*, const String& callFrameId, RefPtr<TypeBuilder::Array<TypeBuilder::Debugger::CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, RefPtr<TypeBuilder::Debugger::StackTrace>& asyncStackTrace) override final;
+    virtual void getScriptSource(ErrorString*, const String& scriptId, String* scriptSource) override final;
+    virtual void getFunctionDetails(ErrorString*, const String& functionId, RefPtr<TypeBuilder::Debugger::FunctionDetails>&) override final;
+    virtual void getCollectionEntries(ErrorString*, const String& objectId, RefPtr<TypeBuilder::Array<TypeBuilder::Debugger::CollectionEntry> >&) override final;
+    virtual void pause(ErrorString*) override final;
+    virtual void resume(ErrorString*) override final;
+    virtual void stepOver(ErrorString*) override final;
+    virtual void stepInto(ErrorString*) override final;
+    virtual void stepOut(ErrorString*) override final;
+    virtual void setPauseOnExceptions(ErrorString*, const String& pauseState) override final;
+    virtual void evaluateOnCallFrame(ErrorString*,
+        const String& callFrameId,
+        const String& expression,
+        const String* objectGroup,
+        const bool* includeCommandLineAPI,
+        const bool* doNotPauseOnExceptionsAndMuteConsole,
+        const bool* returnByValue,
+        const bool* generatePreview,
+        RefPtr<TypeBuilder::Runtime::RemoteObject>& result,
+        TypeBuilder::OptOutput<bool>* wasThrown,
+        RefPtr<TypeBuilder::Debugger::ExceptionDetails>&) override final;
+    virtual void compileScript(ErrorString*, const String& expression, const String& sourceURL, const int* executionContextId, TypeBuilder::OptOutput<TypeBuilder::Debugger::ScriptId>*, RefPtr<TypeBuilder::Debugger::ExceptionDetails>&) override;
+    virtual void runScript(ErrorString*, const TypeBuilder::Debugger::ScriptId&, const int* executionContextId, const String* objectGroup, const bool* doNotPauseOnExceptionsAndMuteConsole, RefPtr<TypeBuilder::Runtime::RemoteObject>& result, RefPtr<TypeBuilder::Debugger::ExceptionDetails>&) override;
+    virtual void setOverlayMessage(ErrorString*, const String*) override;
+    virtual void setVariableValue(ErrorString*, int in_scopeNumber, const String& in_variableName, const RefPtr<JSONObject>& in_newValue, const String* in_callFrame, const String* in_functionObjectId) override final;
+    virtual void skipStackFrames(ErrorString*, const String* pattern) override final;
+    virtual void setAsyncCallStackDepth(ErrorString*, int depth) override final;
+
+    void schedulePauseOnNextStatement(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data);
+    void didInstallTimer(ExecutionContext*, int timerId, int timeout, bool singleShot);
+    void didRemoveTimer(ExecutionContext*, int timerId);
+    bool willFireTimer(ExecutionContext*, int timerId);
+    void didFireTimer();
+    void didRequestAnimationFrame(Document*, int callbackId);
+    void didCancelAnimationFrame(Document*, int callbackId);
+    bool willFireAnimationFrame(Document*, int callbackId);
+    void didFireAnimationFrame();
+    void didEnqueueEvent(EventTarget*, Event*);
+    void didRemoveEvent(EventTarget*, Event*);
+    void willHandleEvent(EventTarget*, Event*, EventListener*, bool useCapture);
+    void didHandleEvent();
+    void didEnqueueMutationRecord(ExecutionContext*, MutationObserver*);
+    void didClearAllMutationRecords(ExecutionContext*, MutationObserver*);
+    void willDeliverMutationRecords(ExecutionContext*, MutationObserver*);
+    void didDeliverMutationRecords();
+    // void didPostExecutionContextTask(ExecutionContext*, ExecutionContextTask*);
+    // void didKillAllExecutionContextTasks(ExecutionContext*);
+    // void willPerformExecutionContextTask(ExecutionContext*, ExecutionContextTask*);
+    // void didPerformExecutionContextTask();
+    int traceAsyncOperationStarting(ExecutionContext*, const String& operationName, int prevOperationId = 0);
+    void traceAsyncOperationCompleted(ExecutionContext*, int operationId);
+    void traceAsyncOperationCompletedCallbackStarting(ExecutionContext*, int operationId);
+    void traceAsyncCallbackStarting(ExecutionContext*, int operationId);
+    void traceAsyncCallbackCompleted();
+    bool canBreakProgram();
+    void breakProgram(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data);
+    void scriptExecutionBlockedByCSP(const String& directiveText);
+
+    class Listener {
+    public:
+        virtual ~Listener() { }
+        virtual void debuggerWasEnabled() = 0;
+        virtual void debuggerWasDisabled() = 0;
+        virtual void stepInto() = 0;
+        virtual void didPause() = 0;
+    };
+    void setListener(Listener* listener) { m_listener = listener; }
+
+    bool enabled();
+
+    virtual ScriptDebugServer& scriptDebugServer() = 0;
+
+    void setBreakpoint(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource, const String& condition = String());
+    void removeBreakpoint(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource);
+
+    PassRefPtr<ScriptAsyncCallStack> currentAsyncStackTraceForConsole();
+
+protected:
+    explicit InspectorDebuggerAgent(InjectedScriptManager*);
+
+    virtual void startListeningScriptDebugServer() = 0;
+    virtual void stopListeningScriptDebugServer() = 0;
+    virtual void muteConsole() = 0;
+    virtual void unmuteConsole() = 0;
+    InjectedScriptManager* injectedScriptManager() { return m_injectedScriptManager; }
+    virtual InjectedScript injectedScriptForEval(ErrorString*, const int* executionContextId) = 0;
+
+    virtual void enable();
+    virtual void disable();
+    virtual SkipPauseRequest didPause(ScriptState*, const ScriptValue& callFrames, const ScriptValue& exception, const Vector<String>& hitBreakpoints) override final;
+    virtual void didContinue() override final;
+    void reset();
+    void pageDidCommitLoad();
+
+private:
+    bool shouldSkipInspectorInternals();
+    SkipPauseRequest shouldSkipExceptionPause();
+    SkipPauseRequest shouldSkipStepPause();
+    bool isTopCallFrameInFramework();
+
+    void cancelPauseOnNextStatement();
+    void addMessageToConsole(MessageSource, MessageType);
+
+    PassRefPtr<TypeBuilder::Array<TypeBuilder::Debugger::CallFrame> > currentCallFrames();
+    PassRefPtr<TypeBuilder::Debugger::StackTrace> currentAsyncStackTrace();
+
+    virtual void didParseSource(const String& scriptId, const Script&, CompileResult) override final;
+    virtual void didReceiveV8AsyncTaskEvent(ExecutionContext*, const String& eventType, const String& eventName, int id) override final;
+    virtual void didReceiveV8PromiseEvent(ScriptState*, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status) override final;
+
+    void setPauseOnExceptionsImpl(ErrorString*, int);
+
+    PassRefPtr<TypeBuilder::Debugger::Location> resolveBreakpoint(const String& breakpointId, const String& scriptId, const ScriptBreakpoint&, BreakpointSource);
+    void removeBreakpoint(const String& breakpointId);
+    void clear();
+    bool assertPaused(ErrorString*);
+    void clearBreakDetails();
+
+    String sourceMapURLForScript(const Script&, CompileResult);
+
+    PassRefPtr<JavaScriptCallFrame> topCallFrameSkipUnknownSources();
+    String scriptURL(JavaScriptCallFrame*);
+    AsyncCallStackTracker& asyncCallStackTracker() { return *m_asyncCallStackTracker; };
+
+    typedef HashMap<String, Script> ScriptsMap;
+    typedef HashMap<String, Vector<String> > BreakpointIdToDebugServerBreakpointIdsMap;
+    typedef HashMap<String, std::pair<String, BreakpointSource> > DebugServerBreakpointToBreakpointIdAndSourceMap;
+
+    RawPtr<InjectedScriptManager> m_injectedScriptManager;
+    InspectorFrontend::Debugger* m_frontend;
+    RefPtr<ScriptState> m_pausedScriptState;
+    ScriptValue m_currentCallStack;
+    ScriptsMap m_scripts;
+    BreakpointIdToDebugServerBreakpointIdsMap m_breakpointIdToDebugServerBreakpointIds;
+    DebugServerBreakpointToBreakpointIdAndSourceMap m_serverBreakpoints;
+    String m_continueToLocationBreakpointId;
+    InspectorFrontend::Debugger::Reason::Enum m_breakReason;
+    RefPtr<JSONObject> m_breakAuxData;
+    bool m_javaScriptPauseScheduled;
+    bool m_debuggerStepScheduled;
+    bool m_steppingFromFramework;
+    bool m_pausingOnNativeEvent;
+    RawPtr<Listener> m_listener;
+
+    int m_skippedStepInCount;
+    int m_minFrameCountForSkip;
+    bool m_skipAllPauses;
+    OwnPtr<ScriptRegexp> m_cachedSkipStackRegExp;
+    OwnPtr<AsyncCallStackTracker> m_asyncCallStackTracker;
+    PromiseTracker m_promiseTracker;
+};
+
+} // namespace blink
+
+
+#endif // !defined(InspectorDebuggerAgent_h)
diff --git a/engine/core/inspector/InspectorFrontendChannel.h b/engine/core/inspector/InspectorFrontendChannel.h
new file mode 100644
index 00000000000..bd45f78bfbf
--- /dev/null
+++ b/engine/core/inspector/InspectorFrontendChannel.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2011 Google Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 COMPUTER, INC. OR
+ * 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.
+ */
+
+#ifndef InspectorFrontendChannel_h
+#define InspectorFrontendChannel_h
+
+#include "platform/JSONValues.h"
+#include "wtf/Forward.h"
+
+namespace blink {
+
+class InspectorFrontendChannel {
+public:
+    virtual ~InspectorFrontendChannel() { }
+    virtual void sendMessageToFrontend(PassRefPtr<JSONObject> message) = 0;
+    virtual void flush() = 0;
+};
+
+} // namespace blink
+
+#endif // !defined(InspectorFrontendChannel_h)
\ No newline at end of file
diff --git a/engine/core/inspector/InspectorState.cpp b/engine/core/inspector/InspectorState.cpp
new file mode 100644
index 00000000000..ca739e36732
--- /dev/null
+++ b/engine/core/inspector/InspectorState.cpp
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GOOGLE 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 "core/inspector/InspectorState.h"
+
+// #include "core/inspector/InspectorStateClient.h"
+#include "core/inspector/JSONParser.h"
+#include "wtf/PassOwnPtr.h"
+
+namespace blink {
+
+InspectorState::InspectorState(InspectorStateUpdateListener* listener, PassRefPtr<JSONObject> properties)
+    : m_listener(listener)
+    , m_properties(properties)
+{
+}
+
+void InspectorState::updateCookie()
+{
+    if (m_listener)
+        m_listener->inspectorStateUpdated();
+}
+
+void InspectorState::setFromCookie(PassRefPtr<JSONObject> properties)
+{
+    m_properties = properties;
+}
+
+void InspectorState::setValue(const String& propertyName, PassRefPtr<JSONValue> value)
+{
+    m_properties->setValue(propertyName, value);
+    updateCookie();
+}
+
+void InspectorState::remove(const String& propertyName)
+{
+    m_properties->remove(propertyName);
+    updateCookie();
+}
+
+bool InspectorState::getBoolean(const String& propertyName)
+{
+    JSONObject::iterator it = m_properties->find(propertyName);
+    bool value = false;
+    if (it != m_properties->end())
+        it->value->asBoolean(&value);
+    return value;
+}
+
+String InspectorState::getString(const String& propertyName)
+{
+    JSONObject::iterator it = m_properties->find(propertyName);
+    String value;
+    if (it != m_properties->end())
+        it->value->asString(&value);
+    return value;
+}
+
+long InspectorState::getLong(const String& propertyName)
+{
+    return getLong(propertyName, 0);
+}
+
+
+long InspectorState::getLong(const String& propertyName, long defaultValue)
+{
+    JSONObject::iterator it = m_properties->find(propertyName);
+    long value = defaultValue;
+    if (it != m_properties->end())
+        it->value->asNumber(&value);
+    return value;
+}
+
+double InspectorState::getDouble(const String& propertyName)
+{
+    return getDouble(propertyName, 0);
+}
+
+double InspectorState::getDouble(const String& propertyName, double defaultValue)
+{
+    JSONObject::iterator it = m_properties->find(propertyName);
+    double value = defaultValue;
+    if (it != m_properties->end())
+        it->value->asNumber(&value);
+    return value;
+}
+
+PassRefPtr<JSONObject> InspectorState::getObject(const String& propertyName)
+{
+    JSONObject::iterator it = m_properties->find(propertyName);
+    if (it == m_properties->end()) {
+        m_properties->setObject(propertyName, JSONObject::create());
+        it = m_properties->find(propertyName);
+    }
+    return it->value->asObject();
+}
+
+InspectorState* InspectorCompositeState::createAgentState(const String& agentName)
+{
+    ASSERT(m_stateObject->find(agentName) == m_stateObject->end());
+    ASSERT(m_inspectorStateMap.find(agentName) == m_inspectorStateMap.end());
+    RefPtr<JSONObject> stateProperties = JSONObject::create();
+    m_stateObject->setObject(agentName, stateProperties);
+    OwnPtr<InspectorState> statePtr = adoptPtr(new InspectorState(this, stateProperties));
+    InspectorState* state = statePtr.get();
+    m_inspectorStateMap.add(agentName, statePtr.release());
+    return state;
+}
+
+void InspectorCompositeState::loadFromCookie(const String& inspectorCompositeStateCookie)
+{
+    RefPtr<JSONValue> cookie = parseJSON(inspectorCompositeStateCookie);
+    if (cookie)
+        m_stateObject = cookie->asObject();
+    if (!m_stateObject)
+        m_stateObject = JSONObject::create();
+
+    InspectorStateMap::iterator end = m_inspectorStateMap.end();
+    for (InspectorStateMap::iterator it = m_inspectorStateMap.begin(); it != end; ++it) {
+        RefPtr<JSONObject> agentStateObject = m_stateObject->getObject(it->key);
+        if (!agentStateObject) {
+            agentStateObject = JSONObject::create();
+            m_stateObject->setObject(it->key, agentStateObject);
+        }
+        it->value->setFromCookie(agentStateObject);
+    }
+}
+
+void InspectorCompositeState::mute()
+{
+    m_isMuted = true;
+}
+
+void InspectorCompositeState::unmute()
+{
+    m_isMuted = false;
+}
+
+void InspectorCompositeState::inspectorStateUpdated()
+{
+    // FIXME(Sky): tell clients?
+}
+
+} // namespace blink
+
diff --git a/engine/core/inspector/InspectorState.h b/engine/core/inspector/InspectorState.h
new file mode 100644
index 00000000000..e1ea09184ec
--- /dev/null
+++ b/engine/core/inspector/InspectorState.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+#ifndef InspectorState_h
+#define InspectorState_h
+
+
+#include "platform/JSONValues.h"
+#include "platform/heap/Handle.h"
+#include "wtf/HashMap.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+class InspectorStateClient;
+
+class InspectorStateUpdateListener {
+public:
+    virtual ~InspectorStateUpdateListener() { }
+    virtual void inspectorStateUpdated() = 0;
+};
+
+class InspectorState final {
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    InspectorState(InspectorStateUpdateListener*, PassRefPtr<JSONObject>);
+
+    void loadFromCookie(const String& inspectorStateCookie);
+
+    void mute();
+    void unmute();
+
+    bool getBoolean(const String& propertyName);
+    String getString(const String& propertyName);
+    long getLong(const String& propertyName);
+    long getLong(const String& propertyName, long defaultValue);
+    double getDouble(const String& propertyName);
+    double getDouble(const String& propertyName, double defaultValue);
+    PassRefPtr<JSONObject> getObject(const String& propertyName);
+
+    void setBoolean(const String& propertyName, bool value) { setValue(propertyName, JSONBasicValue::create(value)); }
+    void setString(const String& propertyName, const String& value) { setValue(propertyName, JSONString::create(value)); }
+    void setLong(const String& propertyName, long value) { setValue(propertyName, JSONBasicValue::create((double)value)); }
+    void setDouble(const String& propertyName, double value) { setValue(propertyName, JSONBasicValue::create(value)); }
+    void setObject(const String& propertyName, PassRefPtr<JSONObject> value) { setValue(propertyName, value); }
+
+    void remove(const String&);
+
+private:
+    void updateCookie();
+    void setValue(const String& propertyName, PassRefPtr<JSONValue>);
+
+    // Gets called from InspectorCompositeState::loadFromCookie().
+    void setFromCookie(PassRefPtr<JSONObject>);
+
+    friend class InspectorCompositeState;
+
+    RawPtr<InspectorStateUpdateListener> m_listener;
+    RefPtr<JSONObject> m_properties;
+};
+
+class InspectorCompositeState final : public InspectorStateUpdateListener {
+public:
+    InspectorCompositeState(InspectorStateClient* inspectorClient)
+        : m_stateObject(JSONObject::create())
+        , m_isMuted(false)
+    {
+    }
+    virtual ~InspectorCompositeState() { }
+
+    void mute();
+    void unmute();
+
+    InspectorState* createAgentState(const String&);
+    void loadFromCookie(const String&);
+
+private:
+    typedef HashMap<String, OwnPtr<InspectorState> > InspectorStateMap;
+
+    // From InspectorStateUpdateListener.
+    virtual void inspectorStateUpdated() override;
+
+    RefPtr<JSONObject> m_stateObject;
+    bool m_isMuted;
+    InspectorStateMap m_inspectorStateMap;
+};
+
+} // namespace blink
+
+#endif // !defined(InspectorState_h)
diff --git a/engine/core/inspector/InspectorTraceEvents.cpp b/engine/core/inspector/InspectorTraceEvents.cpp
index 2fe53adf5d4..56bf3d69863 100644
--- a/engine/core/inspector/InspectorTraceEvents.cpp
+++ b/engine/core/inspector/InspectorTraceEvents.cpp
@@ -10,6 +10,7 @@
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameView.h"
+#include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectorNodeIds.h"
@@ -17,11 +18,11 @@
 #include "core/page/Page.h"
 #include "core/rendering/RenderImage.h"
 #include "core/rendering/RenderObject.h"
-#include "platform/JSONValues.h"
-#include "platform/TracedValue.h"
 #include "platform/graphics/GraphicsLayer.h"
+#include "platform/JSONValues.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
+#include "platform/TracedValue.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/Vector.h"
 #include <inttypes.h>
@@ -158,7 +159,7 @@ static LocalFrame* frameForExecutionContext(ExecutionContext* context)
 {
     LocalFrame* frame = 0;
     if (context->isDocument())
-        frame = toDocument(context)->frame();
+        frame = context->executingWindow()->frame();
     return frame;
 }
 
diff --git a/engine/core/inspector/InstrumentingAgents.h b/engine/core/inspector/InstrumentingAgents.h
new file mode 100644
index 00000000000..4e5ff02da06
--- /dev/null
+++ b/engine/core/inspector/InstrumentingAgents.h
@@ -0,0 +1,33 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef InstrumentingAgents_h
+#define InstrumentingAgents_h
+
+#include "wtf/Noncopyable.h"
+
+namespace blink {
+
+// This is a stub.
+// This allows one agent to talk to another.
+
+class InspectorDebuggerAgent;
+
+class InstrumentingAgents {
+  WTF_MAKE_NONCOPYABLE(InstrumentingAgents);
+public:
+  InstrumentingAgents(InspectorDebuggerAgent* agent) : debug_agent_(agent) {}
+
+  InspectorDebuggerAgent* inspectorDebuggerAgent() {
+      return debug_agent_;
+  }
+
+private:
+
+  InspectorDebuggerAgent* debug_agent_;
+};
+
+} // namespace blink
+
+#endif // InstrumentingAgents_h
diff --git a/engine/core/inspector/JSONParser.cpp b/engine/core/inspector/JSONParser.cpp
new file mode 100644
index 00000000000..1523888fb75
--- /dev/null
+++ b/engine/core/inspector/JSONParser.cpp
@@ -0,0 +1,478 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "core/inspector/JSONParser.h"
+
+#include "platform/JSONValues.h"
+#include "wtf/text/StringBuilder.h"
+
+namespace blink {
+
+namespace {
+
+const int stackLimit = 1000;
+
+enum Token {
+    ObjectBegin,
+    ObjectEnd,
+    ArrayBegin,
+    ArrayEnd,
+    StringLiteral,
+    Number,
+    BoolTrue,
+    BoolFalse,
+    NullToken,
+    ListSeparator,
+    ObjectPairSeparator,
+    InvalidToken,
+};
+
+const char* const nullString = "null";
+const char* const trueString = "true";
+const char* const falseString = "false";
+
+template<typename CharType>
+bool parseConstToken(const CharType* start, const CharType* end, const CharType** tokenEnd, const char* token)
+{
+    while (start < end && *token != '\0' && *start++ == *token++) { }
+    if (*token != '\0')
+        return false;
+    *tokenEnd = start;
+    return true;
+}
+
+template<typename CharType>
+bool readInt(const CharType* start, const CharType* end, const CharType** tokenEnd, bool canHaveLeadingZeros)
+{
+    if (start == end)
+        return false;
+    bool haveLeadingZero = '0' == *start;
+    int length = 0;
+    while (start < end && '0' <= *start && *start <= '9') {
+        ++start;
+        ++length;
+    }
+    if (!length)
+        return false;
+    if (!canHaveLeadingZeros && length > 1 && haveLeadingZero)
+        return false;
+    *tokenEnd = start;
+    return true;
+}
+
+template<typename CharType>
+bool parseNumberToken(const CharType* start, const CharType* end, const CharType** tokenEnd)
+{
+    // We just grab the number here. We validate the size in DecodeNumber.
+    // According to RFC4627, a valid number is: [minus] int [frac] [exp]
+    if (start == end)
+        return false;
+    CharType c = *start;
+    if ('-' == c)
+        ++start;
+
+    if (!readInt(start, end, &start, false))
+        return false;
+    if (start == end) {
+        *tokenEnd = start;
+        return true;
+    }
+
+    // Optional fraction part
+    c = *start;
+    if ('.' == c) {
+        ++start;
+        if (!readInt(start, end, &start, true))
+            return false;
+        if (start == end) {
+            *tokenEnd = start;
+            return true;
+        }
+        c = *start;
+    }
+
+    // Optional exponent part
+    if ('e' == c || 'E' == c) {
+        ++start;
+        if (start == end)
+            return false;
+        c = *start;
+        if ('-' == c || '+' == c) {
+            ++start;
+            if (start == end)
+                return false;
+        }
+        if (!readInt(start, end, &start, true))
+            return false;
+    }
+
+    *tokenEnd = start;
+    return true;
+}
+
+template<typename CharType>
+bool readHexDigits(const CharType* start, const CharType* end, const CharType** tokenEnd, int digits)
+{
+    if (end - start < digits)
+        return false;
+    for (int i = 0; i < digits; ++i) {
+        CharType c = *start++;
+        if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')))
+            return false;
+    }
+    *tokenEnd = start;
+    return true;
+}
+
+template<typename CharType>
+bool parseStringToken(const CharType* start, const CharType* end, const CharType** tokenEnd)
+{
+    while (start < end) {
+        CharType c = *start++;
+        if ('\\' == c) {
+            c = *start++;
+            // Make sure the escaped char is valid.
+            switch (c) {
+            case 'x':
+                if (!readHexDigits(start, end, &start, 2))
+                    return false;
+                break;
+            case 'u':
+                if (!readHexDigits(start, end, &start, 4))
+                    return false;
+                break;
+            case '\\':
+            case '/':
+            case 'b':
+            case 'f':
+            case 'n':
+            case 'r':
+            case 't':
+            case 'v':
+            case '"':
+                break;
+            default:
+                return false;
+            }
+        } else if ('"' == c) {
+            *tokenEnd = start;
+            return true;
+        }
+    }
+    return false;
+}
+
+template<typename CharType>
+Token parseToken(const CharType* start, const CharType* end, const CharType** tokenStart, const CharType** tokenEnd)
+{
+    while (start < end && isSpaceOrNewline(*start))
+        ++start;
+
+    if (start == end)
+        return InvalidToken;
+
+    *tokenStart = start;
+
+    switch (*start) {
+    case 'n':
+        if (parseConstToken(start, end, tokenEnd, nullString))
+            return NullToken;
+        break;
+    case 't':
+        if (parseConstToken(start, end, tokenEnd, trueString))
+            return BoolTrue;
+        break;
+    case 'f':
+        if (parseConstToken(start, end, tokenEnd, falseString))
+            return BoolFalse;
+        break;
+    case '[':
+        *tokenEnd = start + 1;
+        return ArrayBegin;
+    case ']':
+        *tokenEnd = start + 1;
+        return ArrayEnd;
+    case ',':
+        *tokenEnd = start + 1;
+        return ListSeparator;
+    case '{':
+        *tokenEnd = start + 1;
+        return ObjectBegin;
+    case '}':
+        *tokenEnd = start + 1;
+        return ObjectEnd;
+    case ':':
+        *tokenEnd = start + 1;
+        return ObjectPairSeparator;
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '-':
+        if (parseNumberToken(start, end, tokenEnd))
+            return Number;
+        break;
+    case '"':
+        if (parseStringToken(start + 1, end, tokenEnd))
+            return StringLiteral;
+        break;
+    }
+    return InvalidToken;
+}
+
+template<typename CharType>
+inline int hexToInt(CharType c)
+{
+    if ('0' <= c && c <= '9')
+        return c - '0';
+    if ('A' <= c && c <= 'F')
+        return c - 'A' + 10;
+    if ('a' <= c && c <= 'f')
+        return c - 'a' + 10;
+    ASSERT_NOT_REACHED();
+    return 0;
+}
+
+template<typename CharType>
+bool decodeString(const CharType* start, const CharType* end, StringBuilder* output)
+{
+    while (start < end) {
+        UChar c = *start++;
+        if ('\\' != c) {
+            output->append(c);
+            continue;
+        }
+        c = *start++;
+        switch (c) {
+        case '"':
+        case '/':
+        case '\\':
+            break;
+        case 'b':
+            c = '\b';
+            break;
+        case 'f':
+            c = '\f';
+            break;
+        case 'n':
+            c = '\n';
+            break;
+        case 'r':
+            c = '\r';
+            break;
+        case 't':
+            c = '\t';
+            break;
+        case 'v':
+            c = '\v';
+            break;
+        case 'x':
+            c = (hexToInt(*start) << 4) +
+                hexToInt(*(start + 1));
+            start += 2;
+            break;
+        case 'u':
+            c = (hexToInt(*start) << 12) +
+                (hexToInt(*(start + 1)) << 8) +
+                (hexToInt(*(start + 2)) << 4) +
+                hexToInt(*(start + 3));
+            start += 4;
+            break;
+        default:
+            return false;
+        }
+        output->append(c);
+    }
+    return true;
+}
+
+template<typename CharType>
+bool decodeString(const CharType* start, const CharType* end, String* output)
+{
+    if (start == end) {
+        *output = "";
+        return true;
+    }
+    if (start > end)
+        return false;
+    StringBuilder buffer;
+    buffer.reserveCapacity(end - start);
+    if (!decodeString(start, end, &buffer))
+        return false;
+    *output = buffer.toString();
+    return true;
+}
+
+template<typename CharType>
+PassRefPtr<JSONValue> buildValue(const CharType* start, const CharType* end, const CharType** valueTokenEnd, int depth)
+{
+    if (depth > stackLimit)
+        return nullptr;
+
+    RefPtr<JSONValue> result;
+    const CharType* tokenStart;
+    const CharType* tokenEnd;
+    Token token = parseToken(start, end, &tokenStart, &tokenEnd);
+    switch (token) {
+    case InvalidToken:
+        return nullptr;
+    case NullToken:
+        result = JSONValue::null();
+        break;
+    case BoolTrue:
+        result = JSONBasicValue::create(true);
+        break;
+    case BoolFalse:
+        result = JSONBasicValue::create(false);
+        break;
+    case Number: {
+        bool ok;
+        double value = charactersToDouble(tokenStart, tokenEnd - tokenStart, &ok);
+        if (!ok)
+            return nullptr;
+        result = JSONBasicValue::create(value);
+        break;
+    }
+    case StringLiteral: {
+        String value;
+        bool ok = decodeString(tokenStart + 1, tokenEnd - 1, &value);
+        if (!ok)
+            return nullptr;
+        result = JSONString::create(value);
+        break;
+    }
+    case ArrayBegin: {
+        RefPtr<JSONArray> array = JSONArray::create();
+        start = tokenEnd;
+        token = parseToken(start, end, &tokenStart, &tokenEnd);
+        while (token != ArrayEnd) {
+            RefPtr<JSONValue> arrayNode = buildValue(start, end, &tokenEnd, depth + 1);
+            if (!arrayNode)
+                return nullptr;
+            array->pushValue(arrayNode);
+
+            // After a list value, we expect a comma or the end of the list.
+            start = tokenEnd;
+            token = parseToken(start, end, &tokenStart, &tokenEnd);
+            if (token == ListSeparator) {
+                start = tokenEnd;
+                token = parseToken(start, end, &tokenStart, &tokenEnd);
+                if (token == ArrayEnd)
+                    return nullptr;
+            } else if (token != ArrayEnd) {
+                // Unexpected value after list value. Bail out.
+                return nullptr;
+            }
+        }
+        if (token != ArrayEnd)
+            return nullptr;
+        result = array.release();
+        break;
+    }
+    case ObjectBegin: {
+        RefPtr<JSONObject> object = JSONObject::create();
+        start = tokenEnd;
+        token = parseToken(start, end, &tokenStart, &tokenEnd);
+        while (token != ObjectEnd) {
+            if (token != StringLiteral)
+                return nullptr;
+            String key;
+            if (!decodeString(tokenStart + 1, tokenEnd - 1, &key))
+                return nullptr;
+            start = tokenEnd;
+
+            token = parseToken(start, end, &tokenStart, &tokenEnd);
+            if (token != ObjectPairSeparator)
+                return nullptr;
+            start = tokenEnd;
+
+            RefPtr<JSONValue> value = buildValue(start, end, &tokenEnd, depth + 1);
+            if (!value)
+                return nullptr;
+            object->setValue(key, value);
+            start = tokenEnd;
+
+            // After a key/value pair, we expect a comma or the end of the
+            // object.
+            token = parseToken(start, end, &tokenStart, &tokenEnd);
+            if (token == ListSeparator) {
+                start = tokenEnd;
+                token = parseToken(start, end, &tokenStart, &tokenEnd);
+                if (token == ObjectEnd)
+                    return nullptr;
+            } else if (token != ObjectEnd) {
+                // Unexpected value after last object value. Bail out.
+                return nullptr;
+            }
+        }
+        if (token != ObjectEnd)
+            return nullptr;
+        result = object.release();
+        break;
+    }
+
+    default:
+        // We got a token that's not a value.
+        return nullptr;
+    }
+    *valueTokenEnd = tokenEnd;
+    return result.release();
+}
+
+template<typename CharType>
+PassRefPtr<JSONValue> parseJSONInternal(const CharType* start, unsigned length)
+{
+    const CharType* end = start + length;
+    const CharType *tokenEnd;
+    RefPtr<JSONValue> value = buildValue(start, end, &tokenEnd, 0);
+    if (!value || tokenEnd != end)
+        return nullptr;
+    return value.release();
+}
+
+} // anonymous namespace
+
+PassRefPtr<JSONValue> parseJSON(const String& json)
+{
+    if (json.isEmpty())
+        return nullptr;
+    if (json.is8Bit())
+        return parseJSONInternal(json.characters8(), json.length());
+    return parseJSONInternal(json.characters16(), json.length());
+}
+
+} // namespace blink
diff --git a/engine/core/inspector/JSONParser.h b/engine/core/inspector/JSONParser.h
new file mode 100644
index 00000000000..8c4870fed37
--- /dev/null
+++ b/engine/core/inspector/JSONParser.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2009 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+#ifndef JSONParser_h
+#define JSONParser_h
+
+#include "wtf/PassRefPtr.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+class JSONValue;
+
+PassRefPtr<JSONValue> parseJSON(const String& json);
+
+} // namespace blink
+
+#endif // !defined(JSONParser_h)
diff --git a/engine/core/inspector/PageDebuggerAgent.cpp b/engine/core/inspector/PageDebuggerAgent.cpp
new file mode 100644
index 00000000000..13d45cf536e
--- /dev/null
+++ b/engine/core/inspector/PageDebuggerAgent.cpp
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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 "core/inspector/PageDebuggerAgent.h"
+
+#include "bindings/core/v8/DOMWrapperWorld.h"
+#include "bindings/core/v8/ScriptController.h"
+#include "bindings/core/v8/ScriptSourceCode.h"
+#include "core/frame/FrameConsole.h"
+#include "core/frame/LocalFrame.h"
+#include "core/page/Page.h"
+
+namespace blink {
+
+PassOwnPtr<PageDebuggerAgent> PageDebuggerAgent::create(PageScriptDebugServer* pageScriptDebugServer, Page* page, InjectedScriptManager* injectedScriptManager)
+{
+    return adoptPtr(new PageDebuggerAgent(pageScriptDebugServer, page, injectedScriptManager));
+}
+
+PageDebuggerAgent::PageDebuggerAgent(PageScriptDebugServer* pageScriptDebugServer, Page* page, InjectedScriptManager* injectedScriptManager)
+    : InspectorDebuggerAgent(injectedScriptManager)
+    , m_pageScriptDebugServer(pageScriptDebugServer)
+    , m_page(page)
+{
+}
+
+PageDebuggerAgent::~PageDebuggerAgent()
+{
+}
+
+void PageDebuggerAgent::startListeningScriptDebugServer()
+{
+    scriptDebugServer().addListener(this, m_page);
+}
+
+void PageDebuggerAgent::stopListeningScriptDebugServer()
+{
+    scriptDebugServer().removeListener(this, m_page);
+}
+
+PageScriptDebugServer& PageDebuggerAgent::scriptDebugServer()
+{
+    return *m_pageScriptDebugServer;
+}
+
+void PageDebuggerAgent::muteConsole()
+{
+    FrameConsole::mute();
+}
+
+void PageDebuggerAgent::unmuteConsole()
+{
+    FrameConsole::unmute();
+}
+
+InjectedScript PageDebuggerAgent::injectedScriptForEval(ErrorString* errorString, const int* executionContextId)
+{
+    if (!executionContextId) {
+        ScriptState* scriptState = ScriptState::forMainWorld(m_page->mainFrame());
+        return injectedScriptManager()->injectedScriptFor(scriptState);
+    }
+    InjectedScript injectedScript = injectedScriptManager()->injectedScriptForId(*executionContextId);
+    if (injectedScript.isEmpty())
+        *errorString = "Execution context with given id not found.";
+    return injectedScript;
+}
+
+void PageDebuggerAgent::setOverlayMessage(ErrorString*, const String* message)
+{
+    if (message)
+        printf("OVERLAY MESSAGE: %s\n", message->ascii().data());
+    else
+        printf("OVERLAY REMOVED\n");
+}
+
+void PageDebuggerAgent::didClearDocumentOfWindowObject(LocalFrame* frame)
+{
+    reset();
+    scriptDebugServer().setPreprocessorSource(String());
+}
+
+} // namespace blink
diff --git a/engine/core/inspector/PageDebuggerAgent.h b/engine/core/inspector/PageDebuggerAgent.h
new file mode 100644
index 00000000000..97530e37a27
--- /dev/null
+++ b/engine/core/inspector/PageDebuggerAgent.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
+ * OWNER OR 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.
+ */
+
+#ifndef PageDebuggerAgent_h
+#define PageDebuggerAgent_h
+
+#include "bindings/core/v8/PageScriptDebugServer.h"
+#include "core/inspector/InspectorDebuggerAgent.h"
+
+namespace blink {
+
+class DocumentLoader;
+class InspectorPageAgent;
+class Page;
+class PageScriptDebugServer;
+class ScriptSourceCode;
+
+class PageDebuggerAgent final
+    : public InspectorDebuggerAgent {
+    WTF_MAKE_NONCOPYABLE(PageDebuggerAgent);
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    static PassOwnPtr<PageDebuggerAgent> create(PageScriptDebugServer*, Page*, InjectedScriptManager*);
+    virtual ~PageDebuggerAgent();
+
+    void didClearDocumentOfWindowObject(LocalFrame*);
+
+private:
+    virtual void startListeningScriptDebugServer() override;
+    virtual void stopListeningScriptDebugServer() override;
+    virtual PageScriptDebugServer& scriptDebugServer() override;
+    virtual void muteConsole() override;
+    virtual void unmuteConsole() override;
+
+    virtual InjectedScript injectedScriptForEval(ErrorString*, const int* executionContextId) override;
+    virtual void setOverlayMessage(ErrorString*, const String*) override;
+
+    PageDebuggerAgent(PageScriptDebugServer*, Page*, InjectedScriptManager*);
+    PageScriptDebugServer* m_pageScriptDebugServer;
+    Page* m_page;
+};
+
+} // namespace blink
+
+
+#endif // !defined(PageDebuggerAgent_h)
diff --git a/engine/core/inspector/PromiseTracker.cpp b/engine/core/inspector/PromiseTracker.cpp
new file mode 100644
index 00000000000..42cea2b1a6c
--- /dev/null
+++ b/engine/core/inspector/PromiseTracker.cpp
@@ -0,0 +1,147 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "core/inspector/PromiseTracker.h"
+
+#include "bindings/core/v8/ScopedPersistent.h"
+#include "bindings/core/v8/ScriptCallStackFactory.h"
+#include "bindings/core/v8/ScriptState.h"
+#include "wtf/PassOwnPtr.h"
+#include "wtf/WeakPtr.h"
+
+namespace blink {
+
+class PromiseTracker::PromiseData : public RefCounted<PromiseData> {
+public:
+    PromiseData(v8::Isolate* isolate, int promiseHash, v8::Handle<v8::Object> promise)
+        : m_promiseHash(promiseHash)
+        , m_promise(isolate, promise)
+        , m_status(0)
+        , m_weakPtrFactory(this)
+        {
+    }
+
+    int promiseHash() const { return m_promiseHash; }
+    ScopedPersistent<v8::Object>& promise() { return m_promise; }
+
+private:
+    friend class PromiseTracker;
+
+    int m_promiseHash;
+
+    ScopedPersistent<v8::Object> m_promise;
+    ScriptCallFrame m_callFrame;
+    ScopedPersistent<v8::Object> m_parentPromise;
+    int m_status;
+
+    WeakPtrFactory<PromiseData> m_weakPtrFactory;
+};
+
+static int indexOf(PromiseTracker::PromiseDataVector* vector, const ScopedPersistent<v8::Object>& promise)
+{
+    for (size_t index = 0; index < vector->size(); ++index) {
+        if (vector->at(index)->promise() == promise)
+            return index;
+    }
+    return -1;
+}
+
+namespace {
+
+class PromiseDataWrapper {
+public:
+    PromiseDataWrapper(WeakPtr<PromiseTracker::PromiseData> data, PromiseTracker::PromiseDataMap* map)
+        : m_data(data)
+        , m_promiseDataMap(map)
+    {
+    }
+
+    static void didRemovePromise(const v8::WeakCallbackData<v8::Object, PromiseDataWrapper>& data)
+    {
+        OwnPtr<PromiseDataWrapper> wrapper = adoptPtr(data.GetParameter());
+        WeakPtr<PromiseTracker::PromiseData> promiseData = wrapper->m_data;
+        if (!promiseData)
+            return;
+        PromiseTracker::PromiseDataMap* map = wrapper->m_promiseDataMap;
+        int promiseHash = promiseData->promiseHash();
+        PromiseTracker::PromiseDataVector* vector = &map->find(promiseHash)->value;
+        int index = indexOf(vector, promiseData->promise());
+        ASSERT(index >= 0);
+        vector->remove(index);
+        if (vector->size() == 0)
+            map->remove(promiseHash);
+    }
+
+private:
+    WeakPtr<PromiseTracker::PromiseData> m_data;
+    PromiseTracker::PromiseDataMap* m_promiseDataMap;
+};
+
+}
+
+PromiseTracker::PromiseTracker()
+    : m_isEnabled(false)
+{
+}
+
+PromiseTracker::~PromiseTracker()
+{
+}
+
+void PromiseTracker::enable()
+{
+    m_isEnabled = true;
+}
+
+void PromiseTracker::disable()
+{
+    m_isEnabled = false;
+    clear();
+}
+
+void PromiseTracker::clear()
+{
+    m_promiseDataMap.clear();
+}
+
+void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status)
+{
+    ASSERT(isEnabled());
+
+    int promiseHash = promise->GetIdentityHash();
+    PromiseDataVector* vector;
+    PromiseDataMap::iterator it = m_promiseDataMap.find(promiseHash);
+    if (it != m_promiseDataMap.end())
+        vector = &it->value;
+    else
+        vector = &m_promiseDataMap.add(promiseHash, PromiseDataVector()).storedValue->value;
+
+    v8::Isolate* isolate = scriptState->isolate();
+    RefPtr<PromiseData> data;
+    int index = indexOf(vector, ScopedPersistent<v8::Object>(isolate, promise));
+    if (index == -1) {
+        data = adoptRef(new PromiseData(isolate, promiseHash, promise));
+        OwnPtr<PromiseDataWrapper> wrapper = adoptPtr(new PromiseDataWrapper(data->m_weakPtrFactory.createWeakPtr(), &m_promiseDataMap));
+        data->m_promise.setWeak(wrapper.leakPtr(), &PromiseDataWrapper::didRemovePromise);
+        vector->append(data);
+    } else {
+        data = vector->at(index);
+    }
+
+    if (!parentPromise.IsEmpty()) {
+        ASSERT(parentPromise->IsObject());
+        data->m_parentPromise.set(isolate, parentPromise->ToObject());
+    } else {
+        data->m_status = status;
+        if (!status) {
+            v8::Handle<v8::StackTrace> stackTrace(v8::StackTrace::CurrentStackTrace(isolate, 1));
+            RefPtr<ScriptCallStack> stack = createScriptCallStack(stackTrace, 1, isolate);
+            if (stack->size())
+                data->m_callFrame = stack->at(0);
+        }
+    }
+}
+
+} // namespace blink
diff --git a/engine/core/inspector/PromiseTracker.h b/engine/core/inspector/PromiseTracker.h
new file mode 100644
index 00000000000..ffb6bd475f3
--- /dev/null
+++ b/engine/core/inspector/PromiseTracker.h
@@ -0,0 +1,44 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef PromiseTracker_h
+#define PromiseTracker_h
+
+#include "wtf/HashMap.h"
+#include "wtf/Noncopyable.h"
+#include "wtf/RefPtr.h"
+#include "wtf/Vector.h"
+#include <v8.h>
+
+namespace blink {
+
+class ScriptState;
+
+class PromiseTracker {
+    WTF_MAKE_NONCOPYABLE(PromiseTracker);
+public:
+    PromiseTracker();
+    ~PromiseTracker();
+
+    bool isEnabled() const { return m_isEnabled; }
+    void enable();
+    void disable();
+
+    void clear();
+
+    void didReceiveV8PromiseEvent(ScriptState*, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status);
+
+    class PromiseData;
+
+    typedef Vector<RefPtr<PromiseData> > PromiseDataVector;
+    typedef HashMap<int, PromiseDataVector> PromiseDataMap;
+
+private:
+    bool m_isEnabled;
+    PromiseDataMap m_promiseDataMap;
+};
+
+} // namespace blink
+
+#endif // !defined(PromiseTracker_h)
diff --git a/engine/core/inspector/ScriptCallFrame.cpp b/engine/core/inspector/ScriptCallFrame.cpp
index d1e43cb939b..ef69b23f06f 100644
--- a/engine/core/inspector/ScriptCallFrame.cpp
+++ b/engine/core/inspector/ScriptCallFrame.cpp
@@ -55,4 +55,15 @@ ScriptCallFrame::~ScriptCallFrame()
 {
 }
 
+PassRefPtr<TypeBuilder::Console::CallFrame> ScriptCallFrame::buildInspectorObject() const
+{
+    return TypeBuilder::Console::CallFrame::create()
+        .setFunctionName(m_functionName)
+        .setScriptId(m_scriptId)
+        .setUrl(m_scriptName)
+        .setLineNumber(m_lineNumber)
+        .setColumnNumber(m_column)
+        .release();
+}
+
 } // namespace blink
diff --git a/engine/core/inspector/ScriptCallFrame.h b/engine/core/inspector/ScriptCallFrame.h
index 082c56de7da..0d4d626586b 100644
--- a/engine/core/inspector/ScriptCallFrame.h
+++ b/engine/core/inspector/ScriptCallFrame.h
@@ -31,6 +31,7 @@
 #ifndef ScriptCallFrame_h
 #define ScriptCallFrame_h
 
+#include "core/InspectorTypeBuilder.h"
 #include "wtf/Forward.h"
 #include "wtf/text/WTFString.h"
 
@@ -48,6 +49,8 @@ public:
     unsigned lineNumber() const { return m_lineNumber; }
     unsigned columnNumber() const { return m_column; }
 
+    PassRefPtr<TypeBuilder::Console::CallFrame> buildInspectorObject() const;
+
 private:
     String m_functionName;
     String m_scriptId;
diff --git a/engine/core/inspector/ScriptCallStack.cpp b/engine/core/inspector/ScriptCallStack.cpp
index 68835d5123e..def2ce6c44e 100644
--- a/engine/core/inspector/ScriptCallStack.cpp
+++ b/engine/core/inspector/ScriptCallStack.cpp
@@ -68,4 +68,12 @@ void ScriptCallStack::setAsyncCallStack(PassRefPtr<ScriptAsyncCallStack> asyncCa
     m_asyncCallStack = asyncCallStack;
 }
 
+PassRefPtr<TypeBuilder::Array<TypeBuilder::Console::CallFrame> > ScriptCallStack::buildInspectorArray() const
+{
+    RefPtr<TypeBuilder::Array<TypeBuilder::Console::CallFrame> > frames = TypeBuilder::Array<TypeBuilder::Console::CallFrame>::create();
+    for (size_t i = 0; i < m_frames.size(); i++)
+        frames->addItem(m_frames.at(i).buildInspectorObject());
+    return frames;
+}
+
 } // namespace blink
diff --git a/engine/core/inspector/ScriptCallStack.h b/engine/core/inspector/ScriptCallStack.h
index 8750d00768f..d686cbcd8ad 100644
--- a/engine/core/inspector/ScriptCallStack.h
+++ b/engine/core/inspector/ScriptCallStack.h
@@ -31,6 +31,7 @@
 #ifndef ScriptCallStack_h
 #define ScriptCallStack_h
 
+#include "core/InspectorTypeBuilder.h"
 #include "core/inspector/ScriptCallFrame.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Forward.h"
@@ -54,6 +55,8 @@ public:
     PassRefPtr<ScriptAsyncCallStack> asyncCallStack() const;
     void setAsyncCallStack(PassRefPtr<ScriptAsyncCallStack>);
 
+    PassRefPtr<TypeBuilder::Array<TypeBuilder::Console::CallFrame> > buildInspectorArray() const;
+
 private:
     explicit ScriptCallStack(Vector<ScriptCallFrame>&);
 
diff --git a/engine/core/inspector/inspector_backend_mojo.cc b/engine/core/inspector/inspector_backend_mojo.cc
new file mode 100644
index 00000000000..93734c9d056
--- /dev/null
+++ b/engine/core/inspector/inspector_backend_mojo.cc
@@ -0,0 +1,109 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "core/inspector/inspector_backend_mojo.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/run_loop.h"
+#include "bindings/core/v8/PageScriptDebugServer.h"
+#include "bindings/core/v8/ScriptController.h"
+#include "core/frame/FrameHost.h"
+#include "core/inspector/InspectorState.h"
+#include "core/inspector/InstrumentingAgents.h"
+#include "core/inspector/PageDebuggerAgent.h"
+#include "core/InspectorBackendDispatcher.h"
+#include "core/page/Page.h"
+#include "mojo/public/cpp/application/connect.h"
+#include "mojo/public/cpp/application/service_provider_impl.h"
+#include "mojo/public/interfaces/application/shell.mojom.h"
+#include "platform/JSONValues.h"
+#include "public/platform/ServiceProvider.h"
+
+namespace blink {
+
+class MessageLoopAdaptor : public PageScriptDebugServer::ClientMessageLoop {
+public:
+    MessageLoopAdaptor() { }
+
+private:
+    virtual void run(Page* page)
+    {
+      if (run_loop_)
+        return;
+      run_loop_.reset(new base::RunLoop());
+      run_loop_->Run();
+    }
+
+    virtual void quitNow()
+    {
+      if (run_loop_)
+        run_loop_->Quit();
+    }
+
+    scoped_ptr<base::RunLoop> run_loop_;
+};
+
+InspectorBackendMojo::InspectorBackendMojo(const FrameHost& frame_host)
+    : frame_host_(frame_host) {
+}
+
+InspectorBackendMojo::~InspectorBackendMojo() {
+}
+
+void InspectorBackendMojo::Connect() {
+  mojo::Shell* shell = frame_host_.services().Shell();
+  mojo::ServiceProviderPtr inspector_service_provider;
+  shell->ConnectToApplication("mojo:sky_inspector_server",
+                              GetProxy(&inspector_service_provider));
+  mojo::ConnectToService(inspector_service_provider.get(), &frontend_);
+  frontend_.set_client(this);
+
+  // Theoretically we should load our state from the inspector cookie.
+  inspector_state_ = adoptPtr(new InspectorState(nullptr, JSONObject::create()));
+  old_frontend_ = adoptPtr(new InspectorFrontend(this));
+
+  v8::Isolate* isolate = frame_host_.page().mainFrame()->script().isolate();
+  PageScriptDebugServer::setMainThreadIsolate(isolate);
+  OwnPtr<MessageLoopAdaptor> message_loop = adoptPtr(new MessageLoopAdaptor);
+  PageScriptDebugServer::shared().setClientMessageLoop(message_loop.release());
+
+  // AgentRegistry used to do this, but we don't need it for one agent.
+  script_manager_ = InjectedScriptManager::createForPage();
+  debugger_agent_ = PageDebuggerAgent::create(&PageScriptDebugServer::shared(), &frame_host_.page(), script_manager_.get());
+  agents_ = adoptPtr(new InstrumentingAgents(debugger_agent_.get()));
+  debugger_agent_->init(agents_.get(), inspector_state_.get());
+  debugger_agent_->setFrontend(old_frontend_.get());
+
+  dispatcher_ = InspectorBackendDispatcher::create(this);
+  dispatcher_->registerAgent(debugger_agent_.get());
+}
+
+void InspectorBackendMojo::sendMessageToFrontend(
+    PassRefPtr<JSONObject> message) {
+  frontend_->SendMessage(message->toJSONString().toUTF8());
+}
+
+void InspectorBackendMojo::flush() {
+  // TODO(eseidel): Unclear if this is needed.
+}
+
+void InspectorBackendMojo::OnConnect() {
+}
+
+void InspectorBackendMojo::OnDisconnect() {
+}
+
+void InspectorBackendMojo::OnMessage(const mojo::String& message) {
+  String wtf_message = String::fromUTF8(message.To<std::string>());
+  String command_name;
+  InspectorBackendDispatcher::getCommandName(wtf_message, &command_name);
+  // InspectorBackendDispatcher will automatically reply with errors
+  // if agents are missing, since we only want this backend to care about
+  // the Debugger agent, we manually filter here.
+  if (command_name.startsWith("Debugger"))
+      dispatcher_->dispatch(wtf_message);
+}
+
+} // namespace blink
diff --git a/engine/core/inspector/inspector_backend_mojo.h b/engine/core/inspector/inspector_backend_mojo.h
new file mode 100644
index 00000000000..ee0b7d8fb2d
--- /dev/null
+++ b/engine/core/inspector/inspector_backend_mojo.h
@@ -0,0 +1,56 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SKY_ENGINE_INSPECTOR_INSPECTOR_BACKEND_MOJO_H_
+#define SKY_ENGINE_INSPECTOR_INSPECTOR_BACKEND_MOJO_H_
+
+#include "base/basictypes.h"
+#include "core/inspector/InspectorFrontendChannel.h"
+#include "sky/services/inspector/inspector.mojom.h"
+
+namespace blink {
+class FrameHost;
+class InspectorBackendDispatcher;
+class JSONObject;
+class PageDebuggerAgent;
+class InjectedScriptManager;
+class InspectorState;
+class InstrumentingAgents;
+class InspectorFrontend;
+
+class InspectorBackendMojo : public mojo::InterfaceImpl<sky::InspectorBackend>,
+    public InspectorFrontendChannel {
+public:
+  explicit InspectorBackendMojo(const FrameHost& frame_host);
+  ~InspectorBackendMojo();
+
+  void Connect();
+
+private:
+  // InspectorBackend:
+  void OnConnect() override;
+  void OnDisconnect() override;
+  void OnMessage(const mojo::String& message) override;
+
+  // InspectorFrontendChannel:
+  void sendMessageToFrontend(PassRefPtr<JSONObject> message) override;
+  void flush() override;
+
+  const FrameHost& frame_host_;
+
+  sky::InspectorFrontendPtr frontend_;
+
+  OwnPtr<InspectorFrontend> old_frontend_;
+  RefPtr<InspectorBackendDispatcher> dispatcher_;
+  OwnPtr<PageDebuggerAgent> debugger_agent_;
+  OwnPtr<InjectedScriptManager> script_manager_;
+  OwnPtr<InspectorState> inspector_state_;
+  OwnPtr<InstrumentingAgents> agents_;
+
+  DISALLOW_COPY_AND_ASSIGN(InspectorBackendMojo);
+};
+
+}  // namespace blink
+
+#endif  // SKY_ENGINE_INSPECTOR_INSPECTOR_BACKEND_MOJO_H_
\ No newline at end of file
diff --git a/engine/core/testing/DummyPageHolder.cpp b/engine/core/testing/DummyPageHolder.cpp
index 109347b63bb..0b5b7765fc2 100644
--- a/engine/core/testing/DummyPageHolder.cpp
+++ b/engine/core/testing/DummyPageHolder.cpp
@@ -45,6 +45,7 @@ namespace {
 class DummyServiceProvider : public blink::ServiceProvider {
 public:
     mojo::NavigatorHost* NavigatorHost() { return 0; }
+    mojo::Shell* Shell() { return 0; }
 };
 
 }
diff --git a/engine/public/platform/ServiceProvider.h b/engine/public/platform/ServiceProvider.h
index 0898140806f..d8e3ee8c733 100644
--- a/engine/public/platform/ServiceProvider.h
+++ b/engine/public/platform/ServiceProvider.h
@@ -7,6 +7,7 @@
 
 namespace mojo {
 class NavigatorHost;
+class Shell;
 }
 
 namespace blink {
@@ -14,6 +15,7 @@ namespace blink {
 class ServiceProvider {
  public:
   virtual mojo::NavigatorHost* NavigatorHost() = 0;
+  virtual mojo::Shell* Shell() = 0;
 
  protected:
   virtual ~ServiceProvider();
diff --git a/engine/public/web/WebView.h b/engine/public/web/WebView.h
index 508428a89e8..36a56902697 100644
--- a/engine/public/web/WebView.h
+++ b/engine/public/web/WebView.h
@@ -124,6 +124,7 @@ public:
 
     virtual void injectModule(const WebString& path) = 0;
 
+    virtual void connectInspectorBackend() = 0;
 
     // Focus ---------------------------------------------------------------
 
diff --git a/engine/web/FrameLoaderClientImpl.cpp b/engine/web/FrameLoaderClientImpl.cpp
index 469dc178093..1300e28d150 100644
--- a/engine/web/FrameLoaderClientImpl.cpp
+++ b/engine/web/FrameLoaderClientImpl.cpp
@@ -84,6 +84,10 @@ void FrameLoaderClientImpl::documentElementAvailable()
 
 void FrameLoaderClientImpl::didCreateScriptContext(v8::Handle<v8::Context> context, int extensionGroup, int worldId)
 {
+    // FIXME: We shouldn't need separate debugger ids in sky since
+    // we should have at most one DocumentView per process, no?
+    m_webFrame->frame()->script().setWorldDebugId(worldId, 1);
+
     if (m_webFrame->client())
         m_webFrame->client()->didCreateScriptContext(m_webFrame, context, extensionGroup, worldId);
 }
diff --git a/engine/web/WebViewImpl.cpp b/engine/web/WebViewImpl.cpp
index 29c258d6143..f81a5071e0a 100644
--- a/engine/web/WebViewImpl.cpp
+++ b/engine/web/WebViewImpl.cpp
@@ -32,7 +32,6 @@
 #include "web/WebViewImpl.h"
 
 #include "core/CSSValueKeywords.h"
-#include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentMarkerController.h"
 #include "core/dom/NodeRenderingTraversal.h"
@@ -41,8 +40,8 @@
 #include "core/editing/FrameSelection.h"
 #include "core/editing/HTMLInterchange.h"
 #include "core/editing/InputMethodController.h"
-#include "core/editing/TextIterator.h"
 #include "core/editing/markup.h"
+#include "core/editing/TextIterator.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/frame/FrameHost.h"
@@ -51,6 +50,8 @@
 #include "core/frame/Settings.h"
 #include "core/html/HTMLImportElement.h"
 #include "core/html/ime/InputMethodContext.h"
+#include "core/HTMLNames.h"
+#include "core/inspector/inspector_backend_mojo.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/UniqueIdentifier.h"
 #include "core/page/Chrome.h"
@@ -59,9 +60,14 @@
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/TouchDisambiguation.h"
-#include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
+#include "core/rendering/RenderView.h"
 #include "platform/Cursor.h"
+#include "platform/exported/WebActiveGestureAnimation.h"
+#include "platform/fonts/FontCache.h"
+#include "platform/graphics/Color.h"
+#include "platform/graphics/Image.h"
+#include "platform/graphics/ImageBuffer.h"
 #include "platform/KeyboardCodes.h"
 #include "platform/Logging.h"
 #include "platform/NotImplemented.h"
@@ -70,14 +76,9 @@
 #include "platform/PlatformMouseEvent.h"
 #include "platform/PlatformWheelEvent.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/scroll/Scrollbar.h"
 #include "platform/TraceEvent.h"
 #include "platform/UserGestureIndicator.h"
-#include "platform/exported/WebActiveGestureAnimation.h"
-#include "platform/fonts/FontCache.h"
-#include "platform/graphics/Color.h"
-#include "platform/graphics/Image.h"
-#include "platform/graphics/ImageBuffer.h"
-#include "platform/scroll/Scrollbar.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebFloatPoint.h"
@@ -97,10 +98,10 @@
 #include "web/CompositionUnderlineVectorBuilder.h"
 #include "web/GraphicsLayerFactoryChromium.h"
 #include "web/LinkHighlight.h"
+#include "web/painting/ContinuousPainter.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebSettingsImpl.h"
-#include "web/painting/ContinuousPainter.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/RefPtr.h"
 #include "wtf/TemporaryChange.h"
@@ -1605,6 +1606,12 @@ void WebViewImpl::injectModule(const WebString& path)
     document->documentElement()->appendChild(import.release());
 }
 
+void WebViewImpl::connectInspectorBackend()
+{
+    m_inspectorBackend = adoptPtr(new InspectorBackendMojo(page()->frameHost()));
+    m_inspectorBackend->Connect();
+}
+
 void WebViewImpl::setFocusedFrame(WebFrame* frame)
 {
     if (!frame) {
diff --git a/engine/web/WebViewImpl.h b/engine/web/WebViewImpl.h
index 8fe17584c7a..6d834059bde 100644
--- a/engine/web/WebViewImpl.h
+++ b/engine/web/WebViewImpl.h
@@ -32,6 +32,7 @@
 #define WebViewImpl_h
 
 #include "core/html/ime/InputMethodContext.h"
+#include "core/inspector/inspector_backend_mojo.h"
 #include "platform/geometry/IntPoint.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/GraphicsLayer.h"
@@ -117,6 +118,7 @@ public:
     // WebView methods:
     virtual void setMainFrame(WebFrame*) override;
     virtual void injectModule(const WebString&) override;
+    virtual void connectInspectorBackend() override;
     virtual void setSpellCheckClient(WebSpellCheckClient*) override;
     virtual WebSettings* settings() override;
     virtual WebString pageEncoding() const override;
@@ -448,6 +450,8 @@ private:
     WebColor m_backgroundColorOverride;
 
     bool m_userGestureObserved;
+
+    OwnPtr<InspectorBackendMojo> m_inspectorBackend;
 };
 
 // We have no ways to check if the specified WebView is an instance of
diff --git a/framework/inspector/inspector.sky b/framework/inspector/inspector.sky
index 6e73f78f190..b5f3f12ef7d 100644
--- a/framework/inspector/inspector.sky
+++ b/framework/inspector/inspector.sky
@@ -16,18 +16,22 @@ function InspectorBackend(frontend) {
   this.agents = {
     Console: new ConsoleAgent(),
     DOM: domAgent,
-    Page: new PageAgent(),
+    Page: new PageAgent(this),
     Worker: new WorkerAgent(),
     Runtime: new RuntimeAgent(this),
     CSS: new CSSAgent(domAgent),
     IndexedDB: new IndexedDBAgent(),
   };
   this.missingNames_ = {};
+  this.unansweredMessages_ = [];
 }
 
 InspectorBackend.prototype = Object.create(
     inspector.InspectorBackend.stubClass.prototype);
 
+InspectorBackend.prototype.ASYNC_RESPONSE = "ASYNC_RESPONSE";
+InspectorBackend.prototype.MESSAGE_TIMEOUT_MS = 30000;
+
 InspectorBackend.prototype.onConnect = function() {
 };
 
@@ -41,12 +45,16 @@ InspectorBackend.prototype.logMissing_ = function(name) {
   console.log("InspectorBackend missing " + name);
 }
 
-InspectorBackend.prototype.dispatch_ = function(descriptor, params) {
+InspectorBackend.prototype.dispatch_ = function(descriptor, params, message_id) {
   var parsed = descriptor.split('.');
 
   var agentName = parsed[0];
   var methodName = parsed[1];
 
+  // Debugger is implemented in c++.
+  if (agentName == "Debugger")
+    return;
+
   if (!(agentName in this.agents)) {
     this.logMissing_(agentName);
     return {};
@@ -55,12 +63,12 @@ InspectorBackend.prototype.dispatch_ = function(descriptor, params) {
   var agent = this.agents[agentName];
 
   if (!(methodName in agent)) {
-    this.logMissing_(agentName + "." + methodName);
+    this.logMissing_(descriptor);
     return {};
   }
 
   try {
-    return agent[methodName](params);
+    return agent[methodName](params, message_id);
   } catch(ex) {
     console.log(descriptor + ": " + ex);
   }
@@ -68,14 +76,34 @@ InspectorBackend.prototype.dispatch_ = function(descriptor, params) {
 
 InspectorBackend.prototype.onMessage = function(data) {
   var message = JSON.parse(data);
-  var result = this.dispatch_(message.method, message.params);
+  var result = this.dispatch_(message.method, message.params, message.id);
+  this.unansweredMessages_.push(message.id);
+  // FIXME: This magic return value is kinda hacky.
+  if (result != this.ASYNC_RESPONSE)
+    this.sendResponse(message.id, result);
+  else {
+    window.setTimeout(function(message_id) {
+      if (this.unansweredMessages_.indexOf(message_id) == -1)
+        return;
+      console.log("Error, failed to reply to " + descriptor
+          + " message id " + message_id);
+    }, this.MESSAGE_TIMEOUT_MS, this, message.id);
+  }
+};
+
+InspectorBackend.prototype.sendResponse = function(message_id, result) {
+  var messageIndex = this.unansweredMessages_.indexOf(message_id);
+  if (messageIndex != -1)
+    this.unansweredMessages_.splice(messageIndex, 1);
+  else
+    console.log("Error, responding to unknown message id " + message_id);
   var response = {
-    id: message.id,
+    id: message_id,
   };
   if (typeof result !== "undefined")
     response.result = result;
   this.frontend.sendMessage(JSON.stringify(response));
-};
+}
 
 InspectorBackend.prototype.sendMessage = function(method, params) {
   var message = JSON.stringify({
diff --git a/framework/inspector/page-agent.sky b/framework/inspector/page-agent.sky
index 31078a57444..875d5719301 100644
--- a/framework/inspector/page-agent.sky
+++ b/framework/inspector/page-agent.sky
@@ -1,5 +1,7 @@
+<import src="/sky/framework/xmlhttprequest.sky" as="XMLHttpRequest" />
 <script>
-function Page() {
+function Page(delegate) {
+  this.delegate_ = delegate;
 }
 
 Page.prototype.enable = function() {
@@ -17,14 +19,28 @@ Page.prototype.canEmulate = function() {
   };
 };
 
+Page.prototype.getResourceContent = function(params, message_id) {
+  var request = new XMLHttpRequest;
+  request.onload = function() {
+    var message = {
+      'content' : request.responseText,
+    };
+    this.delegate_.sendResponse(message_id, message);
+  }.bind(this);
+  request.open("GET", params.url);
+  request.send();
+
+  return this.delegate_.ASYNC_RESPONSE;
+};
+
 Page.prototype.getResourceTree = function() {
   // Unclear if this is all needed, but if we don't return something here
   // the inspector hits an exception in WebInspector.ResourceTreeModel.
   return {
     "frameTree": {
       "frame": {
-        "id": 1,
-        "loaderId": 1,
+        "id": "1",
+        "loaderId": "1",
         "url": document.URL,
         "mimeType": "text/html",
         "securityOrigin": document.URL,
diff --git a/framework/inspector/runtime-agent.sky b/framework/inspector/runtime-agent.sky
index 4bac0ba4df6..c0857915715 100644
--- a/framework/inspector/runtime-agent.sky
+++ b/framework/inspector/runtime-agent.sky
@@ -115,7 +115,10 @@ Runtime.prototype.evaluate = function(params) {
   return makeResult(params, value, wasThrown);
 }
 
-Runtime.prototype.getProperties = debug.loggingStub("getProperties");
+Runtime.prototype.getProperties = function(params) {
+  // FIXME: Unclear what this is for.
+  return [];
+}
 
 module.exports = Runtime;
 </script>
diff --git a/tests/inspector/page-agent-get-resource-expected.txt b/tests/inspector/page-agent-get-resource-expected.txt
new file mode 100644
index 00000000000..f96104a9406
--- /dev/null
+++ b/tests/inspector/page-agent-get-resource-expected.txt
@@ -0,0 +1 @@
+Got message!
diff --git a/viewer/document_view.cc b/viewer/document_view.cc
index 0bfbeca61cc..49982990210 100644
--- a/viewer/document_view.cc
+++ b/viewer/document_view.cc
@@ -64,6 +64,8 @@ mojo::Target WebNavigationPolicyToNavigationTarget(
 
 }  // namespace
 
+static int s_next_debugger_id = 1;
+
 DocumentView::DocumentView(
     mojo::URLResponsePtr response,
     mojo::ShellPtr shell,
@@ -75,6 +77,7 @@ DocumentView::DocumentView(
       view_manager_client_factory_(shell_.get(), this),
       inspector_service_factory_(this),
       compositor_thread_(compositor_thread),
+      debugger_id_(s_next_debugger_id++),
       weak_factory_(this) {
   shell_.set_client(this);
 }
@@ -191,8 +194,6 @@ void DocumentView::didCreateScriptContext(blink::WebLocalFrame* frame,
                                           v8::Handle<v8::Context> context,
                                           int extensionGroup,
                                           int worldId) {
-  if (frame != web_view_->mainFrame())
-    return;
   script_runner_.reset(new ScriptRunner(frame, context));
 
   v8::Isolate* isolate = context->GetIsolate();
@@ -209,6 +210,10 @@ mojo::NavigatorHost* DocumentView::NavigatorHost() {
   return navigator_host_.get();
 }
 
+mojo::Shell* DocumentView::Shell() {
+  return shell_.get();
+}
+
 void DocumentView::OnViewBoundsChanged(mojo::View* view,
                                        const mojo::Rect& old_bounds,
                                        const mojo::Rect& new_bounds) {
diff --git a/viewer/document_view.h b/viewer/document_view.h
index d52ce7913a3..1ef54835248 100644
--- a/viewer/document_view.h
+++ b/viewer/document_view.h
@@ -89,6 +89,7 @@ class DocumentView : public mojo::InterfaceImpl<mojo::Application>,
 
   // Services methods:
   mojo::NavigatorHost* NavigatorHost() override;
+  mojo::Shell* Shell() override;
 
   // ViewManagerDelegate methods:
   void OnEmbed(
@@ -121,6 +122,7 @@ class DocumentView : public mojo::InterfaceImpl<mojo::Application>,
   scoped_ptr<WebLayerTreeViewImpl> web_layer_tree_view_impl_;
   scoped_refptr<base::MessageLoopProxy> compositor_thread_;
   scoped_ptr<ScriptRunner> script_runner_;
+  int debugger_id_;
 
   base::WeakPtrFactory<DocumentView> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(DocumentView);
diff --git a/viewer/platform/platform_impl.cc b/viewer/platform/platform_impl.cc
index 2315c4560d3..b9131677812 100644
--- a/viewer/platform/platform_impl.cc
+++ b/viewer/platform/platform_impl.cc
@@ -7,6 +7,9 @@
 #include <cmath>
 
 #include "base/debug/trace_event.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
@@ -235,4 +238,28 @@ void PlatformImpl::updateTraceEventDuration(
       category_group_enabled, name, traceEventHandle);
 }
 
+// FIXME(sky): This is a horrible hack and makes sky only work when run
+// inside its source tree!  crbug.com/434513
+blink::WebData PlatformImpl::loadResource(const char* name)
+{
+  base::FilePath root_dir;
+  PathService::Get(base::DIR_SOURCE_ROOT, &root_dir);
+  base::FilePath engine_dir = root_dir.AppendASCII("sky").AppendASCII("engine");
+  base::FilePath v8_dir = engine_dir.AppendASCII("bindings").AppendASCII("core").AppendASCII("v8");
+  base::FilePath inspector_dir = engine_dir.AppendASCII("core").AppendASCII("inspector");
+
+  base::FilePath path;
+  if (std::string("InjectedScriptSource.js") == name)
+    path = inspector_dir.AppendASCII(name);
+  else if (std::string("DebuggerScript.js") == name)
+    path = v8_dir.AppendASCII(name);
+  else
+    CHECK(false);
+
+  std::string buffer;
+  base::ReadFileToString(path, &buffer);
+  CHECK(!buffer.empty());
+  return blink::WebData(buffer.data(), buffer.size());
+}
+
 }  // namespace sky
diff --git a/viewer/platform/platform_impl.h b/viewer/platform/platform_impl.h
index 9495ab477aa..78895b18d68 100644
--- a/viewer/platform/platform_impl.h
+++ b/viewer/platform/platform_impl.h
@@ -70,6 +70,8 @@ class PlatformImpl : public blink::Platform {
       const char* name,
       TraceEventHandle);
 
+  virtual blink::WebData loadResource(const char* name);
+
  private:
   void SuspendSharedTimer();
   void ResumeSharedTimer();
diff --git a/viewer/services/inspector_impl.cc b/viewer/services/inspector_impl.cc
index 4c8d086f3ed..ca8059c7722 100644
--- a/viewer/services/inspector_impl.cc
+++ b/viewer/services/inspector_impl.cc
@@ -27,16 +27,17 @@ void InspectorServiceImpl::Inject() {
   if (!view_)
     return;
 
-  mojo::ServiceProviderPtr inpector_service_provider;
+  mojo::ServiceProviderPtr inspector_service_provider;
   view_->shell()->ConnectToApplication("mojo:sky_inspector_server",
-                                       GetProxy(&inpector_service_provider));
+                                       GetProxy(&inspector_service_provider));
   InspectorServerPtr inspector;
-  ConnectToService(inpector_service_provider.get(), &inspector);
+  mojo::ConnectToService(inspector_service_provider.get(), &inspector);
   inspector->Listen(9898, base::Bind(&Ignored));
   // Listen drops existing agents/backends, wait before registering new ones.
   inspector.WaitForIncomingMethodCall();
 
   view_->web_view()->injectModule("/sky/framework/inspector/inspector.sky");
+  view_->web_view()->connectInspectorBackend();
 }
 
 }  // namespace sky