[SCM] WebKit Debian packaging branch, webkit-1.1, updated. upstream/1.1.19-706-ge5415e9
yurys at chromium.org
yurys at chromium.org
Thu Feb 4 21:36:48 UTC 2010
The following commit has been merged in the webkit-1.1 branch:
commit 5fcf5af2ea74125e05322da534ed9d3bf080bf09
Author: yurys at chromium.org <yurys at chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Tue Feb 2 14:22:32 2010 +0000
2010-02-02 Yury Semikhatsky <yurys at chromium.org>
Reviewed by Pavel Feldman.
Upstream DevTools code.
https://bugs.webkit.org/show_bug.cgi?id=34326
* WebKit.gyp:
* src/APUAgentDelegate.h: Added.
* src/BoundObject.cpp: Added.
(WebKit::BoundObject::BoundObject):
(WebKit::BoundObject::~BoundObject):
(WebKit::BoundObject::addProtoFunction):
(WebKit::BoundObject::build):
* src/BoundObject.h: Added.
* src/DebuggerAgent.h: Added.
* src/DebuggerAgentImpl.cpp: Added.
(WebKit::DebuggerAgentImpl::DebuggerAgentImpl):
(WebKit::DebuggerAgentImpl::~DebuggerAgentImpl):
(WebKit::DebuggerAgentImpl::getContextId):
(WebKit::DebuggerAgentImpl::debuggerOutput):
(WebKit::DebuggerAgentImpl::createUtilityContext):
(WebKit::DebuggerAgentImpl::executeUtilityFunction):
(WebKit::DebuggerAgentImpl::executeVoidJavaScript):
(WebKit::DebuggerAgentImpl::page):
* src/DebuggerAgentImpl.h: Added.
(WebKit::DebuggerAgentImpl::setAutoContinueOnException):
(WebKit::DebuggerAgentImpl::autoContinueOnException):
(WebKit::DebuggerAgentImpl::webdevtoolsAgent):
(WebKit::DebuggerAgentImpl::webView):
* src/DebuggerAgentManager.cpp: Added.
(WebKit::DebuggerAgentManager::debugHostDispatchHandler):
(WebKit::DebuggerAgentManager::debugAttach):
(WebKit::DebuggerAgentManager::debugDetach):
(WebKit::DebuggerAgentManager::onV8DebugMessage):
(WebKit::DebuggerAgentManager::pauseScript):
(WebKit::DebuggerAgentManager::executeDebuggerCommand):
(WebKit::DebuggerAgentManager::setMessageLoopDispatchHandler):
(WebKit::DebuggerAgentManager::setHostId):
(WebKit::DebuggerAgentManager::onWebViewClosed):
(WebKit::DebuggerAgentManager::onNavigate):
(WebKit::DebuggerAgentManager::sendCommandToV8):
(WebKit::DebuggerAgentManager::sendContinueCommandToV8):
(WebKit::DebuggerAgentManager::findAgentForCurrentV8Context):
(WebKit::DebuggerAgentManager::debuggerAgentForHostId):
* src/DebuggerAgentManager.h: Added.
(WebKit::DebuggerAgentManager::UtilityContextScope::UtilityContextScope):
(WebKit::DebuggerAgentManager::UtilityContextScope::~UtilityContextScope):
* src/DevToolsRPC.h: Added.
(WebKit::):
(WebKit::DevToolsRPC::Delegate::Delegate):
(WebKit::DevToolsRPC::Delegate::~Delegate):
(WebKit::DevToolsRPC::DevToolsRPC):
(WebKit::DevToolsRPC::~DevToolsRPC):
(WebKit::DevToolsRPC::sendRpcMessage):
* src/DevToolsRPCJS.h: Added.
* src/ProfilerAgent.h: Added.
* src/ProfilerAgentImpl.cpp: Added.
(WebKit::ProfilerAgentImpl::getActiveProfilerModules):
(WebKit::ProfilerAgentImpl::getLogLines):
* src/ProfilerAgentImpl.h: Added.
(WebKit::ProfilerAgentImpl::ProfilerAgentImpl):
(WebKit::ProfilerAgentImpl::~ProfilerAgentImpl):
* src/ToolsAgent.h: Added.
* src/WebDevToolsAgentImpl.cpp: Added.
(WebKit::):
(WebKit::WebDevToolsAgentImpl::WebDevToolsAgentImpl):
(WebKit::WebDevToolsAgentImpl::~WebDevToolsAgentImpl):
(WebKit::WebDevToolsAgentImpl::disposeUtilityContext):
(WebKit::WebDevToolsAgentImpl::unhideResourcesPanelIfNecessary):
(WebKit::WebDevToolsAgentImpl::attach):
(WebKit::WebDevToolsAgentImpl::detach):
(WebKit::WebDevToolsAgentImpl::didNavigate):
(WebKit::WebDevToolsAgentImpl::didCommitProvisionalLoad):
(WebKit::WebDevToolsAgentImpl::didClearWindowObject):
(WebKit::WebDevToolsAgentImpl::forceRepaint):
(WebKit::WebDevToolsAgentImpl::dispatchOnInspectorController):
(WebKit::WebDevToolsAgentImpl::dispatchOnInjectedScript):
(WebKit::WebDevToolsAgentImpl::executeVoidJavaScript):
(WebKit::WebDevToolsAgentImpl::dispatchMessageFromFrontend):
(WebKit::WebDevToolsAgentImpl::inspectElementAt):
(WebKit::WebDevToolsAgentImpl::setRuntimeFeatureEnabled):
(WebKit::WebDevToolsAgentImpl::sendRpcMessage):
(WebKit::WebDevToolsAgentImpl::compileUtilityScripts):
(WebKit::WebDevToolsAgentImpl::initDevToolsAgentHost):
(WebKit::WebDevToolsAgentImpl::createInspectorBackendV8Wrapper):
(WebKit::WebDevToolsAgentImpl::resetInspectorFrontendProxy):
(WebKit::WebDevToolsAgentImpl::setApuAgentEnabled):
(WebKit::WebDevToolsAgentImpl::jsDispatchOnClient):
(WebKit::WebDevToolsAgentImpl::jsDispatchToApu):
(WebKit::WebDevToolsAgentImpl::jsEvaluateOnSelf):
(WebKit::WebDevToolsAgentImpl::jsOnRuntimeFeatureStateChanged):
(WebKit::WebDevToolsAgentImpl::inspectorController):
(WebKit::WebDevToolsAgentImpl::identifierForInitialRequest):
(WebKit::WebDevToolsAgentImpl::willSendRequest):
(WebKit::WebDevToolsAgentImpl::didReceiveData):
(WebKit::WebDevToolsAgentImpl::didReceiveResponse):
(WebKit::WebDevToolsAgentImpl::didFinishLoading):
(WebKit::WebDevToolsAgentImpl::didFailLoading):
(WebKit::WebDevToolsAgentImpl::evaluateInWebInspector):
(WebKit::WebDevToolsAgentImpl::setTimelineProfilingEnabled):
(WebKit::WebDevToolsAgent::create):
(WebKit::WebDevToolsAgent::executeDebuggerCommand):
(WebKit::WebDevToolsAgent::debuggerPauseScript):
(WebKit::WebDevToolsAgent::setMessageLoopDispatchHandler):
(WebKit::WebDevToolsAgent::dispatchMessageFromFrontendOnIOThread):
* src/WebDevToolsAgentImpl.h: Added.
(WebKit::WebDevToolsAgentImpl::hostId):
* src/WebDevToolsFrontendImpl.cpp: Added.
(WebKit::ToV8String):
(WebKit::WebDevToolsFrontend::create):
(WebKit::WebDevToolsFrontendImpl::WebDevToolsFrontendImpl):
(WebKit::WebDevToolsFrontendImpl::~WebDevToolsFrontendImpl):
(WebKit::WebDevToolsFrontendImpl::dispatchMessageFromAgent):
(WebKit::WebDevToolsFrontendImpl::executeScript):
(WebKit::WebDevToolsFrontendImpl::dispatchOnWebInspector):
(WebKit::WebDevToolsFrontendImpl::sendRpcMessage):
(WebKit::WebDevToolsFrontendImpl::contextMenuItemSelected):
(WebKit::WebDevToolsFrontendImpl::contextMenuCleared):
(WebKit::WebDevToolsFrontendImpl::jsLoaded):
(WebKit::WebDevToolsFrontendImpl::jsPlatform):
(WebKit::WebDevToolsFrontendImpl::jsPort):
(WebKit::WebDevToolsFrontendImpl::jsCopyText):
(WebKit::WebDevToolsFrontendImpl::jsActivateWindow):
(WebKit::WebDevToolsFrontendImpl::jsCloseWindow):
(WebKit::WebDevToolsFrontendImpl::jsDockWindow):
(WebKit::WebDevToolsFrontendImpl::jsUndockWindow):
(WebKit::WebDevToolsFrontendImpl::jsLocalizedStringsURL):
(WebKit::WebDevToolsFrontendImpl::jsHiddenPanels):
(WebKit::WebDevToolsFrontendImpl::jsDebuggerCommand):
(WebKit::WebDevToolsFrontendImpl::jsSetting):
(WebKit::WebDevToolsFrontendImpl::jsSetSetting):
(WebKit::WebDevToolsFrontendImpl::jsDebuggerPauseScript):
(WebKit::WebDevToolsFrontendImpl::jsWindowUnloading):
(WebKit::WebDevToolsFrontendImpl::jsShowContextMenu):
* src/WebDevToolsFrontendImpl.h: Added.
(WebKit::WebDevToolsFrontendImpl::MenuProvider::create):
(WebKit::WebDevToolsFrontendImpl::MenuProvider::~MenuProvider):
(WebKit::WebDevToolsFrontendImpl::MenuProvider::disconnect):
(WebKit::WebDevToolsFrontendImpl::MenuProvider::populateContextMenu):
(WebKit::WebDevToolsFrontendImpl::MenuProvider::contextMenuItemSelected):
(WebKit::WebDevToolsFrontendImpl::MenuProvider::contextMenuCleared):
(WebKit::WebDevToolsFrontendImpl::MenuProvider::MenuProvider):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@54232 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog
index 7961c7a..4f62309 100644
--- a/WebKit/chromium/ChangeLog
+++ b/WebKit/chromium/ChangeLog
@@ -1,3 +1,148 @@
+2010-02-02 Yury Semikhatsky <yurys at chromium.org>
+
+ Reviewed by Pavel Feldman.
+
+ Upstream DevTools code.
+
+ https://bugs.webkit.org/show_bug.cgi?id=34326
+
+ * WebKit.gyp:
+ * src/APUAgentDelegate.h: Added.
+ * src/BoundObject.cpp: Added.
+ (WebKit::BoundObject::BoundObject):
+ (WebKit::BoundObject::~BoundObject):
+ (WebKit::BoundObject::addProtoFunction):
+ (WebKit::BoundObject::build):
+ * src/BoundObject.h: Added.
+ * src/DebuggerAgent.h: Added.
+ * src/DebuggerAgentImpl.cpp: Added.
+ (WebKit::DebuggerAgentImpl::DebuggerAgentImpl):
+ (WebKit::DebuggerAgentImpl::~DebuggerAgentImpl):
+ (WebKit::DebuggerAgentImpl::getContextId):
+ (WebKit::DebuggerAgentImpl::debuggerOutput):
+ (WebKit::DebuggerAgentImpl::createUtilityContext):
+ (WebKit::DebuggerAgentImpl::executeUtilityFunction):
+ (WebKit::DebuggerAgentImpl::executeVoidJavaScript):
+ (WebKit::DebuggerAgentImpl::page):
+ * src/DebuggerAgentImpl.h: Added.
+ (WebKit::DebuggerAgentImpl::setAutoContinueOnException):
+ (WebKit::DebuggerAgentImpl::autoContinueOnException):
+ (WebKit::DebuggerAgentImpl::webdevtoolsAgent):
+ (WebKit::DebuggerAgentImpl::webView):
+ * src/DebuggerAgentManager.cpp: Added.
+ (WebKit::DebuggerAgentManager::debugHostDispatchHandler):
+ (WebKit::DebuggerAgentManager::debugAttach):
+ (WebKit::DebuggerAgentManager::debugDetach):
+ (WebKit::DebuggerAgentManager::onV8DebugMessage):
+ (WebKit::DebuggerAgentManager::pauseScript):
+ (WebKit::DebuggerAgentManager::executeDebuggerCommand):
+ (WebKit::DebuggerAgentManager::setMessageLoopDispatchHandler):
+ (WebKit::DebuggerAgentManager::setHostId):
+ (WebKit::DebuggerAgentManager::onWebViewClosed):
+ (WebKit::DebuggerAgentManager::onNavigate):
+ (WebKit::DebuggerAgentManager::sendCommandToV8):
+ (WebKit::DebuggerAgentManager::sendContinueCommandToV8):
+ (WebKit::DebuggerAgentManager::findAgentForCurrentV8Context):
+ (WebKit::DebuggerAgentManager::debuggerAgentForHostId):
+ * src/DebuggerAgentManager.h: Added.
+ (WebKit::DebuggerAgentManager::UtilityContextScope::UtilityContextScope):
+ (WebKit::DebuggerAgentManager::UtilityContextScope::~UtilityContextScope):
+ * src/DevToolsRPC.h: Added.
+ (WebKit::):
+ (WebKit::DevToolsRPC::Delegate::Delegate):
+ (WebKit::DevToolsRPC::Delegate::~Delegate):
+ (WebKit::DevToolsRPC::DevToolsRPC):
+ (WebKit::DevToolsRPC::~DevToolsRPC):
+ (WebKit::DevToolsRPC::sendRpcMessage):
+ * src/DevToolsRPCJS.h: Added.
+ * src/ProfilerAgent.h: Added.
+ * src/ProfilerAgentImpl.cpp: Added.
+ (WebKit::ProfilerAgentImpl::getActiveProfilerModules):
+ (WebKit::ProfilerAgentImpl::getLogLines):
+ * src/ProfilerAgentImpl.h: Added.
+ (WebKit::ProfilerAgentImpl::ProfilerAgentImpl):
+ (WebKit::ProfilerAgentImpl::~ProfilerAgentImpl):
+ * src/ToolsAgent.h: Added.
+ * src/WebDevToolsAgentImpl.cpp: Added.
+ (WebKit::):
+ (WebKit::WebDevToolsAgentImpl::WebDevToolsAgentImpl):
+ (WebKit::WebDevToolsAgentImpl::~WebDevToolsAgentImpl):
+ (WebKit::WebDevToolsAgentImpl::disposeUtilityContext):
+ (WebKit::WebDevToolsAgentImpl::unhideResourcesPanelIfNecessary):
+ (WebKit::WebDevToolsAgentImpl::attach):
+ (WebKit::WebDevToolsAgentImpl::detach):
+ (WebKit::WebDevToolsAgentImpl::didNavigate):
+ (WebKit::WebDevToolsAgentImpl::didCommitProvisionalLoad):
+ (WebKit::WebDevToolsAgentImpl::didClearWindowObject):
+ (WebKit::WebDevToolsAgentImpl::forceRepaint):
+ (WebKit::WebDevToolsAgentImpl::dispatchOnInspectorController):
+ (WebKit::WebDevToolsAgentImpl::dispatchOnInjectedScript):
+ (WebKit::WebDevToolsAgentImpl::executeVoidJavaScript):
+ (WebKit::WebDevToolsAgentImpl::dispatchMessageFromFrontend):
+ (WebKit::WebDevToolsAgentImpl::inspectElementAt):
+ (WebKit::WebDevToolsAgentImpl::setRuntimeFeatureEnabled):
+ (WebKit::WebDevToolsAgentImpl::sendRpcMessage):
+ (WebKit::WebDevToolsAgentImpl::compileUtilityScripts):
+ (WebKit::WebDevToolsAgentImpl::initDevToolsAgentHost):
+ (WebKit::WebDevToolsAgentImpl::createInspectorBackendV8Wrapper):
+ (WebKit::WebDevToolsAgentImpl::resetInspectorFrontendProxy):
+ (WebKit::WebDevToolsAgentImpl::setApuAgentEnabled):
+ (WebKit::WebDevToolsAgentImpl::jsDispatchOnClient):
+ (WebKit::WebDevToolsAgentImpl::jsDispatchToApu):
+ (WebKit::WebDevToolsAgentImpl::jsEvaluateOnSelf):
+ (WebKit::WebDevToolsAgentImpl::jsOnRuntimeFeatureStateChanged):
+ (WebKit::WebDevToolsAgentImpl::inspectorController):
+ (WebKit::WebDevToolsAgentImpl::identifierForInitialRequest):
+ (WebKit::WebDevToolsAgentImpl::willSendRequest):
+ (WebKit::WebDevToolsAgentImpl::didReceiveData):
+ (WebKit::WebDevToolsAgentImpl::didReceiveResponse):
+ (WebKit::WebDevToolsAgentImpl::didFinishLoading):
+ (WebKit::WebDevToolsAgentImpl::didFailLoading):
+ (WebKit::WebDevToolsAgentImpl::evaluateInWebInspector):
+ (WebKit::WebDevToolsAgentImpl::setTimelineProfilingEnabled):
+ (WebKit::WebDevToolsAgent::create):
+ (WebKit::WebDevToolsAgent::executeDebuggerCommand):
+ (WebKit::WebDevToolsAgent::debuggerPauseScript):
+ (WebKit::WebDevToolsAgent::setMessageLoopDispatchHandler):
+ (WebKit::WebDevToolsAgent::dispatchMessageFromFrontendOnIOThread):
+ * src/WebDevToolsAgentImpl.h: Added.
+ (WebKit::WebDevToolsAgentImpl::hostId):
+ * src/WebDevToolsFrontendImpl.cpp: Added.
+ (WebKit::ToV8String):
+ (WebKit::WebDevToolsFrontend::create):
+ (WebKit::WebDevToolsFrontendImpl::WebDevToolsFrontendImpl):
+ (WebKit::WebDevToolsFrontendImpl::~WebDevToolsFrontendImpl):
+ (WebKit::WebDevToolsFrontendImpl::dispatchMessageFromAgent):
+ (WebKit::WebDevToolsFrontendImpl::executeScript):
+ (WebKit::WebDevToolsFrontendImpl::dispatchOnWebInspector):
+ (WebKit::WebDevToolsFrontendImpl::sendRpcMessage):
+ (WebKit::WebDevToolsFrontendImpl::contextMenuItemSelected):
+ (WebKit::WebDevToolsFrontendImpl::contextMenuCleared):
+ (WebKit::WebDevToolsFrontendImpl::jsLoaded):
+ (WebKit::WebDevToolsFrontendImpl::jsPlatform):
+ (WebKit::WebDevToolsFrontendImpl::jsPort):
+ (WebKit::WebDevToolsFrontendImpl::jsCopyText):
+ (WebKit::WebDevToolsFrontendImpl::jsActivateWindow):
+ (WebKit::WebDevToolsFrontendImpl::jsCloseWindow):
+ (WebKit::WebDevToolsFrontendImpl::jsDockWindow):
+ (WebKit::WebDevToolsFrontendImpl::jsUndockWindow):
+ (WebKit::WebDevToolsFrontendImpl::jsLocalizedStringsURL):
+ (WebKit::WebDevToolsFrontendImpl::jsHiddenPanels):
+ (WebKit::WebDevToolsFrontendImpl::jsDebuggerCommand):
+ (WebKit::WebDevToolsFrontendImpl::jsSetting):
+ (WebKit::WebDevToolsFrontendImpl::jsSetSetting):
+ (WebKit::WebDevToolsFrontendImpl::jsDebuggerPauseScript):
+ (WebKit::WebDevToolsFrontendImpl::jsWindowUnloading):
+ (WebKit::WebDevToolsFrontendImpl::jsShowContextMenu):
+ * src/WebDevToolsFrontendImpl.h: Added.
+ (WebKit::WebDevToolsFrontendImpl::MenuProvider::create):
+ (WebKit::WebDevToolsFrontendImpl::MenuProvider::~MenuProvider):
+ (WebKit::WebDevToolsFrontendImpl::MenuProvider::disconnect):
+ (WebKit::WebDevToolsFrontendImpl::MenuProvider::populateContextMenu):
+ (WebKit::WebDevToolsFrontendImpl::MenuProvider::contextMenuItemSelected):
+ (WebKit::WebDevToolsFrontendImpl::MenuProvider::contextMenuCleared):
+ (WebKit::WebDevToolsFrontendImpl::MenuProvider::MenuProvider):
+
2010-02-01 Jeremy Orlow <jorlow at chromium.org>
Reviewed by Darin Fisher.
diff --git a/WebKit/chromium/WebKit.gyp b/WebKit/chromium/WebKit.gyp
index 3b5a17f..3049b73 100644
--- a/WebKit/chromium/WebKit.gyp
+++ b/WebKit/chromium/WebKit.gyp
@@ -192,6 +192,7 @@
'public/win/WebSandboxSupport.h',
'public/win/WebScreenInfoFactory.h',
'public/win/WebScreenInfoFactory.h',
+ 'src/APUAgentDelegate.h',
'src/ApplicationCacheHost.cpp',
'src/ApplicationCacheHostInternal.h',
'src/AssertMatchingEnums.cpp',
@@ -199,6 +200,8 @@
'src/AutocompletePopupMenuClient.h',
'src/BackForwardListClientImpl.cpp',
'src/BackForwardListClientImpl.h',
+ 'src/BoundObject.cpp',
+ 'src/BoundObject.h',
'src/ChromeClientImpl.cpp',
'src/ChromeClientImpl.h',
'src/ChromiumBridge.cpp',
@@ -207,6 +210,13 @@
'src/ContextMenuClientImpl.cpp',
'src/ContextMenuClientImpl.h',
'src/DatabaseObserver.cpp',
+ 'src/DebuggerAgent.h',
+ 'src/DebuggerAgentImpl.cpp',
+ 'src/DebuggerAgentImpl.h',
+ 'src/DebuggerAgentManager.cpp',
+ 'src/DebuggerAgentManager.h',
+ 'src/DevToolsRPC.h',
+ 'src/DevToolsRPCJS.h',
'src/DOMUtilitiesPrivate.cpp',
'src/DOMUtilitiesPrivate.h',
'src/DragClientImpl.cpp',
@@ -232,6 +242,9 @@
'src/NotificationPresenterImpl.cpp',
'src/PlatformMessagePortChannel.cpp',
'src/PlatformMessagePortChannel.h',
+ 'src/ProfilerAgent.h',
+ 'src/ProfilerAgentImpl.cpp',
+ 'src/ProfilerAgentImpl.h',
'src/ResourceHandle.cpp',
'src/SharedWorkerRepository.cpp',
'src/SocketStreamHandle.cpp',
@@ -243,6 +256,7 @@
'src/StorageNamespaceProxy.cpp',
'src/StorageNamespaceProxy.h',
'src/TemporaryGlue.h',
+ 'src/ToolsAgent.h',
'src/WebAccessibilityCache.cpp',
'src/WebAccessibilityCacheImpl.cpp',
'src/WebAccessibilityCacheImpl.h',
@@ -259,6 +273,10 @@
'src/WebDatabase.cpp',
'src/WebDataSourceImpl.cpp',
'src/WebDataSourceImpl.h',
+ 'src/WebDevToolsAgentImpl.cpp',
+ 'src/WebDevToolsAgentImpl.h',
+ 'src/WebDevToolsFrontendImpl.cpp',
+ 'src/WebDevToolsFrontendImpl.h',
'src/WebDocument.cpp',
'src/WebDragData.cpp',
'src/WebElement.cpp',
diff --git a/WebKit/chromium/src/APUAgentDelegate.h b/WebKit/chromium/src/APUAgentDelegate.h
new file mode 100644
index 0000000..70be702
--- /dev/null
+++ b/WebKit/chromium/src/APUAgentDelegate.h
@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+
+#ifndef APUAgentDelegate_h
+#define APUAgentDelegate_h
+
+#include "DevToolsRPC.h"
+
+namespace WebKit {
+
+#define APU_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, MEHTOD4, METHOD5) \
+ /* Sends a json object to apu. */ \
+ METHOD1(dispatchToApu, String /* data */)
+
+DEFINE_RPC_CLASS(ApuAgentDelegate, APU_AGENT_DELEGATE_STRUCT)
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/BoundObject.cpp b/WebKit/chromium/src/BoundObject.cpp
new file mode 100644
index 0000000..90096c2
--- /dev/null
+++ b/WebKit/chromium/src/BoundObject.cpp
@@ -0,0 +1,79 @@
+/*
+ * 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 "BoundObject.h"
+
+#include "V8Proxy.h"
+
+namespace WebKit {
+
+BoundObject::BoundObject(v8::Handle<v8::Context> context, void* v8This, const char* objectName)
+ : m_objectName(objectName)
+ , m_context(context)
+ , m_v8This(v8This)
+{
+ v8::Context::Scope contextScope(context);
+ v8::Local<v8::FunctionTemplate> localTemplate = v8::FunctionTemplate::New(WebCore::V8Proxy::checkNewLegal);
+ m_hostTemplate = v8::Persistent<v8::FunctionTemplate>::New(localTemplate);
+ m_hostTemplate->SetClassName(v8::String::New(objectName));
+}
+
+BoundObject::~BoundObject()
+{
+ m_hostTemplate.Dispose();
+}
+
+void BoundObject::addProtoFunction(const char* name, v8::InvocationCallback callback)
+{
+ v8::Context::Scope contextScope(m_context);
+ v8::Local<v8::Signature> signature = v8::Signature::New(m_hostTemplate);
+ v8::Local<v8::ObjectTemplate> proto = m_hostTemplate->PrototypeTemplate();
+ v8::Local<v8::External> v8This = v8::External::New(m_v8This);
+ proto->Set(
+ v8::String::New(name),
+ v8::FunctionTemplate::New(
+ callback,
+ v8This,
+ signature),
+ static_cast<v8::PropertyAttribute>(v8::DontDelete));
+}
+
+void BoundObject::build()
+{
+ v8::Context::Scope contextScope(m_context);
+ v8::Local<v8::Function> constructor = m_hostTemplate->GetFunction();
+ v8::Local<v8::Object> boundObject = WebCore::SafeAllocation::newInstance(constructor);
+
+ v8::Handle<v8::Object> global = m_context->Global();
+ global->Set(v8::String::New(m_objectName), boundObject);
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/BoundObject.h b/WebKit/chromium/src/BoundObject.h
new file mode 100644
index 0000000..769e83f
--- /dev/null
+++ b/WebKit/chromium/src/BoundObject.h
@@ -0,0 +1,60 @@
+/*
+ * 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.
+ */
+
+#ifndef BoundObject_h
+#define BoundObject_h
+
+#include <v8.h>
+#include <wtf/Noncopyable.h>
+
+namespace WebKit {
+
+// BoundObject is a helper class that lets you map JavaScript method calls
+// directly to C++ method calls. It should be destroyed once JS object is
+// built.
+class BoundObject : public Noncopyable {
+public:
+ BoundObject(v8::Handle<v8::Context> context, void* v8This, const char* objectName);
+ virtual ~BoundObject();
+
+ void addProtoFunction(const char* name, v8::InvocationCallback callback);
+ void build();
+
+private:
+ v8::HandleScope m_handleScope;
+ const char* m_objectName;
+ v8::Handle<v8::Context> m_context;
+ v8::Persistent<v8::FunctionTemplate> m_hostTemplate;
+ void* m_v8This;
+};
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/DebuggerAgent.h b/WebKit/chromium/src/DebuggerAgent.h
new file mode 100644
index 0000000..cac9686
--- /dev/null
+++ b/WebKit/chromium/src/DebuggerAgent.h
@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#ifndef DebuggerAgent_h
+#define DebuggerAgent_h
+
+#include "DevToolsRPC.h"
+
+namespace WebKit {
+
+#define DEBUGGER_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \
+ /* Requests global context id of the inspected tab. */ \
+ METHOD0(getContextId)
+
+DEFINE_RPC_CLASS(DebuggerAgent, DEBUGGER_AGENT_STRUCT)
+
+#define DEBUGGER_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \
+ METHOD1(debuggerOutput, String /* output text */) \
+ \
+ /* Pushes debugger context id into the client. */ \
+ METHOD1(setContextId, int /* context id */)
+
+DEFINE_RPC_CLASS(DebuggerAgentDelegate, DEBUGGER_AGENT_DELEGATE_STRUCT)
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/DebuggerAgentImpl.cpp b/WebKit/chromium/src/DebuggerAgentImpl.cpp
new file mode 100644
index 0000000..0c3d1ea
--- /dev/null
+++ b/WebKit/chromium/src/DebuggerAgentImpl.cpp
@@ -0,0 +1,204 @@
+/*
+ * 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 "DebuggerAgentImpl.h"
+
+#include "DebuggerAgentManager.h"
+#include "Document.h"
+#include "Frame.h"
+#include "Page.h"
+#include "V8Binding.h"
+#include "V8DOMWindow.h"
+#include "V8Index.h"
+#include "V8Proxy.h"
+#include "WebDevToolsAgentImpl.h"
+#include "WebViewImpl.h"
+#include <wtf/HashSet.h>
+#include <wtf/RefPtr.h>
+#include <wtf/Vector.h>
+
+using WebCore::DOMWindow;
+using WebCore::Document;
+using WebCore::Frame;
+using WebCore::Page;
+using WebCore::String;
+using WebCore::V8ClassIndex;
+using WebCore::V8Custom;
+using WebCore::V8DOMWindow;
+using WebCore::V8DOMWrapper;
+using WebCore::V8Proxy;
+
+namespace WebKit {
+
+DebuggerAgentImpl::DebuggerAgentImpl(
+ WebViewImpl* webViewImpl,
+ DebuggerAgentDelegate* delegate,
+ WebDevToolsAgentImpl* webdevtoolsAgent)
+ : m_webViewImpl(webViewImpl)
+ , m_delegate(delegate)
+ , m_webdevtoolsAgent(webdevtoolsAgent)
+ , m_autoContinueOnException(false)
+{
+ DebuggerAgentManager::debugAttach(this);
+}
+
+DebuggerAgentImpl::~DebuggerAgentImpl()
+{
+ DebuggerAgentManager::debugDetach(this);
+}
+
+void DebuggerAgentImpl::getContextId()
+{
+ m_delegate->setContextId(m_webdevtoolsAgent->hostId());
+}
+
+void DebuggerAgentImpl::debuggerOutput(const String& command)
+{
+ m_delegate->debuggerOutput(command);
+ m_webdevtoolsAgent->forceRepaint();
+}
+
+// static
+void DebuggerAgentImpl::createUtilityContext(Frame* frame, v8::Persistent<v8::Context>* context)
+{
+ v8::HandleScope scope;
+
+ // Set up the DOM window as the prototype of the new global object.
+ v8::Handle<v8::Context> windowContext = V8Proxy::context(frame);
+ v8::Handle<v8::Object> windowGlobal = windowContext->Global();
+ v8::Handle<v8::Object> windowWrapper = V8DOMWrapper::lookupDOMWrapper(V8ClassIndex::DOMWINDOW, windowGlobal);
+
+ ASSERT(V8DOMWindow::toNative(windowWrapper) == frame->domWindow());
+
+ v8::Handle<v8::ObjectTemplate> globalTemplate = v8::ObjectTemplate::New();
+
+ // TODO(yurys): provide a function in v8 bindings that would make the
+ // utility context more like main world context of the inspected frame,
+ // otherwise we need to manually make it satisfy various invariants
+ // that V8Proxy::getEntered and some other V8Proxy methods expect to find
+ // on v8 contexts on the contexts stack.
+ // See V8Proxy::createNewContext.
+ //
+ // Install a security handler with V8.
+ globalTemplate->SetAccessCheckCallbacks(
+ V8DOMWindow::namedSecurityCheck,
+ V8DOMWindow::indexedSecurityCheck,
+ v8::Integer::New(V8ClassIndex::DOMWINDOW));
+ // We set number of internal fields to match that in V8DOMWindow wrapper.
+ // See http://crbug.com/28961
+ globalTemplate->SetInternalFieldCount(V8DOMWindow::internalFieldCount);
+
+ *context = v8::Context::New(0 /* no extensions */, globalTemplate, v8::Handle<v8::Object>());
+ v8::Context::Scope contextScope(*context);
+ v8::Handle<v8::Object> global = (*context)->Global();
+
+ v8::Handle<v8::String> implicitProtoString = v8::String::New("__proto__");
+ global->Set(implicitProtoString, windowWrapper);
+
+ // Give the code running in the new context a way to get access to the
+ // original context.
+ global->Set(v8::String::New("contentWindow"), windowGlobal);
+}
+
+String DebuggerAgentImpl::executeUtilityFunction(
+ v8::Handle<v8::Context> context,
+ int callId,
+ const char* object,
+ const String &functionName,
+ const String& jsonArgs,
+ bool async,
+ String* exception)
+{
+ v8::HandleScope scope;
+ ASSERT(!context.IsEmpty());
+ if (context.IsEmpty()) {
+ *exception = "No window context.";
+ return "";
+ }
+ v8::Context::Scope contextScope(context);
+
+ DebuggerAgentManager::UtilityContextScope utilityScope;
+
+ v8::Handle<v8::Object> dispatchObject = v8::Handle<v8::Object>::Cast(
+ context->Global()->Get(v8::String::New(object)));
+
+ v8::Handle<v8::Value> dispatchFunction = dispatchObject->Get(v8::String::New("dispatch"));
+ ASSERT(dispatchFunction->IsFunction());
+ v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction);
+
+ v8::Handle<v8::String> functionNameWrapper = v8::Handle<v8::String>(
+ v8::String::New(functionName.utf8().data()));
+ v8::Handle<v8::String> jsonArgsWrapper = v8::Handle<v8::String>(
+ v8::String::New(jsonArgs.utf8().data()));
+ v8::Handle<v8::Number> callIdWrapper = v8::Handle<v8::Number>(
+ v8::Number::New(async ? callId : 0));
+
+ v8::Handle<v8::Value> args[] = {
+ functionNameWrapper,
+ jsonArgsWrapper,
+ callIdWrapper
+ };
+
+ v8::TryCatch tryCatch;
+ v8::Handle<v8::Value> resObj = function->Call(context->Global(), 3, args);
+ if (tryCatch.HasCaught()) {
+ v8::Local<v8::Message> message = tryCatch.Message();
+ if (message.IsEmpty())
+ *exception = "Unknown exception";
+ else
+ *exception = WebCore::toWebCoreString(message->Get());
+ return "";
+ }
+ return WebCore::toWebCoreStringWithNullCheck(resObj);
+}
+
+void DebuggerAgentImpl::executeVoidJavaScript(v8::Handle<v8::Context> context)
+{
+ v8::HandleScope scope;
+ ASSERT(!context.IsEmpty());
+ v8::Context::Scope contextScope(context);
+ DebuggerAgentManager::UtilityContextScope utilityScope;
+
+ v8::Handle<v8::Value> function =
+ context->Global()->Get(v8::String::New("devtools$$void"));
+ ASSERT(function->IsFunction());
+ v8::Handle<v8::Value> args[] = {
+ v8::Local<v8::Value>()
+ };
+ v8::Handle<v8::Function>::Cast(function)->Call(context->Global(), 0, args);
+}
+
+WebCore::Page* DebuggerAgentImpl::page()
+{
+ return m_webViewImpl->page();
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/DebuggerAgentImpl.h b/WebKit/chromium/src/DebuggerAgentImpl.h
new file mode 100644
index 0000000..65dc14c
--- /dev/null
+++ b/WebKit/chromium/src/DebuggerAgentImpl.h
@@ -0,0 +1,103 @@
+/*
+ * 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.
+ */
+
+#ifndef DebuggerAgentImpl_h
+#define DebuggerAgentImpl_h
+
+#include "DebuggerAgent.h"
+
+#include <v8.h>
+#include <wtf/HashSet.h>
+#include <wtf/Noncopyable.h>
+
+namespace WebCore {
+class Document;
+class Frame;
+class Node;
+class Page;
+class String;
+}
+
+namespace WebKit {
+
+class WebDevToolsAgentImpl;
+class WebViewImpl;
+
+class DebuggerAgentImpl : public DebuggerAgent {
+public:
+ // Creates utility context with injected js agent.
+ static void createUtilityContext(WebCore::Frame* frame, v8::Persistent<v8::Context>* context);
+
+ DebuggerAgentImpl(WebKit::WebViewImpl* webViewImpl,
+ DebuggerAgentDelegate* delegate,
+ WebDevToolsAgentImpl* webdevtoolsAgent);
+ virtual ~DebuggerAgentImpl();
+
+ // DebuggerAgent implementation.
+ virtual void getContextId();
+
+ void debuggerOutput(const WebCore::String& out);
+
+ void setAutoContinueOnException(bool autoContinue) { m_autoContinueOnException = autoContinue; }
+
+ bool autoContinueOnException() { return m_autoContinueOnException; }
+
+ // Executes function with the given name in the utility context. Passes node
+ // and json args as parameters. Note that the function called must be
+ // implemented in the inject_dispatch.js file.
+ WebCore::String executeUtilityFunction(
+ v8::Handle<v8::Context> context,
+ int callId,
+ const char* object,
+ const WebCore::String& functionName,
+ const WebCore::String& jsonArgs,
+ bool async,
+ WebCore::String* exception);
+
+ // Executes a no-op function in the utility context. We don't use
+ // executeUtilityFunction for that to avoid script evaluation leading to
+ // undesirable AfterCompile events.
+ void executeVoidJavaScript(v8::Handle<v8::Context> context);
+
+ WebCore::Page* page();
+ WebDevToolsAgentImpl* webdevtoolsAgent() { return m_webdevtoolsAgent; }
+
+ WebKit::WebViewImpl* webView() { return m_webViewImpl; }
+
+private:
+ WebKit::WebViewImpl* m_webViewImpl;
+ DebuggerAgentDelegate* m_delegate;
+ WebDevToolsAgentImpl* m_webdevtoolsAgent;
+ bool m_autoContinueOnException;
+};
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/DebuggerAgentManager.cpp b/WebKit/chromium/src/DebuggerAgentManager.cpp
new file mode 100644
index 0000000..faafaff
--- /dev/null
+++ b/WebKit/chromium/src/DebuggerAgentManager.cpp
@@ -0,0 +1,311 @@
+/*
+ * 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 "DebuggerAgentManager.h"
+
+#include "DebuggerAgentImpl.h"
+#include "Frame.h"
+#include "PageGroupLoadDeferrer.h"
+#include "V8Proxy.h"
+#include "WebDevToolsAgentImpl.h"
+#include "WebFrameImpl.h"
+#include "WebViewImpl.h"
+#include <wtf/HashSet.h>
+#include <wtf/Noncopyable.h>
+
+namespace WebKit {
+
+WebDevToolsAgent::MessageLoopDispatchHandler DebuggerAgentManager::s_messageLoopDispatchHandler = 0;
+
+bool DebuggerAgentManager::s_inHostDispatchHandler = false;
+
+DebuggerAgentManager::DeferrersMap DebuggerAgentManager::s_pageDeferrers;
+
+bool DebuggerAgentManager::s_inUtilityContext = false;
+
+bool DebuggerAgentManager::s_debugBreakDelayed = false;
+
+namespace {
+
+class CallerIdWrapper : public v8::Debug::ClientData, public Noncopyable {
+public:
+ CallerIdWrapper() : m_callerIsMananager(true), m_callerId(0) { }
+ explicit CallerIdWrapper(int callerId)
+ : m_callerIsMananager(false)
+ , m_callerId(callerId) { }
+ ~CallerIdWrapper() { }
+ bool callerIsMananager() const { return m_callerIsMananager; }
+ int callerId() const { return m_callerId; }
+private:
+ bool m_callerIsMananager;
+ int m_callerId;
+};
+
+} // namespace
+
+
+void DebuggerAgentManager::debugHostDispatchHandler()
+{
+ if (!s_messageLoopDispatchHandler || !s_attachedAgentsMap)
+ return;
+
+ if (s_inHostDispatchHandler)
+ return;
+
+ s_inHostDispatchHandler = true;
+
+ Vector<WebViewImpl*> views;
+ // 1. Disable active objects and input events.
+ for (AttachedAgentsMap::iterator it = s_attachedAgentsMap->begin(); it != s_attachedAgentsMap->end(); ++it) {
+ DebuggerAgentImpl* agent = it->second;
+ s_pageDeferrers.set(agent->webView(), new WebCore::PageGroupLoadDeferrer(agent->page(), true));
+ views.append(agent->webView());
+ agent->webView()->setIgnoreInputEvents(true);
+ }
+
+ // 2. Process messages.
+ s_messageLoopDispatchHandler();
+
+ // 3. Bring things back.
+ for (Vector<WebViewImpl*>::iterator it = views.begin(); it != views.end(); ++it) {
+ if (s_pageDeferrers.contains(*it)) {
+ // The view was not closed during the dispatch.
+ (*it)->setIgnoreInputEvents(false);
+ }
+ }
+ deleteAllValues(s_pageDeferrers);
+ s_pageDeferrers.clear();
+
+ s_inHostDispatchHandler = false;
+ if (!s_attachedAgentsMap) {
+ // Remove handlers if all agents were detached within host dispatch.
+ v8::Debug::SetMessageHandler(0);
+ v8::Debug::SetHostDispatchHandler(0);
+ }
+}
+
+DebuggerAgentManager::AttachedAgentsMap* DebuggerAgentManager::s_attachedAgentsMap = 0;
+
+void DebuggerAgentManager::debugAttach(DebuggerAgentImpl* debuggerAgent)
+{
+ if (!s_attachedAgentsMap) {
+ s_attachedAgentsMap = new AttachedAgentsMap();
+ v8::Debug::SetMessageHandler2(&DebuggerAgentManager::onV8DebugMessage);
+ v8::Debug::SetHostDispatchHandler(&DebuggerAgentManager::debugHostDispatchHandler, 100 /* ms */);
+ }
+ int hostId = debuggerAgent->webdevtoolsAgent()->hostId();
+ ASSERT(hostId);
+ s_attachedAgentsMap->set(hostId, debuggerAgent);
+}
+
+void DebuggerAgentManager::debugDetach(DebuggerAgentImpl* debuggerAgent)
+{
+ if (!s_attachedAgentsMap) {
+ ASSERT_NOT_REACHED();
+ return;
+ }
+ int hostId = debuggerAgent->webdevtoolsAgent()->hostId();
+ ASSERT(s_attachedAgentsMap->get(hostId) == debuggerAgent);
+ bool isOnBreakpoint = (findAgentForCurrentV8Context() == debuggerAgent);
+ s_attachedAgentsMap->remove(hostId);
+
+ if (s_attachedAgentsMap->isEmpty()) {
+ delete s_attachedAgentsMap;
+ s_attachedAgentsMap = 0;
+ // Note that we do not empty handlers while in dispatch - we schedule
+ // continue and do removal once we are out of the dispatch. Also there is
+ // no need to send continue command in this case since removing message
+ // handler will cause debugger unload and all breakpoints will be cleared.
+ if (!s_inHostDispatchHandler) {
+ v8::Debug::SetMessageHandler2(0);
+ v8::Debug::SetHostDispatchHandler(0);
+ }
+ } else {
+ // Remove all breakpoints set by the agent.
+ String clearBreakpointGroupCmd = String::format(
+ "{\"seq\":1,\"type\":\"request\",\"command\":\"clearbreakpointgroup\","
+ "\"arguments\":{\"groupId\":%d}}",
+ hostId);
+ sendCommandToV8(clearBreakpointGroupCmd, new CallerIdWrapper());
+
+ if (isOnBreakpoint) {
+ // Force continue if detach happened in nessted message loop while
+ // debugger was paused on a breakpoint(as long as there are other
+ // attached agents v8 will wait for explicit'continue' message).
+ sendContinueCommandToV8();
+ }
+ }
+}
+
+void DebuggerAgentManager::onV8DebugMessage(const v8::Debug::Message& message)
+{
+ v8::HandleScope scope;
+ v8::String::Value value(message.GetJSON());
+ String out(reinterpret_cast<const UChar*>(*value), value.length());
+
+ // If callerData is not 0 the message is a response to a debugger command.
+ if (v8::Debug::ClientData* callerData = message.GetClientData()) {
+ CallerIdWrapper* wrapper = static_cast<CallerIdWrapper*>(callerData);
+ if (wrapper->callerIsMananager()) {
+ // Just ignore messages sent by this manager.
+ return;
+ }
+ DebuggerAgentImpl* debuggerAgent = debuggerAgentForHostId(wrapper->callerId());
+ if (debuggerAgent)
+ debuggerAgent->debuggerOutput(out);
+ else if (!message.WillStartRunning()) {
+ // Autocontinue execution if there is no handler.
+ sendContinueCommandToV8();
+ }
+ return;
+ } // Otherwise it's an event message.
+ ASSERT(message.IsEvent());
+
+ // Ignore unsupported event types.
+ if (message.GetEvent() != v8::AfterCompile && message.GetEvent() != v8::Break && message.GetEvent() != v8::Exception)
+ return;
+
+ v8::Handle<v8::Context> context = message.GetEventContext();
+ // If the context is from one of the inpected tabs it should have its context
+ // data.
+ if (context.IsEmpty()) {
+ // Unknown context, skip the event.
+ return;
+ }
+
+ if (s_inUtilityContext && message.GetEvent() == v8::Break) {
+ // This may happen when two tabs are being debugged in the same process.
+ // Suppose that first debugger is pauesed on an exception. It will run
+ // nested MessageLoop which may process Break request from the second
+ // debugger.
+ s_debugBreakDelayed = true;
+ } else {
+ // If the context is from one of the inpected tabs or injected extension
+ // scripts it must have hostId in the data field.
+ int hostId = WebCore::V8Proxy::contextDebugId(context);
+ if (hostId != -1) {
+ DebuggerAgentImpl* agent = debuggerAgentForHostId(hostId);
+ if (agent) {
+ if (agent->autoContinueOnException()
+ && message.GetEvent() == v8::Exception) {
+ sendContinueCommandToV8();
+ return;
+ }
+
+ agent->debuggerOutput(out);
+ return;
+ }
+ }
+ }
+
+ if (!message.WillStartRunning()) {
+ // Autocontinue execution on break and exception events if there is no
+ // handler.
+ sendContinueCommandToV8();
+ }
+}
+
+void DebuggerAgentManager::pauseScript()
+{
+ if (s_inUtilityContext)
+ s_debugBreakDelayed = true;
+ else
+ v8::Debug::DebugBreak();
+}
+
+void DebuggerAgentManager::executeDebuggerCommand(const String& command, int callerId)
+{
+ sendCommandToV8(command, new CallerIdWrapper(callerId));
+}
+
+void DebuggerAgentManager::setMessageLoopDispatchHandler(WebDevToolsAgent::MessageLoopDispatchHandler handler)
+{
+ s_messageLoopDispatchHandler = handler;
+}
+
+void DebuggerAgentManager::setHostId(WebFrameImpl* webframe, int hostId)
+{
+ ASSERT(hostId > 0);
+ WebCore::V8Proxy* proxy = WebCore::V8Proxy::retrieve(webframe->frame());
+ if (proxy)
+ proxy->setContextDebugId(hostId);
+}
+
+void DebuggerAgentManager::onWebViewClosed(WebViewImpl* webview)
+{
+ if (s_pageDeferrers.contains(webview)) {
+ delete s_pageDeferrers.get(webview);
+ s_pageDeferrers.remove(webview);
+ }
+}
+
+void DebuggerAgentManager::onNavigate()
+{
+ if (s_inHostDispatchHandler)
+ DebuggerAgentManager::sendContinueCommandToV8();
+}
+
+void DebuggerAgentManager::sendCommandToV8(const String& cmd, v8::Debug::ClientData* data)
+{
+ v8::Debug::SendCommand(reinterpret_cast<const uint16_t*>(cmd.characters()), cmd.length(), data);
+}
+
+void DebuggerAgentManager::sendContinueCommandToV8()
+{
+ String continueCmd("{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}");
+ sendCommandToV8(continueCmd, new CallerIdWrapper());
+}
+
+DebuggerAgentImpl* DebuggerAgentManager::findAgentForCurrentV8Context()
+{
+ if (!s_attachedAgentsMap)
+ return 0;
+ ASSERT(!s_attachedAgentsMap->isEmpty());
+
+ WebCore::Frame* frame = WebCore::V8Proxy::retrieveFrameForEnteredContext();
+ if (!frame)
+ return 0;
+ WebCore::Page* page = frame->page();
+ for (AttachedAgentsMap::iterator it = s_attachedAgentsMap->begin(); it != s_attachedAgentsMap->end(); ++it) {
+ if (it->second->page() == page)
+ return it->second;
+ }
+ return 0;
+}
+
+DebuggerAgentImpl* DebuggerAgentManager::debuggerAgentForHostId(int hostId)
+{
+ if (!s_attachedAgentsMap)
+ return 0;
+ return s_attachedAgentsMap->get(hostId);
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/DebuggerAgentManager.h b/WebKit/chromium/src/DebuggerAgentManager.h
new file mode 100644
index 0000000..a2e9030
--- /dev/null
+++ b/WebKit/chromium/src/DebuggerAgentManager.h
@@ -0,0 +1,123 @@
+/*
+ * 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.
+ */
+
+#ifndef DebuggerAgentManager_h
+#define DebuggerAgentManager_h
+
+#include "WebDevToolsAgent.h"
+#include <v8-debug.h>
+#include <wtf/HashMap.h>
+#include <wtf/Noncopyable.h>
+
+namespace WebCore {
+class PageGroupLoadDeferrer;
+class String;
+}
+
+namespace WebKit {
+
+class DebuggerAgentImpl;
+class DictionaryValue;
+class WebFrameImpl;
+class WebViewImpl;
+
+// There is single v8 instance per render process. Also there may be several
+// RenderViews and consequently devtools agents in the process that want to talk
+// to the v8 debugger. This class coordinates communication between the debug
+// agents and v8 debugger. It will set debug output handler as long as at least
+// one debugger agent is attached and remove it when last debugger agent is
+// detached. When message is received from debugger it will route it to the
+// right debugger agent if there is one otherwise the message will be ignored.
+//
+// v8 may send a message(e.g. exception event) after which it
+// would expect some actions from the handler. If there is no appropriate
+// debugger agent to handle such messages the manager will perform the action
+// itself, otherwise v8 may hang waiting for the action.
+class DebuggerAgentManager : public Noncopyable {
+public:
+ static void debugAttach(DebuggerAgentImpl* debuggerAgent);
+ static void debugDetach(DebuggerAgentImpl* debuggerAgent);
+ static void pauseScript();
+ static void executeDebuggerCommand(const WebCore::String& command, int callerId);
+ static void setMessageLoopDispatchHandler(WebDevToolsAgent::MessageLoopDispatchHandler handler);
+
+ // Sets |hostId| as the frame context data. This id is used to filter scripts
+ // related to the inspected page.
+ static void setHostId(WebFrameImpl* webframe, int hostId);
+
+ static void onWebViewClosed(WebViewImpl* webview);
+
+ static void onNavigate();
+
+ class UtilityContextScope : public Noncopyable {
+ public:
+ UtilityContextScope()
+ {
+ ASSERT(!s_inUtilityContext);
+ s_inUtilityContext = true;
+ }
+ ~UtilityContextScope()
+ {
+ if (s_debugBreakDelayed) {
+ v8::Debug::DebugBreak();
+ s_debugBreakDelayed = false;
+ }
+ s_inUtilityContext = false;
+ }
+ };
+
+private:
+ DebuggerAgentManager();
+ ~DebuggerAgentManager();
+
+ static void debugHostDispatchHandler();
+ static void onV8DebugMessage(const v8::Debug::Message& message);
+ static void sendCommandToV8(const WebCore::String& cmd,
+ v8::Debug::ClientData* data);
+ static void sendContinueCommandToV8();
+
+ static DebuggerAgentImpl* findAgentForCurrentV8Context();
+ static DebuggerAgentImpl* debuggerAgentForHostId(int hostId);
+
+ typedef HashMap<int, DebuggerAgentImpl*> AttachedAgentsMap;
+ static AttachedAgentsMap* s_attachedAgentsMap;
+
+ static WebDevToolsAgent::MessageLoopDispatchHandler s_messageLoopDispatchHandler;
+ static bool s_inHostDispatchHandler;
+ typedef HashMap<WebViewImpl*, WebCore::PageGroupLoadDeferrer*> DeferrersMap;
+ static DeferrersMap s_pageDeferrers;
+
+ static bool s_inUtilityContext;
+ static bool s_debugBreakDelayed;
+};
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/DevToolsRPC.h b/WebKit/chromium/src/DevToolsRPC.h
new file mode 100644
index 0000000..7176821
--- /dev/null
+++ b/WebKit/chromium/src/DevToolsRPC.h
@@ -0,0 +1,396 @@
+/*
+ * 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.
+ */
+
+// DevTools RPC subsystem is a simple string serialization-based rpc
+// implementation. The client is responsible for defining the Rpc-enabled
+// interface in terms of its macros:
+//
+// #define MYAPI_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3)
+// METHOD0(Method1)
+// METHOD1(Method3, int)
+// (snippet above should be multiline macro, add trailing backslashes)
+//
+// DEFINE_RPC_CLASS(MyApi, MYAPI_STRUCT)
+//
+// The snippet above will generate three classes: MyApi, MyApiStub and
+// MyApiDispatch.
+//
+// 1. For each method defined in the marco MyApi will have a
+// pure virtual function generated, so that MyApi would look like:
+//
+// class MyApi {
+// private:
+// MyApi() { }
+// ~MyApi() { }
+// virtual void method1() = 0;
+// virtual void method2(
+// int param1,
+// const String& param2,
+// const Value& param3) = 0;
+// virtual void method3(int param1) = 0;
+// };
+//
+// 2. MyApiStub will implement MyApi interface and would serialize all calls
+// into the string-based calls of the underlying transport:
+//
+// DevToolsRPC::Delegate* transport;
+// myApi = new MyApiStub(transport);
+// myApi->method1();
+// myApi->method3(2);
+//
+// 3. MyApiDelegate is capable of dispatching the calls and convert them to the
+// calls to the underlying MyApi methods:
+//
+// MyApi* realObject;
+// MyApiDispatch::dispatch(realObject, rawStringCallGeneratedByStub);
+//
+// will make corresponding calls to the real object.
+
+#ifndef DevToolsRPC_h
+#define DevToolsRPC_h
+
+#include "PlatformString.h"
+#include "Vector.h"
+#include "WebDevToolsMessageData.h"
+
+#include <wtf/Noncopyable.h>
+
+namespace WebCore {
+class String;
+}
+
+using WebCore::String;
+using WTF::Vector;
+
+namespace WebKit {
+
+///////////////////////////////////////////////////////
+// RPC dispatch macro
+
+template<typename T>
+struct RpcTypeTrait {
+ typedef T ApiType;
+};
+
+template<>
+struct RpcTypeTrait<bool> {
+ typedef bool ApiType;
+ static bool parse(const WebCore::String& t)
+ {
+ return t == "true";
+ }
+ static WebCore::String toString(bool b)
+ {
+ return b ? "true" : "false";
+ }
+};
+
+template<>
+struct RpcTypeTrait<int> {
+ typedef int ApiType;
+ static int parse(const WebCore::String& t)
+ {
+ bool success;
+ int i = t.toIntStrict(&success);
+ ASSERT(success);
+ return i;
+ }
+ static WebCore::String toString(int i)
+ {
+ return WebCore::String::number(i);
+ }
+};
+
+template<>
+struct RpcTypeTrait<String> {
+ typedef const String& ApiType;
+ static String parse(const WebCore::String& t)
+ {
+ return t;
+ }
+ static WebCore::String toString(const String& t)
+ {
+ return t;
+ }
+};
+
+///////////////////////////////////////////////////////
+// RPC Api method declarations
+
+#define TOOLS_RPC_API_METHOD0(Method) \
+ virtual void Method() = 0;
+
+#define TOOLS_RPC_API_METHOD1(Method, T1) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1) = 0;
+
+#define TOOLS_RPC_API_METHOD2(Method, T1, T2) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
+ RpcTypeTrait<T2>::ApiType t2) = 0;
+
+#define TOOLS_RPC_API_METHOD3(Method, T1, T2, T3) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
+ RpcTypeTrait<T2>::ApiType t2, \
+ RpcTypeTrait<T3>::ApiType t3) = 0;
+
+#define TOOLS_RPC_API_METHOD4(Method, T1, T2, T3, T4) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
+ RpcTypeTrait<T2>::ApiType t2, \
+ RpcTypeTrait<T3>::ApiType t3, \
+ RpcTypeTrait<T4>::ApiType t4) = 0;
+
+#define TOOLS_RPC_API_METHOD5(Method, T1, T2, T3, T4, T5) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
+ RpcTypeTrait<T2>::ApiType t2, \
+ RpcTypeTrait<T3>::ApiType t3, \
+ RpcTypeTrait<T4>::ApiType t4, \
+ RpcTypeTrait<T5>::ApiType t5) = 0;
+
+///////////////////////////////////////////////////////
+// RPC stub method implementations
+
+#define TOOLS_RPC_STUB_METHOD0(Method) \
+ virtual void Method() { \
+ Vector<String> args; \
+ this->sendRpcMessage(m_className, #Method, args); \
+ }
+
+#define TOOLS_RPC_STUB_METHOD1(Method, T1) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1) { \
+ Vector<String> args(1); \
+ args[0] = RpcTypeTrait<T1>::toString(t1); \
+ this->sendRpcMessage(m_className, #Method, args); \
+ }
+
+#define TOOLS_RPC_STUB_METHOD2(Method, T1, T2) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
+ RpcTypeTrait<T2>::ApiType t2) { \
+ Vector<String> args(2); \
+ args[0] = RpcTypeTrait<T1>::toString(t1); \
+ args[1] = RpcTypeTrait<T2>::toString(t2); \
+ this->sendRpcMessage(m_className, #Method, args); \
+ }
+
+#define TOOLS_RPC_STUB_METHOD3(Method, T1, T2, T3) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
+ RpcTypeTrait<T2>::ApiType t2, \
+ RpcTypeTrait<T3>::ApiType t3) { \
+ Vector<String> args(3); \
+ args[0] = RpcTypeTrait<T1>::toString(t1); \
+ args[1] = RpcTypeTrait<T2>::toString(t2); \
+ args[2] = RpcTypeTrait<T3>::toString(t3); \
+ this->sendRpcMessage(m_className, #Method, args); \
+ }
+
+#define TOOLS_RPC_STUB_METHOD4(Method, T1, T2, T3, T4) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
+ RpcTypeTrait<T2>::ApiType t2, \
+ RpcTypeTrait<T3>::ApiType t3, \
+ RpcTypeTrait<T4>::ApiType t4) { \
+ Vector<String> args(4); \
+ args[0] = RpcTypeTrait<T1>::toString(t1); \
+ args[1] = RpcTypeTrait<T2>::toString(t2); \
+ args[2] = RpcTypeTrait<T3>::toString(t3); \
+ args[3] = RpcTypeTrait<T4>::toString(t4); \
+ this->sendRpcMessage(m_className, #Method, args); \
+ }
+
+#define TOOLS_RPC_STUB_METHOD5(Method, T1, T2, T3, T4, T5) \
+ virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
+ RpcTypeTrait<T2>::ApiType t2, \
+ RpcTypeTrait<T3>::ApiType t3, \
+ RpcTypeTrait<T4>::ApiType t4, \
+ RpcTypeTrait<T5>::ApiType t5) { \
+ Vector<String> args(5); \
+ args[0] = RpcTypeTrait<T1>::toString(t1); \
+ args[1] = RpcTypeTrait<T2>::toString(t2); \
+ args[2] = RpcTypeTrait<T3>::toString(t3); \
+ args[3] = RpcTypeTrait<T4>::toString(t4); \
+ args[4] = RpcTypeTrait<T5>::toString(t5); \
+ this->sendRpcMessage(m_className, #Method, args); \
+ }
+
+///////////////////////////////////////////////////////
+// RPC dispatch method implementations
+
+#define TOOLS_RPC_DISPATCH0(Method) \
+if (methodName == #Method) { \
+ delegate->Method(); \
+ return true; \
+}
+
+#define TOOLS_RPC_DISPATCH1(Method, T1) \
+if (methodName == #Method) { \
+ delegate->Method(RpcTypeTrait<T1>::parse(args[0])); \
+ return true; \
+}
+
+#define TOOLS_RPC_DISPATCH2(Method, T1, T2) \
+if (methodName == #Method) { \
+ delegate->Method( \
+ RpcTypeTrait<T1>::parse(args[0]), \
+ RpcTypeTrait<T2>::parse(args[1]) \
+ ); \
+ return true; \
+}
+
+#define TOOLS_RPC_DISPATCH3(Method, T1, T2, T3) \
+if (methodName == #Method) { \
+ delegate->Method( \
+ RpcTypeTrait<T1>::parse(args[0]), \
+ RpcTypeTrait<T2>::parse(args[1]), \
+ RpcTypeTrait<T3>::parse(args[2]) \
+ ); \
+ return true; \
+}
+
+#define TOOLS_RPC_DISPATCH4(Method, T1, T2, T3, T4) \
+if (methodName == #Method) { \
+ delegate->Method( \
+ RpcTypeTrait<T1>::parse(args[0]), \
+ RpcTypeTrait<T2>::parse(args[1]), \
+ RpcTypeTrait<T3>::parse(args[2]), \
+ RpcTypeTrait<T4>::parse(args[3]) \
+ ); \
+ return true; \
+}
+
+#define TOOLS_RPC_DISPATCH5(Method, T1, T2, T3, T4, T5) \
+if (methodName == #Method) { \
+ delegate->Method( \
+ RpcTypeTrait<T1>::parse(args[0]), \
+ RpcTypeTrait<T2>::parse(args[1]), \
+ RpcTypeTrait<T3>::parse(args[2]), \
+ RpcTypeTrait<T4>::parse(args[3]), \
+ RpcTypeTrait<T5>::parse(args[4]) \
+ ); \
+ return true; \
+}
+
+#define TOOLS_END_RPC_DISPATCH() \
+}
+
+// This macro defines three classes: Class with the Api, ClassStub that is
+// serializing method calls and ClassDispatch that is capable of dispatching
+// the serialized message into its delegate.
+#define DEFINE_RPC_CLASS(Class, STRUCT) \
+class Class : public Noncopyable {\
+public: \
+ Class() \
+ { \
+ m_className = #Class; \
+ } \
+ virtual ~Class() { } \
+ \
+ STRUCT( \
+ TOOLS_RPC_API_METHOD0, \
+ TOOLS_RPC_API_METHOD1, \
+ TOOLS_RPC_API_METHOD2, \
+ TOOLS_RPC_API_METHOD3, \
+ TOOLS_RPC_API_METHOD4, \
+ TOOLS_RPC_API_METHOD5) \
+ WebCore::String m_className; \
+}; \
+\
+class Class##Stub \
+ : public Class \
+ , public DevToolsRPC { \
+public: \
+ explicit Class##Stub(Delegate* delegate) : DevToolsRPC(delegate) { } \
+ virtual ~Class##Stub() { } \
+ typedef Class CLASS; \
+ STRUCT( \
+ TOOLS_RPC_STUB_METHOD0, \
+ TOOLS_RPC_STUB_METHOD1, \
+ TOOLS_RPC_STUB_METHOD2, \
+ TOOLS_RPC_STUB_METHOD3, \
+ TOOLS_RPC_STUB_METHOD4, \
+ TOOLS_RPC_STUB_METHOD5) \
+}; \
+\
+class Class##Dispatch : public Noncopyable { \
+public: \
+ Class##Dispatch() { } \
+ virtual ~Class##Dispatch() { } \
+ \
+ static bool dispatch(Class* delegate, \
+ const WebKit::WebDevToolsMessageData& data) { \
+ String className = data.className; \
+ if (className != #Class) \
+ return false; \
+ String methodName = data.methodName; \
+ Vector<String> args; \
+ for (size_t i = 0; i < data.arguments.size(); i++) \
+ args.append(data.arguments[i]); \
+ typedef Class CLASS; \
+ STRUCT( \
+ TOOLS_RPC_DISPATCH0, \
+ TOOLS_RPC_DISPATCH1, \
+ TOOLS_RPC_DISPATCH2, \
+ TOOLS_RPC_DISPATCH3, \
+ TOOLS_RPC_DISPATCH4, \
+ TOOLS_RPC_DISPATCH5) \
+ return false; \
+ } \
+};
+
+///////////////////////////////////////////////////////
+// RPC base class
+class DevToolsRPC {
+public:
+ class Delegate {
+ public:
+ Delegate() { }
+ virtual ~Delegate() { }
+ virtual void sendRpcMessage(const WebKit::WebDevToolsMessageData& data) = 0;
+ };
+
+ explicit DevToolsRPC(Delegate* delegate) : m_delegate(delegate) { }
+ virtual ~DevToolsRPC() { };
+
+protected:
+ void sendRpcMessage(const String& className,
+ const String& methodName,
+ const Vector<String>& args) {
+ WebKit::WebVector<WebKit::WebString> webArgs(args.size());
+ for (size_t i = 0; i < args.size(); i++)
+ webArgs[i] = args[i];
+ WebKit::WebDevToolsMessageData data;
+ data.className = className;
+ data.methodName = methodName;
+ data.arguments.swap(webArgs);
+ this->m_delegate->sendRpcMessage(data);
+ }
+
+ Delegate* m_delegate;
+};
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/DevToolsRPCJS.h b/WebKit/chromium/src/DevToolsRPCJS.h
new file mode 100644
index 0000000..8ae279f
--- /dev/null
+++ b/WebKit/chromium/src/DevToolsRPCJS.h
@@ -0,0 +1,147 @@
+/*
+ * 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.
+ */
+
+// Additional set of macros for the JS RPC.
+
+#ifndef DevToolsRPCJS_h
+#define DevToolsRPCJS_h
+
+// Do not remove this one although it is not used.
+#include "BoundObject.h"
+#include "DevToolsRPC.h"
+#include "WebFrame.h"
+#include <wtf/Noncopyable.h>
+#include <wtf/OwnPtr.h>
+
+namespace WebKit {
+
+///////////////////////////////////////////////////////
+// JS RPC binds and stubs
+
+#define TOOLS_RPC_JS_BIND_METHOD0(Method) \
+ boundObj.addProtoFunction(#Method, OCLASS::js##Method);
+
+#define TOOLS_RPC_JS_BIND_METHOD1(Method, T1) \
+ boundObj.addProtoFunction(#Method, OCLASS::js##Method);
+
+#define TOOLS_RPC_JS_BIND_METHOD2(Method, T1, T2) \
+ boundObj.addProtoFunction(#Method, OCLASS::js##Method);
+
+#define TOOLS_RPC_JS_BIND_METHOD3(Method, T1, T2, T3) \
+ boundObj.addProtoFunction(#Method, OCLASS::js##Method);
+
+#define TOOLS_RPC_JS_BIND_METHOD4(Method, T1, T2, T3, T4) \
+ boundObj.addProtoFunction(#Method, OCLASS::js##Method);
+
+#define TOOLS_RPC_JS_BIND_METHOD5(Method, T1, T2, T3, T4, T5) \
+ boundObj.addProtoFunction(#Method, OCLASS::js##Method);
+
+#define TOOLS_RPC_JS_STUB_METHOD0(Method) \
+ static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \
+ sendRpcMessageFromJS(#Method, args, 0); \
+ return v8::Undefined(); \
+ }
+
+#define TOOLS_RPC_JS_STUB_METHOD1(Method, T1) \
+ static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \
+ sendRpcMessageFromJS(#Method, args, 1); \
+ return v8::Undefined(); \
+ }
+
+#define TOOLS_RPC_JS_STUB_METHOD2(Method, T1, T2) \
+ static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \
+ sendRpcMessageFromJS(#Method, args, 2); \
+ return v8::Undefined(); \
+ }
+
+#define TOOLS_RPC_JS_STUB_METHOD3(Method, T1, T2, T3) \
+ static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \
+ sendRpcMessageFromJS(#Method, args, 3); \
+ return v8::Undefined(); \
+ }
+
+#define TOOLS_RPC_JS_STUB_METHOD4(Method, T1, T2, T3, T4) \
+ static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \
+ sendRpcMessageFromJS(#Method, args, 4); \
+ return v8::Undefined(); \
+ }
+
+#define TOOLS_RPC_JS_STUB_METHOD5(Method, T1, T2, T3, T4, T5) \
+ static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \
+ sendRpcMessageFromJS(#Method, args, 5); \
+ return v8::Undefined(); \
+ }
+
+///////////////////////////////////////////////////////
+// JS RPC main obj macro
+
+#define DEFINE_RPC_JS_BOUND_OBJ(Class, STRUCT, DClass, DELEGATE_STRUCT) \
+class JS##Class##BoundObj : public Class##Stub { \
+public: \
+ JS##Class##BoundObj(Delegate* rpcDelegate, \
+ v8::Handle<v8::Context> context, \
+ const char* classname) \
+ : Class##Stub(rpcDelegate) { \
+ BoundObject boundObj(context, this, classname); \
+ STRUCT( \
+ TOOLS_RPC_JS_BIND_METHOD0, \
+ TOOLS_RPC_JS_BIND_METHOD1, \
+ TOOLS_RPC_JS_BIND_METHOD2, \
+ TOOLS_RPC_JS_BIND_METHOD3, \
+ TOOLS_RPC_JS_BIND_METHOD4, \
+ TOOLS_RPC_JS_BIND_METHOD5) \
+ boundObj.build(); \
+ } \
+ virtual ~JS##Class##BoundObj() { } \
+ typedef JS##Class##BoundObj OCLASS; \
+ STRUCT( \
+ TOOLS_RPC_JS_STUB_METHOD0, \
+ TOOLS_RPC_JS_STUB_METHOD1, \
+ TOOLS_RPC_JS_STUB_METHOD2, \
+ TOOLS_RPC_JS_STUB_METHOD3, \
+ TOOLS_RPC_JS_STUB_METHOD4, \
+ TOOLS_RPC_JS_STUB_METHOD5) \
+private: \
+ static void sendRpcMessageFromJS(const char* method, \
+ const v8::Arguments& jsArguments, \
+ size_t argsCount) \
+ { \
+ Vector<String> args(argsCount); \
+ for (size_t i = 0; i < argsCount; i++) \
+ args[i] = WebCore::toWebCoreStringWithNullCheck(jsArguments[i]); \
+ void* selfPtr = v8::External::Cast(*jsArguments.Data())->Value(); \
+ JS##Class##BoundObj* self = static_cast<JS##Class##BoundObj*>(selfPtr); \
+ self->sendRpcMessage(#Class, method, args); \
+ } \
+};
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/ProfilerAgent.h b/WebKit/chromium/src/ProfilerAgent.h
new file mode 100644
index 0000000..52337b8
--- /dev/null
+++ b/WebKit/chromium/src/ProfilerAgent.h
@@ -0,0 +1,61 @@
+/*
+ * 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.
+ */
+
+#ifndef ProfilerAgent_h
+#define ProfilerAgent_h
+
+#include "DevToolsRPC.h"
+
+namespace WebKit {
+
+// Profiler agent provides API for retrieving profiler data.
+// These methods are handled on the IO thread, so profiler can
+// operate while a script on a page performs heavy work.
+#define PROFILER_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \
+ /* Requests current profiler state. */ \
+ METHOD0(getActiveProfilerModules) \
+ \
+ /* Retrieves portion of profiler log. */ \
+ METHOD1(getLogLines, int /* position */)
+
+DEFINE_RPC_CLASS(ProfilerAgent, PROFILER_AGENT_STRUCT)
+
+#define PROFILER_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \
+ /* Response to getActiveProfilerModules. */ \
+ METHOD1(didGetActiveProfilerModules, int /* flags */) \
+ \
+ /* Response to getLogLines. */ \
+ METHOD2(didGetLogLines, int /* position */, String /* log */)
+
+DEFINE_RPC_CLASS(ProfilerAgentDelegate, PROFILER_AGENT_DELEGATE_STRUCT)
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/ProfilerAgentImpl.cpp b/WebKit/chromium/src/ProfilerAgentImpl.cpp
new file mode 100644
index 0000000..07570df
--- /dev/null
+++ b/WebKit/chromium/src/ProfilerAgentImpl.cpp
@@ -0,0 +1,52 @@
+/*
+ * 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 "ProfilerAgentImpl.h"
+
+#include <v8.h>
+
+namespace WebKit {
+
+void ProfilerAgentImpl::getActiveProfilerModules()
+{
+ m_delegate->didGetActiveProfilerModules(v8::V8::GetActiveProfilerModules());
+}
+
+void ProfilerAgentImpl::getLogLines(int position)
+{
+ static char buffer[65536];
+ const int readSize = v8::V8::GetLogLines(position, buffer, sizeof(buffer) - 1);
+ buffer[readSize] = '\0';
+ position += readSize;
+ m_delegate->didGetLogLines(position, buffer);
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/ProfilerAgentImpl.h b/WebKit/chromium/src/ProfilerAgentImpl.h
new file mode 100644
index 0000000..d38f57c
--- /dev/null
+++ b/WebKit/chromium/src/ProfilerAgentImpl.h
@@ -0,0 +1,57 @@
+/*
+ * 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.
+ */
+
+#ifndef ProfilerAgentImpl_h
+#define ProfilerAgentImpl_h
+
+#include "ProfilerAgent.h"
+
+namespace WebKit {
+
+class ProfilerAgentImpl : public ProfilerAgent {
+public:
+ ProfilerAgentImpl(ProfilerAgentDelegate* delegate) : m_delegate(delegate) { }
+ virtual ~ProfilerAgentImpl() { }
+
+ // ProfilerAgent implementation.
+
+ // This method is called on IO thread.
+ virtual void getActiveProfilerModules();
+
+ // This method is called on IO thread.
+ virtual void getLogLines(int position);
+
+private:
+ ProfilerAgentDelegate* m_delegate;
+};
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/ToolsAgent.h b/WebKit/chromium/src/ToolsAgent.h
new file mode 100644
index 0000000..fd1fcb7
--- /dev/null
+++ b/WebKit/chromium/src/ToolsAgent.h
@@ -0,0 +1,69 @@
+/*
+ * 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.
+ */
+
+#ifndef ToolsAgent_h
+#define ToolsAgent_h
+
+#include "DevToolsRPC.h"
+
+namespace WebKit {
+
+// Tools agent provides API for enabling / disabling other agents as well as
+// API for auxiliary UI functions such as dom elements highlighting.
+#define TOOLS_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \
+ /* Request the agent to to run a no-op JavaScript function to trigger v8 execution. */ \
+ METHOD0(executeVoidJavaScript) \
+ \
+ /* Dispatches given function on the InspectorController object */ \
+ METHOD3(dispatchOnInspectorController, int /* call_id */, \
+ String /* function_name */, String /* json_args */) \
+ \
+ /* Dispatches given function on the InjectedScript object */ \
+ METHOD5(dispatchOnInjectedScript, int /* call_id */, \
+ int /* injected_script_id */, String /* function_name */, \
+ String /* json_args */, bool /* async */)
+
+DEFINE_RPC_CLASS(ToolsAgent, TOOLS_AGENT_STRUCT)
+
+#define TOOLS_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \
+ /* Updates focused node on the client. */ \
+ METHOD1(frameNavigate, String /* url */) \
+ \
+ /* Response to the DispatchOn*. */ \
+ METHOD3(didDispatchOn, int /* call_id */, String /* result */, String /* exception */) \
+ \
+ /* Sends InspectorFrontend message to be dispatched on client. */ \
+ METHOD1(dispatchOnClient, String /* data */)
+
+DEFINE_RPC_CLASS(ToolsAgentDelegate, TOOLS_AGENT_DELEGATE_STRUCT)
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/WebDevToolsAgentImpl.cpp b/WebKit/chromium/src/WebDevToolsAgentImpl.cpp
new file mode 100644
index 0000000..9d386f3
--- /dev/null
+++ b/WebKit/chromium/src/WebDevToolsAgentImpl.cpp
@@ -0,0 +1,566 @@
+/*
+ * 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 "WebDevToolsAgentImpl.h"
+
+#include "BoundObject.h"
+#include "DebuggerAgentImpl.h"
+#include "DebuggerAgentManager.h"
+#include "Document.h"
+#include "EventListener.h"
+#include "InjectedScriptHost.h"
+#include "InspectorBackend.h"
+#include "InspectorController.h"
+#include "InspectorFrontend.h"
+#include "InspectorResource.h"
+#include "Node.h"
+#include "Page.h"
+#include "PlatformString.h"
+#include "ProfilerAgentImpl.h"
+#include "ResourceError.h"
+#include "ResourceRequest.h"
+#include "ResourceResponse.h"
+#include "ScriptObject.h"
+#include "ScriptState.h"
+#include "ScriptValue.h"
+#include "V8Binding.h"
+#include "V8Proxy.h"
+#include "V8Utilities.h"
+#include "WebDataSource.h"
+#include "WebDevToolsAgentClient.h"
+#include "WebDevToolsMessageData.h"
+#include "WebFrameImpl.h"
+#include "WebString.h"
+#include "WebURL.h"
+#include "WebURLError.h"
+#include "WebURLRequest.h"
+#include "WebURLResponse.h"
+#include "WebViewImpl.h"
+#include <wtf/Noncopyable.h>
+#include <wtf/OwnPtr.h>
+
+using WebCore::Document;
+using WebCore::DocumentLoader;
+using WebCore::FrameLoader;
+using WebCore::InjectedScriptHost;
+using WebCore::InspectorBackend;
+using WebCore::InspectorController;
+using WebCore::InspectorFrontend;
+using WebCore::InspectorResource;
+using WebCore::Node;
+using WebCore::Page;
+using WebCore::ResourceError;
+using WebCore::ResourceRequest;
+using WebCore::ResourceResponse;
+using WebCore::SafeAllocation;
+using WebCore::ScriptObject;
+using WebCore::ScriptState;
+using WebCore::ScriptValue;
+using WebCore::String;
+using WebCore::V8ClassIndex;
+using WebCore::V8DOMWrapper;
+using WebCore::V8Proxy;
+
+namespace WebKit {
+
+namespace {
+
+void InspectorBackendWeakReferenceCallback(v8::Persistent<v8::Value> object, void* parameter)
+{
+ InspectorBackend* backend = static_cast<InspectorBackend*>(parameter);
+ backend->deref();
+ object.Dispose();
+}
+
+void SetApuAgentEnabledInUtilityContext(v8::Handle<v8::Context> context, bool enabled)
+{
+ v8::HandleScope handleScope;
+ v8::Context::Scope contextScope(context);
+ v8::Handle<v8::Object> dispatcher = v8::Local<v8::Object>::Cast(
+ context->Global()->Get(v8::String::New("ApuAgentDispatcher")));
+ if (dispatcher.IsEmpty())
+ return;
+ dispatcher->Set(v8::String::New("enabled"), v8::Boolean::New(enabled));
+}
+
+// TODO(pfeldman): Make this public in WebDevToolsAgent API.
+static const char kApuAgentFeatureName[] = "apu-agent";
+
+// Keep these in sync with the ones in inject_dispatch.js.
+static const char kTimelineFeatureName[] = "timeline-profiler";
+static const char kResourceTrackingFeatureName[] = "resource-tracking";
+
+class IORPCDelegate : public DevToolsRPC::Delegate, public Noncopyable {
+public:
+ IORPCDelegate() { }
+ virtual ~IORPCDelegate() { }
+ virtual void sendRpcMessage(const WebDevToolsMessageData& data)
+ {
+ WebDevToolsAgentClient::sendMessageToFrontendOnIOThread(data);
+ }
+};
+
+} // namespace
+
+WebDevToolsAgentImpl::WebDevToolsAgentImpl(
+ WebViewImpl* webViewImpl,
+ WebDevToolsAgentClient* client)
+ : m_hostId(client->hostIdentifier())
+ , m_client(client)
+ , m_webViewImpl(webViewImpl)
+ , m_apuAgentEnabled(false)
+ , m_resourceTrackingWasEnabled(false)
+ , m_attached(false)
+{
+ m_debuggerAgentDelegateStub.set(new DebuggerAgentDelegateStub(this));
+ m_toolsAgentDelegateStub.set(new ToolsAgentDelegateStub(this));
+ m_apuAgentDelegateStub.set(new ApuAgentDelegateStub(this));
+}
+
+WebDevToolsAgentImpl::~WebDevToolsAgentImpl()
+{
+ DebuggerAgentManager::onWebViewClosed(m_webViewImpl);
+ disposeUtilityContext();
+}
+
+void WebDevToolsAgentImpl::disposeUtilityContext()
+{
+ if (!m_utilityContext.IsEmpty()) {
+ m_utilityContext.Dispose();
+ m_utilityContext.Clear();
+ }
+}
+
+void WebDevToolsAgentImpl::unhideResourcesPanelIfNecessary()
+{
+ InspectorController* ic = m_webViewImpl->page()->inspectorController();
+ ic->ensureResourceTrackingSettingsLoaded();
+ String command = String::format("[\"setResourcesPanelEnabled\", %s]",
+ ic->resourceTrackingEnabled() ? "true" : "false");
+ m_toolsAgentDelegateStub->dispatchOnClient(command);
+}
+
+void WebDevToolsAgentImpl::attach()
+{
+ if (m_attached)
+ return;
+ m_debuggerAgentImpl.set(
+ new DebuggerAgentImpl(m_webViewImpl,
+ m_debuggerAgentDelegateStub.get(),
+ this));
+ resetInspectorFrontendProxy();
+ unhideResourcesPanelIfNecessary();
+ // Allow controller to send messages to the frontend.
+ InspectorController* ic = inspectorController();
+
+ { // TODO(yurys): the source should have already been pushed by the frontend.
+ v8::HandleScope scope;
+ v8::Context::Scope contextScope(m_utilityContext);
+ v8::Handle<v8::Value> constructorValue = m_utilityContext->Global()->Get(
+ v8::String::New("injectedScriptConstructor"));
+ if (constructorValue->IsFunction()) {
+ String source = WebCore::toWebCoreString(constructorValue);
+ ic->injectedScriptHost()->setInjectedScriptSource("(" + source + ")");
+ }
+ }
+
+ ic->setWindowVisible(true, false);
+ m_attached = true;
+}
+
+void WebDevToolsAgentImpl::detach()
+{
+ // Prevent controller from sending messages to the frontend.
+ InspectorController* ic = m_webViewImpl->page()->inspectorController();
+ ic->hideHighlight();
+ ic->close();
+ disposeUtilityContext();
+ m_debuggerAgentImpl.set(0);
+ m_attached = false;
+ m_apuAgentEnabled = false;
+}
+
+void WebDevToolsAgentImpl::didNavigate()
+{
+ DebuggerAgentManager::onNavigate();
+}
+
+void WebDevToolsAgentImpl::didCommitProvisionalLoad(WebFrameImpl* webframe, bool isNewNavigation)
+{
+ if (!m_attached)
+ return;
+ WebDataSource* ds = webframe->dataSource();
+ const WebURLRequest& request = ds->request();
+ WebURL url = ds->hasUnreachableURL() ?
+ ds->unreachableURL() :
+ request.url();
+ if (!webframe->parent()) {
+ resetInspectorFrontendProxy();
+ m_toolsAgentDelegateStub->frameNavigate(WebCore::KURL(url).string());
+ SetApuAgentEnabledInUtilityContext(m_utilityContext, m_apuAgentEnabled);
+ unhideResourcesPanelIfNecessary();
+ }
+}
+
+void WebDevToolsAgentImpl::didClearWindowObject(WebFrameImpl* webframe)
+{
+ DebuggerAgentManager::setHostId(webframe, m_hostId);
+ if (m_attached) {
+ // Push context id into the client if it is already attached.
+ m_debuggerAgentDelegateStub->setContextId(m_hostId);
+ }
+}
+
+void WebDevToolsAgentImpl::forceRepaint()
+{
+ m_client->forceRepaint();
+}
+
+void WebDevToolsAgentImpl::dispatchOnInspectorController(int callId, const String& functionName, const String& jsonArgs)
+{
+ String result;
+ String exception;
+ result = m_debuggerAgentImpl->executeUtilityFunction(m_utilityContext, callId,
+ "InspectorControllerDispatcher", functionName, jsonArgs, false /* is sync */, &exception);
+ m_toolsAgentDelegateStub->didDispatchOn(callId, result, exception);
+}
+
+void WebDevToolsAgentImpl::dispatchOnInjectedScript(int callId, int injectedScriptId, const String& functionName, const String& jsonArgs, bool async)
+{
+ inspectorController()->inspectorBackend()->dispatchOnInjectedScript(
+ callId,
+ injectedScriptId,
+ functionName,
+ jsonArgs,
+ async);
+}
+
+void WebDevToolsAgentImpl::executeVoidJavaScript()
+{
+ m_debuggerAgentImpl->executeVoidJavaScript(m_utilityContext);
+}
+
+void WebDevToolsAgentImpl::dispatchMessageFromFrontend(const WebDevToolsMessageData& data)
+{
+ if (ToolsAgentDispatch::dispatch(this, data))
+ return;
+
+ if (!m_attached)
+ return;
+
+ if (m_debuggerAgentImpl.get() && DebuggerAgentDispatch::dispatch(m_debuggerAgentImpl.get(), data))
+ return;
+}
+
+void WebDevToolsAgentImpl::inspectElementAt(const WebPoint& point)
+{
+ m_webViewImpl->inspectElementAt(point);
+}
+
+void WebDevToolsAgentImpl::setRuntimeFeatureEnabled(const WebString& feature, bool enabled)
+{
+ if (feature == kApuAgentFeatureName)
+ setApuAgentEnabled(enabled);
+ else if (feature == kTimelineFeatureName)
+ setTimelineProfilingEnabled(enabled);
+ else if (feature == kResourceTrackingFeatureName) {
+ InspectorController* ic = m_webViewImpl->page()->inspectorController();
+ if (enabled)
+ ic->enableResourceTracking(false /* not sticky */, false /* no reload */);
+ else
+ ic->disableResourceTracking(false /* not sticky */);
+ }
+}
+
+void WebDevToolsAgentImpl::sendRpcMessage(const WebDevToolsMessageData& data)
+{
+ m_client->sendMessageToFrontend(data);
+}
+
+void WebDevToolsAgentImpl::compileUtilityScripts()
+{
+ v8::HandleScope handleScope;
+ v8::Context::Scope contextScope(m_utilityContext);
+ // Inject javascript into the context.
+ WebCString injectedScriptJs = m_client->injectedScriptSource();
+ v8::Script::Compile(v8::String::New(
+ injectedScriptJs.data(),
+ injectedScriptJs.length()))->Run();
+ WebCString injectDispatchJs = m_client->injectedScriptDispatcherSource();
+ v8::Script::Compile(v8::String::New(
+ injectDispatchJs.data(),
+ injectDispatchJs.length()))->Run();
+}
+
+void WebDevToolsAgentImpl::initDevToolsAgentHost()
+{
+ BoundObject devtoolsAgentHost(m_utilityContext, this, "DevToolsAgentHost");
+ devtoolsAgentHost.addProtoFunction(
+ "dispatch",
+ WebDevToolsAgentImpl::jsDispatchOnClient);
+ devtoolsAgentHost.addProtoFunction(
+ "dispatchToApu",
+ WebDevToolsAgentImpl::jsDispatchToApu);
+ devtoolsAgentHost.addProtoFunction(
+ "evaluateOnSelf",
+ WebDevToolsAgentImpl::jsEvaluateOnSelf);
+ devtoolsAgentHost.addProtoFunction(
+ "runtimeFeatureStateChanged",
+ WebDevToolsAgentImpl::jsOnRuntimeFeatureStateChanged);
+ devtoolsAgentHost.build();
+
+ v8::HandleScope scope;
+ v8::Context::Scope utilityScope(m_utilityContext);
+ // Call custom code to create inspector backend wrapper in the utility context
+ // instead of calling V8DOMWrapper::convertToV8Object that would create the
+ // wrapper in the Page main frame context.
+ v8::Handle<v8::Object> backendWrapper = createInspectorBackendV8Wrapper();
+ if (backendWrapper.IsEmpty())
+ return;
+ m_utilityContext->Global()->Set(v8::String::New("InspectorBackend"), backendWrapper);
+}
+
+v8::Local<v8::Object> WebDevToolsAgentImpl::createInspectorBackendV8Wrapper()
+{
+ V8ClassIndex::V8WrapperType descriptorType = V8ClassIndex::INSPECTORBACKEND;
+ v8::Handle<v8::Function> function = V8DOMWrapper::getTemplate(descriptorType)->GetFunction();
+ if (function.IsEmpty()) {
+ // Return if allocation failed.
+ return v8::Local<v8::Object>();
+ }
+ v8::Local<v8::Object> instance = SafeAllocation::newInstance(function);
+ if (instance.IsEmpty()) {
+ // Avoid setting the wrapper if allocation failed.
+ return v8::Local<v8::Object>();
+ }
+ InspectorBackend* backend = m_webViewImpl->page()->inspectorController()->inspectorBackend();
+ V8DOMWrapper::setDOMWrapper(instance, V8ClassIndex::ToInt(descriptorType), backend);
+ // Create a weak reference to the v8 wrapper of InspectorBackend to deref
+ // InspectorBackend when the wrapper is garbage collected.
+ backend->ref();
+ v8::Persistent<v8::Object> weakHandle = v8::Persistent<v8::Object>::New(instance);
+ weakHandle.MakeWeak(backend, &InspectorBackendWeakReferenceCallback);
+ return instance;
+}
+
+void WebDevToolsAgentImpl::resetInspectorFrontendProxy()
+{
+ disposeUtilityContext();
+ m_debuggerAgentImpl->createUtilityContext(m_webViewImpl->page()->mainFrame(), &m_utilityContext);
+ compileUtilityScripts();
+ initDevToolsAgentHost();
+
+ v8::HandleScope scope;
+ v8::Context::Scope contextScope(m_utilityContext);
+ ScriptState* state = ScriptState::forContext(
+ v8::Local<v8::Context>::New(m_utilityContext));
+ InspectorController* ic = inspectorController();
+ ic->setFrontendProxyObject(state, ScriptObject(state, m_utilityContext->Global()));
+}
+
+void WebDevToolsAgentImpl::setApuAgentEnabled(bool enabled)
+{
+ m_apuAgentEnabled = enabled;
+ SetApuAgentEnabledInUtilityContext(m_utilityContext, enabled);
+ InspectorController* ic = m_webViewImpl->page()->inspectorController();
+ if (enabled) {
+ m_resourceTrackingWasEnabled = ic->resourceTrackingEnabled();
+ ic->startTimelineProfiler();
+ if (!m_resourceTrackingWasEnabled) {
+ // TODO(knorton): Introduce some kind of agents dependency here so that
+ // user could turn off resource tracking while apu agent is on.
+ ic->enableResourceTracking(false, false);
+ }
+ m_debuggerAgentImpl->setAutoContinueOnException(true);
+ } else {
+ ic->stopTimelineProfiler();
+ if (!m_resourceTrackingWasEnabled)
+ ic->disableResourceTracking(false);
+ m_resourceTrackingWasEnabled = false;
+ }
+ m_client->runtimeFeatureStateChanged(
+ kApuAgentFeatureName,
+ enabled);
+}
+
+// static
+v8::Handle<v8::Value> WebDevToolsAgentImpl::jsDispatchOnClient(const v8::Arguments& args)
+{
+ v8::TryCatch exceptionCatcher;
+ String message = WebCore::toWebCoreStringWithNullCheck(args[0]);
+ if (message.isEmpty() || exceptionCatcher.HasCaught())
+ return v8::Undefined();
+ WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(v8::External::Cast(*args.Data())->Value());
+ agent->m_toolsAgentDelegateStub->dispatchOnClient(message);
+ return v8::Undefined();
+}
+
+// static
+v8::Handle<v8::Value> WebDevToolsAgentImpl::jsDispatchToApu(const v8::Arguments& args)
+{
+ v8::TryCatch exceptionCatcher;
+ String message = WebCore::toWebCoreStringWithNullCheck(args[0]);
+ if (message.isEmpty() || exceptionCatcher.HasCaught())
+ return v8::Undefined();
+ WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(
+ v8::External::Cast(*args.Data())->Value());
+ agent->m_apuAgentDelegateStub->dispatchToApu(message);
+ return v8::Undefined();
+}
+
+// static
+v8::Handle<v8::Value> WebDevToolsAgentImpl::jsEvaluateOnSelf(const v8::Arguments& args)
+{
+ String code;
+ {
+ v8::TryCatch exceptionCatcher;
+ code = WebCore::toWebCoreStringWithNullCheck(args[0]);
+ if (code.isEmpty() || exceptionCatcher.HasCaught())
+ return v8::Undefined();
+ }
+ WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(v8::External::Cast(*args.Data())->Value());
+ v8::Context::Scope(agent->m_utilityContext);
+ V8Proxy* proxy = V8Proxy::retrieve(agent->m_webViewImpl->page()->mainFrame());
+ v8::Local<v8::Value> result = proxy->runScript(v8::Script::Compile(v8::String::New(code.utf8().data())), true);
+ return result;
+}
+
+// static
+v8::Handle<v8::Value> WebDevToolsAgentImpl::jsOnRuntimeFeatureStateChanged(const v8::Arguments& args)
+{
+ v8::TryCatch exceptionCatcher;
+ String feature = WebCore::toWebCoreStringWithNullCheck(args[0]);
+ bool enabled = args[1]->ToBoolean()->Value();
+ if (feature.isEmpty() || exceptionCatcher.HasCaught())
+ return v8::Undefined();
+ WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(v8::External::Cast(*args.Data())->Value());
+ agent->m_client->runtimeFeatureStateChanged(feature, enabled);
+ return v8::Undefined();
+}
+
+
+WebCore::InspectorController* WebDevToolsAgentImpl::inspectorController()
+{
+ if (Page* page = m_webViewImpl->page())
+ return page->inspectorController();
+ return 0;
+}
+
+
+//------- plugin resource load notifications ---------------
+void WebDevToolsAgentImpl::identifierForInitialRequest(
+ unsigned long resourceId,
+ WebFrame* frame,
+ const WebURLRequest& request)
+{
+ if (InspectorController* ic = inspectorController()) {
+ WebFrameImpl* webFrameImpl = static_cast<WebFrameImpl*>(frame);
+ FrameLoader* frameLoader = webFrameImpl->frame()->loader();
+ DocumentLoader* loader = frameLoader->activeDocumentLoader();
+ ic->identifierForInitialRequest(resourceId, loader, request.toResourceRequest());
+ }
+}
+
+void WebDevToolsAgentImpl::willSendRequest(unsigned long resourceId, const WebURLRequest& request)
+{
+ if (InspectorController* ic = inspectorController())
+ ic->willSendRequest(resourceId, request.toResourceRequest(), ResourceResponse());
+}
+
+void WebDevToolsAgentImpl::didReceiveData(unsigned long resourceId, int length)
+{
+ if (InspectorController* ic = inspectorController())
+ ic->didReceiveContentLength(resourceId, length);
+}
+
+void WebDevToolsAgentImpl::didReceiveResponse(unsigned long resourceId, const WebURLResponse& response)
+{
+ if (InspectorController* ic = inspectorController())
+ ic->didReceiveResponse(resourceId, response.toResourceResponse());
+}
+
+void WebDevToolsAgentImpl::didFinishLoading(unsigned long resourceId)
+{
+ if (InspectorController* ic = inspectorController())
+ ic->didFinishLoading(resourceId);
+}
+
+void WebDevToolsAgentImpl::didFailLoading(unsigned long resourceId, const WebURLError& error)
+{
+ ResourceError resourceError;
+ if (InspectorController* ic = inspectorController())
+ ic->didFailLoading(resourceId, resourceError);
+}
+
+void WebDevToolsAgentImpl::evaluateInWebInspector(long callId, const WebString& script)
+{
+ InspectorController* ic = inspectorController();
+ ic->evaluateForTestInFrontend(callId, script);
+}
+
+void WebDevToolsAgentImpl::setTimelineProfilingEnabled(bool enabled)
+{
+ InspectorController* ic = inspectorController();
+ if (enabled)
+ ic->startTimelineProfiler();
+ else
+ ic->stopTimelineProfiler();
+}
+
+WebDevToolsAgent* WebDevToolsAgent::create(WebView* webview, WebDevToolsAgentClient* client)
+{
+ return new WebDevToolsAgentImpl(static_cast<WebViewImpl*>(webview), client);
+}
+
+void WebDevToolsAgent::executeDebuggerCommand(const WebString& command, int callerId)
+{
+ DebuggerAgentManager::executeDebuggerCommand(command, callerId);
+}
+
+void WebDevToolsAgent::debuggerPauseScript()
+{
+ DebuggerAgentManager::pauseScript();
+}
+
+void WebDevToolsAgent::setMessageLoopDispatchHandler(MessageLoopDispatchHandler handler)
+{
+ DebuggerAgentManager::setMessageLoopDispatchHandler(handler);
+}
+
+bool WebDevToolsAgent::dispatchMessageFromFrontendOnIOThread(const WebDevToolsMessageData& data)
+{
+ IORPCDelegate transport;
+ ProfilerAgentDelegateStub stub(&transport);
+ ProfilerAgentImpl agent(&stub);
+ return ProfilerAgentDispatch::dispatch(&agent, data);
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/WebDevToolsAgentImpl.h b/WebKit/chromium/src/WebDevToolsAgentImpl.h
new file mode 100644
index 0000000..3f5928b
--- /dev/null
+++ b/WebKit/chromium/src/WebDevToolsAgentImpl.h
@@ -0,0 +1,142 @@
+/*
+ * 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.
+ */
+
+#ifndef WebDevToolsAgentImpl_h
+#define WebDevToolsAgentImpl_h
+
+#include "APUAgentDelegate.h"
+#include "DevToolsRPC.h"
+#include "ToolsAgent.h"
+#include "WebDevToolsAgentPrivate.h"
+
+#include <v8.h>
+#include <wtf/OwnPtr.h>
+
+namespace WebCore {
+class Document;
+class InspectorController;
+class Node;
+class String;
+}
+
+namespace WebKit {
+
+class DebuggerAgentDelegateStub;
+class DebuggerAgentImpl;
+class WebDevToolsAgentClient;
+class WebFrame;
+class WebFrameImpl;
+class WebString;
+class WebURLRequest;
+class WebURLResponse;
+class WebViewImpl;
+struct WebURLError;
+struct WebDevToolsMessageData;
+
+class WebDevToolsAgentImpl : public WebDevToolsAgentPrivate,
+ public ToolsAgent,
+ public DevToolsRPC::Delegate {
+public:
+ WebDevToolsAgentImpl(WebViewImpl* webViewImpl, WebDevToolsAgentClient* client);
+ virtual ~WebDevToolsAgentImpl();
+
+ // ToolsAgent implementation.
+ virtual void dispatchOnInspectorController(int callId, const WebCore::String& functionName, const WebCore::String& jsonArgs);
+ virtual void dispatchOnInjectedScript(int callId, int injectedScriptId, const WebCore::String& functionName, const WebCore::String& jsonArgs, bool async);
+ virtual void executeVoidJavaScript();
+
+ // WebDevToolsAgentPrivate implementation.
+ virtual void didClearWindowObject(WebFrameImpl* frame);
+ virtual void didCommitProvisionalLoad(WebFrameImpl* frame, bool isNewNavigation);
+
+ // WebDevToolsAgent implementation.
+ virtual void attach();
+ virtual void detach();
+ virtual void didNavigate();
+ virtual void dispatchMessageFromFrontend(const WebDevToolsMessageData& data);
+ virtual void inspectElementAt(const WebPoint& point);
+ virtual void evaluateInWebInspector(long callId, const WebString& script);
+ virtual void setRuntimeFeatureEnabled(const WebString& feature, bool enabled);
+ virtual void setTimelineProfilingEnabled(bool enable);
+
+ virtual void identifierForInitialRequest(unsigned long, WebFrame*, const WebURLRequest&);
+ virtual void willSendRequest(unsigned long, const WebURLRequest&);
+ virtual void didReceiveData(unsigned long, int length);
+ virtual void didReceiveResponse(unsigned long, const WebURLResponse&);
+ virtual void didFinishLoading(unsigned long);
+ virtual void didFailLoading(unsigned long, const WebURLError&);
+
+ // DevToolsRPC::Delegate implementation.
+ virtual void sendRpcMessage(const WebDevToolsMessageData& data);
+
+ void forceRepaint();
+
+ int hostId() { return m_hostId; }
+
+private:
+ static v8::Handle<v8::Value> jsDispatchOnClient(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsDispatchToApu(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsEvaluateOnSelf(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsOnRuntimeFeatureStateChanged(const v8::Arguments& args);
+
+ void disposeUtilityContext();
+ void unhideResourcesPanelIfNecessary();
+
+ void compileUtilityScripts();
+ void initDevToolsAgentHost();
+ void resetInspectorFrontendProxy();
+ void setApuAgentEnabled(bool enabled);
+
+ WebCore::InspectorController* inspectorController();
+
+ // Creates InspectorBackend v8 wrapper in the utility context so that it's
+ // methods prototype is Function.protoype object from the utility context.
+ // Otherwise some useful methods defined on Function.prototype(such as bind)
+ // are missing for InspectorController native methods.
+ v8::Local<v8::Object> createInspectorBackendV8Wrapper();
+
+ int m_hostId;
+ WebDevToolsAgentClient* m_client;
+ WebViewImpl* m_webViewImpl;
+ OwnPtr<DebuggerAgentDelegateStub> m_debuggerAgentDelegateStub;
+ OwnPtr<ToolsAgentDelegateStub> m_toolsAgentDelegateStub;
+ OwnPtr<DebuggerAgentImpl> m_debuggerAgentImpl;
+ OwnPtr<ApuAgentDelegateStub> m_apuAgentDelegateStub;
+ bool m_apuAgentEnabled;
+ bool m_resourceTrackingWasEnabled;
+ bool m_attached;
+ // TODO(pfeldman): This should not be needed once GC styles issue is fixed
+ // for matching rules.
+ v8::Persistent<v8::Context> m_utilityContext;
+};
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp b/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp
new file mode 100644
index 0000000..2165cec
--- /dev/null
+++ b/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp
@@ -0,0 +1,398 @@
+/*
+ * 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 "WebDevToolsFrontendImpl.h"
+
+#include "BoundObject.h"
+#include "ContextMenuController.h"
+#include "ContextMenuItem.h"
+#include "DOMWindow.h"
+#include "DebuggerAgent.h"
+#include "DevToolsRPCJS.h"
+#include "Document.h"
+#include "Event.h"
+#include "Frame.h"
+#include "InspectorBackend.h"
+#include "InspectorController.h"
+#include "InspectorFrontendHost.h"
+#include "Node.h"
+#include "Page.h"
+#include "Pasteboard.h"
+#include "PlatformString.h"
+#include "ProfilerAgent.h"
+#include "SecurityOrigin.h"
+#include "Settings.h"
+#include "ToolsAgent.h"
+#include "V8Binding.h"
+#include "V8CustomBinding.h"
+#include "V8DOMWrapper.h"
+#include "V8InspectorFrontendHost.h"
+#include "V8Node.h"
+#include "V8Proxy.h"
+#include "V8Utilities.h"
+#include "WebDevToolsFrontendClient.h"
+#include "WebFrameImpl.h"
+#include "WebScriptSource.h"
+#include "WebViewImpl.h"
+#include <wtf/OwnPtr.h>
+#include <wtf/Vector.h>
+
+using namespace WebCore;
+
+namespace WebKit {
+
+static v8::Local<v8::String> ToV8String(const String& s)
+{
+ if (s.isNull())
+ return v8::Local<v8::String>();
+
+ return v8::String::New(reinterpret_cast<const uint16_t*>(s.characters()), s.length());
+}
+
+DEFINE_RPC_JS_BOUND_OBJ(DebuggerAgent, DEBUGGER_AGENT_STRUCT, DebuggerAgentDelegate, DEBUGGER_AGENT_DELEGATE_STRUCT)
+DEFINE_RPC_JS_BOUND_OBJ(ProfilerAgent, PROFILER_AGENT_STRUCT, ProfilerAgentDelegate, PROFILER_AGENT_DELEGATE_STRUCT)
+DEFINE_RPC_JS_BOUND_OBJ(ToolsAgent, TOOLS_AGENT_STRUCT, ToolsAgentDelegate, TOOLS_AGENT_DELEGATE_STRUCT)
+
+WebDevToolsFrontend* WebDevToolsFrontend::create(
+ WebView* view,
+ WebDevToolsFrontendClient* client,
+ const WebString& applicationLocale)
+{
+ return new WebDevToolsFrontendImpl(
+ static_cast<WebViewImpl*>(view),
+ client,
+ applicationLocale);
+}
+
+WebDevToolsFrontendImpl::WebDevToolsFrontendImpl(
+ WebViewImpl* webViewImpl,
+ WebDevToolsFrontendClient* client,
+ const String& applicationLocale)
+ : m_webViewImpl(webViewImpl)
+ , m_client(client)
+ , m_applicationLocale(applicationLocale)
+ , m_loaded(false)
+{
+ WebFrameImpl* frame = m_webViewImpl->mainFrameImpl();
+ v8::HandleScope scope;
+ v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame());
+
+ m_debuggerAgentObj.set(new JSDebuggerAgentBoundObj(this, frameContext, "RemoteDebuggerAgent"));
+ m_profilerAgentObj.set(new JSProfilerAgentBoundObj(this, frameContext, "RemoteProfilerAgent"));
+ m_toolsAgentObj.set(new JSToolsAgentBoundObj(this, frameContext, "RemoteToolsAgent"));
+
+ // Debugger commands should be sent using special method.
+ BoundObject debuggerCommandExecutorObj(frameContext, this, "RemoteDebuggerCommandExecutor");
+ debuggerCommandExecutorObj.addProtoFunction(
+ "DebuggerCommand",
+ WebDevToolsFrontendImpl::jsDebuggerCommand);
+ debuggerCommandExecutorObj.addProtoFunction(
+ "DebuggerPauseScript",
+ WebDevToolsFrontendImpl::jsDebuggerPauseScript);
+ debuggerCommandExecutorObj.build();
+
+ BoundObject devToolsHost(frameContext, this, "InspectorFrontendHost");
+ devToolsHost.addProtoFunction(
+ "loaded",
+ WebDevToolsFrontendImpl::jsLoaded);
+ devToolsHost.addProtoFunction(
+ "platform",
+ WebDevToolsFrontendImpl::jsPlatform);
+ devToolsHost.addProtoFunction(
+ "port",
+ WebDevToolsFrontendImpl::jsPort);
+ devToolsHost.addProtoFunction(
+ "copyText",
+ WebDevToolsFrontendImpl::jsCopyText);
+ devToolsHost.addProtoFunction(
+ "activateWindow",
+ WebDevToolsFrontendImpl::jsActivateWindow);
+ devToolsHost.addProtoFunction(
+ "closeWindow",
+ WebDevToolsFrontendImpl::jsCloseWindow);
+ devToolsHost.addProtoFunction(
+ "attach",
+ WebDevToolsFrontendImpl::jsDockWindow);
+ devToolsHost.addProtoFunction(
+ "detach",
+ WebDevToolsFrontendImpl::jsUndockWindow);
+ devToolsHost.addProtoFunction(
+ "localizedStringsURL",
+ WebDevToolsFrontendImpl::jsLocalizedStringsURL);
+ devToolsHost.addProtoFunction(
+ "hiddenPanels",
+ WebDevToolsFrontendImpl::jsHiddenPanels);
+ devToolsHost.addProtoFunction(
+ "setting",
+ WebDevToolsFrontendImpl::jsSetting);
+ devToolsHost.addProtoFunction(
+ "setSetting",
+ WebDevToolsFrontendImpl::jsSetSetting);
+ devToolsHost.addProtoFunction(
+ "windowUnloading",
+ WebDevToolsFrontendImpl::jsWindowUnloading);
+ devToolsHost.addProtoFunction(
+ "showContextMenu",
+ WebDevToolsFrontendImpl::jsShowContextMenu);
+ devToolsHost.build();
+}
+
+WebDevToolsFrontendImpl::~WebDevToolsFrontendImpl()
+{
+ if (m_menuProvider)
+ m_menuProvider->disconnect();
+}
+
+void WebDevToolsFrontendImpl::dispatchMessageFromAgent(const WebDevToolsMessageData& data)
+{
+ Vector<String> v;
+ v.append(data.className);
+ v.append(data.methodName);
+ for (size_t i = 0; i < data.arguments.size(); i++)
+ v.append(data.arguments[i]);
+ if (!m_loaded) {
+ m_pendingIncomingMessages.append(v);
+ return;
+ }
+ executeScript(v);
+}
+
+void WebDevToolsFrontendImpl::executeScript(const Vector<String>& v)
+{
+ WebFrameImpl* frame = m_webViewImpl->mainFrameImpl();
+ v8::HandleScope scope;
+ v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame());
+ v8::Context::Scope contextScope(frameContext);
+ v8::Handle<v8::Value> dispatchFunction = frameContext->Global()->Get(v8::String::New("devtools$$dispatch"));
+ ASSERT(dispatchFunction->IsFunction());
+ v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction);
+ Vector< v8::Handle<v8::Value> > args;
+ for (size_t i = 0; i < v.size(); i++)
+ args.append(ToV8String(v.at(i)));
+ function->Call(frameContext->Global(), args.size(), args.data());
+}
+
+void WebDevToolsFrontendImpl::dispatchOnWebInspector(const String& methodName, const String& param)
+{
+ WebFrameImpl* frame = m_webViewImpl->mainFrameImpl();
+ v8::HandleScope scope;
+ v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame());
+ v8::Context::Scope contextScope(frameContext);
+
+ v8::Handle<v8::Value> webInspector = frameContext->Global()->Get(v8::String::New("WebInspector"));
+ ASSERT(webInspector->IsObject());
+ v8::Handle<v8::Object> webInspectorObj = v8::Handle<v8::Object>::Cast(webInspector);
+
+ v8::Handle<v8::Value> method = webInspectorObj->Get(ToV8String(methodName));
+ ASSERT(method->IsFunction());
+ v8::Handle<v8::Function> methodFunc = v8::Handle<v8::Function>::Cast(method);
+ v8::Handle<v8::Value> args[] = {
+ ToV8String(param)
+ };
+ methodFunc->Call(frameContext->Global(), 1, args);
+}
+
+void WebDevToolsFrontendImpl::sendRpcMessage(const WebDevToolsMessageData& data)
+{
+ m_client->sendMessageToAgent(data);
+}
+
+void WebDevToolsFrontendImpl::contextMenuItemSelected(ContextMenuItem* item)
+{
+ int itemNumber = item->action() - ContextMenuItemBaseCustomTag;
+ dispatchOnWebInspector("contextMenuItemSelected", String::number(itemNumber));
+}
+
+void WebDevToolsFrontendImpl::contextMenuCleared()
+{
+ dispatchOnWebInspector("contextMenuCleared", "");
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsLoaded(const v8::Arguments& args)
+{
+ WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
+ frontend->m_loaded = true;
+
+ // Grant the devtools page the ability to have source view iframes.
+ Page* page = V8Proxy::retrieveFrameForEnteredContext()->page();
+ SecurityOrigin* origin = page->mainFrame()->domWindow()->securityOrigin();
+ origin->grantUniversalAccess();
+
+ for (Vector<Vector<String> >::iterator it = frontend->m_pendingIncomingMessages.begin();
+ it != frontend->m_pendingIncomingMessages.end();
+ ++it) {
+ frontend->executeScript(*it);
+ }
+ frontend->m_pendingIncomingMessages.clear();
+ return v8::Undefined();
+}
+
+// static
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsPlatform(const v8::Arguments& args)
+{
+#if defined(OS_MACOSX)
+ return v8String("mac-leopard");
+#elif defined(OS_LINUX)
+ return v8String("linux");
+#elif defined(OS_FREEBSD)
+ return v8String("freebsd");
+#elif defined(OS_OPENBSD)
+ return v8String("openbsd");
+#elif defined(OS_WIN)
+ return v8String("windows");
+#endif
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsPort(const v8::Arguments& args)
+{
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsCopyText(const v8::Arguments& args)
+{
+ String text = WebCore::toWebCoreStringWithNullCheck(args[0]);
+ Pasteboard::generalPasteboard()->writePlainText(text);
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsActivateWindow(const v8::Arguments& args)
+{
+ WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
+ frontend->m_client->activateWindow();
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsCloseWindow(const v8::Arguments& args)
+{
+ WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
+ frontend->m_client->closeWindow();
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsDockWindow(const v8::Arguments& args)
+{
+ WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
+ frontend->m_client->dockWindow();
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsUndockWindow(const v8::Arguments& args)
+{
+ WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
+ frontend->m_client->undockWindow();
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsLocalizedStringsURL(const v8::Arguments& args)
+{
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsHiddenPanels(const v8::Arguments& args)
+{
+ return v8String("");
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsDebuggerCommand(const v8::Arguments& args)
+{
+ WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
+ WebString command = WebCore::toWebCoreStringWithNullCheck(args[0]);
+ frontend->m_client->sendDebuggerCommandToAgent(command);
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsSetting(const v8::Arguments& args)
+{
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsSetSetting(const v8::Arguments& args)
+{
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsDebuggerPauseScript(const v8::Arguments& args)
+{
+ WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
+ frontend->m_client->sendDebuggerPauseScript();
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsWindowUnloading(const v8::Arguments& args)
+{
+ // TODO(pfeldman): Implement this.
+ return v8::Undefined();
+}
+
+v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsShowContextMenu(const v8::Arguments& args)
+{
+ if (args.Length() < 2)
+ return v8::Undefined();
+
+ v8::Local<v8::Object> eventWrapper = v8::Local<v8::Object>::Cast(args[0]);
+ if (V8DOMWrapper::domWrapperType(eventWrapper) != V8ClassIndex::EVENT)
+ return v8::Undefined();
+
+ Event* event = V8Event::toNative(eventWrapper);
+ if (!args[1]->IsArray())
+ return v8::Undefined();
+
+ v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(args[1]);
+ Vector<ContextMenuItem*> items;
+
+ for (size_t i = 0; i < array->Length(); ++i) {
+ v8::Local<v8::Object> item = v8::Local<v8::Object>::Cast(array->Get(v8::Integer::New(i)));
+ v8::Local<v8::Value> label = item->Get(v8::String::New("label"));
+ v8::Local<v8::Value> id = item->Get(v8::String::New("id"));
+ if (label->IsUndefined() || id->IsUndefined()) {
+ items.append(new ContextMenuItem(SeparatorType,
+ ContextMenuItemTagNoAction,
+ String()));
+ } else {
+ ContextMenuAction typedId = static_cast<ContextMenuAction>(
+ ContextMenuItemBaseCustomTag + id->ToInt32()->Value());
+ items.append(new ContextMenuItem(ActionType,
+ typedId,
+ toWebCoreStringWithNullCheck(label)));
+ }
+ }
+
+ WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value());
+
+ frontend->m_menuProvider = MenuProvider::create(frontend, items);
+
+ ContextMenuController* menuController = frontend->m_webViewImpl->page()->contextMenuController();
+ menuController->showContextMenu(event, frontend->m_menuProvider);
+
+ return v8::Undefined();
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/WebDevToolsFrontendImpl.h b/WebKit/chromium/src/WebDevToolsFrontendImpl.h
new file mode 100644
index 0000000..62b34da
--- /dev/null
+++ b/WebKit/chromium/src/WebDevToolsFrontendImpl.h
@@ -0,0 +1,161 @@
+/*
+ * 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.
+ */
+
+#ifndef WebDevToolsFrontendImpl_h
+#define WebDevToolsFrontendImpl_h
+
+#include "ContextMenu.h"
+#include "ContextMenuProvider.h"
+#include "DevToolsRPC.h"
+#include "WebDevToolsFrontend.h"
+#include <v8.h>
+#include <wtf/HashMap.h>
+#include <wtf/Noncopyable.h>
+#include <wtf/OwnPtr.h>
+#include <wtf/RefPtr.h>
+#include <wtf/Vector.h>
+
+namespace WebCore {
+class ContextMenuItem;
+class Node;
+class Page;
+class String;
+}
+
+namespace WebKit {
+
+class JSDebuggerAgentBoundObj;
+class JSProfilerAgentBoundObj;
+class JSToolsAgentBoundObj;
+class WebDevToolsClientDelegate;
+class WebViewImpl;
+struct WebDevToolsMessageData;
+
+class WebDevToolsFrontendImpl : public WebKit::WebDevToolsFrontend
+ , public DevToolsRPC::Delegate
+ , public Noncopyable {
+public:
+ WebDevToolsFrontendImpl(
+ WebKit::WebViewImpl* webViewImpl,
+ WebKit::WebDevToolsFrontendClient* client,
+ const String& applicationLocale);
+ virtual ~WebDevToolsFrontendImpl();
+
+ // DevToolsRPC::Delegate implementation.
+ virtual void sendRpcMessage(const WebKit::WebDevToolsMessageData& data);
+
+ // WebDevToolsFrontend implementation.
+ virtual void dispatchMessageFromAgent(const WebKit::WebDevToolsMessageData& data);
+
+private:
+ class MenuProvider : public WebCore::ContextMenuProvider {
+ public:
+ static PassRefPtr<MenuProvider> create(WebDevToolsFrontendImpl* frontendHost, const Vector<WebCore::ContextMenuItem*>& items)
+ {
+ return adoptRef(new MenuProvider(frontendHost, items));
+ }
+
+ virtual ~MenuProvider()
+ {
+ contextMenuCleared();
+ }
+
+ void disconnect()
+ {
+ m_frontendHost = 0;
+ }
+
+ virtual void populateContextMenu(WebCore::ContextMenu* menu)
+ {
+ for (size_t i = 0; i < m_items.size(); ++i)
+ menu->appendItem(*m_items[i]);
+ }
+
+ virtual void contextMenuItemSelected(WebCore::ContextMenuItem* item)
+ {
+ if (m_frontendHost)
+ m_frontendHost->contextMenuItemSelected(item);
+ }
+
+ virtual void contextMenuCleared()
+ {
+ if (m_frontendHost)
+ m_frontendHost->contextMenuCleared();
+ deleteAllValues(m_items);
+ m_items.clear();
+ }
+
+ private:
+ MenuProvider(WebDevToolsFrontendImpl* frontendHost, const Vector<WebCore::ContextMenuItem*>& items)
+ : m_frontendHost(frontendHost)
+ , m_items(items) { }
+ WebDevToolsFrontendImpl* m_frontendHost;
+ Vector<WebCore::ContextMenuItem*> m_items;
+ };
+
+ void executeScript(const Vector<String>& v);
+ void dispatchOnWebInspector(const String& method, const String& param);
+
+ // friend class MenuSelectionHandler;
+ void contextMenuItemSelected(WebCore::ContextMenuItem* menuItem);
+ void contextMenuCleared();
+
+ static v8::Handle<v8::Value> jsLoaded(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsPlatform(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsPort(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsCopyText(const v8::Arguments& args);
+
+ static v8::Handle<v8::Value> jsActivateWindow(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsCloseWindow(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsDockWindow(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsUndockWindow(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsLocalizedStringsURL(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsHiddenPanels(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsDebuggerCommand(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsSetting(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsSetSetting(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsDebuggerPauseScript(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsWindowUnloading(const v8::Arguments& args);
+ static v8::Handle<v8::Value> jsShowContextMenu(const v8::Arguments& args);
+
+ WebKit::WebViewImpl* m_webViewImpl;
+ WebKit::WebDevToolsFrontendClient* m_client;
+ String m_applicationLocale;
+ OwnPtr<JSDebuggerAgentBoundObj> m_debuggerAgentObj;
+ OwnPtr<JSProfilerAgentBoundObj> m_profilerAgentObj;
+ OwnPtr<JSToolsAgentBoundObj> m_toolsAgentObj;
+ bool m_loaded;
+ Vector<Vector<String> > m_pendingIncomingMessages;
+ RefPtr<MenuProvider> m_menuProvider;
+};
+
+} // namespace WebKit
+
+#endif
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list