diff options
| author | Steve Block <steveblock@google.com> | 2009-12-15 10:12:09 +0000 |
|---|---|---|
| committer | Steve Block <steveblock@google.com> | 2009-12-17 17:41:10 +0000 |
| commit | 643ca7872b450ea4efacab6188849e5aac2ba161 (patch) | |
| tree | 6982576c228bcd1a7efe98afed544d840751094c /WebKit/chromium | |
| parent | d026980fde6eb3b01c1fe49441174e89cd1be298 (diff) | |
| download | external_webkit-643ca7872b450ea4efacab6188849e5aac2ba161.zip external_webkit-643ca7872b450ea4efacab6188849e5aac2ba161.tar.gz external_webkit-643ca7872b450ea4efacab6188849e5aac2ba161.tar.bz2 | |
Merge webkit.org at r51976 : Initial merge by git.
Change-Id: Ib0e7e2f0fb4bee5a186610272edf3186f0986b43
Diffstat (limited to 'WebKit/chromium')
258 files changed, 43242 insertions, 54 deletions
diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog new file mode 100644 index 0000000..d55548b --- /dev/null +++ b/WebKit/chromium/ChangeLog @@ -0,0 +1,3666 @@ +2009-12-10 Mike Belshe <mike@belshe.com> + + Unreviewed, build fix for chromium. + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::dispatchWillSendRequest): + +2009-12-10 Kenneth Russell <kbr@google.com> + + Reviewed by Oliver Hunt. + + Changed WebGLRenderingContext to synthesize GL errors rather than + raising JavaScript exceptions. Removed internal getError() calls + after each graphics call. The GraphicsContext3D maintains the + synthetic exceptions because only it has complete information + about certain conditions requiring them to be raised. + + Based on idea from Ilmari Heikkinen, added create3DDebugContext() + to webgl-test.js and changed the WebGL layout tests expecting + error conditions to use it. Updated expected.txt files, which now + implicitly test the OpenGL error as it is part of the exception's + message. + + Added new targeted test covering aspects of synthetic errors as + well as regression tests for bugs uncovered during its development. + + Test: fast/canvas/webgl/error-reporting.html + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::reshape): + (WebCore::GraphicsContext3DInternal::getError): + (WebCore::GraphicsContext3DInternal::synthesizeGLError): + (WebCore::GraphicsContext3D::getActiveAttrib): + (WebCore::GraphicsContext3D::getActiveUniform): + (WebCore::GraphicsContext3D::getError): + (WebCore::GraphicsContext3D::synthesizeGLError): + +2009-12-10 Mike Belshe <mike@belshe.com> + + Reviewed by Darin Fisher. + + Fix FrameLoader to use the new ResourceTypes properly. + + https://bugs.webkit.org/show_bug.cgi?id=32336 + + * public/WebURLRequest.h: + (WebKit::WebURLRequest::): + * src/FrameLoaderClientImpl.cpp: + (WebKit::setTargetTypeFromLoader): + (WebKit::FrameLoaderClientImpl::dispatchWillSendRequest): + +2009-12-10 Ilya Tikhonovsky <loislo@google.com> + + Reviewed by Pavel Feldman. + + Chromium: Expose devtools agent API for inspector layout tests. + + https://bugs.webkit.org/show_bug.cgi?id=32379 + + * public/WebDevToolsAgent.h: + (WebKit::WebDevToolsAgent::setTimelineProfilingEnabled): + (WebKit::WebDevToolsAgent::evaluateInWebInspector): + +2009-12-09 Yury Semikhatsky <yurys@chromium.org> + + Unreviewed, build fix. + + Change forward declaration of WebContextMenuData from class to + struct to match its definition. The bug was introduced by + http://trac.webkit.org/changeset/51874 + + * src/ContextMenuClientImpl.h: + +2009-12-09 Darin Fisher <darin@chromium.org> + + Reviewed by Eric Seidel. + + https://bugs.webkit.org/show_bug.cgi?id=32324 + [Chromium] Suppress WebFrameClient callbacks from a detached frame. + + This change means that we no longer need the ClientHandle class. + FrameLoaderClient::detachedFromParent3() is called on each frame + in the frame tree from within frameDetached(). + + Test: http/tests/loading/gmail-assert-on-load.html + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::detachedFromParent3): + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::create): + (WebKit::WebFrameImpl::WebFrameImpl): + (WebKit::WebFrameImpl::createChildFrame): + * src/WebFrameImpl.h: + (WebKit::WebFrameImpl::client): + (WebKit::WebFrameImpl::dropClient): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::close): + +2009-12-08 Stuart Morgan <stuartmorgan@chromium.org> + + Reviewed by Darin Fisher. + + Include clickCount when doing MouseEvent -> WebMouseEvent conversion + in Chromium API. + + https://bugs.webkit.org/show_bug.cgi?id=32289 + + * src/WebInputEventConversion.cpp: + (WebKit::WebMouseEventBuilder::WebMouseEventBuilder): + +2009-12-09 Yury Semikhatsky <yurys@chromium.org> + + Unreviewed, build fix. + + Add return statement to default implementation of hostIdentifier method + introduced in http://trac.webkit.org/changeset/51897 + + * public/WebDevToolsAgentClient.h: + (WebKit::WebDevToolsAgentClient::hostIdentifier): + +2009-12-09 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Add declaration of static methods that allow to dispatch + DevTools messages on the IO thread and accept WebDevToolsMessageData + argument. + + https://bugs.webkit.org/show_bug.cgi?id=32314 + + * public/WebDevToolsAgent.h: + * public/WebDevToolsAgentClient.h: + +2009-12-09 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Introduce a class for devtools message data + + https://bugs.webkit.org/show_bug.cgi?id=32314 + + * WebKit.gyp: + * public/WebDevToolsAgent.h: + * public/WebDevToolsAgentClient.h: + (WebKit::WebDevToolsAgentClient::sendMessageToFrontend): + (WebKit::WebDevToolsAgentClient::forceRepaint): + (WebKit::WebDevToolsAgentClient::hostIdentifier): + (WebKit::WebDevToolsAgentClient::runtimeFeatureStateChanged): + * public/WebDevToolsFrontend.h: + * public/WebDevToolsFrontendClient.h: + (WebKit::WebDevToolsFrontendClient::sendMessageToAgent): + * public/WebDevToolsMessageData.h: Added. + +2009-12-08 Pavel Feldman <pfeldman@chromium.org> + + Reviewed by Darin Fisher. + + Chromium: support custom WebCore context menu items in Chromium port. + + https://bugs.webkit.org/show_bug.cgi?id=32277 + + * public/WebContextMenuData.h: + * public/WebPopupMenuInfo.h: + (WebKit::WebPopupMenuInfo::Item::): + * public/WebView.h: + * src/ContextMenuClientImpl.cpp: + (WebKit::ContextMenuClientImpl::getCustomMenuFromDefaultItems): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::executeCustomContextMenuAction): + * src/WebViewImpl.h: + +2009-12-08 Albert J. Wong <ajwong@chromium.org> + + Not reviewed: Chromium build fix. + + r51859 changed the case for some of the ResourceRequest::TargetType + enums. + + * src/FrameLoaderClientImpl.cpp: + (WebKit::determineTargetTypeFromLoader): + +2009-12-07 Zhe Su <suzhe@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] accesskey is not supported on Chromium Mac. + https://bugs.webkit.org/show_bug.cgi?id=32213 + + This change fixes (partially) the accesskey issue by decoupling the + code for handling accesskeys and system keys. Because on Mac, + the modifiers of accesskeys are ctrl+alt, which are not marked as + system keys. + In order to fully fix this issue, some changes in Chromium code is + also required. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::keyEvent): + (WebKit::WebViewImpl::charEvent): + +2009-12-07 Evan Martin <evan@chromium.org> + + Reviewed by Eric Seidel. + + Chromium: theme scrollbars to match GTK theme. + Add API to set the colors. + + Since the change is to the Chromium WebKit API layer, testing will + be in Chromium's test shell. + http://bugs.webkit.org/show_bug.cgi?id=32048 + + Patch from Markus Gutschke <markus@chromium.org>. + + * public/WebView.h: + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::setScrollbarColors): + * src/WebViewImpl.h: + +2009-12-07 Finnur Thorarinsson <finnur.webkit@gmail.com> + + Reviewed by Darin Fisher. + + A patch for Chromium to restrict the scope of the Gmail focus fix, + where we set the Selection to 0,0 for content-editable fields and + also make sure we set the selection end-state for find to select the + text found (when not focusing a link we found). + WebKit bug: https://bugs.webkit.org/show_bug.cgi?id=32248 + + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::setFindEndstateFocusAndSelection): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::setFocus): + +2009-12-07 Dmitry Titov <dimich@chromium.org> + + Rubber-stamped by Darin Adler. + + Remove ENABLE_SHARED_SCRIPT flags + https://bugs.webkit.org/show_bug.cgi?id=32245 + This patch was obtained by "git revert" command and then un-reverting of ChangeLog files. + + * features.gypi: + +2009-12-07 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Darin Fisher. + + fixes to build-webkit --chromium + https://bugs.webkit.org/show_bug.cgi?id=32179 + + * DEPS: + * WebKit.gyp: + * gyp_webkit: + +2009-12-07 Mikhail Naganov <mnaganov@chromium.org> + + Reviewed by Pavel Feldman. + + [Chromium] Add declarations for DevTools message dispatching on IO thread + (see http://codereview.chromium.org/460018) + + https://bugs.webkit.org/show_bug.cgi?id=32217 + + * public/WebDevToolsAgent.h: + * public/WebDevToolsAgentClient.h: + +2009-12-04 James Hawkins <jhawkins@chromium.org> + + Reviewed by Darin Fisher. + + https://bugs.webkit.org/show_bug.cgi?id=32095 + Implement WebRegularExpression, a WebKit API for accessing + WebCore::RegularExpression. + + * WebKit.gyp: + * public/WebRegularExpression.h: Added. + * public/WebTextCaseSensitivity.h: Added. + (WebKit::): + * src/AssertMatchingEnums.cpp: + * src/WebRegularExpression.cpp: Added. + (WebKit::WebRegularExpression::WebRegularExpression): + (WebKit::WebRegularExpression::~WebRegularExpression): + (WebKit::WebRegularExpression::match): + +2009-12-04 Peter Kasting <pkasting@google.com> + + Reviewed by Darin Fisher. + + [Chromium] Simplify zoom-related APIs and add a zoom level getter, + part two: Remove deprecated APIs. + https://bugs.webkit.org/show_bug.cgi?id=31893 + + * public/WebView.h: + * src/WebViewImpl.cpp: + * src/WebViewImpl.h: + +2009-12-03 Jonathan Dixon <joth@chromium.org> + + Reviewed by Dimitri Glazkov. + + Bug 32066 - Add enable geolocation flag to WebCore::Settings for Chromium + https://bugs.webkit.org/show_bug.cgi?id=32066 + + Add the plumbing to map WebSettings through to WebCore::Settings + + * features.gypi: + * public/WebSettings.h: Add setGeolocationEnabled API to interface + * src/WebSettingsImpl.cpp: + (WebKit::WebSettingsImpl::setGeolocationEnabled): Calls through to WebCore::Settings::setGeolocationEnabled + * src/WebSettingsImpl.h: Add setGeolocationEnabled interface function + +2009-12-03 Brady Eidson <beidson@apple.com> + + Reviewed by Sam Weinig. + + <rdar://problem/7214236> and http://webkit.org/b/32052 - Implement HTML5 state object history API + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::dispatchDidPushStateWithinPage): + (WebKit::FrameLoaderClientImpl::dispatchDidReplaceStateWithinPage): + (WebKit::FrameLoaderClientImpl::dispatchDidPopStateWithinPage): + * src/FrameLoaderClientImpl.h: + +2009-12-03 Pavel Feldman <pfeldman@chromium.org> + + Reviewed by Timothy Hatcher. + + Chromium: Add support for settings containing ":" + + https://bugs.webkit.org/show_bug.cgi?id=32118 + + * src/InspectorClientImpl.cpp: + (WebKit::InspectorClientImpl::loadSettings): + +2009-12-03 Pavel Feldman <pfeldman@dhcp-172-28-174-220.spb.corp.google.com> + + Reviewed by Timothy Hatcher. + + Web Inspector: Simplify the settings support in inspector controller. + + https://bugs.webkit.org/show_bug.cgi?id=32076 + + * src/InspectorClientImpl.cpp: + (WebKit::InspectorClientImpl::hiddenPanels): + (WebKit::InspectorClientImpl::populateSetting): + (WebKit::InspectorClientImpl::storeSetting): + (WebKit::InspectorClientImpl::loadSettings): + (WebKit::InspectorClientImpl::saveSettings): + * src/InspectorClientImpl.h: + +2009-12-03 Ben Murdoch <benm@google.com> + + Reviewed by Brady Eidson. + + [Android] The FrameLoaderClient is unaware of BackForwardList changes. + https://bugs.webkit.org/show_bug.cgi?id=31914 + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::dispatchDidAddBackForwardItem): Add an empty implementation. Method added to FrameLoaderClient by Android (see bug). + (WebKit::FrameLoaderClientImpl::dispatchDidRemoveBackForwardItem): ditto. + (WebKit::FrameLoaderClientImpl::dispatchDidChangeBackForwardIndex): dito. + * src/FrameLoaderClientImpl.h: + +2009-12-02 Yusuke Sato <yusukes@chromium.org> + + Reviewed by Eric Seidel. + + Sanitize web fonts using the OTS library + https://bugs.webkit.org/show_bug.cgi?id=31106 + + * DEPS: Added dependency to the OpenType sanitizer library. + * features.gypi: Added ENABLE_OPENTYPE_SANITIZER=1. + +2009-12-02 Evan Stade <estade@chromium.org> + + Reviewed by Darin Fisher. + + https://bugs.webkit.org/show_bug.cgi?id=32029 + Mousewheel event delta has reversed sign on Linux Chrome. + + No new tests (layout tests don't cover event conversion code). + Manual test: http://www.switchonthecode.com/tutorials/javascript-tutorial-the-scroll-wheel + + * src/gtk/WebInputEventFactory.cpp: + (WebKit::WebInputEventFactory::mouseWheelEvent): + +2009-12-02 Anton Muhin <antonm@chromium.org> + + Reviewed by Adam Barth. + + Allow to skip thread checks when accessing DOMDataStore for processes + which run V8 in single thread mode. + https://bugs.webkit.org/show_bug.cgi?id=31877 + + * src/WebScriptController.cpp: + (WebKit::WebScriptController::enableV8SingleThreadMode): + +2009-12-01 Peter Kasting <pkasting@google.com> + + Reviewed by Darin Fisher. + + [Chromium] Simplify zoom-related APIs and add a zoom level getter, + part one: Add new APIs. (Old APIs will be removed in a second pass.) + https://bugs.webkit.org/show_bug.cgi?id=31893 + + * public/WebView.h: + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::zoomLevel): + (WebKit::WebViewImpl::setZoomLevel): + * src/WebViewImpl.h: + +2009-12-01 Xiyuan Xia <xiyuan@chromium.org> + + Reviewed by Darin Fisher. + + Only fire start/stop events when main frame is not loading. + + https://bugs.webkit.org/show_bug.cgi?id=31838 + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::dispatchDidChangeLocationWithinPage): + +2009-11-27 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Add separate method for pause command to WebDevToolsAgent + and WebDevToolsFrontendClient interfaces so that pause command + can be processed on the IO thread. + + https://bugs.webkit.org/show_bug.cgi?id=31934 + + * public/WebDevToolsAgent.h: + * public/WebDevToolsFrontendClient.h: + (WebKit::WebDevToolsFrontendClient::sendDebuggerCommandToAgent): + (WebKit::WebDevToolsFrontendClient::sendDebuggerPauseScript): + (WebKit::WebDevToolsFrontendClient::activateWindow): + (WebKit::WebDevToolsFrontendClient::closeWindow): + (WebKit::WebDevToolsFrontendClient::dockWindow): + (WebKit::WebDevToolsFrontendClient::undockWindow): + +2009-11-27 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + WebCore part of the fix that allows to view plugin + resources loaded by plugins. Methods that for resource + loading notifications are exposed through WebDevToolsAgent + interface to the glue code to allow Chromium's plugin + implementation to notify InspectorController about resource + loading in plugins. + + https://bugs.webkit.org/show_bug.cgi?id=31832 + + * public/WebDevToolsAgent.h: + * public/WebView.h: + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::createUniqueIdentifierForRequest): + * src/WebViewImpl.h: + +2009-11-26 Yury Semikhatsky <yurys@chromium.org> + + Not reviewed. Build fix: revert r51421. + + * public/WebDevToolsAgent.h: + * public/WebView.h: + * src/WebViewImpl.cpp: + * src/WebViewImpl.h: + +2009-11-25 Dimitri Glazkov <dglazkov@chromium.org> + + Reviewed by David Levin. + + [Chromium] Implement canSetValueAttribute in the API. + https://bugs.webkit.org/show_bug.cgi?id=31894 + + * public/WebAccessibilityObject.h: Added decl. + * src/WebAccessibilityCacheImpl.h: Cleaned up mis-include. + * src/WebAccessibilityObject.cpp: + (WebKit::WebAccessibilityObject::canSetValueAttribute): Added impl. + +2009-11-25 Dimitri Glazkov <dglazkov@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] Plumb setNeedsSiteSpecificQuirks throught WebKit API. + https://bugs.webkit.org/show_bug.cgi?id=31878 + + * public/WebSettings.h: Added decl. + * src/WebSettingsImpl.cpp: + (WebKit::WebSettingsImpl::setNeedsSiteSpecificQuirks): Added impl. + * src/WebSettingsImpl.h: + +2009-11-24 Dmitry Titov <dimich@chromium.org> + + Reviewed by Eric Seidel. + + Add ENABLE_SHARED_SCRIPT feature define and flag for build-webkit + https://bugs.webkit.org/show_bug.cgi?id=31444 + + * features.gypi: + +2009-11-24 Evan Stade <estade@chromium.org> + + Reviewed by David Levin. + + Linux Chromium sends too many click events + https://bugs.webkit.org/show_bug.cgi?id=31841 + + Manually count number of clicks for double/triple click events. This + makes us match Firefox on http://www.quirksmode.org/js/events_mouse.html + Chromium side of this patch is here: + http://codereview.chromium.org/431031/show + + * src/gtk/WebInputEventFactory.cpp: + (WebKit::WebInputEventFactory::mouseEvent): + +2009-11-24 Darin Fisher <darin@chromium.org> + + Reviewed by Adam Barth. + + [Chromium] Renderer hang when using www.expedia.com + https://bugs.webkit.org/show_bug.cgi?id=31822 + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::dispatchWillSendRequest): + Assign ReturnCacheDataDontLoad cache policy at the last moment + to match Safari. This way the cache policy does not get stored + in DocumentLoader's originalRequest preventing it from being + inherited by subresource requests. + * src/ResourceHandle.cpp: + (WebCore::ResourceHandle::willLoadFromCache): Remove assignment + of ReturnCacheDataDontLoad cache policy so that it doesn't end + up applying to the DocumentLoader's originalRequest. + +2009-11-23 Kenneth Russell <kbr@google.com> + + Reviewed by Oliver Hunt. + + Change get... calls to latest spec + https://bugs.webkit.org/show_bug.cgi?id=30091 + + Removed old versions of get calls on WebGLRenderingContext and + added new ones per spec returning "any". New code simplifies + GraphicsContext3D and fixes previously unimplemented routines. + Added custom JS and V8 bindings. Added exhaustive test case + exercising all new code paths. Updated preexisting test cases for + new APIs. Fixed preexisting bugs in WebKit's and Chrome's WebGL + implementations. + + Ran WebGL layout tests in WebKit (clean) and Chrome (couple of + preexisting known failures) and manual WebGL tests in both + browsers. + + Test: fast/canvas/webgl/gl-object-get-calls.html + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3D::createFramebuffer): + (WebCore::GraphicsContext3D::createRenderbuffer): + (WebCore::GraphicsContext3D::deleteFramebuffer): + (WebCore::GraphicsContext3D::deleteRenderbuffer): + (WebCore::GraphicsContext3D::checkFramebufferStatus): + (WebCore::GraphicsContext3D::getBooleanv): + (WebCore::GraphicsContext3D::getBufferParameteriv): + (WebCore::GraphicsContext3D::getFloatv): + (WebCore::GraphicsContext3D::getFramebufferAttachmentParameteriv): + (WebCore::GraphicsContext3D::getIntegerv): + (WebCore::GraphicsContext3D::getProgramiv): + (WebCore::GraphicsContext3D::getRenderbufferParameteriv): + (WebCore::GraphicsContext3D::getShaderiv): + (WebCore::GraphicsContext3D::getTexParameterfv): + (WebCore::GraphicsContext3D::getTexParameteriv): + (WebCore::GraphicsContext3D::getUniformfv): + (WebCore::GraphicsContext3D::getUniformiv): + (WebCore::GraphicsContext3D::getVertexAttribfv): + (WebCore::GraphicsContext3D::getVertexAttribiv): + (WebCore::GraphicsContext3D::isFramebuffer): + (WebCore::GraphicsContext3D::isRenderbuffer): + +2009-11-24 Pavel Feldman <pfeldman@chromium.org> + + Reviewed by Darin Fisher. + + Chromium: Expose method for reporting user stats + to the host. Also includes drive-by default implementation. + + https://bugs.webkit.org/show_bug.cgi?id=31830 + + * public/WebKitClient.h: + +2009-11-24 Adam Barth <abarth@webkit.org> + + Reviewed by Dimitri Glazkov. + + [Chromium] Fix DOM storage layout tests + https://bugs.webkit.org/show_bug.cgi?id=31833 + + The issue is, essentially, that this code assumes that + SecurityOrigin::createString can re-create a SecurityOrigin given + the string produced from SecurityOrigin::toString. This is a bogus + assumption in a number of corner cases (e.g., document.domain, + @sandbox). A recent patch (http://trac.webkit.org/changeset/51294) + make this assumption further invalid in the case of of file:// URLs. + + The correct fix is for this code to use WebSecurityOrigin objects + (and not strings) to represent SecurityOrigin objects. However, the + expert on this code is on vacation, and I don't want to do major + surgery here without his involvement. This patch is a temporary fix + to get these tests passing again. We'll do the right fix once + jorlow gets back from vacation. + + Tests: Covered by a number of existing DOM storage tests. + + * src/WebStorageNamespaceImpl.cpp: + (WebKit::WebStorageNamespaceImpl::createStorageArea): + +2009-11-23 Jian Li <jianli@chromium.org> + + Reviewed by NOBODY (Chromium build fix). + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3D::createShader): + +2009-11-20 Jian Li <jianli@chromium.org> + + Not reviewed. Fix chromium build. + + * public/WebAccessibilityRole.h: + (WebKit::): + * src/AssertMatchingEnums.cpp: + +2009-11-19 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Darin Fisher. + + Make chromium/webkit/glue/FormFieldValues use the WebKit API + + https://bugs.webkit.org/show_bug.cgi?id=31650 + + * public/WebElement.h: + * public/WebFormElement.h: + * public/WebInputElement.h: + (WebKit::WebInputElement::): + * public/WebNode.h: + * src/AssertMatchingEnums.cpp: + * src/DOMUtilitiesPrivate.cpp: + (WebKit::nameOfInputElement): + * src/DOMUtilitiesPrivate.h: + * src/EditorClientImpl.cpp: + (WebKit::EditorClientImpl::autofill): + (WebKit::EditorClientImpl::doAutofill): + * src/WebFormElement.cpp: + (WebKit::WebFormElement::name): + (WebKit::WebFormElement::method): + (WebKit::WebFormElement::getNamedElements): + (WebKit::WebFormElement::getInputElements): + * src/WebInputElement.cpp: + (WebKit::WebInputElement::isEnabledFormControl): + (WebKit::WebInputElement::inputType): + (WebKit::WebInputElement::formControlType): + (WebKit::WebInputElement::value): + (WebKit::WebInputElement::dispatchFormControlChangeEvent): + (WebKit::WebInputElement::setSelectionRange): + (WebKit::WebInputElement::name): + (WebKit::WebInputElement::nameForAutofill): + * src/WebNode.cpp: + (WebKit::WebNode::frame): + +2009-11-18 Michelangelo De Simone <micdesim@gmail.com> + + Reviewed by Darin Adler. + + Fix for <https://bugs.webkit.org/show_bug.cgi?id=27959>. + Support for validationMessage attribute, as per HTML5 specs. + + * src/LocalizedStrings.cpp: + (WebCore::validationMessageValueMissingText): + (WebCore::validationMessageTypeMismatchText): + (WebCore::validationMessagePatternMismatchText): + (WebCore::validationMessageTooLongText): + (WebCore::validationMessageRangeUnderflowText): + (WebCore::validationMessageRangeOverflowText): + (WebCore::validationMessageStepMismatchText): + +2009-11-18 Nate Chapin <japhet@chromium.org> + + Reviewed by Darin Fisher. + + Remove Chromium port's dependency on some dummy pthreads header + files that live in the Chromium repository. + + https://bugs.webkit.org/show_bug.cgi?id=31648 + + * DEPS: Remove reference to chromium svn's webkit/build/ directory. + +2009-11-18 Evan Stade <estade@chromium.org> + + Reviewed by Darin Fisher. + + Menu button shows wrong content in Chromium + https://bugs.webkit.org/show_bug.cgi?id=31448 + + Make context menu button (VK_APPS) show context menu for node that has + keyboard focus. This affects both the content and the positioning. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::sendContextMenuEvent): + +2009-11-17 Darin Fisher <darin@chromium.org> + + Reviewed by Dmitry Titov. + + Minor cleanup in WebKit API + https://bugs.webkit.org/show_bug.cgi?id=31616 + + * public/WebFormElement.h: Add missing WEBKIT_API prefix. + * public/WebNode.h: Add missing WEBKIT_API prefix. + * src/WebFormElement.cpp: + (WebKit::WebFormElement::action): Make action getter const. + * src/WebNode.cpp: + (WebKit::WebNode::frame): Utilize WebFrameImpl::fromFrame. + +2009-11-17 Nicolas Weber <thakis@chromium.org> + + Reviewed by Darin Fisher, Dmitry Titov. + + Revert r50887, it regressed handling of cmd-left when a text box is focused. + https://bugs.webkit.org/show_bug.cgi?id=31566 + + * src/mac/WebInputEventFactory.mm: + (WebKit::WebInputEventFactory::keyboardEvent): + +2009-11-16 Kenneth Russell <kbr@google.com> + + Reviewed by Oliver Hunt. + + Update API of WebGLArray and friends + https://bugs.webkit.org/show_bug.cgi?id=31175 + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3D::bufferData): + (WebCore::GraphicsContext3D::bufferSubData): + +2009-11-15 Dimitri Glazkov <dglazkov@chromium.org> + + Unreviewed, build fix. + + Correct an error in the previous commit + + * public/WebAccessibilityRole.h: It should be WebAccessibilityRoleDirectory, + not WebAccessibilityDirectoryRole. + +2009-11-15 Dimitri Glazkov <dglazkov@chromium.org> + + Unreviewed, build fix. + + Bring WebAccessibilityRole up to sync after + http://trac.webkit.org/changeset/51007. + + * public/WebAccessibilityRole.h: Added WebAccessibilityRoleDirectory. + * src/AssertMatchingEnums.cpp: Added a match between DirectoryRole and + WebAccessibilityRoleDirectory. + +2009-11-13 Dimitri Glazkov <dglazkov@chromium.org> + + Unreviewed, build fix. + + [Chromium] Rename windowObjectCleared to dispatchDidClearWindowObjectInWorld + to catch up http://trac.webkit.org/changeset/50973. + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::dispatchDidClearWindowObjectInWorld): + * src/FrameLoaderClientImpl.h: + +2009-11-13 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Chromium WebKit Port to compile as dynamic lib + + https://bugs.webkit.org/show_bug.cgi?id=31478 + + * WebKit.gyp: + +2009-11-13 Aaron Boodman <aa@chromium.org> + + Reviewed by Eric Seidel. + + Adds a way to get the document element's scrollHeight, + which is sort of the moral equivalent to + RenderBox::minPrefWidth(). + + https://bugs.webkit.org/show_bug.cgi?id=31036 + + * public/WebFrame.h: Declare documentElementScrollHeight() + * src/WebFrameImpl.h: Ditto + * src/WebFrameImpl.cpp: Implement documentElementScrollHeight() + (WebKit::WebFrameImpl::documentElementScrollHeight): Return the + scroll height of the document element, or zero if there's no + documentElement. + +2009-11-12 Dumitru Daniliuc <dumi@chromium.org> + + Reviewed by Dimitri Glazkov. + + Adding Chromium's DatabaseTracker implementation. + + https://bugs.webkit.org/show_bug.cgi?id=31440 + + * WebKit.gyp: + * src/ChromeClientImpl.cpp: + (WebKit::ChromeClientImpl::exceededDatabaseQuota): + * src/DatabaseObserver.cpp: Added. + (WebCore::DatabaseObserver::databaseOpened): + (WebCore::DatabaseObserver::databaseModified): + (WebCore::DatabaseObserver::databaseClosed): + * src/WebDatabase.cpp: + (WebKit::WebDatabase::name): + (WebKit::WebDatabase::displayName): + (WebKit::WebDatabase::estimatedSize): + (WebKit::WebDatabase::securityOrigin): + (WebKit::WebDatabase::updateDatabaseSize): + * src/WebSecurityOrigin.cpp: + (WebKit::WebSecurityOrigin::toString): + (WebKit::WebSecurityOrigin::databaseIdentifier): + +2009-11-13 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Rolling Chromium dependencies to match Chromium revision 31834. + + https://bugs.webkit.org/show_bug.cgi?id=31445 + + * DEPS: + +2009-11-12 Dumitru Daniliuc <dumi@chromium.org> + + Reviewed by Dimitri Glazkov. + + Renaming some parameters passed to DB-related methods to better + indicate their purpose. + + https://bugs.webkit.org/show_bug.cgi?id=31449 + + * public/WebKitClient.h: + * src/ChromiumBridge.cpp: + (WebCore::ChromiumBridge::databaseOpenFile): + (WebCore::ChromiumBridge::databaseDeleteFile): + (WebCore::ChromiumBridge::databaseGetFileAttributes): + (WebCore::ChromiumBridge::databaseGetFileSize): + +2009-11-12 Adam Barth <abarth> + + Reviewed by Dimitri Glazkov. + + [Chromium] reload-subframe-object.html fails + https://bugs.webkit.org/show_bug.cgi?id=31398 + + More closely match FrameLoaderClient.mm. Turns out we don't want to + use MIMETypeRegistry::getMIMETypeForPath because we can't distinguish + between application/octet-stream and lack of knowledge of the MIME + type. + + Covered by reload-subframe-object.html. + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::objectContentType): + +2009-11-12 Nate Chapin <japhet@chromium.org> + + Unreviewed, Chromium build fix. + + Add new accessibility enum values to Chromium enums from + http://trac.webkit.org/changeset/50865 and + http://trac.webkit.org/changeset/50883. + + https://bugs.webkit.org/show_bug.cgi?id=31424 + + * public/WebAccessibilityRole.h: + (WebKit::): + * src/AssertMatchingEnums.cpp: + +2009-11-12 Nicolas Weber <thakis@chromium.org> + + Reviewed by Dimitri Glazkov. + + Send |keypress()| events for keys with cmd down, like safari. + Test: Hit cmd-shift-a on unixpapa.com/js/testkey.html , should show a + keypress() event. + + * src/mac/WebInputEventFactory.mm: + (WebKit::WebInputEventFactory::keyboardEvent): + +2009-11-11 Jeremy Orlow <jorlow@chromium.org> + + Not reviewed. Build fix. Will be cleaned up in subsequent patch once we know exaclty what's going on. + + * src/WebBindings.cpp: + +2009-11-11 Drew Wilson <atwilson@chromium.org> + + Reviewed by Dimitri Glazkov. + + SharedWorkerRepository.connect() does not call WebSharedWorkerRepository + https://bugs.webkit.org/show_bug.cgi?id=31371 + + Test: Unit tests can be enabled downstream when this lands. + + * src/SharedWorkerRepository.cpp: + (WebCore::SharedWorkerRepository::connect): + Added missing call to WebSharedWorkerRepository.addSharedWorker(). + +2009-11-11 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Tiny path fixes in Chromium API includes. + + https://bugs.webkit.org/show_bug.cgi?id=31369 + + * public/linux/WebSandboxSupport.h: Fixed path. + * src/WebBindings.cpp: Fixed path. + +2009-11-11 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + http://trac.webkit.org/changeset/50811 removed some methods from + platform/network/SocketStreamHandleClient.h, so remove them + here too. + + https://bugs.webkit.org/show_bug.cgi?id=31360 + + * public/WebSocketStreamHandleClient.h: + * src/SocketStreamHandle.cpp: + (WebCore::SocketStreamHandleInternal::send): + +2009-11-11 Nate Chapin <japhet@chromium.org> + + Reviewed by Eric Seidel. + + Remove some additional references to dragSourceMovedTo() not + needed after http://trac.webkit.org/changeset/50786. + + https://bugs.webkit.org/show_bug.cgi?id=31354 + + * public/WebView.h: + * src/WebViewImpl.h: + +2009-11-11 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Remove WebViewImpl::dragSourceMovedTo(), as it is no longer + needed after http://trac.webkit.org/changeset/50786. + + https://bugs.webkit.org/show_bug.cgi?id=31354 + + * src/WebViewImpl.cpp: + +2009-11-10 Nate Chapin <japhet@chromium.org> + + Unreviewed, Chromium build fix for http://trac.webkit.org/changeset/50760. + + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::paint): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Modified WebKit.gyp to build the webkit api. + + https://bugs.webkit.org/show_bug.cgi?id=31320 + + * README: Added. + * WebKit.gyp: Added. + * webkit.gyp: Removed. + +2009-11-10 Nate Chapin <japhet@chromium.org> + + Reviewed by Eric Seidel. + + Update references to Canvas 3D classes to use the WebGL prefix + introduced in http://trac.webkit.org/changeset/50725. + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::beginPaint): + (WebCore::GraphicsContext3DInternal::bindBuffer): + (WebCore::GraphicsContext3DInternal::bindTexture): + (WebCore::GraphicsContext3D::beginPaint): + (WebCore::GraphicsContext3D::bindAttribLocation): + (WebCore::GraphicsContext3D::bindBuffer): + (WebCore::GraphicsContext3D::bindTexture): + (WebCore::GraphicsContext3D::bufferData): + (WebCore::GraphicsContext3D::bufferSubData): + (WebCore::GraphicsContext3D::detachShader): + (WebCore::GraphicsContext3D::getActiveAttrib): + (WebCore::GraphicsContext3D::getActiveUniform): + (WebCore::GraphicsContext3D::getAttribLocation): + (WebCore::GraphicsContext3D::getBooleanv): + (WebCore::GraphicsContext3D::getBufferParameteriv): + (WebCore::GraphicsContext3D::getFloatv): + (WebCore::GraphicsContext3D::getFramebufferAttachmentParameteriv): + (WebCore::GraphicsContext3D::getIntegerv): + (WebCore::GraphicsContext3D::getProgrami): + (WebCore::GraphicsContext3D::getProgramiv): + (WebCore::GraphicsContext3D::getProgramInfoLog): + (WebCore::GraphicsContext3D::getRenderbufferParameteriv): + (WebCore::GraphicsContext3D::getShaderi): + (WebCore::GraphicsContext3D::getShaderiv): + (WebCore::GraphicsContext3D::getShaderInfoLog): + (WebCore::GraphicsContext3D::getShaderSource): + (WebCore::GraphicsContext3D::getTexParameterfv): + (WebCore::GraphicsContext3D::getTexParameteriv): + (WebCore::GraphicsContext3D::getUniformf): + (WebCore::GraphicsContext3D::getUniformfv): + (WebCore::GraphicsContext3D::getUniformi): + (WebCore::GraphicsContext3D::getUniformiv): + (WebCore::GraphicsContext3D::getUniformLocation): + (WebCore::GraphicsContext3D::getVertexAttribfv): + (WebCore::GraphicsContext3D::getVertexAttribiv): + (WebCore::GraphicsContext3D::isBuffer): + (WebCore::GraphicsContext3D::isFramebuffer): + (WebCore::GraphicsContext3D::isProgram): + (WebCore::GraphicsContext3D::isRenderbuffer): + (WebCore::GraphicsContext3D::isShader): + (WebCore::GraphicsContext3D::isTexture): + (WebCore::GraphicsContext3D::readPixels): + (WebCore::GraphicsContext3D::shaderSource): + (WebCore::GraphicsContext3D::texImage2D): + (WebCore::GraphicsContext3D::texSubImage2D): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebWorker and friends. + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebWorkerBase.cpp: Added. + (WebKit::WorkerWebFrameClient::didCreateDataSource): + (WebKit::WorkerWebFrameClient::sharedInstance): + (WebKit::WorkerWebFrameClient::WorkerWebFrameClient): + (WebKit::initializeWebKitStaticValues): + (WebKit::WebWorkerBase::WebWorkerBase): + (WebKit::WebWorkerBase::~WebWorkerBase): + (WebKit::WebWorkerBase::stopWorkerThread): + (WebKit::WebWorkerBase::initializeLoader): + (WebKit::WebWorkerBase::dispatchTaskToMainThread): + (WebKit::WebWorkerBase::invokeTaskMethod): + (WebKit::WebWorkerBase::postMessageToWorkerObject): + (WebKit::WebWorkerBase::postMessageTask): + (WebKit::WebWorkerBase::postExceptionToWorkerObject): + (WebKit::WebWorkerBase::postExceptionTask): + (WebKit::WebWorkerBase::postConsoleMessageToWorkerObject): + (WebKit::WebWorkerBase::postConsoleMessageTask): + (WebKit::WebWorkerBase::confirmMessageFromWorkerObject): + (WebKit::WebWorkerBase::confirmMessageTask): + (WebKit::WebWorkerBase::reportPendingActivity): + (WebKit::WebWorkerBase::reportPendingActivityTask): + (WebKit::WebWorkerBase::workerContextClosed): + (WebKit::WebWorkerBase::workerContextClosedTask): + (WebKit::WebWorkerBase::workerContextDestroyed): + (WebKit::WebWorkerBase::workerContextDestroyedTask): + (WebKit::WebWorkerBase::postTaskToLoader): + (WebKit::WebWorkerBase::postTaskForModeToWorkerContext): + * src/WebWorkerBase.h: Added. + (WebKit::WebWorkerBase::setWorkerThread): + (WebKit::WebWorkerBase::workerThread): + * src/WebWorkerClientImpl.cpp: Added. + (WebKit::WebWorkerClientImpl::createWorkerContextProxy): + (WebKit::WebWorkerClientImpl::WebWorkerClientImpl): + (WebKit::WebWorkerClientImpl::~WebWorkerClientImpl): + (WebKit::WebWorkerClientImpl::setWebWorker): + (WebKit::WebWorkerClientImpl::startWorkerContext): + (WebKit::WebWorkerClientImpl::terminateWorkerContext): + (WebKit::WebWorkerClientImpl::postMessageToWorkerContext): + (WebKit::WebWorkerClientImpl::hasPendingActivity): + (WebKit::WebWorkerClientImpl::workerObjectDestroyed): + (WebKit::WebWorkerClientImpl::postMessageToWorkerObject): + (WebKit::WebWorkerClientImpl::postExceptionToWorkerObject): + (WebKit::WebWorkerClientImpl::postConsoleMessageToWorkerObject): + (WebKit::WebWorkerClientImpl::confirmMessageFromWorkerObject): + (WebKit::WebWorkerClientImpl::reportPendingActivity): + (WebKit::WebWorkerClientImpl::workerContextDestroyed): + (WebKit::WebWorkerClientImpl::workerContextClosed): + (WebKit::WebWorkerClientImpl::startWorkerContextTask): + (WebKit::WebWorkerClientImpl::terminateWorkerContextTask): + (WebKit::WebWorkerClientImpl::postMessageToWorkerContextTask): + (WebKit::WebWorkerClientImpl::workerObjectDestroyedTask): + (WebKit::WebWorkerClientImpl::postMessageToWorkerObjectTask): + (WebKit::WebWorkerClientImpl::postExceptionToWorkerObjectTask): + (WebKit::WebWorkerClientImpl::postConsoleMessageToWorkerObjectTask): + (WebKit::WebWorkerClientImpl::confirmMessageFromWorkerObjectTask): + (WebKit::WebWorkerClientImpl::reportPendingActivityTask): + * src/WebWorkerClientImpl.h: Added. + (WebKit::WebWorkerClientImpl::createWorker): + (WebKit::WebWorkerClientImpl::notificationPresenter): + * src/WebWorkerImpl.cpp: Added. + (WebKit::WebWorker::create): + (WebKit::WebWorkerImpl::WebWorkerImpl): + (WebKit::WebWorkerImpl::~WebWorkerImpl): + (WebKit::WebWorkerImpl::commonClient): + (WebKit::WebWorkerImpl::postMessageToWorkerContextTask): + (WebKit::WebWorkerImpl::startWorkerContext): + (WebKit::WebWorkerImpl::terminateWorkerContext): + (WebKit::WebWorkerImpl::postMessageToWorkerContext): + (WebKit::WebWorkerImpl::workerObjectDestroyed): + (WebKit::WebWorkerImpl::clientDestroyed): + * src/WebWorkerImpl.h: Added. + (WebKit::WebWorkerImpl::client): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: Platform specific files. + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/gtk/WebFontInfo.cpp: Added. + (WebKit::WebFontInfo::familyForChars): + * src/gtk/WebInputEventFactory.cpp: Added. + (WebKit::gdkEventTimeToWebEventTime): + (WebKit::gdkStateToWebEventModifiers): + (WebKit::gdkEventToWindowsKeyCode): + (WebKit::getControlCharacter): + (WebKit::WebInputEventFactory::keyboardEvent): + (WebKit::WebInputEventFactory::mouseEvent): + (WebKit::WebInputEventFactory::mouseWheelEvent): + * src/gtk/WebScreenInfoFactory.cpp: Added. + (WebKit::WebScreenInfoFactory::screenInfo): + * src/linux/WebFontRendering.cpp: Added. + (WebKit::WebFontRendering::setHinting): + (WebKit::WebFontRendering::setAntiAlias): + (WebKit::WebFontRendering::setSubpixelGlyphs): + (WebKit::WebFontRendering::setLCDOrder): + (WebKit::WebFontRendering::setLCDOrientation): + * src/mac/WebInputEventFactory.mm: Added. + (WebKit::isKeyUpEvent): + (WebKit::isKeypadEvent): + (WebKit::windowsKeyCodeForKeyEvent): + (WebKit::textFromEvent): + (WebKit::unmodifiedTextFromEvent): + (WebKit::keyIdentifierForKeyEvent): + (WebKit::modifiersFromEvent): + (WebKit::WebInputEventFactory::keyboardEvent): + (WebKit::WebInputEventFactory::mouseEvent): + (WebKit::WebInputEventFactory::mouseWheelEvent): + * src/mac/WebScreenInfoFactory.mm: Added. + (WebKit::screenForWindow): + (WebKit::toUserSpace): + (WebKit::WebScreenInfoFactory::screenInfo): + * src/win/WebInputEventFactory.cpp: Added. + (WebKit::isKeyPad): + (WebKit::WebInputEventFactory::keyboardEvent): + (WebKit::GetRelativeCursorPos): + (WebKit::WebInputEventFactory::resetLastClickState): + (WebKit::WebInputEventFactory::mouseEvent): + (WebKit::WebInputEventFactory::mouseWheelEvent): + * src/win/WebScreenInfoFactory.cpp: Added. + (WebKit::toWebRect): + (WebKit::WebScreenInfoFactory::screenInfo): + * src/x11/WebScreenInfoFactory.cpp: Added. + (WebKit::WebScreenInfoFactory::screenInfo): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Eric Seidel. + + Up-streaming Chromium API src files: WrapperResourceRequest and Response + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WrappedResourceRequest.h: Added. + (WebKit::WrappedResourceRequest::~WrappedResourceRequest): + (WebKit::WrappedResourceRequest::WrappedResourceRequest): + (WebKit::WrappedResourceRequest::bind): + (WebKit::WrappedResourceRequest::Handle::dispose): + * src/WrappedResourceResponse.h: Added. + (WebKit::WrappedResourceResponse::~WrappedResourceResponse): + (WebKit::WrappedResourceResponse::WrappedResourceResponse): + (WebKit::WrappedResourceResponse::bind): + (WebKit::WrappedResourceResponse::Handle::dispose): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: StorageStreamHandlers...StorageNamespaceProxy + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/SocketStreamHandle.cpp: Added. + (WebCore::SocketStreamHandleInternal::create): + (WebCore::SocketStreamHandleInternal::SocketStreamHandleInternal): + (WebCore::SocketStreamHandleInternal::~SocketStreamHandleInternal): + (WebCore::SocketStreamHandleInternal::connect): + (WebCore::SocketStreamHandleInternal::send): + (WebCore::SocketStreamHandleInternal::close): + (WebCore::SocketStreamHandleInternal::willOpenStream): + (WebCore::SocketStreamHandleInternal::didOpenStream): + (WebCore::SocketStreamHandleInternal::didSendData): + (WebCore::SocketStreamHandleInternal::didReceiveData): + (WebCore::SocketStreamHandleInternal::didClose): + (WebCore::SocketStreamHandleInternal::didFail): + (WebCore::SocketStreamHandle::SocketStreamHandle): + (WebCore::SocketStreamHandle::~SocketStreamHandle): + (WebCore::SocketStreamHandle::platformSend): + (WebCore::SocketStreamHandle::platformClose): + (WebCore::SocketStreamHandle::didReceiveAuthenticationChallenge): + (WebCore::SocketStreamHandle::receivedCredential): + (WebCore::SocketStreamHandle::receivedRequestToContinueWithoutCredential): + (WebCore::SocketStreamHandle::receivedCancellation): + * src/StorageAreaProxy.cpp: Added. + (WebCore::StorageAreaProxy::StorageAreaProxy): + (WebCore::StorageAreaProxy::~StorageAreaProxy): + (WebCore::StorageAreaProxy::length): + (WebCore::StorageAreaProxy::key): + (WebCore::StorageAreaProxy::getItem): + (WebCore::StorageAreaProxy::setItem): + (WebCore::StorageAreaProxy::removeItem): + (WebCore::StorageAreaProxy::clear): + (WebCore::StorageAreaProxy::contains): + * src/StorageAreaProxy.h: Added. + * src/StorageEventDispatcherChromium.cpp: Added. + (WebCore::StorageEventDispatcher::dispatch): + * src/StorageEventDispatcherImpl.cpp: Added. + (WebCore::StorageEventDispatcherImpl::StorageEventDispatcherImpl): + (WebCore::StorageEventDispatcherImpl::dispatchStorageEvent): + * src/StorageEventDispatcherImpl.h: Added. + * src/StorageNamespaceProxy.cpp: Added. + (WebCore::StorageNamespace::localStorageNamespace): + (WebCore::StorageNamespace::sessionStorageNamespace): + (WebCore::StorageNamespaceProxy::StorageNamespaceProxy): + (WebCore::StorageNamespaceProxy::~StorageNamespaceProxy): + (WebCore::StorageNamespaceProxy::copy): + (WebCore::StorageNamespaceProxy::storageArea): + (WebCore::StorageNamespaceProxy::close): + (WebCore::StorageNamespaceProxy::unlock): + * src/StorageNamespaceProxy.h: Added. + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: NotificationPresenterImpl...SharedWorkerRepository + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/NotificationPresenterImpl.cpp: Added. + (WebKit::VoidCallbackClient::VoidCallbackClient): + (WebKit::VoidCallbackClient::permissionRequestComplete): + (WebKit::NotificationPresenterImpl::initialize): + (WebKit::NotificationPresenterImpl::isInitialized): + (WebKit::NotificationPresenterImpl::show): + (WebKit::NotificationPresenterImpl::cancel): + (WebKit::NotificationPresenterImpl::notificationObjectDestroyed): + (WebKit::NotificationPresenterImpl::checkPermission): + (WebKit::NotificationPresenterImpl::requestPermission): + * src/NotificationPresenterImpl.h: Added. + (WebKit::NotificationPresenterImpl::NotificationPresenterImpl): + * src/PlatformMessagePortChannel.cpp: Added. + (WebCore::MessagePortChannel::create): + (WebCore::MessagePortChannel::createChannel): + (WebCore::MessagePortChannel::MessagePortChannel): + (WebCore::MessagePortChannel::~MessagePortChannel): + (WebCore::MessagePortChannel::entangleIfOpen): + (WebCore::MessagePortChannel::disentangle): + (WebCore::MessagePortChannel::postMessageToRemote): + (WebCore::MessagePortChannel::tryGetMessageFromRemote): + (WebCore::MessagePortChannel::close): + (WebCore::MessagePortChannel::isConnectedTo): + (WebCore::MessagePortChannel::hasPendingActivity): + (WebCore::MessagePortChannel::locallyEntangledPort): + (WebCore::PlatformMessagePortChannel::create): + (WebCore::PlatformMessagePortChannel::PlatformMessagePortChannel): + (WebCore::PlatformMessagePortChannel::~PlatformMessagePortChannel): + (WebCore::PlatformMessagePortChannel::createChannel): + (WebCore::PlatformMessagePortChannel::messageAvailable): + (WebCore::PlatformMessagePortChannel::entangleIfOpen): + (WebCore::PlatformMessagePortChannel::disentangle): + (WebCore::PlatformMessagePortChannel::postMessageToRemote): + (WebCore::PlatformMessagePortChannel::tryGetMessageFromRemote): + (WebCore::PlatformMessagePortChannel::close): + (WebCore::PlatformMessagePortChannel::isConnectedTo): + (WebCore::PlatformMessagePortChannel::hasPendingActivity): + (WebCore::PlatformMessagePortChannel::setEntangledChannel): + (WebCore::PlatformMessagePortChannel::webChannelRelease): + * src/PlatformMessagePortChannel.h: Added. + * src/ResourceHandle.cpp: Added. + (WebCore::ResourceHandleInternal::ResourceHandleInternal): + (WebCore::ResourceHandleInternal::start): + (WebCore::ResourceHandleInternal::cancel): + (WebCore::ResourceHandleInternal::setDefersLoading): + (WebCore::ResourceHandleInternal::allowStoredCredentials): + (WebCore::ResourceHandleInternal::willSendRequest): + (WebCore::ResourceHandleInternal::didSendData): + (WebCore::ResourceHandleInternal::didReceiveResponse): + (WebCore::ResourceHandleInternal::didReceiveData): + (WebCore::ResourceHandleInternal::didFinishLoading): + (WebCore::ResourceHandleInternal::didFail): + (WebCore::ResourceHandle::ResourceHandle): + (WebCore::ResourceHandle::create): + (WebCore::ResourceHandle::request): + (WebCore::ResourceHandle::client): + (WebCore::ResourceHandle::setClient): + (WebCore::ResourceHandle::setDefersLoading): + (WebCore::ResourceHandle::start): + (WebCore::ResourceHandle::clearAuthentication): + (WebCore::ResourceHandle::cancel): + (WebCore::ResourceHandle::~ResourceHandle): + (WebCore::ResourceHandle::bufferedData): + (WebCore::ResourceHandle::loadsBlocked): + (WebCore::ResourceHandle::supportsBufferedData): + (WebCore::ResourceHandle::loadResourceSynchronously): + (WebCore::ResourceHandle::willLoadFromCache): + * src/SharedWorkerRepository.cpp: Added. + (WebCore::SharedWorkerScriptLoader::SharedWorkerScriptLoader): + (WebCore::SharedWorkerScriptLoader::load): + (WebCore::getWebPort): + (WebCore::SharedWorkerScriptLoader::notifyFinished): + (WebCore::SharedWorkerScriptLoader::sendConnect): + (WebCore::SharedWorkerScriptLoader::contextDestroyed): + (WebCore::SharedWorkerScriptLoader::connected): + (WebCore::SharedWorkerRepository::isAvailable): + (WebCore::getId): + (WebCore::SharedWorkerRepository::connect): + (WebCore::SharedWorkerRepository::documentDetached): + (WebCore::SharedWorkerRepository::hasSharedWorkers): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: GraphicContext3D...MediaPlaterPrivateChromium + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/GraphicsContext3D.cpp: Added. + (WebCore::GraphicsContext3DInternal::): + (WebCore::GraphicsContext3DInternal::VertexAttribPointerState::VertexAttribPointerState): + (WebCore::tryLoad): + (WebCore::GraphicsContext3DInternal::GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::~GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::checkError): + (WebCore::GraphicsContext3DInternal::makeContextCurrent): + (WebCore::GraphicsContext3DInternal::platformGraphicsContext3D): + (WebCore::GraphicsContext3DInternal::platformTexture): + (WebCore::createTextureObject): + (WebCore::GraphicsContext3DInternal::reshape): + (WebCore::GraphicsContext3DInternal::flipVertically): + (WebCore::GraphicsContext3DInternal::beginPaint): + (WebCore::GraphicsContext3DInternal::validateTextureTarget): + (WebCore::GraphicsContext3DInternal::validateTextureParameter): + (WebCore::GraphicsContext3DInternal::activeTexture): + (WebCore::GraphicsContext3DInternal::bindBuffer): + (WebCore::GraphicsContext3DInternal::bindTexture): + (WebCore::GraphicsContext3DInternal::bufferDataImpl): + (WebCore::GraphicsContext3DInternal::disableVertexAttribArray): + (WebCore::GraphicsContext3DInternal::enableVertexAttribArray): + (WebCore::GraphicsContext3DInternal::vertexAttribPointer): + (WebCore::GraphicsContext3DInternal::viewportImpl): + (WebCore::GraphicsContext3D::create): + (WebCore::GraphicsContext3D::GraphicsContext3D): + (WebCore::GraphicsContext3D::~GraphicsContext3D): + (WebCore::GraphicsContext3D::platformGraphicsContext3D): + (WebCore::GraphicsContext3D::platformTexture): + (WebCore::GraphicsContext3D::checkError): + (WebCore::GraphicsContext3D::makeContextCurrent): + (WebCore::GraphicsContext3D::reshape): + (WebCore::GraphicsContext3D::beginPaint): + (WebCore::GraphicsContext3D::endPaint): + (WebCore::GraphicsContext3D::sizeInBytes): + (WebCore::GraphicsContext3D::createBuffer): + (WebCore::GraphicsContext3D::createFramebuffer): + (WebCore::GraphicsContext3D::createProgram): + (WebCore::GraphicsContext3D::createRenderbuffer): + (WebCore::GraphicsContext3D::createShader): + (WebCore::GraphicsContext3D::createTexture): + (WebCore::GraphicsContext3D::deleteBuffer): + (WebCore::GraphicsContext3D::deleteFramebuffer): + (WebCore::GraphicsContext3D::deleteProgram): + (WebCore::GraphicsContext3D::deleteRenderbuffer): + (WebCore::GraphicsContext3D::deleteShader): + (WebCore::GraphicsContext3D::deleteTexture): + (WebCore::GraphicsContext3D::activeTexture): + (WebCore::GraphicsContext3D::bindAttribLocation): + (WebCore::GraphicsContext3D::bindBuffer): + (WebCore::GraphicsContext3D::bindTexture): + (WebCore::GraphicsContext3D::bufferData): + (WebCore::GraphicsContext3D::bufferSubData): + (WebCore::GraphicsContext3D::checkFramebufferStatus): + (WebCore::GraphicsContext3D::detachShader): + (WebCore::GraphicsContext3D::disableVertexAttribArray): + (WebCore::GraphicsContext3D::drawArrays): + (WebCore::GraphicsContext3D::drawElements): + (WebCore::GraphicsContext3D::enableVertexAttribArray): + (WebCore::GraphicsContext3D::generateMipmap): + (WebCore::GraphicsContext3D::getActiveAttrib): + (WebCore::GraphicsContext3D::getActiveUniform): + (WebCore::GraphicsContext3D::getAttribLocation): + (WebCore::GraphicsContext3D::getBoolean): + (WebCore::GraphicsContext3D::getBooleanv): + (WebCore::GraphicsContext3D::getBufferParameteri): + (WebCore::GraphicsContext3D::getBufferParameteriv): + (WebCore::GraphicsContext3D::getError): + (WebCore::GraphicsContext3D::getFloat): + (WebCore::GraphicsContext3D::getFloatv): + (WebCore::GraphicsContext3D::getFramebufferAttachmentParameteri): + (WebCore::GraphicsContext3D::getFramebufferAttachmentParameteriv): + (WebCore::GraphicsContext3D::getInteger): + (WebCore::GraphicsContext3D::getIntegerv): + (WebCore::GraphicsContext3D::getProgrami): + (WebCore::GraphicsContext3D::getProgramiv): + (WebCore::GraphicsContext3D::getProgramInfoLog): + (WebCore::GraphicsContext3D::getRenderbufferParameteri): + (WebCore::GraphicsContext3D::getRenderbufferParameteriv): + (WebCore::GraphicsContext3D::getShaderi): + (WebCore::GraphicsContext3D::getShaderiv): + (WebCore::GraphicsContext3D::getShaderInfoLog): + (WebCore::GraphicsContext3D::getShaderSource): + (WebCore::GraphicsContext3D::getString): + (WebCore::GraphicsContext3D::getTexParameterf): + (WebCore::GraphicsContext3D::getTexParameterfv): + (WebCore::GraphicsContext3D::getTexParameteri): + (WebCore::GraphicsContext3D::getTexParameteriv): + (WebCore::GraphicsContext3D::getUniformf): + (WebCore::GraphicsContext3D::getUniformfv): + (WebCore::GraphicsContext3D::getUniformi): + (WebCore::GraphicsContext3D::getUniformiv): + (WebCore::GraphicsContext3D::getUniformLocation): + (WebCore::GraphicsContext3D::getVertexAttribf): + (WebCore::GraphicsContext3D::getVertexAttribfv): + (WebCore::GraphicsContext3D::getVertexAttribi): + (WebCore::GraphicsContext3D::getVertexAttribiv): + (WebCore::GraphicsContext3D::getVertexAttribOffset): + (WebCore::GraphicsContext3D::isBuffer): + (WebCore::GraphicsContext3D::isEnabled): + (WebCore::GraphicsContext3D::isFramebuffer): + (WebCore::GraphicsContext3D::isProgram): + (WebCore::GraphicsContext3D::isRenderbuffer): + (WebCore::GraphicsContext3D::isShader): + (WebCore::GraphicsContext3D::isTexture): + (WebCore::GraphicsContext3D::pixelStorei): + (WebCore::GraphicsContext3D::readPixels): + (WebCore::GraphicsContext3D::releaseShaderCompiler): + (WebCore::GraphicsContext3D::shaderSource): + (WebCore::GraphicsContext3D::texImage2D): + (WebCore::unmultiplyAlpha): + (WebCore::texImage2DHelper): + (WebCore::GraphicsContext3D::texSubImage2D): + (WebCore::GraphicsContext3D::uniform1fv): + (WebCore::GraphicsContext3D::uniform1iv): + (WebCore::GraphicsContext3D::uniform2fv): + (WebCore::GraphicsContext3D::uniform2iv): + (WebCore::GraphicsContext3D::uniform3fv): + (WebCore::GraphicsContext3D::uniform3iv): + (WebCore::GraphicsContext3D::uniform4fv): + (WebCore::GraphicsContext3D::uniform4iv): + (WebCore::GraphicsContext3D::uniformMatrix2fv): + (WebCore::GraphicsContext3D::uniformMatrix3fv): + (WebCore::GraphicsContext3D::uniformMatrix4fv): + (WebCore::GraphicsContext3D::vertexAttrib1fv): + (WebCore::GraphicsContext3D::vertexAttrib2fv): + (WebCore::GraphicsContext3D::vertexAttrib3fv): + (WebCore::GraphicsContext3D::vertexAttrib4fv): + (WebCore::GraphicsContext3D::vertexAttribPointer): + (WebCore::GraphicsContext3D::viewport): + * src/InspectorClientImpl.cpp: Added. + (WebKit::InspectorClientImpl::InspectorClientImpl): + (WebKit::InspectorClientImpl::~InspectorClientImpl): + (WebKit::InspectorClientImpl::inspectorDestroyed): + (WebKit::InspectorClientImpl::createPage): + (WebKit::InspectorClientImpl::showWindow): + (WebKit::InspectorClientImpl::closeWindow): + (WebKit::InspectorClientImpl::windowVisible): + (WebKit::InspectorClientImpl::attachWindow): + (WebKit::InspectorClientImpl::detachWindow): + (WebKit::InspectorClientImpl::setAttachedWindowHeight): + (WebKit::invalidateNodeBoundingRect): + (WebKit::InspectorClientImpl::highlight): + (WebKit::InspectorClientImpl::hideHighlight): + (WebKit::InspectorClientImpl::inspectedURLChanged): + (WebKit::InspectorClientImpl::localizedStringsURL): + (WebKit::InspectorClientImpl::hiddenPanels): + (WebKit::InspectorClientImpl::populateSetting): + (WebKit::InspectorClientImpl::storeSetting): + (WebKit::InspectorClientImpl::removeSetting): + (WebKit::InspectorClientImpl::inspectorWindowObjectCleared): + (WebKit::InspectorClientImpl::loadSettings): + (WebKit::InspectorClientImpl::saveSettings): + * src/InspectorClientImpl.h: Added. + * src/LocalizedStrings.cpp: Added. + (WebCore::query): + (WebCore::searchableIndexIntroduction): + (WebCore::submitButtonDefaultLabel): + (WebCore::inputElementAltText): + (WebCore::resetButtonDefaultLabel): + (WebCore::fileButtonChooseFileLabel): + (WebCore::fileButtonNoFileSelectedLabel): + (WebCore::searchMenuNoRecentSearchesText): + (WebCore::searchMenuRecentSearchesText): + (WebCore::searchMenuClearRecentSearchesText): + (WebCore::AXWebAreaText): + (WebCore::AXLinkText): + (WebCore::AXListMarkerText): + (WebCore::AXImageMapText): + (WebCore::AXHeadingText): + (WebCore::AXDefinitionListTermText): + (WebCore::AXDefinitionListDefinitionText): + (WebCore::AXButtonActionVerb): + (WebCore::AXRadioButtonActionVerb): + (WebCore::AXTextFieldActionVerb): + (WebCore::AXCheckedCheckBoxActionVerb): + (WebCore::AXUncheckedCheckBoxActionVerb): + (WebCore::AXLinkActionVerb): + (WebCore::multipleFileUploadText): + (WebCore::unknownFileSizeText): + (WebCore::keygenMenuHighGradeKeySize): + (WebCore::keygenMenuMediumGradeKeySize): + (WebCore::imageTitle): + (WebCore::contextMenuItemTagOpenLinkInNewWindow): + (WebCore::contextMenuItemTagDownloadLinkToDisk): + (WebCore::contextMenuItemTagCopyLinkToClipboard): + (WebCore::contextMenuItemTagOpenImageInNewWindow): + (WebCore::contextMenuItemTagDownloadImageToDisk): + (WebCore::contextMenuItemTagCopyImageToClipboard): + (WebCore::contextMenuItemTagOpenFrameInNewWindow): + (WebCore::contextMenuItemTagCopy): + (WebCore::contextMenuItemTagGoBack): + (WebCore::contextMenuItemTagGoForward): + (WebCore::contextMenuItemTagStop): + (WebCore::contextMenuItemTagReload): + (WebCore::contextMenuItemTagCut): + (WebCore::contextMenuItemTagPaste): + (WebCore::contextMenuItemTagNoGuessesFound): + (WebCore::contextMenuItemTagIgnoreSpelling): + (WebCore::contextMenuItemTagLearnSpelling): + (WebCore::contextMenuItemTagSearchWeb): + (WebCore::contextMenuItemTagLookUpInDictionary): + (WebCore::contextMenuItemTagOpenLink): + (WebCore::contextMenuItemTagIgnoreGrammar): + (WebCore::contextMenuItemTagSpellingMenu): + (WebCore::contextMenuItemTagCheckSpelling): + (WebCore::contextMenuItemTagCheckSpellingWhileTyping): + (WebCore::contextMenuItemTagCheckGrammarWithSpelling): + (WebCore::contextMenuItemTagFontMenu): + (WebCore::contextMenuItemTagBold): + (WebCore::contextMenuItemTagItalic): + (WebCore::contextMenuItemTagUnderline): + (WebCore::contextMenuItemTagOutline): + (WebCore::contextMenuItemTagWritingDirectionMenu): + (WebCore::contextMenuItemTagTextDirectionMenu): + (WebCore::contextMenuItemTagDefaultDirection): + (WebCore::contextMenuItemTagLeftToRight): + (WebCore::contextMenuItemTagRightToLeft): + (WebCore::contextMenuItemTagInspectElement): + (WebCore::contextMenuItemTagShowSpellingPanel): + (WebCore::mediaElementLiveBroadcastStateText): + (WebCore::mediaElementLoadingStateText): + (WebCore::localizedMediaControlElementString): + (WebCore::localizedMediaControlElementHelpText): + (WebCore::localizedMediaTimeDescription): + * src/MediaPlayerPrivateChromium.cpp: Added. + (WebCore::MediaPlayerPrivate::registerMediaEngine): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: DOMUtilities...FrameLoaderClientImpl + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/DOMUtilitiesPrivate.cpp: Added. + (WebCore::toHTMLElement): + (WebKit::toHTMLInputElement): + (WebKit::toHTMLLinkElement): + (WebKit::toHTMLMetaElement): + (WebKit::toHTMLOptionElement): + (WebKit::nameOfInputElement): + * src/DOMUtilitiesPrivate.h: Added. + * src/DragClientImpl.cpp: Added. + (WebKit::DragClientImpl::willPerformDragDestinationAction): + (WebKit::DragClientImpl::willPerformDragSourceAction): + (WebKit::DragClientImpl::actionMaskForDrag): + (WebKit::DragClientImpl::dragSourceActionMaskForPoint): + (WebKit::DragClientImpl::startDrag): + (WebKit::DragClientImpl::createDragImageForLink): + (WebKit::DragClientImpl::dragControllerDestroyed): + * src/DragClientImpl.h: Added. + (WebKit::DragClientImpl::DragClientImpl): + * src/EditorClientImpl.cpp: Added. + (WebKit::EditorClientImpl::EditorClientImpl): + (WebKit::EditorClientImpl::~EditorClientImpl): + (WebKit::EditorClientImpl::pageDestroyed): + (WebKit::EditorClientImpl::shouldShowDeleteInterface): + (WebKit::EditorClientImpl::smartInsertDeleteEnabled): + (WebKit::EditorClientImpl::isSelectTrailingWhitespaceEnabled): + (WebKit::EditorClientImpl::shouldSpellcheckByDefault): + (WebKit::EditorClientImpl::isContinuousSpellCheckingEnabled): + (WebKit::EditorClientImpl::toggleContinuousSpellChecking): + (WebKit::EditorClientImpl::isGrammarCheckingEnabled): + (WebKit::EditorClientImpl::toggleGrammarChecking): + (WebKit::EditorClientImpl::spellCheckerDocumentTag): + (WebKit::EditorClientImpl::isEditable): + (WebKit::EditorClientImpl::shouldBeginEditing): + (WebKit::EditorClientImpl::shouldEndEditing): + (WebKit::EditorClientImpl::shouldInsertNode): + (WebKit::EditorClientImpl::shouldInsertText): + (WebKit::EditorClientImpl::shouldDeleteRange): + (WebKit::EditorClientImpl::shouldChangeSelectedRange): + (WebKit::EditorClientImpl::shouldApplyStyle): + (WebKit::EditorClientImpl::shouldMoveRangeAfterDelete): + (WebKit::EditorClientImpl::didBeginEditing): + (WebKit::EditorClientImpl::respondToChangedSelection): + (WebKit::EditorClientImpl::respondToChangedContents): + (WebKit::EditorClientImpl::didEndEditing): + (WebKit::EditorClientImpl::didWriteSelectionToPasteboard): + (WebKit::EditorClientImpl::didSetSelectionTypesForPasteboard): + (WebKit::EditorClientImpl::registerCommandForUndo): + (WebKit::EditorClientImpl::registerCommandForRedo): + (WebKit::EditorClientImpl::clearUndoRedoOperations): + (WebKit::EditorClientImpl::canUndo): + (WebKit::EditorClientImpl::canRedo): + (WebKit::EditorClientImpl::undo): + (WebKit::EditorClientImpl::redo): + (WebKit::): + (WebKit::EditorClientImpl::interpretKeyEvent): + (WebKit::EditorClientImpl::handleEditingKeyboardEvent): + (WebKit::EditorClientImpl::handleKeyboardEvent): + (WebKit::EditorClientImpl::handleInputMethodKeydown): + (WebKit::EditorClientImpl::textFieldDidBeginEditing): + (WebKit::EditorClientImpl::textFieldDidEndEditing): + (WebKit::EditorClientImpl::textDidChangeInTextField): + (WebKit::EditorClientImpl::showFormAutofillForNode): + (WebKit::EditorClientImpl::autofill): + (WebKit::EditorClientImpl::doAutofill): + (WebKit::EditorClientImpl::cancelPendingAutofill): + (WebKit::EditorClientImpl::onAutofillSuggestionAccepted): + (WebKit::EditorClientImpl::doTextFieldCommandFromEvent): + (WebKit::EditorClientImpl::textWillBeDeletedInTextField): + (WebKit::EditorClientImpl::textDidChangeInTextArea): + (WebKit::EditorClientImpl::ignoreWordInSpellDocument): + (WebKit::EditorClientImpl::learnWord): + (WebKit::EditorClientImpl::checkSpellingOfString): + (WebKit::EditorClientImpl::getAutoCorrectSuggestionForMisspelledWord): + (WebKit::EditorClientImpl::checkGrammarOfString): + (WebKit::EditorClientImpl::updateSpellingUIWithGrammarString): + (WebKit::EditorClientImpl::updateSpellingUIWithMisspelledWord): + (WebKit::EditorClientImpl::showSpellingUI): + (WebKit::EditorClientImpl::spellingUIIsShowing): + (WebKit::EditorClientImpl::getGuessesForWord): + (WebKit::EditorClientImpl::setInputMethodState): + * src/EditorClientImpl.h: Added. + (WebKit::EditorClientImpl::): + * src/FrameLoaderClientImpl.cpp: Added. + (WebKit::): + (WebKit::FrameLoaderClientImpl::FrameLoaderClientImpl): + (WebKit::FrameLoaderClientImpl::~FrameLoaderClientImpl): + (WebKit::FrameLoaderClientImpl::frameLoaderDestroyed): + (WebKit::FrameLoaderClientImpl::windowObjectCleared): + (WebKit::FrameLoaderClientImpl::documentElementAvailable): + (WebKit::FrameLoaderClientImpl::didCreateScriptContextForFrame): + (WebKit::FrameLoaderClientImpl::didDestroyScriptContextForFrame): + (WebKit::FrameLoaderClientImpl::didCreateIsolatedScriptContext): + (WebKit::FrameLoaderClientImpl::didPerformFirstNavigation): + (WebKit::FrameLoaderClientImpl::registerForIconNotification): + (WebKit::FrameLoaderClientImpl::didChangeScrollOffset): + (WebKit::FrameLoaderClientImpl::allowJavaScript): + (WebKit::FrameLoaderClientImpl::hasWebView): + (WebKit::FrameLoaderClientImpl::hasFrameView): + (WebKit::FrameLoaderClientImpl::makeDocumentView): + (WebKit::FrameLoaderClientImpl::makeRepresentation): + (WebKit::FrameLoaderClientImpl::forceLayout): + (WebKit::FrameLoaderClientImpl::forceLayoutForNonHTML): + (WebKit::FrameLoaderClientImpl::setCopiesOnScroll): + (WebKit::FrameLoaderClientImpl::detachedFromParent2): + (WebKit::FrameLoaderClientImpl::detachedFromParent3): + (WebKit::FrameLoaderClientImpl::assignIdentifierToInitialRequest): + (WebKit::determineTargetTypeFromLoader): + (WebKit::FrameLoaderClientImpl::dispatchWillSendRequest): + (WebKit::FrameLoaderClientImpl::shouldUseCredentialStorage): + (WebKit::FrameLoaderClientImpl::dispatchDidReceiveAuthenticationChallenge): + (WebKit::FrameLoaderClientImpl::dispatchDidCancelAuthenticationChallenge): + (WebKit::FrameLoaderClientImpl::dispatchDidReceiveResponse): + (WebKit::FrameLoaderClientImpl::dispatchDidReceiveContentLength): + (WebKit::FrameLoaderClientImpl::dispatchDidFinishLoading): + (WebKit::FrameLoaderClientImpl::dispatchDidFailLoading): + (WebKit::FrameLoaderClientImpl::dispatchDidFinishDocumentLoad): + (WebKit::FrameLoaderClientImpl::dispatchDidLoadResourceFromMemoryCache): + (WebKit::FrameLoaderClientImpl::dispatchDidLoadResourceByXMLHttpRequest): + (WebKit::FrameLoaderClientImpl::dispatchDidHandleOnloadEvents): + (WebKit::FrameLoaderClientImpl::dispatchDidReceiveServerRedirectForProvisionalLoad): + (WebKit::FrameLoaderClientImpl::dispatchDidCancelClientRedirect): + (WebKit::FrameLoaderClientImpl::dispatchWillPerformClientRedirect): + (WebKit::FrameLoaderClientImpl::dispatchDidChangeLocationWithinPage): + (WebKit::FrameLoaderClientImpl::dispatchWillClose): + (WebKit::FrameLoaderClientImpl::dispatchDidReceiveIcon): + (WebKit::FrameLoaderClientImpl::dispatchDidStartProvisionalLoad): + (WebKit::FrameLoaderClientImpl::dispatchDidReceiveTitle): + (WebKit::FrameLoaderClientImpl::dispatchDidCommitLoad): + (WebKit::FrameLoaderClientImpl::dispatchDidFailProvisionalLoad): + (WebKit::FrameLoaderClientImpl::dispatchDidFailLoad): + (WebKit::FrameLoaderClientImpl::dispatchDidFinishLoad): + (WebKit::FrameLoaderClientImpl::dispatchDidFirstLayout): + (WebKit::FrameLoaderClientImpl::dispatchDidFirstVisuallyNonEmptyLayout): + (WebKit::FrameLoaderClientImpl::dispatchCreatePage): + (WebKit::FrameLoaderClientImpl::dispatchShow): + (WebKit::shouldTreatAsAttachment): + (WebKit::FrameLoaderClientImpl::dispatchDecidePolicyForMIMEType): + (WebKit::FrameLoaderClientImpl::dispatchDecidePolicyForNewWindowAction): + (WebKit::FrameLoaderClientImpl::dispatchDecidePolicyForNavigationAction): + (WebKit::FrameLoaderClientImpl::cancelPolicyCheck): + (WebKit::FrameLoaderClientImpl::dispatchUnableToImplementPolicy): + (WebKit::FrameLoaderClientImpl::dispatchWillSubmitForm): + (WebKit::FrameLoaderClientImpl::dispatchDidLoadMainResource): + (WebKit::FrameLoaderClientImpl::revertToProvisionalState): + (WebKit::FrameLoaderClientImpl::setMainDocumentError): + (WebKit::FrameLoaderClientImpl::postProgressStartedNotification): + (WebKit::FrameLoaderClientImpl::postProgressEstimateChangedNotification): + (WebKit::FrameLoaderClientImpl::postProgressFinishedNotification): + (WebKit::FrameLoaderClientImpl::setMainFrameDocumentReady): + (WebKit::FrameLoaderClientImpl::startDownload): + (WebKit::FrameLoaderClientImpl::willChangeTitle): + (WebKit::FrameLoaderClientImpl::didChangeTitle): + (WebKit::FrameLoaderClientImpl::committedLoad): + (WebKit::FrameLoaderClientImpl::finishedLoading): + (WebKit::FrameLoaderClientImpl::updateGlobalHistory): + (WebKit::FrameLoaderClientImpl::updateGlobalHistoryRedirectLinks): + (WebKit::FrameLoaderClientImpl::shouldGoToHistoryItem): + (WebKit::FrameLoaderClientImpl::didDisplayInsecureContent): + (WebKit::FrameLoaderClientImpl::didRunInsecureContent): + (WebKit::FrameLoaderClientImpl::blockedError): + (WebKit::FrameLoaderClientImpl::cancelledError): + (WebKit::FrameLoaderClientImpl::cannotShowURLError): + (WebKit::FrameLoaderClientImpl::interruptForPolicyChangeError): + (WebKit::FrameLoaderClientImpl::cannotShowMIMETypeError): + (WebKit::FrameLoaderClientImpl::fileDoesNotExistError): + (WebKit::FrameLoaderClientImpl::pluginWillHandleLoadError): + (WebKit::FrameLoaderClientImpl::shouldFallBack): + (WebKit::FrameLoaderClientImpl::canHandleRequest): + (WebKit::FrameLoaderClientImpl::canShowMIMEType): + (WebKit::FrameLoaderClientImpl::representationExistsForURLScheme): + (WebKit::FrameLoaderClientImpl::generatedMIMETypeForURLScheme): + (WebKit::FrameLoaderClientImpl::frameLoadCompleted): + (WebKit::FrameLoaderClientImpl::saveViewStateToItem): + (WebKit::FrameLoaderClientImpl::restoreViewState): + (WebKit::FrameLoaderClientImpl::provisionalLoadStarted): + (WebKit::FrameLoaderClientImpl::didFinishLoad): + (WebKit::FrameLoaderClientImpl::prepareForDataSourceReplacement): + (WebKit::FrameLoaderClientImpl::createDocumentLoader): + (WebKit::FrameLoaderClientImpl::setTitle): + (WebKit::FrameLoaderClientImpl::userAgent): + (WebKit::FrameLoaderClientImpl::savePlatformDataToCachedFrame): + (WebKit::FrameLoaderClientImpl::transitionToCommittedFromCachedFrame): + (WebKit::FrameLoaderClientImpl::transitionToCommittedForNewPage): + (WebKit::FrameLoaderClientImpl::canCachePage): + (WebKit::FrameLoaderClientImpl::download): + (WebKit::FrameLoaderClientImpl::createFrame): + (WebKit::FrameLoaderClientImpl::createPlugin): + (WebKit::FrameLoaderClientImpl::redirectDataToPlugin): + (WebKit::FrameLoaderClientImpl::createJavaAppletWidget): + (WebKit::FrameLoaderClientImpl::objectContentType): + (WebKit::FrameLoaderClientImpl::overrideMediaType): + (WebKit::FrameLoaderClientImpl::actionSpecifiesNavigationPolicy): + (WebKit::FrameLoaderClientImpl::handleBackForwardNavigation): + (WebKit::FrameLoaderClientImpl::pluginLoadObserver): + * src/FrameLoaderClientImpl.h: Added. + (WebKit::FrameLoaderClientImpl::webFrame): + (WebKit::FrameLoaderClientImpl::willChangeEstimatedProgress): + (WebKit::FrameLoaderClientImpl::didChangeEstimatedProgress): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: ChromeClientImpl...ContextMenuClientImpl + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/ChromeClientImpl.cpp: Added. + (WebKit::ChromeClientImpl::ChromeClientImpl): + (WebKit::ChromeClientImpl::~ChromeClientImpl): + (WebKit::ChromeClientImpl::chromeDestroyed): + (WebKit::ChromeClientImpl::setWindowRect): + (WebKit::ChromeClientImpl::windowRect): + (WebKit::ChromeClientImpl::pageRect): + (WebKit::ChromeClientImpl::scaleFactor): + (WebKit::ChromeClientImpl::focus): + (WebKit::ChromeClientImpl::unfocus): + (WebKit::ChromeClientImpl::canTakeFocus): + (WebKit::ChromeClientImpl::takeFocus): + (WebKit::ChromeClientImpl::focusedNodeChanged): + (WebKit::ChromeClientImpl::createWindow): + (WebKit::currentEventShouldCauseBackgroundTab): + (WebKit::ChromeClientImpl::show): + (WebKit::ChromeClientImpl::canRunModal): + (WebKit::ChromeClientImpl::runModal): + (WebKit::ChromeClientImpl::setToolbarsVisible): + (WebKit::ChromeClientImpl::toolbarsVisible): + (WebKit::ChromeClientImpl::setStatusbarVisible): + (WebKit::ChromeClientImpl::statusbarVisible): + (WebKit::ChromeClientImpl::setScrollbarsVisible): + (WebKit::ChromeClientImpl::scrollbarsVisible): + (WebKit::ChromeClientImpl::setMenubarVisible): + (WebKit::ChromeClientImpl::menubarVisible): + (WebKit::ChromeClientImpl::setResizable): + (WebKit::ChromeClientImpl::addMessageToConsole): + (WebKit::ChromeClientImpl::canRunBeforeUnloadConfirmPanel): + (WebKit::ChromeClientImpl::runBeforeUnloadConfirmPanel): + (WebKit::ChromeClientImpl::closeWindowSoon): + (WebKit::ChromeClientImpl::runJavaScriptAlert): + (WebKit::ChromeClientImpl::runJavaScriptConfirm): + (WebKit::ChromeClientImpl::runJavaScriptPrompt): + (WebKit::ChromeClientImpl::setStatusbarText): + (WebKit::ChromeClientImpl::shouldInterruptJavaScript): + (WebKit::ChromeClientImpl::tabsToLinks): + (WebKit::ChromeClientImpl::windowResizerRect): + (WebKit::ChromeClientImpl::repaint): + (WebKit::ChromeClientImpl::scroll): + (WebKit::ChromeClientImpl::screenToWindow): + (WebKit::ChromeClientImpl::windowToScreen): + (WebKit::ChromeClientImpl::contentsSizeChanged): + (WebKit::ChromeClientImpl::scrollbarsModeDidChange): + (WebKit::ChromeClientImpl::mouseDidMoveOverElement): + (WebKit::ChromeClientImpl::setToolTip): + (WebKit::ChromeClientImpl::print): + (WebKit::ChromeClientImpl::exceededDatabaseQuota): + (WebKit::ChromeClientImpl::reachedMaxAppCacheSize): + (WebKit::ChromeClientImpl::runOpenPanel): + (WebKit::ChromeClientImpl::popupOpened): + (WebKit::ChromeClientImpl::setCursor): + (WebKit::ChromeClientImpl::setCursorForPlugin): + (WebKit::ChromeClientImpl::formStateDidChange): + (WebKit::ChromeClientImpl::getPopupMenuInfo): + (WebKit::ChromeClientImpl::notificationPresenter): + * src/ChromeClientImpl.h: Added. + (WebKit::ChromeClientImpl::webView): + (WebKit::ChromeClientImpl::platformPageClient): + (WebKit::ChromeClientImpl::scrollRectIntoView): + (WebKit::ChromeClientImpl::requestGeolocationPermissionForFrame): + (WebKit::ChromeClientImpl::setCursor): + (WebKit::ChromeClientImpl::createHTMLParserQuirks): + * src/ChromiumBridge.cpp: Added. + (WebCore::toChromeClientImpl): + (WebCore::toWebWidgetClient): + (WebCore::ChromiumBridge::clipboardIsFormatAvailable): + (WebCore::ChromiumBridge::clipboardReadPlainText): + (WebCore::ChromiumBridge::clipboardReadHTML): + (WebCore::ChromiumBridge::clipboardWriteSelection): + (WebCore::ChromiumBridge::clipboardWritePlainText): + (WebCore::ChromiumBridge::clipboardWriteURL): + (WebCore::ChromiumBridge::clipboardWriteImage): + (WebCore::ChromiumBridge::setCookies): + (WebCore::ChromiumBridge::cookies): + (WebCore::ChromiumBridge::rawCookies): + (WebCore::ChromiumBridge::deleteCookie): + (WebCore::ChromiumBridge::prefetchDNS): + (WebCore::ChromiumBridge::fileExists): + (WebCore::ChromiumBridge::deleteFile): + (WebCore::ChromiumBridge::deleteEmptyDirectory): + (WebCore::ChromiumBridge::getFileSize): + (WebCore::ChromiumBridge::getFileModificationTime): + (WebCore::ChromiumBridge::directoryName): + (WebCore::ChromiumBridge::pathByAppendingComponent): + (WebCore::ChromiumBridge::makeAllDirectories): + (WebCore::ChromiumBridge::getAbsolutePath): + (WebCore::ChromiumBridge::isDirectory): + (WebCore::ChromiumBridge::filePathToURL): + (WebCore::ChromiumBridge::ensureFontLoaded): + (WebCore::ChromiumBridge::getFontFamilyForCharacters): + (WebCore::ChromiumBridge::databaseOpenFile): + (WebCore::ChromiumBridge::databaseDeleteFile): + (WebCore::ChromiumBridge::databaseGetFileAttributes): + (WebCore::ChromiumBridge::databaseGetFileSize): + (WebCore::ChromiumBridge::signedPublicKeyAndChallengeString): + (WebCore::ChromiumBridge::computedDefaultLanguage): + (WebCore::ChromiumBridge::layoutTestMode): + (WebCore::ChromiumBridge::isSupportedImageMIMEType): + (WebCore::ChromiumBridge::isSupportedJavaScriptMIMEType): + (WebCore::ChromiumBridge::isSupportedNonImageMIMEType): + (WebCore::ChromiumBridge::mimeTypeForExtension): + (WebCore::ChromiumBridge::mimeTypeFromFile): + (WebCore::ChromiumBridge::preferredExtensionForMIMEType): + (WebCore::ChromiumBridge::plugins): + (WebCore::ChromiumBridge::pluginScriptableObject): + (WebCore::ChromiumBridge::loadPlatformImageResource): + (WebCore::ChromiumBridge::sandboxEnabled): + (WebCore::ChromiumBridge::setSharedTimerFiredFunction): + (WebCore::ChromiumBridge::setSharedTimerFireTime): + (WebCore::ChromiumBridge::stopSharedTimer): + (WebCore::ChromiumBridge::decrementStatsCounter): + (WebCore::ChromiumBridge::incrementStatsCounter): + (WebCore::ChromiumBridge::suddenTerminationChanged): + (WebCore::ChromiumBridge::currentTime): + (WebCore::ChromiumBridge::paintButton): + (WebCore::ChromiumBridge::paintMenuList): + (WebCore::ChromiumBridge::paintScrollbarArrow): + (WebCore::ChromiumBridge::paintScrollbarThumb): + (WebCore::ChromiumBridge::paintScrollbarTrack): + (WebCore::ChromiumBridge::paintTextField): + (WebCore::ChromiumBridge::paintTrackbar): + (WebCore::ChromiumBridge::traceEventBegin): + (WebCore::ChromiumBridge::traceEventEnd): + (WebCore::ChromiumBridge::visitedLinkHash): + (WebCore::ChromiumBridge::isLinkVisited): + (WebCore::ChromiumBridge::notifyJSOutOfMemory): + (WebCore::ChromiumBridge::memoryUsageMB): + (WebCore::ChromiumBridge::screenDepth): + (WebCore::ChromiumBridge::screenDepthPerComponent): + (WebCore::ChromiumBridge::screenIsMonochrome): + (WebCore::ChromiumBridge::screenRect): + (WebCore::ChromiumBridge::screenAvailableRect): + (WebCore::ChromiumBridge::popupsAllowed): + (WebCore::ChromiumBridge::widgetSetCursor): + (WebCore::ChromiumBridge::widgetSetFocus): + (WebCore::WorkerContextProxy::create): + * src/ChromiumCurrentTime.cpp: Added. + (WTF::currentTime): + * src/ChromiumThreading.cpp: Added. + (WTF::ChromiumThreading::initializeMainThread): + (WTF::ChromiumThreading::scheduleDispatchFunctionsOnMainThread): + * src/ContextMenuClientImpl.cpp: Added. + (WebKit::urlFromFrame): + (WebKit::isASingleWord): + (WebKit::selectMisspelledWord): + (WebKit::ContextMenuClientImpl::getCustomMenuFromDefaultItems): + * src/ContextMenuClientImpl.h: Added. + (WebKit::ContextMenuClientImpl::ContextMenuClientImpl): + (WebKit::ContextMenuClientImpl::~ContextMenuClientImpl): + (WebKit::ContextMenuClientImpl::copyImageToClipboard): + (WebKit::ContextMenuClientImpl::contextMenuDestroyed): + (WebKit::ContextMenuClientImpl::contextMenuItemSelected): + (WebKit::ContextMenuClientImpl::downloadURL): + (WebKit::ContextMenuClientImpl::isSpeaking): + (WebKit::ContextMenuClientImpl::lookUpInDictionary): + (WebKit::ContextMenuClientImpl::searchWithGoogle): + (WebKit::ContextMenuClientImpl::shouldIncludeInspectElementItem): + (WebKit::ContextMenuClientImpl::speak): + (WebKit::ContextMenuClientImpl::stopSpeaking): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: AppCach...BackForwardListClientImpl + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/ApplicationCacheHost.cpp: Added. + (WebCore::ApplicationCacheHostInternal::ApplicationCacheHostInternal): + (WebCore::ApplicationCacheHostInternal::notifyEventListener): + (WebCore::ApplicationCacheHost::ApplicationCacheHost): + (WebCore::ApplicationCacheHost::~ApplicationCacheHost): + (WebCore::ApplicationCacheHost::maybeLoadMainResource): + (WebCore::ApplicationCacheHost::selectCacheWithoutManifest): + (WebCore::ApplicationCacheHost::selectCacheWithManifest): + (WebCore::ApplicationCacheHost::maybeLoadFallbackForMainResponse): + (WebCore::ApplicationCacheHost::maybeLoadFallbackForMainError): + (WebCore::ApplicationCacheHost::mainResourceDataReceived): + (WebCore::ApplicationCacheHost::failedLoadingMainResource): + (WebCore::ApplicationCacheHost::finishedLoadingMainResource): + (WebCore::ApplicationCacheHost::maybeLoadResource): + (WebCore::ApplicationCacheHost::maybeLoadFallbackForRedirect): + (WebCore::ApplicationCacheHost::maybeLoadFallbackForResponse): + (WebCore::ApplicationCacheHost::maybeLoadFallbackForError): + (WebCore::ApplicationCacheHost::maybeLoadSynchronously): + (WebCore::ApplicationCacheHost::maybeLoadFallbackSynchronously): + (WebCore::ApplicationCacheHost::canCacheInPageCache): + (WebCore::ApplicationCacheHost::setDOMApplicationCache): + (WebCore::ApplicationCacheHost::notifyDOMApplicationCache): + (WebCore::ApplicationCacheHost::status): + (WebCore::ApplicationCacheHost::update): + (WebCore::ApplicationCacheHost::swapCache): + (WebCore::ApplicationCacheHost::isApplicationCacheEnabled): + * src/AssertMatchingEnums.cpp: Added. + * src/AutocompletePopupMenuClient.cpp: Added. + (WebKit::AutocompletePopupMenuClient::AutocompletePopupMenuClient): + (WebKit::AutocompletePopupMenuClient::~AutocompletePopupMenuClient): + (WebKit::AutocompletePopupMenuClient::initialize): + (WebKit::AutocompletePopupMenuClient::valueChanged): + (WebKit::AutocompletePopupMenuClient::itemText): + (WebKit::AutocompletePopupMenuClient::itemStyle): + (WebKit::AutocompletePopupMenuClient::menuStyle): + (WebKit::AutocompletePopupMenuClient::clientPaddingLeft): + (WebKit::AutocompletePopupMenuClient::clientPaddingRight): + (WebKit::AutocompletePopupMenuClient::popupDidHide): + (WebKit::AutocompletePopupMenuClient::setTextFromItem): + (WebKit::AutocompletePopupMenuClient::fontSelector): + (WebKit::AutocompletePopupMenuClient::hostWindow): + (WebKit::AutocompletePopupMenuClient::createScrollbar): + (WebKit::AutocompletePopupMenuClient::setSuggestions): + (WebKit::AutocompletePopupMenuClient::removeItemAtIndex): + (WebKit::AutocompletePopupMenuClient::textFieldStyle): + * src/AutocompletePopupMenuClient.h: Added. + (WebKit::AutocompletePopupMenuClient::textField): + (WebKit::AutocompletePopupMenuClient::itemToolTip): + (WebKit::AutocompletePopupMenuClient::itemIsEnabled): + (WebKit::AutocompletePopupMenuClient::clientInsetLeft): + (WebKit::AutocompletePopupMenuClient::clientInsetRight): + (WebKit::AutocompletePopupMenuClient::listSize): + (WebKit::AutocompletePopupMenuClient::selectedIndex): + (WebKit::AutocompletePopupMenuClient::itemIsSeparator): + (WebKit::AutocompletePopupMenuClient::itemIsLabel): + (WebKit::AutocompletePopupMenuClient::itemIsSelected): + (WebKit::AutocompletePopupMenuClient::shouldPopOver): + (WebKit::AutocompletePopupMenuClient::valueShouldChangeOnHotTrack): + * src/BackForwardListClientImpl.cpp: Added. + (WebKit::BackForwardListClientImpl::BackForwardListClientImpl): + (WebKit::BackForwardListClientImpl::~BackForwardListClientImpl): + (WebKit::BackForwardListClientImpl::setCurrentHistoryItem): + (WebKit::BackForwardListClientImpl::previousHistoryItem): + (WebKit::BackForwardListClientImpl::addItem): + (WebKit::BackForwardListClientImpl::goToItem): + (WebKit::BackForwardListClientImpl::currentItem): + (WebKit::BackForwardListClientImpl::itemAtIndex): + (WebKit::BackForwardListClientImpl::backListCount): + (WebKit::BackForwardListClientImpl::forwardListCount): + (WebKit::BackForwardListClientImpl::close): + * src/BackForwardListClientImpl.h: Added. + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebString...WebViewImpl + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebString.cpp: Added. + (WebKit::WebString::reset): + (WebKit::WebString::assign): + (WebKit::WebString::length): + (WebKit::WebString::data): + (WebKit::WebString::utf8): + (WebKit::WebString::fromUTF8): + (WebKit::WebString::WebString): + (WebKit::WebString::operator=): + (WebKit::WebString::operator WebCore::String): + (WebKit::WebString::operator WebCore::AtomicString): + * src/WebURL.cpp: Added. + (WebKit::WebURL::WebURL): + (WebKit::WebURL::operator=): + (WebKit::WebURL::operator WebCore::KURL): + * src/WebURLError.cpp: Added. + (WebKit::WebURLError::WebURLError): + (WebKit::WebURLError::operator=): + (WebKit::WebURLError::operator ResourceError): + * src/WebURLRequest.cpp: Added. + (WebKit::WebURLRequestPrivateImpl::WebURLRequestPrivateImpl): + (WebKit::WebURLRequestPrivateImpl::dispose): + (WebKit::WebURLRequest::initialize): + (WebKit::WebURLRequest::reset): + (WebKit::WebURLRequest::assign): + (WebKit::WebURLRequest::isNull): + (WebKit::WebURLRequest::url): + (WebKit::WebURLRequest::setURL): + (WebKit::WebURLRequest::firstPartyForCookies): + (WebKit::WebURLRequest::setFirstPartyForCookies): + (WebKit::WebURLRequest::allowCookies): + (WebKit::WebURLRequest::setAllowCookies): + (WebKit::WebURLRequest::allowStoredCredentials): + (WebKit::WebURLRequest::setAllowStoredCredentials): + (WebKit::WebURLRequest::cachePolicy): + (WebKit::WebURLRequest::setCachePolicy): + (WebKit::WebURLRequest::httpMethod): + (WebKit::WebURLRequest::setHTTPMethod): + (WebKit::WebURLRequest::httpHeaderField): + (WebKit::WebURLRequest::setHTTPHeaderField): + (WebKit::WebURLRequest::addHTTPHeaderField): + (WebKit::WebURLRequest::clearHTTPHeaderField): + (WebKit::WebURLRequest::visitHTTPHeaderFields): + (WebKit::WebURLRequest::httpBody): + (WebKit::WebURLRequest::setHTTPBody): + (WebKit::WebURLRequest::reportUploadProgress): + (WebKit::WebURLRequest::setReportUploadProgress): + (WebKit::WebURLRequest::targetType): + (WebKit::WebURLRequest::setTargetType): + (WebKit::WebURLRequest::requestorID): + (WebKit::WebURLRequest::setRequestorID): + (WebKit::WebURLRequest::requestorProcessID): + (WebKit::WebURLRequest::setRequestorProcessID): + (WebKit::WebURLRequest::appCacheHostID): + (WebKit::WebURLRequest::setAppCacheHostID): + (WebKit::WebURLRequest::toMutableResourceRequest): + (WebKit::WebURLRequest::toResourceRequest): + * src/WebURLRequestPrivate.h: Added. + (WebKit::WebURLRequestPrivate::WebURLRequestPrivate): + * src/WebURLResponse.cpp: Added. + (WebKit::WebURLResponsePrivateImpl::WebURLResponsePrivateImpl): + (WebKit::WebURLResponsePrivateImpl::dispose): + (WebKit::WebURLResponse::initialize): + (WebKit::WebURLResponse::reset): + (WebKit::WebURLResponse::assign): + (WebKit::WebURLResponse::isNull): + (WebKit::WebURLResponse::url): + (WebKit::WebURLResponse::setURL): + (WebKit::WebURLResponse::mimeType): + (WebKit::WebURLResponse::setMIMEType): + (WebKit::WebURLResponse::expectedContentLength): + (WebKit::WebURLResponse::setExpectedContentLength): + (WebKit::WebURLResponse::textEncodingName): + (WebKit::WebURLResponse::setTextEncodingName): + (WebKit::WebURLResponse::suggestedFileName): + (WebKit::WebURLResponse::setSuggestedFileName): + (WebKit::WebURLResponse::httpStatusCode): + (WebKit::WebURLResponse::setHTTPStatusCode): + (WebKit::WebURLResponse::httpStatusText): + (WebKit::WebURLResponse::setHTTPStatusText): + (WebKit::WebURLResponse::httpHeaderField): + (WebKit::WebURLResponse::setHTTPHeaderField): + (WebKit::WebURLResponse::addHTTPHeaderField): + (WebKit::WebURLResponse::clearHTTPHeaderField): + (WebKit::WebURLResponse::visitHTTPHeaderFields): + (WebKit::WebURLResponse::lastModifiedDate): + (WebKit::WebURLResponse::setLastModifiedDate): + (WebKit::WebURLResponse::isContentFiltered): + (WebKit::WebURLResponse::setIsContentFiltered): + (WebKit::WebURLResponse::appCacheID): + (WebKit::WebURLResponse::setAppCacheID): + (WebKit::WebURLResponse::appCacheManifestURL): + (WebKit::WebURLResponse::setAppCacheManifestURL): + (WebKit::WebURLResponse::securityInfo): + (WebKit::WebURLResponse::setSecurityInfo): + (WebKit::WebURLResponse::toMutableResourceResponse): + (WebKit::WebURLResponse::toResourceResponse): + * src/WebURLResponsePrivate.h: Added. + (WebKit::WebURLResponsePrivate::WebURLResponsePrivate): + * src/WebViewImpl.cpp: Added. + (WebKit::): + (WebKit::WebView::create): + (WebKit::WebView::updateVisitedLinkState): + (WebKit::WebView::resetVisitedLinkState): + (WebKit::WebViewImpl::initializeMainFrame): + (WebKit::WebViewImpl::WebViewImpl): + (WebKit::WebViewImpl::~WebViewImpl): + (WebKit::WebViewImpl::theme): + (WebKit::WebViewImpl::mainFrameImpl): + (WebKit::WebViewImpl::tabKeyCyclesThroughElements): + (WebKit::WebViewImpl::setTabKeyCyclesThroughElements): + (WebKit::WebViewImpl::mouseMove): + (WebKit::WebViewImpl::mouseLeave): + (WebKit::WebViewImpl::mouseDown): + (WebKit::WebViewImpl::mouseContextMenu): + (WebKit::WebViewImpl::mouseUp): + (WebKit::WebViewImpl::mouseWheel): + (WebKit::WebViewImpl::keyEvent): + (WebKit::WebViewImpl::autocompleteHandleKeyEvent): + (WebKit::WebViewImpl::charEvent): + (WebKit::WebViewImpl::sendContextMenuEvent): + (WebKit::WebViewImpl::keyEventDefault): + (WebKit::WebViewImpl::scrollViewWithKeyboard): + (WebKit::WebViewImpl::propagateScroll): + (WebKit::WebViewImpl::focusedWebCoreFrame): + (WebKit::WebViewImpl::fromPage): + (WebKit::WebViewImpl::close): + (WebKit::WebViewImpl::resize): + (WebKit::WebViewImpl::layout): + (WebKit::WebViewImpl::paint): + (WebKit::WebViewImpl::handleInputEvent): + (WebKit::WebViewImpl::mouseCaptureLost): + (WebKit::WebViewImpl::setFocus): + (WebKit::WebViewImpl::handleCompositionEvent): + (WebKit::WebViewImpl::queryCompositionStatus): + (WebKit::WebViewImpl::setTextDirection): + (WebKit::WebViewImpl::settings): + (WebKit::WebViewImpl::pageEncoding): + (WebKit::WebViewImpl::setPageEncoding): + (WebKit::WebViewImpl::dispatchBeforeUnloadEvent): + (WebKit::WebViewImpl::dispatchUnloadEvent): + (WebKit::WebViewImpl::mainFrame): + (WebKit::WebViewImpl::findFrameByName): + (WebKit::WebViewImpl::focusedFrame): + (WebKit::WebViewImpl::setFocusedFrame): + (WebKit::WebViewImpl::setInitialFocus): + (WebKit::WebViewImpl::clearFocusedNode): + (WebKit::WebViewImpl::zoomIn): + (WebKit::WebViewImpl::zoomOut): + (WebKit::WebViewImpl::zoomDefault): + (WebKit::WebViewImpl::performMediaPlayerAction): + (WebKit::WebViewImpl::copyImageAt): + (WebKit::WebViewImpl::dragSourceEndedAt): + (WebKit::WebViewImpl::dragSourceMovedTo): + (WebKit::WebViewImpl::dragSourceSystemDragEnded): + (WebKit::WebViewImpl::dragTargetDragEnter): + (WebKit::WebViewImpl::dragTargetDragOver): + (WebKit::WebViewImpl::dragTargetDragLeave): + (WebKit::WebViewImpl::dragTargetDrop): + (WebKit::WebViewImpl::dragIdentity): + (WebKit::WebViewImpl::inspectElementAt): + (WebKit::WebViewImpl::inspectorSettings): + (WebKit::WebViewImpl::setInspectorSettings): + (WebKit::WebViewImpl::devToolsAgent): + (WebKit::WebViewImpl::setDevToolsAgent): + (WebKit::WebViewImpl::accessibilityObject): + (WebKit::WebViewImpl::applyAutofillSuggestions): + (WebKit::WebViewImpl::hideAutofillPopup): + (WebKit::WebViewImpl::setDropEffect): + (WebKit::WebViewImpl::setIsTransparent): + (WebKit::WebViewImpl::isTransparent): + (WebKit::WebViewImpl::setIsActive): + (WebKit::WebViewImpl::isActive): + (WebKit::WebViewImpl::didCommitLoad): + (WebKit::WebViewImpl::navigationPolicyFromMouseEvent): + (WebKit::WebViewImpl::startDragging): + (WebKit::WebViewImpl::setCurrentHistoryItem): + (WebKit::WebViewImpl::previousHistoryItem): + (WebKit::WebViewImpl::observeNewNavigation): + (WebKit::WebViewImpl::hideAutoCompletePopup): + (WebKit::WebViewImpl::autoCompletePopupDidHide): + (WebKit::WebViewImpl::setIgnoreInputEvents): + (WebKit::WebViewImpl::notificationPresenterImpl): + (WebKit::WebViewImpl::refreshAutofillPopup): + (WebKit::WebViewImpl::focusedWebCoreNode): + (WebKit::WebViewImpl::hitTestResultForWindowPos): + (WebKit::WebViewImpl::setTabsToLinks): + (WebKit::WebViewImpl::tabsToLinks): + * src/WebViewImpl.h: Added. + (WebKit::WebViewImpl::size): + (WebKit::WebViewImpl::devToolsAgentPrivate): + (WebKit::WebViewImpl::lastMouseDownPoint): + (WebKit::WebViewImpl::client): + (WebKit::WebViewImpl::page): + (WebKit::WebViewImpl::contextMenuAllowed): + (WebKit::WebViewImpl::setInitialNavigationPolicy): + (WebKit::WebViewImpl::initialNavigationPolicy): + (WebKit::WebViewImpl::currentInputEvent): + (WebKit::WebViewImpl::): + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebScriptController...WebStorageNamespaceImpl + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebScriptController.cpp: Added. + (WebKit::WebScriptController::registerExtension): + (WebKit::WebScriptController::enableV8SingleThreadMode): + (WebKit::WebScriptController::flushConsoleMessages): + * src/WebSearchableFormData.cpp: Added. + (WebCore::GetFormEncoding): + (WebCore::IsHTTPFormSubmit): + (WebCore::GetButtonToActivate): + (WebCore::IsSelectInDefaultState): + (WebCore::IsInDefaultState): + (WebCore::HasSuitableTextElement): + (WebKit::WebSearchableFormData::WebSearchableFormData): + * src/WebSecurityOrigin.cpp: Added. + (WebKit::WebSecurityOrigin::reset): + (WebKit::WebSecurityOrigin::assign): + (WebKit::WebSecurityOrigin::protocol): + (WebKit::WebSecurityOrigin::host): + (WebKit::WebSecurityOrigin::port): + (WebKit::WebSecurityOrigin::isEmpty): + (WebKit::WebSecurityOrigin::toString): + (WebKit::WebSecurityOrigin::databaseIdentifier): + (WebKit::WebSecurityOrigin::WebSecurityOrigin): + (WebKit::WebSecurityOrigin::operator=): + (WebKit::WebSecurityOrigin::operator WTF::PassRefPtr<WebCore::SecurityOrigin>): + * src/WebSecurityPolicy.cpp: Added. + (WebKit::WebSecurityPolicy::registerURLSchemeAsLocal): + (WebKit::WebSecurityPolicy::registerURLSchemeAsNoAccess): + (WebKit::WebSecurityPolicy::whiteListAccessFromOrigin): + (WebKit::WebSecurityPolicy::resetOriginAccessWhiteLists): + * src/WebSettingsImpl.cpp: Added. + (WebKit::WebSettingsImpl::WebSettingsImpl): + (WebKit::WebSettingsImpl::setStandardFontFamily): + (WebKit::WebSettingsImpl::setFixedFontFamily): + (WebKit::WebSettingsImpl::setSerifFontFamily): + (WebKit::WebSettingsImpl::setSansSerifFontFamily): + (WebKit::WebSettingsImpl::setCursiveFontFamily): + (WebKit::WebSettingsImpl::setFantasyFontFamily): + (WebKit::WebSettingsImpl::setDefaultFontSize): + (WebKit::WebSettingsImpl::setDefaultFixedFontSize): + (WebKit::WebSettingsImpl::setMinimumFontSize): + (WebKit::WebSettingsImpl::setMinimumLogicalFontSize): + (WebKit::WebSettingsImpl::setDefaultTextEncodingName): + (WebKit::WebSettingsImpl::setJavaScriptEnabled): + (WebKit::WebSettingsImpl::setWebSecurityEnabled): + (WebKit::WebSettingsImpl::setJavaScriptCanOpenWindowsAutomatically): + (WebKit::WebSettingsImpl::setLoadsImagesAutomatically): + (WebKit::WebSettingsImpl::setPluginsEnabled): + (WebKit::WebSettingsImpl::setDOMPasteAllowed): + (WebKit::WebSettingsImpl::setDeveloperExtrasEnabled): + (WebKit::WebSettingsImpl::setShrinksStandaloneImagesToFit): + (WebKit::WebSettingsImpl::setUsesEncodingDetector): + (WebKit::WebSettingsImpl::setTextAreasAreResizable): + (WebKit::WebSettingsImpl::setJavaEnabled): + (WebKit::WebSettingsImpl::setAllowScriptsToCloseWindows): + (WebKit::WebSettingsImpl::setUserStyleSheetLocation): + (WebKit::WebSettingsImpl::setUsesPageCache): + (WebKit::WebSettingsImpl::setDownloadableBinaryFontsEnabled): + (WebKit::WebSettingsImpl::setXSSAuditorEnabled): + (WebKit::WebSettingsImpl::setLocalStorageEnabled): + (WebKit::WebSettingsImpl::setEditableLinkBehaviorNeverLive): + (WebKit::WebSettingsImpl::setFontRenderingModeNormal): + (WebKit::WebSettingsImpl::setShouldPaintCustomScrollbars): + (WebKit::WebSettingsImpl::setDatabasesEnabled): + (WebKit::WebSettingsImpl::setAllowUniversalAccessFromFileURLs): + (WebKit::WebSettingsImpl::setTextDirectionSubmenuInclusionBehaviorNeverIncluded): + (WebKit::WebSettingsImpl::setOfflineWebApplicationCacheEnabled): + (WebKit::WebSettingsImpl::setExperimentalWebGLEnabled): + * src/WebSettingsImpl.h: Added. + (WebKit::WebSettingsImpl::~WebSettingsImpl): + * src/WebSharedWorkerImpl.cpp: Added. + (WebKit::WebSharedWorkerImpl::WebSharedWorkerImpl): + (WebKit::WebSharedWorkerImpl::~WebSharedWorkerImpl): + (WebKit::WebSharedWorkerImpl::isStarted): + (WebKit::WebSharedWorkerImpl::connect): + (WebKit::WebSharedWorkerImpl::connectTask): + (WebKit::WebSharedWorkerImpl::startWorkerContext): + (WebKit::WebSharedWorkerImpl::terminateWorkerContext): + (WebKit::WebSharedWorkerImpl::clientDestroyed): + (WebKit::WebSharedWorkerImpl::client): + (WebKit::WebSharedWorker::create): + * src/WebSharedWorkerImpl.h: Added. + (WebKit::WebSharedWorkerImpl::commonClient): + * src/WebStorageAreaImpl.cpp: Added. + (WebKit::WebStorageAreaImpl::WebStorageAreaImpl): + (WebKit::WebStorageAreaImpl::~WebStorageAreaImpl): + (WebKit::WebStorageAreaImpl::length): + (WebKit::WebStorageAreaImpl::key): + (WebKit::WebStorageAreaImpl::getItem): + (WebKit::WebStorageAreaImpl::setItem): + (WebKit::WebStorageAreaImpl::removeItem): + (WebKit::WebStorageAreaImpl::clear): + * src/WebStorageAreaImpl.h: Added. + (WebKit::WebStorageAreaImpl::currentStorageEventURL): + (WebKit::WebStorageAreaImpl::ScopedStorageEventURL::ScopedStorageEventURL): + (WebKit::WebStorageAreaImpl::ScopedStorageEventURL::~ScopedStorageEventURL): + * src/WebStorageEventDispatcherImpl.cpp: Added. + (WebKit::WebStorageEventDispatcher::create): + (WebKit::WebStorageEventDispatcherImpl::WebStorageEventDispatcherImpl): + (WebKit::WebStorageEventDispatcherImpl::dispatchStorageEvent): + * src/WebStorageEventDispatcherImpl.h: Added. + * src/WebStorageNamespaceImpl.cpp: Added. + (WebKit::WebStorageNamespace::createLocalStorageNamespace): + (WebKit::WebStorageNamespace::createSessionStorageNamespace): + (WebKit::WebStorageNamespaceImpl::WebStorageNamespaceImpl): + (WebKit::WebStorageNamespaceImpl::~WebStorageNamespaceImpl): + (WebKit::WebStorageNamespaceImpl::createStorageArea): + (WebKit::WebStorageNamespaceImpl::copy): + (WebKit::WebStorageNamespaceImpl::close): + * src/WebStorageNamespaceImpl.h: Added. + +2009-11-10 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebPasswordFormData...WebRuntimeFeatures + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebPasswordFormData.cpp: Added. + (WebKit::): + (WebKit::WebPasswordFormData::WebPasswordFormData): + * src/WebPasswordFormUtils.cpp: Added. + (WebKit::findPasswordFormFields): + * src/WebPasswordFormUtils.h: Added. + (WebKit::PasswordFormFields::PasswordFormFields): + * src/WebPluginContainerImpl.cpp: Added. + (WebKit::WebPluginContainerImpl::setFrameRect): + (WebKit::WebPluginContainerImpl::paint): + (WebKit::WebPluginContainerImpl::invalidateRect): + (WebKit::WebPluginContainerImpl::setFocus): + (WebKit::WebPluginContainerImpl::show): + (WebKit::WebPluginContainerImpl::hide): + (WebKit::WebPluginContainerImpl::handleEvent): + (WebKit::WebPluginContainerImpl::frameRectsChanged): + (WebKit::WebPluginContainerImpl::setParentVisible): + (WebKit::WebPluginContainerImpl::setParent): + (WebKit::WebPluginContainerImpl::invalidate): + (WebKit::WebPluginContainerImpl::reportGeometry): + (WebKit::WebPluginContainerImpl::clearScriptObjects): + (WebKit::WebPluginContainerImpl::scriptableObjectForElement): + (WebKit::WebPluginContainerImpl::executeScriptURL): + (WebKit::WebPluginContainerImpl::loadFrameRequest): + (WebKit::WebPluginContainerImpl::didReceiveResponse): + (WebKit::WebPluginContainerImpl::didReceiveData): + (WebKit::WebPluginContainerImpl::didFinishLoading): + (WebKit::WebPluginContainerImpl::didFailLoading): + (WebKit::WebPluginContainerImpl::scriptableObject): + (WebKit::WebPluginContainerImpl::willDestroyPluginLoadObserver): + (WebKit::WebPluginContainerImpl::~WebPluginContainerImpl): + (WebKit::WebPluginContainerImpl::handleMouseEvent): + (WebKit::WebPluginContainerImpl::handleKeyboardEvent): + (WebKit::WebPluginContainerImpl::calculateGeometry): + (WebKit::WebPluginContainerImpl::windowClipRect): + (WebKit::getObjectStack): + (WebKit::checkStackOnTop): + (WebKit::WebPluginContainerImpl::windowCutOutRects): + * src/WebPluginContainerImpl.h: Added. + (WebKit::WebPluginContainerImpl::create): + (WebKit::WebPluginContainerImpl::plugin): + (WebKit::WebPluginContainerImpl::WebPluginContainerImpl): + * src/WebPluginListBuilderImpl.cpp: Added. + (WebKit::WebPluginListBuilderImpl::addPlugin): + (WebKit::WebPluginListBuilderImpl::addMediaTypeToLastPlugin): + (WebKit::WebPluginListBuilderImpl::addFileExtensionToLastMediaType): + * src/WebPluginListBuilderImpl.h: Added. + (WebKit::WebPluginListBuilderImpl::WebPluginListBuilderImpl): + * src/WebPluginLoadObserver.cpp: Added. + (WebKit::WebPluginLoadObserver::~WebPluginLoadObserver): + (WebKit::WebPluginLoadObserver::didFinishLoading): + (WebKit::WebPluginLoadObserver::didFailLoading): + * src/WebPluginLoadObserver.h: Added. + (WebKit::WebPluginLoadObserver::WebPluginLoadObserver): + (WebKit::WebPluginLoadObserver::url): + (WebKit::WebPluginLoadObserver::clearPluginContainer): + * src/WebPopupMenuImpl.cpp: Added. + (WebKit::WebPopupMenu::create): + (WebKit::WebPopupMenuImpl::WebPopupMenuImpl): + (WebKit::WebPopupMenuImpl::~WebPopupMenuImpl): + (WebKit::WebPopupMenuImpl::Init): + (WebKit::WebPopupMenuImpl::MouseMove): + (WebKit::WebPopupMenuImpl::MouseLeave): + (WebKit::WebPopupMenuImpl::MouseDown): + (WebKit::WebPopupMenuImpl::MouseUp): + (WebKit::WebPopupMenuImpl::MouseWheel): + (WebKit::WebPopupMenuImpl::KeyEvent): + (WebKit::WebPopupMenuImpl::close): + (WebKit::WebPopupMenuImpl::resize): + (WebKit::WebPopupMenuImpl::layout): + (WebKit::WebPopupMenuImpl::paint): + (WebKit::WebPopupMenuImpl::handleInputEvent): + (WebKit::WebPopupMenuImpl::mouseCaptureLost): + (WebKit::WebPopupMenuImpl::setFocus): + (WebKit::WebPopupMenuImpl::handleCompositionEvent): + (WebKit::WebPopupMenuImpl::queryCompositionStatus): + (WebKit::WebPopupMenuImpl::setTextDirection): + (WebKit::WebPopupMenuImpl::repaint): + (WebKit::WebPopupMenuImpl::scroll): + (WebKit::WebPopupMenuImpl::screenToWindow): + (WebKit::WebPopupMenuImpl::windowToScreen): + (WebKit::WebPopupMenuImpl::scrollRectIntoView): + (WebKit::WebPopupMenuImpl::scrollbarsModeDidChange): + (WebKit::WebPopupMenuImpl::popupClosed): + * src/WebPopupMenuImpl.h: Added. + (WebKit::WebPopupMenuImpl::size): + (WebKit::WebPopupMenuImpl::client): + (WebKit::WebPopupMenuImpl::platformPageClient): + * src/WebRange.cpp: Added. + (WebKit::WebRange::reset): + (WebKit::WebRange::assign): + (WebKit::WebRange::startOffset): + (WebKit::WebRange::endOffset): + (WebKit::WebRange::startContainer): + (WebKit::WebRange::endContainer): + (WebKit::WebRange::toHTMLText): + (WebKit::WebRange::toPlainText): + (WebKit::WebRange::WebRange): + (WebKit::WebRange::operator=): + (WebKit::WebRange::operator WTF::PassRefPtr<WebCore::Range>): + * src/WebRuntimeFeatures.cpp: Added. + (WebKit::WebRuntimeFeatures::enableDatabase): + (WebKit::WebRuntimeFeatures::isDatabaseEnabled): + (WebKit::WebRuntimeFeatures::enableLocalStorage): + (WebKit::WebRuntimeFeatures::isLocalStorageEnabled): + (WebKit::WebRuntimeFeatures::enableSessionStorage): + (WebKit::WebRuntimeFeatures::isSessionStorageEnabled): + (WebKit::WebRuntimeFeatures::enableMediaPlayer): + (WebKit::WebRuntimeFeatures::isMediaPlayerEnabled): + (WebKit::WebRuntimeFeatures::enableSockets): + (WebKit::WebRuntimeFeatures::isSocketsEnabled): + (WebKit::WebRuntimeFeatures::enableNotifications): + (WebKit::WebRuntimeFeatures::isNotificationsEnabled): + (WebKit::WebRuntimeFeatures::enableApplicationCache): + (WebKit::WebRuntimeFeatures::isApplicationCacheEnabled): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebFileInputElement...WebNotifications + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebInputElement.cpp: Added. + (WebKit::WebInputElement::WebInputElement): + (WebKit::WebInputElement::operator=): + (WebKit::WebInputElement::operator WTF::PassRefPtr<HTMLInputElement>): + (WebKit::WebInputElement::setActivatedSubmit): + (WebKit::WebInputElement::setValue): + (WebKit::WebInputElement::value): + (WebKit::WebInputElement::setAutofilled): + (WebKit::WebInputElement::dispatchFormControlChangeEvent): + (WebKit::WebInputElement::setSelectionRange): + * src/WebInputEvent.cpp: Added. + (WebKit::staticKeyIdentifiers): + (WebKit::WebKeyboardEvent::setKeyIdentifierFromWindowsKeyCode): + * src/WebInputEventConversion.cpp: Added. + (WebKit::PlatformMouseEventBuilder::PlatformMouseEventBuilder): + (WebKit::PlatformWheelEventBuilder::PlatformWheelEventBuilder): + (WebKit::toPlatformKeyboardEventType): + (WebKit::PlatformKeyboardEventBuilder::PlatformKeyboardEventBuilder): + (WebKit::PlatformKeyboardEventBuilder::setKeyType): + (WebKit::PlatformKeyboardEventBuilder::isCharacterKey): + (WebKit::getWebInputModifiers): + (WebKit::WebMouseEventBuilder::WebMouseEventBuilder): + (WebKit::WebKeyboardEventBuilder::WebKeyboardEventBuilder): + * src/WebInputEventConversion.h: Added. + * src/WebKit.cpp: Added. + (WebKit::initialize): + (WebKit::shutdown): + (WebKit::webKitClient): + (WebKit::setLayoutTestMode): + (WebKit::layoutTestMode): + (WebKit::resetPluginCache): + * src/WebMediaPlayerClientImpl.cpp: Added. + (WebKit::createWebMediaPlayer): + (WebKit::WebMediaPlayerClientImpl::isEnabled): + (WebKit::WebMediaPlayerClientImpl::setIsEnabled): + (WebKit::WebMediaPlayerClientImpl::registerSelf): + (WebKit::WebMediaPlayerClientImpl::networkStateChanged): + (WebKit::WebMediaPlayerClientImpl::readyStateChanged): + (WebKit::WebMediaPlayerClientImpl::volumeChanged): + (WebKit::WebMediaPlayerClientImpl::timeChanged): + (WebKit::WebMediaPlayerClientImpl::repaint): + (WebKit::WebMediaPlayerClientImpl::durationChanged): + (WebKit::WebMediaPlayerClientImpl::rateChanged): + (WebKit::WebMediaPlayerClientImpl::sizeChanged): + (WebKit::WebMediaPlayerClientImpl::sawUnsupportedTracks): + (WebKit::WebMediaPlayerClientImpl::load): + (WebKit::WebMediaPlayerClientImpl::cancelLoad): + (WebKit::WebMediaPlayerClientImpl::play): + (WebKit::WebMediaPlayerClientImpl::pause): + (WebKit::WebMediaPlayerClientImpl::naturalSize): + (WebKit::WebMediaPlayerClientImpl::hasVideo): + (WebKit::WebMediaPlayerClientImpl::hasAudio): + (WebKit::WebMediaPlayerClientImpl::setVisible): + (WebKit::WebMediaPlayerClientImpl::duration): + (WebKit::WebMediaPlayerClientImpl::currentTime): + (WebKit::WebMediaPlayerClientImpl::seek): + (WebKit::WebMediaPlayerClientImpl::seeking): + (WebKit::WebMediaPlayerClientImpl::setEndTime): + (WebKit::WebMediaPlayerClientImpl::setRate): + (WebKit::WebMediaPlayerClientImpl::paused): + (WebKit::WebMediaPlayerClientImpl::supportsFullscreen): + (WebKit::WebMediaPlayerClientImpl::supportsSave): + (WebKit::WebMediaPlayerClientImpl::setVolume): + (WebKit::WebMediaPlayerClientImpl::networkState): + (WebKit::WebMediaPlayerClientImpl::readyState): + (WebKit::WebMediaPlayerClientImpl::maxTimeSeekable): + (WebKit::WebMediaPlayerClientImpl::buffered): + (WebKit::WebMediaPlayerClientImpl::dataRate): + (WebKit::WebMediaPlayerClientImpl::totalBytesKnown): + (WebKit::WebMediaPlayerClientImpl::totalBytes): + (WebKit::WebMediaPlayerClientImpl::bytesLoaded): + (WebKit::WebMediaPlayerClientImpl::setSize): + (WebKit::WebMediaPlayerClientImpl::paint): + (WebKit::WebMediaPlayerClientImpl::setAutobuffer): + (WebKit::WebMediaPlayerClientImpl::hasSingleSecurityOrigin): + (WebKit::WebMediaPlayerClientImpl::movieLoadType): + (WebKit::WebMediaPlayerClientImpl::create): + (WebKit::WebMediaPlayerClientImpl::getSupportedTypes): + (WebKit::WebMediaPlayerClientImpl::supportsType): + (WebKit::WebMediaPlayerClientImpl::WebMediaPlayerClientImpl): + * src/WebMediaPlayerClientImpl.h: Added. + * src/WebNode.cpp: Added. + (WebKit::WebNode::reset): + (WebKit::WebNode::assign): + (WebKit::WebNode::parentNode): + (WebKit::WebNode::nodeName): + (WebKit::WebNode::WebNode): + (WebKit::WebNode::operator=): + (WebKit::WebNode::operator WTF::PassRefPtr<WebCore::Node>): + (WebKit::WebNode::frame): + * src/WebNotification.cpp: Added. + (WebKit::WebNotification::reset): + (WebKit::WebNotification::assign): + (WebKit::WebNotification::lessThan): + (WebKit::WebNotification::isHTML): + (WebKit::WebNotification::url): + (WebKit::WebNotification::icon): + (WebKit::WebNotification::title): + (WebKit::WebNotification::body): + (WebKit::WebNotification::dispatchDisplayEvent): + (WebKit::WebNotification::dispatchErrorEvent): + (WebKit::WebNotification::dispatchCloseEvent): + (WebKit::WebNotification::WebNotification): + (WebKit::WebNotification::operator=): + (WebKit::WebNotification::operator WTF::PassRefPtr<Notification>): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebFileChooser...WebImageSkia + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebFileChooserCompletionImpl.cpp: Added. + (WebKit::WebFileChooserCompletionImpl::WebFileChooserCompletionImpl): + (WebKit::WebFileChooserCompletionImpl::~WebFileChooserCompletionImpl): + (WebKit::WebFileChooserCompletionImpl::didChooseFile): + * src/WebFileChooserCompletionImpl.h: Added. + * src/WebFontCache.cpp: Added. + (WebKit::WebFontCache::fontDataCount): + (WebKit::WebFontCache::inactiveFontDataCount): + (WebKit::WebFontCache::clear): + * src/WebFormElement.cpp: Added. + (WebKit::WebFormElement::WebFormElement): + (WebKit::WebFormElement::operator=): + (WebKit::WebFormElement::operator WTF::PassRefPtr<WebCore::HTMLFormElement>): + (WebKit::WebFormElement::autoComplete): + (WebKit::WebFormElement::action): + (WebKit::WebFormElement::submit): + (WebKit::WebFormElement::getNamedElements): + * src/WebFrameImpl.cpp: Added. + (WebKit::frameContentAsPlainText): + (WebKit::ChromePrintContext::ChromePrintContext): + (WebKit::ChromePrintContext::begin): + (WebKit::ChromePrintContext::getPageShrink): + (WebKit::ChromePrintContext::spoolPage): + (WebKit::DataSourceForDocLoader): + (WebKit::WebFrameImpl::DeferredScopeStringMatches::DeferredScopeStringMatches): + (WebKit::WebFrameImpl::DeferredScopeStringMatches::doTimeout): + (WebKit::WebFrame::frameForEnteredContext): + (WebKit::WebFrame::frameForCurrentContext): + (WebKit::WebFrameImpl::name): + (WebKit::WebFrameImpl::url): + (WebKit::WebFrameImpl::favIconURL): + (WebKit::WebFrameImpl::openSearchDescriptionURL): + (WebKit::WebFrameImpl::scrollOffset): + (WebKit::WebFrameImpl::contentsSize): + (WebKit::WebFrameImpl::contentsPreferredWidth): + (WebKit::WebFrameImpl::hasVisibleContent): + (WebKit::WebFrameImpl::view): + (WebKit::WebFrameImpl::opener): + (WebKit::WebFrameImpl::parent): + (WebKit::WebFrameImpl::top): + (WebKit::WebFrameImpl::firstChild): + (WebKit::WebFrameImpl::lastChild): + (WebKit::WebFrameImpl::nextSibling): + (WebKit::WebFrameImpl::previousSibling): + (WebKit::WebFrameImpl::traverseNext): + (WebKit::WebFrameImpl::traversePrevious): + (WebKit::WebFrameImpl::findChildByName): + (WebKit::WebFrameImpl::findChildByExpression): + (WebKit::WebFrameImpl::forms): + (WebKit::WebFrameImpl::securityOrigin): + (WebKit::WebFrameImpl::grantUniversalAccess): + (WebKit::WebFrameImpl::windowObject): + (WebKit::WebFrameImpl::bindToWindowObject): + (WebKit::WebFrameImpl::executeScript): + (WebKit::WebFrameImpl::executeScriptInNewContext): + (WebKit::WebFrameImpl::executeScriptInIsolatedWorld): + (WebKit::WebFrameImpl::addMessageToConsole): + (WebKit::WebFrameImpl::collectGarbage): + (WebKit::WebFrameImpl::mainWorldScriptContext): + (WebKit::WebFrameImpl::insertStyleText): + (WebKit::WebFrameImpl::reload): + (WebKit::WebFrameImpl::loadRequest): + (WebKit::WebFrameImpl::loadHistoryItem): + (WebKit::WebFrameImpl::loadData): + (WebKit::WebFrameImpl::loadHTMLString): + (WebKit::WebFrameImpl::isLoading): + (WebKit::WebFrameImpl::stopLoading): + (WebKit::WebFrameImpl::provisionalDataSource): + (WebKit::WebFrameImpl::dataSource): + (WebKit::WebFrameImpl::previousHistoryItem): + (WebKit::WebFrameImpl::currentHistoryItem): + (WebKit::WebFrameImpl::enableViewSourceMode): + (WebKit::WebFrameImpl::isViewSourceModeEnabled): + (WebKit::WebFrameImpl::setReferrerForRequest): + (WebKit::WebFrameImpl::dispatchWillSendRequest): + (WebKit::WebFrameImpl::commitDocumentData): + (WebKit::WebFrameImpl::unloadListenerCount): + (WebKit::WebFrameImpl::isProcessingUserGesture): + (WebKit::WebFrameImpl::willSuppressOpenerInNewFrame): + (WebKit::WebFrameImpl::replaceSelection): + (WebKit::WebFrameImpl::insertText): + (WebKit::WebFrameImpl::setMarkedText): + (WebKit::WebFrameImpl::unmarkText): + (WebKit::WebFrameImpl::hasMarkedText): + (WebKit::WebFrameImpl::markedRange): + (WebKit::WebFrameImpl::executeCommand): + (WebKit::WebFrameImpl::isCommandEnabled): + (WebKit::WebFrameImpl::enableContinuousSpellChecking): + (WebKit::WebFrameImpl::isContinuousSpellCheckingEnabled): + (WebKit::WebFrameImpl::hasSelection): + (WebKit::WebFrameImpl::selectionRange): + (WebKit::WebFrameImpl::selectionAsText): + (WebKit::WebFrameImpl::selectionAsMarkup): + (WebKit::WebFrameImpl::printBegin): + (WebKit::WebFrameImpl::getPrintPageShrink): + (WebKit::WebFrameImpl::printPage): + (WebKit::WebFrameImpl::printEnd): + (WebKit::WebFrameImpl::find): + (WebKit::WebFrameImpl::stopFinding): + (WebKit::WebFrameImpl::scopeStringMatches): + (WebKit::WebFrameImpl::cancelPendingScopingEffort): + (WebKit::WebFrameImpl::increaseMatchCount): + (WebKit::WebFrameImpl::reportFindInPageSelection): + (WebKit::WebFrameImpl::resetMatchCount): + (WebKit::WebFrameImpl::completeURL): + (WebKit::WebFrameImpl::contentAsText): + (WebKit::WebFrameImpl::contentAsMarkup): + (WebKit::WebFrameImpl::create): + (WebKit::WebFrameImpl::WebFrameImpl): + (WebKit::WebFrameImpl::~WebFrameImpl): + (WebKit::WebFrameImpl::initializeAsMainFrame): + (WebKit::WebFrameImpl::createChildFrame): + (WebKit::WebFrameImpl::layout): + (WebKit::WebFrameImpl::paint): + (WebKit::WebFrameImpl::createFrameView): + (WebKit::WebFrameImpl::fromFrame): + (WebKit::WebFrameImpl::viewImpl): + (WebKit::WebFrameImpl::dataSourceImpl): + (WebKit::WebFrameImpl::provisionalDataSourceImpl): + (WebKit::WebFrameImpl::setFindEndstateFocusAndSelection): + (WebKit::WebFrameImpl::didFail): + (WebKit::WebFrameImpl::setAllowsScrolling): + (WebKit::WebFrameImpl::registerPasswordListener): + (WebKit::WebFrameImpl::getPasswordListener): + (WebKit::WebFrameImpl::closing): + (WebKit::WebFrameImpl::invalidateArea): + (WebKit::WebFrameImpl::addMarker): + (WebKit::WebFrameImpl::setMarkerActive): + (WebKit::WebFrameImpl::ordinalOfFirstMatchForFrame): + (WebKit::WebFrameImpl::shouldScopeMatches): + (WebKit::WebFrameImpl::scopeStringMatchesSoon): + (WebKit::WebFrameImpl::callScopeStringMatches): + (WebKit::WebFrameImpl::invalidateIfNecessary): + (WebKit::WebFrameImpl::clearPasswordListeners): + (WebKit::WebFrameImpl::loadJavaScriptURL): + * src/WebFrameImpl.h: Added. + (WebKit::WebFrameImpl::liveObjectCount): + (WebKit::WebFrameImpl::frame): + (WebKit::WebFrameImpl::frameView): + (WebKit::WebFrameImpl::activeMatchFrame): + (WebKit::WebFrameImpl::client): + (WebKit::WebFrameImpl::dropClient): + (WebKit::WebFrameImpl::ClientHandle::create): + (WebKit::WebFrameImpl::ClientHandle::client): + (WebKit::WebFrameImpl::ClientHandle::dropClient): + (WebKit::WebFrameImpl::ClientHandle::ClientHandle): + (WebKit::WebFrameImpl::): + * src/WebHTTPBody.cpp: Added. + (WebKit::WebHTTPBody::initialize): + (WebKit::WebHTTPBody::reset): + (WebKit::WebHTTPBody::assign): + (WebKit::WebHTTPBody::elementCount): + (WebKit::WebHTTPBody::elementAt): + (WebKit::WebHTTPBody::appendData): + (WebKit::WebHTTPBody::appendFile): + (WebKit::WebHTTPBody::identifier): + (WebKit::WebHTTPBody::setIdentifier): + (WebKit::WebHTTPBody::WebHTTPBody): + (WebKit::WebHTTPBody::operator=): + (WebKit::WebHTTPBody::operator PassRefPtr<FormData>): + (WebKit::WebHTTPBody::ensureMutable): + * src/WebHistoryItem.cpp: Added. + (WebKit::WebHistoryItem::initialize): + (WebKit::WebHistoryItem::reset): + (WebKit::WebHistoryItem::assign): + (WebKit::WebHistoryItem::urlString): + (WebKit::WebHistoryItem::setURLString): + (WebKit::WebHistoryItem::originalURLString): + (WebKit::WebHistoryItem::setOriginalURLString): + (WebKit::WebHistoryItem::referrer): + (WebKit::WebHistoryItem::setReferrer): + (WebKit::WebHistoryItem::target): + (WebKit::WebHistoryItem::setTarget): + (WebKit::WebHistoryItem::parent): + (WebKit::WebHistoryItem::setParent): + (WebKit::WebHistoryItem::title): + (WebKit::WebHistoryItem::setTitle): + (WebKit::WebHistoryItem::alternateTitle): + (WebKit::WebHistoryItem::setAlternateTitle): + (WebKit::WebHistoryItem::lastVisitedTime): + (WebKit::WebHistoryItem::setLastVisitedTime): + (WebKit::WebHistoryItem::scrollOffset): + (WebKit::WebHistoryItem::setScrollOffset): + (WebKit::WebHistoryItem::isTargetItem): + (WebKit::WebHistoryItem::setIsTargetItem): + (WebKit::WebHistoryItem::visitCount): + (WebKit::WebHistoryItem::setVisitCount): + (WebKit::WebHistoryItem::documentState): + (WebKit::WebHistoryItem::setDocumentState): + (WebKit::WebHistoryItem::httpContentType): + (WebKit::WebHistoryItem::setHTTPContentType): + (WebKit::WebHistoryItem::httpBody): + (WebKit::WebHistoryItem::setHTTPBody): + (WebKit::WebHistoryItem::children): + (WebKit::WebHistoryItem::setChildren): + (WebKit::WebHistoryItem::appendToChildren): + (WebKit::WebHistoryItem::WebHistoryItem): + (WebKit::WebHistoryItem::operator=): + (WebKit::WebHistoryItem::operator PassRefPtr<HistoryItem>): + (WebKit::WebHistoryItem::ensureMutable): + * src/WebImageCG.cpp: Added. + (WebKit::WebImage::fromData): + (WebKit::WebImage::reset): + (WebKit::WebImage::assign): + (WebKit::WebImage::isNull): + (WebKit::WebImage::size): + (WebKit::WebImage::WebImage): + (WebKit::WebImage::operator=): + * src/WebImageSkia.cpp: Added. + (WebKit::WebImage::fromData): + (WebKit::WebImage::reset): + (WebKit::WebImage::assign): + (WebKit::WebImage::isNull): + (WebKit::WebImage::size): + (WebKit::WebImage::WebImage): + (WebKit::WebImage::operator=): + +2009-11-09 Yaar Schnitman <yaar@chromium.src> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebData...WebElement + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebData.cpp: Added. + (WebKit::WebData::reset): + (WebKit::WebData::assign): + (WebKit::WebData::size): + (WebKit::WebData::data): + (WebKit::WebData::WebData): + (WebKit::WebData::operator=): + (WebKit::WebData::operator PassRefPtr<SharedBuffer>): + * src/WebDataSourceImpl.cpp: Added. + (WebKit::WebDataSourceImpl::create): + (WebKit::WebDataSourceImpl::originalRequest): + (WebKit::WebDataSourceImpl::request): + (WebKit::WebDataSourceImpl::response): + (WebKit::WebDataSourceImpl::hasUnreachableURL): + (WebKit::WebDataSourceImpl::unreachableURL): + (WebKit::WebDataSourceImpl::redirectChain): + (WebKit::WebDataSourceImpl::pageTitle): + (WebKit::WebDataSourceImpl::navigationType): + (WebKit::WebDataSourceImpl::triggeringEventTime): + (WebKit::WebDataSourceImpl::extraData): + (WebKit::WebDataSourceImpl::setExtraData): + (WebKit::WebDataSourceImpl::toWebNavigationType): + (WebKit::WebDataSourceImpl::endOfRedirectChain): + (WebKit::WebDataSourceImpl::clearRedirectChain): + (WebKit::WebDataSourceImpl::appendRedirect): + (WebKit::WebDataSourceImpl::setNextPluginLoadObserver): + (WebKit::WebDataSourceImpl::WebDataSourceImpl): + (WebKit::WebDataSourceImpl::~WebDataSourceImpl): + * src/WebDataSourceImpl.h: Added. + (WebKit::WebDataSourceImpl::fromDocumentLoader): + (WebKit::WebDataSourceImpl::hasRedirectChain): + (WebKit::WebDataSourceImpl::releasePluginLoadObserver): + * src/WebDatabase.cpp: Added. + (WebKit::WebDatabase::reset): + (WebKit::WebDatabase::assign): + (WebKit::WebDatabase::name): + (WebKit::WebDatabase::displayName): + (WebKit::WebDatabase::estimatedSize): + (WebKit::WebDatabase::securityOrigin): + (WebKit::WebDatabase::setObserver): + (WebKit::WebDatabase::observer): + (WebKit::WebDatabase::updateDatabaseSize): + (WebKit::WebDatabase::WebDatabase): + (WebKit::WebDatabase::operator=): + (WebKit::WebDatabase::operator WTF::PassRefPtr<Database>): + * src/WebDevToolsAgentPrivate.h: Added. + * src/WebDragData.cpp: Added. + (WebKit::WebDragData::initialize): + (WebKit::WebDragData::reset): + (WebKit::WebDragData::assign): + (WebKit::WebDragData::url): + (WebKit::WebDragData::setURL): + (WebKit::WebDragData::urlTitle): + (WebKit::WebDragData::setURLTitle): + (WebKit::WebDragData::fileExtension): + (WebKit::WebDragData::setFileExtension): + (WebKit::WebDragData::hasFileNames): + (WebKit::WebDragData::fileNames): + (WebKit::WebDragData::setFileNames): + (WebKit::WebDragData::appendToFileNames): + (WebKit::WebDragData::plainText): + (WebKit::WebDragData::setPlainText): + (WebKit::WebDragData::htmlText): + (WebKit::WebDragData::setHTMLText): + (WebKit::WebDragData::htmlBaseURL): + (WebKit::WebDragData::setHTMLBaseURL): + (WebKit::WebDragData::fileContentFileName): + (WebKit::WebDragData::setFileContentFileName): + (WebKit::WebDragData::fileContent): + (WebKit::WebDragData::setFileContent): + (WebKit::WebDragData::WebDragData): + (WebKit::WebDragData::operator=): + (WebKit::WebDragData::operator WTF::PassRefPtr<WebCore::ChromiumDataObject>): + (WebKit::WebDragData::ensureMutable): + * src/WebElement.cpp: Added. + (WebKit::WebElement::WebElement): + (WebKit::WebElement::operator=): + (WebKit::WebElement::operator WTF::PassRefPtr<Element>): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + WebPo*.h and WebRunetimeFeatures.h Chromium API headers. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebPoint.h: Added. + (WebKit::WebPoint::WebPoint): + (WebKit::WebPoint::operator=): + (WebKit::WebPoint::operator WebCore::IntPoint): + (WebKit::WebPoint::operator gfx::Point): + (WebKit::operator==): + (WebKit::operator!=): + * public/WebPopupMenu.h: Added. + * public/WebPopupMenuInfo.h: Added. + (WebKit::WebPopupMenuInfo::Item::): + * public/WebRuntimeFeatures.h: Added. + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + WebPa*.h and WebPl*.h Chromium API headers. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebPasswordAutocompleteListener.h: Added. + (WebKit::WebPasswordAutocompleteListener::~WebPasswordAutocompleteListener): + * public/WebPasswordFormData.h: Added. + (WebKit::WebPasswordFormData::isValid): + * public/WebPlugin.h: Added. + (WebKit::WebPlugin::~WebPlugin): + * public/WebPluginContainer.h: Added. + (WebKit::WebPluginContainer::~WebPluginContainer): + * public/WebPluginListBuilder.h: Added. + * public/WebPluginParams.h: Added. + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebBindging ... WebCursorInfo + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebBindings.cpp: Added. + (WebKit::WebBindings::construct): + (WebKit::WebBindings::createObject): + (WebKit::WebBindings::enumerate): + (WebKit::WebBindings::evaluate): + (WebKit::WebBindings::evaluateHelper): + (WebKit::WebBindings::getIntIdentifier): + (WebKit::WebBindings::getProperty): + (WebKit::WebBindings::getStringIdentifier): + (WebKit::WebBindings::getStringIdentifiers): + (WebKit::WebBindings::hasMethod): + (WebKit::WebBindings::hasProperty): + (WebKit::WebBindings::identifierIsString): + (WebKit::WebBindings::intFromIdentifier): + (WebKit::WebBindings::initializeVariantWithStringCopy): + (WebKit::WebBindings::invoke): + (WebKit::WebBindings::invokeDefault): + (WebKit::WebBindings::releaseObject): + (WebKit::WebBindings::releaseVariantValue): + (WebKit::WebBindings::removeProperty): + (WebKit::WebBindings::retainObject): + (WebKit::WebBindings::setException): + (WebKit::WebBindings::setProperty): + (WebKit::WebBindings::unregisterObject): + (WebKit::WebBindings::utf8FromIdentifier): + (WebKit::WebBindings::extractIdentifierData): + (WebKit::getEvent): + (WebKit::getDragDataImpl): + (WebKit::getRangeImpl): + (WebKit::WebBindings::getDragData): + (WebKit::WebBindings::isDragEvent): + (WebKit::WebBindings::getRange): + * src/WebCString.cpp: Added. + (WebKit::WebCString::reset): + (WebKit::WebCString::assign): + (WebKit::WebCString::length): + (WebKit::WebCString::data): + (WebKit::WebCString::utf16): + (WebKit::WebCString::fromUTF16): + (WebKit::WebCString::WebCString): + (WebKit::WebCString::operator=): + (WebKit::WebCString::operator WebCore::CString): + * src/WebCache.cpp: Added. + (WebKit::ToResourceTypeStat): + (WebKit::WebCache::setCapacities): + (WebKit::WebCache::clear): + (WebKit::WebCache::getUsageStats): + (WebKit::WebCache::getResourceTypeStats): + * src/WebColor.cpp: Added. + (WebKit::toCSSValueKeyword): + (WebKit::setNamedColors): + * src/WebCrossOriginPreflightResultCache.cpp: Added. + (WebKit::WebCrossOriginPreflightResultCache::clear): + * src/WebCursorInfo.cpp: Added. + (WebKit::WebCursorInfo::WebCursorInfo): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Up-streaming Chromium API src files: WebAccessibilty + + https://bugs.webkit.org/show_bug.cgi?id=31276 + + * src/WebAccessibilityCache.cpp: Added. + (WebKit::WebAccessibilityCache::enableAccessibility): + * src/WebAccessibilityCacheImpl.cpp: Added. + (WebKit::toAccessibilityObject): + (WebKit::WebAccessibilityCache::create): + (WebKit::WebAccessibilityCacheImpl::WeakHandle::create): + (WebKit::WebAccessibilityCacheImpl::WeakHandle::WeakHandle): + (WebKit::WebAccessibilityCacheImpl::WeakHandle::detach): + (WebKit::WebAccessibilityCacheImpl::WebAccessibilityCacheImpl): + (WebKit::WebAccessibilityCacheImpl::~WebAccessibilityCacheImpl): + (WebKit::WebAccessibilityCacheImpl::initialize): + (WebKit::WebAccessibilityCacheImpl::getObjectById): + (WebKit::WebAccessibilityCacheImpl::isValidId): + (WebKit::WebAccessibilityCacheImpl::remove): + (WebKit::WebAccessibilityCacheImpl::clear): + (WebKit::WebAccessibilityCacheImpl::addOrGetId): + * src/WebAccessibilityCacheImpl.h: Added. + (WebKit::WebAccessibilityCacheImpl::isInitialized): + * src/WebAccessibilityObject.cpp: Added. + (WebKit::WebAccessibilityObject::reset): + (WebKit::WebAccessibilityObject::assign): + (WebKit::WebAccessibilityObject::accessibilityDescription): + (WebKit::WebAccessibilityObject::actionVerb): + (WebKit::WebAccessibilityObject::canSetFocusAttribute): + (WebKit::WebAccessibilityObject::childCount): + (WebKit::WebAccessibilityObject::childAt): + (WebKit::WebAccessibilityObject::firstChild): + (WebKit::WebAccessibilityObject::focusedChild): + (WebKit::WebAccessibilityObject::lastChild): + (WebKit::WebAccessibilityObject::nextSibling): + (WebKit::WebAccessibilityObject::parentObject): + (WebKit::WebAccessibilityObject::previousSibling): + (WebKit::WebAccessibilityObject::isAnchor): + (WebKit::WebAccessibilityObject::isChecked): + (WebKit::WebAccessibilityObject::isFocused): + (WebKit::WebAccessibilityObject::isEnabled): + (WebKit::WebAccessibilityObject::isHovered): + (WebKit::WebAccessibilityObject::isIndeterminate): + (WebKit::WebAccessibilityObject::isMultiSelect): + (WebKit::WebAccessibilityObject::isOffScreen): + (WebKit::WebAccessibilityObject::isPasswordField): + (WebKit::WebAccessibilityObject::isPressed): + (WebKit::WebAccessibilityObject::isReadOnly): + (WebKit::WebAccessibilityObject::isVisited): + (WebKit::WebAccessibilityObject::boundingBoxRect): + (WebKit::WebAccessibilityObject::helpText): + (WebKit::WebAccessibilityObject::hitTest): + (WebKit::WebAccessibilityObject::keyboardShortcut): + (WebKit::WebAccessibilityObject::performDefaultAction): + (WebKit::WebAccessibilityObject::roleValue): + (WebKit::WebAccessibilityObject::stringValue): + (WebKit::WebAccessibilityObject::title): + (WebKit::WebAccessibilityObject::WebAccessibilityObject): + (WebKit::WebAccessibilityObject::operator=): + (WebKit::WebAccessibilityObject::operator WTF::PassRefPtr<WebCore::AccessibilityObject>): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstreaming Chromium API: Platform specific files + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/gtk/WebFontInfo.h: Added. + * public/gtk/WebInputEventFactory.h: Added. + * public/gtk/WebScreenInfoFactory.h: Added. + * public/linux/WebFontRendering.h: Added. + * public/linux/WebSandboxSupport.h: Added. + * public/mac/WebInputEventFactory.h: Added. + * public/mac/WebScreenInfoFactory.h: Added. + * public/win/WebInputEventFactory.h: Added. + * public/win/WebSandboxSupport.h: Added. + * public/win/WebScreenInfoFactory.h: Added. + * public/win/WebThemeEngine.h: Added. + * public/x11/WebScreenInfoFactory.h: Added. + +2009-11-09 David Levin <levin@chromium.org> + + Reviewed by Dmitry Titov. + + Change struct ResourceRequest to class ResourceRequest per + http://trac.webkit.org/changeset/50625. + + * public/WebURLRequest.h: + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstream remaining Chromium API WebN*.h headers. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebNonCopyable.h: Added. + (WebKit::WebNonCopyable::WebNonCopyable): + (WebKit::WebNonCopyable::~WebNonCopyable): + * public/WebNotification.h: Added. + (WebKit::WebNotification::WebNotification): + (WebKit::WebNotification::~WebNotification): + (WebKit::WebNotification::operator=): + (WebKit::WebNotification::equals): + (WebKit::operator==): + (WebKit::operator!=): + (WebKit::operator<): + * public/WebNotificationPermissionCallback.h: Added. + (WebKit::WebNotificationPermissionCallback::~WebNotificationPermissionCallback): + * public/WebNotificationPresenter.h: Added. + (WebKit::WebNotificationPresenter::): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstream Chromium API headers WebMessage through WebNavigation. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebMessagePortChannel.h: Added. + (WebKit::WebMessagePortChannel::~WebMessagePortChannel): + * public/WebMessagePortChannelClient.h: Added. + (WebKit::WebMessagePortChannelClient::~WebMessagePortChannelClient): + * public/WebMimeRegistry.h: Added. + (WebKit::WebMimeRegistry::): + (WebKit::WebMimeRegistry::~WebMimeRegistry): + * public/WebNavigationPolicy.h: Added. + (WebKit::): + * public/WebNavigationType.h: Added. + (WebKit::): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstreaming the Chromium WebKit API: WebScreenInfo to WebSharedWorkerRepo. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebScreenInfo.h: Added. + (WebKit::WebScreenInfo::WebScreenInfo): + * public/WebScriptController.h: Added. + * public/WebScriptSource.h: Added. + (WebKit::WebScriptSource::WebScriptSource): + * public/WebSearchableFormData.h: Added. + (WebKit::WebSearchableFormData::isValid): + (WebKit::WebSearchableFormData::url): + (WebKit::WebSearchableFormData::encoding): + * public/WebSecurityOrigin.h: Added. + (WebKit::WebSecurityOrigin::~WebSecurityOrigin): + (WebKit::WebSecurityOrigin::WebSecurityOrigin): + (WebKit::WebSecurityOrigin::operator=): + (WebKit::WebSecurityOrigin::isNull): + * public/WebSecurityPolicy.h: Added. + * public/WebSettings.h: Added. + (WebKit::WebSettings::~WebSettings): + * public/WebSharedWorker.h: Added. + (WebKit::WebSharedWorker::~WebSharedWorker): + * public/WebSharedWorkerRepository.h: Added. + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstream Chromium API headers Webkit.h thru WebMediaPlayerClient.h. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebKit.h: Added. + * public/WebKitClient.h: Added. + (WebKit::WebKitClient::~WebKitClient): + * public/WebLocalizedString.h: Added. + (WebKit::WebLocalizedString::): + * public/WebMediaPlayer.h: Added. + (WebKit::WebTimeRange::WebTimeRange): + (WebKit::WebMediaPlayer::): + (WebKit::WebMediaPlayer::~WebMediaPlayer): + * public/WebMediaPlayerAction.h: Added. + (WebKit::WebMediaPlayerAction::): + (WebKit::WebMediaPlayerAction::WebMediaPlayerAction): + * public/WebMediaPlayerClient.h: Added. + (WebKit::WebMediaPlayerClient::~WebMediaPlayerClient): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstream rest of WebH*.h and WebI*.h Chromium API headers. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebHTTPBody.h: Added. + (WebKit::WebHTTPBody::Element::): + (WebKit::WebHTTPBody::~WebHTTPBody): + (WebKit::WebHTTPBody::WebHTTPBody): + (WebKit::WebHTTPBody::operator=): + (WebKit::WebHTTPBody::isNull): + * public/WebHTTPHeaderVisitor.h: Added. + (WebKit::WebHTTPHeaderVisitor::~WebHTTPHeaderVisitor): + * public/WebHistoryItem.h: Added. + (WebKit::WebHistoryItem::~WebHistoryItem): + (WebKit::WebHistoryItem::WebHistoryItem): + (WebKit::WebHistoryItem::operator=): + (WebKit::WebHistoryItem::isNull): + * public/WebImage.h: Added. + (WebKit::WebImage::~WebImage): + (WebKit::WebImage::WebImage): + (WebKit::WebImage::operator=): + (WebKit::WebImage::getSkBitmap): + (WebKit::WebImage::init): + (WebKit::WebImage::getCGImageRef): + * public/WebInputEvent.h: Added. + (WebKit::WebInputEvent::WebInputEvent): + (WebKit::WebInputEvent::): + (WebKit::WebInputEvent::isKeyboardEventType): + (WebKit::WebKeyboardEvent::WebKeyboardEvent): + (WebKit::WebMouseEvent::): + (WebKit::WebMouseEvent::WebMouseEvent): + (WebKit::WebMouseWheelEvent::WebMouseWheelEvent): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Eric Seidel. + + Upstreaming the Chromium WebKit API: WebSockets and WebStorage. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebSocketStreamError.h: Added. + * public/WebSocketStreamHandle.h: Added. + (WebKit::WebSocketStreamHandle::~WebSocketStreamHandle): + * public/WebSocketStreamHandleClient.h: Added. + * public/WebStorageArea.h: Added. + (WebKit::WebStorageArea::~WebStorageArea): + * public/WebStorageEventDispatcher.h: Added. + (WebKit::WebStorageEventDispatcher::~WebStorageEventDispatcher): + * public/WebStorageNamespace.h: Added. + (WebKit::WebStorageNamespace::~WebStorageNamespace): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstreaming the Chromium WebKit API: WebString and other basic objects. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebRange.h: Added. + (WebKit::WebRange::~WebRange): + (WebKit::WebRange::WebRange): + (WebKit::WebRange::operator=): + (WebKit::WebRange::isNull): + * public/WebRect.h: Added. + (WebKit::WebRect::isEmpty): + (WebKit::WebRect::WebRect): + (WebKit::WebRect::operator=): + (WebKit::WebRect::operator WebCore::IntRect): + (WebKit::WebRect::operator gfx::Rect): + (WebKit::operator==): + (WebKit::operator!=): + * public/WebSize.h: Added. + (WebKit::WebSize::isEmpty): + (WebKit::WebSize::WebSize): + (WebKit::WebSize::operator=): + (WebKit::WebSize::operator WebCore::IntSize): + (WebKit::WebSize::operator gfx::Size): + (WebKit::operator==): + (WebKit::operator!=): + * public/WebString.h: Added. + (WebKit::WebString::~WebString): + (WebKit::WebString::WebString): + (WebKit::WebString::operator=): + (WebKit::WebString::isEmpty): + (WebKit::WebString::isNull): + (WebKit::WebString::operator string16): + (WebKit::WebString::operator NullableString16): + (WebKit::WebString::fromUTF8): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Eric Seidel. + + Upstreaming the Chromium WebKit API: WebText* + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebTextAffinity.h: Added. + (WebKit::): + * public/WebTextDirection.h: Added. + (WebKit::): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstream remainder of WebE*.h and WebF*.h Chromium API headers. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebEditingAction.h: Added. + (WebKit::): + * public/WebFileChooserCompletion.h: Added. + (WebKit::WebFileChooserCompletion::~WebFileChooserCompletion): + * public/WebFindOptions.h: Added. + (WebKit::WebFindOptions::WebFindOptions): + * public/WebFontCache.h: Added. + * public/WebFrame.h: Added. + (WebKit::WebFrame::~WebFrame): + * public/WebFrameClient.h: Added. + (WebKit::WebFrameClient::createPlugin): + (WebKit::WebFrameClient::createWorker): + (WebKit::WebFrameClient::createSharedWorker): + (WebKit::WebFrameClient::createMediaPlayer): + (WebKit::WebFrameClient::willClose): + (WebKit::WebFrameClient::loadURLExternally): + (WebKit::WebFrameClient::decidePolicyForNavigation): + (WebKit::WebFrameClient::canHandleRequest): + (WebKit::WebFrameClient::cannotHandleRequestError): + (WebKit::WebFrameClient::cancelledError): + (WebKit::WebFrameClient::unableToImplementPolicyWithError): + (WebKit::WebFrameClient::willSubmitForm): + (WebKit::WebFrameClient::willPerformClientRedirect): + (WebKit::WebFrameClient::didCancelClientRedirect): + (WebKit::WebFrameClient::didCompleteClientRedirect): + (WebKit::WebFrameClient::didCreateDataSource): + (WebKit::WebFrameClient::didStartProvisionalLoad): + (WebKit::WebFrameClient::didReceiveServerRedirectForProvisionalLoad): + (WebKit::WebFrameClient::didFailProvisionalLoad): + (WebKit::WebFrameClient::didReceiveDocumentData): + (WebKit::WebFrameClient::didCommitProvisionalLoad): + (WebKit::WebFrameClient::didClearWindowObject): + (WebKit::WebFrameClient::didCreateDocumentElement): + (WebKit::WebFrameClient::didReceiveTitle): + (WebKit::WebFrameClient::didFinishDocumentLoad): + (WebKit::WebFrameClient::didHandleOnloadEvents): + (WebKit::WebFrameClient::didFailLoad): + (WebKit::WebFrameClient::didFinishLoad): + (WebKit::WebFrameClient::didChangeLocationWithinPage): + (WebKit::WebFrameClient::didUpdateCurrentHistoryItem): + (WebKit::WebFrameClient::assignIdentifierToRequest): + (WebKit::WebFrameClient::willSendRequest): + (WebKit::WebFrameClient::didReceiveResponse): + (WebKit::WebFrameClient::didFinishResourceLoad): + (WebKit::WebFrameClient::didFailResourceLoad): + (WebKit::WebFrameClient::didLoadResourceFromMemoryCache): + (WebKit::WebFrameClient::didDisplayInsecureContent): + (WebKit::WebFrameClient::didRunInsecureContent): + (WebKit::WebFrameClient::allowScript): + (WebKit::WebFrameClient::didExhaustMemoryAvailableForScript): + (WebKit::WebFrameClient::didCreateScriptContext): + (WebKit::WebFrameClient::didDestroyScriptContext): + (WebKit::WebFrameClient::didCreateIsolatedScriptContext): + (WebKit::WebFrameClient::didChangeContentsSize): + (WebKit::WebFrameClient::didChangeScrollOffset): + (WebKit::WebFrameClient::reportFindInPageMatchCount): + (WebKit::WebFrameClient::reportFindInPageSelection): + (WebKit::WebFrameClient::~WebFrameClient): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstream WebDevTools*.h and WebDrag*.h Chromium API headers. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebDevToolsAgent.h: Added. + (WebKit::WebDevToolsAgent::~WebDevToolsAgent): + * public/WebDevToolsAgentClient.h: Added. + (WebKit::WebDevToolsAgentClient::~WebDevToolsAgentClient): + * public/WebDevToolsFrontend.h: Added. + (WebKit::WebDevToolsFrontend::~WebDevToolsFrontend): + * public/WebDevToolsFrontendClient.h: Added. + (WebKit::WebDevToolsFrontendClient::WebDevToolsFrontendClient): + (WebKit::WebDevToolsFrontendClient::~WebDevToolsFrontendClient): + * public/WebDragData.h: Added. + (WebKit::WebDragData::~WebDragData): + (WebKit::WebDragData::WebDragData): + (WebKit::WebDragData::operator=): + (WebKit::WebDragData::isNull): + * public/WebDragOperation.h: Added. + (WebKit::): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstreaming the Chromium WebKit API: WebURL and friends. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebURL.h: Added. + (WebKit::WebURL::~WebURL): + (WebKit::WebURL::WebURL): + (WebKit::WebURL::operator=): + (WebKit::WebURL::assign): + (WebKit::WebURL::spec): + (WebKit::WebURL::parsed): + (WebKit::WebURL::isValid): + (WebKit::WebURL::isEmpty): + (WebKit::WebURL::isNull): + (WebKit::WebURL::operator GURL): + * public/WebURLError.h: Added. + (WebKit::WebURLError::WebURLError): + * public/WebURLLoader.h: Added. + (WebKit::WebURLLoader::~WebURLLoader): + * public/WebURLLoaderClient.h: Added. + (WebKit::WebURLLoaderClient::~WebURLLoaderClient): + * public/WebURLRequest.h: Added. + (WebKit::WebURLRequest::): + (WebKit::WebURLRequest::~WebURLRequest): + (WebKit::WebURLRequest::WebURLRequest): + (WebKit::WebURLRequest::operator=): + * public/WebURLResponse.h: Added. + (WebKit::WebURLResponse::~WebURLResponse): + (WebKit::WebURLResponse::WebURLResponse): + (WebKit::WebURLResponse::operator=): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstreaming the Chromium WebKit API: WebVector to WebWorkerClient + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebVector.h: Added. + (WebKit::WebVector::~WebVector): + (WebKit::WebVector::WebVector): + (WebKit::WebVector::operator=): + (WebKit::WebVector::assign): + (WebKit::WebVector::size): + (WebKit::WebVector::isEmpty): + (WebKit::WebVector::operator[]): + (WebKit::WebVector::data): + (WebKit::WebVector::swap): + (WebKit::WebVector::initialize): + (WebKit::WebVector::initializeFrom): + (WebKit::WebVector::destroy): + * public/WebView.h: Added. + (WebKit::WebView::~WebView): + * public/WebViewClient.h: Added. + (WebKit::WebViewClient::createView): + (WebKit::WebViewClient::createPopupMenu): + (WebKit::WebViewClient::didAddMessageToConsole): + (WebKit::WebViewClient::printPage): + (WebKit::WebViewClient::notificationPresenter): + (WebKit::WebViewClient::didStartLoading): + (WebKit::WebViewClient::didStopLoading): + (WebKit::WebViewClient::shouldBeginEditing): + (WebKit::WebViewClient::shouldEndEditing): + (WebKit::WebViewClient::shouldInsertNode): + (WebKit::WebViewClient::shouldInsertText): + (WebKit::WebViewClient::shouldChangeSelectedRange): + (WebKit::WebViewClient::shouldDeleteRange): + (WebKit::WebViewClient::shouldApplyStyle): + (WebKit::WebViewClient::isSmartInsertDeleteEnabled): + (WebKit::WebViewClient::isSelectTrailingWhitespaceEnabled): + (WebKit::WebViewClient::setInputMethodEnabled): + (WebKit::WebViewClient::didBeginEditing): + (WebKit::WebViewClient::didChangeSelection): + (WebKit::WebViewClient::didChangeContents): + (WebKit::WebViewClient::didExecuteCommand): + (WebKit::WebViewClient::didEndEditing): + (WebKit::WebViewClient::handleCurrentKeyboardEvent): + (WebKit::WebViewClient::spellCheck): + (WebKit::WebViewClient::autoCorrectWord): + (WebKit::WebViewClient::showSpellingUI): + (WebKit::WebViewClient::isShowingSpellingUI): + (WebKit::WebViewClient::updateSpellingUIWithMisspelledWord): + (WebKit::WebViewClient::runFileChooser): + (WebKit::WebViewClient::runModalAlertDialog): + (WebKit::WebViewClient::runModalConfirmDialog): + (WebKit::WebViewClient::runModalPromptDialog): + (WebKit::WebViewClient::runModalBeforeUnloadDialog): + (WebKit::WebViewClient::setStatusText): + (WebKit::WebViewClient::setMouseOverURL): + (WebKit::WebViewClient::setKeyboardFocusURL): + (WebKit::WebViewClient::setToolTipText): + (WebKit::WebViewClient::showContextMenu): + (WebKit::WebViewClient::startDragging): + (WebKit::WebViewClient::acceptsLoadDrops): + (WebKit::WebViewClient::focusNext): + (WebKit::WebViewClient::focusPrevious): + (WebKit::WebViewClient::navigateBackForwardSoon): + (WebKit::WebViewClient::historyBackListCount): + (WebKit::WebViewClient::historyForwardListCount): + (WebKit::WebViewClient::didAddHistoryItem): + (WebKit::WebViewClient::focusAccessibilityObject): + (WebKit::WebViewClient::didUpdateInspectorSettings): + (WebKit::WebViewClient::queryAutofillSuggestions): + (WebKit::WebViewClient::removeAutofillSuggestions): + (WebKit::WebViewClient::~WebViewClient): + * public/WebWidget.h: Added. + (WebKit::WebWidget::~WebWidget): + * public/WebWidgetClient.h: Added. + (WebKit::WebWidgetClient::didInvalidateRect): + (WebKit::WebWidgetClient::didScrollRect): + (WebKit::WebWidgetClient::didFocus): + (WebKit::WebWidgetClient::didBlur): + (WebKit::WebWidgetClient::didChangeCursor): + (WebKit::WebWidgetClient::closeWidgetSoon): + (WebKit::WebWidgetClient::show): + (WebKit::WebWidgetClient::runModal): + (WebKit::WebWidgetClient::windowRect): + (WebKit::WebWidgetClient::setWindowRect): + (WebKit::WebWidgetClient::windowResizerRect): + (WebKit::WebWidgetClient::rootWindowRect): + (WebKit::WebWidgetClient::screenInfo): + (WebKit::WebWidgetClient::~WebWidgetClient): + * public/WebWorker.h: Added. + (WebKit::WebWorker::~WebWorker): + * public/WebWorkerClient.h: Added. + (WebKit::WebWorkerClient::~WebWorkerClient): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstream WebData*.h Chromium API files. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebData.h: Added. + (WebKit::WebData::~WebData): + (WebKit::WebData::WebData): + (WebKit::WebData::operator=): + (WebKit::WebData::isEmpty): + (WebKit::WebData::isNull): + * public/WebDataSource.h: Added. + (WebKit::WebDataSource::ExtraData::~ExtraData): + (WebKit::WebDataSource::~WebDataSource): + * public/WebDatabase.h: Added. + (WebKit::WebDatabase::WebDatabase): + (WebKit::WebDatabase::~WebDatabase): + (WebKit::WebDatabase::operator=): + (WebKit::WebDatabase::isNull): + * public/WebDatabaseObserver.h: Added. + (WebKit::WebDatabaseObserver::~WebDatabaseObserver): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstream the last of the Chromium API WebC*.h files. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebConsoleMessage.h: Added. + (WebKit::WebConsoleMessage::): + (WebKit::WebConsoleMessage::WebConsoleMessage): + * public/WebContextMenuData.h: Added. + (WebKit::WebContextMenuData::): + * public/WebCookie.h: Added. + (WebKit::WebCookie::WebCookie): + * public/WebCrossOriginPreflightResultCache.h: Added. + * public/WebCursorInfo.h: Added. + (WebKit::WebCursorInfo::): + (WebKit::WebCursorInfo::WebCursorInfo): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + More WebC*.h upstreaming. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebCString.h: Added. + (WebKit::WebCString::~WebCString): + (WebKit::WebCString::WebCString): + (WebKit::WebCString::operator=): + (WebKit::WebCString::isEmpty): + (WebKit::WebCString::isNull): + (WebKit::WebCString::operator std::string): + (WebKit::WebCString::fromUTF16): + * public/WebColorName.h: Added. + (WebKit::): + * public/WebCommon.h: Added. + * public/WebCommonWorkerClient.h: Added. + (WebKit::WebCommonWorkerClient::~WebCommonWorkerClient): + * public/WebCompositionCommand.h: Added. + (WebKit::): + +2009-11-09 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Dimitri Glazkov. + + Upstreaming the Chromium WebKit API: WebNode.h and friends are thin wrappers around WebCore::Nodes + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * public/WebElement.h: Added. + (WebKit::WebElement::WebElement): + (WebKit::WebElement::operator=): + (WebKit::WebElement::assign): + * public/WebFormElement.h: Added. + (WebKit::WebFormElement::~WebFormElement): + (WebKit::WebFormElement::WebFormElement): + (WebKit::WebFormElement::operator=): + (WebKit::WebFormElement::assign): + * public/WebInputElement.h: Added. + (WebKit::WebInputElement::WebInputElement): + (WebKit::WebInputElement::operator=): + (WebKit::WebInputElement::assign): + * public/WebNode.h: Added. + (WebKit::WebNode::~WebNode): + (WebKit::WebNode::WebNode): + (WebKit::WebNode::operator=): + (WebKit::WebNode::isNull): + (WebKit::WebNode::toElement): + (WebKit::WebNode::unwrap): + (WebKit::WebNode::constUnwrap): + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + WebKit Chromium API upstreaming, WebBindings.h through WebColor.h. + + * public/WebBindings.h: Added. + * public/WebCache.h: Added. + * public/WebCanvas.h: Added. + * public/WebClipboard.h: Added. + (WebKit::WebClipboard::): + (WebKit::WebClipboard::~WebClipboard): + * public/WebColor.h: Added. + +2009-11-09 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Starting upstreaming the Chromium WebKit API. public/ contains header files only. + + https://bugs.webkit.org/show_bug.cgi?id=28394 + + * ChangeLog: First!! + * public: Added. + * public/WebAccessibilityCache.h: Added. + (WebKit::WebAccessibilityCache::WebAccessibilityCache): + (WebKit::WebAccessibilityCache::~WebAccessibilityCache): + * public/WebAccessibilityObject.h: Added. + (WebKit::WebAccessibilityObject::~WebAccessibilityObject): + (WebKit::WebAccessibilityObject::WebAccessibilityObject): + (WebKit::WebAccessibilityObject::operator=): + (WebKit::WebAccessibilityObject::isNull): + * public/WebAccessibilityRole.h: Added. + (WebKit::): + * public/WebApplicationCacheHost.h: Added. + (WebKit::WebApplicationCacheHost::): + (WebKit::WebApplicationCacheHost::~WebApplicationCacheHost): + * public/WebApplicationCacheHostClient.h: Added. + (WebKit::WebApplicationCacheHostClient::~WebApplicationCacheHostClient): diff --git a/WebKit/chromium/DEPS b/WebKit/chromium/DEPS index 5f5b9b8..fc90187 100644 --- a/WebKit/chromium/DEPS +++ b/WebKit/chromium/DEPS @@ -35,18 +35,19 @@ vars = { 'chromium_deps_svn': 'http://src.chromium.org/svn/trunk/deps/third_party', # Dependencies' revisions to use: - 'chromium_rev': '28710', - 'google-url_rev': '119', - 'gtest_rev': '329', - 'gyp_rev': '685', - 'icu_rev': '27687', + 'chromium_rev': '31834', + 'google-url_rev': '120', + 'gtest_rev': '336', + 'gyp_rev': '751', + 'icu_rev': '31724', 'openvcdiff_rev': '28', - 'skia_rev': '376', - 'v8_rev': '3030', + 'ots_rev': '19', + 'skia_rev': '424', + 'v8_rev': '3276', # Windows: 'cygwin_rev': '11984', - 'ffmpeg_ia32_rev': '28488', + 'ffmpeg_ia32_rev': '30374', 'pthreads-win32_rev': '26716', 'python_24_rev': '22967', } @@ -55,8 +56,6 @@ deps = { # build tools 'build': Var('chromium_svn')+'/build@'+Var('chromium_rev'), - 'webkit/build': - Var('chromium_svn')+'/webkit/build@'+Var('chromium_rev'), 'tools/gyp': 'http://gyp.googlecode.com/svn/trunk@'+Var('gyp_rev'), @@ -120,6 +119,9 @@ deps = { 'third_party/npapi': Var('chromium_svn')+'/third_party/npapi@'+Var('chromium_rev'), + 'third_party/ots': + 'http://ots.googlecode.com/svn/trunk@'+Var('ots_rev'), + 'third_party/sqlite': Var('chromium_svn')+'/third_party/sqlite@'+Var('chromium_rev'), @@ -141,6 +143,14 @@ deps_os = { 'third_party/pthreads-win32': Var('chromium_deps_svn')+'/pthreads-win32@'+Var('pthreads-win32_rev'), }, + 'unix': { + # Linux, actually. + 'third_party/harfbuzz': + Var('chromium_svn')+'/third_party/harfbuzz@'+Var('chromium_rev'), + + 'tools/xdisplaycheck': + Var('chromium_svn')+'/tools/xdisplaycheck@'+Var('chromium_rev'), + }, } skip_child_includes = [ diff --git a/WebKit/chromium/README b/WebKit/chromium/README new file mode 100644 index 0000000..9173454 --- /dev/null +++ b/WebKit/chromium/README @@ -0,0 +1,41 @@ +This directory contains the Chromium WebKit API. + + +OVERVIEW + + The Chromium WebKit API provides a stable interface to WebCore without + revealing any of the WebCore or WTF types to the consumer. + + The 'public' directory contains the API headers, and the 'src' directory + contains the API implementation. The API is intended to be used either as a + shared or static library. + + +COMPATIBILITY + + No attempt is made to support runtime compatibility in a shared library + build. Instead, the API is intended to support backwards compatibility at + build time. C++ symbols are allowed in other words. + + +DEFINES + + WEBKIT_IMPLEMENTATION is defined when building the 'src' directory. + Consumers should not define this macro. + + WEBKIT_DLL is defined when building as a shared library. This should be + defined when building the 'src' directory, and it should also be defined by + the consumer to ensure proper linkage to the shared library. + + +BASIC TYPES + + Use of STL is prohibited except in cases where it would be allowed in + WebCore. This includes non-allocating uses: algorithms, numeric limits, etc. + WTF container classes should be used in the implementation of this API. + + The API includes some usage of WebCore types when WEBKIT_IMPLEMENTATION is + defined. This is only done for the convenience to the implementation, and + should not be considered part of the Chromium WebKit API. Similarly, STL + types are assumed when WEBKIT_IMPLEMENTATION is not defined, which is done + for the convenience of the consumer. diff --git a/WebKit/chromium/WebKit.gyp b/WebKit/chromium/WebKit.gyp new file mode 100644 index 0000000..c41bf5b --- /dev/null +++ b/WebKit/chromium/WebKit.gyp @@ -0,0 +1,403 @@ +# +# Copyright (C) 2009 Google Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +{ + 'includes': [ + 'features.gypi', + ], + 'variables': { + 'conditions': [ + # Location of the chromium src directory and target type is different + # if webkit is built inside chromium or as standalone project. + ['inside_chromium_build==0', { + # Webkit is being built outside of the full chromium project. + # e.g. via build-webkit --chromium + 'chromium_src_dir': '.', + # FIXME: To enable shared_library in linux all code (including + # dependencies) must be complied with -fPIC flag. That is + # pending on changes in gyp. + 'webkit_target_type': 'shared_library', + },{ + # WebKit is checked out in src/chromium/third_party/WebKit + 'chromium_src_dir': '../../../..', + 'webkit_target_type': 'static_library', + }], + # We can't turn on warnings on Windows and Linux until we upstream the + # WebKit API. + ['OS=="mac"', { + 'chromium_code': 1, + }], + # FIXME: To enable shared_library in linux all code (including + # dependencies) must be complied with -fPIC flag. That is + # pending on changes in gyp. + ['OS=="linux" or OS=="freebsd"', { + 'webkit_target_type': 'static_library', + }], + ], + }, + 'targets': [ + { + 'target_name': 'webkit', + 'type': '<(webkit_target_type)', + 'msvs_guid': '5ECEC9E5-8F23-47B6-93E0-C3B328B3BE65', + 'dependencies': [ + '../../WebCore/WebCore.gyp/WebCore.gyp:webcore', + ], + 'include_dirs': [ + 'public', + 'src', + ], + 'defines': [ + 'WEBKIT_IMPLEMENTATION', + ], + 'sources': [ + 'public/gtk/WebInputEventFactory.h', + 'public/linux/WebFontRendering.h', + 'public/x11/WebScreenInfoFactory.h', + 'public/mac/WebInputEventFactory.h', + 'public/mac/WebScreenInfoFactory.h', + 'public/WebAccessibilityCache.h', + 'public/WebAccessibilityObject.h', + 'public/WebAccessibilityRole.h', + 'public/WebApplicationCacheHost.h', + 'public/WebApplicationCacheHostClient.h', + 'public/WebBindings.h', + 'public/WebCache.h', + 'public/WebCanvas.h', + 'public/WebClipboard.h', + 'public/WebColor.h', + 'public/WebColorName.h', + 'public/WebCommon.h', + 'public/WebCommonWorkerClient.h', + 'public/WebCompositionCommand.h', + 'public/WebConsoleMessage.h', + 'public/WebContextMenuData.h', + 'public/WebCookie.h', + 'public/WebCrossOriginPreflightResultCache.h', + 'public/WebCString.h', + 'public/WebCursorInfo.h', + 'public/WebData.h', + 'public/WebDatabase.h', + 'public/WebDatabaseObserver.h', + 'public/WebDataSource.h', + 'public/WebDevToolsAgent.h', + 'public/WebDevToolsAgentClient.h', + 'public/WebDevToolsFrontend.h', + 'public/WebDevToolsFrontendClient.h', + 'public/WebDevToolsMessageData.h', + 'public/WebDragData.h', + 'public/WebEditingAction.h', + 'public/WebElement.h', + 'public/WebFileChooserCompletion.h', + 'public/WebFindOptions.h', + 'public/WebFrame.h', + 'public/WebFrameClient.h', + 'public/WebFontCache.h', + 'public/WebFormElement.h', + 'public/WebHistoryItem.h', + 'public/WebHTTPBody.h', + 'public/WebImage.h', + 'public/WebInputElement.h', + 'public/WebInputEvent.h', + 'public/WebKit.h', + 'public/WebKitClient.h', + 'public/WebLocalizedString.h', + 'public/WebMediaPlayer.h', + 'public/WebMediaPlayerAction.h', + 'public/WebMediaPlayerClient.h', + 'public/WebMenuItemInfo.h', + 'public/WebMessagePortChannel.h', + 'public/WebMessagePortChannelClient.h', + 'public/WebMimeRegistry.h', + 'public/WebNavigationType.h', + 'public/WebNode.h', + 'public/WebNonCopyable.h', + 'public/WebNotification.h', + 'public/WebNotificationPresenter.h', + 'public/WebNotificationPermissionCallback.h', + 'public/WebPasswordAutocompleteListener.h', + 'public/WebPasswordFormData.h', + 'public/WebPlugin.h', + 'public/WebPluginContainer.h', + 'public/WebPluginListBuilder.h', + 'public/WebPoint.h', + 'public/WebPopupMenu.h', + 'public/WebPopupMenuInfo.h', + 'public/WebRange.h', + 'public/WebRect.h', + 'public/WebRegularExpression.h', + 'public/WebRuntimeFeatures.h', + 'public/WebScreenInfo.h', + 'public/WebScriptController.h', + 'public/WebScriptSource.h', + 'public/WebSearchableFormData.h', + 'public/WebSecurityOrigin.h', + 'public/WebSecurityPolicy.h', + 'public/WebSettings.h', + 'public/WebSharedWorker.h', + 'public/WebSharedWorkerRepository.h', + 'public/WebSize.h', + 'public/WebSocketStreamError.h', + 'public/WebSocketStreamHandle.h', + 'public/WebSocketStreamHandleClient.h', + 'public/WebStorageArea.h', + 'public/WebStorageEventDispatcher.h', + 'public/WebStorageNamespace.h', + 'public/WebString.h', + 'public/WebTextAffinity.h', + 'public/WebTextCaseSensitivity.h', + 'public/WebTextDirection.h', + 'public/WebURL.h', + 'public/WebURLError.h', + 'public/WebURLLoader.h', + 'public/WebURLLoaderClient.h', + 'public/WebURLRequest.h', + 'public/WebURLResponse.h', + 'public/WebVector.h', + 'public/WebView.h', + 'public/WebViewClient.h', + 'public/WebWidget.h', + 'public/WebWidgetClient.h', + 'public/WebWorker.h', + 'public/WebWorkerClient.h', + 'public/win/WebInputEventFactory.h', + 'public/win/WebSandboxSupport.h', + 'public/win/WebScreenInfoFactory.h', + 'public/win/WebScreenInfoFactory.h', + 'src/ApplicationCacheHost.cpp', + 'src/AssertMatchingEnums.cpp', + 'src/AutocompletePopupMenuClient.cpp', + 'src/AutocompletePopupMenuClient.h', + 'src/BackForwardListClientImpl.cpp', + 'src/BackForwardListClientImpl.h', + 'src/ChromeClientImpl.cpp', + 'src/ChromeClientImpl.h', + 'src/ChromiumBridge.cpp', + 'src/ChromiumCurrentTime.cpp', + 'src/ChromiumThreading.cpp', + 'src/ContextMenuClientImpl.cpp', + 'src/ContextMenuClientImpl.h', + 'src/DatabaseObserver.cpp', + 'src/DOMUtilitiesPrivate.cpp', + 'src/DOMUtilitiesPrivate.h', + 'src/DragClientImpl.cpp', + 'src/DragClientImpl.h', + 'src/EditorClientImpl.cpp', + 'src/EditorClientImpl.h', + 'src/FrameLoaderClientImpl.cpp', + 'src/FrameLoaderClientImpl.h', + 'src/gtk/WebFontInfo.cpp', + 'src/gtk/WebFontInfo.h', + 'src/gtk/WebInputEventFactory.cpp', + 'src/InspectorClientImpl.cpp', + 'src/InspectorClientImpl.h', + 'src/linux/WebFontRendering.cpp', + 'src/x11/WebScreenInfoFactory.cpp', + 'src/mac/WebInputEventFactory.mm', + 'src/mac/WebScreenInfoFactory.mm', + 'src/LocalizedStrings.cpp', + 'src/MediaPlayerPrivateChromium.cpp', + 'src/NotificationPresenterImpl.h', + 'src/NotificationPresenterImpl.cpp', + 'src/PlatformMessagePortChannel.cpp', + 'src/PlatformMessagePortChannel.h', + 'src/ResourceHandle.cpp', + 'src/SharedWorkerRepository.cpp', + 'src/SocketStreamHandle.cpp', + 'src/StorageAreaProxy.cpp', + 'src/StorageAreaProxy.h', + 'src/StorageEventDispatcherChromium.cpp', + 'src/StorageEventDispatcherImpl.cpp', + 'src/StorageEventDispatcherImpl.h', + 'src/StorageNamespaceProxy.cpp', + 'src/StorageNamespaceProxy.h', + 'src/TemporaryGlue.h', + 'src/WebAccessibilityCache.cpp', + 'src/WebAccessibilityCacheImpl.cpp', + 'src/WebAccessibilityCacheImpl.h', + 'src/WebAccessibilityObject.cpp', + 'src/WebBindings.cpp', + 'src/WebCache.cpp', + 'src/WebColor.cpp', + 'src/WebCrossOriginPreflightResultCache.cpp', + 'src/WebCString.cpp', + 'src/WebCursorInfo.cpp', + 'src/WebData.cpp', + 'src/WebDatabase.cpp', + 'src/WebDataSourceImpl.cpp', + 'src/WebDataSourceImpl.h', + 'src/WebDragData.cpp', + 'src/WebElement.cpp', + 'src/WebFileChooserCompletionImpl.cpp', + 'src/WebFileChooserCompletionImpl.h', + 'src/WebFontCache.cpp', + 'src/WebFormElement.cpp', + 'src/WebFrameImpl.cpp', + 'src/WebFrameImpl.h', + 'src/WebHistoryItem.cpp', + 'src/WebHTTPBody.cpp', + 'src/WebImageCG.cpp', + 'src/WebImageSkia.cpp', + 'src/WebInputElement.cpp', + 'src/WebInputEvent.cpp', + 'src/WebInputEventConversion.cpp', + 'src/WebInputEventConversion.h', + 'src/WebKit.cpp', + 'src/WebMediaPlayerClientImpl.cpp', + 'src/WebMediaPlayerClientImpl.h', + 'src/WebNode.cpp', + 'src/WebNotification.cpp', + 'src/WebPasswordFormData.cpp', + 'src/WebPasswordFormUtils.cpp', + 'src/WebPasswordFormUtils.h', + 'src/WebPluginContainerImpl.h', + 'src/WebPluginContainerImpl.cpp', + 'src/WebPluginListBuilderImpl.cpp', + 'src/WebPluginListBuilderImpl.h', + 'src/WebPluginLoadObserver.cpp', + 'src/WebPluginLoadObserver.h', + 'src/WebPopupMenuImpl.cpp', + 'src/WebPopupMenuImpl.h', + 'src/WebRange.cpp', + 'src/WebRegularExpression.cpp', + 'src/WebRuntimeFeatures.cpp', + 'src/WebScriptController.cpp', + 'src/WebSearchableFormData.cpp', + 'src/WebSecurityOrigin.cpp', + 'src/WebSecurityPolicy.cpp', + 'src/WebSettingsImpl.cpp', + 'src/WebSettingsImpl.h', + 'src/WebSharedWorkerImpl.cpp', + 'src/WebSharedWorkerImpl.h', + 'src/WebStorageAreaImpl.cpp', + 'src/WebStorageAreaImpl.h', + 'src/WebStorageEventDispatcherImpl.cpp', + 'src/WebStorageEventDispatcherImpl.h', + 'src/WebStorageNamespaceImpl.cpp', + 'src/WebStorageNamespaceImpl.h', + 'src/WebString.cpp', + 'src/WebURL.cpp', + 'src/WebURLRequest.cpp', + 'src/WebURLRequestPrivate.h', + 'src/WebURLResponse.cpp', + 'src/WebURLResponsePrivate.h', + 'src/WebURLError.cpp', + 'src/WebViewImpl.cpp', + 'src/WebViewImpl.h', + 'src/WebWorkerBase.cpp', + 'src/WebWorkerBase.h', + 'src/WebWorkerClientImpl.cpp', + 'src/WebWorkerClientImpl.h', + 'src/WebWorkerImpl.cpp', + 'src/WebWorkerImpl.h', + 'src/WrappedResourceRequest.h', + 'src/WrappedResourceResponse.h', + 'src/win/WebInputEventFactory.cpp', + 'src/win/WebScreenInfoFactory.cpp', + ], + 'conditions': [ + ['OS=="linux" or OS=="freebsd"', { + 'dependencies': [ + '<(chromium_src_dir)/build/linux/system.gyp:fontconfig', + '<(chromium_src_dir)/build/linux/system.gyp:gtk', + '<(chromium_src_dir)/build/linux/system.gyp:x11', + ], + 'include_dirs': [ + 'public/x11', + 'public/gtk', + 'public/linux', + ], + }, { # else: OS!="linux" and OS!="freebsd" + 'sources/': [ + ['exclude', '/gtk/'], + ['exclude', '/x11/'], + ['exclude', '/linux/'], + ], + }], + ['OS=="mac"', { + 'include_dirs': [ + 'public/mac', + ], + 'sources/': [ + ['exclude', 'Skia\\.cpp$'], + ], + }, { # else: OS!="mac" + 'sources/': [ + ['exclude', '/mac/'], + ['exclude', 'CG\\.cpp$'], + ], + }], + ['OS=="win"', { + 'include_dirs': [ + 'public/win', + ], + }, { # else: OS!="win" + 'sources/': [['exclude', '/win/']], + }], + ['"ENABLE_3D_CANVAS=1" in feature_defines', { + # Conditionally compile in GLEW and our GraphicsContext3D implementation. + 'sources+': [ + 'src/GraphicsContext3D.cpp', + '<(chromium_src_dir)/third_party/glew/src/glew.c' + ], + 'include_dirs+': [ + '<(chromium_src_dir)/third_party/glew/include' + ], + 'defines+': [ + 'GLEW_STATIC=1', + 'GLEW_NO_GLU=1', + ], + 'conditions': [ + ['OS=="win"', { + 'link_settings': { + 'libraries': [ + '-lopengl32.lib', + ], + }, + }], + ['OS=="mac"', { + 'link_settings': { + 'libraries': [ + '$(SDKROOT)/System/Library/Frameworks/OpenGL.framework', + ], + }, + }], + ], + }], + ], + }, + ], # targets +} + +# Local Variables: +# tab-width:2 +# indent-tabs-mode:nil +# End: +# vim: set expandtab tabstop=2 shiftwidth=2: diff --git a/WebKit/chromium/features.gypi b/WebKit/chromium/features.gypi index e3bc7d3..8dd0d0d 100644 --- a/WebKit/chromium/features.gypi +++ b/WebKit/chromium/features.gypi @@ -46,10 +46,12 @@ 'ENABLE_OFFLINE_WEB_APPLICATIONS=1', 'ENABLE_DASHBOARD_SUPPORT=0', 'ENABLE_DOM_STORAGE=1', + 'ENABLE_GEOLOCATION=1', 'ENABLE_JAVASCRIPT_DEBUGGER=0', 'ENABLE_JSC_MULTIPLE_THREADS=0', 'ENABLE_ICONDATABASE=0', 'ENABLE_NOTIFICATIONS=1', + 'ENABLE_OPENTYPE_SANITIZER=1', 'ENABLE_ORIENTATION_EVENTS=0', 'ENABLE_XSLT=1', 'ENABLE_XPATH=1', @@ -61,7 +63,7 @@ 'ENABLE_SVG_FOREIGN_OBJECT=1', 'ENABLE_SVG_FONTS=1', 'ENABLE_VIDEO=1', - 'ENABLE_WEB_SOCKETS=1', + 'ENABLE_WEB_SOCKETS=1', 'ENABLE_WORKERS=1', ], }, diff --git a/WebKit/chromium/gyp_webkit b/WebKit/chromium/gyp_webkit index 810af54..ef18239 100644 --- a/WebKit/chromium/gyp_webkit +++ b/WebKit/chromium/gyp_webkit @@ -32,6 +32,7 @@ import glob import os +import platform import shlex import sys @@ -76,6 +77,10 @@ if __name__ == '__main__': # Add includes. args.extend(['-I' + i for i in additional_include_files(args)]) + # On linux, we want gyp to output a makefile (default is scons). + if (platform.system() == 'Linux'): + args.extend(['-fmake']) + # Other command args: args.extend([ # gyp variable defines. @@ -87,7 +92,7 @@ if __name__ == '__main__': '--depth=./', # gyp file to execute. - 'webkit.gyp']) + 'WebKit.gyp']) print 'Updating webkit projects from gyp files...' sys.stdout.flush() diff --git a/WebKit/chromium/public/WebAccessibilityCache.h b/WebKit/chromium/public/WebAccessibilityCache.h new file mode 100644 index 0000000..94704a0 --- /dev/null +++ b/WebKit/chromium/public/WebAccessibilityCache.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebAccessibilityCache_h +#define WebAccessibilityCache_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebView; +class WebAccessibilityObject; + +class WebAccessibilityCache { +public: + WebAccessibilityCache() {} + virtual ~WebAccessibilityCache() {} + + static WebAccessibilityCache* create(); + static void enableAccessibility(); + + virtual void initialize(WebView* view) = 0; + virtual bool isInitialized() const = 0; + + virtual WebAccessibilityObject getObjectById(int) = 0; + virtual bool isValidId(int) const = 0; + virtual int addOrGetId(const WebAccessibilityObject& object) = 0; + + virtual void remove(int) = 0; + virtual void clear() = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebAccessibilityObject.h b/WebKit/chromium/public/WebAccessibilityObject.h new file mode 100644 index 0000000..d32c548 --- /dev/null +++ b/WebKit/chromium/public/WebAccessibilityObject.h @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebAccessibilityObject_h +#define WebAccessibilityObject_h + +#include "WebAccessibilityRole.h" +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class AccessibilityObject; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebAccessibilityObjectPrivate; +class WebString; +struct WebPoint; +struct WebRect; + +// A container for passing around a reference to AccessibilityObject. +class WebAccessibilityObject { +public: + ~WebAccessibilityObject() { reset(); } + + WebAccessibilityObject() : m_private(0) { } + WebAccessibilityObject(const WebAccessibilityObject& o) : m_private(0) { assign(o); } + WebAccessibilityObject& operator=(const WebAccessibilityObject& o) + { + assign(o); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebAccessibilityObject&); + + bool isNull() const { return !m_private; } + + WebString accessibilityDescription() const; + WebString actionVerb() const; + bool canSetFocusAttribute() const; + bool canSetValueAttribute() const; + + unsigned childCount() const; + + WebAccessibilityObject childAt(unsigned) const; + WebAccessibilityObject firstChild() const; + WebAccessibilityObject focusedChild() const; + WebAccessibilityObject lastChild() const; + WebAccessibilityObject nextSibling() const; + WebAccessibilityObject parentObject() const; + WebAccessibilityObject previousSibling() const; + + bool isAnchor() const; + bool isChecked() const; + bool isFocused() const; + bool isEnabled() const; + bool isHovered() const; + bool isIndeterminate() const; + bool isMultiSelect() const; + bool isOffScreen() const; + bool isPasswordField() const; + bool isPressed() const; + bool isReadOnly() const; + bool isVisited() const; + + WebRect boundingBoxRect() const; + WebString helpText() const; + WebAccessibilityObject hitTest(const WebPoint&) const; + WebString keyboardShortcut() const; + bool performDefaultAction() const; + WebAccessibilityRole roleValue() const; + WebString stringValue() const; + WebString title() const; + +#if WEBKIT_IMPLEMENTATION + WebAccessibilityObject(const WTF::PassRefPtr<WebCore::AccessibilityObject>&); + WebAccessibilityObject& operator=(const WTF::PassRefPtr<WebCore::AccessibilityObject>&); + operator WTF::PassRefPtr<WebCore::AccessibilityObject>() const; +#endif + +private: + void assign(WebAccessibilityObjectPrivate*); + WebAccessibilityObjectPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebAccessibilityRole.h b/WebKit/chromium/public/WebAccessibilityRole.h new file mode 100644 index 0000000..e836c56 --- /dev/null +++ b/WebKit/chromium/public/WebAccessibilityRole.h @@ -0,0 +1,139 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebAccessibilityRole_h +#define WebAccessibilityRole_h + +#include "WebCommon.h" + +namespace WebKit { + +// These values must match WebCore::AccessibilityRole values +enum WebAccessibilityRole { + WebAccessibilityRoleUnknown = 1, + WebAccessibilityRoleButton, + WebAccessibilityRoleRadioButton, + WebAccessibilityRoleCheckBox, + WebAccessibilityRoleSlider, + WebAccessibilityRoleTabGroup, + WebAccessibilityRoleTextField, + WebAccessibilityRoleStaticText, + WebAccessibilityRoleTextArea, + WebAccessibilityRoleScrollArea, + WebAccessibilityRolePopUpButton, + WebAccessibilityRoleMenuButton, + WebAccessibilityRoleTable, + WebAccessibilityRoleApplication, + WebAccessibilityRoleGroup, + WebAccessibilityRoleRadioGroup, + WebAccessibilityRoleList, + WebAccessibilityRoleScrollBar, + WebAccessibilityRoleValueIndicator, + WebAccessibilityRoleImage, + WebAccessibilityRoleMenuBar, + WebAccessibilityRoleMenu, + WebAccessibilityRoleMenuItem, + WebAccessibilityRoleColumn, + WebAccessibilityRoleRow, + WebAccessibilityRoleToolbar, + WebAccessibilityRoleBusyIndicator, + WebAccessibilityRoleProgressIndicator, + WebAccessibilityRoleWindow, + WebAccessibilityRoleDrawer, + WebAccessibilityRoleSystemWide, + WebAccessibilityRoleOutline, + WebAccessibilityRoleIncrementor, + WebAccessibilityRoleBrowser, + WebAccessibilityRoleComboBox, + WebAccessibilityRoleSplitGroup, + WebAccessibilityRoleSplitter, + WebAccessibilityRoleColorWell, + WebAccessibilityRoleGrowArea, + WebAccessibilityRoleSheet, + WebAccessibilityRoleHelpTag, + WebAccessibilityRoleMatte, + WebAccessibilityRoleRuler, + WebAccessibilityRoleRulerMarker, + WebAccessibilityRoleLink, + WebAccessibilityRoleDisclosureTriangle, + WebAccessibilityRoleGrid, + WebAccessibilityRoleCell, + WebAccessibilityRoleColumnHeader, + WebAccessibilityRoleRowHeader, + + WebAccessibilityRoleWebCoreLink, + WebAccessibilityRoleImageMapLink, + WebAccessibilityRoleImageMap, + WebAccessibilityRoleListMarker, + WebAccessibilityRoleWebArea, + WebAccessibilityRoleHeading, + WebAccessibilityRoleListBox, + WebAccessibilityRoleListBoxOption, + WebAccessibilityRoleTableHeaderContainer, + WebAccessibilityRoleDefinitionListTerm, + WebAccessibilityRoleDefinitionListDefinition, + WebAccessibilityRoleAnnotation, + WebAccessibilityRoleSliderThumb, + WebAccessibilityRoleIgnored, + WebAccessibilityRoleTab, + WebAccessibilityRoleTabList, + WebAccessibilityRoleTabPanel, + WebAccessibilityRoleTreeRole, + WebAccessibilityRoleTreeItemRole, + WebAccessibilityRoleDirectory, + + WebAccessibilityRoleLandmarkApplication, + WebAccessibilityRoleLandmarkBanner, + WebAccessibilityRoleLandmarkComplementary, + WebAccessibilityRoleLandmarkContentInfo, + WebAccessibilityRoleLandmarkMain, + WebAccessibilityRoleLandmarkNavigation, + WebAccessibilityRoleLandmarkSearch, + + WebAccessibilityRoleApplicationAlert, + WebAccessibilityRoleApplicationAlertDialog, + WebAccessibilityRoleApplicationDialog, + WebAccessibilityRoleApplicationLog, + WebAccessibilityRoleApplicationMarquee, + WebAccessibilityRoleApplicationStatus, + WebAccessibilityRoleApplicationTimer, + + WebAccessibilityRoleDocument, + WebAccessibilityRoleDocumentArticle, + WebAccessibilityRoleDocumentMath, + WebAccessibilityRoleDocumentNote, + WebAccessibilityRoleDocumentRegion, + + WebAccessibilityRoleUserInterfaceTooltip +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebApplicationCacheHost.h b/WebKit/chromium/public/WebApplicationCacheHost.h new file mode 100644 index 0000000..7c5dafe --- /dev/null +++ b/WebKit/chromium/public/WebApplicationCacheHost.h @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebApplicationCacheHost_h +#define WebApplicationCacheHost_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebApplicationCacheHostClient; +class WebURL; +class WebURLRequest; +class WebURLResponse; +struct WebURLError; + +// This interface is used by webkit to call out to the embedder. Webkit uses +// the WebKitClient::createApplicationCacheHost method to create instances, +// and calls delete when the instance is no longer needed. +class WebApplicationCacheHost { +public: + // These values must match WebCore::ApplicationCacheHost::Status values + enum Status { + Uncached, + Idle, + Checking, + Downloading, + UpdateReady, + Obsolete + }; + + // These values must match WebCore::ApplicationCacheHost::EventID values + enum EventID { + CheckingEvent, + ErrorEvent, + NoUpdateEvent, + DownloadingEvent, + ProgressEvent, + UpdateReadyEvent, + CachedEvent, + ObsoleteEvent + }; + + virtual ~WebApplicationCacheHost() { } + + // Called for every request made within the context. + virtual void willStartMainResourceRequest(WebURLRequest&) = 0; + virtual void willStartSubResourceRequest(WebURLRequest&) = 0; + + // One or the other selectCache methods is called after having parsed the <html> tag. + // The latter returns false if the current document has been identified as a "foreign" + // entry, in which case the frame navigation will be restarted by webkit. + virtual void selectCacheWithoutManifest() = 0; + virtual bool selectCacheWithManifest(const WebURL& manifestURL) = 0; + + // Called as the main resource is retrieved. + virtual void didReceiveResponseForMainResource(const WebURLResponse&) = 0; + virtual void didReceiveDataForMainResource(const char* data, int len) = 0; + virtual void didFinishLoadingMainResource(bool success) = 0; + + // Called on behalf of the scriptable interface. + virtual Status status() = 0; + virtual bool startUpdate() = 0; + virtual bool swapCache() = 0; +}; + +} // namespace WebKit + +#endif // WebApplicationCacheHost_h + diff --git a/WebKit/chromium/public/WebApplicationCacheHostClient.h b/WebKit/chromium/public/WebApplicationCacheHostClient.h new file mode 100644 index 0000000..4e830e3 --- /dev/null +++ b/WebKit/chromium/public/WebApplicationCacheHostClient.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebApplicationCacheHostClient_h +#define WebApplicationCacheHostClient_h + +#include "WebApplicationCacheHost.h" +#include "WebCommon.h" + +namespace WebKit { + +// This interface is used by the embedder to call into webkit. +class WebApplicationCacheHostClient { +public: + // Called to fire the event in the scriptable interface. + virtual void notifyEventListener(WebApplicationCacheHost::EventID) = 0; + +protected: + // Should not be deleted by the embedder. + virtual ~WebApplicationCacheHostClient() { } +}; + +} // namespace WebKit + +#endif // WebApplicationCacheHostClient_h + diff --git a/WebKit/chromium/public/WebBindings.h b/WebKit/chromium/public/WebBindings.h new file mode 100644 index 0000000..4e66a8f --- /dev/null +++ b/WebKit/chromium/public/WebBindings.h @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebBindings_h +#define WebBindings_h + +#include "WebCommon.h" +#include <bindings/npruntime.h> + +namespace WebKit { + +class WebDragData; +class WebRange; + +// A haphazard collection of functions for dealing with plugins. +class WebBindings { +public: + // NPN Functions ------------------------------------------------------ + // These are all defined in npruntime.h and are well documented. + + // NPN_Construct + WEBKIT_API static bool construct(NPP, NPObject*, const NPVariant* args, uint32_t argCount, NPVariant* result); + + // NPN_CreateObject + WEBKIT_API static NPObject* createObject(NPP, NPClass*); + + // NPN_Enumerate + WEBKIT_API static bool enumerate(NPP, NPObject*, NPIdentifier**, uint32_t* count); + + // NPN_Evaluate + WEBKIT_API static bool evaluate(NPP, NPObject*, NPString* script, NPVariant* result); + + // NPN_EvaluateHelper + WEBKIT_API static bool evaluateHelper(NPP, bool popupsAllowed, NPObject*, NPString* script, NPVariant* result); + + // NPN_GetIntIdentifier + WEBKIT_API static NPIdentifier getIntIdentifier(int32_t number); + + // NPN_GetProperty + WEBKIT_API static bool getProperty(NPP, NPObject*, NPIdentifier propertyName, NPVariant *result); + + // NPN_GetStringIdentifier + WEBKIT_API static NPIdentifier getStringIdentifier(const NPUTF8* string); + + // NPN_GetStringIdentifiers + WEBKIT_API static void getStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier*); + + // NPN_HasMethod + WEBKIT_API static bool hasMethod(NPP, NPObject*, NPIdentifier methodName); + + // NPN_HasProperty + WEBKIT_API static bool hasProperty(NPP, NPObject*, NPIdentifier propertyName); + + // NPN_IdentifierIsString + WEBKIT_API static bool identifierIsString(NPIdentifier); + + // NPN_InitializeVariantWithStringCopy (though sometimes prefixed with an underscore) + WEBKIT_API static void initializeVariantWithStringCopy(NPVariant*, const NPString*); + + // NPN_IntFromIdentifier + WEBKIT_API static int32_t intFromIdentifier(NPIdentifier); + + // NPN_Invoke + WEBKIT_API static bool invoke(NPP, NPObject*, NPIdentifier methodName, const NPVariant* args, uint32_t count, NPVariant* result); + + // NPN_InvokeDefault + WEBKIT_API static bool invokeDefault(NPP, NPObject*, const NPVariant* args, uint32_t count, NPVariant* result); + + // NPN_ReleaseObject + WEBKIT_API static void releaseObject(NPObject*); + + // NPN_ReleaseVariantValue + WEBKIT_API static void releaseVariantValue(NPVariant*); + + // NPN_RemoveProperty + WEBKIT_API static bool removeProperty(NPP, NPObject*, NPIdentifier); + + // NPN_RetainObject + WEBKIT_API static NPObject* retainObject(NPObject*); + + // NPN_SetException + WEBKIT_API static void setException(NPObject*, const NPUTF8* message); + + // NPN_SetProperty + WEBKIT_API static bool setProperty(NPP, NPObject*, NPIdentifier, const NPVariant*); + + // _NPN_UnregisterObject + WEBKIT_API static void unregisterObject(NPObject*); + + // NPN_UTF8FromIdentifier + WEBKIT_API static NPUTF8* utf8FromIdentifier(NPIdentifier); + + // Miscellaneous utility functions ------------------------------------ + + // Complement to NPN_Get___Identifier functions. Extracts data from the NPIdentifier data + // structure. If isString is true upon return, string will be set but number's value is + // undefined. If iString is false, the opposite is true. + WEBKIT_API static void extractIdentifierData(const NPIdentifier&, const NPUTF8*& string, int32_t& number, bool& isString); + + // Return true (success) if the given npobj is the current drag event in browser dispatch, + // and is accessible based on context execution frames and their security origins and + // WebKit clipboard access policy. If so, return the event id and the clipboard data (WebDragData). + // This only works with V8. If compiled without V8, it'll always return false. + WEBKIT_API static bool getDragData(NPObject* event, int* eventId, WebDragData*); + + // Invoke the event access policy checks listed above with GetDragData(). No need for clipboard + // data or event_id outputs, just confirm the given npobj is the current & accessible drag event. + // This only works with V8. If compiled without V8, it'll always return false. + WEBKIT_API static bool isDragEvent(NPObject* event); + + // Return true (success) if the given npobj is a range object. + // If so, return that range as a WebRange object. + WEBKIT_API static bool getRange(NPObject* range, WebRange*); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCString.h b/WebKit/chromium/public/WebCString.h new file mode 100644 index 0000000..434cb06 --- /dev/null +++ b/WebKit/chromium/public/WebCString.h @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCString_h +#define WebCString_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class CString; } +#else +#include <string> +#endif + +namespace WebKit { + +class WebCStringPrivate; +class WebString; + +// A single-byte string container with unspecified encoding. It is +// inexpensive to copy a WebCString object. +// +// WARNING: It is not safe to pass a WebCString across threads!!! +// +class WebCString { +public: + ~WebCString() { reset(); } + + WebCString() : m_private(0) { } + + WebCString(const char* data, size_t len) : m_private(0) + { + assign(data, len); + } + + WebCString(const WebCString& s) : m_private(0) { assign(s); } + + WebCString& operator=(const WebCString& s) + { + assign(s); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebCString&); + WEBKIT_API void assign(const char* data, size_t len); + + WEBKIT_API size_t length() const; + WEBKIT_API const char* data() const; + + bool isEmpty() const { return !length(); } + bool isNull() const { return !m_private; } + + WEBKIT_API WebString utf16() const; + + WEBKIT_API static WebCString fromUTF16(const WebUChar* data, size_t length); + WEBKIT_API static WebCString fromUTF16(const WebUChar* data); + +#if WEBKIT_IMPLEMENTATION + WebCString(const WebCore::CString&); + WebCString& operator=(const WebCore::CString&); + operator WebCore::CString() const; +#else + WebCString(const std::string& s) : m_private(0) + { + assign(s.data(), s.length()); + } + + WebCString& operator=(const std::string& s) + { + assign(s.data(), s.length()); + return *this; + } + + operator std::string() const + { + size_t len = length(); + return len ? std::string(data(), len) : std::string(); + } + + template <class UTF16String> + static WebCString fromUTF16(const UTF16String& s) + { + return fromUTF16(s.data(), s.length()); + } +#endif + +private: + void assign(WebCStringPrivate*); + WebCStringPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCache.h b/WebKit/chromium/public/WebCache.h new file mode 100644 index 0000000..433eb1a --- /dev/null +++ b/WebKit/chromium/public/WebCache.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCache_h +#define WebCache_h + +#include "WebCommon.h" + +namespace WebKit { + +// An interface to query and configure WebKit's resource cache. +class WebCache { +public: + struct UsageStats { + // Capacities. + size_t minDeadCapacity; + size_t maxDeadCapacity; + size_t capacity; + // Utilization. + size_t liveSize; + size_t deadSize; + }; + + // A struct mirroring WebCore::Cache::TypeStatistic. + struct ResourceTypeStat { + size_t count; + size_t size; + size_t liveSize; + size_t decodedSize; + }; + + // A struct mirroring WebCore::Cache::Statistics. + struct ResourceTypeStats { + ResourceTypeStat images; + ResourceTypeStat cssStyleSheets; + ResourceTypeStat scripts; + ResourceTypeStat xslStyleSheets; + ResourceTypeStat fonts; + }; + + // Sets the capacities of the resource cache, evicting objects as necessary. + WEBKIT_API static void setCapacities(size_t minDeadCapacity, + size_t maxDeadCapacity, + size_t capacity); + + // Clears the cache (as much as possible; some resources may not be + // cleared if they are actively referenced). + WEBKIT_API static void clear(); + + // Gets the usage statistics from the resource cache. + WEBKIT_API static void getUsageStats(UsageStats*); + + // Get usage stats about the resource cache. + WEBKIT_API static void getResourceTypeStats(ResourceTypeStats*); + +private: + WebCache(); // Not intended to be instanced. +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCanvas.h b/WebKit/chromium/public/WebCanvas.h new file mode 100644 index 0000000..4675487 --- /dev/null +++ b/WebKit/chromium/public/WebCanvas.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCanvas_h +#define WebCanvas_h + +#include "WebCommon.h" + +#if WEBKIT_USING_SKIA +namespace skia { class PlatformCanvas; } +#elif WEBKIT_USING_CG +struct CGContext; +#endif + +namespace WebKit { + +#if WEBKIT_USING_SKIA +typedef skia::PlatformCanvas WebCanvas; +#elif WEBKIT_USING_CG +typedef struct CGContext WebCanvas; +#else +#error "Need to define WebCanvas" +#endif + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebClipboard.h b/WebKit/chromium/public/WebClipboard.h new file mode 100644 index 0000000..68e22b5 --- /dev/null +++ b/WebKit/chromium/public/WebClipboard.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebClipboard_h +#define WebClipboard_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebImage; +class WebString; +class WebURL; + +class WebClipboard { +public: + enum Format { + FormatHTML, + FormatBookmark, + FormatSmartPaste + }; + + enum Buffer { + BufferStandard, + // Used on platforms like the X Window System that treat selection + // as a type of clipboard. + BufferSelection + }; + + virtual bool isFormatAvailable(Format, Buffer) = 0; + + virtual WebString readPlainText(Buffer) = 0; + virtual WebString readHTML(Buffer, WebURL*) = 0; + + virtual void writePlainText(const WebString&) = 0; + virtual void writeHTML( + const WebString& htmlText, const WebURL&, + const WebString& plainText, bool writeSmartPaste) = 0; + virtual void writeURL( + const WebURL&, const WebString& title) = 0; + virtual void writeImage( + const WebImage&, const WebURL&, const WebString& title) = 0; + +protected: + ~WebClipboard() {} +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebColor.h b/WebKit/chromium/public/WebColor.h new file mode 100644 index 0000000..034f8db --- /dev/null +++ b/WebKit/chromium/public/WebColor.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebColor_h +#define WebColor_h + +#include "WebColorName.h" +#include "WebCommon.h" + +namespace WebKit { + +typedef unsigned WebColor; // RGBA quad. Equivalent to SkColor. + +// Sets the values of a set of named colors. +WEBKIT_API void setNamedColors(const WebColorName*, const WebColor*, size_t length); + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebColorName.h b/WebKit/chromium/public/WebColorName.h new file mode 100644 index 0000000..f97ed26 --- /dev/null +++ b/WebKit/chromium/public/WebColorName.h @@ -0,0 +1,71 @@ +/* +* Copyright (C) 2009 Google Inc. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are +* met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following disclaimer +* in the documentation and/or other materials provided with the +* distribution. +* * Neither the name of Google Inc. nor the names of its +* contributors may be used to endorse or promote products derived from +* this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef WebColorName_h +#define WebColorName_h + +namespace WebKit { + +enum WebColorName { + WebColorActiveBorder, + WebColorActiveCaption, + WebColorAppworkspace, + WebColorBackground, + WebColorButtonFace, + WebColorButtonHighlight, + WebColorButtonShadow, + WebColorButtonText, + WebColorCaptionText, + WebColorGrayText, + WebColorHighlight, + WebColorHighlightText, + WebColorInactiveBorder, + WebColorInactiveCaption, + WebColorInactiveCaptionText, + WebColorInfoBackground, + WebColorInfoText, + WebColorMenu, + WebColorMenuText, + WebColorScrollbar, + WebColorText, + WebColorThreedDarkShadow, + WebColorThreedShadow, + WebColorThreedFace, + WebColorThreedHighlight, + WebColorThreedLightShadow, + WebColorWebkitFocusRingColor, + WebColorWindow, + WebColorWindowFrame, + WebColorWindowText +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCommon.h b/WebKit/chromium/public/WebCommon.h new file mode 100644 index 0000000..d347ea6 --- /dev/null +++ b/WebKit/chromium/public/WebCommon.h @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCommon_h +#define WebCommon_h + +// ----------------------------------------------------------------------------- +// Default configuration + +#if !defined(WEBKIT_IMPLEMENTATION) + #define WEBKIT_IMPLEMENTATION 0 +#endif + +#if !defined(WEBKIT_USING_SKIA) + #if !defined(__APPLE__) + #define WEBKIT_USING_SKIA 1 + #else + #define WEBKIT_USING_SKIA 0 + #endif +#endif + +#if !defined(WEBKIT_USING_CG) + #if defined(__APPLE__) + #define WEBKIT_USING_CG 1 + #else + #define WEBKIT_USING_CG 0 + #endif +#endif + +#if !defined(WEBKIT_USING_V8) + #define WEBKIT_USING_V8 1 +#endif + +#if !defined(WEBKIT_USING_JSC) + #define WEBKIT_USING_JSC 0 +#endif + +// ----------------------------------------------------------------------------- +// Exported symbols need to be annotated with WEBKIT_API + +#if defined(WIN32) && defined(WEBKIT_DLL) + #if defined(WEBKIT_IMPLEMENTATION) + #define WEBKIT_API __declspec(dllexport) + #else + #define WEBKIT_API __declspec(dllimport) + #endif +#else + #define WEBKIT_API +#endif + +// ----------------------------------------------------------------------------- +// Basic types + +#include <stddef.h> // For size_t + +namespace WebKit { + + // UTF-16 character type +#if defined(WIN32) +typedef wchar_t WebUChar; +#else +typedef unsigned short WebUChar; +#endif + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCommonWorkerClient.h b/WebKit/chromium/public/WebCommonWorkerClient.h new file mode 100644 index 0000000..771ffff --- /dev/null +++ b/WebKit/chromium/public/WebCommonWorkerClient.h @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCommonWorkerClient_h +#define WebCommonWorkerClient_h + +namespace WebKit { + +class WebNotificationPresenter; +class WebString; +class WebWorker; +class WebWorkerClient; + +// Provides an interface back to the in-page script object for a worker. +// This interface contains common APIs used by both shared and dedicated +// workers. +// All functions are expected to be called back on the thread that created +// the Worker object, unless noted. +class WebCommonWorkerClient { +public: + virtual void postExceptionToWorkerObject( + const WebString& errorString, int lineNumber, + const WebString& sourceURL) = 0; + + virtual void postConsoleMessageToWorkerObject( + int destinationIdentifier, + int sourceIdentifier, + int messageType, + int messageLevel, + const WebString& message, + int lineNumber, + const WebString& sourceURL) = 0; + + virtual void workerContextClosed() = 0; + virtual void workerContextDestroyed() = 0; + + // Returns the notification presenter for this worker context. Pointer + // is owned by the object implementing WebCommonWorkerClient. + virtual WebNotificationPresenter* notificationPresenter() = 0; + + // This can be called on any thread to create a nested WebWorker. + // WebSharedWorkers are not instantiated via this API - instead + // they are created via the WebSharedWorkerRepository. + virtual WebWorker* createWorker(WebWorkerClient* client) = 0; + +protected: + ~WebCommonWorkerClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCompositionCommand.h b/WebKit/chromium/public/WebCompositionCommand.h new file mode 100644 index 0000000..fa89529 --- /dev/null +++ b/WebKit/chromium/public/WebCompositionCommand.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCompositionCommand_h +#define WebCompositionCommand_h + +namespace WebKit { + +enum WebCompositionCommand { + WebCompositionCommandDiscard, + WebCompositionCommandSet, + WebCompositionCommandConfirm, +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebConsoleMessage.h b/WebKit/chromium/public/WebConsoleMessage.h new file mode 100644 index 0000000..d7a0ead --- /dev/null +++ b/WebKit/chromium/public/WebConsoleMessage.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebConsoleMessage_h +#define WebConsoleMessage_h + +#include "WebString.h" + +namespace WebKit { + +struct WebConsoleMessage { + enum Level { + LevelTip, + LevelLog, + LevelWarning, + LevelError + }; + + Level level; + WebString text; + + WebConsoleMessage() + : level(LevelLog) { } + WebConsoleMessage(Level level, const WebString& text) + : level(LevelLog) + , text(text) { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebContextMenuData.h b/WebKit/chromium/public/WebContextMenuData.h new file mode 100644 index 0000000..b4acb1c --- /dev/null +++ b/WebKit/chromium/public/WebContextMenuData.h @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebContextMenuData_h +#define WebContextMenuData_h + +#include "WebMenuItemInfo.h" +#include "WebPoint.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebVector.h" + +namespace WebKit { + +// This struct is passed to WebViewClient::ShowContextMenu. +struct WebContextMenuData { + enum MediaType { + // No special node is in context. + MediaTypeNone, + // An image node is selected. + MediaTypeImage, + // A video node is selected. + MediaTypeVideo, + // An audio node is selected. + MediaTypeAudio, + }; + // The type of media the context menu is being invoked on. + MediaType mediaType; + + // The x and y position of the mouse pointer (relative to the webview). + WebPoint mousePosition; + + // The absolute URL of the link that is in context. + WebURL linkURL; + + // The absolute URL of the image/video/audio that is in context. + WebURL srcURL; + + // The absolute URL of the page in context. + WebURL pageURL; + + // The absolute URL of the subframe in context. + WebURL frameURL; + + // The encoding for the frame in context. + WebString frameEncoding; + + enum MediaFlags { + MediaNone = 0x0, + MediaInError = 0x1, + MediaPaused = 0x2, + MediaMuted = 0x4, + MediaLoop = 0x8, + MediaCanSave = 0x10, + MediaHasAudio = 0x20, + }; + + // Extra attributes describing media elements. + int mediaFlags; + + // The raw text of the selection in context. + WebString selectedText; + + // Whether spell checking is enabled. + bool isSpellCheckingEnabled; + + // The editable (possibily) misspelled word. + WebString misspelledWord; + + // Whether context is editable. + bool isEditable; + + enum EditFlags { + CanDoNone = 0x0, + CanUndo = 0x1, + CanRedo = 0x2, + CanCut = 0x4, + CanCopy = 0x8, + CanPaste = 0x10, + CanDelete = 0x20, + CanSelectAll = 0x40, + }; + + // Which edit operations are available in the context. + int editFlags; + + // Security information for the context. + WebCString securityInfo; + + // Custom context menu items provided by the WebCore internals. + WebVector<WebMenuItemInfo> customItems; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCookie.h b/WebKit/chromium/public/WebCookie.h new file mode 100644 index 0000000..81cb361 --- /dev/null +++ b/WebKit/chromium/public/WebCookie.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCookie_h +#define WebCookie_h + +#include "WebCommon.h" +#include "WebString.h" + +namespace WebKit { + +class WebString; + +// A cookie. +// +struct WebCookie { + WebCookie() + : expires(0) + , httpOnly(false) + , secure(false) + , session(false) + { + } + + WebCookie(const WebString& name, const WebString& value, const WebString& domain, + const WebString& path, double expires, bool httpOnly, bool secure, bool session) + : name(name) + , value(value) + , domain(domain) + , path(path) + , expires(expires) + , httpOnly(httpOnly) + , secure(secure) + , session(session) + { + } + + WebString name; + WebString value; + WebString domain; + WebString path; + double expires; + bool httpOnly; + bool secure; + bool session; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCrossOriginPreflightResultCache.h b/WebKit/chromium/public/WebCrossOriginPreflightResultCache.h new file mode 100644 index 0000000..62827f7 --- /dev/null +++ b/WebKit/chromium/public/WebCrossOriginPreflightResultCache.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCrossOriginPreflightResultCache_h +#define WebCrossOriginPreflightResultCache_h + +#include "WebCommon.h" + +namespace WebKit { + +// An interface to configure WebKit's cross-origin preflight result cache. +class WebCrossOriginPreflightResultCache { +public: + // Clears the cache. + WEBKIT_API static void clear(); + +private: + WebCrossOriginPreflightResultCache(); // Not intended to be instanced. +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebCursorInfo.h b/WebKit/chromium/public/WebCursorInfo.h new file mode 100644 index 0000000..8926e5c --- /dev/null +++ b/WebKit/chromium/public/WebCursorInfo.h @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebCursorInfo_h +#define WebCursorInfo_h + +#include "WebImage.h" +#include "WebPoint.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Cursor; } +#endif + +#ifdef WIN32 +typedef struct HICON__* HICON; +typedef HICON HCURSOR; +#endif + +namespace WebKit { + +struct WebCursorInfo { + enum Type { + TypePointer, + TypeCross, + TypeHand, + TypeIBeam, + TypeWait, + TypeHelp, + TypeEastResize, + TypeNorthResize, + TypeNorthEastResize, + TypeNorthWestResize, + TypeSouthResize, + TypeSouthEastResize, + TypeSouthWestResize, + TypeWestResize, + TypeNorthSouthResize, + TypeEastWestResize, + TypeNorthEastSouthWestResize, + TypeNorthWestSouthEastResize, + TypeColumnResize, + TypeRowResize, + TypeMiddlePanning, + TypeEastPanning, + TypeNorthPanning, + TypeNorthEastPanning, + TypeNorthWestPanning, + TypeSouthPanning, + TypeSouthEastPanning, + TypeSouthWestPanning, + TypeWestPanning, + TypeMove, + TypeVerticalText, + TypeCell, + TypeContextMenu, + TypeAlias, + TypeProgress, + TypeNoDrop, + TypeCopy, + TypeNone, + TypeNotAllowed, + TypeZoomIn, + TypeZoomOut, + TypeCustom + }; + + Type type; + WebPoint hotSpot; + WebImage customImage; + +#ifdef WIN32 + // On Windows, TypeCustom may alternatively reference an externally + // defined HCURSOR. If type is TypeCustom and externalHandle is non- + // null, then customData should be ignored. The WebCursorInfo is not + // responsible for managing the lifetime of this cursor handle. + HCURSOR externalHandle; +#endif + + explicit WebCursorInfo(Type type = TypePointer) + : type(type) + { +#ifdef WIN32 + externalHandle = 0; +#endif + } + +#if WEBKIT_IMPLEMENTATION + explicit WebCursorInfo(const WebCore::Cursor&); +#endif +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebData.h b/WebKit/chromium/public/WebData.h new file mode 100644 index 0000000..5874bed --- /dev/null +++ b/WebKit/chromium/public/WebData.h @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebData_h +#define WebData_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class SharedBuffer; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebDataPrivate; + +// A container for raw bytes. It is inexpensive to copy a WebData object. +// +// WARNING: It is not safe to pass a WebData across threads!!! +// +class WebData { +public: + ~WebData() { reset(); } + + WebData() : m_private(0) { } + + WebData(const char* data, size_t size) : m_private(0) + { + assign(data, size); + } + + template <int N> + WebData(const char (&data)[N]) : m_private(0) + { + assign(data, N - 1); + } + + WebData(const WebData& d) : m_private(0) { assign(d); } + + WebData& operator=(const WebData& d) + { + assign(d); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebData&); + WEBKIT_API void assign(const char* data, size_t size); + + WEBKIT_API size_t size() const; + WEBKIT_API const char* data() const; + + bool isEmpty() const { return !size(); } + bool isNull() const { return !m_private; } + +#if WEBKIT_IMPLEMENTATION + WebData(const WTF::PassRefPtr<WebCore::SharedBuffer>&); + WebData& operator=(const WTF::PassRefPtr<WebCore::SharedBuffer>&); + operator WTF::PassRefPtr<WebCore::SharedBuffer>() const; +#else + template <class C> + WebData(const C& c) : m_private(0) + { + assign(c.data(), c.size()); + } + + template <class C> + WebData& operator=(const C& c) + { + assign(c.data(), c.size()); + return *this; + } +#endif + +private: + void assign(WebDataPrivate*); + WebDataPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDataSource.h b/WebKit/chromium/public/WebDataSource.h new file mode 100644 index 0000000..3a83341 --- /dev/null +++ b/WebKit/chromium/public/WebDataSource.h @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDataSource_h +#define WebDataSource_h + +#include "WebCommon.h" +#include "WebNavigationType.h" + +namespace WebKit { + +class WebString; +class WebURL; +class WebURLRequest; +class WebURLResponse; +template <typename T> class WebVector; + +class WebDataSource { +public: + class ExtraData { + public: + virtual ~ExtraData() { } + }; + + // Returns the original request that resulted in this datasource. + virtual const WebURLRequest& originalRequest() const = 0; + + // Returns the request corresponding to this datasource. It may + // include additional request headers added by WebKit that were not + // present in the original request. This request may also correspond + // to a location specified by a redirect that was followed. + virtual const WebURLRequest& request() const = 0; + + // Returns the response associated with this datasource. + virtual const WebURLResponse& response() const = 0; + + // When this datasource was created as a result of WebFrame::loadData, + // there may be an associated unreachableURL. + virtual bool hasUnreachableURL() const = 0; + virtual WebURL unreachableURL() const = 0; + + // Returns all redirects that occurred (both client and server) before + // at last committing the current page. This will contain one entry + // for each intermediate URL, and one entry for the last URL (so if + // there are no redirects, it will contain exactly the current URL, and + // if there is one redirect, it will contain the source and destination + // URL). + virtual void redirectChain(WebVector<WebURL>&) const = 0; + + // Returns the title for the current page. + virtual WebString pageTitle() const = 0; + + // The type of navigation that triggered the creation of this datasource. + virtual WebNavigationType navigationType() const = 0; + + // The time in seconds (since the epoch) of the event that triggered + // the creation of this datasource. Returns 0 if unknown. + virtual double triggeringEventTime() const = 0; + + // Extra data associated with this datasource. If non-null, the extra + // data pointer will be deleted when the datasource is destroyed. + // Setting the extra data pointer will cause any existing non-null + // extra data pointer to be deleted. + virtual ExtraData* extraData() const = 0; + virtual void setExtraData(ExtraData*) = 0; + +protected: + ~WebDataSource() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDatabase.h b/WebKit/chromium/public/WebDatabase.h new file mode 100644 index 0000000..179e828 --- /dev/null +++ b/WebKit/chromium/public/WebDatabase.h @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDatabase_h +#define WebDatabase_h + +#include "WebCommon.h" +#include "WebSecurityOrigin.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Database; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebDatabaseObserver; +class WebDatabasePrivate; +class WebString; + +class WebDatabase { +public: + WebDatabase() : m_private(0) { } + WebDatabase(const WebDatabase& d) : m_private(0) { assign(d); } + ~WebDatabase() { reset(); } + + WebDatabase& operator=(const WebDatabase& d) + { + assign(d); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebDatabase&); + bool isNull() const { return !m_private; } + + WEBKIT_API WebString name() const; + WEBKIT_API WebString displayName() const; + WEBKIT_API unsigned long estimatedSize() const; + WEBKIT_API WebSecurityOrigin securityOrigin() const; + + WEBKIT_API static void setObserver(WebDatabaseObserver*); + WEBKIT_API static WebDatabaseObserver* observer(); + + WEBKIT_API static void updateDatabaseSize( + const WebString& originIdentifier, const WebString& databaseName, + unsigned long long databaseSize, unsigned long long spaceAvailable); + +#if WEBKIT_IMPLEMENTATION + WebDatabase(const WTF::PassRefPtr<WebCore::Database>&); + WebDatabase& operator=(const WTF::PassRefPtr<WebCore::Database>&); + operator WTF::PassRefPtr<WebCore::Database>() const; +#endif + +private: + void assign(WebDatabasePrivate*); + + WebDatabasePrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDatabaseObserver.h b/WebKit/chromium/public/WebDatabaseObserver.h new file mode 100644 index 0000000..da85c93 --- /dev/null +++ b/WebKit/chromium/public/WebDatabaseObserver.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDatabaseObserver_h +#define WebDatabaseObserver_h + +namespace WebKit { +class WebDatabase; + +class WebDatabaseObserver { +public: + virtual void databaseOpened(const WebDatabase&) = 0; + virtual void databaseModified(const WebDatabase&) = 0; + virtual void databaseClosed(const WebDatabase&) = 0; +protected: + ~WebDatabaseObserver() {} +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDevToolsAgent.h b/WebKit/chromium/public/WebDevToolsAgent.h new file mode 100644 index 0000000..9c27628 --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsAgent.h @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDevToolsAgent_h +#define WebDevToolsAgent_h + +#include "WebCommon.h" + +namespace WebKit { +class WebDevToolsAgentClient; +class WebFrame; +class WebString; +class WebURLRequest; +class WebURLResponse; +class WebView; +struct WebDevToolsMessageData; +struct WebPoint; +struct WebURLError; + +class WebDevToolsAgent { +public: + WEBKIT_API static WebDevToolsAgent* create(WebView*, WebDevToolsAgentClient*); + + virtual ~WebDevToolsAgent() {} + + virtual void attach() = 0; + virtual void detach() = 0; + + virtual void didNavigate() = 0; + + // TODO(32320): remove this method from API. + virtual void dispatchMessageFromFrontend(const WebString& className, + const WebString& methodName, + const WebString& param1, + const WebString& param2, + const WebString& param3) = 0; + virtual void dispatchMessageFromFrontend(const WebDevToolsMessageData&) = 0; + + virtual void inspectElementAt(const WebPoint&) = 0; + + virtual void setRuntimeFeatureEnabled(const WebString& feature, bool enabled) = 0; + + // Exposed for LayoutTestController. + virtual void evaluateInWebInspector(long callId, const WebString& script) = 0; + virtual void setTimelineProfilingEnabled(bool enabled) = 0; + + // Asynchronously executes debugger command in the render thread. + // |callerIdentifier| will be used for sending response. + WEBKIT_API static void executeDebuggerCommand( + const WebString& command, int callerIdentifier); + + // Asynchronously request debugger to pause immediately. + WEBKIT_API static void debuggerPauseScript(); + + // TODO(32320): remove this method from API. + WEBKIT_API static bool dispatchMessageFromFrontendOnIOThread(const WebString& className, + const WebString& methodName, + const WebString& param1, + const WebString& param2, + const WebString& param3); + WEBKIT_API static bool dispatchMessageFromFrontendOnIOThread(const WebDevToolsMessageData&); + + typedef void (*MessageLoopDispatchHandler)(); + + // Installs dispatch handle that is going to be called periodically + // while on a breakpoint. + WEBKIT_API static void setMessageLoopDispatchHandler(MessageLoopDispatchHandler); + + virtual void identifierForInitialRequest(unsigned long resourceId, WebFrame*, const WebURLRequest&) = 0; + virtual void willSendRequest(unsigned long resourceId, const WebURLRequest&) = 0; + virtual void didReceiveData(unsigned long resourceId, int length) = 0; + virtual void didReceiveResponse(unsigned long resourceId, const WebURLResponse&) = 0; + virtual void didFinishLoading(unsigned long resourceId) = 0; + virtual void didFailLoading(unsigned long resourceId, const WebURLError&) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDevToolsAgentClient.h b/WebKit/chromium/public/WebDevToolsAgentClient.h new file mode 100644 index 0000000..ec51654 --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsAgentClient.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDevToolsAgentClient_h +#define WebDevToolsAgentClient_h + +#include "WebCommon.h" + +namespace WebKit { +class WebString; +struct WebDevToolsMessageData; + +class WebDevToolsAgentClient { +public: + // TODO(32320): remove this method from API. + virtual void sendMessageToFrontend(const WebString& className, + const WebString& methodName, + const WebString& param1, + const WebString& param2, + const WebString& param3) {} + virtual void sendMessageToFrontend(const WebDevToolsMessageData&) { } + + // Invalidates widget which leads to the repaint. + virtual void forceRepaint() { } + + // Returns the identifier of the entity hosting this agent. + virtual int hostIdentifier() { return -1; } + + // Notifies host upon runtime feature being enabled/disabled. + virtual void runtimeFeatureStateChanged(const WebString& feature, bool enabled) { } + + // TODO(32320): remove this method from API. + WEBKIT_API static void sendMessageToFrontendOnIOThread(const WebString& className, + const WebString& methodName, + const WebString& param1, + const WebString& param2, + const WebString& param3); + WEBKIT_API static void sendMessageToFrontendOnIOThread(const WebDevToolsMessageData&); + +protected: + ~WebDevToolsAgentClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDevToolsFrontend.h b/WebKit/chromium/public/WebDevToolsFrontend.h new file mode 100644 index 0000000..b7d7189 --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsFrontend.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDevToolsFrontend_h +#define WebDevToolsFrontend_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebDevToolsFrontendClient; +class WebString; +class WebView; +struct WebDevToolsMessageData; + +// WebDevToolsFrontend represents DevTools client sitting in the Glue. It provides +// direct and delegate Apis to the host. +class WebDevToolsFrontend { +public: + WEBKIT_API static WebDevToolsFrontend* create(WebView* view, + WebDevToolsFrontendClient* client, + const WebString& applicationLocale); + + virtual ~WebDevToolsFrontend() {} + + virtual void dispatchMessageFromAgent(const WebString& className, + const WebString& methodName, + const WebString& param1, + const WebString& param2, + const WebString& param3) = 0; + virtual void dispatchMessageFromAgent(const WebDevToolsMessageData&) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDevToolsFrontendClient.h b/WebKit/chromium/public/WebDevToolsFrontendClient.h new file mode 100644 index 0000000..2f74a8c --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsFrontendClient.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDevToolsFrontendClient_h +#define WebDevToolsFrontendClient_h + +namespace WebKit { + +class WebString; +struct WebDevToolsMessageData; + +class WebDevToolsFrontendClient { +public: + WebDevToolsFrontendClient() {} + + virtual void sendMessageToAgent(const WebString& className, + const WebString& methodName, + const WebString& param1, + const WebString& param2, + const WebString& param3) {}; + virtual void sendMessageToAgent(const WebDevToolsMessageData&) {}; + virtual void sendDebuggerCommandToAgent(const WebString& command) {}; + virtual void sendDebuggerPauseScript() {} + + virtual void activateWindow() {}; + virtual void closeWindow() {}; + virtual void dockWindow() {}; + virtual void undockWindow() {}; + +protected: + virtual ~WebDevToolsFrontendClient() {} +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDevToolsMessageData.h b/WebKit/chromium/public/WebDevToolsMessageData.h new file mode 100644 index 0000000..9bf9acd --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsMessageData.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDevToolsMessageData_h +#define WebDevToolsMessageData_h + +#include "WebCommon.h" +#include "WebString.h" +#include "WebVector.h" + +namespace WebKit { + +struct WebDevToolsMessageData { + WebString className; + WebString methodName; + WebVector<WebString> arguments; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDragData.h b/WebKit/chromium/public/WebDragData.h new file mode 100644 index 0000000..f7a165d --- /dev/null +++ b/WebKit/chromium/public/WebDragData.h @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDragData_h +#define WebDragData_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class ChromiumDataObject; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebData; +class WebDragDataPrivate; +class WebString; +class WebURL; +template <typename T> class WebVector; + +// Holds data that may be exchanged through a drag-n-drop operation. It is +// inexpensive to copy a WebDragData object. +class WebDragData { +public: + ~WebDragData() { reset(); } + + WebDragData() : m_private(0) { } + WebDragData(const WebDragData& d) : m_private(0) { assign(d); } + WebDragData& operator=(const WebDragData& d) + { + assign(d); + return *this; + } + + WEBKIT_API void initialize(); + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebDragData&); + + bool isNull() const { return !m_private; } + + WEBKIT_API WebURL url() const; + WEBKIT_API void setURL(const WebURL&); + + WEBKIT_API WebString urlTitle() const; + WEBKIT_API void setURLTitle(const WebString&); + + WEBKIT_API WebString fileExtension() const; + WEBKIT_API void setFileExtension(const WebString&); + + WEBKIT_API bool hasFileNames() const; + WEBKIT_API void fileNames(WebVector<WebString>&) const; + WEBKIT_API void setFileNames(const WebVector<WebString>&); + WEBKIT_API void appendToFileNames(const WebString&); + + WEBKIT_API WebString plainText() const; + WEBKIT_API void setPlainText(const WebString&); + + WEBKIT_API WebString htmlText() const; + WEBKIT_API void setHTMLText(const WebString&); + + WEBKIT_API WebURL htmlBaseURL() const; + WEBKIT_API void setHTMLBaseURL(const WebURL&); + + WEBKIT_API WebString fileContentFileName() const; + WEBKIT_API void setFileContentFileName(const WebString&); + + WEBKIT_API WebData fileContent() const; + WEBKIT_API void setFileContent(const WebData&); + +#if WEBKIT_IMPLEMENTATION + WebDragData(const WTF::PassRefPtr<WebCore::ChromiumDataObject>&); + WebDragData& operator=(const WTF::PassRefPtr<WebCore::ChromiumDataObject>&); + operator WTF::PassRefPtr<WebCore::ChromiumDataObject>() const; +#endif + +private: + void assign(WebDragDataPrivate*); + void ensureMutable(); + WebDragDataPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDragOperation.h b/WebKit/chromium/public/WebDragOperation.h new file mode 100644 index 0000000..050b74f --- /dev/null +++ b/WebKit/chromium/public/WebDragOperation.h @@ -0,0 +1,59 @@ +/* +* Copyright (C) 2009 Google Inc. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are +* met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following disclaimer +* in the documentation and/or other materials provided with the +* distribution. +* * Neither the name of Google Inc. nor the names of its +* contributors may be used to endorse or promote products derived from +* this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef WebDragOperation_h +#define WebDragOperation_h + +#include <limits.h> + +namespace WebKit { + +// "Verb" of a drag-and-drop operation as negotiated between the source and +// destination. +// (These constants match their equivalents in WebCore's DragActions.h and +// should not be renumbered.) +enum WebDragOperation { + WebDragOperationNone = 0, + WebDragOperationCopy = 1, + WebDragOperationLink = 2, + WebDragOperationGeneric = 4, + WebDragOperationPrivate = 8, + WebDragOperationMove = 16, + WebDragOperationDelete = 32, + WebDragOperationEvery = UINT_MAX +}; + +// Alternate typedef to make it clear when this is being used as a mask +// with potentially multiple value bits set. +typedef WebDragOperation WebDragOperationsMask; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebEditingAction.h b/WebKit/chromium/public/WebEditingAction.h new file mode 100644 index 0000000..4e76100 --- /dev/null +++ b/WebKit/chromium/public/WebEditingAction.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebEditingAction_h +#define WebEditingAction_h + +namespace WebKit { + +enum WebEditingAction { + WebEditingActionTyped, + WebEditingActionPasted, + WebEditingActionDropped, +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebElement.h b/WebKit/chromium/public/WebElement.h new file mode 100644 index 0000000..d7a2cbf --- /dev/null +++ b/WebKit/chromium/public/WebElement.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebElement_h +#define WebElement_h + +#include "WebNode.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Element; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + + // Provides readonly access to some properties of a DOM element node. + class WebElement : public WebNode { + public: + WebElement() : WebNode() { } + WebElement(const WebElement& e) : WebNode(e) { } + + WebElement& operator=(const WebElement& e) { WebNode::assign(e); return *this; } + WEBKIT_API void assign(const WebElement& e) { WebNode::assign(e); } + +#if WEBKIT_IMPLEMENTATION + WebElement(const WTF::PassRefPtr<WebCore::Element>&); + WebElement& operator=(const WTF::PassRefPtr<WebCore::Element>&); + operator WTF::PassRefPtr<WebCore::Element>() const; +#endif + }; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebFileChooserCompletion.h b/WebKit/chromium/public/WebFileChooserCompletion.h new file mode 100644 index 0000000..14bace4 --- /dev/null +++ b/WebKit/chromium/public/WebFileChooserCompletion.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFileChooserCompletion_h +#define WebFileChooserCompletion_h + +namespace WebKit { + +class WebString; +template <typename T> class WebVector; + +// Gets called back when WebViewClient finished choosing a file. +class WebFileChooserCompletion { +public: + // Called with zero or more file names. Zero-lengthed vector means that + // the user cancelled or that file choosing failed. The callback instance + // is destroyed when this method is called. + virtual void didChooseFile(const WebVector<WebString>& fileNames) = 0; +protected: + virtual ~WebFileChooserCompletion() {} +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebFindOptions.h b/WebKit/chromium/public/WebFindOptions.h new file mode 100644 index 0000000..93d48d3 --- /dev/null +++ b/WebKit/chromium/public/WebFindOptions.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFindOptions_h +#define WebFindOptions_h + +#include "WebString.h" + +namespace WebKit { + +// Options used when performing a find-in-page query. +struct WebFindOptions { + // Whether to search forward or backward within the page. + bool forward; + + // Whether search should be case-sensitive. + bool matchCase; + + // Whether this operation is the first request or a follow-up. + bool findNext; + + WebFindOptions() + : forward(true) + , matchCase(false) + , findNext(false) { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebFontCache.h b/WebKit/chromium/public/WebFontCache.h new file mode 100644 index 0000000..05aadc7 --- /dev/null +++ b/WebKit/chromium/public/WebFontCache.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFontCache_h +#define WebFontCache_h + +#include "WebCommon.h" + +namespace WebKit { + +// An interface to query and configure WebKit's font cache. +class WebFontCache { +public: + // Returns the number of items in the font data cache. + WEBKIT_API static size_t fontDataCount(); + + // Returns the number of inactive items in the font data cache. + WEBKIT_API static size_t inactiveFontDataCount(); + + // Clears the cache. + WEBKIT_API static void clear(); + +private: + WebFontCache(); // Not intended to be instanced. +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebFormElement.h b/WebKit/chromium/public/WebFormElement.h new file mode 100644 index 0000000..27a1edb --- /dev/null +++ b/WebKit/chromium/public/WebFormElement.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFormElement_h +#define WebFormElement_h + +#include "WebElement.h" +#include "WebInputElement.h" +#include "WebVector.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class HTMLFormElement; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + // A container for passing around a reference to a form element. Provides + // some information about the form. + class WebFormElement : public WebElement { + public: + ~WebFormElement() { reset(); } + + WebFormElement() : WebElement() { } + WebFormElement(const WebFormElement& e) : WebElement(e) { } + + WebElement& operator=(const WebFormElement& e) { WebElement::assign(e); return *this; } + WEBKIT_API void assign(const WebFormElement& e) { WebElement::assign(e); } + +#if WEBKIT_IMPLEMENTATION + WebFormElement(const WTF::PassRefPtr<WebCore::HTMLFormElement>&); + WebFormElement& operator=(const WTF::PassRefPtr<WebCore::HTMLFormElement>&); + operator WTF::PassRefPtr<WebCore::HTMLFormElement>() const; +#endif + + WEBKIT_API bool autoComplete() const; + WEBKIT_API WebString action() const; + WEBKIT_API WebString name() const; + WEBKIT_API WebString method() const; + WEBKIT_API void submit(); + // FIXME: Deprecate and replace with WebVector<WebElement>. + WEBKIT_API void getNamedElements(const WebString&, WebVector<WebNode>&); + WEBKIT_API void getInputElements(WebVector<WebInputElement>&) const; + }; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebFrame.h b/WebKit/chromium/public/WebFrame.h new file mode 100644 index 0000000..44b57aa --- /dev/null +++ b/WebKit/chromium/public/WebFrame.h @@ -0,0 +1,469 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFrame_h +#define WebFrame_h + +#include "WebCanvas.h" +#include "WebURL.h" + +struct NPObject; + +#if WEBKIT_USING_V8 +namespace v8 { +class Context; +template <class T> class Local; +} +#endif + +namespace WebKit { + +class WebData; +class WebDataSource; +class WebFormElement; +class WebHistoryItem; +class WebInputElement; +class WebPasswordAutocompleteListener; +class WebRange; +class WebSecurityOrigin; +class WebString; +class WebURL; +class WebURLRequest; +class WebView; +struct WebConsoleMessage; +struct WebFindOptions; +struct WebRect; +struct WebScriptSource; +struct WebSize; +template <typename T> class WebVector; + +class WebFrame { +public: + // The two functions below retrieve the WebFrame instances relating the + // currently executing JavaScript. Since JavaScript can make function + // calls across frames, though, we need to be more precise. + // + // For example, imagine that a JS function in frame A calls a function + // in frame B, which calls native code, which wants to know what the + // 'active' frame is. + // + // The 'entered context' is the context where execution first entered + // the script engine; the context that is at the bottom of the JS + // function stack. frameForEnteredContext() would return frame A in + // our example. + // + // The 'current context' is the context the JS engine is currently + // inside of; the context that is at the top of the JS function stack. + // frameForCurrentContext() would return frame B in our example. + WEBKIT_API static WebFrame* frameForEnteredContext(); + WEBKIT_API static WebFrame* frameForCurrentContext(); + + + // Basic properties --------------------------------------------------- + + // The name of this frame. + virtual WebString name() const = 0; + + // The url of the document loaded in this frame. This is equivalent to + // dataSource()->request().url(). + virtual WebURL url() const = 0; + + // The url of the favicon (if any) specified by the document loaded in + // this frame. + virtual WebURL favIconURL() const = 0; + + // The url of the OpenSearch Desription Document (if any) specified by + // the document loaded in this frame. + virtual WebURL openSearchDescriptionURL() const = 0; + + + // Geometry ----------------------------------------------------------- + + // NOTE: These routines do not force page layout so their results may + // not be accurate if the page layout is out-of-date. + + // The scroll offset from the top-left corner of the frame in pixels. + virtual WebSize scrollOffset() const = 0; + + // The size of the contents area. + virtual WebSize contentsSize() const = 0; + + // Returns the minimum preferred width of the content contained in the + // current document. + virtual int contentsPreferredWidth() const = 0; + + // Returns the scroll height of the document element. This is + // equivalent to the DOM property of the same name, and is the minimum + // height required to display the document without scrollbars. + virtual int documentElementScrollHeight() const = 0; + + // Returns true if the contents (minus scrollbars) has non-zero area. + virtual bool hasVisibleContent() const = 0; + + + // Hierarchy ---------------------------------------------------------- + + // Returns the containing view. + virtual WebView* view() const = 0; + + // Returns the frame that opened this frame or 0 if there is none. + virtual WebFrame* opener() const = 0; + + // Returns the parent frame or 0 if this is a top-most frame. + virtual WebFrame* parent() const = 0; + + // Returns the top-most frame in the hierarchy containing this frame. + virtual WebFrame* top() const = 0; + + // Returns the first/last child frame. + virtual WebFrame* firstChild() const = 0; + virtual WebFrame* lastChild() const = 0; + + // Returns the next/previous sibling frame. + virtual WebFrame* nextSibling() const = 0; + virtual WebFrame* previousSibling() const = 0; + + // Returns the next/previous frame in "frame traversal order" + // optionally wrapping around. + virtual WebFrame* traverseNext(bool wrap) const = 0; + virtual WebFrame* traversePrevious(bool wrap) const = 0; + + // Returns the child frame identified by the given name. + virtual WebFrame* findChildByName(const WebString& name) const = 0; + + // Returns the child frame identified by the given xpath expression. + virtual WebFrame* findChildByExpression(const WebString& xpath) const = 0; + + + // Content ------------------------------------------------------------ + + virtual void forms(WebVector<WebFormElement>&) const = 0; + + + // Scripting ---------------------------------------------------------- + + // Returns the security origin of the current document. + virtual WebSecurityOrigin securityOrigin() const = 0; + + // This grants the currently loaded document access to all security + // origins (including file URLs). Use with care. The access is + // revoked when a new document is loaded into this frame. + virtual void grantUniversalAccess() = 0; + + // Returns a NPObject corresponding to this frame's DOMWindow. + virtual NPObject* windowObject() const = 0; + + // Binds a NPObject as a property of this frame's DOMWindow. + virtual void bindToWindowObject(const WebString& name, NPObject*) = 0; + + // Executes script in the context of the current page. + virtual void executeScript(const WebScriptSource&) = 0; + + // Executes script in a new context associated with the frame. The + // script gets its own global scope and its own prototypes for + // intrinsic JS objects (String, Array, and so-on). It shares the + // wrappers for all DOM nodes and DOM constructors. extensionGroup is + // an embedder-provided specifier that controls which v8 extensions are + // loaded into the new context - see WebKit::registerExtension for the + // corresponding specifier. + virtual void executeScriptInNewContext(const WebScriptSource* sources, + unsigned numSources, + int extensionGroup) = 0; + + // Executes JavaScript in a new world associated with the web frame. + // The script gets its own global scope and its own prototypes for + // intrinsic JavaScript objects (String, Array, and so-on). It also + // gets its own wrappers for all DOM nodes and DOM constructors. + // extensionGroup is an embedder-provided specifier that controls which + // v8 extensions are loaded into the new context - see + // WebKit::registerExtension for the corresponding specifier. + virtual void executeScriptInIsolatedWorld( + int worldId, const WebScriptSource* sources, unsigned numSources, + int extensionGroup) = 0; + + // Logs to the console associated with this frame. + virtual void addMessageToConsole(const WebConsoleMessage&) = 0; + + // Calls window.gc() if it is defined. + virtual void collectGarbage() = 0; + +#if WEBKIT_USING_V8 + // Returns the V8 context for this frame, or an empty handle if there + // is none. + virtual v8::Local<v8::Context> mainWorldScriptContext() const = 0; +#endif + + + // Styling ------------------------------------------------------------- + + // Insert the given text as a STYLE element at the beginning of the + // document. |elementId| can be empty, but if specified then it is used + // as the id for the newly inserted element (replacing an existing one + // with the same id, if any). + virtual bool insertStyleText(const WebString& styleText, + const WebString& elementId) = 0; + + + // Navigation ---------------------------------------------------------- + + // Reload the current document. + virtual void reload() = 0; + + // Load the given URL. + virtual void loadRequest(const WebURLRequest&) = 0; + + // Load the given history state, corresponding to a back/forward + // navigation. + virtual void loadHistoryItem(const WebHistoryItem&) = 0; + + // Loads the given data with specific mime type and optional text + // encoding. For HTML data, baseURL indicates the security origin of + // the document and is used to resolve links. If specified, + // unreachableURL is reported via WebDataSource::unreachableURL. If + // replace is false, then this data will be loaded as a normal + // navigation. Otherwise, the current history item will be replaced. + virtual void loadData(const WebData& data, + const WebString& mimeType, + const WebString& textEncoding, + const WebURL& baseURL, + const WebURL& unreachableURL = WebURL(), + bool replace = false) = 0; + + // This method is short-hand for calling LoadData, where mime_type is + // "text/html" and text_encoding is "UTF-8". + virtual void loadHTMLString(const WebData& html, + const WebURL& baseURL, + const WebURL& unreachableURL = WebURL(), + bool replace = false) = 0; + + // Returns true if the current frame is busy loading content. + virtual bool isLoading() const = 0; + + // Stops any pending loads on the frame and its children. + virtual void stopLoading() = 0; + + // Returns the data source that is currently loading. May be null. + virtual WebDataSource* provisionalDataSource() const = 0; + + // Returns the data source that is currently loaded. + virtual WebDataSource* dataSource() const = 0; + + // Returns the previous history item. Check WebHistoryItem::isNull() + // before using. + virtual WebHistoryItem previousHistoryItem() const = 0; + + // Returns the current history item. Check WebHistoryItem::isNull() + // before using. + virtual WebHistoryItem currentHistoryItem() const = 0; + + // View-source rendering mode. Set this before loading an URL to cause + // it to be rendered in view-source mode. + virtual void enableViewSourceMode(bool) = 0; + virtual bool isViewSourceModeEnabled() const = 0; + + // Sets the referrer for the given request to be the specified URL or + // if that is null, then it sets the referrer to the referrer that the + // frame would use for subresources. NOTE: This method also filters + // out invalid referrers (e.g., it is invalid to send a HTTPS URL as + // the referrer for a HTTP request). + virtual void setReferrerForRequest(WebURLRequest&, const WebURL&) = 0; + + // Called to associate the WebURLRequest with this frame. The request + // will be modified to inherit parameters that allow it to be loaded. + // This method ends up triggering WebFrameClient::willSendRequest. + virtual void dispatchWillSendRequest(WebURLRequest&) = 0; + + // Called from within WebFrameClient::didReceiveDocumentData to commit + // data for the frame that will be used to construct the frame's + // document. + virtual void commitDocumentData(const char* data, size_t length) = 0; + + // Returns the number of registered unload listeners. + virtual unsigned unloadListenerCount() const = 0; + + // Returns true if a user gesture is currently being processed. + virtual bool isProcessingUserGesture() const = 0; + + // Returns true if this frame is in the process of opening a new frame + // with a suppressed opener. + virtual bool willSuppressOpenerInNewFrame() const = 0; + + + // Editing ------------------------------------------------------------- + + // Replaces the selection with the given text. + virtual void replaceSelection(const WebString& text) = 0; + + virtual void insertText(const WebString& text) = 0; + + virtual void setMarkedText(const WebString& text, unsigned location, unsigned length) = 0; + virtual void unmarkText() = 0; + virtual bool hasMarkedText() const = 0; + + virtual WebRange markedRange() const = 0; + + // Supports commands like Undo, Redo, Cut, Copy, Paste, SelectAll, + // Unselect, etc. See EditorCommand.cpp for the full list of supported + // commands. + virtual bool executeCommand(const WebString&) = 0; + virtual bool executeCommand(const WebString&, const WebString& value) = 0; + virtual bool isCommandEnabled(const WebString&) const = 0; + + // Spell-checking support. + virtual void enableContinuousSpellChecking(bool) = 0; + virtual bool isContinuousSpellCheckingEnabled() const = 0; + + + // Selection ----------------------------------------------------------- + + virtual bool hasSelection() const = 0; + + virtual WebRange selectionRange() const = 0; + + virtual WebString selectionAsText() const = 0; + virtual WebString selectionAsMarkup() const = 0; + + + // Printing ------------------------------------------------------------ + + // Reformats the WebFrame for printing. pageSize is the page size in + // pixels. Returns the number of pages that can be printed at the + // given page size. + virtual int printBegin(const WebSize& pageSize) = 0; + + // Returns the page shrinking factor calculated by webkit (usually + // between 1/1.25 and 1/2). Returns 0 if the page number is invalid or + // not in printing mode. + virtual float getPrintPageShrink(int page) = 0; + + // Prints one page, and returns the calculated page shrinking factor + // (usually between 1/1.25 and 1/2). Returns 0 if the page number is + // invalid or not in printing mode. + virtual float printPage(int pageToPrint, WebCanvas*) = 0; + + // Reformats the WebFrame for screen display. + virtual void printEnd() = 0; + + + // Find-in-page -------------------------------------------------------- + + // Searches a frame for a given string. + // + // If a match is found, this function will select it (scrolling down to + // make it visible if needed) and fill in selectionRect with the + // location of where the match was found (in window coordinates). + // + // If no match is found, this function clears all tickmarks and + // highlighting. + // + // Returns true if the search string was found, false otherwise. + virtual bool find(int identifier, + const WebString& searchText, + const WebFindOptions& options, + bool wrapWithinFrame, + WebRect* selectionRect) = 0; + + // Notifies the frame that we are no longer interested in searching. + // This will abort any asynchronous scoping effort already under way + // (see the function scopeStringMatches for details) and erase all + // tick-marks and highlighting from the previous search. If + // clearSelection is true, it will also make sure the end state for the + // find operation does not leave a selection. This can occur when the + // user clears the search string but does not close the find box. + virtual void stopFinding(bool clearSelection) = 0; + + // Counts how many times a particular string occurs within the frame. + // It also retrieves the location of the string and updates a vector in + // the frame so that tick-marks and highlighting can be drawn. This + // function does its work asynchronously, by running for a certain + // time-slice and then scheduling itself (co-operative multitasking) to + // be invoked later (repeating the process until all matches have been + // found). This allows multiple frames to be searched at the same time + // and provides a way to cancel at any time (see + // cancelPendingScopingEffort). The parameter searchText specifies + // what to look for and |reset| signals whether this is a brand new + // request or a continuation of the last scoping effort. + virtual void scopeStringMatches(int identifier, + const WebString& searchText, + const WebFindOptions& options, + bool reset) = 0; + + // Cancels any outstanding requests for scoping string matches on a frame. + virtual void cancelPendingScopingEffort() = 0; + + // This function is called on the main frame during the scoping effort + // to keep a running tally of the accumulated total match-count for all + // frames. After updating the count it will notify the WebViewClient + // about the new count. + virtual void increaseMatchCount(int count, int identifier) = 0; + + // This function is called on the main frame to reset the total number + // of matches found during the scoping effort. + virtual void resetMatchCount() = 0; + + // Password autocompletion --------------------------------------------- + + // Registers a listener for the specified user name input element. The + // listener will receive notifications for blur and when autocomplete + // should be triggered. + // The WebFrame becomes the owner of the passed listener. + virtual void registerPasswordListener( + WebInputElement, + WebPasswordAutocompleteListener*) = 0; + + // Utility ------------------------------------------------------------- + + // Given a relative URL, returns an absolute URL by resolving the URL + // relative to the base URL of the frame's document. This uses the + // same algorithm that WebKit uses to resolve hyperlinks found in a + // HTML document. + virtual WebURL completeURL(const WebString&) const = 0; + + // Returns the contents of this frame as a string. If the text is + // longer than maxChars, it will be clipped to that length. WARNING: + // This function may be slow depending on the number of characters + // retrieved and page complexity. For a typically sized page, expect + // it to take on the order of milliseconds. + // + // If there is room, subframe text will be recursively appended. Each + // frame will be separated by an empty line. + virtual WebString contentAsText(size_t maxChars) const = 0; + + // Returns HTML text for the contents of this frame. This is generated + // from the DOM. + virtual WebString contentAsMarkup() const = 0; + +protected: + ~WebFrame() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebFrameClient.h b/WebKit/chromium/public/WebFrameClient.h new file mode 100644 index 0000000..297eb62 --- /dev/null +++ b/WebKit/chromium/public/WebFrameClient.h @@ -0,0 +1,290 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFrameClient_h +#define WebFrameClient_h + +#include "WebCommon.h" +#include "WebNavigationPolicy.h" +#include "WebNavigationType.h" +#include "WebURLError.h" + +namespace WebKit { + +class WebDataSource; +class WebFormElement; +class WebFrame; +class WebMediaPlayer; +class WebMediaPlayerClient; +class WebNode; +class WebPlugin; +class WebSecurityOrigin; +class WebSharedWorker; +class WebString; +class WebURL; +class WebURLRequest; +class WebURLResponse; +class WebWorker; +class WebWorkerClient; +struct WebPluginParams; +struct WebRect; +struct WebSize; +struct WebURLError; + +class WebFrameClient { +public: + // Factory methods ----------------------------------------------------- + + // May return null. + virtual WebPlugin* createPlugin(WebFrame*, const WebPluginParams&) { return 0; } + + // May return null. + virtual WebWorker* createWorker(WebFrame*, WebWorkerClient*) { return 0; } + + // May return null. + virtual WebSharedWorker* createSharedWorker(WebFrame*, const WebURL&, const WebString&, unsigned long long) { return 0; } + + // May return null. + virtual WebMediaPlayer* createMediaPlayer(WebFrame*, WebMediaPlayerClient*) { return 0; } + + + // General notifications ----------------------------------------------- + + // This frame is about to be closed. + virtual void willClose(WebFrame*) { } + + + // Load commands ------------------------------------------------------- + + // The client should handle the navigation externally. + virtual void loadURLExternally( + WebFrame*, const WebURLRequest&, WebNavigationPolicy) { } + + + // Navigational queries ------------------------------------------------ + + // The client may choose to alter the navigation policy. Otherwise, + // defaultPolicy should just be returned. + virtual WebNavigationPolicy decidePolicyForNavigation( + WebFrame*, const WebURLRequest&, WebNavigationType, + const WebNode& originatingNode, + WebNavigationPolicy defaultPolicy, bool isRedirect) { return defaultPolicy; } + + // Query if the specified request can be handled. + virtual bool canHandleRequest( + WebFrame*, const WebURLRequest& request) { return true; } + + // Returns an error corresponding to canHandledRequest() returning false. + virtual WebURLError cannotHandleRequestError( + WebFrame*, const WebURLRequest& request) { return WebURLError(); } + + // Returns an error corresponding to a user cancellation event. + virtual WebURLError cancelledError( + WebFrame*, const WebURLRequest& request) { return WebURLError(); } + + // Notify that a URL cannot be handled. + virtual void unableToImplementPolicyWithError( + WebFrame*, const WebURLError&) { } + + + // Navigational notifications ------------------------------------------ + + // A form submission is about to occur. + virtual void willSubmitForm(WebFrame*, const WebFormElement&) { } + + // A client-side redirect will occur. This may correspond to a <META + // refresh> or some script activity. + virtual void willPerformClientRedirect( + WebFrame*, const WebURL& from, const WebURL& to, + double interval, double fireTime) { } + + // A client-side redirect was cancelled. + virtual void didCancelClientRedirect(WebFrame*) { } + + // A client-side redirect completed. + virtual void didCompleteClientRedirect(WebFrame*, const WebURL& fromURL) { } + + // A datasource has been created for a new navigation. The given + // datasource will become the provisional datasource for the frame. + virtual void didCreateDataSource(WebFrame*, WebDataSource*) { } + + // A new provisional load has been started. + virtual void didStartProvisionalLoad(WebFrame*) { } + + // The provisional load was redirected via a HTTP 3xx response. + virtual void didReceiveServerRedirectForProvisionalLoad(WebFrame*) { } + + // The provisional load failed. + virtual void didFailProvisionalLoad(WebFrame*, const WebURLError&) { } + + // Notifies the client to commit data for the given frame. The client + // may optionally prevent default processing by setting preventDefault + // to true before returning. If default processing is prevented, then + // it is up to the client to manually call commitDocumentData on the + // WebFrame. It is only valid to call commitDocumentData within a call + // to didReceiveDocumentData. If commitDocumentData is not called, + // then an empty document will be loaded. + virtual void didReceiveDocumentData( + WebFrame*, const char* data, size_t length, bool& preventDefault) { } + + // The provisional datasource is now committed. The first part of the + // response body has been received, and the encoding of the response + // body is known. + virtual void didCommitProvisionalLoad(WebFrame*, bool isNewNavigation) { } + + // The window object for the frame has been cleared of any extra + // properties that may have been set by script from the previously + // loaded document. + virtual void didClearWindowObject(WebFrame*) { } + + // The document element has been created. + virtual void didCreateDocumentElement(WebFrame*) { } + + // The page title is available. + virtual void didReceiveTitle(WebFrame*, const WebString& title) { } + + // The frame's document finished loading. + virtual void didFinishDocumentLoad(WebFrame*) { } + + // The 'load' event was dispatched. + virtual void didHandleOnloadEvents(WebFrame*) { } + + // The frame's document or one of its subresources failed to load. + virtual void didFailLoad(WebFrame*, const WebURLError&) { } + + // The frame's document and all of its subresources succeeded to load. + virtual void didFinishLoad(WebFrame*) { } + + // The navigation resulted in scrolling the page to a named anchor instead + // of downloading a new document. + virtual void didChangeLocationWithinPage(WebFrame*, bool isNewNavigation) { } + + // Called upon update to scroll position, document state, and other + // non-navigational events related to the data held by WebHistoryItem. + // WARNING: This method may be called very frequently. + virtual void didUpdateCurrentHistoryItem(WebFrame*) { } + + + // Low-level resource notifications ------------------------------------ + + // An identifier was assigned to the specified request. The client + // should remember this association if interested in subsequent events. + virtual void assignIdentifierToRequest( + WebFrame*, unsigned identifier, const WebURLRequest&) { } + + // A request is about to be sent out, and the client may modify it. Request + // is writable, and changes to the URL, for example, will change the request + // made. If this request is the result of a redirect, then redirectResponse + // will be non-null and contain the response that triggered the redirect. + virtual void willSendRequest( + WebFrame*, unsigned identifier, WebURLRequest&, + const WebURLResponse& redirectResponse) { } + + // Response headers have been received for the resource request given + // by identifier. + virtual void didReceiveResponse( + WebFrame*, unsigned identifier, const WebURLResponse&) { } + + // The resource request given by identifier succeeded. + virtual void didFinishResourceLoad( + WebFrame*, unsigned identifier) { } + + // The resource request given by identifier failed. + virtual void didFailResourceLoad( + WebFrame*, unsigned identifier, const WebURLError&) { } + + // The specified request was satified from WebCore's memory cache. + virtual void didLoadResourceFromMemoryCache( + WebFrame*, const WebURLRequest&, const WebURLResponse&) { } + + // This frame has displayed inactive content (such as an image) from an + // insecure source. Inactive content cannot spread to other frames. + virtual void didDisplayInsecureContent(WebFrame*) { } + + // The indicated security origin has run active content (such as a + // script) from an insecure source. Note that the insecure content can + // spread to other frames in the same origin. + virtual void didRunInsecureContent(WebFrame*, const WebSecurityOrigin&) { } + + + // Script notifications ------------------------------------------------ + + // Controls whether scripts are allowed to execute for this frame. + virtual bool allowScript(WebFrame*, bool enabledPerSettings) { return enabledPerSettings; } + + // Script in the page tried to allocate too much memory. + virtual void didExhaustMemoryAvailableForScript(WebFrame*) { } + + // Notifies that a new script context has been created for this frame. + // This is similar to didClearWindowObject but only called once per + // frame context. + virtual void didCreateScriptContext(WebFrame*) { } + + // Notifies that this frame's script context has been destroyed. + virtual void didDestroyScriptContext(WebFrame*) { } + + // Notifies that a garbage-collected context was created - content + // scripts. + virtual void didCreateIsolatedScriptContext(WebFrame*) { } + + + // Geometry notifications ---------------------------------------------- + + // The size of the content area changed. + virtual void didChangeContentsSize(WebFrame*, const WebSize&) { } + + // The main frame scrolled. + virtual void didChangeScrollOffset(WebFrame*) { } + + + // Find-in-page notifications ------------------------------------------ + + // Notifies how many matches have been found so far, for a given + // identifier. |finalUpdate| specifies whether this is the last update + // (all frames have completed scoping). + virtual void reportFindInPageMatchCount( + int identifier, int count, bool finalUpdate) { } + + // Notifies what tick-mark rect is currently selected. The given + // identifier lets the client know which request this message belongs + // to, so that it can choose to ignore the message if it has moved on + // to other things. The selection rect is expected to have coordinates + // relative to the top left corner of the web page area and represent + // where on the screen the selection rect is currently located. + virtual void reportFindInPageSelection( + int identifier, int activeMatchOrdinal, const WebRect& selection) { } + +protected: + ~WebFrameClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebHTTPBody.h b/WebKit/chromium/public/WebHTTPBody.h new file mode 100644 index 0000000..43f51a6 --- /dev/null +++ b/WebKit/chromium/public/WebHTTPBody.h @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebHTTPBody_h +#define WebHTTPBody_h + +#include "WebData.h" +#include "WebNonCopyable.h" +#include "WebString.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class FormData; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebHTTPBodyPrivate; + +class WebHTTPBody { +public: + struct Element { + enum { TypeData, TypeFile } type; + WebData data; + WebString filePath; + }; + + ~WebHTTPBody() { reset(); } + + WebHTTPBody() : m_private(0) { } + WebHTTPBody(const WebHTTPBody& b) : m_private(0) { assign(b); } + WebHTTPBody& operator=(const WebHTTPBody& b) + { + assign(b); + return *this; + } + + WEBKIT_API void initialize(); + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebHTTPBody&); + + bool isNull() const { return !m_private; } + + // Returns the number of elements comprising the http body. + WEBKIT_API size_t elementCount() const; + + // Sets the values of the element at the given index. Returns false if + // index is out of bounds. + WEBKIT_API bool elementAt(size_t index, Element&) const; + + // Append to the list of elements. + WEBKIT_API void appendData(const WebData&); + WEBKIT_API void appendFile(const WebString&); + + // Identifies a particular form submission instance. A value of 0 is + // used to indicate an unspecified identifier. + WEBKIT_API long long identifier() const; + WEBKIT_API void setIdentifier(long long); + +#if WEBKIT_IMPLEMENTATION + WebHTTPBody(const WTF::PassRefPtr<WebCore::FormData>&); + WebHTTPBody& operator=(const WTF::PassRefPtr<WebCore::FormData>&); + operator WTF::PassRefPtr<WebCore::FormData>() const; +#endif + +private: + void assign(WebHTTPBodyPrivate*); + void ensureMutable(); + WebHTTPBodyPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebHTTPHeaderVisitor.h b/WebKit/chromium/public/WebHTTPHeaderVisitor.h new file mode 100644 index 0000000..2ca86c0 --- /dev/null +++ b/WebKit/chromium/public/WebHTTPHeaderVisitor.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebHTTPHeaderVisitor_h +#define WebHTTPHeaderVisitor_h + +namespace WebKit { + +class WebString; + +class WebHTTPHeaderVisitor { +public: + virtual void visitHeader(const WebString& name, const WebString& value) = 0; + +protected: + ~WebHTTPHeaderVisitor() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebHistoryItem.h b/WebKit/chromium/public/WebHistoryItem.h new file mode 100644 index 0000000..f15a62c --- /dev/null +++ b/WebKit/chromium/public/WebHistoryItem.h @@ -0,0 +1,132 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebHistoryItem_h +#define WebHistoryItem_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class HistoryItem; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebHistoryItemPrivate; +class WebHTTPBody; +class WebString; +struct WebPoint; +template <typename T> class WebVector; + +// Represents a frame-level navigation entry in session history. A +// WebHistoryItem is a node in a tree. +// +// Copying a WebHistoryItem is cheap. +// +class WebHistoryItem { +public: + ~WebHistoryItem() { reset(); } + + WebHistoryItem() : m_private(0) { } + WebHistoryItem(const WebHistoryItem& h) : m_private(0) { assign(h); } + WebHistoryItem& operator=(const WebHistoryItem& h) + { + assign(h); + return *this; + } + + WEBKIT_API void initialize(); + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebHistoryItem&); + + bool isNull() const { return !m_private; } + + WEBKIT_API WebString urlString() const; + WEBKIT_API void setURLString(const WebString&); + + WEBKIT_API WebString originalURLString() const; + WEBKIT_API void setOriginalURLString(const WebString&); + + WEBKIT_API WebString referrer() const; + WEBKIT_API void setReferrer(const WebString&); + + WEBKIT_API WebString target() const; + WEBKIT_API void setTarget(const WebString&); + + WEBKIT_API WebString parent() const; + WEBKIT_API void setParent(const WebString&); + + WEBKIT_API WebString title() const; + WEBKIT_API void setTitle(const WebString&); + + WEBKIT_API WebString alternateTitle() const; + WEBKIT_API void setAlternateTitle(const WebString&); + + WEBKIT_API double lastVisitedTime() const; + WEBKIT_API void setLastVisitedTime(double); + + WEBKIT_API WebPoint scrollOffset() const; + WEBKIT_API void setScrollOffset(const WebPoint&); + + WEBKIT_API bool isTargetItem() const; + WEBKIT_API void setIsTargetItem(bool); + + WEBKIT_API int visitCount() const; + WEBKIT_API void setVisitCount(int); + + WEBKIT_API WebVector<WebString> documentState() const; + WEBKIT_API void setDocumentState(const WebVector<WebString>&); + + WEBKIT_API WebString httpContentType() const; + WEBKIT_API void setHTTPContentType(const WebString&); + + WEBKIT_API WebHTTPBody httpBody() const; + WEBKIT_API void setHTTPBody(const WebHTTPBody&); + + WEBKIT_API WebVector<WebHistoryItem> children() const; + WEBKIT_API void setChildren(const WebVector<WebHistoryItem>&); + WEBKIT_API void appendToChildren(const WebHistoryItem&); + +#if WEBKIT_IMPLEMENTATION + WebHistoryItem(const WTF::PassRefPtr<WebCore::HistoryItem>&); + WebHistoryItem& operator=(const WTF::PassRefPtr<WebCore::HistoryItem>&); + operator WTF::PassRefPtr<WebCore::HistoryItem>() const; +#endif + +private: + void assign(WebHistoryItemPrivate*); + void ensureMutable(); + WebHistoryItemPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebImage.h b/WebKit/chromium/public/WebImage.h new file mode 100644 index 0000000..a7b6f8c --- /dev/null +++ b/WebKit/chromium/public/WebImage.h @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebImage_h +#define WebImage_h + +#include "WebCommon.h" + +#if WEBKIT_USING_SKIA +#include <SkBitmap.h> +#elif WEBKIT_USING_CG +typedef struct CGImage* CGImageRef; +#endif + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Image; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebData; +struct WebSize; + +// A container for an ARGB bitmap. +class WebImage { +public: + ~WebImage() { reset(); } + + WebImage() { init(); } + WebImage(const WebImage& image) + { + init(); + assign(image); + } + + WebImage& operator=(const WebImage& image) + { + assign(image); + return *this; + } + + // Decodes the given image data. If the image has multiple frames, + // then the frame whose size is desiredSize is returned. Otherwise, + // the first frame is returned. + WEBKIT_API static WebImage fromData(const WebData&, const WebSize& desiredSize); + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebImage&); + + WEBKIT_API bool isNull() const; + WEBKIT_API WebSize size() const; + +#if WEBKIT_IMPLEMENTATION + WebImage(const WTF::PassRefPtr<WebCore::Image>&); + WebImage& operator=(const WTF::PassRefPtr<WebCore::Image>&); +#endif + +#if WEBKIT_USING_SKIA + WebImage(const SkBitmap& bitmap) : m_bitmap(bitmap) { } + + WebImage& operator=(const SkBitmap& bitmap) + { + m_bitmap = bitmap; + return *this; + } + + SkBitmap& getSkBitmap() { return m_bitmap; } + const SkBitmap& getSkBitmap() const { return m_bitmap; } + +private: + void init() { } + SkBitmap m_bitmap; + +#elif WEBKIT_USING_CG + WebImage(CGImageRef imageRef) + { + init(); + assign(imageRef); + } + + WebImage& operator=(CGImageRef imageRef) + { + assign(imageRef); + return *this; + } + + CGImageRef getCGImageRef() const { return m_imageRef; } + +private: + void init() { m_imageRef = 0; } + void assign(CGImageRef); + CGImageRef m_imageRef; +#endif +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebInputElement.h b/WebKit/chromium/public/WebInputElement.h new file mode 100644 index 0000000..75e44b9 --- /dev/null +++ b/WebKit/chromium/public/WebInputElement.h @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebInputElement_h +#define WebInputElement_h + +#include "WebElement.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class HTMLInputElement; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + + // Provides readonly access to some properties of a DOM input element node. + class WebInputElement : public WebElement { + public: + WebInputElement() : WebElement() { } + WebInputElement(const WebInputElement& n) : WebElement(n) { } + + WebInputElement& operator=(const WebInputElement& n) { WebElement::assign(n); return *this; } + WEBKIT_API void assign(const WebInputElement& n) { WebElement::assign(n); } + +#if WEBKIT_IMPLEMENTATION + WebInputElement(const WTF::PassRefPtr<WebCore::HTMLInputElement>&); + WebInputElement& operator=(const WTF::PassRefPtr<WebCore::HTMLInputElement>&); + operator WTF::PassRefPtr<WebCore::HTMLInputElement>() const; +#endif + + enum InputType { + Text = 0, + Password, + IsIndex, + CheckBox, + Radio, + Submit, + Reset, + File, + Hidden, + Image, + Button, + Search, + Range, + Email, + Number, + Telephone, + URL, + Color, + Date, + DateTime, + DateTimeLocal, + Month, + Time, + Week + }; + + WEBKIT_API bool isEnabledFormControl() const; + WEBKIT_API InputType inputType() const; + WEBKIT_API WebString formControlType() const; + WEBKIT_API void setActivatedSubmit(bool); + WEBKIT_API void setValue(const WebString& value); + WEBKIT_API WebString value() const; + WEBKIT_API void setAutofilled(bool); + WEBKIT_API void dispatchFormControlChangeEvent(); + WEBKIT_API void setSelectionRange(int, int); + WEBKIT_API WebString name() const; + // Returns the name that should be used for the specified |element| when + // storing autofill data. This is either the field name or its id, an empty + // string if it has no name and no id. + WEBKIT_API WebString nameForAutofill() const; + + }; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebInputEvent.h b/WebKit/chromium/public/WebInputEvent.h new file mode 100644 index 0000000..983aa2a --- /dev/null +++ b/WebKit/chromium/public/WebInputEvent.h @@ -0,0 +1,260 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebInputEvent_h +#define WebInputEvent_h + +#include "WebCommon.h" + +#include <string.h> + +namespace WebKit { + +// The classes defined in this file are intended to be used with +// WebWidget's handleInputEvent method. These event types are cross- +// platform and correspond closely to WebCore's Platform*Event classes. +// +// WARNING! These classes must remain PODs (plain old data). They are +// intended to be "serializable" by copying their raw bytes, so they must +// not contain any non-bit-copyable member variables! + +// WebInputEvent -------------------------------------------------------------- + +class WebInputEvent { +public: + WebInputEvent(unsigned sizeParam = sizeof(WebInputEvent)) + : size(sizeParam) + , type(Undefined) + , modifiers(0) + , timeStampSeconds(0.0) { } + + // When we use an input method (or an input method editor), we receive + // two events for a keypress. The former event is a keydown, which + // provides a keycode, and the latter is a textinput, which provides + // a character processed by an input method. (The mapping from a + // keycode to a character code is not trivial for non-English + // keyboards.) + // To support input methods, Safari sends keydown events to WebKit for + // filtering. WebKit sends filtered keydown events back to Safari, + // which sends them to input methods. + // Unfortunately, it is hard to apply this design to Chrome because of + // our multiprocess architecture. An input method is running in a + // browser process. On the other hand, WebKit is running in a renderer + // process. So, this design results in increasing IPC messages. + // To support input methods without increasing IPC messages, Chrome + // handles keyboard events in a browser process and send asynchronous + // input events (to be translated to DOM events) to a renderer + // process. + // This design is mostly the same as the one of Windows and Mac Carbon. + // So, for what it's worth, our Linux and Mac front-ends emulate our + // Windows front-end. To emulate our Windows front-end, we can share + // our back-end code among Windows, Linux, and Mac. + // TODO(hbono): Issue 18064: remove the KeyDown type since it isn't + // used in Chrome any longer. + + enum Type { + Undefined = -1, + + // WebMouseEvent + MouseDown, + MouseUp, + MouseMove, + MouseEnter, + MouseLeave, + + // WebMouseWheelEvent + MouseWheel, + + // WebKeyboardEvent + RawKeyDown, + KeyDown, + KeyUp, + Char + }; + + enum Modifiers { + // modifiers for all events: + ShiftKey = 1 << 0, + ControlKey = 1 << 1, + AltKey = 1 << 2, + MetaKey = 1 << 3, + + // modifiers for keyboard events: + IsKeyPad = 1 << 4, + IsAutoRepeat = 1 << 5, + + // modifiers for mouse events: + LeftButtonDown = 1 << 6, + MiddleButtonDown = 1 << 7, + RightButtonDown = 1 << 8, + }; + + unsigned size; // The size of this structure, for serialization. + Type type; + int modifiers; + double timeStampSeconds; // Seconds since epoch. + + // Returns true if the WebInputEvent |type| is a keyboard event. + static bool isKeyboardEventType(int type) + { + return type == RawKeyDown + || type == KeyDown + || type == KeyUp + || type == Char; + } +}; + +// WebKeyboardEvent ----------------------------------------------------------- + +class WebKeyboardEvent : public WebInputEvent { +public: + // Caps on string lengths so we can make them static arrays and keep + // them PODs. + static const size_t textLengthCap = 4; + + // http://www.w3.org/TR/DOM-Level-3-Events/keyset.html lists the + // identifiers. The longest is 18 characters, so we round up to the + // next multiple of 4. + static const size_t keyIdentifierLengthCap = 20; + + // |windowsKeyCode| is the Windows key code associated with this key + // event. Sometimes it's direct from the event (i.e. on Windows), + // sometimes it's via a mapping function. If you want a list, see + // WebCore/platform/chromium/KeyboardCodes* . + int windowsKeyCode; + + // The actual key code genenerated by the platform. The DOM spec runs + // on Windows-equivalent codes (thus |windowsKeyCode| above) but it + // doesn't hurt to have this one around. + int nativeKeyCode; + + // |text| is the text generated by this keystroke. |unmodifiedText| is + // |text|, but unmodified by an concurrently-held modifiers (except + // shift). This is useful for working out shortcut keys. Linux and + // Windows guarantee one character per event. The Mac does not, but in + // reality that's all it ever gives. We're generous, and cap it a bit + // longer. + WebUChar text[textLengthCap]; + WebUChar unmodifiedText[textLengthCap]; + + // This is a string identifying the key pressed. + char keyIdentifier[keyIdentifierLengthCap]; + + // This identifies whether this event was tagged by the system as being + // a "system key" event (see + // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for + // details). Other platforms don't have this concept, but it's just + // easier to leave it always false than ifdef. + // int is used instead of bool to ensure the size of this structure is + // strictly aligned to a factor of 4 bytes, otherwise memory check tools + // like valgrind may complain about uninitialized memory usage when + // transfering it over the wire. + int isSystemKey; + + WebKeyboardEvent(unsigned sizeParam = sizeof(WebKeyboardEvent)) + : WebInputEvent(sizeParam) + , windowsKeyCode(0) + , nativeKeyCode(0) + , isSystemKey(false) + { + memset(&text, 0, sizeof(text)); + memset(&unmodifiedText, 0, sizeof(unmodifiedText)); + memset(&keyIdentifier, 0, sizeof(keyIdentifier)); + } + + // Sets keyIdentifier based on the value of windowsKeyCode. This is + // handy for generating synthetic keyboard events. + WEBKIT_API void setKeyIdentifierFromWindowsKeyCode(); +}; + +// WebMouseEvent -------------------------------------------------------------- + +class WebMouseEvent : public WebInputEvent { +public: + // These values defined for WebCore::MouseButton + enum Button { + ButtonNone = -1, + ButtonLeft, + ButtonMiddle, + ButtonRight + }; + + Button button; + int x; + int y; + int windowX; + int windowY; + int globalX; + int globalY; + int clickCount; + + WebMouseEvent(unsigned sizeParam = sizeof(WebMouseEvent)) + : WebInputEvent(sizeParam) + , button(ButtonNone) + , x(0) + , y(0) + , windowX(0) + , windowY(0) + , globalX(0) + , globalY(0) + , clickCount(0) + { + } +}; + +// WebMouseWheelEvent --------------------------------------------------------- + +class WebMouseWheelEvent : public WebMouseEvent { +public: + float deltaX; + float deltaY; + float wheelTicksX; + float wheelTicksY; + + // int is used instead of bool to ensure the size of this structure is + // strictly aligned to a factor of 4 bytes, otherwise memory check tools + // like valgrind may complain about uninitialized memory usage when + // transfering it over the wire. + int scrollByPage; + + WebMouseWheelEvent(unsigned sizeParam = sizeof(WebMouseWheelEvent)) + : WebMouseEvent(sizeParam) + , deltaX(0.0f) + , deltaY(0.0f) + , wheelTicksX(0.0f) + , wheelTicksY(0.0f) + , scrollByPage(false) + { + } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebKit.h b/WebKit/chromium/public/WebKit.h new file mode 100644 index 0000000..b9e6407 --- /dev/null +++ b/WebKit/chromium/public/WebKit.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebKit_h +#define WebKit_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebKitClient; + +// Must be called on the thread that will be the main WebKit thread before +// using any other WebKit APIs. The provided WebKitClient must be non-null +// and must remain valid until the current thread calls shutdown. +WEBKIT_API void initialize(WebKitClient*); + +// Once shutdown, the WebKitClient passed to initialize will no longer be +// accessed. No other WebKit objects should be in use when this function +// is called. Any background threads created by WebKit are promised to be +// terminated by the time this function returns. +WEBKIT_API void shutdown(); + +// Returns the WebKitClient instance passed to initialize. +WEBKIT_API WebKitClient* webKitClient(); + +// Alters the rendering of content to conform to a fixed set of rules. +WEBKIT_API void setLayoutTestMode(bool); +WEBKIT_API bool layoutTestMode(); + +// Purge the plugin list cache. If |reloadPages| is true, any pages +// containing plugins will be reloaded after refreshing the plugin list. +WEBKIT_API void resetPluginCache(bool reloadPages); + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebKitClient.h b/WebKit/chromium/public/WebKitClient.h new file mode 100644 index 0000000..2a00a9a --- /dev/null +++ b/WebKit/chromium/public/WebKitClient.h @@ -0,0 +1,277 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebKitClient_h +#define WebKitClient_h + +#include "WebCommon.h" +#include "WebData.h" +#include "WebLocalizedString.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebVector.h" + +#include <time.h> + +#ifdef WIN32 +typedef void *HANDLE; +#endif + +namespace WebKit { + +class WebApplicationCacheHost; +class WebApplicationCacheHostClient; +class WebClipboard; +class WebMessagePortChannel; +class WebMimeRegistry; +class WebPluginListBuilder; +class WebSandboxSupport; +class WebSharedWorkerRepository; +class WebSocketStreamHandle; +class WebStorageNamespace; +class WebThemeEngine; +class WebURLLoader; +struct WebCookie; +struct WebPluginInfo; +template <typename T> class WebVector; + +class WebKitClient { +public: + // Must return non-null. + virtual WebClipboard* clipboard() { return 0; } + + // Must return non-null. + virtual WebMimeRegistry* mimeRegistry() { return 0; } + + // May return null if sandbox support is not necessary + virtual WebSandboxSupport* sandboxSupport() { return 0; } + + // May return null on some platforms. + virtual WebThemeEngine* themeEngine() { return 0; } + + + // Application Cache -------------------------------------------- + + // May return null if the process type doesn't involve appcaching. + virtual WebApplicationCacheHost* createApplicationCacheHost(WebApplicationCacheHostClient*) { return 0; } + + + // DOM Storage -------------------------------------------------- + + // Return a LocalStorage namespace that corresponds to the following path. + virtual WebStorageNamespace* createLocalStorageNamespace(const WebString& path, unsigned quota) { return 0; } + + // Return a new SessionStorage namespace. + virtual WebStorageNamespace* createSessionStorageNamespace() { return 0; } + + // Called when storage events fire. + virtual void dispatchStorageEvent(const WebString& key, const WebString& oldValue, + const WebString& newValue, const WebString& origin, + const WebURL& url, bool isLocalStorage) { } + + + // File ---------------------------------------------------------------- + + // Various file/directory related functions. These map 1:1 with + // functions in WebCore's FileSystem.h. + virtual bool fileExists(const WebString& path) { return false; } + virtual bool deleteFile(const WebString& path) { return false; } + virtual bool deleteEmptyDirectory(const WebString& path) { return false; } + virtual bool getFileSize(const WebString& path, long long& result) { return false; } + virtual bool getFileModificationTime(const WebString& path, time_t& result) { return false; } + virtual WebString directoryName(const WebString& path) { return WebString(); } + virtual WebString pathByAppendingComponent(const WebString& path, const WebString& component) { return WebString(); } + virtual bool makeAllDirectories(const WebString& path) { return false; } + virtual WebString getAbsolutePath(const WebString& path) { return WebString(); } + virtual bool isDirectory(const WebString& path) { return false; } + virtual WebURL filePathToURL(const WebString& path) { return WebURL(); } + + + // History ------------------------------------------------------------- + + // Returns the hash for the given canonicalized URL for use in visited + // link coloring. + virtual unsigned long long visitedLinkHash( + const char* canonicalURL, size_t length) { return 0; } + + // Returns whether the given link hash is in the user's history. The + // hash must have been generated by calling VisitedLinkHash(). + virtual bool isLinkVisited(unsigned long long linkHash) { return false; } + + + // Database ------------------------------------------------------------ + +#ifdef WIN32 + typedef HANDLE FileHandle; +#else + typedef int FileHandle; +#endif + + // Opens a database file; dirHandle should be 0 if the caller does not need + // a handle to the directory containing this file + virtual FileHandle databaseOpenFile( + const WebString& vfsFileName, int desiredFlags, FileHandle* dirHandle) { return FileHandle(); } + + // Deletes a database file and returns the error code + virtual int databaseDeleteFile(const WebString& vfsFileName, bool syncDir) { return 0; } + + // Returns the attributes of the given database file + virtual long databaseGetFileAttributes(const WebString& vfsFileName) { return 0; } + + // Returns the size of the given database file + virtual long long databaseGetFileSize(const WebString& vfsFileName) { return 0; } + + + // Keygen -------------------------------------------------------------- + + // Handle the <keygen> tag for generating client certificates + // Returns a base64 encoded signed copy of a public key from a newly + // generated key pair and the supplied challenge string. keySizeindex + // specifies the strength of the key. + virtual WebString signedPublicKeyAndChallengeString(unsigned keySizeIndex, + const WebKit::WebString& challenge, + const WebKit::WebURL& url) { return WebString(); } + + + + // Memory -------------------------------------------------------------- + + // Returns the current space allocated for the pagefile, in MB. + // That is committed size for Windows and virtual memory size for POSIX + virtual size_t memoryUsageMB() { return 0; } + + + // Message Ports ------------------------------------------------------- + + // Creates a Message Port Channel. This can be called on any thread. + // The returned object should only be used on the thread it was created on. + virtual WebMessagePortChannel* createMessagePortChannel() { return 0; } + + + // Network ------------------------------------------------------------- + + virtual void setCookies( + const WebURL& url, const WebURL& policyURL, const WebString& cookies) { } + virtual WebString cookies(const WebURL& url, const WebURL& policyURL) { return WebString(); } + virtual bool rawCookies(const WebURL& url, const WebURL& policyURL, WebVector<WebCookie>*) { return false; } + virtual void deleteCookie(const WebURL& url, const WebString& cookieName) { } + + // A suggestion to prefetch IP information for the given hostname. + virtual void prefetchHostName(const WebString&) { } + + // Returns a new WebURLLoader instance. + virtual WebURLLoader* createURLLoader() { return 0; } + + // Returns a new WebSocketStreamHandle instance. + virtual WebSocketStreamHandle* createSocketStreamHandle() { return 0; } + + // Returns the User-Agent string that should be used for the given URL. + virtual WebString userAgent(const WebURL&) { return WebString(); } + + + // Plugins ------------------------------------------------------------- + + // If refresh is true, then cached information should not be used to + // satisfy this call. + virtual void getPluginList(bool refresh, WebPluginListBuilder*) { }; + + + // Profiling ----------------------------------------------------------- + + virtual void decrementStatsCounter(const char* name) { }; + virtual void incrementStatsCounter(const char* name) { }; + + // An event is identified by the pair (name, id). The extra parameter + // specifies additional data to log with the event. + virtual void traceEventBegin(const char* name, void* id, const char* extra) { }; + virtual void traceEventEnd(const char* name, void* id, const char* extra) { }; + + // Generic callback for reporting histogram data. Range is identified by the min, max pair. + // By default, histogram is exponential, so that min=1, max=1000000, bucketCount=50 would do. Setting + // linear to true would require bucket count to cover whole min-max range. + virtual void histogramCounts(const WebString& name, int sample, int min, int max, int bucketCount, bool linear) { }; + + + // Resources ----------------------------------------------------------- + + // Returns a blob of data corresponding to the named resource. + virtual WebData loadResource(const char* name) { return WebData(); } + + // Returns a localized string resource (with an optional numeric + // parameter value). + virtual WebString queryLocalizedString(WebLocalizedString::Name) { return WebString(); } + virtual WebString queryLocalizedString(WebLocalizedString::Name, int numericValue) { return WebString(); } + + + // Sandbox ------------------------------------------------------------ + + // In some browsers, a "sandbox" restricts what operations a program + // is allowed to preform. Such operations are typically abstracted out + // via this API, but sometimes (like in HTML 5 database opening) WebKit + // needs to behave differently based on whether it's restricted or not. + // In these cases (and these cases only) you can call this function. + // It's OK for this value to be conservitive (i.e. true even if the + // sandbox isn't active). + virtual bool sandboxEnabled() { return false; } + + + // Shared Workers ------------------------------------------------------ + + virtual WebSharedWorkerRepository* sharedWorkerRepository() { return 0; } + + // Sudden Termination -------------------------------------------------- + + // Disable/Enable sudden termination. + virtual void suddenTerminationChanged(bool enabled) { } + + + // System -------------------------------------------------------------- + + // Returns a value such as "en-US". + virtual WebString defaultLocale() { return WebString(); } + + // Wall clock time in seconds since the epoch. + virtual double currentTime() { return 0; } + + // Delayed work is driven by a shared timer. + virtual void setSharedTimerFiredFunction(void (*func)()) { } + virtual void setSharedTimerFireTime(double fireTime) { } + virtual void stopSharedTimer() { } + + // Callable from a background WebKit thread. + virtual void callOnMainThread(void (*func)()) { } + +protected: + ~WebKitClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebLocalizedString.h b/WebKit/chromium/public/WebLocalizedString.h new file mode 100644 index 0000000..99a7d23 --- /dev/null +++ b/WebKit/chromium/public/WebLocalizedString.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebLocalizedString_h +#define WebLocalizedString_h + +namespace WebKit { + +struct WebLocalizedString { + enum Name { + SubmitButtonDefaultLabel, + InputElementAltText, + ResetButtonDefaultLabel, + FileButtonChooseFileLabel, + FileButtonNoFileSelectedLabel, + MultipleFileUploadText, + SearchableIndexIntroduction, + SearchMenuNoRecentSearchesText, + SearchMenuRecentSearchesText, + SearchMenuClearRecentSearchesText, + AXWebAreaText, + AXLinkText, + AXListMarkerText, + AXImageMapText, + AXHeadingText, + AXButtonActionVerb, + AXRadioButtonActionVerb, + AXTextFieldActionVerb, + AXCheckedCheckBoxActionVerb, + AXUncheckedCheckBoxActionVerb, + AXLinkActionVerb, + KeygenMenuHighGradeKeySize, + KeygenMenuMediumGradeKeySize, + }; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebMediaPlayer.h b/WebKit/chromium/public/WebMediaPlayer.h new file mode 100644 index 0000000..0b658f9 --- /dev/null +++ b/WebKit/chromium/public/WebMediaPlayer.h @@ -0,0 +1,134 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebMediaPlayer_h +#define WebMediaPlayer_h + +#include "WebCanvas.h" +#include "WebVector.h" + +namespace WebKit { + +class WebMediaPlayerClient; +class WebURL; +struct WebRect; +struct WebSize; + +struct WebTimeRange { + WebTimeRange() : start(0), end(0) {} + WebTimeRange(float s, float e) : start(s), end(e) {} + + float start; + float end; +}; + +typedef WebVector<WebTimeRange> WebTimeRanges; + +class WebMediaPlayer { +public: + enum NetworkState { + Empty, + Idle, + Loading, + Loaded, + FormatError, + NetworkError, + DecodeError, + }; + + enum ReadyState { + HaveNothing, + HaveMetadata, + HaveCurrentData, + HaveFutureData, + HaveEnoughData, + }; + + enum MovieLoadType { + Unknown, + Download, + StoredStream, + LiveStream, + }; + + virtual ~WebMediaPlayer() {} + + virtual void load(const WebURL&) = 0; + virtual void cancelLoad() = 0; + + // Playback controls. + virtual void play() = 0; + virtual void pause() = 0; + virtual bool supportsFullscreen() const = 0; + virtual bool supportsSave() const = 0; + virtual void seek(float seconds) = 0; + virtual void setEndTime(float seconds) = 0; + virtual void setRate(float) = 0; + virtual void setVolume(float) = 0; + virtual void setVisible(bool) = 0; + virtual bool setAutoBuffer(bool) = 0; + virtual bool totalBytesKnown() = 0; + virtual const WebTimeRanges& buffered() const = 0; + virtual float maxTimeSeekable() const = 0; + + virtual void setSize(const WebSize&) = 0; + + virtual void paint(WebCanvas*, const WebRect&) = 0; + + // True if the loaded media has a playable video/audio track. + virtual bool hasVideo() const = 0; + virtual bool hasAudio() const = 0; + + // Dimension of the video. + virtual WebSize naturalSize() const = 0; + + // Getters of playback state. + virtual bool paused() const = 0; + virtual bool seeking() const = 0; + virtual float duration() const = 0; + virtual float currentTime() const = 0; + + // Get rate of loading the resource. + virtual int dataRate() const = 0; + + // Internal states of loading and network. + virtual NetworkState networkState() const = 0; + virtual ReadyState readyState() const = 0; + + virtual unsigned long long bytesLoaded() const = 0; + virtual unsigned long long totalBytes() const = 0; + + virtual bool hasSingleSecurityOrigin() const = 0; + virtual MovieLoadType movieLoadType() const = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebMediaPlayerAction.h b/WebKit/chromium/public/WebMediaPlayerAction.h new file mode 100644 index 0000000..3aede25 --- /dev/null +++ b/WebKit/chromium/public/WebMediaPlayerAction.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebMediaPlayerAction_h +#define WebMediaPlayerAction_h + +namespace WebKit { + +struct WebMediaPlayerAction { + enum Type { + Unknown, + Play, + Mute, + Loop + }; + + Type type; + bool enable; + + WebMediaPlayerAction() + : type(Unknown), enable(false) { } + WebMediaPlayerAction(Type type, bool enable) + : type(type), enable(enable) { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebMediaPlayerClient.h b/WebKit/chromium/public/WebMediaPlayerClient.h new file mode 100644 index 0000000..558fb4a --- /dev/null +++ b/WebKit/chromium/public/WebMediaPlayerClient.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebMediaPlayerClient_h +#define WebMediaPlayerClient_h + +namespace WebKit { + +class WebRequest; +class WebURL; + +class WebMediaPlayerClient { +public: + virtual void networkStateChanged() = 0; + virtual void readyStateChanged() = 0; + virtual void volumeChanged() = 0; + virtual void timeChanged() = 0; + virtual void repaint() = 0; + virtual void durationChanged() = 0; + virtual void rateChanged() = 0; + virtual void sizeChanged() = 0; + virtual void sawUnsupportedTracks() = 0; + +protected: + ~WebMediaPlayerClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebMenuItemInfo.h b/WebKit/chromium/public/WebMenuItemInfo.h new file mode 100644 index 0000000..d513e66 --- /dev/null +++ b/WebKit/chromium/public/WebMenuItemInfo.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebMenuItemInfo_h +#define WebMenuItemInfo_h + +#include "WebCommon.h" +#include "WebString.h" +#include "WebVector.h" + +namespace WebKit { + +struct WebMenuItemInfo { + enum Type { + Option, + CheckableOption, + Group, + Separator, + }; + WebString label; + Type type; + unsigned action; + bool enabled; + bool checked; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebMessagePortChannel.h b/WebKit/chromium/public/WebMessagePortChannel.h new file mode 100644 index 0000000..288bd55 --- /dev/null +++ b/WebKit/chromium/public/WebMessagePortChannel.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebMessagePortChannel_h +#define WebMessagePortChannel_h + +#include "WebCommon.h" +#include "WebVector.h" + +namespace WebKit { + +class WebMessagePortChannelClient; +class WebString; + +typedef WebVector<class WebMessagePortChannel*> WebMessagePortChannelArray; + +// Provides an interface to a Message Port Channel implementation. The object owns itself and +// is signalled that its not needed anymore with the destroy() call. +class WebMessagePortChannel { +public: + virtual void setClient(WebMessagePortChannelClient*) = 0; + virtual void destroy() = 0; + // WebKit versions of WebCore::MessagePortChannel. + virtual void entangle(WebMessagePortChannel*) = 0; + // Callee receives ownership of the passed vector. + virtual void postMessage(const WebString&, WebMessagePortChannelArray*) = 0; + virtual bool tryGetMessage(WebString*, WebMessagePortChannelArray&) = 0; + +protected: + ~WebMessagePortChannel() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebMessagePortChannelClient.h b/WebKit/chromium/public/WebMessagePortChannelClient.h new file mode 100644 index 0000000..0b85bb3 --- /dev/null +++ b/WebKit/chromium/public/WebMessagePortChannelClient.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebMessagePortChannelClient_h +#define WebMessagePortChannelClient_h + +namespace WebKit { + +// Provides an interface for users of WebMessagePortChannel to be notified +// when messages are available. +class WebMessagePortChannelClient { +public: + // Alerts that new messages have arrived, which are retrieved by calling + // WebMessagePortChannel::tryGetMessage. Note that this may be called + // on any thread. + virtual void messageAvailable() = 0; + +protected: + ~WebMessagePortChannelClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebMimeRegistry.h b/WebKit/chromium/public/WebMimeRegistry.h new file mode 100644 index 0000000..425753e --- /dev/null +++ b/WebKit/chromium/public/WebMimeRegistry.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebMimeRegistry_h +#define WebMimeRegistry_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebString; + +class WebMimeRegistry { +public: + enum SupportsType { IsNotSupported, IsSupported, MayBeSupported }; + + virtual SupportsType supportsMIMEType(const WebString& mimeType) = 0; + virtual SupportsType supportsImageMIMEType(const WebString& mimeType) = 0; + virtual SupportsType supportsJavaScriptMIMEType(const WebString& mimeType) = 0; + virtual SupportsType supportsMediaMIMEType(const WebString& mimeType, + const WebString& codecs) = 0; + virtual SupportsType supportsNonImageMIMEType(const WebString& mimeType) = 0; + + virtual WebString mimeTypeForExtension(const WebString& fileExtension) = 0; + virtual WebString mimeTypeFromFile(const WebString& filePath) = 0; + virtual WebString preferredExtensionForMIMEType(const WebString& mimeType) = 0; + +protected: + ~WebMimeRegistry() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebNavigationPolicy.h b/WebKit/chromium/public/WebNavigationPolicy.h new file mode 100644 index 0000000..54bee9d --- /dev/null +++ b/WebKit/chromium/public/WebNavigationPolicy.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebNavigationPolicy_h +#define WebNavigationPolicy_h + +namespace WebKit { + +enum WebNavigationPolicy { + WebNavigationPolicyIgnore, + WebNavigationPolicyDownload, + WebNavigationPolicyCurrentTab, + WebNavigationPolicyNewBackgroundTab, + WebNavigationPolicyNewForegroundTab, + WebNavigationPolicyNewWindow, + WebNavigationPolicyNewPopup, +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebNavigationType.h b/WebKit/chromium/public/WebNavigationType.h new file mode 100644 index 0000000..8ca8dc6 --- /dev/null +++ b/WebKit/chromium/public/WebNavigationType.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebNavigationType_h +#define WebNavigationType_h + +namespace WebKit { + +enum WebNavigationType { + WebNavigationTypeLinkClicked, + WebNavigationTypeFormSubmitted, + WebNavigationTypeBackForward, + WebNavigationTypeReload, + WebNavigationTypeFormResubmitted, + WebNavigationTypeOther +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebNode.h b/WebKit/chromium/public/WebNode.h new file mode 100644 index 0000000..03afa90 --- /dev/null +++ b/WebKit/chromium/public/WebNode.h @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebNode_h +#define WebNode_h + +#include "WebCommon.h" +#include "WebString.h" + +namespace WebCore { class Node; } +#if WEBKIT_IMPLEMENTATION +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { +class WebFrame; + +// Provides readonly access to some properties of a DOM node. +class WebNode { +public: + virtual ~WebNode() { reset(); } + + WebNode() : m_private(0) { } + WebNode(const WebNode& n) : m_private(0) { assign(n); } + WebNode& operator=(const WebNode& n) + { + assign(n); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebNode&); + + bool isNull() const { return !m_private; } + +#if WEBKIT_IMPLEMENTATION + WebNode(const WTF::PassRefPtr<WebCore::Node>&); + WebNode& operator=(const WTF::PassRefPtr<WebCore::Node>&); + operator WTF::PassRefPtr<WebCore::Node>() const; +#endif + + WEBKIT_API WebNode parentNode() const; + WEBKIT_API WebString nodeName() const; + WEBKIT_API WebFrame* frame() const; + + template<typename T> T toElement() + { + T res; + res.m_private = m_private; + return res; + } + +protected: + typedef WebCore::Node WebNodePrivate; + void assign(WebNodePrivate*); + WebNodePrivate* m_private; + + template<typename T> T* unwrap() + { + return static_cast<T*>(m_private); + } + + template<typename T> const T* constUnwrap() const + { + return static_cast<const T*>(m_private); + } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebNonCopyable.h b/WebKit/chromium/public/WebNonCopyable.h new file mode 100644 index 0000000..b0bd456 --- /dev/null +++ b/WebKit/chromium/public/WebNonCopyable.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebNonCopyable_h +#define WebNonCopyable_h + +namespace WebKit { + +// A base class to extend from if you do not support copying. +class WebNonCopyable { +protected: + WebNonCopyable() { } + ~WebNonCopyable() { } + +private: + WebNonCopyable(const WebNonCopyable&); + WebNonCopyable& operator=(const WebNonCopyable&); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebNotification.h b/WebKit/chromium/public/WebNotification.h new file mode 100644 index 0000000..1a41252 --- /dev/null +++ b/WebKit/chromium/public/WebNotification.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebNotification_h +#define WebNotification_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Notification; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebNotificationPrivate; +class WebURL; +class WebString; + +// Represents access to a desktop notification. +class WebNotification { +public: + WebNotification() : m_private(0) { } + WebNotification(const WebNotification& other) : m_private(0) { assign(other); } + + ~WebNotification() { reset(); } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebNotification&); + + WebNotification& operator=(const WebNotification& other) + { + assign(other); + return *this; + } + + // Operators required to put WebNotification in an ordered map. + bool equals(const WebNotification& other) const { return m_private == other.m_private; } + bool lessThan(const WebNotification& other) const; + + // Is the notification HTML vs. icon-title-text? + WEBKIT_API bool isHTML() const; + + // If HTML, the URL which contains the contents of the notification. + WEBKIT_API WebURL url() const; + + // If not HTML, the parameters for the icon-title-text notification. + WEBKIT_API WebString icon() const; + WEBKIT_API WebString title() const; + WEBKIT_API WebString body() const; + + // Called to indicate the notification has been displayed. + WEBKIT_API void dispatchDisplayEvent(); + + // Called to indicate an error has occurred with this notification. + WEBKIT_API void dispatchErrorEvent(const WebString& errorMessage); + + // Called to indicate the notification has been closed. If it was + // closed by the user (as opposed to automatically by the system), + // the byUser parameter will be true. + WEBKIT_API void dispatchCloseEvent(bool byUser); + +#if WEBKIT_IMPLEMENTATION + WebNotification(const WTF::PassRefPtr<WebCore::Notification>&); + WebNotification& operator=(const WTF::PassRefPtr<WebCore::Notification>&); + operator WTF::PassRefPtr<WebCore::Notification>() const; +#endif + +private: + void assign(WebNotificationPrivate*); + WebNotificationPrivate* m_private; +}; + +inline bool operator==(const WebNotification& a, const WebNotification& b) +{ + return a.equals(b); +} + +inline bool operator!=(const WebNotification& a, const WebNotification& b) +{ + return !a.equals(b); +} + +inline bool operator<(const WebNotification& a, const WebNotification& b) +{ + return a.lessThan(b); +} + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebNotificationPermissionCallback.h b/WebKit/chromium/public/WebNotificationPermissionCallback.h new file mode 100644 index 0000000..07e85ee --- /dev/null +++ b/WebKit/chromium/public/WebNotificationPermissionCallback.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebNotificationPermissionCallback_h +#define WebNotificationPermissionCallback_h + +namespace WebKit { + +// Callback object used with WebNotificationPresenter. +class WebNotificationPermissionCallback { +public: + // Method to be invoked when the async permission request involving + // this object has been completed. + virtual void permissionRequestComplete() = 0; + +protected: + // This object is to be destroyed after the callback is invoked; + // it should not be directly destroyed. + ~WebNotificationPermissionCallback() {} +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebNotificationPresenter.h b/WebKit/chromium/public/WebNotificationPresenter.h new file mode 100644 index 0000000..653b142 --- /dev/null +++ b/WebKit/chromium/public/WebNotificationPresenter.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebNotificationPresenter_h +#define WebNotificationPresenter_h + +#include "WebString.h" + +namespace WebKit { + +class WebNotification; +class WebNotificationPermissionCallback; + +// Provides the services to show desktop notifications to the user. +class WebNotificationPresenter { +public: + enum Permission { + PermissionAllowed, // User has allowed permission to the origin. + PermissionNotAllowed, // User has not taken an action on the origin (defaults to not allowed). + PermissionDenied // User has explicitly denied permission from the origin. + }; + + // Shows a notification. + virtual bool show(const WebNotification&) = 0; + + // Cancels a notification previously shown, and removes it if being shown. + virtual void cancel(const WebNotification&) = 0; + + // Indiciates that the notification object subscribed to events for a previously shown notification is + // being destroyed. Does _not_ remove the notification if being shown, but detaches it from receiving events. + virtual void objectDestroyed(const WebNotification&) = 0; + + // Checks the permission level of a given origin. + virtual Permission checkPermission(const WebString& origin) = 0; + + // Requests permission for a given origin. This operation is asynchronous and the callback provided + // will be invoked when the permission decision is made. Callback pointer must remain + // valid until called. + virtual void requestPermission(const WebString& origin, WebNotificationPermissionCallback* callback) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPasswordAutocompleteListener.h b/WebKit/chromium/public/WebPasswordAutocompleteListener.h new file mode 100644 index 0000000..db6589d --- /dev/null +++ b/WebKit/chromium/public/WebPasswordAutocompleteListener.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPasswordAutocompleteListener_h +#define WebPasswordAutocompleteListener_h + +namespace WebKit { +class WebString; + +class WebPasswordAutocompleteListener { +public: + virtual ~WebPasswordAutocompleteListener() {} + + virtual void didBlurInputElement( + const WebString& userInput) = 0; + + virtual void performInlineAutocomplete( + const WebString& userInput, + bool backSpaceOrDeletePressed, + bool showSuggestions) = 0; +}; + +} // namespace WebKit + + +#endif diff --git a/WebKit/chromium/public/WebPasswordFormData.h b/WebKit/chromium/public/WebPasswordFormData.h new file mode 100644 index 0000000..e1804d1 --- /dev/null +++ b/WebKit/chromium/public/WebPasswordFormData.h @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPasswordFormData_h +#define WebPasswordFormData_h + +#include "WebFormElement.h" +#include "WebString.h" +#include "WebURL.h" + +namespace WebKit { + +struct WebPasswordFormData { + // If the provided form is suitable for password completion, isValid() will + // return true; + WebPasswordFormData(const WebFormElement&); + + // If creation failed, return false. + bool isValid() const { return action.isValid(); } + + // The action target of the form. This is the primary data used by the + // PasswordManager for form autofill; that is, the action of the saved + // credentials must match the action of the form on the page to be autofilled. + // If this is empty / not available, it will result in a "restricted" + // IE-like autofill policy, where we wait for the user to type in his + // username before autofilling the password. In these cases, after successful + // login the action URL will automatically be assigned by the + // PasswordManager. + // + // When parsing an HTML form, this must always be set. + WebURL action; + + // The "Realm" for the sign-on (scheme, host, port for SCHEME_HTML, and + // contains the HTTP realm for dialog-based forms). + // The signon_realm is effectively the primary key used for retrieving + // data from the database, so it must not be empty. + WebString signonRealm; + + // The URL (minus query parameters) containing the form. This is the primary + // data used by the PasswordManager to decide (in longest matching prefix + // fashion) whether or not a given PasswordForm result from the database is a + // good fit for a particular form on a page, so it must not be empty. + WebURL origin; + + // The name of the submit button used. Optional; only used in scoring + // of PasswordForm results from the database to make matches as tight as + // possible. + // + // When parsing an HTML form, this must always be set. + WebString submitElement; + + // The name of the username input element. Optional (improves scoring). + // + // When parsing an HTML form, this must always be set. + WebString userNameElement; + + // The username. Optional. + // + // When parsing an HTML form, this is typically empty unless the site + // has implemented some form of autofill. + WebString userNameValue; + + // The name of the password input element, Optional (improves scoring). + // + // When parsing an HTML form, this must always be set. + WebString passwordElement; + + // The password. Required. + // + // When parsing an HTML form, this is typically empty. + WebString passwordValue; + + // If the form was a change password form, the name of the + // 'old password' input element. Optional. + WebString oldPasswordElement; + + // The old password. Optional. + WebString oldPasswordValue; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPlugin.h b/WebKit/chromium/public/WebPlugin.h new file mode 100644 index 0000000..5097265 --- /dev/null +++ b/WebKit/chromium/public/WebPlugin.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPlugin_h +#define WebPlugin_h + +#include "WebCanvas.h" + +struct NPObject; + +namespace WebKit { + +class WebDataSource; +class WebFrame; +class WebInputEvent; +class WebPluginContainer; +class WebURL; +class WebURLResponse; +struct WebCursorInfo; +struct WebPluginParams; +struct WebRect; +struct WebURLError; +template <typename T> class WebVector; + +class WebPlugin { +public: + virtual bool initialize(WebPluginContainer*) = 0; + virtual void destroy() = 0; + + virtual NPObject* scriptableObject() = 0; + + virtual void paint(WebCanvas*, const WebRect&) = 0; + + // Coordinates are relative to the containing window. + virtual void updateGeometry( + const WebRect& frameRect, const WebRect& clipRect, + const WebVector<WebRect>& cutOutsRects, bool isVisible) = 0; + + virtual void updateFocus(bool) = 0; + virtual void updateVisibility(bool) = 0; + + virtual bool acceptsInputEvents() = 0; + virtual bool handleInputEvent(const WebInputEvent&, WebCursorInfo&) = 0; + + virtual void didReceiveResponse(const WebURLResponse&) = 0; + virtual void didReceiveData(const char* data, int dataLength) = 0; + virtual void didFinishLoading() = 0; + virtual void didFailLoading(const WebURLError&) = 0; + + // Called in response to WebPluginContainer::loadFrameRequest + virtual void didFinishLoadingFrameRequest( + const WebURL&, void* notifyData) = 0; + virtual void didFailLoadingFrameRequest( + const WebURL&, void* notifyData, const WebURLError&) = 0; + +protected: + ~WebPlugin() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPluginContainer.h b/WebKit/chromium/public/WebPluginContainer.h new file mode 100644 index 0000000..41e304e --- /dev/null +++ b/WebKit/chromium/public/WebPluginContainer.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPluginContainer_h +#define WebPluginContainer_h + +struct NPObject; + +namespace WebKit { + +class WebString; +class WebURL; +class WebURLRequest; +struct WebRect; + +class WebPluginContainer { +public: + virtual void invalidate() = 0; + virtual void invalidateRect(const WebRect&) = 0; + + // Causes the container to report its current geometry via + // WebPlugin::updateGeometry. + virtual void reportGeometry() = 0; + + // Drop any references to script objects allocated by the plugin. + // These are objects derived from WebPlugin::scriptableObject. This is + // called when the plugin is being destroyed or if it needs to be + // re-initialized. + virtual void clearScriptObjects() = 0; + + // Returns the scriptable object associated with the DOM element + // containing the plugin. + virtual NPObject* scriptableObjectForElement() = 0; + + // Executes a "javascript:" URL on behalf of the plugin in the context + // of the frame containing the plugin. Returns the result of script + // execution, if any. + virtual WebString executeScriptURL(const WebURL&, bool popupsAllowed) = 0; + + // Loads an URL in the specified frame (or the frame containing this + // plugin if target is empty). If notifyNeeded is true, then upon + // completion, WebPlugin::didFinishLoadingFrameRequest is called if the + // load was successful or WebPlugin::didFailLoadingFrameRequest is + // called if the load failed. The given notifyData is passed along to + // the callback. + virtual void loadFrameRequest( + const WebURLRequest&, const WebString& target, bool notifyNeeded, void* notifyData) = 0; + +protected: + ~WebPluginContainer() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPluginListBuilder.h b/WebKit/chromium/public/WebPluginListBuilder.h new file mode 100644 index 0000000..4bd427d --- /dev/null +++ b/WebKit/chromium/public/WebPluginListBuilder.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPluginListBuilder_h +#define WebPluginListBuilder_h + +namespace WebKit { + +class WebString; + +// An interface for building a list of known plugins. +class WebPluginListBuilder { +public: + virtual void addPlugin( + const WebString& name, const WebString& description, + const WebString& fileName) = 0; + + virtual void addMediaTypeToLastPlugin( + const WebString& name, const WebString& description) = 0; + + virtual void addFileExtensionToLastMediaType( + const WebString& fileExtension) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPluginParams.h b/WebKit/chromium/public/WebPluginParams.h new file mode 100644 index 0000000..5d03204 --- /dev/null +++ b/WebKit/chromium/public/WebPluginParams.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPluginParams_h +#define WebPluginParams_h + +#include "WebString.h" +#include "WebURL.h" +#include "WebVector.h" + +namespace WebKit { + +struct WebPluginParams { + WebURL url; + WebString mimeType; + WebVector<WebString> attributeNames; + WebVector<WebString> attributeValues; + bool loadManually; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPoint.h b/WebKit/chromium/public/WebPoint.h new file mode 100644 index 0000000..d1abe02 --- /dev/null +++ b/WebKit/chromium/public/WebPoint.h @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPoint_h +#define WebPoint_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +#include "IntPoint.h" +#else +#include <base/gfx/rect.h> +#endif + +namespace WebKit { + +struct WebPoint { + int x; + int y; + + WebPoint() + : x(0) + , y(0) + { + } + + WebPoint(int x, int y) + : x(x) + , y(y) + { + } + +#if WEBKIT_IMPLEMENTATION + WebPoint(const WebCore::IntPoint& p) + : x(p.x()) + , y(p.y()) + { + } + + WebPoint& operator=(const WebCore::IntPoint& p) + { + x = p.x(); + y = p.y(); + return *this; + } + + operator WebCore::IntPoint() const + { + return WebCore::IntPoint(x, y); + } +#else + WebPoint(const gfx::Point& p) + : x(p.x()) + , y(p.y()) + { + } + + WebPoint& operator=(const gfx::Point& p) + { + x = p.x(); + y = p.y(); + return *this; + } + + operator gfx::Point() const + { + return gfx::Point(x, y); + } +#endif +}; + +inline bool operator==(const WebPoint& a, const WebPoint& b) +{ + return a.x == b.x && a.y == b.y; +} + +inline bool operator!=(const WebPoint& a, const WebPoint& b) +{ + return !(a == b); +} + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPopupMenu.h b/WebKit/chromium/public/WebPopupMenu.h new file mode 100644 index 0000000..c2cdec3 --- /dev/null +++ b/WebKit/chromium/public/WebPopupMenu.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPopupMenu_h +#define WebPopupMenu_h + +#include "WebCommon.h" +#include "WebWidget.h" + +namespace WebKit { + +class WebWidgetClient; + +class WebPopupMenu : public WebWidget { +public: + WEBKIT_API static WebPopupMenu* create(WebWidgetClient*); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPopupMenuInfo.h b/WebKit/chromium/public/WebPopupMenuInfo.h new file mode 100644 index 0000000..876842d --- /dev/null +++ b/WebKit/chromium/public/WebPopupMenuInfo.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPopupMenuInfo_h +#define WebPopupMenuInfo_h + +#include "WebMenuItemInfo.h" +#include "WebVector.h" + +namespace WebKit { + +// Describes the contents of a popup menu. +struct WebPopupMenuInfo { + // FIXME: migrate clients to WebMenuItemInfo and remove this temporary Item typedef. + typedef WebMenuItemInfo Item; + int itemHeight; + int selectedIndex; + WebVector<WebMenuItemInfo> items; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebRange.h b/WebKit/chromium/public/WebRange.h new file mode 100644 index 0000000..89fc8f6 --- /dev/null +++ b/WebKit/chromium/public/WebRange.h @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebRange_h +#define WebRange_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Range; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebNode; +class WebRangePrivate; +class WebString; + +// Provides readonly access to some properties of a DOM range. +class WebRange { +public: + ~WebRange() { reset(); } + + WebRange() : m_private(0) { } + WebRange(const WebRange& r) : m_private(0) { assign(r); } + WebRange& operator=(const WebRange& r) + { + assign(r); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebRange&); + + bool isNull() const { return !m_private; } + + WEBKIT_API int startOffset() const; + WEBKIT_API int endOffset() const; + WEBKIT_API WebNode startContainer(int& exceptionCode) const; + WEBKIT_API WebNode endContainer(int& exceptionCode) const; + + WEBKIT_API WebString toHTMLText() const; + WEBKIT_API WebString toPlainText() const; + +#if WEBKIT_IMPLEMENTATION + WebRange(const WTF::PassRefPtr<WebCore::Range>&); + WebRange& operator=(const WTF::PassRefPtr<WebCore::Range>&); + operator WTF::PassRefPtr<WebCore::Range>() const; +#endif + +private: + void assign(WebRangePrivate*); + WebRangePrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebRect.h b/WebKit/chromium/public/WebRect.h new file mode 100644 index 0000000..ed5a7d1 --- /dev/null +++ b/WebKit/chromium/public/WebRect.h @@ -0,0 +1,127 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebRect_h +#define WebRect_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +#include "IntRect.h" +#else +#include <base/gfx/rect.h> +#endif + +namespace WebKit { + +struct WebRect { + int x; + int y; + int width; + int height; + + bool isEmpty() const { return width <= 0 || height <= 0; } + + WebRect() + : x(0) + , y(0) + , width(0) + , height(0) + { + } + + WebRect(int x, int y, int width, int height) + : x(x) + , y(y) + , width(width) + , height(height) + { + } + +#if WEBKIT_IMPLEMENTATION + WebRect(const WebCore::IntRect& r) + : x(r.x()) + , y(r.y()) + , width(r.width()) + , height(r.height()) + { + } + + WebRect& operator=(const WebCore::IntRect& r) + { + x = r.x(); + y = r.y(); + width = r.width(); + height = r.height(); + return *this; + } + + operator WebCore::IntRect() const + { + return WebCore::IntRect(x, y, width, height); + } +#else + WebRect(const gfx::Rect& r) + : x(r.x()) + , y(r.y()) + , width(r.width()) + , height(r.height()) + { + } + + WebRect& operator=(const gfx::Rect& r) + { + x = r.x(); + y = r.y(); + width = r.width(); + height = r.height(); + return *this; + } + + operator gfx::Rect() const + { + return gfx::Rect(x, y, width, height); + } +#endif +}; + +inline bool operator==(const WebRect& a, const WebRect& b) +{ + return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height; +} + +inline bool operator!=(const WebRect& a, const WebRect& b) +{ + return !(a == b); +} + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebRegularExpression.h b/WebKit/chromium/public/WebRegularExpression.h new file mode 100644 index 0000000..bdf72d8 --- /dev/null +++ b/WebKit/chromium/public/WebRegularExpression.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebRegularExpression_h +#define WebRegularExpression_h + +#include "WebCommon.h" +#include "WebNonCopyable.h" +#include "WebTextCaseSensitivity.h" + +namespace WebKit { + +class WebRegularExpressionPrivate; +class WebString; + +class WebRegularExpression : public WebNonCopyable { +public: + WEBKIT_API WebRegularExpression(const WebString& pattern, WebTextCaseSensitivity); + WEBKIT_API ~WebRegularExpression(); + + WEBKIT_API int match(const WebString&, int startFrom = 0, int* matchLength = 0) const; + +private: + WebRegularExpressionPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebRuntimeFeatures.h b/WebKit/chromium/public/WebRuntimeFeatures.h new file mode 100644 index 0000000..eb6b2da --- /dev/null +++ b/WebKit/chromium/public/WebRuntimeFeatures.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebRuntimeFeatures_h +#define WebRuntimeFeatures_h + +#include "WebCommon.h" + +namespace WebKit { + +// This class is used to enable runtime features of WebKit. It is unspecified +// whether a feature is enabled by default. In the future, a feature may be +// promoted from disabled by default to enabled by default once it reaches a +// certain level of maturity. +class WebRuntimeFeatures { +public: + WEBKIT_API static void enableDatabase(bool); + WEBKIT_API static bool isDatabaseEnabled(); + + WEBKIT_API static void enableLocalStorage(bool); + WEBKIT_API static bool isLocalStorageEnabled(); + + WEBKIT_API static void enableSessionStorage(bool); + WEBKIT_API static bool isSessionStorageEnabled(); + + WEBKIT_API static void enableMediaPlayer(bool); + WEBKIT_API static bool isMediaPlayerEnabled(); + + WEBKIT_API static void enableSockets(bool); + WEBKIT_API static bool isSocketsEnabled(); + + WEBKIT_API static void enableNotifications(bool); + WEBKIT_API static bool isNotificationsEnabled(); + + WEBKIT_API static void enableApplicationCache(bool); + WEBKIT_API static bool isApplicationCacheEnabled(); + +private: + WebRuntimeFeatures(); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebScreenInfo.h b/WebKit/chromium/public/WebScreenInfo.h new file mode 100644 index 0000000..d3d268a --- /dev/null +++ b/WebKit/chromium/public/WebScreenInfo.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebScreenInfo_h +#define WebScreenInfo_h + +#include "WebRect.h" + +namespace WebKit { + +struct WebScreenInfo { + // The screen depth in bits per pixel + int depth; + + // The bits per colour component. This assumes that the colours are balanced + // equally. + int depthPerComponent; + + // This can be true for black and white printers + bool isMonochrome; + + // This is set from the rcMonitor member of MONITORINFOEX, to whit: + // "A RECT structure that specifies the display monitor rectangle, + // expressed in virtual-screen coordinates. Note that if the monitor + // is not the primary display monitor, some of the rectangle's + // coordinates may be negative values." + WebRect rect; + + // This is set from the rcWork member of MONITORINFOEX, to whit: + // "A RECT structure that specifies the work area rectangle of the + // display monitor that can be used by applications, expressed in + // virtual-screen coordinates. Windows uses this rectangle to + // maximize an application on the monitor. The rest of the area in + // rcMonitor contains system windows such as the task bar and side + // bars. Note that if the monitor is not the primary display monitor, + // some of the rectangle's coordinates may be negative values". + WebRect availableRect; + + WebScreenInfo() + : depth(0) + , depthPerComponent(0) + , isMonochrome(false) { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebScriptController.h b/WebKit/chromium/public/WebScriptController.h new file mode 100644 index 0000000..54bb08a --- /dev/null +++ b/WebKit/chromium/public/WebScriptController.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebScriptController_h +#define WebScriptController_h + +#include "WebCommon.h" + +namespace v8 { +class Extension; +} + +namespace WebKit { + +class WebString; + +class WebScriptController { +public: + // Registers a v8 extension to be available on webpages. The three forms + // offer various restrictions on what types of contexts the extension is + // loaded into. If a scheme is provided, only pages whose URL has the given + // scheme will match. If extensionGroup is provided, the extension will only + // be loaded into scripts run via WebFrame::ExecuteInNewWorld with the + // matching group. + // Will only affect v8 contexts initialized after this call. Takes ownership + // of the v8::Extension object passed. + WEBKIT_API static void registerExtension(v8::Extension*); + WEBKIT_API static void registerExtension(v8::Extension*, + const WebString& schemeRestriction); + WEBKIT_API static void registerExtension(v8::Extension*, int extensionGroup); + + // Enables special settings which are only applicable if V8 is executed + // in the single thread which must be the main thread. + // FIXME: make a try to dynamically detect when this condition is broken + // and automatically switch off single thread mode. + WEBKIT_API static void enableV8SingleThreadMode(); + + // Process any pending JavaScript console messages. + WEBKIT_API static void flushConsoleMessages(); + +private: + WebScriptController(); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebScriptSource.h b/WebKit/chromium/public/WebScriptSource.h new file mode 100644 index 0000000..344815b --- /dev/null +++ b/WebKit/chromium/public/WebScriptSource.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebScriptSource_h +#define WebScriptSource_h + +#include "WebString.h" +#include "WebURL.h" + +namespace WebKit { + +struct WebScriptSource { + WebString code; + WebURL url; + int startLine; + + WebScriptSource(const WebString& code) + : code(code), startLine(1) { } + WebScriptSource(const WebString& code, const WebURL& url) + : code(code), url(url), startLine(1) { } + WebScriptSource(const WebString& code, const WebURL& url, int startLine) + : code(code), url(url), startLine(startLine) { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSearchableFormData.h b/WebKit/chromium/public/WebSearchableFormData.h new file mode 100644 index 0000000..e453387 --- /dev/null +++ b/WebKit/chromium/public/WebSearchableFormData.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSearchableFormData_h +#define WebSearchableFormData_h + +#include "WebString.h" +#include "WebURL.h" + +namespace WebKit { +class WebFormElement; + +// SearchableFormData encapsulates a URL and encoding of an INPUT field that +// corresponds to a searchable form request. +class WebSearchableFormData { +public: + // If the provided form is suitable for automated searching, isValid() + // will return false. + WebSearchableFormData(const WebFormElement&); + + bool isValid() { return m_url.isValid(); } + + // URL for the searchable form request. + const WebURL& url() const + { + return m_url; + } + + // Encoding used to encode the form parameters; never empty. + const WebString& encoding() const + { + return m_encoding; + } + +private: + WebURL m_url; + WebString m_encoding; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSecurityOrigin.h b/WebKit/chromium/public/WebSecurityOrigin.h new file mode 100644 index 0000000..d04fbc6 --- /dev/null +++ b/WebKit/chromium/public/WebSecurityOrigin.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSecurityOrigin_h +#define WebSecurityOrigin_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class SecurityOrigin; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebSecurityOriginPrivate; +class WebString; + +class WebSecurityOrigin { +public: + ~WebSecurityOrigin() { reset(); } + + WebSecurityOrigin() : m_private(0) { } + WebSecurityOrigin(const WebSecurityOrigin& s) : m_private(0) { assign(s); } + WebSecurityOrigin& operator=(const WebSecurityOrigin& s) + { + assign(s); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebSecurityOrigin&); + + bool isNull() const { return !m_private; } + + WEBKIT_API WebString protocol() const; + WEBKIT_API WebString host() const; + WEBKIT_API unsigned short port() const; + + // The empty WebSecurityOrigin is the least privileged WebSecurityOrigin. + WEBKIT_API bool isEmpty() const; + + // Returns a string representation of the WebSecurityOrigin. The empty + // WebSecurityOrigin is represented by "null". The representation of a + // non-empty WebSecurityOrigin resembles a standard URL. + WEBKIT_API WebString toString() const; + + // Returns a string representation of this WebSecurityOrigin that can + // be used as a file. Should be used in storage APIs only. + WEBKIT_API WebString databaseIdentifier(); + +#if WEBKIT_IMPLEMENTATION + WebSecurityOrigin(const WTF::PassRefPtr<WebCore::SecurityOrigin>&); + WebSecurityOrigin& operator=(const WTF::PassRefPtr<WebCore::SecurityOrigin>&); + operator WTF::PassRefPtr<WebCore::SecurityOrigin>() const; +#endif + +private: + void assign(WebSecurityOriginPrivate*); + WebSecurityOriginPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSecurityPolicy.h b/WebKit/chromium/public/WebSecurityPolicy.h new file mode 100644 index 0000000..47dfe87 --- /dev/null +++ b/WebKit/chromium/public/WebSecurityPolicy.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSecurityPolicy_h +#define WebSecurityPolicy_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebString; +class WebURL; + +class WebSecurityPolicy { +public: + // Registers a URL scheme to be treated as a local scheme (i.e., with the + // same security rules as those applied to "file" URLs). This means that + // normal pages cannot link to or access URLs of this scheme. + WEBKIT_API static void registerURLSchemeAsLocal(const WebString&); + + // Registers a URL scheme to be treated as a noAccess scheme. This means + // that pages loaded with this URL scheme cannot access pages loaded with + // any other URL scheme. + WEBKIT_API static void registerURLSchemeAsNoAccess(const WebString&); + + // Support for whitelisting access to origins beyond the same-origin policy. + WEBKIT_API static void whiteListAccessFromOrigin( + const WebURL& sourceOrigin, const WebString& destinationProtocol, + const WebString& destinationHost, bool allowDestinationSubdomains); + WEBKIT_API static void resetOriginAccessWhiteLists(); + +private: + WebSecurityPolicy(); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSettings.h b/WebKit/chromium/public/WebSettings.h new file mode 100644 index 0000000..da36806 --- /dev/null +++ b/WebKit/chromium/public/WebSettings.h @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSettings_h +#define WebSettings_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebString; +class WebURL; + +// WebSettings is owned by the WebView and allows code to modify the settings for +// the WebView's page without any knowledge of WebCore itself. For the most part, +// these functions have a 1:1 mapping with the methods in WebCore/page/settings.h. +class WebSettings { +public: + virtual void setStandardFontFamily(const WebString&) = 0; + virtual void setFixedFontFamily(const WebString&) = 0; + virtual void setSerifFontFamily(const WebString&) = 0; + virtual void setSansSerifFontFamily(const WebString&) = 0; + virtual void setCursiveFontFamily(const WebString&) = 0; + virtual void setFantasyFontFamily(const WebString&) = 0; + virtual void setDefaultFontSize(int) = 0; + virtual void setDefaultFixedFontSize(int) = 0; + virtual void setMinimumFontSize(int) = 0; + virtual void setMinimumLogicalFontSize(int) = 0; + virtual void setDefaultTextEncodingName(const WebString&) = 0; + virtual void setJavaScriptEnabled(bool) = 0; + virtual void setWebSecurityEnabled(bool) = 0; + virtual void setJavaScriptCanOpenWindowsAutomatically(bool) = 0; + virtual void setLoadsImagesAutomatically(bool) = 0; + virtual void setPluginsEnabled(bool) = 0; + virtual void setDOMPasteAllowed(bool) = 0; + virtual void setDeveloperExtrasEnabled(bool) = 0; + virtual void setNeedsSiteSpecificQuirks(bool) = 0; + virtual void setShrinksStandaloneImagesToFit(bool) = 0; + virtual void setUsesEncodingDetector(bool) = 0; + virtual void setTextAreasAreResizable(bool) = 0; + virtual void setJavaEnabled(bool) = 0; + virtual void setAllowScriptsToCloseWindows(bool) = 0; + virtual void setUserStyleSheetLocation(const WebURL&) = 0; + virtual void setUsesPageCache(bool) = 0; + virtual void setDownloadableBinaryFontsEnabled(bool) = 0; + virtual void setXSSAuditorEnabled(bool) = 0; + virtual void setLocalStorageEnabled(bool) = 0; + virtual void setEditableLinkBehaviorNeverLive() = 0; + virtual void setFontRenderingModeNormal() = 0; + virtual void setShouldPaintCustomScrollbars(bool) = 0; + virtual void setDatabasesEnabled(bool) = 0; + virtual void setAllowUniversalAccessFromFileURLs(bool) = 0; + virtual void setTextDirectionSubmenuInclusionBehaviorNeverIncluded() = 0; + virtual void setOfflineWebApplicationCacheEnabled(bool) = 0; + virtual void setExperimentalWebGLEnabled(bool) = 0; + virtual void setGeolocationEnabled(bool) = 0; + +protected: + ~WebSettings() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSharedWorker.h b/WebKit/chromium/public/WebSharedWorker.h new file mode 100644 index 0000000..4ac7639 --- /dev/null +++ b/WebKit/chromium/public/WebSharedWorker.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSharedWorker_h +#define WebSharedWorker_h + +#include "WebCommon.h" + +namespace WebCore { +class ScriptExecutionContext; +} + +namespace WebKit { + +class WebString; +class WebMessagePortChannel; +class WebCommonWorkerClient; +class WebURL; + +// This is the interface to a SharedWorker thread. +// Since SharedWorkers communicate entirely through MessagePorts this interface only contains APIs for starting up a SharedWorker. +class WebSharedWorker { +public: + // Invoked from the worker thread to instantiate a WebSharedWorker that interacts with the WebKit worker components. + WEBKIT_API static WebSharedWorker* create(WebCommonWorkerClient*); + + virtual ~WebSharedWorker() {}; + + // Returns false if the thread hasn't been started yet (script loading has not taken place). + // FIXME(atwilson): Remove this when we move the initial script loading into the worker process. + virtual bool isStarted() = 0; + + virtual void startWorkerContext(const WebURL& scriptURL, + const WebString& name, + const WebString& userAgent, + const WebString& sourceCode) = 0; + class ConnectListener { + public: + // Invoked once the connect event has been sent so the caller can free this object. + virtual void connected() = 0; + }; + + // Sends a connect event to the SharedWorker context. The listener is invoked when this async operation completes. + virtual void connect(WebMessagePortChannel*, ConnectListener*) = 0; + + // Invoked to shutdown the worker when there are no more associated documents. + virtual void terminateWorkerContext() = 0; + + // Notification when the WebCommonWorkerClient is destroyed. + virtual void clientDestroyed() = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSharedWorkerRepository.h b/WebKit/chromium/public/WebSharedWorkerRepository.h new file mode 100644 index 0000000..9fe6890 --- /dev/null +++ b/WebKit/chromium/public/WebSharedWorkerRepository.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSharedWorkerRepository_h +#define WebSharedWorkerRepository_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebString; +class WebSharedWorker; +class WebURL; + +class WebSharedWorkerRepository { +public: + // Unique identifier for the parent document of a worker (unique within a given process). + typedef unsigned long long DocumentID; + + // Tracks a newly-created SharedWorker via the repository. + virtual void addSharedWorker(WebSharedWorker*, DocumentID) = 0; + + // Invoked when a document has been detached. DocumentID can be re-used after documentDetached() is invoked. + virtual void documentDetached(DocumentID) = 0; + + // Returns true if the passed document is associated with any SharedWorkers. + virtual bool hasSharedWorkers(DocumentID) = 0; +}; + +} // namespace WebKit + +#endif // WebSharedWorkerRepository_h diff --git a/WebKit/chromium/public/WebSize.h b/WebKit/chromium/public/WebSize.h new file mode 100644 index 0000000..bb88633 --- /dev/null +++ b/WebKit/chromium/public/WebSize.h @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSize_h +#define WebSize_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +#include "IntSize.h" +#else +#include <base/gfx/rect.h> +#endif + +namespace WebKit { + +struct WebSize { + int width; + int height; + + bool isEmpty() const { return width <= 0 || height <= 0; } + + WebSize() + : width(0) + , height(0) + { + } + + WebSize(int width, int height) + : width(width) + , height(height) + { + } + +#if WEBKIT_IMPLEMENTATION + WebSize(const WebCore::IntSize& s) + : width(s.width()) + , height(s.height()) + { + } + + WebSize& operator=(const WebCore::IntSize& s) + { + width = s.width(); + height = s.height(); + return *this; + } + + operator WebCore::IntSize() const + { + return WebCore::IntSize(width, height); + } +#else + WebSize(const gfx::Size& s) + : width(s.width()) + , height(s.height()) + { + } + + WebSize& operator=(const gfx::Size& s) + { + width = s.width(); + height = s.height(); + return *this; + } + + operator gfx::Size() const + { + return gfx::Size(width, height); + } +#endif +}; + +inline bool operator==(const WebSize& a, const WebSize& b) +{ + return a.width == b.width && a.height == b.height; +} + +inline bool operator!=(const WebSize& a, const WebSize& b) +{ + return !(a == b); +} + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSocketStreamError.h b/WebKit/chromium/public/WebSocketStreamError.h new file mode 100644 index 0000000..f52869b --- /dev/null +++ b/WebKit/chromium/public/WebSocketStreamError.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSocketStreamError_h +#define WebSocketStreamError_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebSocketStreamError { +public: + // FIXME: Define SocketStream Error codes and accessor methods. +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSocketStreamHandle.h b/WebKit/chromium/public/WebSocketStreamHandle.h new file mode 100644 index 0000000..ededa0e --- /dev/null +++ b/WebKit/chromium/public/WebSocketStreamHandle.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSocketStreamHandle_h +#define WebSocketStreamHandle_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebData; +class WebSocketStreamHandleClient; +class WebURL; + +class WebSocketStreamHandle { +public: + virtual ~WebSocketStreamHandle() { } + + // Connect new socket stream asynchronously. + virtual void connect(const WebURL&, WebSocketStreamHandleClient*) = 0; + + // Send web socket frame data on the socket stream. + virtual bool send(const WebData&) = 0; + + // Close the socket stream. + virtual void close() = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebSocketStreamHandleClient.h b/WebKit/chromium/public/WebSocketStreamHandleClient.h new file mode 100644 index 0000000..82f328c --- /dev/null +++ b/WebKit/chromium/public/WebSocketStreamHandleClient.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSocketStreamHandleClient_h +#define WebSocketStreamHandleClient_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebData; +class WebSocketStreamError; +class WebSocketStreamHandle; +class WebURL; + +class WebSocketStreamHandleClient { +public: + + // Called when Socket Stream is opened. + virtual void didOpenStream(WebSocketStreamHandle*, int /* maxPendingSendAllowed */) = 0; + + // Called when |amountSent| bytes are sent. + virtual void didSendData(WebSocketStreamHandle*, int /* amountSent */) = 0; + + // Called when data are received. + virtual void didReceiveData(WebSocketStreamHandle*, const WebData&) = 0; + + // Called when Socket Stream is closed. + virtual void didClose(WebSocketStreamHandle*) = 0; + + // Called when Socket Stream has an error. + virtual void didFail(WebSocketStreamHandle*, const WebSocketStreamError&) = 0; + + // FIXME: auth challenge for proxy +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebStorageArea.h b/WebKit/chromium/public/WebStorageArea.h new file mode 100644 index 0000000..71dc7a5 --- /dev/null +++ b/WebKit/chromium/public/WebStorageArea.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebStorageArea_h +#define WebStorageArea_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebString; +class WebURL; + +// In WebCore, there's one distinct StorageArea per origin per StorageNamespace. This +// class wraps a StorageArea. All the methods have obvious connections to the spec: +// http://dev.w3.org/html5/webstorage/ +class WebStorageArea { +public: + virtual ~WebStorageArea() { } + + // The number of key/value pairs in the storage area. + virtual unsigned length() = 0; + + // Get a value for a specific key. Valid key indices are 0 through length() - 1. + // Indexes may change on any set/removeItem call. Will return null if the index + // provided is out of range. + virtual WebString key(unsigned index) = 0; + + // Get the value that corresponds to a specific key. This returns null if there is + // no entry for that key. + virtual WebString getItem(const WebString& key) = 0; + + // Set the value that corresponds to a specific key. QuotaException is set if we've + // the StorageArea would have exceeded its quota. The value is NOT set when there's + // an exception. url is the url that should be used if a storage event fires. + virtual void setItem(const WebString& key, const WebString& value, const WebURL& url, bool& quotaException) = 0; + + // Remove the value associated with a particular key. url is the url that should be used + // if a storage event fires. + virtual void removeItem(const WebString& key, const WebURL& url) = 0; + + // Clear all key/value pairs. url is the url that should be used if a storage event fires. + virtual void clear(const WebURL& url) = 0; +}; + +} // namespace WebKit + +#endif // WebStorageArea_h diff --git a/WebKit/chromium/public/WebStorageEventDispatcher.h b/WebKit/chromium/public/WebStorageEventDispatcher.h new file mode 100644 index 0000000..57750e8 --- /dev/null +++ b/WebKit/chromium/public/WebStorageEventDispatcher.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebStorageEventDispatcher_h +#define WebStorageEventDispatcher_h + +#include "WebString.h" + +namespace WebKit { + +class WebURL; + +// This is used to dispatch storage events to all pages. +// FIXME: Make this (or something) work for SessionStorage! +class WebStorageEventDispatcher { +public: + static WebStorageEventDispatcher* create(); + + virtual ~WebStorageEventDispatcher() { } + + // Dispatch the actual event. Doesn't yet work for SessionStorage. + virtual void dispatchStorageEvent(const WebString& key, const WebString& oldValue, + const WebString& newValue, const WebString& origin, + const WebURL& url, bool isLocalStorage) = 0; +}; + +} // namespace WebKit + +#endif // WebStorageEventDispatcher_h diff --git a/WebKit/chromium/public/WebStorageNamespace.h b/WebKit/chromium/public/WebStorageNamespace.h new file mode 100644 index 0000000..da92a77 --- /dev/null +++ b/WebKit/chromium/public/WebStorageNamespace.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebStorageNamespace_h +#define WebStorageNamespace_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebStorageArea; +class WebString; + +// WebStorageNamespace represents a collection of StorageAreas. Typically, you'll have +// multiple StorageNamespaces to represent the SessionStorage for each tab and a single +// StorageNamespace to represent LocalStorage for the entire browser. +class WebStorageNamespace { +public: + // Create a new WebStorageNamespace. LocalStorageNamespaces require a path to specify + // where the SQLite databases that make LocalStorage data persistent are located. + // If path is empty, data will not persist. You should call delete on the returned + // object when you're finished. + WEBKIT_API static WebStorageNamespace* createLocalStorageNamespace(const WebString& backingDirectoryPath, unsigned quota); + WEBKIT_API static WebStorageNamespace* createSessionStorageNamespace(); + + static const unsigned noQuota = UINT_MAX; + + virtual ~WebStorageNamespace() { } + + // Create a new WebStorageArea object. Two subsequent calls with the same origin + // will return two different WebStorageArea objects that share the same backing store. + // You should call delete on the returned object when you're finished. + virtual WebStorageArea* createStorageArea(const WebString& origin) = 0; + + // Copy a StorageNamespace. This only makes sense in the case of SessionStorage. + virtual WebStorageNamespace* copy() = 0; + + // Shutdown the StorageNamespace. Write all StorageArea's to disk and disallow new + // write activity. + virtual void close() = 0; +}; + +} // namespace WebKit + +#endif // WebStorageNamespace_h diff --git a/WebKit/chromium/public/WebString.h b/WebKit/chromium/public/WebString.h new file mode 100644 index 0000000..d9b66b2 --- /dev/null +++ b/WebKit/chromium/public/WebString.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebString_h +#define WebString_h + +#include "WebCommon.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { +class String; +class AtomicString; +} +#else +#include <base/nullable_string16.h> +#include <base/string16.h> +#endif + +namespace WebKit { + +class WebCString; +class WebStringPrivate; + +// A UTF-16 string container. It is inexpensive to copy a WebString +// object. +// +// WARNING: It is not safe to pass a WebString across threads!!! +// +class WebString { +public: + ~WebString() { reset(); } + + WebString() : m_private(0) { } + + WebString(const WebUChar* data, size_t len) : m_private(0) + { + assign(data, len); + } + + WebString(const WebString& s) : m_private(0) { assign(s); } + + WebString& operator=(const WebString& s) + { + assign(s); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebString&); + WEBKIT_API void assign(const WebUChar* data, size_t len); + + WEBKIT_API size_t length() const; + WEBKIT_API const WebUChar* data() const; + + bool isEmpty() const { return !length(); } + bool isNull() const { return !m_private; } + + WEBKIT_API WebCString utf8() const; + + WEBKIT_API static WebString fromUTF8(const char* data, size_t length); + WEBKIT_API static WebString fromUTF8(const char* data); + +#if WEBKIT_IMPLEMENTATION + WebString(const WebCore::String&); + WebString& operator=(const WebCore::String&); + operator WebCore::String() const; + + WebString(const WebCore::AtomicString&); + WebString& operator=(const WebCore::AtomicString&); + operator WebCore::AtomicString() const; +#else + WebString(const string16& s) : m_private(0) + { + assign(s.data(), s.length()); + } + + WebString& operator=(const string16& s) + { + assign(s.data(), s.length()); + return *this; + } + + operator string16() const + { + size_t len = length(); + return len ? string16(data(), len) : string16(); + } + + WebString(const NullableString16& s) : m_private(0) + { + if (s.is_null()) + assign(0); + else + assign(s.string().data(), s.string().length()); + } + + WebString& operator=(const NullableString16& s) + { + if (s.is_null()) + assign(0); + else + assign(s.string().data(), s.string().length()); + return *this; + } + + operator NullableString16() const + { + if (!m_private) + return NullableString16(string16(), true); + size_t len = length(); + return NullableString16(len ? string16(data(), len) : string16(), false); + } + + template <class UTF8String> + static WebString fromUTF8(const UTF8String& s) + { + return fromUTF8(s.data(), s.length()); + } +#endif + +private: + void assign(WebStringPrivate*); + WebStringPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebTextAffinity.h b/WebKit/chromium/public/WebTextAffinity.h new file mode 100644 index 0000000..1224f61 --- /dev/null +++ b/WebKit/chromium/public/WebTextAffinity.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebTextAffinity_h +#define WebTextAffinity_h + +namespace WebKit { + +// These constants specify the preferred direction of selection. +enum WebTextAffinity { + WebTextAffinityUpstream, // The selection is moving toward the top of the document. + WebTextAffinityDownstream, // The selection is moving toward the bottom of the document. +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebTextCaseSensitivity.h b/WebKit/chromium/public/WebTextCaseSensitivity.h new file mode 100644 index 0000000..ae5860c --- /dev/null +++ b/WebKit/chromium/public/WebTextCaseSensitivity.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebTextCaseSensitivity_h +#define WebTextCaseSensitivity_h + +namespace WebKit { + +// These constants specify the preferred case sensitivity. +enum WebTextCaseSensitivity { + WebTextCaseSensitive, // String matching is case-sensitive. + WebTextCaseInsensitive, // String matching is case-insensitive. +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebTextDirection.h b/WebKit/chromium/public/WebTextDirection.h new file mode 100644 index 0000000..3d51296 --- /dev/null +++ b/WebKit/chromium/public/WebTextDirection.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebTextDirection_h +#define WebTextDirection_h + +namespace WebKit { + +// Represents text directions (or writing directions) of a DOM node. +enum WebTextDirection { + WebTextDirectionDefault, // Natural writing direction ("inherit") + WebTextDirectionLeftToRight, + WebTextDirectionRightToLeft, +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebURL.h b/WebKit/chromium/public/WebURL.h new file mode 100644 index 0000000..78a16a8 --- /dev/null +++ b/WebKit/chromium/public/WebURL.h @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebURL_h +#define WebURL_h + +#include "WebCString.h" +#include <googleurl/src/url_parse.h> + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class KURL; } +#else +#include <googleurl/src/gurl.h> +#endif + +namespace WebKit { + +class WebURL { +public: + ~WebURL() + { + } + + WebURL() : m_isValid(false) + { + } + + WebURL(const WebCString& spec, const url_parse::Parsed& parsed, bool isValid) + : m_spec(spec) + , m_parsed(parsed) + , m_isValid(isValid) + { + } + + WebURL(const WebURL& s) + : m_spec(s.m_spec) + , m_parsed(s.m_parsed) + , m_isValid(s.m_isValid) + { + } + + WebURL& operator=(const WebURL& s) + { + m_spec = s.m_spec; + m_parsed = s.m_parsed; + m_isValid = s.m_isValid; + return *this; + } + + void assign(const WebCString& spec, const url_parse::Parsed& parsed, bool isValid) + { + m_spec = spec; + m_parsed = parsed; + m_isValid = isValid; + } + + const WebCString& spec() const + { + return m_spec; + } + + const url_parse::Parsed& parsed() const + { + return m_parsed; + } + + bool isValid() const + { + return m_isValid; + } + + bool isEmpty() const + { + return m_spec.isEmpty(); + } + + bool isNull() const + { + return m_spec.isEmpty(); + } + +#if WEBKIT_IMPLEMENTATION + WebURL(const WebCore::KURL&); + WebURL& operator=(const WebCore::KURL&); + operator WebCore::KURL() const; +#else + WebURL(const GURL& g) + : m_spec(g.possibly_invalid_spec()) + , m_parsed(g.parsed_for_possibly_invalid_spec()) + , m_isValid(g.is_valid()) + { + } + + WebURL& operator=(const GURL& g) + { + m_spec = g.possibly_invalid_spec(); + m_parsed = g.parsed_for_possibly_invalid_spec(); + m_isValid = g.is_valid(); + return *this; + } + + operator GURL() const + { + return isNull() ? GURL() : GURL(m_spec.data(), m_spec.length(), m_parsed, m_isValid); + } +#endif + +private: + WebCString m_spec; // UTF-8 encoded + url_parse::Parsed m_parsed; + bool m_isValid; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebURLError.h b/WebKit/chromium/public/WebURLError.h new file mode 100644 index 0000000..de88e3e --- /dev/null +++ b/WebKit/chromium/public/WebURLError.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebURLError_h +#define WebURLError_h + +#include "WebString.h" +#include "WebURL.h" + +#if defined(WEBKIT_IMPLEMENTATION) +namespace WebCore { class ResourceError; } +#endif + +namespace WebKit { + +struct WebURLError { + // A namespace for "reason" to support various layers generating + // resource errors. WebKit does not care about the value of this + // string as it will just be passed via callbacks to the consumer. + WebString domain; + + // A numeric error code detailing the reason for this error. A value + // of 0 means no error. WebKit does not interpret the meaning of other + // values and normally just forwards this error information back to the + // embedder (see for example WebFrameClient). + int reason; + + // The url that failed to load. + WebURL unreachableURL; + + WebURLError() : reason(0) { } + +#if defined(WEBKIT_IMPLEMENTATION) + WebURLError(const WebCore::ResourceError&); + WebURLError& operator=(const WebCore::ResourceError&); + operator WebCore::ResourceError() const; +#endif +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebURLLoader.h b/WebKit/chromium/public/WebURLLoader.h new file mode 100644 index 0000000..54d105e --- /dev/null +++ b/WebKit/chromium/public/WebURLLoader.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebURLLoader_h +#define WebURLLoader_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebData; +class WebURLLoaderClient; +class WebURLRequest; +class WebURLResponse; +struct WebURLError; + +class WebURLLoader { +public: + // The WebURLLoader may be deleted in a call to its client. + virtual ~WebURLLoader() {} + + // Load the request synchronously, returning results directly to the + // caller upon completion. There is no mechanism to interrupt a + // synchronous load!! + virtual void loadSynchronously(const WebURLRequest&, + WebURLResponse&, WebURLError&, WebData& data) = 0; + + // Load the request asynchronously, sending notifications to the given + // client. The client will receive no further notifications if the + // loader is disposed before it completes its work. + virtual void loadAsynchronously(const WebURLRequest&, + WebURLLoaderClient*) = 0; + + // Cancels an asynchronous load. This will appear as a load error to + // the client. + virtual void cancel() = 0; + + // Suspends/resumes an asynchronous load. + virtual void setDefersLoading(bool) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebURLLoaderClient.h b/WebKit/chromium/public/WebURLLoaderClient.h new file mode 100644 index 0000000..03b2c54 --- /dev/null +++ b/WebKit/chromium/public/WebURLLoaderClient.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebURLLoaderClient_h +#define WebURLLoaderClient_h + +namespace WebKit { + +class WebURLLoader; +class WebURLRequest; +class WebURLResponse; +struct WebURLError; + +class WebURLLoaderClient { +public: + // Called when following a redirect. |newRequest| contains the request + // generated by the redirect. The client may modify |newRequest|. + virtual void willSendRequest( + WebURLLoader*, WebURLRequest& newRequest, const WebURLResponse& redirectResponse) = 0; + + // Called to report upload progress. The bytes reported correspond to + // the HTTP message body. + virtual void didSendData( + WebURLLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) = 0; + + // Called when response headers are received. + virtual void didReceiveResponse(WebURLLoader*, const WebURLResponse&) = 0; + + // Called when a chunk of response data is received. + virtual void didReceiveData(WebURLLoader*, const char* data, int dataLength) = 0; + + // Called when the load completes successfully. + virtual void didFinishLoading(WebURLLoader*) = 0; + + // Called when the load completes with an error. + virtual void didFail(WebURLLoader*, const WebURLError&) = 0; + +protected: + ~WebURLLoaderClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebURLRequest.h b/WebKit/chromium/public/WebURLRequest.h new file mode 100644 index 0000000..41443b4 --- /dev/null +++ b/WebKit/chromium/public/WebURLRequest.h @@ -0,0 +1,161 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebURLRequest_h +#define WebURLRequest_h + +#include "WebCommon.h" +#include "WebHTTPBody.h" + +#if defined(WEBKIT_IMPLEMENTATION) +namespace WebCore { class ResourceRequest; } +#endif + +namespace WebKit { + +class WebCString; +class WebHTTPBody; +class WebHTTPHeaderVisitor; +class WebString; +class WebURL; +class WebURLRequestPrivate; + +class WebURLRequest { +public: + enum CachePolicy { + UseProtocolCachePolicy, // normal load + ReloadIgnoringCacheData, // reload + ReturnCacheDataElseLoad, // back/forward or encoding change - allow stale data + ReturnCacheDataDontLoad, // results of a post - allow stale data and only use cache + }; + + enum TargetType { + TargetIsMainFrame = 0, + TargetIsSubFrame = 1, // Temporary for backward compatibility. + TargetIsSubframe = 1, + TargetIsSubResource = 2, // Temporary for backward comptibility. + TargetIsSubresource = 2, + TargetIsStyleSheet = 3, + TargetIsScript = 4, + TargetIsFontResource = 5, + TargetIsImage = 6, + TargetIsObject = 7, + TargetIsMedia = 8 + }; + + ~WebURLRequest() { reset(); } + + WebURLRequest() : m_private(0) { } + WebURLRequest(const WebURLRequest& r) : m_private(0) { assign(r); } + WebURLRequest& operator=(const WebURLRequest& r) + { + assign(r); + return *this; + } + + explicit WebURLRequest(const WebURL& url) : m_private(0) + { + initialize(); + setURL(url); + } + + WEBKIT_API void initialize(); + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebURLRequest&); + + WEBKIT_API bool isNull() const; + + WEBKIT_API WebURL url() const; + WEBKIT_API void setURL(const WebURL&); + + // Used to implement third-party cookie blocking. + WEBKIT_API WebURL firstPartyForCookies() const; + WEBKIT_API void setFirstPartyForCookies(const WebURL&); + + WEBKIT_API bool allowCookies() const; + WEBKIT_API void setAllowCookies(bool allowCookies); + + // Controls whether user name, password, and cookies may be sent with the + // request. (If false, this overrides allowCookies.) + WEBKIT_API bool allowStoredCredentials() const; + WEBKIT_API void setAllowStoredCredentials(bool allowStoredCredentials); + + WEBKIT_API CachePolicy cachePolicy() const; + WEBKIT_API void setCachePolicy(CachePolicy); + + WEBKIT_API WebString httpMethod() const; + WEBKIT_API void setHTTPMethod(const WebString&); + + WEBKIT_API WebString httpHeaderField(const WebString& name) const; + WEBKIT_API void setHTTPHeaderField(const WebString& name, const WebString& value); + WEBKIT_API void addHTTPHeaderField(const WebString& name, const WebString& value); + WEBKIT_API void clearHTTPHeaderField(const WebString& name); + WEBKIT_API void visitHTTPHeaderFields(WebHTTPHeaderVisitor*) const; + + WEBKIT_API WebHTTPBody httpBody() const; + WEBKIT_API void setHTTPBody(const WebHTTPBody&); + + // Controls whether upload progress events are generated when a request + // has a body. + WEBKIT_API bool reportUploadProgress() const; + WEBKIT_API void setReportUploadProgress(bool); + + WEBKIT_API TargetType targetType() const; + WEBKIT_API void setTargetType(TargetType); + + // A consumer controlled value intended to be used to identify the + // requestor. + WEBKIT_API int requestorID() const; + WEBKIT_API void setRequestorID(int); + + // A consumer controlled value intended to be used to identify the + // process of the requestor. + WEBKIT_API int requestorProcessID() const; + WEBKIT_API void setRequestorProcessID(int); + + // Allows the request to be matched up with its app cache host. + WEBKIT_API int appCacheHostID() const; + WEBKIT_API void setAppCacheHostID(int id); + +#if defined(WEBKIT_IMPLEMENTATION) + WebCore::ResourceRequest& toMutableResourceRequest(); + const WebCore::ResourceRequest& toResourceRequest() const; +#endif + +protected: + void assign(WebURLRequestPrivate*); + +private: + WebURLRequestPrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebURLResponse.h b/WebKit/chromium/public/WebURLResponse.h new file mode 100644 index 0000000..cdac83c --- /dev/null +++ b/WebKit/chromium/public/WebURLResponse.h @@ -0,0 +1,130 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebURLResponse_h +#define WebURLResponse_h + +#include "WebCommon.h" + +#if defined(WEBKIT_IMPLEMENTATION) +namespace WebCore { class ResourceResponse; } +#endif + +namespace WebKit { + +class WebCString; +class WebHTTPHeaderVisitor; +class WebString; +class WebURL; +class WebURLResponsePrivate; + +class WebURLResponse { +public: + ~WebURLResponse() { reset(); } + + WebURLResponse() : m_private(0) { } + WebURLResponse(const WebURLResponse& r) : m_private(0) { assign(r); } + WebURLResponse& operator=(const WebURLResponse& r) + { + assign(r); + return *this; + } + + explicit WebURLResponse(const WebURL& url) : m_private(0) + { + initialize(); + setURL(url); + } + + WEBKIT_API void initialize(); + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebURLResponse&); + + WEBKIT_API bool isNull() const; + + WEBKIT_API WebURL url() const; + WEBKIT_API void setURL(const WebURL&); + + WEBKIT_API WebString mimeType() const; + WEBKIT_API void setMIMEType(const WebString&); + + WEBKIT_API long long expectedContentLength() const; + WEBKIT_API void setExpectedContentLength(long long); + + WEBKIT_API WebString textEncodingName() const; + WEBKIT_API void setTextEncodingName(const WebString&); + + WEBKIT_API WebString suggestedFileName() const; + WEBKIT_API void setSuggestedFileName(const WebString&); + + WEBKIT_API int httpStatusCode() const; + WEBKIT_API void setHTTPStatusCode(int); + + WEBKIT_API WebString httpStatusText() const; + WEBKIT_API void setHTTPStatusText(const WebString&); + + WEBKIT_API WebString httpHeaderField(const WebString& name) const; + WEBKIT_API void setHTTPHeaderField(const WebString& name, const WebString& value); + WEBKIT_API void addHTTPHeaderField(const WebString& name, const WebString& value); + WEBKIT_API void clearHTTPHeaderField(const WebString& name); + WEBKIT_API void visitHTTPHeaderFields(WebHTTPHeaderVisitor*) const; + + WEBKIT_API double lastModifiedDate() const; + WEBKIT_API void setLastModifiedDate(double); + + WEBKIT_API bool isContentFiltered() const; + WEBKIT_API void setIsContentFiltered(bool); + + WEBKIT_API long long appCacheID() const; + WEBKIT_API void setAppCacheID(long long); + + WEBKIT_API WebURL appCacheManifestURL() const; + WEBKIT_API void setAppCacheManifestURL(const WebURL&); + + // A consumer controlled value intended to be used to record opaque + // security info related to this request. + WEBKIT_API WebCString securityInfo() const; + WEBKIT_API void setSecurityInfo(const WebCString&); + +#if defined(WEBKIT_IMPLEMENTATION) + WebCore::ResourceResponse& toMutableResourceResponse(); + const WebCore::ResourceResponse& toResourceResponse() const; +#endif + +protected: + void assign(WebURLResponsePrivate*); + +private: + WebURLResponsePrivate* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebVector.h b/WebKit/chromium/public/WebVector.h new file mode 100644 index 0000000..d1f99b4 --- /dev/null +++ b/WebKit/chromium/public/WebVector.h @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebVector_h +#define WebVector_h + +#include "WebCommon.h" + +#include <algorithm> + +namespace WebKit { + +// A simple vector class. +// +// Sample usage: +// +// void Foo(WebVector<int>& result) +// { +// WebVector<int> data(10); +// for (size_t i = 0; i < data.size(); ++i) +// data[i] = ... +// result.swap(data); +// } +// +// It is also possible to assign from other types of random access +// containers: +// +// void Foo(const std::vector<std::string>& input) +// { +// WebVector<WebCString> cstrings = input; +// ... +// } +// +template <typename T> +class WebVector { +public: + typedef T ValueType; + + ~WebVector() + { + destroy(); + } + + explicit WebVector(size_t size = 0) + { + initialize(size); + } + + WebVector(const WebVector<T>& other) + { + initializeFrom(other.m_ptr, other.m_size); + } + + template <typename C> + WebVector(const C& other) + { + initializeFrom(other.size() ? &other[0] : 0, other.size()); + } + + template <typename C> + WebVector<T>& operator=(const C& other) + { + if (this != reinterpret_cast<const WebVector<T>*>(&other)) + assign(other); + return *this; + } + + template <typename C> + void assign(const C& other) + { + assign(other.size() ? &other[0] : 0, other.size()); + } + + template <typename U> + void assign(const U* values, size_t size) + { + destroy(); + initializeFrom(values, size); + } + + size_t size() const { return m_size; } + bool isEmpty() const { return !m_size; } + + T& operator[](size_t i) { return m_ptr[i]; } + const T& operator[](size_t i) const { return m_ptr[i]; } + + T* data() { return m_ptr; } + const T* data() const { return m_ptr; } + + void swap(WebVector<T>& other) + { + std::swap(m_ptr, other.m_ptr); + std::swap(m_size, other.m_size); + } + +private: + void initialize(size_t size) + { + m_size = size; + if (!m_size) + m_ptr = 0; + else { + m_ptr = static_cast<T*>(::operator new(sizeof(T) * m_size)); + for (size_t i = 0; i < m_size; ++i) + new (&m_ptr[i]) T(); + } + } + + template <typename U> + void initializeFrom(const U* values, size_t size) + { + m_size = size; + if (!m_size) + m_ptr = 0; + else { + m_ptr = static_cast<T*>(::operator new(sizeof(T) * m_size)); + for (size_t i = 0; i < m_size; ++i) + new (&m_ptr[i]) T(values[i]); + } + } + + void destroy() + { + for (size_t i = 0; i < m_size; ++i) + m_ptr[i].~T(); + ::operator delete(m_ptr); + } + + T* m_ptr; + size_t m_size; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebView.h b/WebKit/chromium/public/WebView.h new file mode 100644 index 0000000..5e1f15d --- /dev/null +++ b/WebKit/chromium/public/WebView.h @@ -0,0 +1,265 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebView_h +#define WebView_h + +#include "WebDragOperation.h" +#include "WebWidget.h" + +namespace WebKit { + +class WebAccessibilityObject; +class WebDevToolsAgent; +class WebDragData; +class WebFrame; +class WebFrameClient; +class WebNode; +class WebSettings; +class WebString; +class WebViewClient; +struct WebMediaPlayerAction; +struct WebPoint; +template <typename T> class WebVector; + +class WebView : public WebWidget { +public: + // Initialization ------------------------------------------------------ + + // Creates a WebView that is NOT yet initialized. You will need to + // call initializeMainFrame to finish the initialization. It is valid + // to pass a null WebViewClient pointer. + WEBKIT_API static WebView* create(WebViewClient*); + + // After creating a WebView, you should immediately call this method. + // You can optionally modify the settings before calling this method. + // The WebFrameClient will receive events for the main frame and any + // child frames. It is valid to pass a null WebFrameClient pointer. + virtual void initializeMainFrame(WebFrameClient*) = 0; + + + // Options ------------------------------------------------------------- + + // The returned pointer is valid for the lifetime of the WebView. + virtual WebSettings* settings() = 0; + + // Corresponds to the encoding of the main frame. Setting the page + // encoding may cause the main frame to reload. + virtual WebString pageEncoding() const = 0; + virtual void setPageEncoding(const WebString&) = 0; + + // Makes the WebView transparent. This is useful if you want to have + // some custom background rendered behind it. + virtual bool isTransparent() const = 0; + virtual void setIsTransparent(bool) = 0; + + // Controls whether pressing Tab key advances focus to links. + virtual bool tabsToLinks() const = 0; + virtual void setTabsToLinks(bool) = 0; + + // Method that controls whether pressing Tab key cycles through page + // elements or inserts a '\t' char in the focused text area. + virtual bool tabKeyCyclesThroughElements() const = 0; + virtual void setTabKeyCyclesThroughElements(bool) = 0; + + // Controls the WebView's active state, which may affect the rendering + // of elements on the page (i.e., tinting of input elements). + virtual bool isActive() const = 0; + virtual void setIsActive(bool) = 0; + + + // Closing ------------------------------------------------------------- + + // Runs beforeunload handlers for the current page, returning false if + // any handler suppressed unloading. + virtual bool dispatchBeforeUnloadEvent() = 0; + + // Runs unload handlers for the current page. + virtual void dispatchUnloadEvent() = 0; + + + // Frames -------------------------------------------------------------- + + virtual WebFrame* mainFrame() = 0; + + // Returns the frame identified by the given name. This method + // supports pseudo-names like _self, _top, and _blank. It traverses + // the entire frame tree containing this tree looking for a frame that + // matches the given name. If the optional relativeToFrame parameter + // is specified, then the search begins with the given frame and its + // children. + virtual WebFrame* findFrameByName( + const WebString& name, WebFrame* relativeToFrame = 0) = 0; + + + // Focus --------------------------------------------------------------- + + virtual WebFrame* focusedFrame() = 0; + virtual void setFocusedFrame(WebFrame*) = 0; + + // Focus the first (last if reverse is true) focusable node. + virtual void setInitialFocus(bool reverse) = 0; + + // Clears the focused node (and selection if a text field is focused) + // to ensure that a text field on the page is not eating keystrokes we + // send it. + virtual void clearFocusedNode() = 0; + + + // Zoom ---------------------------------------------------------------- + + // Returns the current zoom level. 0 is "original size", and each increment + // above or below represents zooming 20% larger or smaller to limits of 300% + // and 50% of original size, respectively. + virtual int zoomLevel() = 0; + + // Changes the zoom level to the specified level, clamping at the limits + // noted above, and returns the current zoom level after applying the + // change. + // + // If |textOnly| is set, only the text will be zoomed; otherwise the entire + // page will be zoomed. You can only have either text zoom or full page zoom + // at one time. Changing the mode while the page is zoomed will have odd + // effects. + virtual int setZoomLevel(bool textOnly, int zoomLevel) = 0; + + + // Media --------------------------------------------------------------- + + // Performs the specified action on the node at the given location. + virtual void performMediaPlayerAction( + const WebMediaPlayerAction&, const WebPoint& location) = 0; + + + // Data exchange ------------------------------------------------------- + + // Copy to the clipboard the image located at a particular point in the + // WebView (if there is such an image) + virtual void copyImageAt(const WebPoint&) = 0; + + // Notifies the WebView that a drag has terminated. + virtual void dragSourceEndedAt( + const WebPoint& clientPoint, const WebPoint& screenPoint, + WebDragOperation operation) = 0; + + // Notfies the WebView that the system drag and drop operation has ended. + virtual void dragSourceSystemDragEnded() = 0; + + // Callback methods when a drag-and-drop operation is trying to drop + // something on the WebView. + virtual WebDragOperation dragTargetDragEnter( + const WebDragData&, int identity, + const WebPoint& clientPoint, const WebPoint& screenPoint, + WebDragOperationsMask operationsAllowed) = 0; + virtual WebDragOperation dragTargetDragOver( + const WebPoint& clientPoint, const WebPoint& screenPoint, + WebDragOperationsMask operationsAllowed) = 0; + virtual void dragTargetDragLeave() = 0; + virtual void dragTargetDrop( + const WebPoint& clientPoint, const WebPoint& screenPoint) = 0; + + virtual int dragIdentity() = 0; + + // Helper method for drag and drop target operations: override the + // default drop effect with either a "copy" (accept true) or "none" + // (accept false) effect. Return true on success. + virtual bool setDropEffect(bool accept) = 0; + + + // Support for resource loading initiated by plugins ------------------- + + // Returns next unused request identifier which is unique within the + // parent Page. + virtual unsigned long createUniqueIdentifierForRequest() = 0; + + + // Developer tools ----------------------------------------------------- + + // Inspect a particular point in the WebView. (x = -1 || y = -1) is a + // special case, meaning inspect the current page and not a specific + // point. + virtual void inspectElementAt(const WebPoint&) = 0; + + // Settings used by the inspector. + virtual WebString inspectorSettings() const = 0; + virtual void setInspectorSettings(const WebString&) = 0; + + // The embedder may optionally engage a WebDevToolsAgent. This may only + // be set once per WebView. + virtual WebDevToolsAgent* devToolsAgent() = 0; + virtual void setDevToolsAgent(WebDevToolsAgent*) = 0; + + + // Accessibility ------------------------------------------------------- + + // Returns the accessibility object for this view. + virtual WebAccessibilityObject accessibilityObject() = 0; + + + // Autofill ------------------------------------------------------------ + + // Notifies the WebView that autofill suggestions are available for a node. + virtual void applyAutofillSuggestions( + const WebNode&, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex) = 0; + + // Hides the autofill popup if any are showing. + virtual void hideAutofillPopup() = 0; + + + // Context menu -------------------------------------------------------- + + virtual void performCustomContextMenuAction(unsigned action) = 0; + + + // Visited link state -------------------------------------------------- + + // Tells all WebView instances to update the visited link state for the + // specified hash. + WEBKIT_API static void updateVisitedLinkState(unsigned long long hash); + + // Tells all WebView instances to update the visited state for all + // their links. + WEBKIT_API static void resetVisitedLinkState(); + + + // Scrollbar colors ---------------------------------------------------- + virtual void setScrollbarColors(unsigned inactiveColor, + unsigned activeColor, + unsigned trackColor) = 0; + +protected: + ~WebView() {} +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebViewClient.h b/WebKit/chromium/public/WebViewClient.h new file mode 100644 index 0000000..2e2f953 --- /dev/null +++ b/WebKit/chromium/public/WebViewClient.h @@ -0,0 +1,278 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebViewClient_h +#define WebViewClient_h + +#include "WebDragOperation.h" +#include "WebEditingAction.h" +#include "WebFileChooserCompletion.h" +#include "WebString.h" +#include "WebTextAffinity.h" +#include "WebTextDirection.h" +#include "WebWidgetClient.h" + +namespace WebKit { + +class WebAccessibilityObject; +class WebDragData; +class WebFileChooserCompletion; +class WebFrame; +class WebNode; +class WebNotificationPresenter; +class WebRange; +class WebURL; +class WebView; +class WebWidget; +struct WebConsoleMessage; +struct WebContextMenuData; +struct WebPoint; +struct WebPopupMenuInfo; + +// Since a WebView is a WebWidget, a WebViewClient is a WebWidgetClient. +// Virtual inheritance allows an implementation of WebWidgetClient to be +// easily reused as part of an implementation of WebViewClient. +class WebViewClient : virtual public WebWidgetClient { +public: + // Factory methods ----------------------------------------------------- + + // Create a new related WebView. + virtual WebView* createView(WebFrame* creator) { return 0; } + + // Create a new WebPopupMenu. In the second form, the client is + // responsible for rendering the contents of the popup menu. + virtual WebWidget* createPopupMenu(bool activatable) { return 0; } + virtual WebWidget* createPopupMenu(const WebPopupMenuInfo&) { return 0; } + + + // Misc ---------------------------------------------------------------- + + // A new message was added to the console. + virtual void didAddMessageToConsole( + const WebConsoleMessage&, const WebString& sourceName, unsigned sourceLine) { } + + // Called when script in the page calls window.print(). If frame is + // non-null, then it selects a particular frame, including its + // children, to print. Otherwise, the main frame and its children + // should be printed. + virtual void printPage(WebFrame*) { } + + // Called to retrieve the provider of desktop notifications. + virtual WebNotificationPresenter* notificationPresenter() { return 0; } + + + // Navigational -------------------------------------------------------- + + // These notifications bracket any loading that occurs in the WebView. + virtual void didStartLoading() { } + virtual void didStopLoading() { } + + + // Editing ------------------------------------------------------------- + + // These methods allow the client to intercept and overrule editing + // operations. + virtual bool shouldBeginEditing(const WebRange&) { return true; } + virtual bool shouldEndEditing(const WebRange&) { return true; } + virtual bool shouldInsertNode( + const WebNode&, const WebRange&, WebEditingAction) { return true; } + virtual bool shouldInsertText( + const WebString&, const WebRange&, WebEditingAction) { return true; } + virtual bool shouldChangeSelectedRange( + const WebRange& from, const WebRange& to, WebTextAffinity, + bool stillSelecting) { return true; } + virtual bool shouldDeleteRange(const WebRange&) { return true; } + virtual bool shouldApplyStyle(const WebString& style, const WebRange&) { return true; } + + virtual bool isSmartInsertDeleteEnabled() { return true; } + virtual bool isSelectTrailingWhitespaceEnabled() { return true; } + virtual void setInputMethodEnabled(bool enabled) { } + + virtual void didBeginEditing() { } + virtual void didChangeSelection(bool isSelectionEmpty) { } + virtual void didChangeContents() { } + virtual void didExecuteCommand(const WebString& commandName) { } + virtual void didEndEditing() { } + + // This method is called in response to WebView's handleInputEvent() + // when the default action for the current keyboard event is not + // suppressed by the page, to give the embedder a chance to handle + // the keyboard event specially. + // + // Returns true if the keyboard event was handled by the embedder, + // indicating that the default action should be suppressed. + virtual bool handleCurrentKeyboardEvent() { return false; } + + + // Spellchecker -------------------------------------------------------- + + // The client should perform spell-checking on the given text. If the + // text contains a misspelled word, then upon return misspelledOffset + // will point to the start of the misspelled word, and misspelledLength + // will indicates its length. Otherwise, if there was not a spelling + // error, then upon return misspelledLength is 0. + virtual void spellCheck( + const WebString& text, int& misspelledOffset, int& misspelledLength) { } + + // Computes an auto-corrected replacement for a misspelled word. If no + // replacement is found, then an empty string is returned. + virtual WebString autoCorrectWord(const WebString& misspelledWord) { return WebString(); } + + // Show or hide the spelling UI. + virtual void showSpellingUI(bool show) { } + + // Returns true if the spelling UI is showing. + virtual bool isShowingSpellingUI() { return false; } + + // Update the spelling UI with the given word. + virtual void updateSpellingUIWithMisspelledWord(const WebString& word) { } + + + // Dialogs ------------------------------------------------------------- + + // This method returns immediately after showing the dialog. When the + // dialog is closed, it should call the WebFileChooserCompletion to + // pass the results of the dialog. Returns false if + // WebFileChooseCompletion will never be called. + virtual bool runFileChooser( + bool multiSelect, const WebString& title, + const WebString& initialValue, WebFileChooserCompletion*) { return false; } + + // Displays a modal alert dialog containing the given message. Returns + // once the user dismisses the dialog. + virtual void runModalAlertDialog( + WebFrame*, const WebString& message) { } + + // Displays a modal confirmation dialog with the given message as + // description and OK/Cancel choices. Returns true if the user selects + // 'OK' or false otherwise. + virtual bool runModalConfirmDialog( + WebFrame*, const WebString& message) { return false; } + + // Displays a modal input dialog with the given message as description + // and OK/Cancel choices. The input field is pre-filled with + // defaultValue. Returns true if the user selects 'OK' or false + // otherwise. Upon returning true, actualValue contains the value of + // the input field. + virtual bool runModalPromptDialog( + WebFrame*, const WebString& message, const WebString& defaultValue, + WebString* actualValue) { return false; } + + // Displays a modal confirmation dialog containing the given message as + // description and OK/Cancel choices, where 'OK' means that it is okay + // to proceed with closing the view. Returns true if the user selects + // 'OK' or false otherwise. + virtual bool runModalBeforeUnloadDialog( + WebFrame*, const WebString& message) { return true; } + + + // UI ------------------------------------------------------------------ + + // Called when script modifies window.status + virtual void setStatusText(const WebString&) { } + + // Called when hovering over an anchor with the given URL. + virtual void setMouseOverURL(const WebURL&) { } + + // Called when keyboard focus switches to an anchor with the given URL. + virtual void setKeyboardFocusURL(const WebURL&) { } + + // Called when a tooltip should be shown at the current cursor position. + virtual void setToolTipText(const WebString&, WebTextDirection hint) { } + + // Shows a context menu with commands relevant to a specific element on + // the given frame. Additional context data is supplied. + virtual void showContextMenu(WebFrame*, const WebContextMenuData&) { } + + // Called when a drag-n-drop operation should begin. + virtual void startDragging( + const WebPoint& from, const WebDragData&, WebDragOperationsMask) { } + + // Called to determine if drag-n-drop operations may initiate a page + // navigation. + virtual bool acceptsLoadDrops() { return true; } + + // Take focus away from the WebView by focusing an adjacent UI element + // in the containing window. + virtual void focusNext() { } + virtual void focusPrevious() { } + + + // Session history ----------------------------------------------------- + + // Tells the embedder to navigate back or forward in session history by + // the given offset (relative to the current position in session + // history). + virtual void navigateBackForwardSoon(int offset) { } + + // Returns the number of history items before/after the current + // history item. + virtual int historyBackListCount() { return 0; } + virtual int historyForwardListCount() { return 0; } + + // Called to notify the embedder when a new history item is added. + virtual void didAddHistoryItem() { } + + + // Accessibility ------------------------------------------------------- + + // Notifies embedder that the focus has changed to the given + // accessibility object. + virtual void focusAccessibilityObject(const WebAccessibilityObject&) { } + + + // Developer tools ----------------------------------------------------- + + // Called to notify the client that the inspector's settings were + // changed and should be saved. See WebView::inspectorSettings. + virtual void didUpdateInspectorSettings() { } + + + // Autofill ------------------------------------------------------------ + + // Queries the browser for suggestions to be shown for the form text + // field named |name|. |value| is the text entered by the user so + // far and the WebNode corresponds to the input field. + virtual void queryAutofillSuggestions(const WebNode&, + const WebString& name, + const WebString& value) { } + + // Instructs the browser to remove the autofill entry specified from + // its DB. + virtual void removeAutofillSuggestions(const WebString& name, + const WebString& value) { } + +protected: + ~WebViewClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebWidget.h b/WebKit/chromium/public/WebWidget.h new file mode 100644 index 0000000..9dfeefc --- /dev/null +++ b/WebKit/chromium/public/WebWidget.h @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebWidget_h +#define WebWidget_h + +#include "WebCanvas.h" +#include "WebCommon.h" +#include "WebCompositionCommand.h" +#include "WebTextDirection.h" + +namespace WebKit { + +class WebInputEvent; +class WebString; +struct WebRect; +struct WebSize; + +class WebWidget { +public: + // This method closes and deletes the WebWidget. + virtual void close() = 0; + + // Returns the current size of the WebWidget. + virtual WebSize size() = 0; + + // Called to resize the WebWidget. + virtual void resize(const WebSize&) = 0; + + // Called to layout the WebWidget. This MUST be called before Paint, + // and it may result in calls to WebWidgetClient::didInvalidateRect. + virtual void layout() = 0; + + // Called to paint the specified region of the WebWidget onto the given + // canvas. You MUST call Layout before calling this method. It is + // okay to call paint multiple times once layout has been called, + // assuming no other changes are made to the WebWidget (e.g., once + // events are processed, it should be assumed that another call to + // layout is warranted before painting again). + virtual void paint(WebCanvas*, const WebRect&) = 0; + + // Called to inform the WebWidget of an input event. Returns true if + // the event has been processed, false otherwise. + virtual bool handleInputEvent(const WebInputEvent&) = 0; + + // Called to inform the WebWidget that mouse capture was lost. + virtual void mouseCaptureLost() = 0; + + // Called to inform the WebWidget that it has gained or lost keyboard focus. + virtual void setFocus(bool) = 0; + + // Called to inform the WebWidget of a composition event. + virtual bool handleCompositionEvent(WebCompositionCommand command, + int cursorPosition, + int targetStart, + int targetEnd, + const WebString& text) = 0; + + // Retrieve the status of this WebWidget required by IME APIs. Upon + // success enabled and caretBounds are set. + virtual bool queryCompositionStatus(bool* enabled, WebRect* caretBounds) = 0; + + // Changes the text direction of the selected input node. + virtual void setTextDirection(WebTextDirection) = 0; + +protected: + ~WebWidget() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebWidgetClient.h b/WebKit/chromium/public/WebWidgetClient.h new file mode 100644 index 0000000..06d9eba --- /dev/null +++ b/WebKit/chromium/public/WebWidgetClient.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebWidgetClient_h +#define WebWidgetClient_h + +#include "WebCommon.h" +#include "WebNavigationPolicy.h" +#include "WebRect.h" +#include "WebScreenInfo.h" + +namespace WebKit { + +class WebWidget; +struct WebCursorInfo; + +class WebWidgetClient { +public: + // Called when a region of the WebWidget needs to be re-painted. + virtual void didInvalidateRect(const WebRect&) { } + + // Called when a region of the WebWidget, given by clipRect, should be + // scrolled by the specified dx and dy amounts. + virtual void didScrollRect(int dx, int dy, const WebRect& clipRect) { } + + // Called when the widget acquires or loses focus, respectively. + virtual void didFocus() { } + virtual void didBlur() { } + + // Called when the cursor for the widget changes. + virtual void didChangeCursor(const WebCursorInfo&) { } + + // Called when the widget should be closed. WebWidget::close() should + // be called asynchronously as a result of this notification. + virtual void closeWidgetSoon() { } + + // Called to show the widget according to the given policy. + virtual void show(WebNavigationPolicy) { } + + // Called to block execution of the current thread until the widget is + // closed. + virtual void runModal() { } + + // Called to get/set the position of the widget in screen coordinates. + virtual WebRect windowRect() { return WebRect(); } + virtual void setWindowRect(const WebRect&) { } + + // Called to get the position of the resizer rect in window coordinates. + virtual WebRect windowResizerRect() { return WebRect(); } + + // Called to get the position of the root window containing the widget + // in screen coordinates. + virtual WebRect rootWindowRect() { return WebRect(); } + + // Called to query information about the screen where this widget is + // displayed. + virtual WebScreenInfo screenInfo() { return WebScreenInfo(); } + +protected: + ~WebWidgetClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebWorker.h b/WebKit/chromium/public/WebWorker.h new file mode 100644 index 0000000..9397bcd --- /dev/null +++ b/WebKit/chromium/public/WebWorker.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebWorker_h +#define WebWorker_h + +#include "WebMessagePortChannel.h" + +namespace WebKit { + +class WebString; +class WebURL; +class WebWorkerClient; + +// Provides an interface to the script execution context for a worker. +class WebWorker { +public: + // Instantiates a built-in WebWorker. + WEBKIT_API static WebWorker* create(WebWorkerClient*); + + virtual ~WebWorker() { } + virtual void startWorkerContext(const WebURL& scriptURL, + const WebString& userAgent, + const WebString& sourceCode) = 0; + virtual void terminateWorkerContext() = 0; + virtual void postMessageToWorkerContext( + const WebString&, + const WebMessagePortChannelArray&) = 0; + virtual void workerObjectDestroyed() = 0; + virtual void clientDestroyed() = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebWorkerClient.h b/WebKit/chromium/public/WebWorkerClient.h new file mode 100644 index 0000000..eb2e63e --- /dev/null +++ b/WebKit/chromium/public/WebWorkerClient.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebWorkerClient_h +#define WebWorkerClient_h + +#include "WebCommonWorkerClient.h" +#include "WebMessagePortChannel.h" + +namespace WebKit { + +class WebNotificationPresenter; +class WebString; +class WebWorker; + +// Provides an interface back to the in-page script object for a worker. +// All functions are expected to be called back on the thread that created +// the Worker object, unless noted. +class WebWorkerClient : public WebCommonWorkerClient { +public: + virtual void postMessageToWorkerObject( + const WebString&, + const WebMessagePortChannelArray&) = 0; + + virtual void confirmMessageFromWorkerObject(bool hasPendingActivity) = 0; + virtual void reportPendingActivity(bool hasPendingActivity) = 0; + +protected: + ~WebWorkerClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/gtk/WebFontInfo.h b/WebKit/chromium/public/gtk/WebFontInfo.h new file mode 100644 index 0000000..ad37680 --- /dev/null +++ b/WebKit/chromium/public/gtk/WebFontInfo.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFontInfo_h +#define WebFontInfo_h + +#include "../WebCString.h" + +#include <string.h> +#include <unistd.h> + +namespace WebKit { + +class WebFontInfo { +public: + // Return a font family which provides glyphs for the Unicode code points + // specified by |utf16| + // characters: a native-endian UTF16 string + // numCharacters: the number of 16-bit words in |utf16| + // + // Returns: the font family or an empty string if the request could not be + // satisfied. + WEBKIT_API static WebCString familyForChars(const WebUChar* characters, size_t numCharacters); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/gtk/WebInputEventFactory.h b/WebKit/chromium/public/gtk/WebInputEventFactory.h new file mode 100644 index 0000000..463bd28 --- /dev/null +++ b/WebKit/chromium/public/gtk/WebInputEventFactory.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebInputEventFactory_h +#define WebInputEventFactory_h + +#include "../WebCommon.h" + +typedef struct _GdkEventButton GdkEventButton; +typedef struct _GdkEventMotion GdkEventMotion; +typedef struct _GdkEventCrossing GdkEventCrossing; +typedef struct _GdkEventScroll GdkEventScroll; +typedef struct _GdkEventKey GdkEventKey; + +namespace WebKit { + +class WebKeyboardEvent; +class WebMouseEvent; +class WebMouseWheelEvent; + +class WebInputEventFactory { +public: + WEBKIT_API static WebKeyboardEvent keyboardEvent(const GdkEventKey*); + WEBKIT_API static WebKeyboardEvent keyboardEvent(wchar_t character, int state, double timeStampSeconds); + WEBKIT_API static WebMouseEvent mouseEvent(const GdkEventButton*); + WEBKIT_API static WebMouseEvent mouseEvent(const GdkEventMotion*); + WEBKIT_API static WebMouseEvent mouseEvent(const GdkEventCrossing*); + WEBKIT_API static WebMouseWheelEvent mouseWheelEvent(const GdkEventScroll*); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/gtk/WebScreenInfoFactory.h b/WebKit/chromium/public/gtk/WebScreenInfoFactory.h new file mode 100644 index 0000000..c964741 --- /dev/null +++ b/WebKit/chromium/public/gtk/WebScreenInfoFactory.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebScreenInfoFactory_h +#define WebScreenInfoFactory_h + +#include "../WebCommon.h" + +typedef struct _GtkWidget GtkWidget; + +namespace WebKit { + +struct WebScreenInfo; + +class WebScreenInfoFactory { +public: + WEBKIT_API static WebScreenInfo screenInfo(GtkWidget*); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/linux/WebFontRendering.h b/WebKit/chromium/public/linux/WebFontRendering.h new file mode 100644 index 0000000..9b61bdc --- /dev/null +++ b/WebKit/chromium/public/linux/WebFontRendering.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFontRendering_h +#define WebFontRendering_h + +#include "../WebCommon.h" +#include <SkFontHost.h> +#include <SkPaint.h> + +namespace WebKit { + +class WebFontRendering { +public: + // Set global font renderering preferences. + + WEBKIT_API static void setHinting(SkPaint::Hinting); + WEBKIT_API static void setAntiAlias(bool on); + WEBKIT_API static void setSubpixelGlyphs(bool on); + WEBKIT_API static void setLCDOrder(SkFontHost::LCDOrder); + WEBKIT_API static void setLCDOrientation(SkFontHost::LCDOrientation); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/linux/WebSandboxSupport.h b/WebKit/chromium/public/linux/WebSandboxSupport.h new file mode 100644 index 0000000..5edceb2 --- /dev/null +++ b/WebKit/chromium/public/linux/WebSandboxSupport.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSandboxSupport_h +#define WebSandboxSupport_h + +#include "../WebCommon.h" +#include "../WebString.h" + +namespace WebKit { + +// Put methods here that are required due to sandbox restrictions. +class WebSandboxSupport { +public: + // Fonts --------------------------------------------------------------- + + // Get a font family which contains glyphs for the given Unicode + // code-points. + // characters: a UTF-16 encoded string + // numCharacters: the number of 16-bit words in |characters| + // + // Returns a string with the font family on an empty string if the + // request cannot be satisfied. + virtual WebString getFontFamilyForCharacters(const WebUChar* characters, size_t numCharacters) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/mac/WebInputEventFactory.h b/WebKit/chromium/public/mac/WebInputEventFactory.h new file mode 100644 index 0000000..cbf213c --- /dev/null +++ b/WebKit/chromium/public/mac/WebInputEventFactory.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebInputEventFactory_h +#define WebInputEventFactory_h + +#include "../WebCommon.h" + +#ifdef __OBJC__ +@class NSEvent; +@class NSView; +#else +class NSEvent; +class NSView; +#endif + +namespace WebKit { + +class WebKeyboardEvent; +class WebMouseEvent; +class WebMouseWheelEvent; + +class WebInputEventFactory { +public: + WEBKIT_API static WebKeyboardEvent keyboardEvent(NSEvent*); + WEBKIT_API static WebKeyboardEvent keyboardEvent(wchar_t character, int modifiers, double timeStampSeconds); + WEBKIT_API static WebMouseEvent mouseEvent(NSEvent*, NSView*); + WEBKIT_API static WebMouseWheelEvent mouseWheelEvent(NSEvent*, NSView*); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/mac/WebScreenInfoFactory.h b/WebKit/chromium/public/mac/WebScreenInfoFactory.h new file mode 100644 index 0000000..485e77f --- /dev/null +++ b/WebKit/chromium/public/mac/WebScreenInfoFactory.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebScreenInfoFactory_h +#define WebScreenInfoFactory_h + +#include "../WebCommon.h" + +#ifdef __OBJC__ +@class NSView; +#else +class NSView; +#endif + +namespace WebKit { + +struct WebScreenInfo; + +class WebScreenInfoFactory { +public: + WEBKIT_API static WebScreenInfo screenInfo(NSView*); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/win/WebInputEventFactory.h b/WebKit/chromium/public/win/WebInputEventFactory.h new file mode 100644 index 0000000..ae02464 --- /dev/null +++ b/WebKit/chromium/public/win/WebInputEventFactory.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebInputEventFactory_h +#define WebInputEventFactory_h + +#include "../WebCommon.h" + +#include <windows.h> + +namespace WebKit { + +class WebKeyboardEvent; +class WebMouseEvent; +class WebMouseWheelEvent; + +class WebInputEventFactory { +public: + WEBKIT_API static WebKeyboardEvent keyboardEvent(HWND, UINT, WPARAM, LPARAM); + WEBKIT_API static WebMouseEvent mouseEvent(HWND, UINT, WPARAM, LPARAM); + WEBKIT_API static WebMouseWheelEvent mouseWheelEvent(HWND, UINT, WPARAM, LPARAM); + + // Windows only provides information on whether a click was a single or + // double click, while we need to know the click count past two. The + // WebInputEventFactory keeps internal state to allow it to synthesize + // that information. In some cases, like fast-running tests, that + // information is known to be stale and needs to be reset; that is the + // function of resetLastClickState(). + WEBKIT_API static void resetLastClickState(); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/win/WebSandboxSupport.h b/WebKit/chromium/public/win/WebSandboxSupport.h new file mode 100644 index 0000000..88d5362 --- /dev/null +++ b/WebKit/chromium/public/win/WebSandboxSupport.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSandboxSupport_h +#define WebSandboxSupport_h + +typedef struct HFONT__* HFONT; + +namespace WebKit { + +// Put methods here that are required due to sandbox restrictions. +class WebSandboxSupport { +public: + // Sometimes a Win32 API call will fail because a font is not loaded, + // and due to sandbox restrictions, the current process may be unable + // to access the filesystem to load the font. So, this call serves as + // a failover to ask the embedder to try some other way to load the + // font (usually by delegating to an empowered process to have it load + // the font). Returns true if the font was successfully loaded. + virtual bool ensureFontLoaded(HFONT) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/win/WebScreenInfoFactory.h b/WebKit/chromium/public/win/WebScreenInfoFactory.h new file mode 100644 index 0000000..a7040ea --- /dev/null +++ b/WebKit/chromium/public/win/WebScreenInfoFactory.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebScreenInfoFactory_h +#define WebScreenInfoFactory_h + +#include "../WebCommon.h" + +typedef struct HWND__* HWND; + +namespace WebKit { + +struct WebScreenInfo; + +class WebScreenInfoFactory { +public: + WEBKIT_API static WebScreenInfo screenInfo(HWND); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/win/WebThemeEngine.h b/WebKit/chromium/public/win/WebThemeEngine.h new file mode 100644 index 0000000..b563608 --- /dev/null +++ b/WebKit/chromium/public/win/WebThemeEngine.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebThemeEngine_h +#define WebThemeEngine_h + +#include "../WebCanvas.h" +#include "../WebColor.h" + +namespace WebKit { + +struct WebRect; + +// The part and state parameters correspond to values defined by the +// Windows Theme API (see +// http://msdn.microsoft.com/en-us/library/bb773187(VS.85).aspx ). +// The classicState parameter corresponds to the uState +// parameter of the Windows DrawFrameControl() function. +// See the definitions in <vsstyle.h> and <winuser.h>. +class WebThemeEngine { +public: + virtual void paintButton( + WebCanvas*, int part, int state, int classicState, + const WebRect&) = 0; + + virtual void paintMenuList( + WebCanvas*, int part, int state, int classicState, + const WebRect&) = 0; + + virtual void paintScrollbarArrow( + WebCanvas*, int state, int classicState, + const WebRect&) = 0; + + virtual void paintScrollbarThumb( + WebCanvas*, int part, int state, int classicState, + const WebRect&) = 0; + + virtual void paintScrollbarTrack( + WebCanvas*, int part, int state, int classicState, + const WebRect&, const WebRect& alignRect) = 0; + + virtual void paintTextField( + WebCanvas*, int part, int state, int classicState, + const WebRect&, WebColor, bool fillContentArea, bool drawEdges) = 0; + + virtual void paintTrackbar( + WebCanvas*, int part, int state, int classicState, + const WebRect&) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/x11/WebScreenInfoFactory.h b/WebKit/chromium/public/x11/WebScreenInfoFactory.h new file mode 100644 index 0000000..5e30da8 --- /dev/null +++ b/WebKit/chromium/public/x11/WebScreenInfoFactory.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebScreenInfoFactory_h +#define WebScreenInfoFactory_h + +#include "../WebCommon.h" + +typedef struct _XDisplay Display; + +namespace WebKit { + +struct WebScreenInfo; + +class WebScreenInfoFactory { +public: + WEBKIT_API static WebScreenInfo screenInfo(Display*, int screenNumber); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/ApplicationCacheHost.cpp b/WebKit/chromium/src/ApplicationCacheHost.cpp new file mode 100644 index 0000000..ef8f860 --- /dev/null +++ b/WebKit/chromium/src/ApplicationCacheHost.cpp @@ -0,0 +1,256 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "ApplicationCacheHost.h" + +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + +#include "DocumentLoader.h" +#include "DOMApplicationCache.h" +#include "Frame.h" +#include "Settings.h" +#include "WebApplicationCacheHost.h" +#include "WebApplicationCacheHostClient.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebURL.h" +#include "WebURLError.h" +#include "WebURLResponse.h" +#include "WrappedResourceRequest.h" +#include "WrappedResourceResponse.h" + +using namespace WebKit; + +namespace WebCore { + +// ApplicationCacheHostInternal ----------------------------------------------- + +class ApplicationCacheHostInternal : public WebApplicationCacheHostClient { +public: + ApplicationCacheHostInternal(ApplicationCacheHost* host) + : m_innerHost(host) + { + m_outerHost.set(WebKit::webKitClient()->createApplicationCacheHost(this)); + } + + virtual void notifyEventListener(WebApplicationCacheHost::EventID eventID) + { + m_innerHost->notifyDOMApplicationCache( + static_cast<ApplicationCacheHost::EventID>(eventID)); + } + + ApplicationCacheHost* m_innerHost; + OwnPtr<WebApplicationCacheHost> m_outerHost; +}; + +// ApplicationCacheHost ------------------------------------------------------- +// We provide a custom implementation of this class that calls out to the +// embedding application instead of using WebCore's built in appcache system. +// This file replaces webcore/appcache/ApplicationCacheHost.cpp in our build. + +ApplicationCacheHost::ApplicationCacheHost(DocumentLoader* documentLoader) + : m_domApplicationCache(0) + , m_documentLoader(documentLoader) +{ + ASSERT(m_documentLoader); +} + +ApplicationCacheHost::~ApplicationCacheHost() +{ +} + +void ApplicationCacheHost::maybeLoadMainResource(ResourceRequest& request, SubstituteData&) +{ + // We defer creating the outer host object to avoid spurious creation/destruction + // around creating empty documents. At this point, we're initiating a main resource + // load for the document, so its for real. + + if (!isApplicationCacheEnabled()) + return; + + m_internal.set(new ApplicationCacheHostInternal(this)); + if (m_internal->m_outerHost) { + WrappedResourceRequest wrapped(request); + m_internal->m_outerHost->willStartMainResourceRequest(wrapped); + } else + m_internal.clear(); + + // NOTE: The semantics of this method, and others in this interface, are subtly different + // than the method names would suggest. For example, in this method never returns an appcached + // response in the SubstituteData out argument, instead we return the appcached response thru + // the usual resource loading pipeline. +} + +void ApplicationCacheHost::selectCacheWithoutManifest() +{ + if (m_internal) + m_internal->m_outerHost->selectCacheWithoutManifest(); +} + +void ApplicationCacheHost::selectCacheWithManifest(const KURL& manifestURL) +{ + if (m_internal) { + if (!m_internal->m_outerHost->selectCacheWithManifest(manifestURL)) { + // It's a foreign entry, restart the current navigation from the top + // of the navigation algorithm. The navigation will not result in the + // same resource being loaded, because "foreign" entries are never picked + // during navigation. + // see WebCore::ApplicationCacheGroup::selectCache() + const KURL& docURL = m_documentLoader->frame()->document()->url(); + String referrer = m_documentLoader->frameLoader()->referrer(); + m_documentLoader->frame()->redirectScheduler()->scheduleLocationChange(docURL, referrer); + } + } +} + +bool ApplicationCacheHost::maybeLoadFallbackForMainResponse(const ResourceRequest&, const ResourceResponse& response) +{ + if (m_internal) { + WrappedResourceResponse wrapped(response); + m_internal->m_outerHost->didReceiveResponseForMainResource(wrapped); + } + return false; +} + +bool ApplicationCacheHost::maybeLoadFallbackForMainError(const ResourceRequest&, const ResourceError& error) +{ + // N/A to the chromium port + return false; +} + +void ApplicationCacheHost::mainResourceDataReceived(const char* data, int length, long long, bool) +{ + if (m_internal) + m_internal->m_outerHost->didReceiveDataForMainResource(data, length); +} + +void ApplicationCacheHost::failedLoadingMainResource() +{ + if (m_internal) + m_internal->m_outerHost->didFinishLoadingMainResource(false); +} + +void ApplicationCacheHost::finishedLoadingMainResource() +{ + if (m_internal) + m_internal->m_outerHost->didFinishLoadingMainResource(true); +} + +bool ApplicationCacheHost::maybeLoadResource(ResourceLoader*, ResourceRequest& request, const KURL&) +{ + // FIXME: look into the purpose of the unused KURL& originalURL parameter + if (m_internal) { + WrappedResourceRequest wrapped(request); + m_internal->m_outerHost->willStartSubResourceRequest(wrapped); + } + return false; +} + +bool ApplicationCacheHost::maybeLoadFallbackForRedirect(ResourceLoader*, ResourceRequest&, const ResourceResponse&) +{ + // N/A to the chromium port + return false; +} + +bool ApplicationCacheHost::maybeLoadFallbackForResponse(ResourceLoader*, const ResourceResponse&) +{ + // N/A to the chromium port + return false; +} + +bool ApplicationCacheHost::maybeLoadFallbackForError(ResourceLoader*, const ResourceError&) +{ + // N/A to the chromium port + return false; +} + +bool ApplicationCacheHost::maybeLoadSynchronously(ResourceRequest& request, ResourceError&, ResourceResponse&, Vector<char>&) +{ + if (m_internal) { + WrappedResourceRequest wrapped(request); + m_internal->m_outerHost->willStartSubResourceRequest(wrapped); + } + return false; +} + +void ApplicationCacheHost::maybeLoadFallbackSynchronously(const ResourceRequest&, ResourceError&, ResourceResponse&, Vector<char>&) +{ + // N/A to the chromium port +} + +bool ApplicationCacheHost::canCacheInPageCache() const +{ + // N/A to the chromium port which doesn't use the page cache. + return false; +} + +void ApplicationCacheHost::setDOMApplicationCache(DOMApplicationCache* domApplicationCache) +{ + ASSERT(!m_domApplicationCache || !domApplicationCache); + m_domApplicationCache = domApplicationCache; +} + +void ApplicationCacheHost::notifyDOMApplicationCache(EventID id) +{ + if (m_domApplicationCache) { + ExceptionCode ec = 0; + m_domApplicationCache->dispatchEvent( + Event::create(DOMApplicationCache::toEventType(id), false, false), + ec); + ASSERT(!ec); + } +} + +ApplicationCacheHost::Status ApplicationCacheHost::status() const +{ + return m_internal ? static_cast<Status>(m_internal->m_outerHost->status()) : UNCACHED; +} + +bool ApplicationCacheHost::update() +{ + return m_internal ? m_internal->m_outerHost->startUpdate() : false; +} + +bool ApplicationCacheHost::swapCache() +{ + return m_internal ? m_internal->m_outerHost->swapCache() : false; +} + +bool ApplicationCacheHost::isApplicationCacheEnabled() +{ + ASSERT(m_documentLoader->frame()); + return m_documentLoader->frame()->settings() + && m_documentLoader->frame()->settings()->offlineWebApplicationCacheEnabled(); +} + +} // namespace WebCore + +#endif // ENABLE(OFFLINE_WEB_APPLICATIONS) diff --git a/WebKit/chromium/src/AssertMatchingEnums.cpp b/WebKit/chromium/src/AssertMatchingEnums.cpp new file mode 100644 index 0000000..35e2057 --- /dev/null +++ b/WebKit/chromium/src/AssertMatchingEnums.cpp @@ -0,0 +1,279 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// Use this file to assert that various WebKit API enum values continue +// matching WebCore defined enum values. + +#include "config.h" + +#include "AccessibilityObject.h" +#include "ApplicationCacheHost.h" +#include "EditorInsertAction.h" +#include "HTMLInputElement.h" +#include "MediaPlayer.h" +#include "NotificationPresenter.h" +#include "PasteboardPrivate.h" +#include "PlatformCursor.h" +#include "StringImpl.h" +#include "TextAffinity.h" +#include "WebAccessibilityObject.h" +#include "WebApplicationCacheHost.h" +#include "WebClipboard.h" +#include "WebCursorInfo.h" +#include "WebEditingAction.h" +#include "WebInputElement.h" +#include "WebMediaPlayer.h" +#include "WebNotificationPresenter.h" +#include "WebTextAffinity.h" +#include "WebTextCaseSensitivity.h" +#include <wtf/Assertions.h> + +#define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, webcore_name) \ + COMPILE_ASSERT(int(WebKit::webkit_name) == int(WebCore::webcore_name), mismatching_enums) + +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleUnknown, UnknownRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleButton, ButtonRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleRadioButton, RadioButtonRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleCheckBox, CheckBoxRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleSlider, SliderRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTabGroup, TabGroupRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTextField, TextFieldRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleStaticText, StaticTextRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTextArea, TextAreaRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleScrollArea, ScrollAreaRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRolePopUpButton, PopUpButtonRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleMenuButton, MenuButtonRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTable, TableRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleApplication, ApplicationRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleGroup, GroupRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleRadioGroup, RadioGroupRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleList, ListRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleScrollBar, ScrollBarRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleValueIndicator, ValueIndicatorRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleImage, ImageRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleMenuBar, MenuBarRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleMenu, MenuRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleMenuItem, MenuItemRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleColumn, ColumnRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleRow, RowRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleToolbar, ToolbarRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleBusyIndicator, BusyIndicatorRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleProgressIndicator, ProgressIndicatorRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleWindow, WindowRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDrawer, DrawerRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleSystemWide, SystemWideRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleOutline, OutlineRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleIncrementor, IncrementorRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleBrowser, BrowserRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleComboBox, ComboBoxRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleSplitGroup, SplitGroupRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleSplitter, SplitterRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleColorWell, ColorWellRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleGrowArea, GrowAreaRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleSheet, SheetRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleHelpTag, HelpTagRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleMatte, MatteRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleRuler, RulerRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleRulerMarker, RulerMarkerRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleLink, LinkRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDisclosureTriangle, DisclosureTriangleRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleGrid, GridRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleCell, CellRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleColumnHeader, ColumnHeaderRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleRowHeader, RowHeaderRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleWebCoreLink, WebCoreLinkRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleImageMapLink, ImageMapLinkRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleImageMap, ImageMapRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleListMarker, ListMarkerRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleWebArea, WebAreaRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleHeading, HeadingRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleListBox, ListBoxRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleListBoxOption, ListBoxOptionRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTableHeaderContainer, TableHeaderContainerRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDefinitionListTerm, DefinitionListTermRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDefinitionListDefinition, DefinitionListDefinitionRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleAnnotation, AnnotationRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleSliderThumb, SliderThumbRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleIgnored, IgnoredRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTab, TabRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTabList, TabListRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTabPanel, TabPanelRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTreeRole, TreeRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTreeItemRole, TreeItemRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDirectory, DirectoryRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleLandmarkApplication, LandmarkApplicationRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleLandmarkBanner, LandmarkBannerRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleLandmarkComplementary, LandmarkComplementaryRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleLandmarkContentInfo, LandmarkContentInfoRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleLandmarkMain, LandmarkMainRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleLandmarkNavigation, LandmarkNavigationRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleLandmarkSearch, LandmarkSearchRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleApplicationAlert, ApplicationAlertRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleApplicationAlertDialog, ApplicationAlertDialogRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleApplicationDialog, ApplicationDialogRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleApplicationLog, ApplicationLogRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleApplicationMarquee, ApplicationMarqueeRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleApplicationStatus, ApplicationStatusRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleApplicationTimer, ApplicationTimerRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDocument, DocumentRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDocumentArticle, DocumentArticleRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDocumentMath, DocumentMathRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDocumentNote, DocumentNoteRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDocumentRegion, DocumentRegionRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleUserInterfaceTooltip, UserInterfaceTooltipRole); + +#if ENABLE(OFFLINE_WEB_APPLICATIONS) +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::Uncached, ApplicationCacheHost::UNCACHED); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::Idle, ApplicationCacheHost::IDLE); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::Checking, ApplicationCacheHost::CHECKING); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::Downloading, ApplicationCacheHost::DOWNLOADING); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::UpdateReady, ApplicationCacheHost::UPDATEREADY); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::Obsolete, ApplicationCacheHost::OBSOLETE); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::CheckingEvent, ApplicationCacheHost::CHECKING_EVENT); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::ErrorEvent, ApplicationCacheHost::ERROR_EVENT); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::NoUpdateEvent, ApplicationCacheHost::NOUPDATE_EVENT); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::DownloadingEvent, ApplicationCacheHost::DOWNLOADING_EVENT); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::ProgressEvent, ApplicationCacheHost::PROGRESS_EVENT); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::UpdateReadyEvent, ApplicationCacheHost::UPDATEREADY_EVENT); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::CachedEvent, ApplicationCacheHost::CACHED_EVENT); +COMPILE_ASSERT_MATCHING_ENUM(WebApplicationCacheHost::ObsoleteEvent, ApplicationCacheHost::OBSOLETE_EVENT); +#endif + +COMPILE_ASSERT_MATCHING_ENUM(WebClipboard::FormatHTML, PasteboardPrivate::HTMLFormat); +COMPILE_ASSERT_MATCHING_ENUM(WebClipboard::FormatBookmark, PasteboardPrivate::BookmarkFormat); +COMPILE_ASSERT_MATCHING_ENUM(WebClipboard::FormatSmartPaste, PasteboardPrivate::WebSmartPasteFormat); + +COMPILE_ASSERT_MATCHING_ENUM(WebClipboard::BufferStandard, PasteboardPrivate::StandardBuffer); +COMPILE_ASSERT_MATCHING_ENUM(WebClipboard::BufferSelection, PasteboardPrivate::SelectionBuffer); + +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypePointer, PlatformCursor::TypePointer); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeCross, PlatformCursor::TypeCross); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeHand, PlatformCursor::TypeHand); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeIBeam, PlatformCursor::TypeIBeam); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeWait, PlatformCursor::TypeWait); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeHelp, PlatformCursor::TypeHelp); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeEastResize, PlatformCursor::TypeEastResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthResize, PlatformCursor::TypeNorthResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthEastResize, PlatformCursor::TypeNorthEastResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthWestResize, PlatformCursor::TypeNorthWestResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeSouthResize, PlatformCursor::TypeSouthResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeSouthEastResize, PlatformCursor::TypeSouthEastResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeSouthWestResize, PlatformCursor::TypeSouthWestResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeWestResize, PlatformCursor::TypeWestResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthSouthResize, PlatformCursor::TypeNorthSouthResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeEastWestResize, PlatformCursor::TypeEastWestResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthEastSouthWestResize, PlatformCursor::TypeNorthEastSouthWestResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthWestSouthEastResize, PlatformCursor::TypeNorthWestSouthEastResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeColumnResize, PlatformCursor::TypeColumnResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeRowResize, PlatformCursor::TypeRowResize); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeMiddlePanning, PlatformCursor::TypeMiddlePanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeEastPanning, PlatformCursor::TypeEastPanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthPanning, PlatformCursor::TypeNorthPanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthEastPanning, PlatformCursor::TypeNorthEastPanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNorthWestPanning, PlatformCursor::TypeNorthWestPanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeSouthPanning, PlatformCursor::TypeSouthPanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeSouthEastPanning, PlatformCursor::TypeSouthEastPanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeSouthWestPanning, PlatformCursor::TypeSouthWestPanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeWestPanning, PlatformCursor::TypeWestPanning); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeMove, PlatformCursor::TypeMove); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeVerticalText, PlatformCursor::TypeVerticalText); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeCell, PlatformCursor::TypeCell); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeContextMenu, PlatformCursor::TypeContextMenu); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeAlias, PlatformCursor::TypeAlias); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeProgress, PlatformCursor::TypeProgress); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNoDrop, PlatformCursor::TypeNoDrop); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeCopy, PlatformCursor::TypeCopy); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNone, PlatformCursor::TypeNone); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeNotAllowed, PlatformCursor::TypeNotAllowed); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeZoomIn, PlatformCursor::TypeZoomIn); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeZoomOut, PlatformCursor::TypeZoomOut); +COMPILE_ASSERT_MATCHING_ENUM(WebCursorInfo::TypeCustom, PlatformCursor::TypeCustom); + +COMPILE_ASSERT_MATCHING_ENUM(WebEditingActionTyped, EditorInsertActionTyped); +COMPILE_ASSERT_MATCHING_ENUM(WebEditingActionPasted, EditorInsertActionPasted); +COMPILE_ASSERT_MATCHING_ENUM(WebEditingActionDropped, EditorInsertActionDropped); + +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Text, HTMLInputElement::TEXT); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Password, HTMLInputElement::PASSWORD); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::IsIndex, HTMLInputElement::ISINDEX); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::CheckBox, HTMLInputElement::CHECKBOX); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Radio, HTMLInputElement::RADIO); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Submit, HTMLInputElement::SUBMIT); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Reset, HTMLInputElement::RESET); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::File, HTMLInputElement::FILE); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Hidden, HTMLInputElement::HIDDEN); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Image, HTMLInputElement::IMAGE); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Button, HTMLInputElement::BUTTON); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Search, HTMLInputElement::SEARCH); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Range, HTMLInputElement::RANGE); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Email, HTMLInputElement::EMAIL); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Number, HTMLInputElement::NUMBER); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Telephone, HTMLInputElement::TELEPHONE); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::URL, HTMLInputElement::URL); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Color, HTMLInputElement::COLOR); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Date, HTMLInputElement::DATE); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::DateTime, HTMLInputElement::DATETIME); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::DateTimeLocal, HTMLInputElement::DATETIMELOCAL); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Month, HTMLInputElement::MONTH); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Time, HTMLInputElement::TIME); +COMPILE_ASSERT_MATCHING_ENUM(WebInputElement::Week, HTMLInputElement::WEEK); + +#if ENABLE(VIDEO) +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::Empty, MediaPlayer::Empty); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::Idle, MediaPlayer::Idle); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::Loading, MediaPlayer::Loading); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::Loaded, MediaPlayer::Loaded); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::FormatError, MediaPlayer::FormatError); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::NetworkError, MediaPlayer::NetworkError); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::DecodeError, MediaPlayer::DecodeError); + +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::HaveNothing, MediaPlayer::HaveNothing); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::HaveMetadata, MediaPlayer::HaveMetadata); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::HaveCurrentData, MediaPlayer::HaveCurrentData); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::HaveFutureData, MediaPlayer::HaveFutureData); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::HaveEnoughData, MediaPlayer::HaveEnoughData); + +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::Unknown, MediaPlayer::Unknown); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::Download, MediaPlayer::Download); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::StoredStream, MediaPlayer::StoredStream); +COMPILE_ASSERT_MATCHING_ENUM(WebMediaPlayer::LiveStream, MediaPlayer::LiveStream); +#endif + +#if ENABLE(NOTIFICATIONS) +COMPILE_ASSERT_MATCHING_ENUM(WebNotificationPresenter::PermissionAllowed, NotificationPresenter::PermissionAllowed); +COMPILE_ASSERT_MATCHING_ENUM(WebNotificationPresenter::PermissionNotAllowed, NotificationPresenter::PermissionNotAllowed); +COMPILE_ASSERT_MATCHING_ENUM(WebNotificationPresenter::PermissionDenied, NotificationPresenter::PermissionDenied); +#endif + +COMPILE_ASSERT_MATCHING_ENUM(WebTextAffinityUpstream, UPSTREAM); +COMPILE_ASSERT_MATCHING_ENUM(WebTextAffinityDownstream, DOWNSTREAM); + +COMPILE_ASSERT_MATCHING_ENUM(WebTextCaseSensitive, TextCaseSensitive); +COMPILE_ASSERT_MATCHING_ENUM(WebTextCaseInsensitive, TextCaseInsensitive); diff --git a/WebKit/chromium/src/AutocompletePopupMenuClient.cpp b/WebKit/chromium/src/AutocompletePopupMenuClient.cpp new file mode 100644 index 0000000..62d4dff --- /dev/null +++ b/WebKit/chromium/src/AutocompletePopupMenuClient.cpp @@ -0,0 +1,178 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "AutocompletePopupMenuClient.h" + +#include "CSSStyleSelector.h" +#include "CSSValueKeywords.h" +#include "FrameView.h" +#include "HTMLInputElement.h" +#include "RenderTheme.h" +#include "WebVector.h" +#include "WebViewImpl.h" + +using namespace WebCore; + +namespace WebKit { + +AutocompletePopupMenuClient::AutocompletePopupMenuClient(WebViewImpl* webView) + : m_textField(0) + , m_selectedIndex(0) + , m_webView(webView) +{ +} + +AutocompletePopupMenuClient::~AutocompletePopupMenuClient() +{ +} + +void AutocompletePopupMenuClient::initialize( + HTMLInputElement* textField, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex) +{ + ASSERT(defaultSuggestionIndex < static_cast<int>(suggestions.size())); + m_textField = textField; + m_selectedIndex = defaultSuggestionIndex; + setSuggestions(suggestions); + + FontDescription fontDescription; + m_webView->theme()->systemFont(CSSValueWebkitControl, fontDescription); + // Use a smaller font size to match IE/Firefox. + // FIXME: http://crbug.com/7376 use the system size instead of a + // fixed font size value. + fontDescription.setComputedSize(12.0); + Font font(fontDescription, 0, 0); + font.update(textField->document()->styleSelector()->fontSelector()); + // The direction of text in popup menu is set the same as the direction of + // the input element: textField. + m_style.set(new PopupMenuStyle(Color::black, Color::white, font, true, + Length(WebCore::Fixed), + textField->renderer()->style()->direction())); +} + +void AutocompletePopupMenuClient::valueChanged(unsigned listIndex, bool fireEvents) +{ + m_textField->setValue(m_suggestions[listIndex]); + EditorClientImpl* editor = + static_cast<EditorClientImpl*>(m_webView->page()->editorClient()); + ASSERT(editor); + editor->onAutofillSuggestionAccepted( + static_cast<HTMLInputElement*>(m_textField.get())); +} + +String AutocompletePopupMenuClient::itemText(unsigned listIndex) const +{ + return m_suggestions[listIndex]; +} + +PopupMenuStyle AutocompletePopupMenuClient::itemStyle(unsigned listIndex) const +{ + return *m_style; +} + +PopupMenuStyle AutocompletePopupMenuClient::menuStyle() const +{ + return *m_style; +} + +int AutocompletePopupMenuClient::clientPaddingLeft() const +{ + // Bug http://crbug.com/7708 seems to indicate the style can be 0. + RenderStyle* style = textFieldStyle(); + return style ? m_webView->theme()->popupInternalPaddingLeft(style) : 0; +} + +int AutocompletePopupMenuClient::clientPaddingRight() const +{ + // Bug http://crbug.com/7708 seems to indicate the style can be 0. + RenderStyle* style = textFieldStyle(); + return style ? m_webView->theme()->popupInternalPaddingRight(style) : 0; +} + +void AutocompletePopupMenuClient::popupDidHide() +{ + m_webView->autoCompletePopupDidHide(); +} + +void AutocompletePopupMenuClient::setTextFromItem(unsigned listIndex) +{ + m_textField->setValue(m_suggestions[listIndex]); +} + +FontSelector* AutocompletePopupMenuClient::fontSelector() const +{ + return m_textField->document()->styleSelector()->fontSelector(); +} + +HostWindow* AutocompletePopupMenuClient::hostWindow() const +{ + return m_textField->document()->view()->hostWindow(); +} + +PassRefPtr<Scrollbar> AutocompletePopupMenuClient::createScrollbar( + ScrollbarClient* client, + ScrollbarOrientation orientation, + ScrollbarControlSize size) +{ + return Scrollbar::createNativeScrollbar(client, orientation, size); +} + +void AutocompletePopupMenuClient::setSuggestions(const WebVector<WebString>& suggestions) +{ + m_suggestions.clear(); + for (size_t i = 0; i < suggestions.size(); ++i) + m_suggestions.append(suggestions[i]); + // Try to preserve selection if possible. + if (m_selectedIndex >= static_cast<int>(suggestions.size())) + m_selectedIndex = -1; +} + +void AutocompletePopupMenuClient::removeItemAtIndex(int index) +{ + ASSERT(index >= 0 && index < static_cast<int>(m_suggestions.size())); + m_suggestions.remove(index); +} + +RenderStyle* AutocompletePopupMenuClient::textFieldStyle() const +{ + RenderStyle* style = m_textField->computedStyle(); + if (!style) { + // It seems we can only have a 0 style in a TextField if the + // node is detached, in which case we the popup shoud not be + // showing. Please report this in http://crbug.com/7708 and + // include the page you were visiting. + ASSERT_NOT_REACHED(); + } + return style; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/AutocompletePopupMenuClient.h b/WebKit/chromium/src/AutocompletePopupMenuClient.h new file mode 100644 index 0000000..ad24e54 --- /dev/null +++ b/WebKit/chromium/src/AutocompletePopupMenuClient.h @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "PopupMenuClient.h" + +namespace WebCore { +class HTMLInputElement; +class PopupMenuStyle; +class RenderStyle; +} + +namespace WebKit { +class WebString; +class WebViewImpl; +template <typename T> class WebVector; + +// AutocompletePopupMenuClient +class AutocompletePopupMenuClient : public WebCore::PopupMenuClient { +public: + AutocompletePopupMenuClient(WebViewImpl* webview); + ~AutocompletePopupMenuClient(); + + void initialize(WebCore::HTMLInputElement*, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex); + + WebCore::HTMLInputElement* textField() const { return m_textField.get(); } + + void setSuggestions(const WebVector<WebString>&); + void removeItemAtIndex(int index); + + // WebCore::PopupMenuClient methods: + virtual void valueChanged(unsigned listIndex, bool fireEvents = true); + virtual WebCore::String itemText(unsigned listIndex) const; + virtual WebCore::String itemToolTip(unsigned lastIndex) const { return WebCore::String(); } + virtual bool itemIsEnabled(unsigned listIndex) const { return true; } + virtual WebCore::PopupMenuStyle itemStyle(unsigned listIndex) const; + virtual WebCore::PopupMenuStyle menuStyle() const; + virtual int clientInsetLeft() const { return 0; } + virtual int clientInsetRight() const { return 0; } + virtual int clientPaddingLeft() const; + virtual int clientPaddingRight() const; + virtual int listSize() const { return m_suggestions.size(); } + virtual int selectedIndex() const { return m_selectedIndex; } + virtual void popupDidHide(); + virtual bool itemIsSeparator(unsigned listIndex) const { return false; } + virtual bool itemIsLabel(unsigned listIndex) const { return false; } + virtual bool itemIsSelected(unsigned listIndex) const { return false; } + virtual bool shouldPopOver() const { return false; } + virtual bool valueShouldChangeOnHotTrack() const { return false; } + virtual void setTextFromItem(unsigned listIndex); + virtual WebCore::FontSelector* fontSelector() const; + virtual WebCore::HostWindow* hostWindow() const; + virtual PassRefPtr<WebCore::Scrollbar> createScrollbar( + WebCore::ScrollbarClient* client, + WebCore::ScrollbarOrientation orientation, + WebCore::ScrollbarControlSize size); + +private: + WebCore::RenderStyle* textFieldStyle() const; + + RefPtr<WebCore::HTMLInputElement> m_textField; + Vector<WebCore::String> m_suggestions; + int m_selectedIndex; + WebViewImpl* m_webView; + OwnPtr<WebCore::PopupMenuStyle> m_style; +}; + +} // namespace WebKit diff --git a/WebKit/chromium/src/BackForwardListClientImpl.cpp b/WebKit/chromium/src/BackForwardListClientImpl.cpp new file mode 100644 index 0000000..8feae32 --- /dev/null +++ b/WebKit/chromium/src/BackForwardListClientImpl.cpp @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "BackForwardListClientImpl.h" + +#include "HistoryItem.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" + +using namespace WebCore; + +namespace WebKit { + +const char backForwardNavigationScheme[] = "chrome-back-forward"; + +BackForwardListClientImpl::BackForwardListClientImpl(WebViewImpl* webView) + : m_webView(webView) +{ +} + +BackForwardListClientImpl::~BackForwardListClientImpl() +{ +} + +void BackForwardListClientImpl::setCurrentHistoryItem(HistoryItem* item) +{ + m_previousItem = m_currentItem; + m_currentItem = item; +} + +HistoryItem* BackForwardListClientImpl::previousHistoryItem() const +{ + return m_previousItem.get(); +} + +void BackForwardListClientImpl::addItem(PassRefPtr<HistoryItem> item) +{ + m_previousItem = m_currentItem; + m_currentItem = item; + + // If WebCore adds a new HistoryItem, it means this is a new navigation (ie, + // not a reload or back/forward). + m_webView->observeNewNavigation(); + + if (m_webView->client()) + m_webView->client()->didAddHistoryItem(); +} + +void BackForwardListClientImpl::goToItem(HistoryItem* item) +{ + m_previousItem = m_currentItem; + m_currentItem = item; + + if (m_pendingHistoryItem == item) + m_pendingHistoryItem = 0; +} + +HistoryItem* BackForwardListClientImpl::currentItem() +{ + return m_currentItem.get(); +} + +HistoryItem* BackForwardListClientImpl::itemAtIndex(int index) +{ + if (!m_webView->client()) + return 0; + + // Since we don't keep the entire back/forward list, we have no way to + // properly implement this method. We return a dummy entry instead that we + // intercept in our FrameLoaderClient implementation in case WebCore asks + // to navigate to this HistoryItem. + + // FIXME: We should change WebCore to handle history.{back,forward,go} + // differently. It should perhaps just ask the FrameLoaderClient to + // perform those navigations. + + String url_string = String::format( + "%s://go/%d", backForwardNavigationScheme, index); + + m_pendingHistoryItem = + HistoryItem::create(url_string, String(), 0.0); + return m_pendingHistoryItem.get(); +} + +int BackForwardListClientImpl::backListCount() +{ + if (!m_webView->client()) + return 0; + + return m_webView->client()->historyBackListCount(); +} + +int BackForwardListClientImpl::forwardListCount() +{ + if (!m_webView->client()) + return 0; + + return m_webView->client()->historyForwardListCount(); +} + +void BackForwardListClientImpl::close() +{ + m_currentItem = 0; + m_previousItem = 0; + m_pendingHistoryItem = 0; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/BackForwardListClientImpl.h b/WebKit/chromium/src/BackForwardListClientImpl.h new file mode 100644 index 0000000..1d8beb0 --- /dev/null +++ b/WebKit/chromium/src/BackForwardListClientImpl.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef BackForwardListClientImpl_h +#define BackForwardListClientImpl_h + +#include "BackForwardList.h" + +namespace WebKit { +class WebViewImpl; + +extern const char backForwardNavigationScheme[]; + +class BackForwardListClientImpl : public WebCore::BackForwardListClient { +public: + BackForwardListClientImpl(WebViewImpl* webview); + ~BackForwardListClientImpl(); + + void setCurrentHistoryItem(WebCore::HistoryItem* item); + WebCore::HistoryItem* previousHistoryItem() const; + +private: + // WebCore::BackForwardListClient methods: + virtual void addItem(PassRefPtr<WebCore::HistoryItem>); + virtual void goToItem(WebCore::HistoryItem*); + virtual WebCore::HistoryItem* currentItem(); + virtual WebCore::HistoryItem* itemAtIndex(int index); + virtual int backListCount(); + virtual int forwardListCount(); + virtual void close(); + + WebViewImpl* m_webView; + + RefPtr<WebCore::HistoryItem> m_previousItem; + RefPtr<WebCore::HistoryItem> m_currentItem; + + // The last history item that was accessed via itemAtIndex(). We keep track + // of this until goToItem() is called, so we can track the navigation. + RefPtr<WebCore::HistoryItem> m_pendingHistoryItem; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/ChromeClientImpl.cpp b/WebKit/chromium/src/ChromeClientImpl.cpp new file mode 100644 index 0000000..4e20124 --- /dev/null +++ b/WebKit/chromium/src/ChromeClientImpl.cpp @@ -0,0 +1,671 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "ChromeClientImpl.h" + +#include "AccessibilityObject.h" +#include "AXObjectCache.h" +#include "CharacterNames.h" +#include "Console.h" +#include "Cursor.h" +#include "DatabaseTracker.h" +#include "Document.h" +#include "DocumentLoader.h" +#include "FileChooser.h" +#include "FloatRect.h" +#include "FrameLoadRequest.h" +#include "FrameView.h" +#include "HitTestResult.h" +#include "IntRect.h" +#include "Node.h" +#include "NotificationPresenterImpl.h" +#include "Page.h" +#include "PopupMenuChromium.h" +#include "ScriptController.h" +#if USE(V8) +#include "V8Proxy.h" +#endif +#include "WebAccessibilityObject.h" +#include "WebConsoleMessage.h" +#include "WebCursorInfo.h" +#include "WebFileChooserCompletionImpl.h" +#include "WebFrameClient.h" +#include "WebFrameImpl.h" +#include "WebInputEvent.h" +#include "WebKit.h" +#include "WebPopupMenuImpl.h" +#include "WebPopupMenuInfo.h" +#include "WebRect.h" +#include "WebTextDirection.h" +#include "WebURLRequest.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" +#include "WindowFeatures.h" +#include "WrappedResourceRequest.h" + +using namespace WebCore; + +namespace WebKit { + +ChromeClientImpl::ChromeClientImpl(WebViewImpl* webView) + : m_webView(webView) + , m_toolbarsVisible(true) + , m_statusbarVisible(true) + , m_scrollbarsVisible(true) + , m_menubarVisible(true) + , m_resizable(true) + , m_ignoreNextSetCursor(false) +{ +} + +ChromeClientImpl::~ChromeClientImpl() +{ +} + +void ChromeClientImpl::chromeDestroyed() +{ + // Our lifetime is bound to the WebViewImpl. +} + +void ChromeClientImpl::setWindowRect(const FloatRect& r) +{ + if (m_webView->client()) + m_webView->client()->setWindowRect(IntRect(r)); +} + +FloatRect ChromeClientImpl::windowRect() +{ + WebRect rect; + if (m_webView->client()) + rect = m_webView->client()->rootWindowRect(); + else { + // These numbers will be fairly wrong. The window's x/y coordinates will + // be the top left corner of the screen and the size will be the content + // size instead of the window size. + rect.width = m_webView->size().width; + rect.height = m_webView->size().height; + } + return FloatRect(rect); +} + +FloatRect ChromeClientImpl::pageRect() +{ + // We hide the details of the window's border thickness from the web page by + // simple re-using the window position here. So, from the point-of-view of + // the web page, the window has no border. + return windowRect(); +} + +float ChromeClientImpl::scaleFactor() +{ + // This is supposed to return the scale factor of the web page. It looks like + // the implementor of the graphics layer is responsible for doing most of the + // operations associated with scaling. However, this value is used ins some + // cases by WebCore. For example, this is used as a scaling factor in canvas + // so that things drawn in it are scaled just like the web page is. + // + // We don't currently implement scaling, so just return 1.0 (no scaling). + return 1.0; +} + +void ChromeClientImpl::focus() +{ + if (!m_webView->client()) + return; + + m_webView->client()->didFocus(); + + // If accessibility is enabled, we should notify assistive technology that + // the active AccessibilityObject changed. + const Frame* frame = m_webView->focusedWebCoreFrame(); + if (!frame) + return; + + Document* doc = frame->document(); + + if (doc && doc->axObjectCache()->accessibilityEnabled()) { + Node* focusedNode = m_webView->focusedWebCoreNode(); + + if (!focusedNode) { + // Could not retrieve focused Node. + return; + } + + // Retrieve the focused AccessibilityObject. + AccessibilityObject* focusedAccObj = + doc->axObjectCache()->getOrCreate(focusedNode->renderer()); + + // Alert assistive technology that focus changed. + if (focusedAccObj) + m_webView->client()->focusAccessibilityObject(WebAccessibilityObject(focusedAccObj)); + } +} + +void ChromeClientImpl::unfocus() +{ + if (m_webView->client()) + m_webView->client()->didBlur(); +} + +bool ChromeClientImpl::canTakeFocus(FocusDirection) +{ + // For now the browser can always take focus if we're not running layout + // tests. + return !layoutTestMode(); +} + +void ChromeClientImpl::takeFocus(FocusDirection direction) +{ + if (!m_webView->client()) + return; + if (direction == FocusDirectionBackward) + m_webView->client()->focusPrevious(); + else + m_webView->client()->focusNext(); +} + +void ChromeClientImpl::focusedNodeChanged(Node* node) +{ + WebURL focus_url; + if (node && node->isLink()) { + // This HitTestResult hack is the easiest way to get a link URL out of a + // WebCore::Node. + HitTestResult hit_test(IntPoint(0, 0)); + // This cast must be valid because of the isLink() check. + hit_test.setURLElement(reinterpret_cast<Element*>(node)); + if (hit_test.isLiveLink()) + focus_url = hit_test.absoluteLinkURL(); + } + m_webView->client()->setKeyboardFocusURL(focus_url); +} + +Page* ChromeClientImpl::createWindow( + Frame* frame, const FrameLoadRequest& r, const WindowFeatures& features) +{ + if (!m_webView->client()) + return 0; + + WebViewImpl* newView = static_cast<WebViewImpl*>( + m_webView->client()->createView(WebFrameImpl::fromFrame(frame))); + if (!newView) + return 0; + + // The request is empty when we are just being asked to open a blank window. + // This corresponds to window.open(""), for example. + if (!r.resourceRequest().isEmpty()) { + WrappedResourceRequest request(r.resourceRequest()); + newView->mainFrame()->loadRequest(request); + } + + return newView->page(); +} + +static inline bool currentEventShouldCauseBackgroundTab(const WebInputEvent* inputEvent) +{ + if (!inputEvent) + return false; + + if (inputEvent->type != WebInputEvent::MouseUp) + return false; + + const WebMouseEvent* mouseEvent = static_cast<const WebMouseEvent*>(inputEvent); + + WebNavigationPolicy policy; + unsigned short buttonNumber; + switch (mouseEvent->button) { + case WebMouseEvent::ButtonLeft: + buttonNumber = 0; + break; + case WebMouseEvent::ButtonMiddle: + buttonNumber = 1; + break; + case WebMouseEvent::ButtonRight: + buttonNumber = 2; + break; + default: + return false; + } + bool ctrl = mouseEvent->modifiers & WebMouseEvent::ControlKey; + bool shift = mouseEvent->modifiers & WebMouseEvent::ShiftKey; + bool alt = mouseEvent->modifiers & WebMouseEvent::AltKey; + bool meta = mouseEvent->modifiers & WebMouseEvent::MetaKey; + + if (!WebViewImpl::navigationPolicyFromMouseEvent(buttonNumber, ctrl, shift, alt, meta, &policy)) + return false; + + return policy == WebNavigationPolicyNewBackgroundTab; +} + +void ChromeClientImpl::show() +{ + if (!m_webView->client()) + return; + + // If our default configuration was modified by a script or wasn't + // created by a user gesture, then show as a popup. Else, let this + // new window be opened as a toplevel window. + bool asPopup = !m_toolbarsVisible + || !m_statusbarVisible + || !m_scrollbarsVisible + || !m_menubarVisible + || !m_resizable; + + WebNavigationPolicy policy = WebNavigationPolicyNewForegroundTab; + if (asPopup) + policy = WebNavigationPolicyNewPopup; + if (currentEventShouldCauseBackgroundTab(WebViewImpl::currentInputEvent())) + policy = WebNavigationPolicyNewBackgroundTab; + + m_webView->client()->show(policy); +} + +bool ChromeClientImpl::canRunModal() +{ + return !!m_webView->client(); +} + +void ChromeClientImpl::runModal() +{ + if (m_webView->client()) + m_webView->client()->runModal(); +} + +void ChromeClientImpl::setToolbarsVisible(bool value) +{ + m_toolbarsVisible = value; +} + +bool ChromeClientImpl::toolbarsVisible() +{ + return m_toolbarsVisible; +} + +void ChromeClientImpl::setStatusbarVisible(bool value) +{ + m_statusbarVisible = value; +} + +bool ChromeClientImpl::statusbarVisible() +{ + return m_statusbarVisible; +} + +void ChromeClientImpl::setScrollbarsVisible(bool value) +{ + m_scrollbarsVisible = value; + WebFrameImpl* web_frame = static_cast<WebFrameImpl*>(m_webView->mainFrame()); + if (web_frame) + web_frame->setAllowsScrolling(value); +} + +bool ChromeClientImpl::scrollbarsVisible() +{ + return m_scrollbarsVisible; +} + +void ChromeClientImpl::setMenubarVisible(bool value) +{ + m_menubarVisible = value; +} + +bool ChromeClientImpl::menubarVisible() +{ + return m_menubarVisible; +} + +void ChromeClientImpl::setResizable(bool value) +{ + m_resizable = value; +} + +void ChromeClientImpl::addMessageToConsole(MessageSource source, + MessageType type, + MessageLevel level, + const String& message, + unsigned lineNumber, + const String& sourceID) +{ + if (m_webView->client()) { + m_webView->client()->didAddMessageToConsole( + WebConsoleMessage(static_cast<WebConsoleMessage::Level>(level), message), + sourceID, + lineNumber); + } +} + +bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel() +{ + return !!m_webView->client(); +} + +bool ChromeClientImpl::runBeforeUnloadConfirmPanel(const String& message, Frame* frame) +{ + if (m_webView->client()) { + return m_webView->client()->runModalBeforeUnloadDialog( + WebFrameImpl::fromFrame(frame), message); + } + return false; +} + +void ChromeClientImpl::closeWindowSoon() +{ + // Make sure this Page can no longer be found by JS. + m_webView->page()->setGroupName(String()); + + // Make sure that all loading is stopped. Ensures that JS stops executing! + m_webView->mainFrame()->stopLoading(); + + if (m_webView->client()) + m_webView->client()->closeWidgetSoon(); +} + +// Although a Frame is passed in, we don't actually use it, since we +// already know our own m_webView. +void ChromeClientImpl::runJavaScriptAlert(Frame* frame, const String& message) +{ + if (m_webView->client()) { +#if USE(V8) + // Before showing the JavaScript dialog, we give the proxy implementation + // a chance to process any pending console messages. + V8Proxy::processConsoleMessages(); +#endif + m_webView->client()->runModalAlertDialog( + WebFrameImpl::fromFrame(frame), message); + } +} + +// See comments for runJavaScriptAlert(). +bool ChromeClientImpl::runJavaScriptConfirm(Frame* frame, const String& message) +{ + if (m_webView->client()) { + return m_webView->client()->runModalConfirmDialog( + WebFrameImpl::fromFrame(frame), message); + } + return false; +} + +// See comments for runJavaScriptAlert(). +bool ChromeClientImpl::runJavaScriptPrompt(Frame* frame, + const String& message, + const String& defaultValue, + String& result) +{ + if (m_webView->client()) { + WebString actualValue; + bool ok = m_webView->client()->runModalPromptDialog( + WebFrameImpl::fromFrame(frame), + message, + defaultValue, + &actualValue); + if (ok) + result = actualValue; + return ok; + } + return false; +} + +void ChromeClientImpl::setStatusbarText(const String& message) +{ + if (m_webView->client()) + m_webView->client()->setStatusText(message); +} + +bool ChromeClientImpl::shouldInterruptJavaScript() +{ + // FIXME: implement me + return false; +} + +bool ChromeClientImpl::tabsToLinks() const +{ + // Returns true if anchors should accept keyboard focus with the tab key. + // This method is used in a convoluted fashion by EventHandler::tabsToLinks. + // It's a twisted path (self-evident, but more complicated than seems + // necessary), but the net result is that returning true from here, on a + // platform other than MAC or QT, lets anchors get keyboard focus. + return m_webView->tabsToLinks(); +} + +IntRect ChromeClientImpl::windowResizerRect() const +{ + IntRect result; + if (m_webView->client()) + result = m_webView->client()->windowResizerRect(); + return result; +} + +void ChromeClientImpl::repaint( + const IntRect& paintRect, bool contentChanged, bool immediate, + bool repaintContentOnly) +{ + // Ignore spurious calls. + if (!contentChanged || paintRect.isEmpty()) + return; + if (m_webView->client()) + m_webView->client()->didInvalidateRect(paintRect); +} + +void ChromeClientImpl::scroll( + const IntSize& scrollDelta, const IntRect& scrollRect, + const IntRect& clipRect) +{ + if (m_webView->client()) { + int dx = scrollDelta.width(); + int dy = scrollDelta.height(); + m_webView->client()->didScrollRect(dx, dy, clipRect); + } +} + +IntPoint ChromeClientImpl::screenToWindow(const IntPoint&) const +{ + notImplemented(); + return IntPoint(); +} + +IntRect ChromeClientImpl::windowToScreen(const IntRect& rect) const +{ + IntRect screenRect(rect); + + if (m_webView->client()) { + WebRect windowRect = m_webView->client()->windowRect(); + screenRect.move(windowRect.x, windowRect.y); + } + + return screenRect; +} + +void ChromeClientImpl::contentsSizeChanged(Frame* frame, const IntSize& size) const +{ + WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame); + if (webframe->client()) + webframe->client()->didChangeContentsSize(webframe, size); +} + +void ChromeClientImpl::scrollbarsModeDidChange() const +{ +} + +void ChromeClientImpl::mouseDidMoveOverElement( + const HitTestResult& result, unsigned modifierFlags) +{ + if (!m_webView->client()) + return; + // Find out if the mouse is over a link, and if so, let our UI know... + if (result.isLiveLink() && !result.absoluteLinkURL().string().isEmpty()) + m_webView->client()->setMouseOverURL(result.absoluteLinkURL()); + else + m_webView->client()->setMouseOverURL(WebURL()); +} + +void ChromeClientImpl::setToolTip(const String& tooltipText, TextDirection dir) +{ + if (!m_webView->client()) + return; + WebTextDirection textDirection = (dir == RTL) ? + WebTextDirectionRightToLeft : + WebTextDirectionLeftToRight; + m_webView->client()->setToolTipText( + tooltipText, textDirection); +} + +void ChromeClientImpl::print(Frame* frame) +{ + if (m_webView->client()) + m_webView->client()->printPage(WebFrameImpl::fromFrame(frame)); +} + +void ChromeClientImpl::exceededDatabaseQuota(Frame* frame, const String& databaseName) +{ + // Chromium users cannot currently change the default quota +} + +#if ENABLE(OFFLINE_WEB_APPLICATIONS) +void ChromeClientImpl::reachedMaxAppCacheSize(int64_t spaceNeeded) +{ + ASSERT_NOT_REACHED(); +} +#endif + +void ChromeClientImpl::runOpenPanel(Frame* frame, PassRefPtr<FileChooser> fileChooser) +{ + WebViewClient* client = m_webView->client(); + if (!client) + return; + + bool multipleFiles = fileChooser->allowsMultipleFiles(); + + WebString suggestion; + if (fileChooser->filenames().size() > 0) + suggestion = fileChooser->filenames()[0]; + + WebFileChooserCompletionImpl* chooserCompletion = + new WebFileChooserCompletionImpl(fileChooser); + bool ok = client->runFileChooser(multipleFiles, + WebString(), + suggestion, + chooserCompletion); + if (!ok) { + // Choosing failed, so do callback with an empty list. + chooserCompletion->didChooseFile(WebVector<WebString>()); + } +} + +void ChromeClientImpl::popupOpened(PopupContainer* popupContainer, + const IntRect& bounds, + bool activatable, + bool handleExternally) +{ + if (!m_webView->client()) + return; + + WebWidget* webwidget; + if (handleExternally) { + WebPopupMenuInfo popupInfo; + getPopupMenuInfo(popupContainer, &popupInfo); + webwidget = m_webView->client()->createPopupMenu(popupInfo); + } else + webwidget = m_webView->client()->createPopupMenu(activatable); + + static_cast<WebPopupMenuImpl*>(webwidget)->Init(popupContainer, bounds); +} + +void ChromeClientImpl::setCursor(const WebCursorInfo& cursor) +{ + if (m_ignoreNextSetCursor) { + m_ignoreNextSetCursor = false; + return; + } + + if (m_webView->client()) + m_webView->client()->didChangeCursor(cursor); +} + +void ChromeClientImpl::setCursorForPlugin(const WebCursorInfo& cursor) +{ + setCursor(cursor); + + // Currently, Widget::setCursor is always called after this function in + // EventHandler.cpp and since we don't want that we set a flag indicating + // that the next SetCursor call is to be ignored. + m_ignoreNextSetCursor = true; +} + +void ChromeClientImpl::formStateDidChange(const Node* node) +{ + // The current history item is not updated yet. That happens lazily when + // WebFrame::currentHistoryItem is requested. + WebFrameImpl* webframe = WebFrameImpl::fromFrame(node->document()->frame()); + if (webframe->client()) + webframe->client()->didUpdateCurrentHistoryItem(webframe); +} + +void ChromeClientImpl::getPopupMenuInfo(PopupContainer* popupContainer, + WebPopupMenuInfo* info) +{ + const Vector<PopupItem*>& inputItems = popupContainer->popupData(); + + WebVector<WebPopupMenuInfo::Item> outputItems(inputItems.size()); + + for (size_t i = 0; i < inputItems.size(); ++i) { + const PopupItem& inputItem = *inputItems[i]; + WebPopupMenuInfo::Item& outputItem = outputItems[i]; + + outputItem.label = inputItem.label; + outputItem.enabled = inputItem.enabled; + + switch (inputItem.type) { + case PopupItem::TypeOption: + outputItem.type = WebPopupMenuInfo::Item::Option; + break; + case PopupItem::TypeGroup: + outputItem.type = WebPopupMenuInfo::Item::Group; + break; + case PopupItem::TypeSeparator: + outputItem.type = WebPopupMenuInfo::Item::Separator; + break; + default: + ASSERT_NOT_REACHED(); + } + } + + info->itemHeight = popupContainer->menuItemHeight(); + info->selectedIndex = popupContainer->selectedIndex(); + info->items.swap(outputItems); +} + +#if ENABLE(NOTIFICATIONS) +NotificationPresenter* ChromeClientImpl::notificationPresenter() const +{ + return m_webView->notificationPresenterImpl(); +} +#endif + +} // namespace WebKit diff --git a/WebKit/chromium/src/ChromeClientImpl.h b/WebKit/chromium/src/ChromeClientImpl.h new file mode 100644 index 0000000..5a1e9cc --- /dev/null +++ b/WebKit/chromium/src/ChromeClientImpl.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ChromeClientImpl_h +#define ChromeClientImpl_h + +#include "ChromeClientChromium.h" + +namespace WebCore { +class HTMLParserQuirks; +class PopupContainer; +class SecurityOrigin; +struct WindowFeatures; +} + +namespace WebKit { +class WebViewImpl; +struct WebCursorInfo; +struct WebPopupMenuInfo; + +// Handles window-level notifications from WebCore on behalf of a WebView. +class ChromeClientImpl : public WebCore::ChromeClientChromium { +public: + explicit ChromeClientImpl(WebViewImpl* webView); + virtual ~ChromeClientImpl(); + + WebViewImpl* webView() const { return m_webView; } + + // ChromeClient methods: + virtual void chromeDestroyed(); + virtual void setWindowRect(const WebCore::FloatRect&); + virtual WebCore::FloatRect windowRect(); + virtual WebCore::FloatRect pageRect(); + virtual float scaleFactor(); + virtual void focus(); + virtual void unfocus(); + virtual bool canTakeFocus(WebCore::FocusDirection); + virtual void takeFocus(WebCore::FocusDirection); + virtual void focusedNodeChanged(WebCore::Node*); + virtual WebCore::Page* createWindow( + WebCore::Frame*, const WebCore::FrameLoadRequest&, const WebCore::WindowFeatures&); + virtual void show(); + virtual bool canRunModal(); + virtual void runModal(); + virtual void setToolbarsVisible(bool); + virtual bool toolbarsVisible(); + virtual void setStatusbarVisible(bool); + virtual bool statusbarVisible(); + virtual void setScrollbarsVisible(bool); + virtual bool scrollbarsVisible(); + virtual void setMenubarVisible(bool); + virtual bool menubarVisible(); + virtual void setResizable(bool); + virtual void addMessageToConsole( + WebCore::MessageSource, WebCore::MessageType, WebCore::MessageLevel, + const WebCore::String& message, unsigned lineNumber, + const WebCore::String& sourceID); + virtual bool canRunBeforeUnloadConfirmPanel(); + virtual bool runBeforeUnloadConfirmPanel( + const WebCore::String& message, WebCore::Frame*); + virtual void closeWindowSoon(); + virtual void runJavaScriptAlert(WebCore::Frame*, const WebCore::String&); + virtual bool runJavaScriptConfirm(WebCore::Frame*, const WebCore::String&); + virtual bool runJavaScriptPrompt( + WebCore::Frame*, const WebCore::String& message, + const WebCore::String& defaultValue, WebCore::String& result); + virtual void setStatusbarText(const WebCore::String& message); + virtual bool shouldInterruptJavaScript(); + virtual bool tabsToLinks() const; + virtual WebCore::IntRect windowResizerRect() const; + virtual void repaint( + const WebCore::IntRect&, bool contentChanged, bool immediate = false, + bool repaintContentOnly = false); + virtual void scroll( + const WebCore::IntSize& scrollDelta, const WebCore::IntRect& rectToScroll, + const WebCore::IntRect& clipRect); + virtual WebCore::IntPoint screenToWindow(const WebCore::IntPoint&) const; + virtual WebCore::IntRect windowToScreen(const WebCore::IntRect&) const; + virtual PlatformPageClient platformPageClient() const { return 0; } + virtual void contentsSizeChanged(WebCore::Frame*, const WebCore::IntSize&) const; + virtual void scrollRectIntoView( + const WebCore::IntRect&, const WebCore::ScrollView*) const { } + virtual void scrollbarsModeDidChange() const; + virtual void mouseDidMoveOverElement( + const WebCore::HitTestResult& result, unsigned modifierFlags); + virtual void setToolTip(const WebCore::String& tooltipText, WebCore::TextDirection); + virtual void print(WebCore::Frame*); + virtual void exceededDatabaseQuota( + WebCore::Frame*, const WebCore::String& databaseName); +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + virtual void reachedMaxAppCacheSize(int64_t spaceNeeded); +#endif +#if ENABLE(NOTIFICATIONS) + virtual WebCore::NotificationPresenter* notificationPresenter() const; +#endif + virtual void requestGeolocationPermissionForFrame( + WebCore::Frame*, WebCore::Geolocation*) { } + virtual void runOpenPanel(WebCore::Frame*, PassRefPtr<WebCore::FileChooser>); + virtual bool setCursor(WebCore::PlatformCursorHandle) { return false; } + virtual void formStateDidChange(const WebCore::Node*); + virtual PassOwnPtr<WebCore::HTMLParserQuirks> createHTMLParserQuirks() { return 0; } + + // ChromeClientChromium methods: + virtual void popupOpened(WebCore::PopupContainer* popupContainer, + const WebCore::IntRect& bounds, + bool activatable, + bool handleExternally); + + // ChromeClientImpl: + void setCursor(const WebCursorInfo& cursor); + void setCursorForPlugin(const WebCursorInfo& cursor); + +private: + void getPopupMenuInfo(WebCore::PopupContainer*, WebPopupMenuInfo*); + + WebViewImpl* m_webView; // weak pointer + bool m_toolbarsVisible; + bool m_statusbarVisible; + bool m_scrollbarsVisible; + bool m_menubarVisible; + bool m_resizable; + // Set to true if the next SetCursor is to be ignored. + bool m_ignoreNextSetCursor; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/ChromiumBridge.cpp b/WebKit/chromium/src/ChromiumBridge.cpp new file mode 100644 index 0000000..93d92ba --- /dev/null +++ b/WebKit/chromium/src/ChromiumBridge.cpp @@ -0,0 +1,689 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "ChromiumBridge.h" + +#include <googleurl/src/url_util.h> + +#include "ChromeClientImpl.h" +#include "WebClipboard.h" +#include "WebCookie.h" +#include "WebCursorInfo.h" +#include "WebData.h" +#include "WebFrameClient.h" +#include "WebFrameImpl.h" +#include "WebImage.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebMimeRegistry.h" +#include "WebPluginContainerImpl.h" +#include "WebPluginListBuilderImpl.h" +#include "WebScreenInfo.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebVector.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" +#include "WebWorkerClientImpl.h" + +#if PLATFORM(WIN_OS) +#include "WebRect.h" +#include "WebSandboxSupport.h" +#include "WebThemeEngine.h" +#endif + +#if PLATFORM(LINUX) +#include "WebSandboxSupport.h" +#include "WebFontInfo.h" +#endif + +#if WEBKIT_USING_SKIA +#include "NativeImageSkia.h" +#endif + +#include "BitmapImage.h" +#include "Cookie.h" +#include "FrameView.h" +#include "GraphicsContext.h" +#include "KURL.h" +#include "NotImplemented.h" +#include "PlatformContextSkia.h" +#include "PluginData.h" +#include "Worker.h" +#include "WorkerContextProxy.h" +#include <wtf/Assertions.h> + +// We are part of the WebKit implementation. +using namespace WebKit; + +namespace WebCore { + +static ChromeClientImpl* toChromeClientImpl(Widget* widget) +{ + FrameView* view; + if (widget->isFrameView()) + view = static_cast<FrameView*>(widget); + else if (widget->parent() && widget->parent()->isFrameView()) + view = static_cast<FrameView*>(widget->parent()); + else + return 0; + + Page* page = view->frame() ? view->frame()->page() : 0; + if (!page) + return 0; + + return static_cast<ChromeClientImpl*>(page->chrome()->client()); +} + +static WebWidgetClient* toWebWidgetClient(Widget* widget) +{ + ChromeClientImpl* chromeClientImpl = toChromeClientImpl(widget); + if (!chromeClientImpl || !chromeClientImpl->webView()) + return 0; + return chromeClientImpl->webView()->client(); +} + +// Clipboard ------------------------------------------------------------------ + +bool ChromiumBridge::clipboardIsFormatAvailable( + PasteboardPrivate::ClipboardFormat format, + PasteboardPrivate::ClipboardBuffer buffer) +{ + return webKitClient()->clipboard()->isFormatAvailable( + static_cast<WebClipboard::Format>(format), + static_cast<WebClipboard::Buffer>(buffer)); +} + +String ChromiumBridge::clipboardReadPlainText( + PasteboardPrivate::ClipboardBuffer buffer) +{ + return webKitClient()->clipboard()->readPlainText( + static_cast<WebClipboard::Buffer>(buffer)); +} + +void ChromiumBridge::clipboardReadHTML( + PasteboardPrivate::ClipboardBuffer buffer, + String* htmlText, KURL* sourceURL) +{ + WebURL url; + *htmlText = webKitClient()->clipboard()->readHTML( + static_cast<WebClipboard::Buffer>(buffer), &url); + *sourceURL = url; +} + +void ChromiumBridge::clipboardWriteSelection(const String& htmlText, + const KURL& sourceURL, + const String& plainText, + bool writeSmartPaste) +{ + webKitClient()->clipboard()->writeHTML( + htmlText, sourceURL, plainText, writeSmartPaste); +} + +void ChromiumBridge::clipboardWritePlainText(const String& plainText) +{ + webKitClient()->clipboard()->writePlainText(plainText); +} + +void ChromiumBridge::clipboardWriteURL(const KURL& url, const String& title) +{ + webKitClient()->clipboard()->writeURL(url, title); +} + +void ChromiumBridge::clipboardWriteImage(NativeImagePtr image, + const KURL& sourceURL, + const String& title) +{ +#if WEBKIT_USING_SKIA + WebImage webImage(*image); +#else + WebImage webImage(image); +#endif + webKitClient()->clipboard()->writeImage(webImage, sourceURL, title); +} + +// Cookies -------------------------------------------------------------------- + +void ChromiumBridge::setCookies(const KURL& url, + const KURL& firstPartyForCookies, + const String& cookie) +{ + webKitClient()->setCookies(url, firstPartyForCookies, cookie); +} + +String ChromiumBridge::cookies(const KURL& url, + const KURL& firstPartyForCookies) +{ + return webKitClient()->cookies(url, firstPartyForCookies); +} + +bool ChromiumBridge::rawCookies(const KURL& url, const KURL& firstPartyForCookies, Vector<Cookie>* rawCookies) +{ + rawCookies->clear(); + WebVector<WebCookie> webCookies; + if (!webKitClient()->rawCookies(url, firstPartyForCookies, &webCookies)) + return false; + + for (unsigned i = 0; i < webCookies.size(); ++i) { + const WebCookie& webCookie = webCookies[i]; + Cookie cookie(webCookie.name, + webCookie.value, + webCookie.domain, + webCookie.path, + webCookie.expires, + webCookie.httpOnly, + webCookie.secure, + webCookie.session); + rawCookies->append(cookie); + } + return true; +} + +void ChromiumBridge::deleteCookie(const KURL& url, const String& cookieName) +{ + webKitClient()->deleteCookie(url, cookieName); +} + +// DNS ------------------------------------------------------------------------ + +void ChromiumBridge::prefetchDNS(const String& hostname) +{ + webKitClient()->prefetchHostName(hostname); +} + +// File ------------------------------------------------------------------------ + +bool ChromiumBridge::fileExists(const String& path) +{ + return webKitClient()->fileExists(path); +} + +bool ChromiumBridge::deleteFile(const String& path) +{ + return webKitClient()->deleteFile(path); +} + +bool ChromiumBridge::deleteEmptyDirectory(const String& path) +{ + return webKitClient()->deleteEmptyDirectory(path); +} + +bool ChromiumBridge::getFileSize(const String& path, long long& result) +{ + return webKitClient()->getFileSize(path, result); +} + +bool ChromiumBridge::getFileModificationTime(const String& path, time_t& result) +{ + return webKitClient()->getFileModificationTime(path, result); +} + +String ChromiumBridge::directoryName(const String& path) +{ + return webKitClient()->directoryName(path); +} + +String ChromiumBridge::pathByAppendingComponent(const String& path, const String& component) +{ + return webKitClient()->pathByAppendingComponent(path, component); +} + +bool ChromiumBridge::makeAllDirectories(const String& path) +{ + return webKitClient()->makeAllDirectories(path); +} + +String ChromiumBridge::getAbsolutePath(const String& path) +{ + return webKitClient()->getAbsolutePath(path); +} + +bool ChromiumBridge::isDirectory(const String& path) +{ + return webKitClient()->isDirectory(path); +} + +KURL ChromiumBridge::filePathToURL(const String& path) +{ + return webKitClient()->filePathToURL(path); +} + +// Font ----------------------------------------------------------------------- + +#if PLATFORM(WIN_OS) +bool ChromiumBridge::ensureFontLoaded(HFONT font) +{ + WebSandboxSupport* ss = webKitClient()->sandboxSupport(); + + // if there is no sandbox, then we can assume the font + // was able to be loaded successfully already + return ss ? ss->ensureFontLoaded(font) : true; +} +#endif + +#if PLATFORM(LINUX) +String ChromiumBridge::getFontFamilyForCharacters(const UChar* characters, size_t numCharacters) +{ + if (webKitClient()->sandboxSupport()) + return webKitClient()->sandboxSupport()->getFontFamilyForCharacters(characters, numCharacters); + + WebCString family = WebFontInfo::familyForChars(characters, numCharacters); + if (family.data()) + return WebString::fromUTF8(family.data()); + + return WebString(); +} +#endif + +// HTML5 DB ------------------------------------------------------------------- + +#if ENABLE(DATABASE) +PlatformFileHandle ChromiumBridge::databaseOpenFile(const String& vfsFileName, int desiredFlags, PlatformFileHandle* dirHandle) +{ + return webKitClient()->databaseOpenFile(WebString(vfsFileName), desiredFlags, dirHandle); +} + +int ChromiumBridge::databaseDeleteFile(const String& vfsFileName, bool syncDir) +{ + return webKitClient()->databaseDeleteFile(WebString(vfsFileName), syncDir); +} + +long ChromiumBridge::databaseGetFileAttributes(const String& vfsFileName) +{ + return webKitClient()->databaseGetFileAttributes(WebString(vfsFileName)); +} + +long long ChromiumBridge::databaseGetFileSize(const String& vfsFileName) +{ + return webKitClient()->databaseGetFileSize(WebString(vfsFileName)); +} +#endif + +// Keygen --------------------------------------------------------------------- + +String ChromiumBridge::signedPublicKeyAndChallengeString( + unsigned keySizeIndex, const String& challenge, const KURL& url) +{ + return webKitClient()->signedPublicKeyAndChallengeString(keySizeIndex, + WebString(challenge), + WebURL(url)); +} + +// Language ------------------------------------------------------------------- + +String ChromiumBridge::computedDefaultLanguage() +{ + return webKitClient()->defaultLocale(); +} + +// LayoutTestMode ------------------------------------------------------------- + +bool ChromiumBridge::layoutTestMode() +{ + return WebKit::layoutTestMode(); +} + +// MimeType ------------------------------------------------------------------- + +bool ChromiumBridge::isSupportedImageMIMEType(const String& mimeType) +{ + return webKitClient()->mimeRegistry()->supportsImageMIMEType(mimeType) + != WebMimeRegistry::IsNotSupported; +} + +bool ChromiumBridge::isSupportedJavaScriptMIMEType(const String& mimeType) +{ + return webKitClient()->mimeRegistry()->supportsJavaScriptMIMEType(mimeType) + != WebMimeRegistry::IsNotSupported; +} + +bool ChromiumBridge::isSupportedNonImageMIMEType(const String& mimeType) +{ + return webKitClient()->mimeRegistry()->supportsNonImageMIMEType(mimeType) + != WebMimeRegistry::IsNotSupported; +} + +String ChromiumBridge::mimeTypeForExtension(const String& extension) +{ + return webKitClient()->mimeRegistry()->mimeTypeForExtension(extension); +} + +String ChromiumBridge::mimeTypeFromFile(const String& path) +{ + return webKitClient()->mimeRegistry()->mimeTypeFromFile(path); +} + +String ChromiumBridge::preferredExtensionForMIMEType(const String& mimeType) +{ + return webKitClient()->mimeRegistry()->preferredExtensionForMIMEType(mimeType); +} + +// Plugin --------------------------------------------------------------------- + +bool ChromiumBridge::plugins(bool refresh, Vector<PluginInfo*>* results) +{ + WebPluginListBuilderImpl builder(results); + webKitClient()->getPluginList(refresh, &builder); + return true; // FIXME: There is no need for this function to return a value. +} + +NPObject* ChromiumBridge::pluginScriptableObject(Widget* widget) +{ + if (!widget) + return 0; + + ASSERT(!widget->isFrameView()); + + // NOTE: We have to trust that the widget passed to us here is a + // WebPluginContainerImpl. There isn't a way to dynamically verify it, + // since the derived class (Widget) has no identifier. + return static_cast<WebPluginContainerImpl*>(widget)->scriptableObject(); +} + +// Resources ------------------------------------------------------------------ + +PassRefPtr<Image> ChromiumBridge::loadPlatformImageResource(const char* name) +{ + const WebData& resource = webKitClient()->loadResource(name); + if (resource.isEmpty()) + return Image::nullImage(); + + RefPtr<Image> image = BitmapImage::create(); + image->setData(resource, true); + return image; +} + +// Sandbox -------------------------------------------------------------------- + +bool ChromiumBridge::sandboxEnabled() +{ + return webKitClient()->sandboxEnabled(); +} + +// SharedTimers --------------------------------------------------------------- + +void ChromiumBridge::setSharedTimerFiredFunction(void (*func)()) +{ + webKitClient()->setSharedTimerFiredFunction(func); +} + +void ChromiumBridge::setSharedTimerFireTime(double fireTime) +{ + webKitClient()->setSharedTimerFireTime(fireTime); +} + +void ChromiumBridge::stopSharedTimer() +{ + webKitClient()->stopSharedTimer(); +} + +// StatsCounters -------------------------------------------------------------- + +void ChromiumBridge::decrementStatsCounter(const char* name) +{ + webKitClient()->decrementStatsCounter(name); +} + +void ChromiumBridge::incrementStatsCounter(const char* name) +{ + webKitClient()->incrementStatsCounter(name); +} + +// Sudden Termination --------------------------------------------------------- + +void ChromiumBridge::suddenTerminationChanged(bool enabled) +{ + webKitClient()->suddenTerminationChanged(enabled); +} + +// SystemTime ----------------------------------------------------------------- + +double ChromiumBridge::currentTime() +{ + return webKitClient()->currentTime(); +} + +// Theming -------------------------------------------------------------------- + +#if PLATFORM(WIN_OS) + +void ChromiumBridge::paintButton( + GraphicsContext* gc, int part, int state, int classicState, + const IntRect& rect) +{ + webKitClient()->themeEngine()->paintButton( + gc->platformContext()->canvas(), part, state, classicState, rect); +} + +void ChromiumBridge::paintMenuList( + GraphicsContext* gc, int part, int state, int classicState, + const IntRect& rect) +{ + webKitClient()->themeEngine()->paintMenuList( + gc->platformContext()->canvas(), part, state, classicState, rect); +} + +void ChromiumBridge::paintScrollbarArrow( + GraphicsContext* gc, int state, int classicState, + const IntRect& rect) +{ + webKitClient()->themeEngine()->paintScrollbarArrow( + gc->platformContext()->canvas(), state, classicState, rect); +} + +void ChromiumBridge::paintScrollbarThumb( + GraphicsContext* gc, int part, int state, int classicState, + const IntRect& rect) +{ + webKitClient()->themeEngine()->paintScrollbarThumb( + gc->platformContext()->canvas(), part, state, classicState, rect); +} + +void ChromiumBridge::paintScrollbarTrack( + GraphicsContext* gc, int part, int state, int classicState, + const IntRect& rect, const IntRect& alignRect) +{ + webKitClient()->themeEngine()->paintScrollbarTrack( + gc->platformContext()->canvas(), part, state, classicState, rect, + alignRect); +} + +void ChromiumBridge::paintTextField( + GraphicsContext* gc, int part, int state, int classicState, + const IntRect& rect, const Color& color, bool fillContentArea, + bool drawEdges) +{ + // Fallback to white when |color| is invalid. + RGBA32 backgroundColor = color.isValid() ? color.rgb() : Color::white; + + webKitClient()->themeEngine()->paintTextField( + gc->platformContext()->canvas(), part, state, classicState, rect, + backgroundColor, fillContentArea, drawEdges); +} + +void ChromiumBridge::paintTrackbar( + GraphicsContext* gc, int part, int state, int classicState, + const IntRect& rect) +{ + webKitClient()->themeEngine()->paintTrackbar( + gc->platformContext()->canvas(), part, state, classicState, rect); +} + +#endif + +// Trace Event ---------------------------------------------------------------- + +void ChromiumBridge::traceEventBegin(const char* name, void* id, const char* extra) +{ + webKitClient()->traceEventBegin(name, id, extra); +} + +void ChromiumBridge::traceEventEnd(const char* name, void* id, const char* extra) +{ + webKitClient()->traceEventEnd(name, id, extra); +} + +// Visited Links -------------------------------------------------------------- + +LinkHash ChromiumBridge::visitedLinkHash(const UChar* url, unsigned length) +{ + url_canon::RawCanonOutput<2048> buffer; + url_parse::Parsed parsed; + if (!url_util::Canonicalize(url, length, 0, &buffer, &parsed)) + return 0; // Invalid URLs are unvisited. + return webKitClient()->visitedLinkHash(buffer.data(), buffer.length()); +} + +LinkHash ChromiumBridge::visitedLinkHash(const KURL& base, + const AtomicString& attributeURL) +{ + // Resolve the relative URL using googleurl and pass the absolute URL up to + // the embedder. We could create a GURL object from the base and resolve + // the relative URL that way, but calling the lower-level functions + // directly saves us the string allocation in most cases. + url_canon::RawCanonOutput<2048> buffer; + url_parse::Parsed parsed; + +#if USE(GOOGLEURL) + const CString& cstr = base.utf8String(); + const char* data = cstr.data(); + int length = cstr.length(); + const url_parse::Parsed& srcParsed = base.parsed(); +#else + // When we're not using GoogleURL, first canonicalize it so we can resolve it + // below. + url_canon::RawCanonOutput<2048> srcCanon; + url_parse::Parsed srcParsed; + String str = base.string(); + if (!url_util::Canonicalize(str.characters(), str.length(), 0, &srcCanon, &srcParsed)) + return 0; + const char* data = srcCanon.data(); + int length = srcCanon.length(); +#endif + + if (!url_util::ResolveRelative(data, length, srcParsed, attributeURL.characters(), + attributeURL.length(), 0, &buffer, &parsed)) + return 0; // Invalid resolved URL. + + return webKitClient()->visitedLinkHash(buffer.data(), buffer.length()); +} + +bool ChromiumBridge::isLinkVisited(LinkHash visitedLinkHash) +{ + return webKitClient()->isLinkVisited(visitedLinkHash); +} + +// These are temporary methods that the WebKit layer can use to call to the +// Glue layer. Once the Glue layer moves entirely into the WebKit layer, these +// methods will be deleted. + +void ChromiumBridge::notifyJSOutOfMemory(Frame* frame) +{ + if (!frame) + return; + + WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame); + if (!webFrame->client()) + return; + webFrame->client()->didExhaustMemoryAvailableForScript(webFrame); +} + +int ChromiumBridge::memoryUsageMB() +{ + return static_cast<int>(webKitClient()->memoryUsageMB()); +} + +int ChromiumBridge::screenDepth(Widget* widget) +{ + WebWidgetClient* client = toWebWidgetClient(widget); + if (!client) + return 0; + return client->screenInfo().depth; +} + +int ChromiumBridge::screenDepthPerComponent(Widget* widget) +{ + WebWidgetClient* client = toWebWidgetClient(widget); + if (!client) + return 0; + return client->screenInfo().depthPerComponent; +} + +bool ChromiumBridge::screenIsMonochrome(Widget* widget) +{ + WebWidgetClient* client = toWebWidgetClient(widget); + if (!client) + return 0; + return client->screenInfo().isMonochrome; +} + +IntRect ChromiumBridge::screenRect(Widget* widget) +{ + WebWidgetClient* client = toWebWidgetClient(widget); + if (!client) + return IntRect(); + return client->screenInfo().rect; +} + +IntRect ChromiumBridge::screenAvailableRect(Widget* widget) +{ + WebWidgetClient* client = toWebWidgetClient(widget); + if (!client) + return IntRect(); + return client->screenInfo().availableRect; +} + +bool ChromiumBridge::popupsAllowed(NPP npp) +{ + // FIXME: Give the embedder a way to control this. + return false; +} + +void ChromiumBridge::widgetSetCursor(Widget* widget, const Cursor& cursor) +{ + ChromeClientImpl* client = toChromeClientImpl(widget); + if (client) + client->setCursor(WebCursorInfo(cursor)); +} + +void ChromiumBridge::widgetSetFocus(Widget* widget) +{ + ChromeClientImpl* client = toChromeClientImpl(widget); + if (client) + client->focus(); +} + +WorkerContextProxy* WorkerContextProxy::create(Worker* worker) +{ + return WebWorkerClientImpl::createWorkerContextProxy(worker); +} + +} // namespace WebCore diff --git a/WebKit/chromium/src/ChromiumCurrentTime.cpp b/WebKit/chromium/src/ChromiumCurrentTime.cpp new file mode 100644 index 0000000..1eccc41 --- /dev/null +++ b/WebKit/chromium/src/ChromiumCurrentTime.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include <wtf/CurrentTime.h> + +#include "WebKit.h" +#include "WebKitClient.h" + +namespace WTF { + +double currentTime() +{ + return WebKit::webKitClient()->currentTime(); +} + +} // namespace WTF diff --git a/WebKit/chromium/src/ChromiumThreading.cpp b/WebKit/chromium/src/ChromiumThreading.cpp new file mode 100644 index 0000000..902a433 --- /dev/null +++ b/WebKit/chromium/src/ChromiumThreading.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include <wtf/chromium/ChromiumThreading.h> + +#include "WebKit.h" +#include "WebKitClient.h" + +#include <wtf/MainThread.h> + +namespace WTF { + +void ChromiumThreading::initializeMainThread() +{ +} + +void ChromiumThreading::scheduleDispatchFunctionsOnMainThread() +{ + WebKit::webKitClient()->callOnMainThread(&WTF::dispatchFunctionsFromMainThread); +} + +} // namespace WTF diff --git a/WebKit/chromium/src/ContextMenuClientImpl.cpp b/WebKit/chromium/src/ContextMenuClientImpl.cpp new file mode 100644 index 0000000..f23919e --- /dev/null +++ b/WebKit/chromium/src/ContextMenuClientImpl.cpp @@ -0,0 +1,279 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "ContextMenuClientImpl.h" + +#include "ContextMenu.h" +#include "Document.h" +#include "DocumentLoader.h" +#include "Editor.h" +#include "EventHandler.h" +#include "FrameLoader.h" +#include "FrameView.h" +#include "HitTestResult.h" +#include "HTMLMediaElement.h" +#include "HTMLNames.h" +#include "KURL.h" +#include "MediaError.h" +#include "PlatformString.h" +#include "TextBreakIterator.h" +#include "Widget.h" + +#include "WebContextMenuData.h" +#include "WebDataSourceImpl.h" +#include "WebFrameImpl.h" +#include "WebMenuItemInfo.h" +#include "WebPoint.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebURLResponse.h" +#include "WebVector.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" + +using namespace WebCore; + +namespace WebKit { + +// Figure out the URL of a page or subframe. Returns |page_type| as the type, +// which indicates page or subframe, or ContextNodeType::NONE if the URL could not +// be determined for some reason. +static WebURL urlFromFrame(Frame* frame) +{ + if (frame) { + DocumentLoader* dl = frame->loader()->documentLoader(); + if (dl) { + WebDataSource* ds = WebDataSourceImpl::fromDocumentLoader(dl); + if (ds) + return ds->hasUnreachableURL() ? ds->unreachableURL() : ds->request().url(); + } + } + return WebURL(); +} + +// Helper function to determine whether text is a single word or a sentence. +static bool isASingleWord(const String& text) +{ + TextBreakIterator* it = characterBreakIterator(text.characters(), text.length()); + return it && textBreakNext(it) == TextBreakDone; +} + +// Helper function to get misspelled word on which context menu +// is to be evolked. This function also sets the word on which context menu +// has been evoked to be the selected word, as required. This function changes +// the selection only when there were no selected characters. +static String selectMisspelledWord(const ContextMenu* defaultMenu, Frame* selectedFrame) +{ + // First select from selectedText to check for multiple word selection. + String misspelledWord = selectedFrame->selectedText().stripWhiteSpace(); + + // If some texts were already selected, we don't change the selection. + if (!misspelledWord.isEmpty()) { + // Don't provide suggestions for multiple words. + if (!isASingleWord(misspelledWord)) + return String(); + return misspelledWord; + } + + // Selection is empty, so change the selection to the word under the cursor. + HitTestResult hitTestResult = selectedFrame->eventHandler()-> + hitTestResultAtPoint(defaultMenu->hitTestResult().point(), true); + Node* innerNode = hitTestResult.innerNode(); + VisiblePosition pos(innerNode->renderer()->positionForPoint( + hitTestResult.localPoint())); + + VisibleSelection selection; + if (pos.isNotNull()) { + selection = VisibleSelection(pos); + selection.expandUsingGranularity(WordGranularity); + } + + if (selection.isRange()) + selectedFrame->setSelectionGranularity(WordGranularity); + + if (selectedFrame->shouldChangeSelection(selection)) + selectedFrame->selection()->setSelection(selection); + + misspelledWord = selectedFrame->selectedText().stripWhiteSpace(); + + // If misspelled word is still empty, then that portion should not be + // selected. Set the selection to that position only, and do not expand. + if (misspelledWord.isEmpty()) { + selection = VisibleSelection(pos); + selectedFrame->selection()->setSelection(selection); + } + + return misspelledWord; +} + +PlatformMenuDescription ContextMenuClientImpl::getCustomMenuFromDefaultItems( + ContextMenu* defaultMenu) +{ + // Displaying the context menu in this function is a big hack as we don't + // have context, i.e. whether this is being invoked via a script or in + // response to user input (Mouse event WM_RBUTTONDOWN, + // Keyboard events KeyVK_APPS, Shift+F10). Check if this is being invoked + // in response to the above input events before popping up the context menu. + if (!m_webView->contextMenuAllowed()) + return 0; + + HitTestResult r = defaultMenu->hitTestResult(); + Frame* selectedFrame = r.innerNonSharedNode()->document()->frame(); + + WebContextMenuData data; + data.mousePosition = selectedFrame->view()->contentsToWindow(r.point()); + + // Links, Images, Media tags, and Image/Media-Links take preference over + // all else. + data.linkURL = r.absoluteLinkURL(); + + data.mediaType = WebContextMenuData::MediaTypeNone; + data.mediaFlags = WebContextMenuData::MediaNone; + + if (!r.absoluteImageURL().isEmpty()) { + data.srcURL = r.absoluteImageURL(); + data.mediaType = WebContextMenuData::MediaTypeImage; + } else if (!r.absoluteMediaURL().isEmpty()) { + data.srcURL = r.absoluteMediaURL(); + + // We know that if absoluteMediaURL() is not empty, then this + // is a media element. + HTMLMediaElement* mediaElement = + static_cast<HTMLMediaElement*>(r.innerNonSharedNode()); + if (mediaElement->hasTagName(HTMLNames::videoTag)) + data.mediaType = WebContextMenuData::MediaTypeVideo; + else if (mediaElement->hasTagName(HTMLNames::audioTag)) + data.mediaType = WebContextMenuData::MediaTypeAudio; + + if (mediaElement->error()) + data.mediaFlags |= WebContextMenuData::MediaInError; + if (mediaElement->paused()) + data.mediaFlags |= WebContextMenuData::MediaPaused; + if (mediaElement->muted()) + data.mediaFlags |= WebContextMenuData::MediaMuted; + if (mediaElement->loop()) + data.mediaFlags |= WebContextMenuData::MediaLoop; + if (mediaElement->supportsSave()) + data.mediaFlags |= WebContextMenuData::MediaCanSave; + if (mediaElement->hasAudio()) + data.mediaFlags |= WebContextMenuData::MediaHasAudio; + } + // If it's not a link, an image, a media element, or an image/media link, + // show a selection menu or a more generic page menu. + data.frameEncoding = selectedFrame->loader()->encoding(); + + // Send the frame and page URLs in any case. + data.pageURL = urlFromFrame(m_webView->mainFrameImpl()->frame()); + if (selectedFrame != m_webView->mainFrameImpl()->frame()) + data.frameURL = urlFromFrame(selectedFrame); + + if (r.isSelected()) + data.selectedText = selectedFrame->selectedText().stripWhiteSpace(); + + data.isEditable = false; + if (r.isContentEditable()) { + data.isEditable = true; + if (m_webView->focusedWebCoreFrame()->editor()->isContinuousSpellCheckingEnabled()) { + data.isSpellCheckingEnabled = true; + data.misspelledWord = selectMisspelledWord(defaultMenu, selectedFrame); + } + } + + // Now retrieve the security info. + DocumentLoader* dl = selectedFrame->loader()->documentLoader(); + WebDataSource* ds = WebDataSourceImpl::fromDocumentLoader(dl); + if (ds) + data.securityInfo = ds->response().securityInfo(); + + // Compute edit flags. + data.editFlags = WebContextMenuData::CanDoNone; + if (m_webView->focusedWebCoreFrame()->editor()->canUndo()) + data.editFlags |= WebContextMenuData::CanUndo; + if (m_webView->focusedWebCoreFrame()->editor()->canRedo()) + data.editFlags |= WebContextMenuData::CanRedo; + if (m_webView->focusedWebCoreFrame()->editor()->canCut()) + data.editFlags |= WebContextMenuData::CanCut; + if (m_webView->focusedWebCoreFrame()->editor()->canCopy()) + data.editFlags |= WebContextMenuData::CanCopy; + if (m_webView->focusedWebCoreFrame()->editor()->canPaste()) + data.editFlags |= WebContextMenuData::CanPaste; + if (m_webView->focusedWebCoreFrame()->editor()->canDelete()) + data.editFlags |= WebContextMenuData::CanDelete; + // We can always select all... + data.editFlags |= WebContextMenuData::CanSelectAll; + + // Filter out custom menu elements and add them into the data. + populateCustomMenuItems(defaultMenu, &data); + + WebFrame* selected_web_frame = WebFrameImpl::fromFrame(selectedFrame); + if (m_webView->client()) + m_webView->client()->showContextMenu(selected_web_frame, data); + + return 0; +} + +void ContextMenuClientImpl::populateCustomMenuItems(WebCore::ContextMenu* defaultMenu, WebContextMenuData* data) +{ + Vector<WebMenuItemInfo> customItems; + for (size_t i = 0; i < defaultMenu->itemCount(); ++i) { + ContextMenuItem* inputItem = defaultMenu->itemAtIndex(i, defaultMenu->platformDescription()); + if (inputItem->action() < ContextMenuItemBaseCustomTag || inputItem->action() >= ContextMenuItemBaseApplicationTag) + continue; + + WebMenuItemInfo outputItem; + outputItem.label = inputItem->title(); + outputItem.enabled = inputItem->enabled(); + outputItem.checked = inputItem->checked(); + outputItem.action = static_cast<unsigned>(inputItem->action() - ContextMenuItemBaseCustomTag); + switch (inputItem->type()) { + case ActionType: + outputItem.type = WebMenuItemInfo::Option; + break; + case CheckableActionType: + outputItem.type = WebMenuItemInfo::CheckableOption; + break; + case SeparatorType: + outputItem.type = WebMenuItemInfo::Separator; + break; + case SubmenuType: + outputItem.type = WebMenuItemInfo::Group; + break; + } + customItems.append(outputItem); + } + + WebVector<WebMenuItemInfo> outputItems(customItems.size()); + for (size_t i = 0; i < customItems.size(); ++i) + outputItems[i] = customItems[i]; + data->customItems.swap(outputItems); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/ContextMenuClientImpl.h b/WebKit/chromium/src/ContextMenuClientImpl.h new file mode 100644 index 0000000..4191fad --- /dev/null +++ b/WebKit/chromium/src/ContextMenuClientImpl.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ContextMenuClientImpl_h +#define ContextMenuClientImpl_h + +#include "ContextMenuClient.h" + +namespace WebKit { + +class WebViewImpl; +struct WebContextMenuData; + +class ContextMenuClientImpl : public WebCore::ContextMenuClient { +public: + ContextMenuClientImpl(WebViewImpl* webView) : m_webView(webView) {} + virtual ~ContextMenuClientImpl() {} + virtual void copyImageToClipboard(const WebCore::HitTestResult&) {} + virtual void contextMenuDestroyed() {} + virtual void contextMenuItemSelected(WebCore::ContextMenuItem*, const WebCore::ContextMenu*) {} + virtual void downloadURL(const WebCore::KURL&) {} + virtual WebCore::PlatformMenuDescription getCustomMenuFromDefaultItems(WebCore::ContextMenu*); + virtual bool isSpeaking() { return false; } + virtual void lookUpInDictionary(WebCore::Frame*) {} + virtual void searchWithGoogle(const WebCore::Frame*) {} + virtual bool shouldIncludeInspectElementItem() { return false; } + virtual void speak(const WebCore::String&) {} + virtual void stopSpeaking() {} +private: + void populateCustomMenuItems(WebCore::ContextMenu*, WebContextMenuData*); + WebViewImpl* m_webView; +}; + +} // namespace WebKit + +#endif // ContextMenuClientImpl_h diff --git a/WebKit/chromium/src/DOMUtilitiesPrivate.cpp b/WebKit/chromium/src/DOMUtilitiesPrivate.cpp new file mode 100644 index 0000000..ffdd85d --- /dev/null +++ b/WebKit/chromium/src/DOMUtilitiesPrivate.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "DOMUtilitiesPrivate.h" + +#include "Element.h" +#include "HTMLInputElement.h" +#include "HTMLLinkElement.h" +#include "HTMLMetaElement.h" +#include "HTMLNames.h" +#include "HTMLOptionElement.h" +#include "Node.h" + +#include "WebInputElement.h" + +using namespace WebCore; + +namespace { + +template <class HTMLNodeType> +HTMLNodeType* toHTMLElement(Node* node, const QualifiedName& name) +{ + if (node->isHTMLElement() + && static_cast<HTMLElement*>(node)->hasTagName(name)) { + return static_cast<HTMLNodeType*>(node); + } + return 0; +} + +} // namespace + +namespace WebKit { + +HTMLInputElement* toHTMLInputElement(Node* node) +{ + return toHTMLElement<HTMLInputElement>(node, HTMLNames::inputTag); +} + +HTMLLinkElement* toHTMLLinkElement(Node* node) +{ + return toHTMLElement<HTMLLinkElement>(node, HTMLNames::linkTag); +} + +HTMLMetaElement* toHTMLMetaElement(Node* node) +{ + return toHTMLElement<HTMLMetaElement>(node, HTMLNames::metaTag); +} + +HTMLOptionElement* toHTMLOptionElement(Node* node) +{ + return toHTMLElement<HTMLOptionElement>(node, HTMLNames::optionTag); +} + +String nameOfInputElement(HTMLInputElement* element) +{ + return WebInputElement(element).nameForAutofill(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/DOMUtilitiesPrivate.h b/WebKit/chromium/src/DOMUtilitiesPrivate.h new file mode 100644 index 0000000..c02bf84 --- /dev/null +++ b/WebKit/chromium/src/DOMUtilitiesPrivate.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef DOMUtilitiesPrivate_h +#define DOMUtilitiesPrivate_h + +namespace WebCore { +class HTMLInputElement; +class HTMLLinkElement; +class HTMLMetaElement; +class HTMLOptionElement; +class Node; +class String; +} + +// This file is an aggregate of useful WebCore operations. +namespace WebKit { + +// If node is an HTML node with a tag name of name it is casted and returned. +// If node is not an HTML node or the tag name is not name, 0 is returned. +WebCore::HTMLInputElement* toHTMLInputElement(WebCore::Node*); +WebCore::HTMLLinkElement* toHTMLLinkElement(WebCore::Node*); +WebCore::HTMLMetaElement* toHTMLMetaElement(WebCore::Node*); +WebCore::HTMLOptionElement* toHTMLOptionElement(WebCore::Node*); + +// FIXME: Deprecate. Use WebInputElement::nameForAutofill instead. +WebCore::String nameOfInputElement(WebCore::HTMLInputElement*); + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/DatabaseObserver.cpp b/WebKit/chromium/src/DatabaseObserver.cpp new file mode 100644 index 0000000..54e93e1 --- /dev/null +++ b/WebKit/chromium/src/DatabaseObserver.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "DatabaseObserver.h" + +#include "Database.h" +#include "WebDatabase.h" +#include "WebDatabaseObserver.h" + +using namespace WebKit; + +namespace WebCore { + +void DatabaseObserver::databaseOpened(Database* database) +{ + ASSERT(isMainThread()); + WebDatabase::observer()->databaseOpened(WebDatabase(database)); +} + +void DatabaseObserver::databaseModified(Database* database) +{ + ASSERT(isMainThread()); + WebDatabase::observer()->databaseModified(WebDatabase(database)); +} + +void DatabaseObserver::databaseClosed(Database* database) +{ + ASSERT(isMainThread()); + WebDatabase::observer()->databaseClosed(WebDatabase(database)); +} + +} // namespace WebCore diff --git a/WebKit/chromium/src/DragClientImpl.cpp b/WebKit/chromium/src/DragClientImpl.cpp new file mode 100644 index 0000000..5d8a9c3 --- /dev/null +++ b/WebKit/chromium/src/DragClientImpl.cpp @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "DragClientImpl.h" + +#include "ChromiumDataObject.h" +#include "ClipboardChromium.h" +#include "Frame.h" +#include "WebDragData.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" + +using namespace WebCore; + +namespace WebKit { + +void DragClientImpl::willPerformDragDestinationAction(DragDestinationAction, DragData*) +{ + // FIXME +} + +void DragClientImpl::willPerformDragSourceAction(DragSourceAction, const IntPoint&, Clipboard*) +{ + // FIXME +} + +DragDestinationAction DragClientImpl::actionMaskForDrag(DragData*) +{ + if (m_webView->client() && m_webView->client()->acceptsLoadDrops()) + return DragDestinationActionAny; + + return static_cast<DragDestinationAction>( + DragDestinationActionDHTML | DragDestinationActionEdit); +} + +DragSourceAction DragClientImpl::dragSourceActionMaskForPoint(const IntPoint& windowPoint) +{ + // We want to handle drag operations for all source types. + return DragSourceActionAny; +} + +void DragClientImpl::startDrag(DragImageRef dragImage, + const IntPoint& dragImageOrigin, + const IntPoint& eventPos, + Clipboard* clipboard, + Frame* frame, + bool isLinkDrag) +{ + // Add a ref to the frame just in case a load occurs mid-drag. + RefPtr<Frame> frameProtector = frame; + + WebDragData dragData = static_cast<ClipboardChromium*>(clipboard)->dataObject(); + + DragOperation dragOperationMask; + if (!clipboard->sourceOperation(dragOperationMask)) + dragOperationMask = DragOperationEvery; + + m_webView->startDragging( + eventPos, dragData, static_cast<WebDragOperationsMask>(dragOperationMask)); +} + +DragImageRef DragClientImpl::createDragImageForLink(KURL&, const String& label, Frame*) +{ + // FIXME + return 0; +} + +void DragClientImpl::dragControllerDestroyed() +{ + // Our lifetime is bound to the WebViewImpl. +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/DragClientImpl.h b/WebKit/chromium/src/DragClientImpl.h new file mode 100644 index 0000000..fc4c608 --- /dev/null +++ b/WebKit/chromium/src/DragClientImpl.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef DragClientImpl_h +#define DragClientImpl_h + +#include "DragActions.h" +#include "DragClient.h" + +namespace WebCore { +class ClipBoard; +class DragData; +class IntPoint; +class KURL; +} + +namespace WebKit { +class WebViewImpl; + +class DragClientImpl : public WebCore::DragClient { +public: + DragClientImpl(WebViewImpl* webView) : m_webView(webView) { } + + virtual void willPerformDragDestinationAction( + WebCore::DragDestinationAction, WebCore::DragData*); + virtual void willPerformDragSourceAction( + WebCore::DragSourceAction, const WebCore::IntPoint&, WebCore::Clipboard*); + virtual WebCore::DragDestinationAction actionMaskForDrag(WebCore::DragData*); + virtual WebCore::DragSourceAction dragSourceActionMaskForPoint( + const WebCore::IntPoint& windowPoint); + virtual void startDrag( + WebCore::DragImageRef dragImage, + const WebCore::IntPoint& dragImageOrigin, + const WebCore::IntPoint& eventPos, + WebCore::Clipboard* clipboard, + WebCore::Frame* frame, + bool isLinkDrag = false); + virtual WebCore::DragImageRef createDragImageForLink( + WebCore::KURL&, const WebCore::String& label, WebCore::Frame*); + virtual void dragControllerDestroyed(); + +private: + WebViewImpl* m_webView; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/EditorClientImpl.cpp b/WebKit/chromium/src/EditorClientImpl.cpp new file mode 100644 index 0000000..5db8ff7 --- /dev/null +++ b/WebKit/chromium/src/EditorClientImpl.cpp @@ -0,0 +1,922 @@ +/* + * Copyright (C) 2006, 2007 Apple, Inc. All rights reserved. + * Copyright (C) 2009 Google, Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "EditorClientImpl.h" + +#include "Document.h" +#include "EditCommand.h" +#include "Editor.h" +#include "EventHandler.h" +#include "EventNames.h" +#include "Frame.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "KeyboardCodes.h" +#include "KeyboardEvent.h" +#include "PlatformKeyboardEvent.h" +#include "PlatformString.h" +#include "RenderObject.h" + +#include "DOMUtilitiesPrivate.h" +#include "WebEditingAction.h" +#include "WebFrameImpl.h" +#include "WebKit.h" +#include "WebInputElement.h" +#include "WebNode.h" +#include "WebPasswordAutocompleteListener.h" +#include "WebRange.h" +#include "WebTextAffinity.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" + +using namespace WebCore; + +namespace WebKit { + +// Arbitrary depth limit for the undo stack, to keep it from using +// unbounded memory. This is the maximum number of distinct undoable +// actions -- unbroken stretches of typed characters are coalesced +// into a single action. +static const size_t maximumUndoStackDepth = 1000; + +// The size above which we stop triggering autofill for an input text field +// (so to avoid sending long strings through IPC). +static const size_t maximumTextSizeForAutofill = 1000; + +EditorClientImpl::EditorClientImpl(WebViewImpl* webview) + : m_webView(webview) + , m_inRedo(false) + , m_backspaceOrDeletePressed(false) + , m_spellCheckThisFieldStatus(SpellCheckAutomatic) + , m_autofillTimer(this, &EditorClientImpl::doAutofill) +{ +} + +EditorClientImpl::~EditorClientImpl() +{ +} + +void EditorClientImpl::pageDestroyed() +{ + // Our lifetime is bound to the WebViewImpl. +} + +bool EditorClientImpl::shouldShowDeleteInterface(HTMLElement* elem) +{ + // Normally, we don't care to show WebCore's deletion UI, so we only enable + // it if in testing mode and the test specifically requests it by using this + // magic class name. + return WebKit::layoutTestMode() + && elem->getAttribute(HTMLNames::classAttr) == "needsDeletionUI"; +} + +bool EditorClientImpl::smartInsertDeleteEnabled() +{ + if (m_webView->client()) + return m_webView->client()->isSmartInsertDeleteEnabled(); + return true; +} + +bool EditorClientImpl::isSelectTrailingWhitespaceEnabled() +{ + if (m_webView->client()) + return m_webView->client()->isSelectTrailingWhitespaceEnabled(); +#if PLATFORM(WIN_OS) + return true; +#else + return false; +#endif +} + +bool EditorClientImpl::shouldSpellcheckByDefault() +{ + // Spellcheck should be enabled for all editable areas (such as textareas, + // contentEditable regions, and designMode docs), except text inputs. + const Frame* frame = m_webView->focusedWebCoreFrame(); + if (!frame) + return false; + const Editor* editor = frame->editor(); + if (!editor) + return false; + if (editor->spellCheckingEnabledInFocusedNode()) + return true; + const Document* document = frame->document(); + if (!document) + return false; + const Node* node = document->focusedNode(); + // If |node| is null, we default to allowing spellchecking. This is done in + // order to mitigate the issue when the user clicks outside the textbox, as a + // result of which |node| becomes null, resulting in all the spell check + // markers being deleted. Also, the Frame will decide not to do spellchecking + // if the user can't edit - so returning true here will not cause any problems + // to the Frame's behavior. + if (!node) + return true; + const RenderObject* renderer = node->renderer(); + if (!renderer) + return false; + + return !renderer->isTextField(); +} + +bool EditorClientImpl::isContinuousSpellCheckingEnabled() +{ + if (m_spellCheckThisFieldStatus == SpellCheckForcedOff) + return false; + if (m_spellCheckThisFieldStatus == SpellCheckForcedOn) + return true; + return shouldSpellcheckByDefault(); +} + +void EditorClientImpl::toggleContinuousSpellChecking() +{ + if (isContinuousSpellCheckingEnabled()) + m_spellCheckThisFieldStatus = SpellCheckForcedOff; + else + m_spellCheckThisFieldStatus = SpellCheckForcedOn; +} + +bool EditorClientImpl::isGrammarCheckingEnabled() +{ + return false; +} + +void EditorClientImpl::toggleGrammarChecking() +{ + notImplemented(); +} + +int EditorClientImpl::spellCheckerDocumentTag() +{ + ASSERT_NOT_REACHED(); + return 0; +} + +bool EditorClientImpl::isEditable() +{ + return false; +} + +bool EditorClientImpl::shouldBeginEditing(Range* range) +{ + if (m_webView->client()) + return m_webView->client()->shouldBeginEditing(WebRange(range)); + return true; +} + +bool EditorClientImpl::shouldEndEditing(Range* range) +{ + if (m_webView->client()) + return m_webView->client()->shouldEndEditing(WebRange(range)); + return true; +} + +bool EditorClientImpl::shouldInsertNode(Node* node, + Range* range, + EditorInsertAction action) +{ + if (m_webView->client()) { + return m_webView->client()->shouldInsertNode(WebNode(node), + WebRange(range), + static_cast<WebEditingAction>(action)); + } + return true; +} + +bool EditorClientImpl::shouldInsertText(const String& text, + Range* range, + EditorInsertAction action) +{ + if (m_webView->client()) { + return m_webView->client()->shouldInsertText(WebString(text), + WebRange(range), + static_cast<WebEditingAction>(action)); + } + return true; +} + + +bool EditorClientImpl::shouldDeleteRange(Range* range) +{ + if (m_webView->client()) + return m_webView->client()->shouldDeleteRange(WebRange(range)); + return true; +} + +bool EditorClientImpl::shouldChangeSelectedRange(Range* fromRange, + Range* toRange, + EAffinity affinity, + bool stillSelecting) +{ + if (m_webView->client()) { + return m_webView->client()->shouldChangeSelectedRange(WebRange(fromRange), + WebRange(toRange), + static_cast<WebTextAffinity>(affinity), + stillSelecting); + } + return true; +} + +bool EditorClientImpl::shouldApplyStyle(CSSStyleDeclaration* style, + Range* range) +{ + if (m_webView->client()) { + // FIXME: Pass a reference to the CSSStyleDeclaration somehow. + return m_webView->client()->shouldApplyStyle(WebString(), + WebRange(range)); + } + return true; +} + +bool EditorClientImpl::shouldMoveRangeAfterDelete(Range* range, + Range* rangeToBeReplaced) +{ + return true; +} + +void EditorClientImpl::didBeginEditing() +{ + if (m_webView->client()) + m_webView->client()->didBeginEditing(); +} + +void EditorClientImpl::respondToChangedSelection() +{ + if (m_webView->client()) { + Frame* frame = m_webView->focusedWebCoreFrame(); + if (frame) + m_webView->client()->didChangeSelection(!frame->selection()->isRange()); + } +} + +void EditorClientImpl::respondToChangedContents() +{ + if (m_webView->client()) + m_webView->client()->didChangeContents(); +} + +void EditorClientImpl::didEndEditing() +{ + if (m_webView->client()) + m_webView->client()->didEndEditing(); +} + +void EditorClientImpl::didWriteSelectionToPasteboard() +{ +} + +void EditorClientImpl::didSetSelectionTypesForPasteboard() +{ +} + +void EditorClientImpl::registerCommandForUndo(PassRefPtr<EditCommand> command) +{ + if (m_undoStack.size() == maximumUndoStackDepth) + m_undoStack.removeFirst(); // drop oldest item off the far end + if (!m_inRedo) + m_redoStack.clear(); + m_undoStack.append(command); +} + +void EditorClientImpl::registerCommandForRedo(PassRefPtr<EditCommand> command) +{ + m_redoStack.append(command); +} + +void EditorClientImpl::clearUndoRedoOperations() +{ + m_undoStack.clear(); + m_redoStack.clear(); +} + +bool EditorClientImpl::canUndo() const +{ + return !m_undoStack.isEmpty(); +} + +bool EditorClientImpl::canRedo() const +{ + return !m_redoStack.isEmpty(); +} + +void EditorClientImpl::undo() +{ + if (canUndo()) { + EditCommandStack::iterator back = --m_undoStack.end(); + RefPtr<EditCommand> command(*back); + m_undoStack.remove(back); + command->unapply(); + // unapply will call us back to push this command onto the redo stack. + } +} + +void EditorClientImpl::redo() +{ + if (canRedo()) { + EditCommandStack::iterator back = --m_redoStack.end(); + RefPtr<EditCommand> command(*back); + m_redoStack.remove(back); + + ASSERT(!m_inRedo); + m_inRedo = true; + command->reapply(); + // reapply will call us back to push this command onto the undo stack. + m_inRedo = false; + } +} + +// +// The below code was adapted from the WebKit file webview.cpp +// + +static const unsigned CtrlKey = 1 << 0; +static const unsigned AltKey = 1 << 1; +static const unsigned ShiftKey = 1 << 2; +static const unsigned MetaKey = 1 << 3; +#if PLATFORM(DARWIN) +// Aliases for the generic key defintions to make kbd shortcuts definitions more +// readable on OS X. +static const unsigned OptionKey = AltKey; + +// Do not use this constant for anything but cursor movement commands. Keys +// with cmd set have their |isSystemKey| bit set, so chances are the shortcut +// will not be executed. Another, less important, reason is that shortcuts +// defined in the renderer do not blink the menu item that they triggered. See +// http://crbug.com/25856 and the bugs linked from there for details. +static const unsigned CommandKey = MetaKey; +#endif + +// Keys with special meaning. These will be delegated to the editor using +// the execCommand() method +struct KeyDownEntry { + unsigned virtualKey; + unsigned modifiers; + const char* name; +}; + +struct KeyPressEntry { + unsigned charCode; + unsigned modifiers; + const char* name; +}; + +static const KeyDownEntry keyDownEntries[] = { + { VKEY_LEFT, 0, "MoveLeft" }, + { VKEY_LEFT, ShiftKey, "MoveLeftAndModifySelection" }, +#if PLATFORM(DARWIN) + { VKEY_LEFT, OptionKey, "MoveWordLeft" }, + { VKEY_LEFT, OptionKey | ShiftKey, + "MoveWordLeftAndModifySelection" }, +#else + { VKEY_LEFT, CtrlKey, "MoveWordLeft" }, + { VKEY_LEFT, CtrlKey | ShiftKey, + "MoveWordLeftAndModifySelection" }, +#endif + { VKEY_RIGHT, 0, "MoveRight" }, + { VKEY_RIGHT, ShiftKey, "MoveRightAndModifySelection" }, +#if PLATFORM(DARWIN) + { VKEY_RIGHT, OptionKey, "MoveWordRight" }, + { VKEY_RIGHT, OptionKey | ShiftKey, + "MoveWordRightAndModifySelection" }, +#else + { VKEY_RIGHT, CtrlKey, "MoveWordRight" }, + { VKEY_RIGHT, CtrlKey | ShiftKey, + "MoveWordRightAndModifySelection" }, +#endif + { VKEY_UP, 0, "MoveUp" }, + { VKEY_UP, ShiftKey, "MoveUpAndModifySelection" }, + { VKEY_PRIOR, ShiftKey, "MovePageUpAndModifySelection" }, + { VKEY_DOWN, 0, "MoveDown" }, + { VKEY_DOWN, ShiftKey, "MoveDownAndModifySelection" }, + { VKEY_NEXT, ShiftKey, "MovePageDownAndModifySelection" }, + { VKEY_PRIOR, 0, "MovePageUp" }, + { VKEY_NEXT, 0, "MovePageDown" }, + { VKEY_HOME, 0, "MoveToBeginningOfLine" }, + { VKEY_HOME, ShiftKey, + "MoveToBeginningOfLineAndModifySelection" }, +#if PLATFORM(DARWIN) + { VKEY_LEFT, CommandKey, "MoveToBeginningOfLine" }, + { VKEY_LEFT, CommandKey | ShiftKey, + "MoveToBeginningOfLineAndModifySelection" }, +#endif +#if PLATFORM(DARWIN) + { VKEY_UP, CommandKey, "MoveToBeginningOfDocument" }, + { VKEY_UP, CommandKey | ShiftKey, + "MoveToBeginningOfDocumentAndModifySelection" }, +#else + { VKEY_HOME, CtrlKey, "MoveToBeginningOfDocument" }, + { VKEY_HOME, CtrlKey | ShiftKey, + "MoveToBeginningOfDocumentAndModifySelection" }, +#endif + { VKEY_END, 0, "MoveToEndOfLine" }, + { VKEY_END, ShiftKey, "MoveToEndOfLineAndModifySelection" }, +#if PLATFORM(DARWIN) + { VKEY_DOWN, CommandKey, "MoveToEndOfDocument" }, + { VKEY_DOWN, CommandKey | ShiftKey, + "MoveToEndOfDocumentAndModifySelection" }, +#else + { VKEY_END, CtrlKey, "MoveToEndOfDocument" }, + { VKEY_END, CtrlKey | ShiftKey, + "MoveToEndOfDocumentAndModifySelection" }, +#endif +#if PLATFORM(DARWIN) + { VKEY_RIGHT, CommandKey, "MoveToEndOfLine" }, + { VKEY_RIGHT, CommandKey | ShiftKey, + "MoveToEndOfLineAndModifySelection" }, +#endif + { VKEY_BACK, 0, "DeleteBackward" }, + { VKEY_BACK, ShiftKey, "DeleteBackward" }, + { VKEY_DELETE, 0, "DeleteForward" }, +#if PLATFORM(DARWIN) + { VKEY_BACK, OptionKey, "DeleteWordBackward" }, + { VKEY_DELETE, OptionKey, "DeleteWordForward" }, +#else + { VKEY_BACK, CtrlKey, "DeleteWordBackward" }, + { VKEY_DELETE, CtrlKey, "DeleteWordForward" }, +#endif + { 'B', CtrlKey, "ToggleBold" }, + { 'I', CtrlKey, "ToggleItalic" }, + { 'U', CtrlKey, "ToggleUnderline" }, + { VKEY_ESCAPE, 0, "Cancel" }, + { VKEY_OEM_PERIOD, CtrlKey, "Cancel" }, + { VKEY_TAB, 0, "InsertTab" }, + { VKEY_TAB, ShiftKey, "InsertBacktab" }, + { VKEY_RETURN, 0, "InsertNewline" }, + { VKEY_RETURN, CtrlKey, "InsertNewline" }, + { VKEY_RETURN, AltKey, "InsertNewline" }, + { VKEY_RETURN, AltKey | ShiftKey, "InsertNewline" }, + { VKEY_RETURN, ShiftKey, "InsertLineBreak" }, + { VKEY_INSERT, CtrlKey, "Copy" }, + { VKEY_INSERT, ShiftKey, "Paste" }, + { VKEY_DELETE, ShiftKey, "Cut" }, +#if !PLATFORM(DARWIN) + // On OS X, we pipe these back to the browser, so that it can do menu item + // blinking. + { 'C', CtrlKey, "Copy" }, + { 'V', CtrlKey, "Paste" }, + { 'V', CtrlKey | ShiftKey, "PasteAndMatchStyle" }, + { 'X', CtrlKey, "Cut" }, + { 'A', CtrlKey, "SelectAll" }, + { 'Z', CtrlKey, "Undo" }, + { 'Z', CtrlKey | ShiftKey, "Redo" }, + { 'Y', CtrlKey, "Redo" }, +#endif +}; + +static const KeyPressEntry keyPressEntries[] = { + { '\t', 0, "InsertTab" }, + { '\t', ShiftKey, "InsertBacktab" }, + { '\r', 0, "InsertNewline" }, + { '\r', CtrlKey, "InsertNewline" }, + { '\r', ShiftKey, "InsertLineBreak" }, + { '\r', AltKey, "InsertNewline" }, + { '\r', AltKey | ShiftKey, "InsertNewline" }, +}; + +const char* EditorClientImpl::interpretKeyEvent(const KeyboardEvent* evt) +{ + const PlatformKeyboardEvent* keyEvent = evt->keyEvent(); + if (!keyEvent) + return ""; + + static HashMap<int, const char*>* keyDownCommandsMap = 0; + static HashMap<int, const char*>* keyPressCommandsMap = 0; + + if (!keyDownCommandsMap) { + keyDownCommandsMap = new HashMap<int, const char*>; + keyPressCommandsMap = new HashMap<int, const char*>; + + for (unsigned i = 0; i < arraysize(keyDownEntries); i++) { + keyDownCommandsMap->set(keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey, + keyDownEntries[i].name); + } + + for (unsigned i = 0; i < arraysize(keyPressEntries); i++) { + keyPressCommandsMap->set(keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode, + keyPressEntries[i].name); + } + } + + unsigned modifiers = 0; + if (keyEvent->shiftKey()) + modifiers |= ShiftKey; + if (keyEvent->altKey()) + modifiers |= AltKey; + if (keyEvent->ctrlKey()) + modifiers |= CtrlKey; + if (keyEvent->metaKey()) + modifiers |= MetaKey; + + if (keyEvent->type() == PlatformKeyboardEvent::RawKeyDown) { + int mapKey = modifiers << 16 | evt->keyCode(); + return mapKey ? keyDownCommandsMap->get(mapKey) : 0; + } + + int mapKey = modifiers << 16 | evt->charCode(); + return mapKey ? keyPressCommandsMap->get(mapKey) : 0; +} + +bool EditorClientImpl::handleEditingKeyboardEvent(KeyboardEvent* evt) +{ + const PlatformKeyboardEvent* keyEvent = evt->keyEvent(); + // do not treat this as text input if it's a system key event + if (!keyEvent || keyEvent->isSystemKey()) + return false; + + Frame* frame = evt->target()->toNode()->document()->frame(); + if (!frame) + return false; + + String commandName = interpretKeyEvent(evt); + Editor::Command command = frame->editor()->command(commandName); + + if (keyEvent->type() == PlatformKeyboardEvent::RawKeyDown) { + // WebKit doesn't have enough information about mode to decide how + // commands that just insert text if executed via Editor should be treated, + // so we leave it upon WebCore to either handle them immediately + // (e.g. Tab that changes focus) or let a keypress event be generated + // (e.g. Tab that inserts a Tab character, or Enter). + if (command.isTextInsertion() || commandName.isEmpty()) + return false; + if (command.execute(evt)) { + if (m_webView->client()) + m_webView->client()->didExecuteCommand(WebString(commandName)); + return true; + } + return false; + } + + if (command.execute(evt)) { + if (m_webView->client()) + m_webView->client()->didExecuteCommand(WebString(commandName)); + return true; + } + + // Here we need to filter key events. + // On Gtk/Linux, it emits key events with ASCII text and ctrl on for ctrl-<x>. + // In Webkit, EditorClient::handleKeyboardEvent in + // WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp drop such events. + // On Mac, it emits key events with ASCII text and meta on for Command-<x>. + // These key events should not emit text insert event. + // Alt key would be used to insert alternative character, so we should let + // through. Also note that Ctrl-Alt combination equals to AltGr key which is + // also used to insert alternative character. + // http://code.google.com/p/chromium/issues/detail?id=10846 + // Windows sets both alt and meta are on when "Alt" key pressed. + // http://code.google.com/p/chromium/issues/detail?id=2215 + // Also, we should not rely on an assumption that keyboards don't + // send ASCII characters when pressing a control key on Windows, + // which may be configured to do it so by user. + // See also http://en.wikipedia.org/wiki/Keyboard_Layout + // FIXME(ukai): investigate more detail for various keyboard layout. + if (evt->keyEvent()->text().length() == 1) { + UChar ch = evt->keyEvent()->text()[0U]; + + // Don't insert null or control characters as they can result in + // unexpected behaviour + if (ch < ' ') + return false; +#if !PLATFORM(WIN_OS) + // Don't insert ASCII character if ctrl w/o alt or meta is on. + // On Mac, we should ignore events when meta is on (Command-<x>). + if (ch < 0x80) { + if (evt->keyEvent()->ctrlKey() && !evt->keyEvent()->altKey()) + return false; +#if PLATFORM(DARWIN) + if (evt->keyEvent()->metaKey()) + return false; +#endif + } +#endif + } + + if (!frame->editor()->canEdit()) + return false; + + return frame->editor()->insertText(evt->keyEvent()->text(), evt); +} + +void EditorClientImpl::handleKeyboardEvent(KeyboardEvent* evt) +{ + if (evt->keyCode() == VKEY_DOWN + || evt->keyCode() == VKEY_UP) { + ASSERT(evt->target()->toNode()); + showFormAutofillForNode(evt->target()->toNode()); + } + + // Give the embedder a chance to handle the keyboard event. + if ((m_webView->client() + && m_webView->client()->handleCurrentKeyboardEvent()) + || handleEditingKeyboardEvent(evt)) + evt->setDefaultHandled(); +} + +void EditorClientImpl::handleInputMethodKeydown(KeyboardEvent* keyEvent) +{ + // We handle IME within chrome. +} + +void EditorClientImpl::textFieldDidBeginEditing(Element*) +{ +} + +void EditorClientImpl::textFieldDidEndEditing(Element* element) +{ + // Notification that focus was lost. Be careful with this, it's also sent + // when the page is being closed. + + // Cancel any pending DoAutofill call. + m_autofillArgs.clear(); + m_autofillTimer.stop(); + + // Hide any showing popup. + m_webView->hideAutoCompletePopup(); + + if (!m_webView->client()) + return; // The page is getting closed, don't fill the password. + + // Notify any password-listener of the focus change. + HTMLInputElement* inputElement = WebKit::toHTMLInputElement(element); + if (!inputElement) + return; + + WebFrameImpl* webframe = WebFrameImpl::fromFrame(inputElement->document()->frame()); + if (!webframe) + return; + + WebPasswordAutocompleteListener* listener = webframe->getPasswordListener(inputElement); + if (!listener) + return; + + listener->didBlurInputElement(inputElement->value()); +} + +void EditorClientImpl::textDidChangeInTextField(Element* element) +{ + ASSERT(element->hasLocalName(HTMLNames::inputTag)); + // Note that we only show the autofill popup in this case if the caret is at + // the end. This matches FireFox and Safari but not IE. + autofill(static_cast<HTMLInputElement*>(element), false, false, + true); +} + +bool EditorClientImpl::showFormAutofillForNode(Node* node) +{ + HTMLInputElement* inputElement = WebKit::toHTMLInputElement(node); + if (inputElement) + return autofill(inputElement, true, true, false); + return false; +} + +bool EditorClientImpl::autofill(HTMLInputElement* inputElement, + bool autofillFormOnly, + bool autofillOnEmptyValue, + bool requireCaretAtEnd) +{ + // Cancel any pending DoAutofill call. + m_autofillArgs.clear(); + m_autofillTimer.stop(); + + // Let's try to trigger autofill for that field, if applicable. + if (!inputElement->isEnabledFormControl() || !inputElement->isTextField() + || inputElement->isPasswordField() + || !inputElement->autoComplete()) + return false; + + WebString name = WebInputElement(inputElement).nameForAutofill(); + if (name.isEmpty()) // If the field has no name, then we won't have values. + return false; + + // Don't attempt to autofill with values that are too large. + if (inputElement->value().length() > maximumTextSizeForAutofill) + return false; + + m_autofillArgs = new AutofillArgs(); + m_autofillArgs->inputElement = inputElement; + m_autofillArgs->autofillFormOnly = autofillFormOnly; + m_autofillArgs->autofillOnEmptyValue = autofillOnEmptyValue; + m_autofillArgs->requireCaretAtEnd = requireCaretAtEnd; + m_autofillArgs->backspaceOrDeletePressed = m_backspaceOrDeletePressed; + + if (!requireCaretAtEnd) + doAutofill(0); + else { + // We post a task for doing the autofill as the caret position is not set + // properly at this point (http://bugs.webkit.org/show_bug.cgi?id=16976) + // and we need it to determine whether or not to trigger autofill. + m_autofillTimer.startOneShot(0.0); + } + return true; +} + +void EditorClientImpl::doAutofill(Timer<EditorClientImpl>* timer) +{ + OwnPtr<AutofillArgs> args(m_autofillArgs.release()); + HTMLInputElement* inputElement = args->inputElement.get(); + + const String& value = inputElement->value(); + + // Enforce autofill_on_empty_value and caret_at_end. + + bool isCaretAtEnd = true; + if (args->requireCaretAtEnd) + isCaretAtEnd = inputElement->selectionStart() == inputElement->selectionEnd() + && inputElement->selectionEnd() == static_cast<int>(value.length()); + + if ((!args->autofillOnEmptyValue && value.isEmpty()) || !isCaretAtEnd) { + m_webView->hideAutoCompletePopup(); + return; + } + + // First let's see if there is a password listener for that element. + // We won't trigger form autofill in that case, as having both behavior on + // a node would be confusing. + WebFrameImpl* webframe = WebFrameImpl::fromFrame(inputElement->document()->frame()); + if (!webframe) + return; + WebPasswordAutocompleteListener* listener = webframe->getPasswordListener(inputElement); + if (listener) { + if (args->autofillFormOnly) + return; + + listener->performInlineAutocomplete(value, + args->backspaceOrDeletePressed, + true); + return; + } + + // Then trigger form autofill. + WebString name = WebInputElement(inputElement).nameForAutofill(); + ASSERT(static_cast<int>(name.length()) > 0); + + if (m_webView->client()) + m_webView->client()->queryAutofillSuggestions(WebNode(inputElement), + name, WebString(value)); +} + +void EditorClientImpl::cancelPendingAutofill() +{ + m_autofillArgs.clear(); + m_autofillTimer.stop(); +} + +void EditorClientImpl::onAutofillSuggestionAccepted(HTMLInputElement* textField) +{ + WebFrameImpl* webframe = WebFrameImpl::fromFrame(textField->document()->frame()); + if (!webframe) + return; + + WebPasswordAutocompleteListener* listener = webframe->getPasswordListener(textField); + // Password listeners need to autocomplete other fields that depend on the + // input element with autofill suggestions. + if (listener) + listener->performInlineAutocomplete(textField->value(), false, false); +} + +bool EditorClientImpl::doTextFieldCommandFromEvent(Element* element, + KeyboardEvent* event) +{ + // Remember if backspace was pressed for the autofill. It is not clear how to + // find if backspace was pressed from textFieldDidBeginEditing and + // textDidChangeInTextField as when these methods are called the value of the + // input element already contains the type character. + m_backspaceOrDeletePressed = event->keyCode() == VKEY_BACK || event->keyCode() == VKEY_DELETE; + + // The Mac code appears to use this method as a hook to implement special + // keyboard commands specific to Safari's auto-fill implementation. We + // just return false to allow the default action. + return false; +} + +void EditorClientImpl::textWillBeDeletedInTextField(Element*) +{ +} + +void EditorClientImpl::textDidChangeInTextArea(Element*) +{ +} + +void EditorClientImpl::ignoreWordInSpellDocument(const String&) +{ + notImplemented(); +} + +void EditorClientImpl::learnWord(const String&) +{ + notImplemented(); +} + +void EditorClientImpl::checkSpellingOfString(const UChar* text, int length, + int* misspellingLocation, + int* misspellingLength) +{ + // SpellCheckWord will write (0, 0) into the output vars, which is what our + // caller expects if the word is spelled correctly. + int spellLocation = -1; + int spellLength = 0; + + // Check to see if the provided text is spelled correctly. + if (isContinuousSpellCheckingEnabled() && m_webView->client()) + m_webView->client()->spellCheck(WebString(text, length), spellLocation, spellLength); + else { + spellLocation = 0; + spellLength = 0; + } + + // Note: the Mac code checks if the pointers are null before writing to them, + // so we do too. + if (misspellingLocation) + *misspellingLocation = spellLocation; + if (misspellingLength) + *misspellingLength = spellLength; +} + +String EditorClientImpl::getAutoCorrectSuggestionForMisspelledWord(const String& misspelledWord) +{ + if (!(isContinuousSpellCheckingEnabled() && m_webView->client())) + return String(); + + // Do not autocorrect words with capital letters in it except the + // first letter. This will remove cases changing "IMB" to "IBM". + for (size_t i = 1; i < misspelledWord.length(); i++) { + if (u_isupper(static_cast<UChar32>(misspelledWord[i]))) + return String(); + } + + return m_webView->client()->autoCorrectWord(WebString(misspelledWord)); +} + +void EditorClientImpl::checkGrammarOfString(const UChar*, int length, + WTF::Vector<GrammarDetail>&, + int* badGrammarLocation, + int* badGrammarLength) +{ + notImplemented(); + if (badGrammarLocation) + *badGrammarLocation = 0; + if (badGrammarLength) + *badGrammarLength = 0; +} + +void EditorClientImpl::updateSpellingUIWithGrammarString(const String&, + const GrammarDetail& detail) +{ + notImplemented(); +} + +void EditorClientImpl::updateSpellingUIWithMisspelledWord(const String& misspelledWord) +{ + if (m_webView->client()) + m_webView->client()->updateSpellingUIWithMisspelledWord(WebString(misspelledWord)); +} + +void EditorClientImpl::showSpellingUI(bool show) +{ + if (m_webView->client()) + m_webView->client()->showSpellingUI(show); +} + +bool EditorClientImpl::spellingUIIsShowing() +{ + if (m_webView->client()) + return m_webView->client()->isShowingSpellingUI(); + return false; +} + +void EditorClientImpl::getGuessesForWord(const String&, + WTF::Vector<String>& guesses) +{ + notImplemented(); +} + +void EditorClientImpl::setInputMethodState(bool enabled) +{ + if (m_webView->client()) + m_webView->client()->setInputMethodEnabled(enabled); +} + +} // namesace WebKit diff --git a/WebKit/chromium/src/EditorClientImpl.h b/WebKit/chromium/src/EditorClientImpl.h new file mode 100644 index 0000000..fd08b4d --- /dev/null +++ b/WebKit/chromium/src/EditorClientImpl.h @@ -0,0 +1,194 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef EditorClientImpl_h +#define EditorClientImpl_h + +#include "EditorClient.h" +#include "Timer.h" +#include <wtf/Deque.h> + +namespace WebCore { +class HTMLInputElement; +} + +namespace WebKit { +class WebViewImpl; + +class EditorClientImpl : public WebCore::EditorClient { +public: + EditorClientImpl(WebViewImpl* webView); + + virtual ~EditorClientImpl(); + virtual void pageDestroyed(); + + virtual bool shouldShowDeleteInterface(WebCore::HTMLElement*); + virtual bool smartInsertDeleteEnabled(); + virtual bool isSelectTrailingWhitespaceEnabled(); + virtual bool isContinuousSpellCheckingEnabled(); + virtual void toggleContinuousSpellChecking(); + virtual bool isGrammarCheckingEnabled(); + virtual void toggleGrammarChecking(); + virtual int spellCheckerDocumentTag(); + virtual bool isEditable(); + virtual bool shouldBeginEditing(WebCore::Range*); + virtual bool shouldEndEditing(WebCore::Range*); + virtual bool shouldInsertNode(WebCore::Node*, WebCore::Range*, WebCore::EditorInsertAction); + virtual bool shouldInsertText(const WebCore::String&, WebCore::Range*, WebCore::EditorInsertAction); + virtual bool shouldDeleteRange(WebCore::Range*); + virtual bool shouldChangeSelectedRange(WebCore::Range* fromRange, + WebCore::Range* toRange, + WebCore::EAffinity, + bool stillSelecting); + virtual bool shouldApplyStyle(WebCore::CSSStyleDeclaration*, WebCore::Range*); + virtual bool shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range*); + virtual void didBeginEditing(); + virtual void respondToChangedContents(); + virtual void respondToChangedSelection(); + virtual void didEndEditing(); + virtual void didWriteSelectionToPasteboard(); + virtual void didSetSelectionTypesForPasteboard(); + virtual void registerCommandForUndo(PassRefPtr<WebCore::EditCommand>); + virtual void registerCommandForRedo(PassRefPtr<WebCore::EditCommand>); + virtual void clearUndoRedoOperations(); + virtual bool canUndo() const; + virtual bool canRedo() const; + virtual void undo(); + virtual void redo(); + virtual const char* interpretKeyEvent(const WebCore::KeyboardEvent*); + virtual bool handleEditingKeyboardEvent(WebCore::KeyboardEvent*); + virtual void handleKeyboardEvent(WebCore::KeyboardEvent*); + virtual void handleInputMethodKeydown(WebCore::KeyboardEvent*); + virtual void textFieldDidBeginEditing(WebCore::Element*); + virtual void textFieldDidEndEditing(WebCore::Element*); + virtual void textDidChangeInTextField(WebCore::Element*); + virtual bool doTextFieldCommandFromEvent(WebCore::Element*, WebCore::KeyboardEvent*); + virtual void textWillBeDeletedInTextField(WebCore::Element*); + virtual void textDidChangeInTextArea(WebCore::Element*); + virtual void ignoreWordInSpellDocument(const WebCore::String&); + virtual void learnWord(const WebCore::String&); + virtual void checkSpellingOfString(const UChar*, int length, + int* misspellingLocation, + int* misspellingLength); + virtual void checkGrammarOfString(const UChar*, int length, + WTF::Vector<WebCore::GrammarDetail>&, + int* badGrammarLocation, + int* badGrammarLength); + virtual WebCore::String getAutoCorrectSuggestionForMisspelledWord(const WebCore::String&); + virtual void updateSpellingUIWithGrammarString(const WebCore::String&, const WebCore::GrammarDetail&); + virtual void updateSpellingUIWithMisspelledWord(const WebCore::String&); + virtual void showSpellingUI(bool show); + virtual bool spellingUIIsShowing(); + virtual void getGuessesForWord(const WebCore::String& word, + WTF::Vector<WebCore::String>& guesses); + virtual void setInputMethodState(bool enabled); + + // Shows the form autofill popup for |node| if it is an HTMLInputElement and + // it is empty. This is called when you press the up or down arrow in a + // text-field or when clicking an already focused text-field. + // Returns true if the autofill popup has been scheduled to be shown, false + // otherwise. + virtual bool showFormAutofillForNode(WebCore::Node*); + + // Notification that the text changed due to acceptance of a suggestion + // provided by an autofill popup. Having a separate callback in this case + // is a simple way to break the cycle that would otherwise occur if + // textDidChangeInTextField was called. + virtual void onAutofillSuggestionAccepted(WebCore::HTMLInputElement*); + +private: + void modifySelection(WebCore::Frame*, WebCore::KeyboardEvent*); + + // Triggers autofill for an input element if applicable. This can be form + // autofill (via a popup-menu) or password autofill depending on the + // input element. If |formAutofillOnly| is true, password autofill is not + // triggered. + // |autofillOnEmptyValue| indicates whether the autofill should be shown + // when the text-field is empty. + // If |requiresCaretAtEnd| is true, the autofill popup is only shown if the + // caret is located at the end of the entered text. + // Returns true if the autofill popup has been scheduled to be shown, false + // otherwise. + bool autofill(WebCore::HTMLInputElement*, + bool formAutofillOnly, bool autofillOnEmptyValue, + bool requiresCaretAtEnd); + + // Called to process the autofill described by m_autofillArgs. + // This method is invoked asynchronously if the caret position is not + // reflecting the last text change yet, and we need it to decide whether or + // not to show the autofill popup. + void doAutofill(WebCore::Timer<EditorClientImpl>*); + + void cancelPendingAutofill(); + + // Returns whether or not the focused control needs spell-checking. + // Currently, this function just retrieves the focused node and determines + // whether or not it is a <textarea> element or an element whose + // contenteditable attribute is true. + // FIXME: Bug 740540: This code just implements the default behavior + // proposed in this issue. We should also retrieve "spellcheck" attributes + // for text fields and create a flag to over-write the default behavior. + bool shouldSpellcheckByDefault(); + + WebViewImpl* m_webView; + bool m_inRedo; + + typedef Deque<RefPtr<WebCore::EditCommand> > EditCommandStack; + EditCommandStack m_undoStack; + EditCommandStack m_redoStack; + + // Whether the last entered key was a backspace. + bool m_backspaceOrDeletePressed; + + // This flag is set to false if spell check for this editor is manually + // turned off. The default setting is SpellCheckAutomatic. + enum { + SpellCheckAutomatic, + SpellCheckForcedOn, + SpellCheckForcedOff + }; + int m_spellCheckThisFieldStatus; + + // Used to delay autofill processing. + WebCore::Timer<EditorClientImpl> m_autofillTimer; + + struct AutofillArgs { + RefPtr<WebCore::HTMLInputElement> inputElement; + bool autofillFormOnly; + bool autofillOnEmptyValue; + bool requireCaretAtEnd; + bool backspaceOrDeletePressed; + }; + OwnPtr<AutofillArgs> m_autofillArgs; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/FrameLoaderClientImpl.cpp b/WebKit/chromium/src/FrameLoaderClientImpl.cpp new file mode 100644 index 0000000..3ca8e8d --- /dev/null +++ b/WebKit/chromium/src/FrameLoaderClientImpl.cpp @@ -0,0 +1,1469 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "FrameLoaderClientImpl.h" + +#include "Chrome.h" +#include "CString.h" +#include "Document.h" +#include "DocumentLoader.h" +#include "FormState.h" +#include "FrameLoader.h" +#include "FrameLoadRequest.h" +#include "HitTestResult.h" +#include "HTMLAppletElement.h" +#include "HTMLFormElement.h" // needed by FormState.h +#include "HTMLNames.h" +#include "MIMETypeRegistry.h" +#include "MouseEvent.h" +#include "Page.h" +#include "PlatformString.h" +#include "PluginData.h" +#include "PluginDataChromium.h" +#include "StringExtras.h" +#include "WebDataSourceImpl.h" +#include "WebDevToolsAgentPrivate.h" +#include "WebFormElement.h" +#include "WebFrameClient.h" +#include "WebFrameImpl.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebMimeRegistry.h" +#include "WebNode.h" +#include "WebPlugin.h" +#include "WebPluginContainerImpl.h" +#include "WebPluginLoadObserver.h" +#include "WebPluginParams.h" +#include "WebSecurityOrigin.h" +#include "WebURL.h" +#include "WebURLError.h" +#include "WebVector.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" +#include "WindowFeatures.h" +#include "WrappedResourceRequest.h" +#include "WrappedResourceResponse.h" + +using namespace WebCore; + +namespace WebKit { + +// Domain for internal error codes. +static const char internalErrorDomain[] = "WebKit"; + +// An internal error code. Used to note a policy change error resulting from +// dispatchDecidePolicyForMIMEType not passing the PolicyUse option. +enum { + PolicyChangeError = -10000, +}; + +FrameLoaderClientImpl::FrameLoaderClientImpl(WebFrameImpl* frame) + : m_webFrame(frame) + , m_hasRepresentation(false) + , m_sentInitialResponseToPlugin(false) + , m_nextNavigationPolicy(WebNavigationPolicyIgnore) +{ +} + +FrameLoaderClientImpl::~FrameLoaderClientImpl() +{ +} + +void FrameLoaderClientImpl::frameLoaderDestroyed() +{ + // When the WebFrame was created, it had an extra reference given to it on + // behalf of the Frame. Since the WebFrame owns us, this extra ref also + // serves to keep us alive until the FrameLoader is done with us. The + // FrameLoader calls this method when it's going away. Therefore, we balance + // out that extra reference, which may cause 'this' to be deleted. + m_webFrame->closing(); + m_webFrame->deref(); +} + +void FrameLoaderClientImpl::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*) +{ + if (m_webFrame->client()) + m_webFrame->client()->didClearWindowObject(m_webFrame); + + WebViewImpl* webview = m_webFrame->viewImpl(); + if (webview->devToolsAgentPrivate()) + webview->devToolsAgentPrivate()->didClearWindowObject(m_webFrame); +} + +void FrameLoaderClientImpl::documentElementAvailable() +{ + if (m_webFrame->client()) + m_webFrame->client()->didCreateDocumentElement(m_webFrame); +} + +void FrameLoaderClientImpl::didCreateScriptContextForFrame() +{ + if (m_webFrame->client()) + m_webFrame->client()->didCreateScriptContext(m_webFrame); +} + +void FrameLoaderClientImpl::didDestroyScriptContextForFrame() +{ + if (m_webFrame->client()) + m_webFrame->client()->didDestroyScriptContext(m_webFrame); +} + +void FrameLoaderClientImpl::didCreateIsolatedScriptContext() +{ + if (m_webFrame->client()) + m_webFrame->client()->didCreateIsolatedScriptContext(m_webFrame); +} + +void FrameLoaderClientImpl::didPerformFirstNavigation() const +{ +} + +void FrameLoaderClientImpl::registerForIconNotification(bool) +{ +} + +void FrameLoaderClientImpl::didChangeScrollOffset() +{ + if (m_webFrame->client()) + m_webFrame->client()->didChangeScrollOffset(m_webFrame); +} + +bool FrameLoaderClientImpl::allowJavaScript(bool enabledPerSettings) +{ + if (m_webFrame->client()) + return m_webFrame->client()->allowScript(m_webFrame, enabledPerSettings); + + return enabledPerSettings; +} + +bool FrameLoaderClientImpl::hasWebView() const +{ + return m_webFrame->viewImpl(); +} + +bool FrameLoaderClientImpl::hasFrameView() const +{ + // The Mac port has this notion of a WebFrameView, which seems to be + // some wrapper around an NSView. Since our equivalent is HWND, I guess + // we have a "frameview" whenever we have the toplevel HWND. + return m_webFrame->viewImpl(); +} + +void FrameLoaderClientImpl::makeDocumentView() +{ + m_webFrame->createFrameView(); +} + +void FrameLoaderClientImpl::makeRepresentation(DocumentLoader*) +{ + m_hasRepresentation = true; +} + +void FrameLoaderClientImpl::forceLayout() +{ + // FIXME +} + +void FrameLoaderClientImpl::forceLayoutForNonHTML() +{ + // FIXME +} + +void FrameLoaderClientImpl::setCopiesOnScroll() +{ + // FIXME +} + +void FrameLoaderClientImpl::detachedFromParent2() +{ + // Nothing to do here. +} + +void FrameLoaderClientImpl::detachedFromParent3() +{ + // Close down the proxy. The purpose of this change is to make the + // call to ScriptController::clearWindowShell a no-op when called from + // Frame::pageDestroyed. Without this change, this call to clearWindowShell + // will cause a crash. If you remove/modify this, just ensure that you can + // go to a page and then navigate to a new page without getting any asserts + // or crashes. + m_webFrame->frame()->script()->proxy()->clearForClose(); + + // Stop communicating with the WebFrameClient at this point since we are no + // longer associated with the Page. + m_webFrame->dropClient(); +} + +// This function is responsible for associating the |identifier| with a given +// subresource load. The following functions that accept an |identifier| are +// called for each subresource, so they should not be dispatched to the +// WebFrame. +void FrameLoaderClientImpl::assignIdentifierToInitialRequest( + unsigned long identifier, DocumentLoader* loader, + const ResourceRequest& request) +{ + if (m_webFrame->client()) { + WrappedResourceRequest webreq(request); + m_webFrame->client()->assignIdentifierToRequest( + m_webFrame, identifier, webreq); + } +} + +// If the request being loaded by |loader| is a frame, update the ResourceType. +// A subresource in this context is anything other than a frame -- +// this includes images and xmlhttp requests. It is important to note that a +// subresource is NOT limited to stuff loaded through the frame's subresource +// loader. Synchronous xmlhttp requests for example, do not go through the +// subresource loader, but we still label them as TargetIsSubResource. +// +// The important edge cases to consider when modifying this function are +// how synchronous resource loads are treated during load/unload threshold. +static void setTargetTypeFromLoader(ResourceRequest& request, DocumentLoader* loader) +{ + if (loader == loader->frameLoader()->provisionalDocumentLoader()) { + ResourceRequest::TargetType type; + if (loader->frameLoader()->isLoadingMainFrame()) + type = ResourceRequest::TargetIsMainFrame; + else + type = ResourceRequest::TargetIsSubframe; + request.setTargetType(type); + } +} + +void FrameLoaderClientImpl::dispatchWillSendRequest( + DocumentLoader* loader, unsigned long identifier, ResourceRequest& request, + const ResourceResponse& redirectResponse) +{ + if (loader) { + // We want to distinguish between a request for a document to be loaded into + // the main frame, a sub-frame, or the sub-objects in that document. + setTargetTypeFromLoader(request, loader); + + // Avoid repeating a form submission when navigating back or forward. + if (loader == loader->frameLoader()->provisionalDocumentLoader() + && request.httpMethod() == "POST" + && isBackForwardLoadType(loader->frameLoader()->loadType())) + request.setCachePolicy(ReturnCacheDataDontLoad); + } + + // FrameLoader::loadEmptyDocumentSynchronously() creates an empty document + // with no URL. We don't like that, so we'll rename it to about:blank. + if (request.url().isEmpty()) + request.setURL(KURL(ParsedURLString, "about:blank")); + if (request.firstPartyForCookies().isEmpty()) + request.setFirstPartyForCookies(KURL(ParsedURLString, "about:blank")); + + // Give the WebFrameClient a crack at the request. + if (m_webFrame->client()) { + WrappedResourceRequest webreq(request); + WrappedResourceResponse webresp(redirectResponse); + m_webFrame->client()->willSendRequest( + m_webFrame, identifier, webreq, webresp); + } +} + +bool FrameLoaderClientImpl::shouldUseCredentialStorage( + DocumentLoader*, unsigned long identifier) +{ + // FIXME + // Intended to pass through to a method on the resource load delegate. + // If implemented, that method controls whether the browser should ask the + // networking layer for a stored default credential for the page (say from + // the Mac OS keychain). If the method returns false, the user should be + // presented with an authentication challenge whether or not the networking + // layer has a credential stored. + // This returns true for backward compatibility: the ability to override the + // system credential store is new. (Actually, not yet fully implemented in + // WebKit, as of this writing.) + return true; +} + +void FrameLoaderClientImpl::dispatchDidReceiveAuthenticationChallenge( + DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) +{ + // FIXME +} + +void FrameLoaderClientImpl::dispatchDidCancelAuthenticationChallenge( + DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) +{ + // FIXME +} + +void FrameLoaderClientImpl::dispatchDidReceiveResponse(DocumentLoader* loader, + unsigned long identifier, + const ResourceResponse& response) +{ + if (m_webFrame->client()) { + WrappedResourceResponse webresp(response); + m_webFrame->client()->didReceiveResponse(m_webFrame, identifier, webresp); + } +} + +void FrameLoaderClientImpl::dispatchDidReceiveContentLength( + DocumentLoader* loader, + unsigned long identifier, + int lengthReceived) +{ +} + +// Called when a particular resource load completes +void FrameLoaderClientImpl::dispatchDidFinishLoading(DocumentLoader* loader, + unsigned long identifier) +{ + if (m_webFrame->client()) + m_webFrame->client()->didFinishResourceLoad(m_webFrame, identifier); +} + +void FrameLoaderClientImpl::dispatchDidFailLoading(DocumentLoader* loader, + unsigned long identifier, + const ResourceError& error) +{ + if (m_webFrame->client()) + m_webFrame->client()->didFailResourceLoad(m_webFrame, identifier, error); +} + +void FrameLoaderClientImpl::dispatchDidFinishDocumentLoad() +{ + // A frame may be reused. This call ensures we don't hold on to our password + // listeners and their associated HTMLInputElements. + m_webFrame->clearPasswordListeners(); + + if (m_webFrame->client()) + m_webFrame->client()->didFinishDocumentLoad(m_webFrame); +} + +bool FrameLoaderClientImpl::dispatchDidLoadResourceFromMemoryCache( + DocumentLoader* loader, + const ResourceRequest& request, + const ResourceResponse& response, + int length) +{ + if (m_webFrame->client()) { + WrappedResourceRequest webreq(request); + WrappedResourceResponse webresp(response); + m_webFrame->client()->didLoadResourceFromMemoryCache( + m_webFrame, webreq, webresp); + } + return false; // Do not suppress remaining notifications +} + +void FrameLoaderClientImpl::dispatchDidLoadResourceByXMLHttpRequest( + unsigned long identifier, + const ScriptString& source) +{ +} + +void FrameLoaderClientImpl::dispatchDidHandleOnloadEvents() +{ + if (m_webFrame->client()) + m_webFrame->client()->didHandleOnloadEvents(m_webFrame); +} + +// Redirect Tracking +// ================= +// We want to keep track of the chain of redirects that occur during page +// loading. There are two types of redirects, server redirects which are HTTP +// response codes, and client redirects which are document.location= and meta +// refreshes. +// +// This outlines the callbacks that we get in different redirect situations, +// and how each call modifies the redirect chain. +// +// Normal page load +// ---------------- +// dispatchDidStartProvisionalLoad() -> adds URL to the redirect list +// dispatchDidCommitLoad() -> DISPATCHES & clears list +// +// Server redirect (success) +// ------------------------- +// dispatchDidStartProvisionalLoad() -> adds source URL +// dispatchDidReceiveServerRedirectForProvisionalLoad() -> adds dest URL +// dispatchDidCommitLoad() -> DISPATCHES +// +// Client redirect (success) +// ------------------------- +// (on page) +// dispatchWillPerformClientRedirect() -> saves expected redirect +// dispatchDidStartProvisionalLoad() -> appends redirect source (since +// it matches the expected redirect) +// and the current page as the dest) +// dispatchDidCancelClientRedirect() -> clears expected redirect +// dispatchDidCommitLoad() -> DISPATCHES +// +// Client redirect (cancelled) +// (e.g meta-refresh trumped by manual doc.location change, or just cancelled +// because a link was clicked that requires the meta refresh to be rescheduled +// (the SOURCE URL may have changed). +// --------------------------- +// dispatchDidCancelClientRedirect() -> clears expected redirect +// dispatchDidStartProvisionalLoad() -> adds only URL to redirect list +// dispatchDidCommitLoad() -> DISPATCHES & clears list +// rescheduled ? dispatchWillPerformClientRedirect() -> saves expected redirect +// : nothing + +// Client redirect (failure) +// ------------------------- +// (on page) +// dispatchWillPerformClientRedirect() -> saves expected redirect +// dispatchDidStartProvisionalLoad() -> appends redirect source (since +// it matches the expected redirect) +// and the current page as the dest) +// dispatchDidCancelClientRedirect() +// dispatchDidFailProvisionalLoad() +// +// Load 1 -> Server redirect to 2 -> client redirect to 3 -> server redirect to 4 +// ------------------------------------------------------------------------------ +// dispatchDidStartProvisionalLoad() -> adds source URL 1 +// dispatchDidReceiveServerRedirectForProvisionalLoad() -> adds dest URL 2 +// dispatchDidCommitLoad() -> DISPATCHES 1+2 +// -- begin client redirect and NEW DATA SOURCE +// dispatchWillPerformClientRedirect() -> saves expected redirect +// dispatchDidStartProvisionalLoad() -> appends URL 2 and URL 3 +// dispatchDidReceiveServerRedirectForProvisionalLoad() -> appends destination URL 4 +// dispatchDidCancelClientRedirect() -> clears expected redirect +// dispatchDidCommitLoad() -> DISPATCHES +// +// Interesting case with multiple location changes involving anchors. +// Load page 1 containing future client-redirect (back to 1, e.g meta refresh) > Click +// on a link back to the same page (i.e an anchor href) > +// client-redirect finally fires (with new source, set to 1#anchor) +// ----------------------------------------------------------------------------- +// dispatchWillPerformClientRedirect(non-zero 'interval' param) -> saves expected redirect +// -- click on anchor href +// dispatchDidCancelClientRedirect() -> clears expected redirect +// dispatchDidStartProvisionalLoad() -> adds 1#anchor source +// dispatchDidCommitLoad() -> DISPATCHES 1#anchor +// dispatchWillPerformClientRedirect() -> saves exp. source (1#anchor) +// -- redirect timer fires +// dispatchDidStartProvisionalLoad() -> appends 1#anchor (src) and 1 (dest) +// dispatchDidCancelClientRedirect() -> clears expected redirect +// dispatchDidCommitLoad() -> DISPATCHES 1#anchor + 1 +// +void FrameLoaderClientImpl::dispatchDidReceiveServerRedirectForProvisionalLoad() +{ + WebDataSourceImpl* ds = m_webFrame->provisionalDataSourceImpl(); + if (!ds) { + // Got a server redirect when there is no provisional DS! + ASSERT_NOT_REACHED(); + return; + } + + // The server redirect may have been blocked. + if (ds->request().isNull()) + return; + + // A provisional load should have started already, which should have put an + // entry in our redirect chain. + ASSERT(ds->hasRedirectChain()); + + // The URL of the destination is on the provisional data source. We also need + // to update the redirect chain to account for this addition (we do this + // before the callback so the callback can look at the redirect chain to see + // what happened). + ds->appendRedirect(ds->request().url()); + + if (m_webFrame->client()) + m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(m_webFrame); +} + +// Called on both success and failure of a client redirect. +void FrameLoaderClientImpl::dispatchDidCancelClientRedirect() +{ + // No longer expecting a client redirect. + if (m_webFrame->client()) { + m_expectedClientRedirectSrc = KURL(); + m_expectedClientRedirectDest = KURL(); + m_webFrame->client()->didCancelClientRedirect(m_webFrame); + } + + // No need to clear the redirect chain, since that data source has already + // been deleted by the time this function is called. +} + +void FrameLoaderClientImpl::dispatchWillPerformClientRedirect( + const KURL& url, + double interval, + double fireDate) +{ + // Tells dispatchDidStartProvisionalLoad that if it sees this item it is a + // redirect and the source item should be added as the start of the chain. + m_expectedClientRedirectSrc = m_webFrame->url(); + m_expectedClientRedirectDest = url; + + // FIXME: bug 1135512. Webkit does not properly notify us of cancelling + // http > file client redirects. Since the FrameLoader's policy is to never + // carry out such a navigation anyway, the best thing we can do for now to + // not get confused is ignore this notification. + if (m_expectedClientRedirectDest.isLocalFile() + && m_expectedClientRedirectSrc.protocolInHTTPFamily()) { + m_expectedClientRedirectSrc = KURL(); + m_expectedClientRedirectDest = KURL(); + return; + } + + if (m_webFrame->client()) { + m_webFrame->client()->willPerformClientRedirect( + m_webFrame, + m_expectedClientRedirectSrc, + m_expectedClientRedirectDest, + static_cast<unsigned int>(interval), + static_cast<unsigned int>(fireDate)); + } +} + +void FrameLoaderClientImpl::dispatchDidChangeLocationWithinPage() +{ + // Anchor fragment navigations are not normal loads, so we need to synthesize + // some events for our delegate. + WebViewImpl* webView = m_webFrame->viewImpl(); + + // Flag of whether frame loader is completed. Generate didStartLoading and + // didStopLoading only when loader is completed so that we don't fire + // them for fragment redirection that happens in window.onload handler. + // See https://bugs.webkit.org/show_bug.cgi?id=31838 + bool loaderCompleted = + !m_webFrame->frame()->page()->mainFrame()->loader()->isLoading(); + + // Generate didStartLoading if loader is completed. + if (webView->client() && loaderCompleted) + webView->client()->didStartLoading(); + + WebDataSourceImpl* ds = m_webFrame->dataSourceImpl(); + ASSERT(ds); // Should not be null when navigating to a reference fragment! + if (ds) { + KURL url = ds->request().url(); + KURL chainEnd; + if (ds->hasRedirectChain()) { + chainEnd = ds->endOfRedirectChain(); + ds->clearRedirectChain(); + } + + // Figure out if this location change is because of a JS-initiated + // client redirect (e.g onload/setTimeout document.location.href=). + // FIXME: (bugs 1085325, 1046841) We don't get proper redirect + // performed/cancelled notifications across anchor navigations, so the + // other redirect-tracking code in this class (see + // dispatch*ClientRedirect() and dispatchDidStartProvisionalLoad) is + // insufficient to catch and properly flag these transitions. Once a + // proper fix for this bug is identified and applied the following + // block may no longer be required. + bool wasClientRedirect = + (url == m_expectedClientRedirectDest && chainEnd == m_expectedClientRedirectSrc) + || !m_webFrame->isProcessingUserGesture(); + + if (wasClientRedirect) { + if (m_webFrame->client()) + m_webFrame->client()->didCompleteClientRedirect(m_webFrame, chainEnd); + ds->appendRedirect(chainEnd); + // Make sure we clear the expected redirect since we just effectively + // completed it. + m_expectedClientRedirectSrc = KURL(); + m_expectedClientRedirectDest = KURL(); + } + + // Regardless of how we got here, we are navigating to a URL so we need to + // add it to the redirect chain. + ds->appendRedirect(url); + } + + bool isNewNavigation; + webView->didCommitLoad(&isNewNavigation); + if (m_webFrame->client()) + m_webFrame->client()->didChangeLocationWithinPage(m_webFrame, isNewNavigation); + + // Generate didStopLoading if loader is completed. + if (webView->client() && loaderCompleted) + webView->client()->didStopLoading(); +} + +void FrameLoaderClientImpl::dispatchDidPushStateWithinPage() +{ + // FIXME +} + +void FrameLoaderClientImpl::dispatchDidReplaceStateWithinPage() +{ + // FIXME +} + +void FrameLoaderClientImpl::dispatchDidPopStateWithinPage() +{ + // FIXME +} + +void FrameLoaderClientImpl::dispatchWillClose() +{ + if (m_webFrame->client()) + m_webFrame->client()->willClose(m_webFrame); +} + +void FrameLoaderClientImpl::dispatchDidReceiveIcon() +{ + // The icon database is disabled, so this should never be called. + ASSERT_NOT_REACHED(); +} + +void FrameLoaderClientImpl::dispatchDidStartProvisionalLoad() +{ + // In case a redirect occurs, we need this to be set so that the redirect + // handling code can tell where the redirect came from. Server redirects + // will occur on the provisional load, so we need to keep track of the most + // recent provisional load URL. + // See dispatchDidReceiveServerRedirectForProvisionalLoad. + WebDataSourceImpl* ds = m_webFrame->provisionalDataSourceImpl(); + if (!ds) { + ASSERT_NOT_REACHED(); + return; + } + KURL url = ds->request().url(); + + // Since the provisional load just started, we should have not gotten + // any redirects yet. + ASSERT(!ds->hasRedirectChain()); + + // If this load is what we expected from a client redirect, treat it as a + // redirect from that original page. The expected redirect urls will be + // cleared by DidCancelClientRedirect. + bool completingClientRedirect = false; + if (m_expectedClientRedirectSrc.isValid()) { + // m_expectedClientRedirectDest could be something like + // "javascript:history.go(-1)" thus we need to exclude url starts with + // "javascript:". See bug: 1080873 + ASSERT(m_expectedClientRedirectDest.protocolIs("javascript") + || m_expectedClientRedirectDest == url); + ds->appendRedirect(m_expectedClientRedirectSrc); + completingClientRedirect = true; + } + ds->appendRedirect(url); + + if (m_webFrame->client()) { + // Whatever information didCompleteClientRedirect contains should only + // be considered relevant until the next provisional load has started. + // So we first tell the client that the load started, and then tell it + // about the client redirect the load is responsible for completing. + m_webFrame->client()->didStartProvisionalLoad(m_webFrame); + if (completingClientRedirect) { + m_webFrame->client()->didCompleteClientRedirect( + m_webFrame, m_expectedClientRedirectSrc); + } + } +} + +void FrameLoaderClientImpl::dispatchDidReceiveTitle(const String& title) +{ + if (m_webFrame->client()) + m_webFrame->client()->didReceiveTitle(m_webFrame, title); +} + +void FrameLoaderClientImpl::dispatchDidCommitLoad() +{ + WebViewImpl* webview = m_webFrame->viewImpl(); + bool isNewNavigation; + webview->didCommitLoad(&isNewNavigation); + + if (m_webFrame->client()) + m_webFrame->client()->didCommitProvisionalLoad(m_webFrame, isNewNavigation); + + if (webview->devToolsAgentPrivate()) + webview->devToolsAgentPrivate()->didCommitProvisionalLoad(m_webFrame, isNewNavigation); +} + +void FrameLoaderClientImpl::dispatchDidFailProvisionalLoad( + const ResourceError& error) +{ + + // If a policy change occured, then we do not want to inform the plugin + // delegate. See http://b/907789 for details. FIXME: This means the + // plugin won't receive NPP_URLNotify, which seems like it could result in + // a memory leak in the plugin!! + if (error.domain() == internalErrorDomain + && error.errorCode() == PolicyChangeError) { + m_webFrame->didFail(cancelledError(error.failingURL()), true); + return; + } + + OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(); + m_webFrame->didFail(error, true); + if (observer) + observer->didFailLoading(error); +} + +void FrameLoaderClientImpl::dispatchDidFailLoad(const ResourceError& error) +{ + OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(); + m_webFrame->didFail(error, false); + if (observer) + observer->didFailLoading(error); + + // Don't clear the redirect chain, this will happen in the middle of client + // redirects, and we need the context. The chain will be cleared when the + // provisional load succeeds or fails, not the "real" one. +} + +void FrameLoaderClientImpl::dispatchDidFinishLoad() +{ + OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(); + + if (m_webFrame->client()) + m_webFrame->client()->didFinishLoad(m_webFrame); + + if (observer) + observer->didFinishLoading(); + + // Don't clear the redirect chain, this will happen in the middle of client + // redirects, and we need the context. The chain will be cleared when the + // provisional load succeeds or fails, not the "real" one. +} + +void FrameLoaderClientImpl::dispatchDidFirstLayout() +{ +} + +void FrameLoaderClientImpl::dispatchDidFirstVisuallyNonEmptyLayout() +{ + // FIXME: called when webkit finished layout of a page that was visually non-empty. + // All resources have not necessarily finished loading. +} + +Frame* FrameLoaderClientImpl::dispatchCreatePage() +{ + struct WindowFeatures features; + Page* newPage = m_webFrame->frame()->page()->chrome()->createWindow( + m_webFrame->frame(), FrameLoadRequest(), features); + + // Make sure that we have a valid disposition. This should have been set in + // the preceeding call to dispatchDecidePolicyForNewWindowAction. + ASSERT(m_nextNavigationPolicy != WebNavigationPolicyIgnore); + WebNavigationPolicy policy = m_nextNavigationPolicy; + m_nextNavigationPolicy = WebNavigationPolicyIgnore; + + // createWindow can return null (e.g., popup blocker denies the window). + if (!newPage) + return 0; + + WebViewImpl::fromPage(newPage)->setInitialNavigationPolicy(policy); + return newPage->mainFrame(); +} + +void FrameLoaderClientImpl::dispatchShow() +{ + WebViewImpl* webView = m_webFrame->viewImpl(); + if (webView && webView->client()) + webView->client()->show(webView->initialNavigationPolicy()); +} + +static bool shouldTreatAsAttachment(const ResourceResponse& response) +{ + const String& contentDisposition = + response.httpHeaderField("Content-Disposition"); + if (contentDisposition.isEmpty()) + return false; + + // Some broken sites just send + // Content-Disposition: ; filename="file" + // screen those out here. + if (contentDisposition.startsWith(";")) + return false; + + if (contentDisposition.startsWith("inline", false)) + return false; + + // Some broken sites just send + // Content-Disposition: filename="file" + // without a disposition token... screen those out. + if (contentDisposition.startsWith("filename", false)) + return false; + + // Also in use is Content-Disposition: name="file" + if (contentDisposition.startsWith("name", false)) + return false; + + // We have a content-disposition of "attachment" or unknown. + // RFC 2183, section 2.8 says that an unknown disposition + // value should be treated as "attachment" + return true; +} + +void FrameLoaderClientImpl::dispatchDecidePolicyForMIMEType( + FramePolicyFunction function, + const String& mimeType, + const ResourceRequest&) +{ + const ResourceResponse& response = + m_webFrame->frame()->loader()->activeDocumentLoader()->response(); + + PolicyAction action; + + int statusCode = response.httpStatusCode(); + if (statusCode == 204 || statusCode == 205) { + // The server does not want us to replace the page contents. + action = PolicyIgnore; + } else if (shouldTreatAsAttachment(response)) { + // The server wants us to download instead of replacing the page contents. + // Downloading is handled by the embedder, but we still get the initial + // response so that we can ignore it and clean up properly. + action = PolicyIgnore; + } else if (!canShowMIMEType(mimeType)) { + // Make sure that we can actually handle this type internally. + action = PolicyIgnore; + } else { + // OK, we will render this page. + action = PolicyUse; + } + + // NOTE: PolicyChangeError will be generated when action is not PolicyUse. + (m_webFrame->frame()->loader()->policyChecker()->*function)(action); +} + +void FrameLoaderClientImpl::dispatchDecidePolicyForNewWindowAction( + FramePolicyFunction function, + const NavigationAction& action, + const ResourceRequest& request, + PassRefPtr<FormState> formState, + const String& frameName) +{ + WebNavigationPolicy navigationPolicy; + if (!actionSpecifiesNavigationPolicy(action, &navigationPolicy)) + navigationPolicy = WebNavigationPolicyNewForegroundTab; + + PolicyAction policyAction; + if (navigationPolicy == WebNavigationPolicyDownload) + policyAction = PolicyDownload; + else { + policyAction = PolicyUse; + + // Remember the disposition for when dispatchCreatePage is called. It is + // unfortunate that WebCore does not provide us with any context when + // creating or showing the new window that would allow us to avoid having + // to keep this state. + m_nextNavigationPolicy = navigationPolicy; + } + (m_webFrame->frame()->loader()->policyChecker()->*function)(policyAction); +} + +void FrameLoaderClientImpl::dispatchDecidePolicyForNavigationAction( + FramePolicyFunction function, + const NavigationAction& action, + const ResourceRequest& request, + PassRefPtr<FormState> formState) { + PolicyAction policyAction = PolicyIgnore; + + // It is valid for this function to be invoked in code paths where the + // the webview is closed. + // The null check here is to fix a crash that seems strange + // (see - https://bugs.webkit.org/show_bug.cgi?id=23554). + if (m_webFrame->client() && !request.url().isNull()) { + WebNavigationPolicy navigationPolicy = WebNavigationPolicyCurrentTab; + actionSpecifiesNavigationPolicy(action, &navigationPolicy); + + // Give the delegate a chance to change the navigation policy. + const WebDataSourceImpl* ds = m_webFrame->provisionalDataSourceImpl(); + if (ds) { + KURL url = ds->request().url(); + if (url.protocolIs(backForwardNavigationScheme)) { + handleBackForwardNavigation(url); + navigationPolicy = WebNavigationPolicyIgnore; + } else { + bool isRedirect = ds->hasRedirectChain(); + + WebNavigationType webnavType = + WebDataSourceImpl::toWebNavigationType(action.type()); + + RefPtr<Node> node; + for (const Event* event = action.event(); event; event = event->underlyingEvent()) { + if (event->isMouseEvent()) { + const MouseEvent* mouseEvent = + static_cast<const MouseEvent*>(event); + node = m_webFrame->frame()->eventHandler()->hitTestResultAtPoint( + mouseEvent->absoluteLocation(), false).innerNonSharedNode(); + break; + } + } + WebNode originatingNode(node); + + navigationPolicy = m_webFrame->client()->decidePolicyForNavigation( + m_webFrame, ds->request(), webnavType, originatingNode, + navigationPolicy, isRedirect); + } + } + + if (navigationPolicy == WebNavigationPolicyCurrentTab) + policyAction = PolicyUse; + else if (navigationPolicy == WebNavigationPolicyDownload) + policyAction = PolicyDownload; + else { + if (navigationPolicy != WebNavigationPolicyIgnore) { + WrappedResourceRequest webreq(request); + m_webFrame->client()->loadURLExternally(m_webFrame, webreq, navigationPolicy); + } + policyAction = PolicyIgnore; + } + } + + (m_webFrame->frame()->loader()->policyChecker()->*function)(policyAction); +} + +void FrameLoaderClientImpl::cancelPolicyCheck() +{ + // FIXME +} + +void FrameLoaderClientImpl::dispatchUnableToImplementPolicy(const ResourceError& error) +{ + m_webFrame->client()->unableToImplementPolicyWithError(m_webFrame, error); +} + +void FrameLoaderClientImpl::dispatchWillSubmitForm(FramePolicyFunction function, + PassRefPtr<FormState> formState) +{ + if (m_webFrame->client()) + m_webFrame->client()->willSubmitForm(m_webFrame, WebFormElement(formState->form())); + (m_webFrame->frame()->loader()->policyChecker()->*function)(PolicyUse); +} + +void FrameLoaderClientImpl::dispatchDidLoadMainResource(DocumentLoader*) +{ + // FIXME +} + +void FrameLoaderClientImpl::revertToProvisionalState(DocumentLoader*) +{ + m_hasRepresentation = true; +} + +void FrameLoaderClientImpl::setMainDocumentError(DocumentLoader*, + const ResourceError& error) +{ + if (m_pluginWidget.get()) { + if (m_sentInitialResponseToPlugin) { + m_pluginWidget->didFailLoading(error); + m_sentInitialResponseToPlugin = false; + } + m_pluginWidget = 0; + } +} + +void FrameLoaderClientImpl::postProgressStartedNotification() +{ + WebViewImpl* webview = m_webFrame->viewImpl(); + if (webview && webview->client()) + webview->client()->didStartLoading(); +} + +void FrameLoaderClientImpl::postProgressEstimateChangedNotification() +{ + // FIXME +} + +void FrameLoaderClientImpl::postProgressFinishedNotification() +{ + // FIXME: why might the webview be null? http://b/1234461 + WebViewImpl* webview = m_webFrame->viewImpl(); + if (webview && webview->client()) + webview->client()->didStopLoading(); +} + +void FrameLoaderClientImpl::setMainFrameDocumentReady(bool ready) +{ + // FIXME +} + +// Creates a new connection and begins downloading from that (contrast this +// with |download|). +void FrameLoaderClientImpl::startDownload(const ResourceRequest& request) +{ + if (m_webFrame->client()) { + WrappedResourceRequest webreq(request); + m_webFrame->client()->loadURLExternally( + m_webFrame, webreq, WebNavigationPolicyDownload); + } +} + +void FrameLoaderClientImpl::willChangeTitle(DocumentLoader*) +{ + // FIXME +} + +void FrameLoaderClientImpl::didChangeTitle(DocumentLoader*) +{ + // FIXME +} + +// Called whenever data is received. +void FrameLoaderClientImpl::committedLoad(DocumentLoader* loader, const char* data, int length) +{ + if (!m_pluginWidget.get()) { + if (m_webFrame->client()) { + bool preventDefault = false; + m_webFrame->client()->didReceiveDocumentData(m_webFrame, data, length, preventDefault); + if (!preventDefault) + m_webFrame->commitDocumentData(data, length); + } + } + + // If we are sending data to MediaDocument, we should stop here + // and cancel the request. + if (m_webFrame->frame()->document() + && m_webFrame->frame()->document()->isMediaDocument()) + loader->cancelMainResourceLoad(pluginWillHandleLoadError(loader->response())); + + // The plugin widget could have been created in the m_webFrame->DidReceiveData + // function. + if (m_pluginWidget.get()) { + if (!m_sentInitialResponseToPlugin) { + m_sentInitialResponseToPlugin = true; + m_pluginWidget->didReceiveResponse( + m_webFrame->frame()->loader()->activeDocumentLoader()->response()); + } + m_pluginWidget->didReceiveData(data, length); + } +} + +void FrameLoaderClientImpl::finishedLoading(DocumentLoader* dl) +{ + if (m_pluginWidget.get()) { + m_pluginWidget->didFinishLoading(); + m_pluginWidget = 0; + m_sentInitialResponseToPlugin = false; + } else { + // This is necessary to create an empty document. See bug 634004. + // However, we only want to do this if makeRepresentation has been called, to + // match the behavior on the Mac. + if (m_hasRepresentation) + dl->frameLoader()->setEncoding("", false); + } +} + +void FrameLoaderClientImpl::updateGlobalHistory() +{ +} + +void FrameLoaderClientImpl::updateGlobalHistoryRedirectLinks() +{ +} + +bool FrameLoaderClientImpl::shouldGoToHistoryItem(HistoryItem*) const +{ + // FIXME + return true; +} + +void FrameLoaderClientImpl::dispatchDidAddBackForwardItem(HistoryItem*) const +{ +} + +void FrameLoaderClientImpl::dispatchDidRemoveBackForwardItem(HistoryItem*) const +{ +} + +void FrameLoaderClientImpl::dispatchDidChangeBackForwardIndex() const +{ +} + +void FrameLoaderClientImpl::didDisplayInsecureContent() +{ + if (m_webFrame->client()) + m_webFrame->client()->didDisplayInsecureContent(m_webFrame); +} + +void FrameLoaderClientImpl::didRunInsecureContent(SecurityOrigin* origin) +{ + if (m_webFrame->client()) + m_webFrame->client()->didRunInsecureContent(m_webFrame, WebSecurityOrigin(origin)); +} + +ResourceError FrameLoaderClientImpl::blockedError(const ResourceRequest&) +{ + // FIXME + return ResourceError(); +} + +ResourceError FrameLoaderClientImpl::cancelledError(const ResourceRequest& request) +{ + if (!m_webFrame->client()) + return ResourceError(); + + return m_webFrame->client()->cancelledError( + m_webFrame, WrappedResourceRequest(request)); +} + +ResourceError FrameLoaderClientImpl::cannotShowURLError(const ResourceRequest& request) +{ + if (!m_webFrame->client()) + return ResourceError(); + + return m_webFrame->client()->cannotHandleRequestError( + m_webFrame, WrappedResourceRequest(request)); +} + +ResourceError FrameLoaderClientImpl::interruptForPolicyChangeError( + const ResourceRequest& request) +{ + return ResourceError(internalErrorDomain, PolicyChangeError, + request.url().string(), String()); +} + +ResourceError FrameLoaderClientImpl::cannotShowMIMETypeError(const ResourceResponse&) +{ + // FIXME + return ResourceError(); +} + +ResourceError FrameLoaderClientImpl::fileDoesNotExistError(const ResourceResponse&) +{ + // FIXME + return ResourceError(); +} + +ResourceError FrameLoaderClientImpl::pluginWillHandleLoadError(const ResourceResponse&) +{ + // FIXME + return ResourceError(); +} + +bool FrameLoaderClientImpl::shouldFallBack(const ResourceError& error) +{ + // This method is called when we fail to load the URL for an <object> tag + // that has fallback content (child elements) and is being loaded as a frame. + // The error parameter indicates the reason for the load failure. + // We should let the fallback content load only if this wasn't a cancelled + // request. + // Note: The mac version also has a case for "WebKitErrorPluginWillHandleLoad" + ResourceError c = cancelledError(ResourceRequest()); + return error.errorCode() != c.errorCode() || error.domain() != c.domain(); +} + +bool FrameLoaderClientImpl::canHandleRequest(const ResourceRequest& request) const +{ + return m_webFrame->client()->canHandleRequest( + m_webFrame, WrappedResourceRequest(request)); +} + +bool FrameLoaderClientImpl::canShowMIMEType(const String& mimeType) const +{ + // This method is called to determine if the media type can be shown + // "internally" (i.e. inside the browser) regardless of whether or not the + // browser or a plugin is doing the rendering. + + // mimeType strings are supposed to be ASCII, but if they are not for some + // reason, then it just means that the mime type will fail all of these "is + // supported" checks and go down the path of an unhandled mime type. + if (webKitClient()->mimeRegistry()->supportsMIMEType(mimeType) == WebMimeRegistry::IsSupported) + return true; + + // If Chrome is started with the --disable-plugins switch, pluginData is null. + PluginData* pluginData = m_webFrame->frame()->page()->pluginData(); + + // See if the type is handled by an installed plugin, if so, we can show it. + // FIXME: (http://b/1085524) This is the place to stick a preference to + // disable full page plugins (optionally for certain types!) + return !mimeType.isEmpty() && pluginData && pluginData->supportsMimeType(mimeType); +} + +bool FrameLoaderClientImpl::representationExistsForURLScheme(const String&) const +{ + // FIXME + return false; +} + +String FrameLoaderClientImpl::generatedMIMETypeForURLScheme(const String& scheme) const +{ + // This appears to generate MIME types for protocol handlers that are handled + // internally. The only place I can find in the WebKit code that uses this + // function is WebView::registerViewClass, where it is used as part of the + // process by which custom view classes for certain document representations + // are registered. + String mimeType("x-apple-web-kit/"); + mimeType.append(scheme.lower()); + return mimeType; +} + +void FrameLoaderClientImpl::frameLoadCompleted() +{ + // FIXME: the mac port also conditionally calls setDrawsBackground:YES on + // it's ScrollView here. + + // This comment from the Mac port: + // Note: Can be called multiple times. + // Even if already complete, we might have set a previous item on a frame that + // didn't do any data loading on the past transaction. Make sure to clear these out. + + // FIXME: setPreviousHistoryItem() no longer exists. http://crbug.com/8566 + // m_webFrame->frame()->loader()->setPreviousHistoryItem(0); +} + +void FrameLoaderClientImpl::saveViewStateToItem(HistoryItem*) +{ + // FIXME +} + +void FrameLoaderClientImpl::restoreViewState() +{ + // FIXME: probably scrolls to last position when you go back or forward +} + +void FrameLoaderClientImpl::provisionalLoadStarted() +{ + // FIXME: On mac, this does various caching stuff +} + +void FrameLoaderClientImpl::didFinishLoad() +{ + OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(); + if (observer) + observer->didFinishLoading(); +} + +void FrameLoaderClientImpl::prepareForDataSourceReplacement() +{ + // FIXME +} + +PassRefPtr<DocumentLoader> FrameLoaderClientImpl::createDocumentLoader( + const ResourceRequest& request, + const SubstituteData& data) +{ + RefPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(request, data); + if (m_webFrame->client()) + m_webFrame->client()->didCreateDataSource(m_webFrame, ds.get()); + return ds.release(); +} + +void FrameLoaderClientImpl::setTitle(const String& title, const KURL& url) +{ + // FIXME: inform consumer of changes to the title. +} + +String FrameLoaderClientImpl::userAgent(const KURL& url) +{ + return webKitClient()->userAgent(url); +} + +void FrameLoaderClientImpl::savePlatformDataToCachedFrame(CachedFrame*) +{ + // The page cache should be disabled. + ASSERT_NOT_REACHED(); +} + +void FrameLoaderClientImpl::transitionToCommittedFromCachedFrame(CachedFrame*) +{ + ASSERT_NOT_REACHED(); +} + +// Called when the FrameLoader goes into a state in which a new page load +// will occur. +void FrameLoaderClientImpl::transitionToCommittedForNewPage() +{ + makeDocumentView(); +} + +bool FrameLoaderClientImpl::canCachePage() const +{ + // Since we manage the cache, always report this page as non-cacheable to + // FrameLoader. + return false; +} + +// Downloading is handled in the browser process, not WebKit. If we get to this +// point, our download detection code in the ResourceDispatcherHost is broken! +void FrameLoaderClientImpl::download(ResourceHandle* handle, + const ResourceRequest& request, + const ResourceRequest& initialRequest, + const ResourceResponse& response) +{ + ASSERT_NOT_REACHED(); +} + +PassRefPtr<Frame> FrameLoaderClientImpl::createFrame( + const KURL& url, + const String& name, + HTMLFrameOwnerElement* ownerElement, + const String& referrer, + bool allowsScrolling, + int marginWidth, + int marginHeight) +{ + FrameLoadRequest frameRequest(ResourceRequest(url, referrer), name); + return m_webFrame->createChildFrame(frameRequest, ownerElement); +} + +PassRefPtr<Widget> FrameLoaderClientImpl::createPlugin( + const IntSize& size, // FIXME: how do we use this? + HTMLPlugInElement* element, + const KURL& url, + const Vector<String>& paramNames, + const Vector<String>& paramValues, + const String& mimeType, + bool loadManually) +{ +#if !PLATFORM(WIN_OS) + // WebCore asks us to make a plugin even if we don't have a + // registered handler, with a comment saying it's so we can display + // the broken plugin icon. In Chromium, we normally register a + // fallback plugin handler that allows you to install a missing + // plugin. Since we don't yet have a default plugin handler, we + // need to return null here rather than going through all the + // plugin-creation IPCs only to discover we don't have a plugin + // registered, which causes a crash. + // FIXME: remove me once we have a default plugin. + if (objectContentType(url, mimeType) != ObjectContentNetscapePlugin) + return 0; +#endif + + if (!m_webFrame->client()) + return 0; + + WebPluginParams params; + params.url = url; + params.mimeType = mimeType; + params.attributeNames = paramNames; + params.attributeValues = paramValues; + params.loadManually = loadManually; + + WebPlugin* webPlugin = m_webFrame->client()->createPlugin(m_webFrame, params); + if (!webPlugin) + return 0; + + // The container takes ownership of the WebPlugin. + RefPtr<WebPluginContainerImpl> container = + WebPluginContainerImpl::create(element, webPlugin); + + if (!webPlugin->initialize(container.get())) + return 0; + + // The element might have been removed during plugin initialization! + if (!element->renderer()) + return 0; + + return container; +} + +// This method gets called when a plugin is put in place of html content +// (e.g., acrobat reader). +void FrameLoaderClientImpl::redirectDataToPlugin(Widget* pluginWidget) +{ + m_pluginWidget = static_cast<WebPluginContainerImpl*>(pluginWidget); + ASSERT(m_pluginWidget.get()); +} + +PassRefPtr<Widget> FrameLoaderClientImpl::createJavaAppletWidget( + const IntSize& size, + HTMLAppletElement* element, + const KURL& /* baseURL */, + const Vector<String>& paramNames, + const Vector<String>& paramValues) +{ + return createPlugin(size, element, KURL(), paramNames, paramValues, + "application/x-java-applet", false); +} + +ObjectContentType FrameLoaderClientImpl::objectContentType( + const KURL& url, + const String& explicitMimeType) +{ + // This code is based on Apple's implementation from + // WebCoreSupport/WebFrameBridge.mm. + + String mimeType = explicitMimeType; + if (mimeType.isEmpty()) { + // Try to guess the MIME type based off the extension. + String filename = url.lastPathComponent(); + int extensionPos = filename.reverseFind('.'); + if (extensionPos >= 0) { + String extension = filename.substring(extensionPos + 1); + mimeType = MIMETypeRegistry::getMIMETypeForExtension(extension); + if (mimeType.isEmpty()) { + // If there's no mimetype registered for the extension, check to see + // if a plugin can handle the extension. + mimeType = getPluginMimeTypeFromExtension(extension); + } + } + + if (mimeType.isEmpty()) + return ObjectContentFrame; + } + + if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType)) + return ObjectContentImage; + + // If Chrome is started with the --disable-plugins switch, pluginData is 0. + PluginData* pluginData = m_webFrame->frame()->page()->pluginData(); + if (pluginData && pluginData->supportsMimeType(mimeType)) + return ObjectContentNetscapePlugin; + + if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType)) + return ObjectContentFrame; + + return ObjectContentNone; +} + +String FrameLoaderClientImpl::overrideMediaType() const +{ + // FIXME + return String(); +} + +bool FrameLoaderClientImpl::actionSpecifiesNavigationPolicy( + const NavigationAction& action, + WebNavigationPolicy* policy) +{ + if ((action.type() != NavigationTypeLinkClicked) || !action.event()->isMouseEvent()) + return false; + + const MouseEvent* event = static_cast<const MouseEvent*>(action.event()); + return WebViewImpl::navigationPolicyFromMouseEvent( + event->button(), event->ctrlKey(), event->shiftKey(), event->altKey(), + event->metaKey(), policy); +} + +void FrameLoaderClientImpl::handleBackForwardNavigation(const KURL& url) +{ + ASSERT(url.protocolIs(backForwardNavigationScheme)); + + bool ok; + int offset = url.lastPathComponent().toIntStrict(&ok); + if (!ok) + return; + + WebViewImpl* webview = m_webFrame->viewImpl(); + if (webview->client()) + webview->client()->navigateBackForwardSoon(offset); +} + +PassOwnPtr<WebPluginLoadObserver> FrameLoaderClientImpl::pluginLoadObserver() +{ + WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader( + m_webFrame->frame()->loader()->activeDocumentLoader()); + return ds->releasePluginLoadObserver(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/FrameLoaderClientImpl.h b/WebKit/chromium/src/FrameLoaderClientImpl.h new file mode 100644 index 0000000..4ddfe5f --- /dev/null +++ b/WebKit/chromium/src/FrameLoaderClientImpl.h @@ -0,0 +1,240 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FrameLoaderClientImpl_h +#define FrameLoaderClientImpl_h + +// FIXME: remove this relative path once consumers from glue are removed. +#include "../public/WebNavigationPolicy.h" +#include "FrameLoaderClient.h" +#include "KURL.h" +#include <wtf/PassOwnPtr.h> +#include <wtf/RefPtr.h> + + +namespace WebKit { + +class WebFrameImpl; +class WebPluginContainerImpl; +class WebPluginLoadObserver; + +class FrameLoaderClientImpl : public WebCore::FrameLoaderClient { +public: + FrameLoaderClientImpl(WebFrameImpl* webFrame); + ~FrameLoaderClientImpl(); + + WebFrameImpl* webFrame() const { return m_webFrame; } + + // WebCore::FrameLoaderClient ---------------------------------------------- + + virtual void frameLoaderDestroyed(); + + // Notifies the WebView delegate that the JS window object has been cleared, + // giving it a chance to bind native objects to the window before script + // parsing begins. + virtual void dispatchDidClearWindowObjectInWorld(WebCore::DOMWrapperWorld*); + virtual void documentElementAvailable(); + + // A frame's V8 context was created or destroyed. + virtual void didCreateScriptContextForFrame(); + virtual void didDestroyScriptContextForFrame(); + + // A context untied to a frame was created (through evaluateInNewContext). + // This context is not tied to the lifetime of its frame, and is destroyed + // in garbage collection. + virtual void didCreateIsolatedScriptContext(); + + virtual bool hasWebView() const; + virtual bool hasFrameView() const; + virtual void makeRepresentation(WebCore::DocumentLoader*); + virtual void forceLayout(); + virtual void forceLayoutForNonHTML(); + virtual void setCopiesOnScroll(); + virtual void detachedFromParent2(); + virtual void detachedFromParent3(); + virtual void assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&); + virtual void dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long identifier, WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse); + virtual bool shouldUseCredentialStorage(WebCore::DocumentLoader*, unsigned long identifier); + virtual void dispatchDidReceiveAuthenticationChallenge(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::AuthenticationChallenge&); + virtual void dispatchDidCancelAuthenticationChallenge(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::AuthenticationChallenge&); + virtual void dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::ResourceResponse&); + virtual void dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long identifier, int lengthReceived); + virtual void dispatchDidFinishLoading(WebCore::DocumentLoader*, unsigned long identifier); + virtual void dispatchDidFailLoading(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::ResourceError&); + virtual bool dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int length); + virtual void dispatchDidLoadResourceByXMLHttpRequest(unsigned long identifier, const WebCore::ScriptString&); + virtual void dispatchDidHandleOnloadEvents(); + virtual void dispatchDidReceiveServerRedirectForProvisionalLoad(); + virtual void dispatchDidCancelClientRedirect(); + virtual void dispatchWillPerformClientRedirect(const WebCore::KURL&, double interval, double fireDate); + virtual void dispatchDidChangeLocationWithinPage(); + virtual void dispatchDidPushStateWithinPage(); + virtual void dispatchDidReplaceStateWithinPage(); + virtual void dispatchDidPopStateWithinPage(); + virtual void dispatchWillClose(); + virtual void dispatchDidReceiveIcon(); + virtual void dispatchDidStartProvisionalLoad(); + virtual void dispatchDidReceiveTitle(const WebCore::String& title); + virtual void dispatchDidCommitLoad(); + virtual void dispatchDidFailProvisionalLoad(const WebCore::ResourceError&); + virtual void dispatchDidFailLoad(const WebCore::ResourceError&); + virtual void dispatchDidFinishDocumentLoad(); + virtual void dispatchDidFinishLoad(); + virtual void dispatchDidFirstLayout(); + virtual void dispatchDidFirstVisuallyNonEmptyLayout(); + virtual WebCore::Frame* dispatchCreatePage(); + virtual void dispatchShow(); + virtual void dispatchDecidePolicyForMIMEType(WebCore::FramePolicyFunction function, const WebCore::String& mime_type, const WebCore::ResourceRequest&); + virtual void dispatchDecidePolicyForNewWindowAction(WebCore::FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request, PassRefPtr<WebCore::FormState> form_state, const WebCore::String& frame_name); + virtual void dispatchDecidePolicyForNavigationAction(WebCore::FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request, PassRefPtr<WebCore::FormState> form_state); + virtual void cancelPolicyCheck(); + virtual void dispatchUnableToImplementPolicy(const WebCore::ResourceError&); + virtual void dispatchWillSubmitForm(WebCore::FramePolicyFunction, PassRefPtr<WebCore::FormState>); + virtual void dispatchDidLoadMainResource(WebCore::DocumentLoader*); + virtual void revertToProvisionalState(WebCore::DocumentLoader*); + virtual void setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&); + virtual void willChangeEstimatedProgress() { } + virtual void didChangeEstimatedProgress() { } + virtual void postProgressStartedNotification(); + virtual void postProgressEstimateChangedNotification(); + virtual void postProgressFinishedNotification(); + virtual void setMainFrameDocumentReady(bool); + virtual void startDownload(const WebCore::ResourceRequest&); + virtual void willChangeTitle(WebCore::DocumentLoader*); + virtual void didChangeTitle(WebCore::DocumentLoader*); + virtual void committedLoad(WebCore::DocumentLoader*, const char*, int); + virtual void finishedLoading(WebCore::DocumentLoader*); + virtual void updateGlobalHistory(); + virtual void updateGlobalHistoryRedirectLinks(); + virtual bool shouldGoToHistoryItem(WebCore::HistoryItem*) const; + virtual void dispatchDidAddBackForwardItem(WebCore::HistoryItem*) const; + virtual void dispatchDidRemoveBackForwardItem(WebCore::HistoryItem*) const; + virtual void dispatchDidChangeBackForwardIndex() const; + virtual void didDisplayInsecureContent(); + virtual void didRunInsecureContent(WebCore::SecurityOrigin*); + virtual WebCore::ResourceError blockedError(const WebCore::ResourceRequest&); + virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&); + virtual WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&); + virtual WebCore::ResourceError interruptForPolicyChangeError(const WebCore::ResourceRequest&); + virtual WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&); + virtual WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&); + virtual WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&); + virtual bool shouldFallBack(const WebCore::ResourceError&); + virtual bool canHandleRequest(const WebCore::ResourceRequest&) const; + virtual bool canShowMIMEType(const WebCore::String& MIMEType) const; + virtual bool representationExistsForURLScheme(const WebCore::String& URLScheme) const; + virtual WebCore::String generatedMIMETypeForURLScheme(const WebCore::String& URLScheme) const; + virtual void frameLoadCompleted(); + virtual void saveViewStateToItem(WebCore::HistoryItem*); + virtual void restoreViewState(); + virtual void provisionalLoadStarted(); + virtual void didFinishLoad(); + virtual void prepareForDataSourceReplacement(); + virtual PassRefPtr<WebCore::DocumentLoader> createDocumentLoader( + const WebCore::ResourceRequest&, const WebCore::SubstituteData&); + virtual void setTitle(const WebCore::String& title, const WebCore::KURL&); + virtual WebCore::String userAgent(const WebCore::KURL&); + virtual void savePlatformDataToCachedFrame(WebCore::CachedFrame*); + virtual void transitionToCommittedFromCachedFrame(WebCore::CachedFrame*); + virtual void transitionToCommittedForNewPage(); + virtual bool canCachePage() const; + virtual void download( + WebCore::ResourceHandle*, const WebCore::ResourceRequest&, + const WebCore::ResourceRequest& initialRequest, + const WebCore::ResourceResponse&); + virtual PassRefPtr<WebCore::Frame> createFrame( + const WebCore::KURL& url, const WebCore::String& name, + WebCore::HTMLFrameOwnerElement* ownerElement, + const WebCore::String& referrer, bool allowsScrolling, + int marginWidth, int marginHeight); + virtual PassRefPtr<WebCore::Widget> createPlugin( + const WebCore::IntSize&, WebCore::HTMLPlugInElement*, const WebCore::KURL&, + const Vector<WebCore::String>&, const Vector<WebCore::String>&, + const WebCore::String&, bool loadManually); + virtual void redirectDataToPlugin(WebCore::Widget* pluginWidget); + virtual PassRefPtr<WebCore::Widget> createJavaAppletWidget( + const WebCore::IntSize&, + WebCore::HTMLAppletElement*, + const WebCore::KURL& /* base_url */, + const Vector<WebCore::String>& paramNames, + const Vector<WebCore::String>& paramValues); + virtual WebCore::ObjectContentType objectContentType( + const WebCore::KURL& url, const WebCore::String& mimeType); + virtual WebCore::String overrideMediaType() const; + virtual void didPerformFirstNavigation() const; + virtual void registerForIconNotification(bool listen = true); + virtual void didChangeScrollOffset(); + virtual bool allowJavaScript(bool enabledPerSettings); + +private: + void makeDocumentView(); + + // Given a NavigationAction, determine the associated WebNavigationPolicy. + // For example, a middle click means "open in background tab". + static bool actionSpecifiesNavigationPolicy( + const WebCore::NavigationAction& action, WebNavigationPolicy* policy); + + // Called when a dummy back-forward navigation is intercepted. + void handleBackForwardNavigation(const WebCore::KURL&); + + PassOwnPtr<WebPluginLoadObserver> pluginLoadObserver(); + + // The WebFrame that owns this object and manages its lifetime. Therefore, + // the web frame object is guaranteed to exist. + WebFrameImpl* m_webFrame; + + // True if makeRepresentation was called. We don't actually have a concept + // of a "representation", but we need to know when we're expected to have one. + // See finishedLoading(). + bool m_hasRepresentation; + + // Used to help track client redirects. When a provisional load starts, it + // has no redirects in its chain. But in the case of client redirects, we want + // to add that initial load as a redirect. When we get a new provisional load + // and the dest URL matches that load, we know that it was the result of a + // previous client redirect and the source should be added as a redirect. + // Both should be empty if unused. + WebCore::KURL m_expectedClientRedirectSrc; + WebCore::KURL m_expectedClientRedirectDest; + + // Contains a pointer to the plugin widget. + RefPtr<WebPluginContainerImpl> m_pluginWidget; + + // Indicates if we need to send over the initial notification to the plugin + // which specifies that the plugin should be ready to accept data. + bool m_sentInitialResponseToPlugin; + + // The navigation policy to use for the next call to dispatchCreatePage. + WebNavigationPolicy m_nextNavigationPolicy; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/GraphicsContext3D.cpp b/WebKit/chromium/src/GraphicsContext3D.cpp new file mode 100644 index 0000000..c9ba5a1 --- /dev/null +++ b/WebKit/chromium/src/GraphicsContext3D.cpp @@ -0,0 +1,2146 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if ENABLE(3D_CANVAS) + +#include "GraphicsContext3D.h" + +#include "CachedImage.h" +#include "CString.h" +#include "HTMLCanvasElement.h" +#include "HTMLImageElement.h" +#include "ImageBuffer.h" +#include "ImageData.h" +#include "NotImplemented.h" +#include "WebGLBuffer.h" +#include "WebGLByteArray.h" +#include "WebGLFloatArray.h" +#include "WebGLFramebuffer.h" +#include "WebGLIntArray.h" +#include "WebGLProgram.h" +#include "WebGLRenderbuffer.h" +#include "WebGLRenderingContext.h" +#include "WebGLShader.h" +#include "WebGLTexture.h" +#include "WebGLUnsignedByteArray.h" + +#include <stdio.h> +#include <wtf/FastMalloc.h> + +#if PLATFORM(WIN_OS) +#include <windows.h> +#endif + +#include "GL/glew.h" + +#if PLATFORM(CG) +#include "GraphicsContext.h" +#include <CoreGraphics/CGContext.h> +#include <CoreGraphics/CGBitmapContext.h> +#include <CoreGraphics/CGImage.h> +#include <OpenGL/OpenGL.h> +#else +#define FLIP_FRAMEBUFFER_VERTICALLY +#endif + +#if PLATFORM(SKIA) +#include "NativeImageSkia.h" +#endif + +#if PLATFORM(DARWIN) +#define USE_TEXTURE_RECTANGLE_FOR_FRAMEBUFFER +#endif + +#if PLATFORM(LINUX) +#include <dlfcn.h> +#include "GL/glxew.h" +#endif + +using namespace std; + +namespace WebCore { + +// GraphicsContext3DInternal ----------------------------------------------------- + +// Uncomment this to render to a separate window for debugging +// #define RENDER_TO_DEBUGGING_WINDOW + +#define EXTRACT(val) (!val ? 0 : val->object()) + +class GraphicsContext3DInternal { +public: + GraphicsContext3DInternal(); + ~GraphicsContext3DInternal(); + + bool makeContextCurrent(); + + PlatformGraphicsContext3D platformGraphicsContext3D() const; + Platform3DObject platformTexture() const; + + void reshape(int width, int height); + + void beginPaint(WebGLRenderingContext* context); + + bool validateTextureTarget(int target); + bool validateTextureParameter(int param); + + void activeTexture(unsigned long texture); + void bindBuffer(unsigned long target, + WebGLBuffer* buffer); + void bindTexture(unsigned long target, + WebGLTexture* texture); + void bufferDataImpl(unsigned long target, int size, const void* data, unsigned long usage); + void disableVertexAttribArray(unsigned long index); + void enableVertexAttribArray(unsigned long index); + unsigned long getError(); + void vertexAttribPointer(unsigned long indx, int size, int type, bool normalized, + unsigned long stride, unsigned long offset); + void viewportImpl(long x, long y, unsigned long width, unsigned long height); + + void synthesizeGLError(unsigned long error); + +private: + unsigned int m_texture; + unsigned int m_fbo; + unsigned int m_depthBuffer; + unsigned int m_cachedWidth, m_cachedHeight; + +#ifdef FLIP_FRAMEBUFFER_VERTICALLY + unsigned char* m_scanline; + void flipVertically(unsigned char* framebuffer, + unsigned int width, + unsigned int height); +#endif + + // Note: we aren't currently using this information, but we will + // need to in order to verify that all enabled vertex arrays have + // a valid buffer bound -- to avoid crashes on certain cards. + unsigned int m_boundArrayBuffer; + class VertexAttribPointerState { + public: + VertexAttribPointerState(); + + bool enabled; + unsigned long buffer; + unsigned long indx; + int size; + int type; + bool normalized; + unsigned long stride; + unsigned long offset; + }; + + enum { + NumTrackedPointerStates = 2 + }; + VertexAttribPointerState m_vertexAttribPointerState[NumTrackedPointerStates]; + + // Errors raised by synthesizeGLError(). + ListHashSet<unsigned long> m_syntheticErrors; + +#if PLATFORM(SKIA) + // If the width and height of the Canvas's backing store don't + // match those that we were given in the most recent call to + // reshape(), then we need an intermediate bitmap to read back the + // frame buffer into. This seems to happen when CSS styles are + // used to resize the Canvas. + SkBitmap* m_resizingBitmap; +#endif + +#if PLATFORM(WIN_OS) + HWND m_canvasWindow; + HDC m_canvasDC; + HGLRC m_contextObj; +#elif PLATFORM(CG) + CGLPBufferObj m_pbuffer; + CGLContextObj m_contextObj; + unsigned char* m_renderOutput; + CGContextRef m_cgContext; +#elif PLATFORM(LINUX) + Display* m_display; + GLXContext m_contextObj; + GLXPbuffer m_pbuffer; + // In order to avoid problems caused by linking against libGL, we + // dynamically look up all the symbols we need. + // http://code.google.com/p/chromium/issues/detail?id=16800 + void* m_libGL; + PFNGLXCHOOSEFBCONFIGPROC m_glXChooseFBConfig; + PFNGLXCREATENEWCONTEXTPROC m_glXCreateNewContext; + PFNGLXCREATEPBUFFERPROC m_glXCreatePbuffer; + PFNGLXDESTROYPBUFFERPROC m_glXDestroyPbuffer; + typedef Bool (* PFNGLXMAKECURRENTPROC)(Display* dpy, GLXDrawable drawable, GLXContext ctx); + PFNGLXMAKECURRENTPROC m_glXMakeCurrent; + typedef void (* PFNGLXDESTROYCONTEXTPROC)(Display* dpy, GLXContext ctx); + PFNGLXDESTROYCONTEXTPROC m_glXDestroyContext; + typedef GLXContext (* PFNGLXGETCURRENTCONTEXTPROC)(void); + PFNGLXGETCURRENTCONTEXTPROC m_glXGetCurrentContext; +#else + #error Must port GraphicsContext3D to your platform +#endif +}; + +GraphicsContext3DInternal::VertexAttribPointerState::VertexAttribPointerState() + : enabled(false) + , buffer(0) + , indx(0) + , size(0) + , type(0) + , normalized(false) + , stride(0) + , offset(0) +{ +} + +#if PLATFORM(LINUX) +static void* tryLoad(const char* libName) +{ + // We use RTLD_GLOBAL semantics so that GLEW initialization works; + // GLEW expects to be able to open the current process's handle + // and do dlsym's of GL entry points from there. + return dlopen(libName, RTLD_LAZY | RTLD_GLOBAL); +} +#endif + +GraphicsContext3DInternal::GraphicsContext3DInternal() + : m_texture(0) + , m_fbo(0) + , m_depthBuffer(0) +#ifdef FLIP_FRAMEBUFFER_VERTICALLY + , m_scanline(0) +#endif + , m_boundArrayBuffer(0) +#if PLATFORM(SKIA) + , m_resizingBitmap(0) +#endif +#if PLATFORM(WIN_OS) + , m_canvasWindow(0) + , m_canvasDC(0) + , m_contextObj(0) +#elif PLATFORM(CG) + , m_pbuffer(0) + , m_contextObj(0) + , m_renderOutput(0) + , m_cgContext(0) +#elif PLATFORM(LINUX) + , m_display(0) + , m_contextObj(0) + , m_pbuffer(0) + , m_glXChooseFBConfig(0) + , m_glXCreateNewContext(0) + , m_glXCreatePbuffer(0) + , m_glXDestroyPbuffer(0) + , m_glXMakeCurrent(0) + , m_glXDestroyContext(0) + , m_glXGetCurrentContext(0) +#else +#error Must port to your platform +#endif +{ +#if PLATFORM(WIN_OS) + WNDCLASS wc; + if (!GetClassInfo(GetModuleHandle(0), L"CANVASGL", &wc)) { + ZeroMemory(&wc, sizeof(WNDCLASS)); + wc.style = CS_OWNDC; + wc.hInstance = GetModuleHandle(0); + wc.lpfnWndProc = DefWindowProc; + wc.lpszClassName = L"CANVASGL"; + + if (!RegisterClass(&wc)) { + printf("GraphicsContext3D: RegisterClass failed\n"); + return; + } + } + + m_canvasWindow = CreateWindow(L"CANVASGL", L"CANVASGL", + WS_CAPTION, + CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, + CW_USEDEFAULT, 0, 0, GetModuleHandle(0), 0); + if (!m_canvasWindow) { + printf("GraphicsContext3DInternal: CreateWindow failed\n"); + return; + } + + // get the device context + m_canvasDC = GetDC(m_canvasWindow); + if (!m_canvasDC) { + printf("GraphicsContext3DInternal: GetDC failed\n"); + return; + } + + // find default pixel format + PIXELFORMATDESCRIPTOR pfd; + ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR)); + pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); + pfd.nVersion = 1; + pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL +#ifdef RENDER_TO_DEBUGGING_WINDOW + | PFD_DOUBLEBUFFER +#endif // RENDER_TO_DEBUGGING_WINDOW + ; + int pixelformat = ChoosePixelFormat(m_canvasDC, &pfd); + + // set the pixel format for the dc + if (!SetPixelFormat(m_canvasDC, pixelformat, &pfd)) { + printf("GraphicsContext3D: SetPixelFormat failed\n"); + return; + } + + // create rendering context + m_contextObj = wglCreateContext(m_canvasDC); + if (!m_contextObj) { + printf("GraphicsContext3D: wglCreateContext failed\n"); + return; + } + + if (!wglMakeCurrent(m_canvasDC, m_contextObj)) { + printf("GraphicsContext3D: wglMakeCurrent failed\n"); + return; + } + +#ifdef RENDER_TO_DEBUGGING_WINDOW + typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval); + PFNWGLSWAPINTERVALEXTPROC setSwapInterval = 0; + setSwapInterval = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT"); + if (setSwapInterval) + setSwapInterval(1); +#endif // RENDER_TO_DEBUGGING_WINDOW + +#elif PLATFORM(CG) + // Create a 1x1 pbuffer and associated context to bootstrap things + CGLPixelFormatAttribute attribs[] = { + (CGLPixelFormatAttribute) kCGLPFAPBuffer, + (CGLPixelFormatAttribute) 0 + }; + CGLPixelFormatObj pixelFormat; + GLint numPixelFormats; + if (CGLChoosePixelFormat(attribs, &pixelFormat, &numPixelFormats) != kCGLNoError) { + printf("GraphicsContext3D: error choosing pixel format\n"); + return; + } + if (!pixelFormat) { + printf("GraphicsContext3D: no pixel format selected\n"); + return; + } + CGLContextObj context; + CGLError res = CGLCreateContext(pixelFormat, 0, &context); + CGLDestroyPixelFormat(pixelFormat); + if (res != kCGLNoError) { + printf("GraphicsContext3D: error creating context\n"); + return; + } + CGLPBufferObj pbuffer; + if (CGLCreatePBuffer(1, 1, GL_TEXTURE_2D, GL_RGBA, 0, &pbuffer) != kCGLNoError) { + CGLDestroyContext(context); + printf("GraphicsContext3D: error creating pbuffer\n"); + return; + } + if (CGLSetPBuffer(context, pbuffer, 0, 0, 0) != kCGLNoError) { + CGLDestroyContext(context); + CGLDestroyPBuffer(pbuffer); + printf("GraphicsContext3D: error attaching pbuffer to context\n"); + return; + } + if (CGLSetCurrentContext(context) != kCGLNoError) { + CGLDestroyContext(context); + CGLDestroyPBuffer(pbuffer); + printf("GraphicsContext3D: error making context current\n"); + return; + } + m_pbuffer = pbuffer; + m_contextObj = context; +#elif PLATFORM(LINUX) + m_display = XOpenDisplay(0); + if (!m_display) { + printf("GraphicsContext3D: error opening X display\n"); + return; + } + + const char* libNames[] = { + "/usr/lib/libGL.so.1", + "/usr/lib32/libGL.so.1", + "/usr/lib64/libGL.so.1", + }; + for (int i = 0; i < sizeof(libNames) / sizeof(const char*); i++) { + m_libGL = tryLoad(libNames[i]); + if (m_libGL) + break; + } + if (!m_libGL) { + printf("GraphicsContext3D: error opening libGL.so.1\n"); + printf("GraphicsContext3D: tried:"); + for (int i = 0; i < sizeof(libNames) / sizeof(const char*); i++) + printf(" %s", libNames[i]); + return; + } + m_glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC) dlsym(m_libGL, "glXChooseFBConfig"); + m_glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC) dlsym(m_libGL, "glXCreateNewContext"); + m_glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC) dlsym(m_libGL, "glXCreatePbuffer"); + m_glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC) dlsym(m_libGL, "glXDestroyPbuffer"); + m_glXMakeCurrent = (PFNGLXMAKECURRENTPROC) dlsym(m_libGL, "glXMakeCurrent"); + m_glXDestroyContext = (PFNGLXDESTROYCONTEXTPROC) dlsym(m_libGL, "glXDestroyContext"); + m_glXGetCurrentContext = (PFNGLXGETCURRENTCONTEXTPROC) dlsym(m_libGL, "glXGetCurrentContext"); + if (!m_glXChooseFBConfig || !m_glXCreateNewContext || !m_glXCreatePbuffer + || !m_glXDestroyPbuffer || !m_glXMakeCurrent || !m_glXDestroyContext + || !m_glXGetCurrentContext) { + printf("GraphicsContext3D: error looking up bootstrapping entry points\n"); + return; + } + int configAttrs[] = { + GLX_DRAWABLE_TYPE, + GLX_PBUFFER_BIT, + GLX_RENDER_TYPE, + GLX_RGBA_BIT, + GLX_DOUBLEBUFFER, + 0, + 0 + }; + int nelements = 0; + GLXFBConfig* config = m_glXChooseFBConfig(m_display, 0, configAttrs, &nelements); + if (!config) { + printf("GraphicsContext3D: glXChooseFBConfig failed\n"); + return; + } + if (!nelements) { + printf("GraphicsContext3D: glXChooseFBConfig returned 0 elements\n"); + XFree(config); + return; + } + GLXContext context = m_glXCreateNewContext(m_display, config[0], GLX_RGBA_TYPE, 0, True); + if (!context) { + printf("GraphicsContext3D: glXCreateNewContext failed\n"); + XFree(config); + return; + } + int pbufferAttrs[] = { + GLX_PBUFFER_WIDTH, + 1, + GLX_PBUFFER_HEIGHT, + 1, + 0 + }; + GLXPbuffer pbuffer = m_glXCreatePbuffer(m_display, config[0], pbufferAttrs); + XFree(config); + if (!pbuffer) { + printf("GraphicsContext3D: glxCreatePbuffer failed\n"); + return; + } + if (!m_glXMakeCurrent(m_display, pbuffer, context)) { + printf("GraphicsContext3D: glXMakeCurrent failed\n"); + return; + } + m_contextObj = context; + m_pbuffer = pbuffer; +#else +#error Must port to your platform +#endif + + static bool initializedGLEW = false; + if (!initializedGLEW) { + // Initialize GLEW and check for GL 2.0 support by the drivers. + GLenum glewInitResult = glewInit(); + if (glewInitResult != GLEW_OK) { + printf("GraphicsContext3D: GLEW initialization failed\n"); + return; + } + if (!glewIsSupported("GL_VERSION_2_0")) { + printf("GraphicsContext3D: OpenGL 2.0 not supported\n"); + return; + } + initializedGLEW = true; + } +} + +GraphicsContext3DInternal::~GraphicsContext3DInternal() +{ + makeContextCurrent(); +#ifndef RENDER_TO_DEBUGGING_WINDOW + glDeleteRenderbuffersEXT(1, &m_depthBuffer); + glDeleteTextures(1, &m_texture); +#ifdef FLIP_FRAMEBUFFER_VERTICALLY + if (m_scanline) + delete[] m_scanline; +#endif + glDeleteFramebuffersEXT(1, &m_fbo); +#endif // !RENDER_TO_DEBUGGING_WINDOW +#if PLATFORM(SKIA) + if (m_resizingBitmap) + delete m_resizingBitmap; +#endif +#if PLATFORM(WIN_OS) + wglMakeCurrent(0, 0); + wglDeleteContext(m_contextObj); + ReleaseDC(m_canvasWindow, m_canvasDC); + DestroyWindow(m_canvasWindow); +#elif PLATFORM(CG) + CGLSetCurrentContext(0); + CGLDestroyContext(m_contextObj); + CGLDestroyPBuffer(m_pbuffer); + if (m_cgContext) + CGContextRelease(m_cgContext); + if (m_renderOutput) + delete[] m_renderOutput; +#elif PLATFORM(LINUX) + m_glXMakeCurrent(m_display, 0, 0); + m_glXDestroyContext(m_display, m_contextObj); + m_glXDestroyPbuffer(m_display, m_pbuffer); + XCloseDisplay(m_display); + dlclose(m_libGL); +#else +#error Must port to your platform +#endif + m_contextObj = 0; +} + +bool GraphicsContext3DInternal::makeContextCurrent() +{ +#if PLATFORM(WIN_OS) + if (wglGetCurrentContext() != m_contextObj) + if (wglMakeCurrent(m_canvasDC, m_contextObj)) + return true; +#elif PLATFORM(CG) + if (CGLGetCurrentContext() != m_contextObj) + if (CGLSetCurrentContext(m_contextObj) == kCGLNoError) + return true; +#elif PLATFORM(LINUX) + if (m_glXGetCurrentContext() != m_contextObj) + if (m_glXMakeCurrent(m_display, m_pbuffer, m_contextObj)) + return true; +#else +#error Must port to your platform +#endif + return false; +} + +PlatformGraphicsContext3D GraphicsContext3DInternal::platformGraphicsContext3D() const +{ + return m_contextObj; +} + +Platform3DObject GraphicsContext3DInternal::platformTexture() const +{ + return m_texture; +} + +static int createTextureObject(GLenum target) +{ + GLuint texture = 0; + glGenTextures(1, &texture); + glBindTexture(target, texture); + glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + return texture; +} + +void GraphicsContext3DInternal::reshape(int width, int height) +{ +#ifdef RENDER_TO_DEBUGGING_WINDOW + SetWindowPos(m_canvasWindow, HWND_TOP, 0, 0, width, height, + SWP_NOMOVE); + ShowWindow(m_canvasWindow, SW_SHOW); +#endif + + m_cachedWidth = width; + m_cachedHeight = height; + makeContextCurrent(); + +#ifndef RENDER_TO_DEBUGGING_WINDOW +#ifdef USE_TEXTURE_RECTANGLE_FOR_FRAMEBUFFER + // GL_TEXTURE_RECTANGLE_ARB is the best supported render target on Mac OS X + GLenum target = GL_TEXTURE_RECTANGLE_ARB; +#else + GLenum target = GL_TEXTURE_2D; +#endif + if (!m_texture) { + // Generate the texture object + m_texture = createTextureObject(target); + // Generate the framebuffer object + glGenFramebuffersEXT(1, &m_fbo); + // Generate the depth buffer + glGenRenderbuffersEXT(1, &m_depthBuffer); + } + + // Reallocate the color and depth buffers + glBindTexture(target, m_texture); + glTexImage2D(target, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); + glBindTexture(target, 0); + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); + glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthBuffer); + glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height); + glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); + + glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, m_texture, 0); + glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBuffer); + GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { + printf("GraphicsContext3D: framebuffer was incomplete\n"); + + // FIXME: cleanup. + notImplemented(); + } +#endif // RENDER_TO_DEBUGGING_WINDOW + +#ifdef FLIP_FRAMEBUFFER_VERTICALLY + if (m_scanline) { + delete[] m_scanline; + m_scanline = 0; + } + m_scanline = new unsigned char[width * 4]; +#endif // FLIP_FRAMEBUFFER_VERTICALLY + + glClear(GL_COLOR_BUFFER_BIT); + viewportImpl(0, 0, width, height); + +#if PLATFORM(CG) + // Need to reallocate the client-side backing store. + // FIXME: make this more efficient. + if (m_cgContext) { + CGContextRelease(m_cgContext); + m_cgContext = 0; + } + if (m_renderOutput) { + delete[] m_renderOutput; + m_renderOutput = 0; + } + int rowBytes = width * 4; + m_renderOutput = new unsigned char[height * rowBytes]; + CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); + m_cgContext = CGBitmapContextCreate(m_renderOutput, width, height, 8, rowBytes, + colorSpace, kCGImageAlphaPremultipliedLast); + CGColorSpaceRelease(colorSpace); +#endif // PLATFORM(CG) +} + +#ifdef FLIP_FRAMEBUFFER_VERTICALLY +void GraphicsContext3DInternal::flipVertically(unsigned char* framebuffer, + unsigned int width, + unsigned int height) +{ + unsigned char* scanline = m_scanline; + if (!scanline) + return; + unsigned int rowBytes = width * 4; + unsigned int count = height / 2; + for (unsigned int i = 0; i < count; i++) { + unsigned char* rowA = framebuffer + i * rowBytes; + unsigned char* rowB = framebuffer + (height - i - 1) * rowBytes; + // FIXME: this is where the multiplication of the alpha + // channel into the color buffer will need to occur if the + // user specifies the "premultiplyAlpha" flag in the context + // creation attributes. + memcpy(scanline, rowB, rowBytes); + memcpy(rowB, rowA, rowBytes); + memcpy(rowA, scanline, rowBytes); + } +} +#endif + +void GraphicsContext3DInternal::beginPaint(WebGLRenderingContext* context) +{ + makeContextCurrent(); + +#ifdef RENDER_TO_DEBUGGING_WINDOW + SwapBuffers(m_canvasDC); +#else + // Earlier versions of this code used the GPU to flip the + // framebuffer vertically before reading it back for compositing + // via software. This code was quite complicated, used a lot of + // GPU memory, and didn't provide an obvious speedup. Since this + // vertical flip is only a temporary solution anyway until Chrome + // is fully GPU composited, it wasn't worth the complexity. + + HTMLCanvasElement* canvas = context->canvas(); + ImageBuffer* imageBuffer = canvas->buffer(); + unsigned char* pixels = 0; +#if PLATFORM(SKIA) + const SkBitmap* canvasBitmap = imageBuffer->context()->platformContext()->bitmap(); + const SkBitmap* readbackBitmap = 0; + ASSERT(canvasBitmap->config() == SkBitmap::kARGB_8888_Config); + if (canvasBitmap->width() == m_cachedWidth && canvasBitmap->height() == m_cachedHeight) { + // This is the fastest and most common case. We read back + // directly into the canvas's backing store. + readbackBitmap = canvasBitmap; + if (m_resizingBitmap) { + delete m_resizingBitmap; + m_resizingBitmap = 0; + } + } else { + // We need to allocate a temporary bitmap for reading back the + // pixel data. We will then use Skia to rescale this bitmap to + // the size of the canvas's backing store. + if (m_resizingBitmap && (m_resizingBitmap->width() != m_cachedWidth || m_resizingBitmap->height() != m_cachedHeight)) { + delete m_resizingBitmap; + m_resizingBitmap = 0; + } + if (!m_resizingBitmap) { + m_resizingBitmap = new SkBitmap(); + m_resizingBitmap->setConfig(SkBitmap::kARGB_8888_Config, + m_cachedWidth, + m_cachedHeight); + if (!m_resizingBitmap->allocPixels()) { + delete m_resizingBitmap; + m_resizingBitmap = 0; + return; + } + } + readbackBitmap = m_resizingBitmap; + } + + // Read back the frame buffer. + SkAutoLockPixels bitmapLock(*readbackBitmap); + pixels = static_cast<unsigned char*>(readbackBitmap->getPixels()); + glReadPixels(0, 0, m_cachedWidth, m_cachedHeight, GL_BGRA, GL_UNSIGNED_BYTE, pixels); +#elif PLATFORM(CG) + if (m_renderOutput) { + ASSERT(CGBitmapContextGetWidth(m_cgContext) == m_cachedWidth); + ASSERT(CGBitmapContextGetHeight(m_cgContext) == m_cachedHeight); + pixels = m_renderOutput; + glReadPixels(0, 0, m_cachedWidth, m_cachedHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels); + } +#else +#error Must port to your platform +#endif + +#ifdef FLIP_FRAMEBUFFER_VERTICALLY + if (pixels) + flipVertically(pixels, m_cachedWidth, m_cachedHeight); +#endif + +#if PLATFORM(SKIA) + if (m_resizingBitmap) { + // We need to draw the resizing bitmap into the canvas's backing store. + SkCanvas canvas(*canvasBitmap); + SkRect dst; + dst.set(0, 0, canvasBitmap->width(), canvasBitmap->height()); + canvas.drawBitmapRect(*m_resizingBitmap, 0, dst); + } +#elif PLATFORM(CG) + if (m_renderOutput) { + CGImageRef cgImage = CGBitmapContextCreateImage(m_cgContext); + // CSS styling may cause the canvas's content to be resized on + // the page. Go back to the Canvas to figure out the correct + // width and height to draw. + CGRect rect = CGRectMake(0, 0, + context->canvas()->width(), + context->canvas()->height()); + // We want to completely overwrite the previous frame's + // rendering results. + CGContextSetBlendMode(imageBuffer->context()->platformContext(), + kCGBlendModeCopy); + CGContextDrawImage(imageBuffer->context()->platformContext(), + rect, cgImage); + CGImageRelease(cgImage); + } +#else +#error Must port to your platform +#endif + +#endif // RENDER_TO_DEBUGGING_WINDOW +} + +void GraphicsContext3DInternal::activeTexture(unsigned long texture) +{ + // FIXME: query number of textures available. + if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0+32) + // FIXME: raise exception. + return; + + makeContextCurrent(); + glActiveTexture(texture); +} + +void GraphicsContext3DInternal::bindBuffer(unsigned long target, + WebGLBuffer* buffer) +{ + makeContextCurrent(); + GLuint bufID = EXTRACT(buffer); + if (target == GL_ARRAY_BUFFER) + m_boundArrayBuffer = bufID; + glBindBuffer(target, bufID); +} + +// If we didn't have to hack GL_TEXTURE_WRAP_R for cube maps, +// we could just use: +// GL_SAME_METHOD_2_X2(BindTexture, bindTexture, unsigned long, WebGLTexture*) +void GraphicsContext3DInternal::bindTexture(unsigned long target, + WebGLTexture* texture) +{ + makeContextCurrent(); + unsigned int textureObject = EXTRACT(texture); + + glBindTexture(target, textureObject); + + // FIXME: GL_TEXTURE_WRAP_R isn't exposed in the OpenGL ES 2.0 + // API. On desktop OpenGL implementations it seems necessary to + // set this wrap mode to GL_CLAMP_TO_EDGE to get correct behavior + // of cube maps. + if (texture) { + if (target == GL_TEXTURE_CUBE_MAP) { + if (!texture->isCubeMapRWrapModeInitialized()) { + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); + texture->setCubeMapRWrapModeInitialized(true); + } + } else + texture->setCubeMapRWrapModeInitialized(false); + } +} + +void GraphicsContext3DInternal::bufferDataImpl(unsigned long target, int size, const void* data, unsigned long usage) +{ + makeContextCurrent(); + // FIXME: make this verification more efficient. + GLint binding = 0; + GLenum binding_target = GL_ARRAY_BUFFER_BINDING; + if (target == GL_ELEMENT_ARRAY_BUFFER) + binding_target = GL_ELEMENT_ARRAY_BUFFER_BINDING; + glGetIntegerv(binding_target, &binding); + if (binding <= 0) { + // FIXME: raise exception. + // LogMessagef(("bufferData: no buffer bound")); + return; + } + + glBufferData(target, + size, + data, + usage); +} + +void GraphicsContext3DInternal::disableVertexAttribArray(unsigned long index) +{ + makeContextCurrent(); + if (index < NumTrackedPointerStates) + m_vertexAttribPointerState[index].enabled = false; + glDisableVertexAttribArray(index); +} + +void GraphicsContext3DInternal::enableVertexAttribArray(unsigned long index) +{ + makeContextCurrent(); + if (index < NumTrackedPointerStates) + m_vertexAttribPointerState[index].enabled = true; + glEnableVertexAttribArray(index); +} + +unsigned long GraphicsContext3DInternal::getError() +{ + if (m_syntheticErrors.size() > 0) { + ListHashSet<unsigned long>::iterator iter = m_syntheticErrors.begin(); + unsigned long err = *iter; + m_syntheticErrors.remove(iter); + return err; + } + + makeContextCurrent(); + return glGetError(); +} + +void GraphicsContext3DInternal::vertexAttribPointer(unsigned long indx, int size, int type, bool normalized, + unsigned long stride, unsigned long offset) +{ + makeContextCurrent(); + + if (m_boundArrayBuffer <= 0) { + // FIXME: raise exception. + // LogMessagef(("bufferData: no buffer bound")); + return; + } + + if (indx < NumTrackedPointerStates) { + VertexAttribPointerState& state = m_vertexAttribPointerState[indx]; + state.buffer = m_boundArrayBuffer; + state.indx = indx; + state.size = size; + state.type = type; + state.normalized = normalized; + state.stride = stride; + state.offset = offset; + } + + glVertexAttribPointer(indx, size, type, normalized, stride, + reinterpret_cast<void*>(static_cast<intptr_t>(offset))); +} + +void GraphicsContext3DInternal::viewportImpl(long x, long y, unsigned long width, unsigned long height) +{ + glViewport(x, y, width, height); +} + +void GraphicsContext3DInternal::synthesizeGLError(unsigned long error) +{ + m_syntheticErrors.add(error); +} + +// GraphicsContext3D ----------------------------------------------------- + +/* Helper macros for when we're just wrapping a gl method, so that + * we can avoid having to type this 500 times. Note that these MUST + * NOT BE USED if we need to check any of the parameters. + */ + +#define GL_SAME_METHOD_0(glname, name) \ +void GraphicsContext3D::name() \ +{ \ + makeContextCurrent(); \ + gl##glname(); \ +} + +#define GL_SAME_METHOD_1(glname, name, t1) \ +void GraphicsContext3D::name(t1 a1) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1); \ +} + +#define GL_SAME_METHOD_1_X(glname, name, t1) \ +void GraphicsContext3D::name(t1 a1) \ +{ \ + makeContextCurrent(); \ + gl##glname(EXTRACT(a1)); \ +} + +#define GL_SAME_METHOD_2(glname, name, t1, t2) \ +void GraphicsContext3D::name(t1 a1, t2 a2) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, a2); \ +} + +#define GL_SAME_METHOD_2_X12(glname, name, t1, t2) \ +void GraphicsContext3D::name(t1 a1, t2 a2) \ +{ \ + makeContextCurrent(); \ + gl##glname(EXTRACT(a1), EXTRACT(a2)); \ +} + +#define GL_SAME_METHOD_2_X2(glname, name, t1, t2) \ +void GraphicsContext3D::name(t1 a1, t2 a2) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, EXTRACT(a2)); \ +} + +#define GL_SAME_METHOD_3(glname, name, t1, t2, t3) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, a2, a3); \ +} + +#define GL_SAME_METHOD_3_X12(glname, name, t1, t2, t3) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3) \ +{ \ + makeContextCurrent(); \ + gl##glname(EXTRACT(a1), EXTRACT(a2), a3); \ +} + +#define GL_SAME_METHOD_3_X2(glname, name, t1, t2, t3) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, EXTRACT(a2), a3); \ +} + +#define GL_SAME_METHOD_4(glname, name, t1, t2, t3, t4) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3, t4 a4) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, a2, a3, a4); \ +} + +#define GL_SAME_METHOD_4_X4(glname, name, t1, t2, t3, t4) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3, t4 a4) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, a2, a3, EXTRACT(a4)); \ +} + +#define GL_SAME_METHOD_5(glname, name, t1, t2, t3, t4, t5) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, a2, a3, a4, a5); \ +} + +#define GL_SAME_METHOD_5_X4(glname, name, t1, t2, t3, t4, t5) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, a2, a3, EXTRACT(a4), a5); \ +} + +#define GL_SAME_METHOD_6(glname, name, t1, t2, t3, t4, t5, t6) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, a2, a3, a4, a5, a6); \ +} + +#define GL_SAME_METHOD_8(glname, name, t1, t2, t3, t4, t5, t6, t7, t8) \ +void GraphicsContext3D::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6, t7 a7, t8 a8) \ +{ \ + makeContextCurrent(); \ + gl##glname(a1, a2, a3, a4, a5, a6, a7, a8); \ +} + +PassOwnPtr<GraphicsContext3D> GraphicsContext3D::create() +{ + PassOwnPtr<GraphicsContext3D> context = new GraphicsContext3D(); + // FIXME: add error checking + return context; +} + +GraphicsContext3D::GraphicsContext3D() + : m_currentWidth(0) + , m_currentHeight(0) + , m_internal(new GraphicsContext3DInternal()) +{ +} + +GraphicsContext3D::~GraphicsContext3D() +{ +} + +PlatformGraphicsContext3D GraphicsContext3D::platformGraphicsContext3D() const +{ + return m_internal->platformGraphicsContext3D(); +} + +Platform3DObject GraphicsContext3D::platformTexture() const +{ + return m_internal->platformTexture(); +} + +void GraphicsContext3D::makeContextCurrent() +{ + m_internal->makeContextCurrent(); +} + +void GraphicsContext3D::reshape(int width, int height) +{ + if (width == m_currentWidth && height == m_currentHeight) + return; + + m_currentWidth = width; + m_currentHeight = height; + + m_internal->reshape(width, height); +} + +void GraphicsContext3D::beginPaint(WebGLRenderingContext* context) +{ + m_internal->beginPaint(context); +} + +void GraphicsContext3D::endPaint() +{ +} + +int GraphicsContext3D::sizeInBytes(int type) +{ + switch (type) { + case GL_BYTE: + return sizeof(GLbyte); + case GL_UNSIGNED_BYTE: + return sizeof(GLubyte); + case GL_SHORT: + return sizeof(GLshort); + case GL_UNSIGNED_SHORT: + return sizeof(GLushort); + case GL_INT: + return sizeof(GLint); + case GL_UNSIGNED_INT: + return sizeof(GLuint); + case GL_FLOAT: + return sizeof(GLfloat); + default: // FIXME: default cases are discouraged in WebKit. + return 0; + } +} + +unsigned GraphicsContext3D::createBuffer() +{ + makeContextCurrent(); + GLuint o; + glGenBuffers(1, &o); + return o; +} + +unsigned GraphicsContext3D::createFramebuffer() +{ + makeContextCurrent(); + GLuint o = 0; + glGenFramebuffersEXT(1, &o); + return o; +} + +unsigned GraphicsContext3D::createProgram() +{ + makeContextCurrent(); + return glCreateProgram(); +} + +unsigned GraphicsContext3D::createRenderbuffer() +{ + makeContextCurrent(); + GLuint o; + glGenRenderbuffersEXT(1, &o); + return o; +} + +unsigned GraphicsContext3D::createShader(unsigned long type) +{ + makeContextCurrent(); + return glCreateShader((type == FRAGMENT_SHADER) ? GL_FRAGMENT_SHADER : GL_VERTEX_SHADER); +} + +unsigned GraphicsContext3D::createTexture() +{ + makeContextCurrent(); + GLuint o; + glGenTextures(1, &o); + return o; +} + +void GraphicsContext3D::deleteBuffer(unsigned buffer) +{ + makeContextCurrent(); + glDeleteBuffers(1, &buffer); +} + +void GraphicsContext3D::deleteFramebuffer(unsigned framebuffer) +{ + makeContextCurrent(); + glDeleteFramebuffersEXT(1, &framebuffer); +} + +void GraphicsContext3D::deleteProgram(unsigned program) +{ + makeContextCurrent(); + glDeleteProgram(program); +} + +void GraphicsContext3D::deleteRenderbuffer(unsigned renderbuffer) +{ + makeContextCurrent(); + glDeleteRenderbuffersEXT(1, &renderbuffer); +} + +void GraphicsContext3D::deleteShader(unsigned shader) +{ + makeContextCurrent(); + glDeleteShader(shader); +} + +void GraphicsContext3D::deleteTexture(unsigned texture) +{ + makeContextCurrent(); + glDeleteTextures(1, &texture); +} + +void GraphicsContext3D::activeTexture(unsigned long texture) +{ + m_internal->activeTexture(texture); +} + +GL_SAME_METHOD_2_X12(AttachShader, attachShader, WebGLProgram*, WebGLShader*) + +void GraphicsContext3D::bindAttribLocation(WebGLProgram* program, + unsigned long index, + const String& name) +{ + if (!program) + return; + makeContextCurrent(); + glBindAttribLocation(EXTRACT(program), index, name.utf8().data()); +} + +void GraphicsContext3D::bindBuffer(unsigned long target, + WebGLBuffer* buffer) +{ + m_internal->bindBuffer(target, buffer); +} + +GL_SAME_METHOD_2_X2(BindFramebufferEXT, bindFramebuffer, unsigned long, WebGLFramebuffer*) + +GL_SAME_METHOD_2_X2(BindRenderbufferEXT, bindRenderbuffer, unsigned long, WebGLRenderbuffer*) + +// If we didn't have to hack GL_TEXTURE_WRAP_R for cube maps, +// we could just use: +// GL_SAME_METHOD_2_X2(BindTexture, bindTexture, unsigned long, WebGLTexture*) +void GraphicsContext3D::bindTexture(unsigned long target, + WebGLTexture* texture) +{ + m_internal->bindTexture(target, texture); +} + +GL_SAME_METHOD_4(BlendColor, blendColor, double, double, double, double) + +GL_SAME_METHOD_1(BlendEquation, blendEquation, unsigned long) + +GL_SAME_METHOD_2(BlendEquationSeparate, blendEquationSeparate, unsigned long, unsigned long) + +GL_SAME_METHOD_2(BlendFunc, blendFunc, unsigned long, unsigned long) + +GL_SAME_METHOD_4(BlendFuncSeparate, blendFuncSeparate, unsigned long, unsigned long, unsigned long, unsigned long) + +void GraphicsContext3D::bufferData(unsigned long target, int size, unsigned long usage) +{ + m_internal->bufferDataImpl(target, size, 0, usage); +} + +void GraphicsContext3D::bufferData(unsigned long target, WebGLArray* array, unsigned long usage) +{ + m_internal->bufferDataImpl(target, array->byteLength(), array->baseAddress(), usage); +} + +void GraphicsContext3D::bufferSubData(unsigned long target, long offset, WebGLArray* array) +{ + if (!array || !array->length()) + return; + + makeContextCurrent(); + // FIXME: make this verification more efficient. + GLint binding = 0; + GLenum binding_target = GL_ARRAY_BUFFER_BINDING; + if (target == GL_ELEMENT_ARRAY_BUFFER) + binding_target = GL_ELEMENT_ARRAY_BUFFER_BINDING; + glGetIntegerv(binding_target, &binding); + if (binding <= 0) { + // FIXME: raise exception. + // LogMessagef(("bufferSubData: no buffer bound")); + return; + } + glBufferSubData(target, offset, array->byteLength(), array->baseAddress()); +} + +unsigned long GraphicsContext3D::checkFramebufferStatus(unsigned long target) +{ + makeContextCurrent(); + return glCheckFramebufferStatusEXT(target); +} + +GL_SAME_METHOD_1(Clear, clear, unsigned long) + +GL_SAME_METHOD_4(ClearColor, clearColor, double, double, double, double) + +GL_SAME_METHOD_1(ClearDepth, clearDepth, double) + +GL_SAME_METHOD_1(ClearStencil, clearStencil, long) + +GL_SAME_METHOD_4(ColorMask, colorMask, bool, bool, bool, bool) + +GL_SAME_METHOD_1_X(CompileShader, compileShader, WebGLShader*) + +GL_SAME_METHOD_8(CopyTexImage2D, copyTexImage2D, unsigned long, long, unsigned long, long, long, unsigned long, unsigned long, long) + +GL_SAME_METHOD_8(CopyTexSubImage2D, copyTexSubImage2D, unsigned long, long, long, long, long, long, unsigned long, unsigned long) + +GL_SAME_METHOD_1(CullFace, cullFace, unsigned long) + +GL_SAME_METHOD_1(DepthFunc, depthFunc, unsigned long) + +GL_SAME_METHOD_1(DepthMask, depthMask, bool) + +GL_SAME_METHOD_2(DepthRange, depthRange, double, double) + +void GraphicsContext3D::detachShader(WebGLProgram* program, WebGLShader* shader) +{ + if (!program || !shader) + return; + + makeContextCurrent(); + glDetachShader(EXTRACT(program), EXTRACT(shader)); +} + +GL_SAME_METHOD_1(Disable, disable, unsigned long) + +void GraphicsContext3D::disableVertexAttribArray(unsigned long index) +{ + m_internal->disableVertexAttribArray(index); +} + +void GraphicsContext3D::drawArrays(unsigned long mode, long first, long count) +{ + switch (mode) { + case GL_TRIANGLES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + case GL_POINTS: + case GL_LINE_STRIP: + case GL_LINE_LOOP: + case GL_LINES: + break; + default: // FIXME: default cases are discouraged in WebKit. + // FIXME: output log message, raise exception. + // LogMessage(NS_LITERAL_CSTRING("drawArrays: invalid mode")); + // return NS_ERROR_DOM_SYNTAX_ERR; + return; + } + + if (first+count < first || first+count < count) { + // FIXME: output log message, raise exception. + // LogMessage(NS_LITERAL_CSTRING("drawArrays: overflow in first+count")); + // return NS_ERROR_INVALID_ARG; + return; + } + + // FIXME: validate against currently bound buffer. + // if (!ValidateBuffers(first+count)) + // return NS_ERROR_INVALID_ARG; + + makeContextCurrent(); + glDrawArrays(mode, first, count); +} + +void GraphicsContext3D::drawElements(unsigned long mode, unsigned long count, unsigned long type, long offset) +{ + makeContextCurrent(); + // FIXME: make this verification more efficient. + GLint binding = 0; + GLenum binding_target = GL_ELEMENT_ARRAY_BUFFER_BINDING; + glGetIntegerv(binding_target, &binding); + if (binding <= 0) { + // FIXME: raise exception. + // LogMessagef(("bufferData: no buffer bound")); + return; + } + glDrawElements(mode, count, type, + reinterpret_cast<void*>(static_cast<intptr_t>(offset))); +} + +GL_SAME_METHOD_1(Enable, enable, unsigned long) + +void GraphicsContext3D::enableVertexAttribArray(unsigned long index) +{ + m_internal->enableVertexAttribArray(index); +} + +GL_SAME_METHOD_0(Finish, finish) + +GL_SAME_METHOD_0(Flush, flush) + +GL_SAME_METHOD_4_X4(FramebufferRenderbufferEXT, framebufferRenderbuffer, unsigned long, unsigned long, unsigned long, WebGLRenderbuffer*) + +GL_SAME_METHOD_5_X4(FramebufferTexture2DEXT, framebufferTexture2D, unsigned long, unsigned long, unsigned long, WebGLTexture*, long) + +GL_SAME_METHOD_1(FrontFace, frontFace, unsigned long) + +void GraphicsContext3D::generateMipmap(unsigned long target) +{ + makeContextCurrent(); + if (glGenerateMipmapEXT) + glGenerateMipmapEXT(target); + // FIXME: provide alternative code path? This will be unpleasant + // to implement if glGenerateMipmapEXT is not available -- it will + // require a texture readback and re-upload. +} + +bool GraphicsContext3D::getActiveAttrib(WebGLProgram* program, unsigned long index, ActiveInfo& info) +{ + if (!program) { + synthesizeGLError(INVALID_VALUE); + return false; + } + GLint maxNameLength = -1; + glGetProgramiv(EXTRACT(program), GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxNameLength); + if (maxNameLength < 0) + return false; + GLchar* name = 0; + if (!tryFastMalloc(maxNameLength * sizeof(GLchar)).getValue(name)) { + synthesizeGLError(OUT_OF_MEMORY); + return false; + } + GLsizei length = 0; + GLint size = -1; + GLenum type = 0; + glGetActiveAttrib(EXTRACT(program), index, maxNameLength, + &length, &size, &type, name); + if (size < 0) { + fastFree(name); + return false; + } + info.name = String(name, length); + info.type = type; + info.size = size; + fastFree(name); + return true; +} + +bool GraphicsContext3D::getActiveUniform(WebGLProgram* program, unsigned long index, ActiveInfo& info) +{ + if (!program) { + synthesizeGLError(INVALID_VALUE); + return false; + } + GLint maxNameLength = -1; + glGetProgramiv(EXTRACT(program), GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength); + if (maxNameLength < 0) + return false; + GLchar* name = 0; + if (!tryFastMalloc(maxNameLength * sizeof(GLchar)).getValue(name)) { + synthesizeGLError(OUT_OF_MEMORY); + return false; + } + GLsizei length = 0; + GLint size = -1; + GLenum type = 0; + glGetActiveUniform(EXTRACT(program), index, maxNameLength, + &length, &size, &type, name); + if (size < 0) { + fastFree(name); + return false; + } + info.name = String(name, length); + info.type = type; + info.size = size; + fastFree(name); + return true; +} + +int GraphicsContext3D::getAttribLocation(WebGLProgram* program, const String& name) +{ + if (!program) + return -1; + + makeContextCurrent(); + return glGetAttribLocation(EXTRACT(program), name.utf8().data()); +} + +void GraphicsContext3D::getBooleanv(unsigned long pname, unsigned char* value) +{ + makeContextCurrent(); + glGetBooleanv(pname, value); +} + +void GraphicsContext3D::getBufferParameteriv(unsigned long target, unsigned long pname, int* value) +{ + makeContextCurrent(); + glGetBufferParameteriv(target, pname, value); +} + +unsigned long GraphicsContext3D::getError() +{ + return m_internal->getError(); +} + +void GraphicsContext3D::getFloatv(unsigned long pname, float* value) +{ + makeContextCurrent(); + glGetFloatv(pname, value); +} + +void GraphicsContext3D::getFramebufferAttachmentParameteriv(unsigned long target, + unsigned long attachment, + unsigned long pname, + int* value) +{ + makeContextCurrent(); + glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, value); +} + +void GraphicsContext3D::getIntegerv(unsigned long pname, int* value) +{ + makeContextCurrent(); + glGetIntegerv(pname, value); +} + +void GraphicsContext3D::getProgramiv(WebGLProgram* program, + unsigned long pname, + int* value) +{ + makeContextCurrent(); + glGetProgramiv(EXTRACT(program), pname, value); +} + +String GraphicsContext3D::getProgramInfoLog(WebGLProgram* program) +{ + makeContextCurrent(); + GLuint programID = EXTRACT(program); + GLint logLength; + glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &logLength); + if (!logLength) + return String(); + GLchar* log = 0; + if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log)) + return String(); + GLsizei returnedLogLength; + glGetProgramInfoLog(programID, logLength, &returnedLogLength, log); + ASSERT(logLength == returnedLogLength + 1); + String res = String(log, returnedLogLength); + fastFree(log); + return res; +} + +void GraphicsContext3D::getRenderbufferParameteriv(unsigned long target, + unsigned long pname, + int* value) +{ + makeContextCurrent(); + glGetRenderbufferParameterivEXT(target, pname, value); +} + +void GraphicsContext3D::getShaderiv(WebGLShader* shader, + unsigned long pname, + int* value) +{ + makeContextCurrent(); + glGetShaderiv(EXTRACT(shader), pname, value); +} + +String GraphicsContext3D::getShaderInfoLog(WebGLShader* shader) +{ + makeContextCurrent(); + GLuint shaderID = EXTRACT(shader); + GLint logLength; + glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &logLength); + if (!logLength) + return String(); + GLchar* log = 0; + if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log)) + return String(); + GLsizei returnedLogLength; + glGetShaderInfoLog(shaderID, logLength, &returnedLogLength, log); + ASSERT(logLength == returnedLogLength + 1); + String res = String(log, returnedLogLength); + fastFree(log); + return res; +} + +String GraphicsContext3D::getShaderSource(WebGLShader* shader) +{ + makeContextCurrent(); + GLuint shaderID = EXTRACT(shader); + GLint logLength; + glGetShaderiv(shaderID, GL_SHADER_SOURCE_LENGTH, &logLength); + if (!logLength) + return String(); + GLchar* log = 0; + if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log)) + return String(); + GLsizei returnedLogLength; + glGetShaderSource(shaderID, logLength, &returnedLogLength, log); + ASSERT(logLength == returnedLogLength + 1); + String res = String(log, returnedLogLength); + fastFree(log); + return res; +} + +String GraphicsContext3D::getString(unsigned long name) +{ + makeContextCurrent(); + return String(reinterpret_cast<const char*>(glGetString(name))); +} + +void GraphicsContext3D::getTexParameterfv(unsigned long target, unsigned long pname, float* value) +{ + makeContextCurrent(); + glGetTexParameterfv(target, pname, value); +} + +void GraphicsContext3D::getTexParameteriv(unsigned long target, unsigned long pname, int* value) +{ + makeContextCurrent(); + glGetTexParameteriv(target, pname, value); +} + +void GraphicsContext3D::getUniformfv(WebGLProgram* program, long location, float* value) +{ + makeContextCurrent(); + glGetUniformfv(EXTRACT(program), location, value); +} + +void GraphicsContext3D::getUniformiv(WebGLProgram* program, long location, int* value) +{ + makeContextCurrent(); + glGetUniformiv(EXTRACT(program), location, value); +} + +long GraphicsContext3D::getUniformLocation(WebGLProgram* program, const String& name) +{ + if (!program) + return -1; + + makeContextCurrent(); + return glGetUniformLocation(EXTRACT(program), name.utf8().data()); +} + +void GraphicsContext3D::getVertexAttribfv(unsigned long index, + unsigned long pname, + float* value) +{ + makeContextCurrent(); + glGetVertexAttribfv(index, pname, value); +} + +void GraphicsContext3D::getVertexAttribiv(unsigned long index, + unsigned long pname, + int* value) +{ + makeContextCurrent(); + glGetVertexAttribiv(index, pname, value); +} + +long GraphicsContext3D::getVertexAttribOffset(unsigned long index, unsigned long pname) +{ + // FIXME: implement. + notImplemented(); + return 0; +} + +GL_SAME_METHOD_2(Hint, hint, unsigned long, unsigned long); + +bool GraphicsContext3D::isBuffer(WebGLBuffer* buffer) +{ + makeContextCurrent(); + return glIsBuffer(EXTRACT(buffer)); +} + +bool GraphicsContext3D::isEnabled(unsigned long cap) +{ + makeContextCurrent(); + return glIsEnabled(cap); +} + +bool GraphicsContext3D::isFramebuffer(WebGLFramebuffer* framebuffer) +{ + makeContextCurrent(); + return glIsFramebufferEXT(EXTRACT(framebuffer)); +} + +bool GraphicsContext3D::isProgram(WebGLProgram* program) +{ + makeContextCurrent(); + return glIsProgram(EXTRACT(program)); +} + +bool GraphicsContext3D::isRenderbuffer(WebGLRenderbuffer* renderbuffer) +{ + makeContextCurrent(); + return glIsRenderbufferEXT(EXTRACT(renderbuffer)); +} + +bool GraphicsContext3D::isShader(WebGLShader* shader) +{ + makeContextCurrent(); + return glIsShader(EXTRACT(shader)); +} + +bool GraphicsContext3D::isTexture(WebGLTexture* texture) +{ + makeContextCurrent(); + return glIsTexture(EXTRACT(texture)); +} + +GL_SAME_METHOD_1(LineWidth, lineWidth, double) + +GL_SAME_METHOD_1_X(LinkProgram, linkProgram, WebGLProgram*) + +void GraphicsContext3D::pixelStorei(unsigned long pname, long param) +{ + if (pname != GL_PACK_ALIGNMENT && pname != GL_UNPACK_ALIGNMENT) { + // FIXME: Create a fake GL error and throw an exception. + return; + } + + makeContextCurrent(); + glPixelStorei(pname, param); +} + +GL_SAME_METHOD_2(PolygonOffset, polygonOffset, double, double) + +PassRefPtr<WebGLArray> GraphicsContext3D::readPixels(long x, long y, + unsigned long width, unsigned long height, + unsigned long format, unsigned long type) { + // FIXME: support more pixel formats and types. + if (!((format == GL_RGBA) && (type == GL_UNSIGNED_BYTE))) + return 0; + + // FIXME: take into account pack alignment. + RefPtr<WebGLUnsignedByteArray> array = WebGLUnsignedByteArray::create(width * height * 4); + glReadPixels(x, y, width, height, format, type, array->baseAddress()); + return array; +} + +void GraphicsContext3D::releaseShaderCompiler() +{ +} + +GL_SAME_METHOD_4(RenderbufferStorageEXT, renderbufferStorage, unsigned long, unsigned long, unsigned long, unsigned long) + +GL_SAME_METHOD_2(SampleCoverage, sampleCoverage, double, bool) + +GL_SAME_METHOD_4(Scissor, scissor, long, long, unsigned long, unsigned long) + +void GraphicsContext3D::shaderSource(WebGLShader* shader, const String& source) +{ + makeContextCurrent(); + CString str = source.utf8(); + const char* data = str.data(); + GLint length = str.length(); + glShaderSource(EXTRACT(shader), 1, &data, &length); +} + +GL_SAME_METHOD_3(StencilFunc, stencilFunc, unsigned long, long, unsigned long) + +GL_SAME_METHOD_4(StencilFuncSeparate, stencilFuncSeparate, unsigned long, unsigned long, long, unsigned long) + +GL_SAME_METHOD_1(StencilMask, stencilMask, unsigned long) + +GL_SAME_METHOD_2(StencilMaskSeparate, stencilMaskSeparate, unsigned long, unsigned long) + +GL_SAME_METHOD_3(StencilOp, stencilOp, unsigned long, unsigned long, unsigned long) + +GL_SAME_METHOD_4(StencilOpSeparate, stencilOpSeparate, unsigned long, unsigned long, unsigned long, unsigned long) + +void GraphicsContext3D::synthesizeGLError(unsigned long error) +{ + m_internal->synthesizeGLError(error); +} + +int GraphicsContext3D::texImage2D(unsigned target, + unsigned level, + unsigned internalformat, + unsigned width, + unsigned height, + unsigned border, + unsigned format, + unsigned type, + WebGLArray* pixels) +{ + // FIXME: must do validation similar to JOGL's to ensure that + // the incoming array is of the appropriate length. + glTexImage2D(target, + level, + internalformat, + width, + height, + border, + format, + type, + pixels->baseAddress()); + return 0; +} + +int GraphicsContext3D::texImage2D(unsigned target, + unsigned level, + unsigned internalformat, + unsigned width, + unsigned height, + unsigned border, + unsigned format, + unsigned type, + ImageData* pixels) +{ + // FIXME: implement. + notImplemented(); + return -1; +} + +// Remove premultiplied alpha from color channels. +// FIXME: this is lossy. Must retrieve original values from HTMLImageElement. +static void unmultiplyAlpha(unsigned char* rgbaData, int numPixels) +{ + for (int j = 0; j < numPixels; j++) { + float b = rgbaData[4*j+0] / 255.0f; + float g = rgbaData[4*j+1] / 255.0f; + float r = rgbaData[4*j+2] / 255.0f; + float a = rgbaData[4*j+3] / 255.0f; + if (a > 0.0f) { + b /= a; + g /= a; + r /= a; + b = (b > 1.0f) ? 1.0f : b; + g = (g > 1.0f) ? 1.0f : g; + r = (r > 1.0f) ? 1.0f : r; + rgbaData[4*j+0] = (unsigned char) (b * 255.0f); + rgbaData[4*j+1] = (unsigned char) (g * 255.0f); + rgbaData[4*j+2] = (unsigned char) (r * 255.0f); + } + } +} + +// FIXME: this must be changed to refer to the original image data +// rather than unmultiplying the alpha channel. +static int texImage2DHelper(unsigned target, unsigned level, + int width, int height, + int rowBytes, + bool flipY, + bool premultiplyAlpha, + GLenum format, + bool skipAlpha, + unsigned char* pixels) +{ + ASSERT(format == GL_RGBA || format == GL_BGRA); + GLint internalFormat = GL_RGBA8; + if (skipAlpha) { + internalFormat = GL_RGB8; + // Ignore the alpha channel + premultiplyAlpha = true; + } + if (flipY) { + // Need to flip images vertically. To avoid making a copy of + // the entire image, we perform a ton of glTexSubImage2D + // calls. FIXME: should rethink this strategy for efficiency. + glTexImage2D(target, level, internalFormat, + width, + height, + 0, + format, + GL_UNSIGNED_BYTE, + 0); + unsigned char* row = 0; + bool allocatedRow = false; + if (!premultiplyAlpha) { + row = new unsigned char[rowBytes]; + allocatedRow = true; + } + for (int i = 0; i < height; i++) { + if (premultiplyAlpha) + row = pixels + (rowBytes * i); + else { + memcpy(row, pixels + (rowBytes * i), rowBytes); + unmultiplyAlpha(row, width); + } + glTexSubImage2D(target, level, 0, height - i - 1, + width, 1, + format, + GL_UNSIGNED_BYTE, + row); + } + if (allocatedRow) + delete[] row; + } else { + // The pixels of cube maps' faces are defined with a top-down + // scanline ordering, unlike GL_TEXTURE_2D, so when uploading + // these, the above vertical flip is the wrong thing to do. + if (premultiplyAlpha) + glTexImage2D(target, level, internalFormat, + width, + height, + 0, + format, + GL_UNSIGNED_BYTE, + pixels); + else { + glTexImage2D(target, level, internalFormat, + width, + height, + 0, + format, + GL_UNSIGNED_BYTE, + 0); + unsigned char* row = new unsigned char[rowBytes]; + for (int i = 0; i < height; i++) { + memcpy(row, pixels + (rowBytes * i), rowBytes); + unmultiplyAlpha(row, width); + glTexSubImage2D(target, level, 0, i, + width, 1, + format, + GL_UNSIGNED_BYTE, + row); + } + delete[] row; + } + } + return 0; +} + +int GraphicsContext3D::texImage2D(unsigned target, unsigned level, Image* image, + bool flipY, bool premultiplyAlpha) +{ + ASSERT(image); + + int res = -1; +#if PLATFORM(SKIA) + NativeImageSkia* skiaImage = image->nativeImageForCurrentFrame(); + if (!skiaImage) { + ASSERT_NOT_REACHED(); + return -1; + } + SkBitmap::Config skiaConfig = skiaImage->config(); + // FIXME: must support more image configurations. + if (skiaConfig != SkBitmap::kARGB_8888_Config) { + ASSERT_NOT_REACHED(); + return -1; + } + SkBitmap& skiaImageRef = *skiaImage; + SkAutoLockPixels lock(skiaImageRef); + int width = skiaImage->width(); + int height = skiaImage->height(); + unsigned char* pixels = + reinterpret_cast<unsigned char*>(skiaImage->getPixels()); + int rowBytes = skiaImage->rowBytes(); + res = texImage2DHelper(target, level, + width, height, + rowBytes, + flipY, premultiplyAlpha, + GL_BGRA, + false, + pixels); +#elif PLATFORM(CG) + CGImageRef cgImage = image->nativeImageForCurrentFrame(); + if (!cgImage) { + ASSERT_NOT_REACHED(); + return -1; + } + int width = CGImageGetWidth(cgImage); + int height = CGImageGetHeight(cgImage); + int rowBytes = width * 4; + CGImageAlphaInfo info = CGImageGetAlphaInfo(cgImage); + bool skipAlpha = (info == kCGImageAlphaNone + || info == kCGImageAlphaNoneSkipLast + || info == kCGImageAlphaNoneSkipFirst); + unsigned char* imageData = new unsigned char[height * rowBytes]; + CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); + CGContextRef tmpContext = CGBitmapContextCreate(imageData, width, height, 8, rowBytes, + colorSpace, + kCGImageAlphaPremultipliedLast); + CGColorSpaceRelease(colorSpace); + CGContextDrawImage(tmpContext, + CGRectMake(0, 0, static_cast<CGFloat>(width), static_cast<CGFloat>(height)), + cgImage); + CGContextRelease(tmpContext); + res = texImage2DHelper(target, level, width, height, rowBytes, + flipY, premultiplyAlpha, GL_RGBA, skipAlpha, imageData); + delete[] imageData; +#else +#error Must port to your platform +#endif + return res; +} + +int GraphicsContext3D::texImage2D(unsigned target, unsigned level, HTMLVideoElement* video, + bool flipY, bool premultiplyAlpha) +{ + // FIXME: implement. + notImplemented(); + return -1; +} + +GL_SAME_METHOD_3(TexParameterf, texParameterf, unsigned, unsigned, float); + +GL_SAME_METHOD_3(TexParameteri, texParameteri, unsigned, unsigned, int); + +int GraphicsContext3D::texSubImage2D(unsigned target, + unsigned level, + unsigned xoffset, + unsigned yoffset, + unsigned width, + unsigned height, + unsigned format, + unsigned type, + WebGLArray* pixels) +{ + // FIXME: implement. + notImplemented(); + return -1; +} + +int GraphicsContext3D::texSubImage2D(unsigned target, + unsigned level, + unsigned xoffset, + unsigned yoffset, + unsigned width, + unsigned height, + unsigned format, + unsigned type, + ImageData* pixels) +{ + // FIXME: implement. + notImplemented(); + return -1; +} + +int GraphicsContext3D::texSubImage2D(unsigned target, + unsigned level, + unsigned xoffset, + unsigned yoffset, + unsigned width, + unsigned height, + Image* image, + bool flipY, + bool premultiplyAlpha) +{ + // FIXME: implement. + notImplemented(); + return -1; +} + +int GraphicsContext3D::texSubImage2D(unsigned target, + unsigned level, + unsigned xoffset, + unsigned yoffset, + unsigned width, + unsigned height, + HTMLVideoElement* video, + bool flipY, + bool premultiplyAlpha) +{ + // FIXME: implement. + notImplemented(); + return -1; +} + +GL_SAME_METHOD_2(Uniform1f, uniform1f, long, float) + +void GraphicsContext3D::uniform1fv(long location, float* v, int size) +{ + makeContextCurrent(); + glUniform1fv(location, size, v); +} + +GL_SAME_METHOD_2(Uniform1i, uniform1i, long, int) + +void GraphicsContext3D::uniform1iv(long location, int* v, int size) +{ + makeContextCurrent(); + glUniform1iv(location, size, v); +} + +GL_SAME_METHOD_3(Uniform2f, uniform2f, long, float, float) + +void GraphicsContext3D::uniform2fv(long location, float* v, int size) +{ + makeContextCurrent(); + glUniform2fv(location, size, v); +} + +GL_SAME_METHOD_3(Uniform2i, uniform2i, long, int, int) + +void GraphicsContext3D::uniform2iv(long location, int* v, int size) +{ + makeContextCurrent(); + glUniform2iv(location, size, v); +} + +GL_SAME_METHOD_4(Uniform3f, uniform3f, long, float, float, float) + +void GraphicsContext3D::uniform3fv(long location, float* v, int size) +{ + makeContextCurrent(); + glUniform3fv(location, size, v); +} + +GL_SAME_METHOD_4(Uniform3i, uniform3i, long, int, int, int) + +void GraphicsContext3D::uniform3iv(long location, int* v, int size) +{ + makeContextCurrent(); + glUniform3iv(location, size, v); +} + +GL_SAME_METHOD_5(Uniform4f, uniform4f, long, float, float, float, float) + +void GraphicsContext3D::uniform4fv(long location, float* v, int size) +{ + makeContextCurrent(); + glUniform4fv(location, size, v); +} + +GL_SAME_METHOD_5(Uniform4i, uniform4i, long, int, int, int, int) + +void GraphicsContext3D::uniform4iv(long location, int* v, int size) +{ + makeContextCurrent(); + glUniform4iv(location, size, v); +} + +void GraphicsContext3D::uniformMatrix2fv(long location, bool transpose, float* value, int size) +{ + makeContextCurrent(); + glUniformMatrix2fv(location, size, transpose, value); +} + +void GraphicsContext3D::uniformMatrix3fv(long location, bool transpose, float* value, int size) +{ + makeContextCurrent(); + glUniformMatrix3fv(location, size, transpose, value); +} + +void GraphicsContext3D::uniformMatrix4fv(long location, bool transpose, float* value, int size) +{ + makeContextCurrent(); + glUniformMatrix4fv(location, size, transpose, value); +} + +GL_SAME_METHOD_1_X(UseProgram, useProgram, WebGLProgram*) + +GL_SAME_METHOD_1_X(ValidateProgram, validateProgram, WebGLProgram*) + +GL_SAME_METHOD_2(VertexAttrib1f, vertexAttrib1f, unsigned long, float) + +void GraphicsContext3D::vertexAttrib1fv(unsigned long indx, float* values) +{ + makeContextCurrent(); + glVertexAttrib1fv(indx, values); +} + +GL_SAME_METHOD_3(VertexAttrib2f, vertexAttrib2f, unsigned long, float, float) + +void GraphicsContext3D::vertexAttrib2fv(unsigned long indx, float* values) +{ + makeContextCurrent(); + glVertexAttrib2fv(indx, values); +} + +GL_SAME_METHOD_4(VertexAttrib3f, vertexAttrib3f, unsigned long, float, float, float) + +void GraphicsContext3D::vertexAttrib3fv(unsigned long indx, float* values) +{ + makeContextCurrent(); + glVertexAttrib3fv(indx, values); +} + +GL_SAME_METHOD_5(VertexAttrib4f, vertexAttrib4f, unsigned long, float, float, float, float) + +void GraphicsContext3D::vertexAttrib4fv(unsigned long indx, float* values) +{ + makeContextCurrent(); + glVertexAttrib4fv(indx, values); +} + +void GraphicsContext3D::vertexAttribPointer(unsigned long indx, int size, int type, bool normalized, + unsigned long stride, unsigned long offset) +{ + m_internal->vertexAttribPointer(indx, size, type, normalized, stride, offset); +} + +void GraphicsContext3D::viewport(long x, long y, unsigned long width, unsigned long height) +{ + makeContextCurrent(); + m_internal->viewportImpl(x, y, width, height); +} + +} + +#endif // ENABLE(3D_CANVAS) diff --git a/WebKit/chromium/src/InspectorClientImpl.cpp b/WebKit/chromium/src/InspectorClientImpl.cpp new file mode 100644 index 0000000..54550d1 --- /dev/null +++ b/WebKit/chromium/src/InspectorClientImpl.cpp @@ -0,0 +1,218 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "InspectorClientImpl.h" + +#include "DOMWindow.h" +#include "FloatRect.h" +#include "InspectorController.h" +#include "NotImplemented.h" +#include "Page.h" +#include "Settings.h" +#include "WebRect.h" +#include "WebURL.h" +#include "WebURLRequest.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" +#include <wtf/Vector.h> + +using namespace WebCore; + +namespace WebKit { + +InspectorClientImpl::InspectorClientImpl(WebViewImpl* webView) + : m_inspectedWebView(webView) +{ + ASSERT(m_inspectedWebView); +} + +InspectorClientImpl::~InspectorClientImpl() +{ +} + +void InspectorClientImpl::inspectorDestroyed() +{ + // Our lifetime is bound to the WebViewImpl. +} + +Page* InspectorClientImpl::createPage() +{ + // This method should never be called in Chrome as inspector front-end lives + // in a separate process. + ASSERT_NOT_REACHED(); + return 0; +} + +void InspectorClientImpl::showWindow() +{ + ASSERT(m_inspectedWebView->devToolsAgentPrivate()); + m_inspectedWebView->page()->inspectorController()->setWindowVisible(true); +} + +void InspectorClientImpl::closeWindow() +{ + if (m_inspectedWebView->page()) + m_inspectedWebView->page()->inspectorController()->setWindowVisible(false); +} + +bool InspectorClientImpl::windowVisible() +{ + ASSERT(m_inspectedWebView->devToolsAgentPrivate()); + return false; +} + +void InspectorClientImpl::attachWindow() +{ + // FIXME: Implement this +} + +void InspectorClientImpl::detachWindow() +{ + // FIXME: Implement this +} + +void InspectorClientImpl::setAttachedWindowHeight(unsigned int height) +{ + // FIXME: Implement this + notImplemented(); +} + +static void invalidateNodeBoundingRect(WebViewImpl* webView) +{ + // FIXME: Is it important to just invalidate the rect of the node region + // given that this is not on a critical codepath? In order to do so, we'd + // have to take scrolling into account. + const WebSize& size = webView->size(); + WebRect damagedRect(0, 0, size.width, size.height); + if (webView->client()) + webView->client()->didInvalidateRect(damagedRect); +} + +void InspectorClientImpl::highlight(Node* node) +{ + // InspectorController does the actually tracking of the highlighted node + // and the drawing of the highlight. Here we just make sure to invalidate + // the rects of the old and new nodes. + hideHighlight(); +} + +void InspectorClientImpl::hideHighlight() +{ + // FIXME: able to invalidate a smaller rect. + invalidateNodeBoundingRect(m_inspectedWebView); +} + +void InspectorClientImpl::inspectedURLChanged(const String& newURL) +{ + // FIXME: Implement this +} + +String InspectorClientImpl::localizedStringsURL() +{ + notImplemented(); + return String(); +} + +String InspectorClientImpl::hiddenPanels() +{ + notImplemented(); + return ""; +} + +void InspectorClientImpl::populateSetting(const String& key, String* value) +{ + loadSettings(); + if (m_settings->contains(key)) + *value = m_settings->get(key); +} + +void InspectorClientImpl::storeSetting(const String& key, const String& value) +{ + loadSettings(); + m_settings->set(key, value); + saveSettings(); +} + +void InspectorClientImpl::inspectorWindowObjectCleared() +{ + notImplemented(); +} + +void InspectorClientImpl::loadSettings() +{ + if (m_settings) + return; + + m_settings.set(new SettingsMap); + String data = m_inspectedWebView->inspectorSettings(); + if (data.isEmpty()) + return; + + Vector<String> entries; + data.split("\n", entries); + for (Vector<String>::iterator it = entries.begin(); it != entries.end(); ++it) { + Vector<String> tokens; + it->split(":", tokens); + if (tokens.size() < 3) + continue; + + String name = decodeURLEscapeSequences(tokens[0]); + String type = tokens[1]; + String value = tokens[2]; + for (size_t i = 3; i < tokens.size(); ++i) + value += ":" + tokens[i]; + + if (type == "string") + value = decodeURLEscapeSequences(value); + + m_settings->set(name, value); + } +} + +void InspectorClientImpl::saveSettings() +{ + String data; + for (SettingsMap::iterator it = m_settings->begin(); it != m_settings->end(); ++it) { + String name = encodeWithURLEscapeSequences(it->first); + String value = it->second; + String entry = String::format( + "%s:string:%s", + name.utf8().data(), + encodeWithURLEscapeSequences(value).utf8().data()); + data.append(entry); + data.append("\n"); + } + m_inspectedWebView->setInspectorSettings(data); + if (m_inspectedWebView->client()) + m_inspectedWebView->client()->didUpdateInspectorSettings(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/InspectorClientImpl.h b/WebKit/chromium/src/InspectorClientImpl.h new file mode 100644 index 0000000..6f7f8b1 --- /dev/null +++ b/WebKit/chromium/src/InspectorClientImpl.h @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef InspectorClientImpl_h +#define InspectorClientImpl_h + +#include "InspectorClient.h" +#include "InspectorController.h" +#include <wtf/OwnPtr.h> + +namespace WebKit { +class WebViewImpl; + +class InspectorClientImpl : public WebCore::InspectorClient { +public: + InspectorClientImpl(WebViewImpl*); + ~InspectorClientImpl(); + + // InspectorClient methods: + virtual void inspectorDestroyed(); + virtual WebCore::Page* createPage(); + virtual WebCore::String localizedStringsURL(); + virtual WebCore::String hiddenPanels(); + virtual void showWindow(); + virtual void closeWindow(); + virtual bool windowVisible(); + virtual void attachWindow(); + virtual void detachWindow(); + virtual void setAttachedWindowHeight(unsigned height); + virtual void highlight(WebCore::Node*); + virtual void hideHighlight(); + virtual void inspectedURLChanged(const WebCore::String& newURL); + virtual void populateSetting( + const WebCore::String& key, + WebCore::String* value); + virtual void storeSetting( + const WebCore::String& key, + const WebCore::String& value); + virtual void inspectorWindowObjectCleared(); + +private: + void loadSettings(); + void saveSettings(); + + // The WebViewImpl of the page being inspected; gets passed to the constructor + WebViewImpl* m_inspectedWebView; + + typedef HashMap<WebCore::String, WebCore::String> SettingsMap; + OwnPtr<SettingsMap> m_settings; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/LocalizedStrings.cpp b/WebKit/chromium/src/LocalizedStrings.cpp new file mode 100644 index 0000000..1121931 --- /dev/null +++ b/WebKit/chromium/src/LocalizedStrings.cpp @@ -0,0 +1,307 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "LocalizedStrings.h" + +#include "IntSize.h" +#include "NotImplemented.h" +#include "PlatformString.h" +#include "StringBuilder.h" + +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebLocalizedString.h" +#include "WebString.h" + +using WebKit::WebLocalizedString; + +namespace WebCore { + +static String query(WebLocalizedString::Name name) +{ + return WebKit::webKitClient()->queryLocalizedString(name); +} + +static String query(WebLocalizedString::Name name, int numericValue) +{ + return WebKit::webKitClient()->queryLocalizedString(name, numericValue); +} + +String searchableIndexIntroduction() +{ + return query(WebLocalizedString::SearchableIndexIntroduction); +} + +String submitButtonDefaultLabel() +{ + return query(WebLocalizedString::SubmitButtonDefaultLabel); +} + +String inputElementAltText() +{ + return query(WebLocalizedString::InputElementAltText); +} + +String resetButtonDefaultLabel() +{ + return query(WebLocalizedString::ResetButtonDefaultLabel); +} + +String fileButtonChooseFileLabel() +{ + return query(WebLocalizedString::FileButtonChooseFileLabel); +} + +String fileButtonNoFileSelectedLabel() +{ + return query(WebLocalizedString::FileButtonNoFileSelectedLabel); +} + +String searchMenuNoRecentSearchesText() +{ + return query(WebLocalizedString::SearchMenuNoRecentSearchesText); +} +String searchMenuRecentSearchesText() +{ + return query(WebLocalizedString::SearchMenuRecentSearchesText); +} +String searchMenuClearRecentSearchesText() +{ + return query(WebLocalizedString::SearchMenuClearRecentSearchesText); +} + +String AXWebAreaText() +{ + return query(WebLocalizedString::AXWebAreaText); +} + +String AXLinkText() +{ + return query(WebLocalizedString::AXLinkText); +} + +String AXListMarkerText() +{ + return query(WebLocalizedString::AXListMarkerText); +} + +String AXImageMapText() +{ + return query(WebLocalizedString::AXImageMapText); +} + +String AXHeadingText() +{ + return query(WebLocalizedString::AXHeadingText); +} + +String AXDefinitionListTermText() +{ + notImplemented(); + return String("term"); +} + +String AXDefinitionListDefinitionText() +{ + notImplemented(); + return String("definition"); +} + +String AXButtonActionVerb() +{ + return query(WebLocalizedString::AXButtonActionVerb); +} + +String AXRadioButtonActionVerb() +{ + return query(WebLocalizedString::AXRadioButtonActionVerb); +} + +String AXTextFieldActionVerb() +{ + return query(WebLocalizedString::AXTextFieldActionVerb); +} + +String AXCheckedCheckBoxActionVerb() +{ + return query(WebLocalizedString::AXCheckedCheckBoxActionVerb); +} + +String AXUncheckedCheckBoxActionVerb() +{ + return query(WebLocalizedString::AXUncheckedCheckBoxActionVerb); +} + +String AXLinkActionVerb() +{ + return query(WebLocalizedString::AXLinkActionVerb); +} + +String multipleFileUploadText(unsigned numberOfFiles) +{ + return query(WebLocalizedString::MultipleFileUploadText, numberOfFiles); +} + +// Used in FTPDirectoryDocument.cpp +String unknownFileSizeText() +{ + return String(); +} + +// The following two functions are not declared in LocalizedStrings.h. +// They are used by the menu for the HTML keygen tag. +String keygenMenuHighGradeKeySize() +{ + return query(WebLocalizedString::KeygenMenuHighGradeKeySize); +} + +String keygenMenuMediumGradeKeySize() +{ + return query(WebLocalizedString::KeygenMenuMediumGradeKeySize); +} + +// Used in ImageDocument.cpp as the title for pages when that page is an image. +String imageTitle(const String& filename, const IntSize& size) +{ + // Note that we cannot use String::format because it works for ASCII only. + StringBuilder result; + result.append(filename); + result.append(" ("); + result.append(String::number(size.width())); + result.append(static_cast<UChar>(0xD7)); // U+00D7 (multiplication sign) + result.append(String::number(size.height())); + result.append(")"); + return result.toString(); +} + +// We don't use these strings, so they return an empty String. We can't just +// make them asserts because webcore still calls them. +String contextMenuItemTagOpenLinkInNewWindow() { return String(); } +String contextMenuItemTagDownloadLinkToDisk() { return String(); } +String contextMenuItemTagCopyLinkToClipboard() { return String(); } +String contextMenuItemTagOpenImageInNewWindow() { return String(); } +String contextMenuItemTagDownloadImageToDisk() { return String(); } +String contextMenuItemTagCopyImageToClipboard() { return String(); } +String contextMenuItemTagOpenFrameInNewWindow() { return String(); } +String contextMenuItemTagCopy() { return String(); } +String contextMenuItemTagGoBack() { return String(); } +String contextMenuItemTagGoForward() { return String(); } +String contextMenuItemTagStop() { return String(); } +String contextMenuItemTagReload() { return String(); } +String contextMenuItemTagCut() { return String(); } +String contextMenuItemTagPaste() { return String(); } +String contextMenuItemTagNoGuessesFound() { return String(); } +String contextMenuItemTagIgnoreSpelling() { return String(); } +String contextMenuItemTagLearnSpelling() { return String(); } +String contextMenuItemTagSearchWeb() { return String(); } +String contextMenuItemTagLookUpInDictionary() { return String(); } +String contextMenuItemTagOpenLink() { return String(); } +String contextMenuItemTagIgnoreGrammar() { return String(); } +String contextMenuItemTagSpellingMenu() { return String(); } +String contextMenuItemTagCheckSpelling() { return String(); } +String contextMenuItemTagCheckSpellingWhileTyping() { return String(); } +String contextMenuItemTagCheckGrammarWithSpelling() { return String(); } +String contextMenuItemTagFontMenu() { return String(); } +String contextMenuItemTagBold() { return String(); } +String contextMenuItemTagItalic() { return String(); } +String contextMenuItemTagUnderline() { return String(); } +String contextMenuItemTagOutline() { return String(); } +String contextMenuItemTagWritingDirectionMenu() { return String(); } +String contextMenuItemTagTextDirectionMenu() { return String(); } +String contextMenuItemTagDefaultDirection() { return String(); } +String contextMenuItemTagLeftToRight() { return String(); } +String contextMenuItemTagRightToLeft() { return String(); } +String contextMenuItemTagInspectElement() { return String(); } +String contextMenuItemTagShowSpellingPanel(bool show) { return String(); } +String mediaElementLiveBroadcastStateText() { return String(); } +String mediaElementLoadingStateText() { return String(); } + +String localizedMediaControlElementString(const String& /*name*/) +{ + // FIXME: to be fixed. + return String(); +} + +String localizedMediaControlElementHelpText(const String& /*name*/) +{ + // FIXME: to be fixed. + return String(); +} + +String localizedMediaTimeDescription(float /*time*/) +{ + // FIXME: to be fixed. + return String(); +} + +String validationMessageValueMissingText() +{ + notImplemented(); + return String(); +} + +String validationMessageTypeMismatchText() +{ + notImplemented(); + return String(); +} + +String validationMessagePatternMismatchText() +{ + notImplemented(); + return String(); +} + +String validationMessageTooLongText() +{ + notImplemented(); + return String(); +} + +String validationMessageRangeUnderflowText() +{ + notImplemented(); + return String(); +} + +String validationMessageRangeOverflowText() +{ + notImplemented(); + return String(); +} + +String validationMessageStepMismatchText() +{ + notImplemented(); + return String(); +} + +} // namespace WebCore diff --git a/WebKit/chromium/src/MediaPlayerPrivateChromium.cpp b/WebKit/chromium/src/MediaPlayerPrivateChromium.cpp new file mode 100644 index 0000000..09d33d4 --- /dev/null +++ b/WebKit/chromium/src/MediaPlayerPrivateChromium.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "MediaPlayerPrivateChromium.h" + +#if ENABLE(VIDEO) + +#include "WebMediaPlayerClientImpl.h" + +namespace WebCore { + +void MediaPlayerPrivate::registerMediaEngine(MediaEngineRegistrar registrar) +{ + WebKit::WebMediaPlayerClientImpl::registerSelf(registrar); +} + +} // namespace WebCore + +#endif diff --git a/WebKit/chromium/src/NotificationPresenterImpl.cpp b/WebKit/chromium/src/NotificationPresenterImpl.cpp new file mode 100644 index 0000000..6b22319 --- /dev/null +++ b/WebKit/chromium/src/NotificationPresenterImpl.cpp @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "NotificationPresenterImpl.h" + +#if ENABLE(NOTIFICATIONS) + +#include "Notification.h" +#include "SecurityOrigin.h" + +#include "WebNotification.h" +#include "WebNotificationPermissionCallback.h" +#include "WebNotificationPresenter.h" + +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +class VoidCallbackClient : public WebNotificationPermissionCallback { +public: + VoidCallbackClient(PassRefPtr<VoidCallback> callback) + : m_callback(callback) + { + } + + virtual void permissionRequestComplete() + { + if (m_callback) + m_callback->handleEvent(); + delete this; + } + +private: + RefPtr<VoidCallback> m_callback; +}; + +void NotificationPresenterImpl::initialize(WebNotificationPresenter* presenter) +{ + m_presenter = presenter; +} + +bool NotificationPresenterImpl::isInitialized() +{ + return !!m_presenter; +} + +bool NotificationPresenterImpl::show(Notification* notification) +{ + return m_presenter->show(PassRefPtr<Notification>(notification)); +} + +void NotificationPresenterImpl::cancel(Notification* notification) +{ + m_presenter->cancel(PassRefPtr<Notification>(notification)); +} + +void NotificationPresenterImpl::notificationObjectDestroyed(Notification* notification) +{ + m_presenter->objectDestroyed(PassRefPtr<Notification>(notification)); +} + +NotificationPresenter::Permission NotificationPresenterImpl::checkPermission(SecurityOrigin* origin) +{ + int result = m_presenter->checkPermission(origin->toString()); + return static_cast<NotificationPresenter::Permission>(result); +} + +void NotificationPresenterImpl::requestPermission(SecurityOrigin* origin, PassRefPtr<VoidCallback> callback) +{ + m_presenter->requestPermission(origin->toString(), new VoidCallbackClient(callback)); +} + +} // namespace WebKit + +#endif // ENABLE(NOTIFICATIONS) diff --git a/WebKit/chromium/src/NotificationPresenterImpl.h b/WebKit/chromium/src/NotificationPresenterImpl.h new file mode 100644 index 0000000..4afe9dc --- /dev/null +++ b/WebKit/chromium/src/NotificationPresenterImpl.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef NotificationPresenterImpl_h +#define NotificationPresenterImpl_h + +#include "NotificationPresenter.h" +#include "VoidCallback.h" + +#include <wtf/HashMap.h> +#include <wtf/PassRefPtr.h> + +#if ENABLE(NOTIFICATIONS) + +namespace WebKit { + +class WebNotificationPresenter; + +class NotificationPresenterImpl : public WebCore::NotificationPresenter { +public: + NotificationPresenterImpl() : m_presenter(0) { } + + void initialize(WebNotificationPresenter* presenter); + bool isInitialized(); + + // WebCore::NotificationPresenter implementation. + virtual bool show(WebCore::Notification* object); + virtual void cancel(WebCore::Notification* object); + virtual void notificationObjectDestroyed(WebCore::Notification* object); + virtual WebCore::NotificationPresenter::Permission checkPermission(WebCore::SecurityOrigin* origin); + virtual void requestPermission(WebCore::SecurityOrigin* origin, WTF::PassRefPtr<WebCore::VoidCallback> callback); + +private: + // WebNotificationPresenter that this object delegates to. + WebNotificationPresenter* m_presenter; +}; + +} // namespace WebKit + +#endif // ENABLE(NOTIFICATIONS) + +#endif diff --git a/WebKit/chromium/src/PlatformMessagePortChannel.cpp b/WebKit/chromium/src/PlatformMessagePortChannel.cpp new file mode 100644 index 0000000..f8c41d3 --- /dev/null +++ b/WebKit/chromium/src/PlatformMessagePortChannel.cpp @@ -0,0 +1,258 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "PlatformMessagePortChannel.h" + +#include "MessagePort.h" +#include "ScriptExecutionContext.h" +#include "SerializedScriptValue.h" + +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebMessagePortChannel.h" +#include "WebString.h" + +using namespace WebKit; + +namespace WebCore { + +PassOwnPtr<MessagePortChannel> MessagePortChannel::create(PassRefPtr<PlatformMessagePortChannel> channel) +{ + return new MessagePortChannel(channel); +} + +void MessagePortChannel::createChannel(PassRefPtr<MessagePort> port1, PassRefPtr<MessagePort> port2) +{ + PlatformMessagePortChannel::createChannel(port1, port2); +} + +MessagePortChannel::MessagePortChannel(PassRefPtr<PlatformMessagePortChannel> channel) + : m_channel(channel) +{ +} + +MessagePortChannel::~MessagePortChannel() +{ + // Make sure we close our platform channel when the base is freed, to keep the channel objects from leaking. + m_channel->close(); +} + +bool MessagePortChannel::entangleIfOpen(MessagePort* port) +{ + return m_channel->entangleIfOpen(port); +} + +void MessagePortChannel::disentangle() +{ + m_channel->disentangle(); +} + +void MessagePortChannel::postMessageToRemote(PassOwnPtr<MessagePortChannel::EventData> message) +{ + m_channel->postMessageToRemote(message); +} + +bool MessagePortChannel::tryGetMessageFromRemote(OwnPtr<MessagePortChannel::EventData>& result) +{ + return m_channel->tryGetMessageFromRemote(result); +} + +void MessagePortChannel::close() +{ + m_channel->close(); +} + +bool MessagePortChannel::isConnectedTo(MessagePort* port) +{ + return m_channel->isConnectedTo(port); +} + +bool MessagePortChannel::hasPendingActivity() +{ + return m_channel->hasPendingActivity(); +} + +MessagePort* MessagePortChannel::locallyEntangledPort(const ScriptExecutionContext* context) +{ + // This is just an optimization, so return 0 always. + return 0; +} + + +PassRefPtr<PlatformMessagePortChannel> PlatformMessagePortChannel::create() +{ + return adoptRef(new PlatformMessagePortChannel()); +} + +PassRefPtr<PlatformMessagePortChannel> PlatformMessagePortChannel::create( + WebMessagePortChannel* channel) +{ + return adoptRef(new PlatformMessagePortChannel(channel)); +} + + +PlatformMessagePortChannel::PlatformMessagePortChannel() + : m_localPort(0) +{ + m_webChannel = webKitClient()->createMessagePortChannel(); + if (m_webChannel) + m_webChannel->setClient(this); +} + +PlatformMessagePortChannel::PlatformMessagePortChannel(WebMessagePortChannel* channel) + : m_localPort(0) + , m_webChannel(channel) +{ +} + +PlatformMessagePortChannel::~PlatformMessagePortChannel() +{ + if (m_webChannel) + m_webChannel->destroy(); +} + +void PlatformMessagePortChannel::createChannel(PassRefPtr<MessagePort> port1, PassRefPtr<MessagePort> port2) +{ + // Create proxies for each endpoint. + RefPtr<PlatformMessagePortChannel> channel1 = PlatformMessagePortChannel::create(); + RefPtr<PlatformMessagePortChannel> channel2 = PlatformMessagePortChannel::create(); + + // Entangle the two endpoints. + channel1->setEntangledChannel(channel2); + channel2->setEntangledChannel(channel1); + + // Now entangle the proxies with the appropriate local ports. + port1->entangle(MessagePortChannel::create(channel2)); + port2->entangle(MessagePortChannel::create(channel1)); +} + +void PlatformMessagePortChannel::messageAvailable() +{ + MutexLocker lock(m_mutex); + if (m_localPort) + m_localPort->messageAvailable(); +} + +bool PlatformMessagePortChannel::entangleIfOpen(MessagePort* port) +{ + MutexLocker lock(m_mutex); + m_localPort = port; + return true; +} + +void PlatformMessagePortChannel::disentangle() +{ + MutexLocker lock(m_mutex); + m_localPort = 0; +} + +void PlatformMessagePortChannel::postMessageToRemote(PassOwnPtr<MessagePortChannel::EventData> message) +{ + if (!m_localPort || !m_webChannel) + return; + + WebString messageString = message->message()->toString(); + OwnPtr<WebCore::MessagePortChannelArray> channels = message->channels(); + WebMessagePortChannelArray* webChannels = 0; + if (channels.get() && channels->size()) { + webChannels = new WebMessagePortChannelArray(channels->size()); + for (size_t i = 0; i < channels->size(); ++i) { + WebCore::PlatformMessagePortChannel* platformChannel = (*channels)[i]->channel(); + (*webChannels)[i] = platformChannel->webChannelRelease(); + (*webChannels)[i]->setClient(0); + } + } + m_webChannel->postMessage(messageString, webChannels); +} + +bool PlatformMessagePortChannel::tryGetMessageFromRemote(OwnPtr<MessagePortChannel::EventData>& result) +{ + if (!m_webChannel) + return false; + + WebString message; + WebMessagePortChannelArray webChannels; + bool rv = m_webChannel->tryGetMessage(&message, webChannels); + if (rv) { + OwnPtr<MessagePortChannelArray> channels; + if (webChannels.size()) { + channels = new MessagePortChannelArray(webChannels.size()); + for (size_t i = 0; i < webChannels.size(); ++i) { + RefPtr<PlatformMessagePortChannel> platformChannel = create(webChannels[i]); + webChannels[i]->setClient(platformChannel.get()); + (*channels)[i] = MessagePortChannel::create(platformChannel); + } + } + RefPtr<SerializedScriptValue> serializedMessage = SerializedScriptValue::create(message); + result = MessagePortChannel::EventData::create(serializedMessage.release(), channels.release()); + } + + return rv; +} + +void PlatformMessagePortChannel::close() +{ + MutexLocker lock(m_mutex); + // Disentangle ourselves from the other end. We still maintain a reference to m_webChannel, + // since previously-existing messages should still be delivered. + m_localPort = 0; + m_entangledChannel = 0; +} + +bool PlatformMessagePortChannel::isConnectedTo(MessagePort* port) +{ + MutexLocker lock(m_mutex); + return m_entangledChannel && m_entangledChannel->m_localPort == port; +} + +bool PlatformMessagePortChannel::hasPendingActivity() +{ + MutexLocker lock(m_mutex); + return m_localPort; +} + +void PlatformMessagePortChannel::setEntangledChannel(PassRefPtr<PlatformMessagePortChannel> remote) +{ + if (m_webChannel) + m_webChannel->entangle(remote->m_webChannel); + + MutexLocker lock(m_mutex); + m_entangledChannel = remote; +} + +WebMessagePortChannel* PlatformMessagePortChannel::webChannelRelease() +{ + WebMessagePortChannel* rv = m_webChannel; + m_webChannel = 0; + return rv; +} + +} // namespace WebCore diff --git a/WebKit/chromium/src/PlatformMessagePortChannel.h b/WebKit/chromium/src/PlatformMessagePortChannel.h new file mode 100644 index 0000000..05e8397 --- /dev/null +++ b/WebKit/chromium/src/PlatformMessagePortChannel.h @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef PlatformMessagePortChannel_h +#define PlatformMessagePortChannel_h + +// FIXME: This relative path is a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebMessagePortChannelClient.h" + +#include "MessagePortChannel.h" + +#include <wtf/PassRefPtr.h> +#include <wtf/Threading.h> + +namespace WebKit { +class WebMessagePortChannel; +} + +namespace WebCore { + +class MessagePort; + +// PlatformMessagePortChannel is a platform-dependent interface to the remote side of a message channel. +class PlatformMessagePortChannel : public ThreadSafeShared<PlatformMessagePortChannel>, + public WebKit::WebMessagePortChannelClient { +public: + static void createChannel(PassRefPtr<MessagePort>, PassRefPtr<MessagePort>); + static PassRefPtr<PlatformMessagePortChannel> create(); + static PassRefPtr<PlatformMessagePortChannel> create(WebKit::WebMessagePortChannel*); + + // APIs delegated from MessagePortChannel.h + bool entangleIfOpen(MessagePort*); + void disentangle(); + void postMessageToRemote(PassOwnPtr<MessagePortChannel::EventData>); + bool tryGetMessageFromRemote(OwnPtr<MessagePortChannel::EventData>&); + void close(); + bool isConnectedTo(MessagePort* port); + bool hasPendingActivity(); + + // Releases ownership of the contained web channel. + WebKit::WebMessagePortChannel* webChannelRelease(); + + ~PlatformMessagePortChannel(); + +private: + PlatformMessagePortChannel(); + PlatformMessagePortChannel(WebKit::WebMessagePortChannel*); + + void setEntangledChannel(PassRefPtr<PlatformMessagePortChannel>); + + // WebKit::WebMessagePortChannelClient implementation + virtual void messageAvailable(); + + // Mutex used to ensure exclusive access to the object internals. + Mutex m_mutex; + + // Pointer to our entangled pair - cleared when close() is called. + RefPtr<PlatformMessagePortChannel> m_entangledChannel; + + // The port we are connected to - this is the port that is notified when new messages arrive. + MessagePort* m_localPort; + + WebKit::WebMessagePortChannel* m_webChannel; +}; + +} // namespace WebCore + +#endif // PlatformMessagePortChannel_h diff --git a/WebKit/chromium/src/ResourceHandle.cpp b/WebKit/chromium/src/ResourceHandle.cpp new file mode 100644 index 0000000..bf6910f --- /dev/null +++ b/WebKit/chromium/src/ResourceHandle.cpp @@ -0,0 +1,282 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "ResourceHandle.h" + +#include "ResourceHandleClient.h" +#include "ResourceRequest.h" + +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebURLError.h" +#include "WebURLLoader.h" +#include "WebURLLoaderClient.h" +#include "WebURLRequest.h" +#include "WebURLResponse.h" +#include "WrappedResourceRequest.h" +#include "WrappedResourceResponse.h" + +using namespace WebKit; + +namespace WebCore { + +// ResourceHandleInternal ----------------------------------------------------- + +class ResourceHandleInternal : public WebURLLoaderClient { +public: + ResourceHandleInternal(const ResourceRequest& request, ResourceHandleClient* client) + : m_request(request) + , m_owner(0) + , m_client(client) + { + } + + void start(); + void cancel(); + void setDefersLoading(bool); + bool allowStoredCredentials() const; + + // WebURLLoaderClient methods: + virtual void willSendRequest(WebURLLoader*, WebURLRequest&, const WebURLResponse&); + virtual void didSendData( + WebURLLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent); + virtual void didReceiveResponse(WebURLLoader*, const WebURLResponse&); + virtual void didReceiveData(WebURLLoader*, const char* data, int dataLength); + virtual void didFinishLoading(WebURLLoader*); + virtual void didFail(WebURLLoader*, const WebURLError&); + + ResourceRequest m_request; + ResourceHandle* m_owner; + ResourceHandleClient* m_client; + OwnPtr<WebURLLoader> m_loader; +}; + +void ResourceHandleInternal::start() +{ + m_loader.set(webKitClient()->createURLLoader()); + ASSERT(m_loader.get()); + + WrappedResourceRequest wrappedRequest(m_request); + wrappedRequest.setAllowStoredCredentials(allowStoredCredentials()); + m_loader->loadAsynchronously(wrappedRequest, this); +} + +void ResourceHandleInternal::cancel() +{ + m_loader->cancel(); + + // Do not make any further calls to the client. + m_client = 0; +} + +void ResourceHandleInternal::setDefersLoading(bool value) +{ + m_loader->setDefersLoading(value); +} + +bool ResourceHandleInternal::allowStoredCredentials() const +{ + return m_client && m_client->shouldUseCredentialStorage(m_owner); +} + +void ResourceHandleInternal::willSendRequest( + WebURLLoader*, WebURLRequest& request, const WebURLResponse& response) +{ + ASSERT(m_client); + ASSERT(!request.isNull()); + ASSERT(!response.isNull()); + m_client->willSendRequest(m_owner, request.toMutableResourceRequest(), response.toResourceResponse()); +} + +void ResourceHandleInternal::didSendData( + WebURLLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) +{ + ASSERT(m_client); + m_client->didSendData(m_owner, bytesSent, totalBytesToBeSent); +} + +void ResourceHandleInternal::didReceiveResponse(WebURLLoader*, const WebURLResponse& response) +{ + ASSERT(m_client); + ASSERT(!response.isNull()); + m_client->didReceiveResponse(m_owner, response.toResourceResponse()); +} + +void ResourceHandleInternal::didReceiveData( + WebURLLoader*, const char* data, int dataLength) +{ + ASSERT(m_client); + + // FIXME(yurys): it looks like lengthReceived is always the same as + // dataLength and that the latter parameter can be eliminated. + // See WebKit bug: https://bugs.webkit.org/show_bug.cgi?id=31019 + m_client->didReceiveData(m_owner, data, dataLength, dataLength); +} + +void ResourceHandleInternal::didFinishLoading(WebURLLoader*) +{ + ASSERT(m_client); + m_client->didFinishLoading(m_owner); +} + +void ResourceHandleInternal::didFail(WebURLLoader*, const WebURLError& error) +{ + ASSERT(m_client); + m_client->didFail(m_owner, error); +} + +// ResourceHandle ------------------------------------------------------------- + +ResourceHandle::ResourceHandle(const ResourceRequest& request, + ResourceHandleClient* client, + bool defersLoading, + bool shouldContentSniff, + bool mightDownloadFromHandle) + : d(new ResourceHandleInternal(request, client)) +{ + d->m_owner = this; + + // FIXME: Figure out what to do with the bool params. +} + +PassRefPtr<ResourceHandle> ResourceHandle::create(const ResourceRequest& request, + ResourceHandleClient* client, + Frame* deprecated, + bool defersLoading, + bool shouldContentSniff, + bool mightDownloadFromHandle) +{ + RefPtr<ResourceHandle> newHandle = adoptRef(new ResourceHandle( + request, client, defersLoading, shouldContentSniff, mightDownloadFromHandle)); + + if (newHandle->start(deprecated)) + return newHandle.release(); + + return 0; +} + +const ResourceRequest& ResourceHandle::request() const +{ + return d->m_request; +} + +ResourceHandleClient* ResourceHandle::client() const +{ + return d->m_client; +} + +void ResourceHandle::setClient(ResourceHandleClient* client) +{ + d->m_client = client; +} + +void ResourceHandle::setDefersLoading(bool value) +{ + d->setDefersLoading(value); +} + +bool ResourceHandle::start(Frame* deprecated) +{ + d->start(); + return true; +} + +void ResourceHandle::clearAuthentication() +{ +} + +void ResourceHandle::cancel() +{ + d->cancel(); +} + +ResourceHandle::~ResourceHandle() +{ + d->m_owner = 0; +} + +PassRefPtr<SharedBuffer> ResourceHandle::bufferedData() +{ + return 0; +} + +bool ResourceHandle::loadsBlocked() +{ + return false; // This seems to be related to sync XMLHttpRequest... +} + +// static +bool ResourceHandle::supportsBufferedData() +{ + return false; // The loader will buffer manually if it needs to. +} + +// static +void ResourceHandle::loadResourceSynchronously(const ResourceRequest& request, + StoredCredentials storedCredentials, + ResourceError& error, + ResourceResponse& response, + Vector<char>& data, + Frame* deprecated) +{ + OwnPtr<WebURLLoader> loader(webKitClient()->createURLLoader()); + ASSERT(loader.get()); + + WrappedResourceRequest requestIn(request); + requestIn.setAllowStoredCredentials(storedCredentials == AllowStoredCredentials); + WrappedResourceResponse responseOut(response); + WebURLError errorOut; + WebData dataOut; + + loader->loadSynchronously(requestIn, responseOut, errorOut, dataOut); + + error = errorOut; + data.clear(); + data.append(dataOut.data(), dataOut.size()); +} + +// static +bool ResourceHandle::willLoadFromCache(ResourceRequest& request, Frame*) +{ + // This method is used to determine if a POST request can be repeated from + // cache, but you cannot really know until you actually try to read from the + // cache. Even if we checked now, something else could come along and wipe + // out the cache entry by the time we fetch it. + // + // So, we always say yes here, to prevent the FrameLoader from initiating a + // reload. Then in FrameLoaderClientImpl::dispatchWillSendRequest, we + // fix-up the cache policy of the request to force a load from the cache. + // + ASSERT(request.httpMethod() == "POST"); + return true; +} + +} // namespace WebCore diff --git a/WebKit/chromium/src/SharedWorkerRepository.cpp b/WebKit/chromium/src/SharedWorkerRepository.cpp new file mode 100644 index 0000000..5e5bc46 --- /dev/null +++ b/WebKit/chromium/src/SharedWorkerRepository.cpp @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if ENABLE(SHARED_WORKERS) + +#include "SharedWorkerRepository.h" + +#include "Event.h" +#include "EventNames.h" +#include "MessagePortChannel.h" +#include "PlatformMessagePortChannel.h" +#include "ScriptExecutionContext.h" +#include "SharedWorker.h" +#include "WebFrameClient.h" +#include "WebFrameImpl.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebMessagePortChannel.h" +#include "WebSharedWorker.h" +#include "WebSharedWorkerRepository.h" +#include "WebString.h" +#include "WebURL.h" +#include "WorkerScriptLoader.h" +#include "WorkerScriptLoaderClient.h" + +namespace WebCore { + +class Document; +using WebKit::WebFrameImpl; +using WebKit::WebMessagePortChannel; +using WebKit::WebSharedWorker; +using WebKit::WebSharedWorkerRepository; + +// Callback class that keeps the SharedWorker and WebSharedWorker objects alive while loads are potentially happening, and also translates load errors into error events on the worker. +class SharedWorkerScriptLoader : private WorkerScriptLoaderClient, private WebSharedWorker::ConnectListener, private ActiveDOMObject { +public: + SharedWorkerScriptLoader(PassRefPtr<SharedWorker> worker, const KURL& url, const String& name, PassOwnPtr<MessagePortChannel> port, PassOwnPtr<WebSharedWorker> webWorker) + : ActiveDOMObject(worker->scriptExecutionContext(), this) + , m_worker(worker) + , m_url(url) + , m_name(name) + , m_webWorker(webWorker) + , m_port(port) + { + } + + void load(); + virtual void contextDestroyed(); +private: + // WorkerScriptLoaderClient callback + virtual void notifyFinished(); + + virtual void connected(); + + void sendConnect(); + + RefPtr<SharedWorker> m_worker; + KURL m_url; + String m_name; + OwnPtr<WebSharedWorker> m_webWorker; + OwnPtr<MessagePortChannel> m_port; + WorkerScriptLoader m_scriptLoader; +}; + +void SharedWorkerScriptLoader::load() +{ + // If the shared worker is not yet running, load the script resource for it, otherwise just send it a connect event. + if (m_webWorker->isStarted()) + sendConnect(); + else + m_scriptLoader.loadAsynchronously(m_worker->scriptExecutionContext(), m_url, DenyCrossOriginRequests, this); +} + +// Extracts a WebMessagePortChannel from a MessagePortChannel. +static WebMessagePortChannel* getWebPort(PassOwnPtr<MessagePortChannel> port) +{ + // Extract the WebMessagePortChannel to send to the worker. + PlatformMessagePortChannel* platformChannel = port->channel(); + WebMessagePortChannel* webPort = platformChannel->webChannelRelease(); + webPort->setClient(0); + return webPort; +} + +void SharedWorkerScriptLoader::notifyFinished() +{ + if (m_scriptLoader.failed()) { + m_worker->dispatchEvent(Event::create(eventNames().errorEvent, false, true)); + delete this; + } else { + // Pass the script off to the worker, then send a connect event. + m_webWorker->startWorkerContext(m_url, m_name, m_worker->scriptExecutionContext()->userAgent(m_url), m_scriptLoader.script()); + sendConnect(); + } +} + +void SharedWorkerScriptLoader::sendConnect() +{ + // Send the connect event off, and linger until it is done sending. + m_webWorker->connect(getWebPort(m_port.release()), this); +} + +void SharedWorkerScriptLoader::contextDestroyed() +{ + ActiveDOMObject::contextDestroyed(); + delete this; +} + +void SharedWorkerScriptLoader::connected() +{ + // Connect event has been sent, so free ourselves (this releases the SharedWorker so it can be freed as well if unreferenced). + delete this; +} + +bool SharedWorkerRepository::isAvailable() +{ + // Allow the WebKitClient to determine if SharedWorkers are available. + return WebKit::webKitClient()->sharedWorkerRepository(); +} + +static WebSharedWorkerRepository::DocumentID getId(void* document) +{ + ASSERT(document); + return reinterpret_cast<WebSharedWorkerRepository::DocumentID>(document); +} + +void SharedWorkerRepository::connect(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const KURL& url, const String& name, ExceptionCode& ec) +{ + // This should not be callable unless there's a SharedWorkerRepository for + // this context (since isAvailable() should have returned null). + ASSERT(WebKit::webKitClient()->sharedWorkerRepository()); + + // No nested workers (for now) - connect() should only be called from document context. + ASSERT(worker->scriptExecutionContext()->isDocument()); + Document* document = static_cast<Document*>(worker->scriptExecutionContext()); + WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame()); + OwnPtr<WebSharedWorker> webWorker; + webWorker = webFrame->client()->createSharedWorker(webFrame, url, name, getId(document)); + + if (!webWorker) { + // Existing worker does not match this url, so return an error back to the caller. + ec = URL_MISMATCH_ERR; + return; + } + + WebKit::webKitClient()->sharedWorkerRepository()->addSharedWorker( + webWorker.get(), getId(document)); + + // The loader object manages its own lifecycle (and the lifecycles of the two worker objects). + // It will free itself once loading is completed. + SharedWorkerScriptLoader* loader = new SharedWorkerScriptLoader(worker, url, name, port.release(), webWorker.release()); + loader->load(); +} + +void SharedWorkerRepository::documentDetached(Document* document) +{ + WebSharedWorkerRepository* repo = WebKit::webKitClient()->sharedWorkerRepository(); + if (repo) + repo->documentDetached(getId(document)); +} + +bool SharedWorkerRepository::hasSharedWorkers(Document* document) +{ + WebSharedWorkerRepository* repo = WebKit::webKitClient()->sharedWorkerRepository(); + return repo && repo->hasSharedWorkers(getId(document)); +} + + + +} // namespace WebCore + +#endif // ENABLE(SHARED_WORKERS) diff --git a/WebKit/chromium/src/SocketStreamHandle.cpp b/WebKit/chromium/src/SocketStreamHandle.cpp new file mode 100644 index 0000000..9f19942 --- /dev/null +++ b/WebKit/chromium/src/SocketStreamHandle.cpp @@ -0,0 +1,236 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "SocketStreamHandle.h" + +#if ENABLE(WEB_SOCKETS) + +#include "Logging.h" +#include "NotImplemented.h" +#include "SocketStreamHandleClient.h" +#include "WebData.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebSocketStreamHandle.h" +#include "WebSocketStreamHandleClient.h" +#include "WebURL.h" +#include <wtf/PassOwnPtr.h> + +using namespace WebKit; + +namespace WebCore { + +class SocketStreamHandleInternal : public WebSocketStreamHandleClient { +public: + static PassOwnPtr<SocketStreamHandleInternal> create(SocketStreamHandle* handle) + { + return new SocketStreamHandleInternal(handle); + } + virtual ~SocketStreamHandleInternal(); + + void connect(const KURL&); + int send(const char*, int); + void close(); + + virtual void didOpenStream(WebSocketStreamHandle*, int); + virtual void didSendData(WebSocketStreamHandle*, int); + virtual void didReceiveData(WebSocketStreamHandle*, const WebData&); + virtual void didClose(WebSocketStreamHandle*); + virtual void didFail(WebSocketStreamHandle*, const WebSocketStreamError&); + +private: + explicit SocketStreamHandleInternal(SocketStreamHandle*); + + SocketStreamHandle* m_handle; + OwnPtr<WebSocketStreamHandle> m_socket; + int m_maxPendingSendAllowed; + int m_pendingAmountSent; +}; + +SocketStreamHandleInternal::SocketStreamHandleInternal(SocketStreamHandle* handle) + : m_handle(handle) + , m_maxPendingSendAllowed(0) + , m_pendingAmountSent(0) +{ +} + +SocketStreamHandleInternal::~SocketStreamHandleInternal() +{ + m_handle = 0; +} + +void SocketStreamHandleInternal::connect(const KURL& url) +{ + m_socket.set(webKitClient()->createSocketStreamHandle()); + LOG(Network, "connect"); + ASSERT(m_socket.get()); + m_socket->connect(url, this); +} + +int SocketStreamHandleInternal::send(const char* data, int len) +{ + LOG(Network, "send len=%d", len); + ASSERT(m_socket.get()); + if (m_pendingAmountSent + len >= m_maxPendingSendAllowed) + len = m_maxPendingSendAllowed - m_pendingAmountSent - 1; + + if (len <= 0) + return len; + WebData webdata(data, len); + if (m_socket->send(webdata)) { + m_pendingAmountSent += len; + LOG(Network, "sent"); + return len; + } + LOG(Network, "busy. buffering"); + return 0; +} + +void SocketStreamHandleInternal::close() +{ + LOG(Network, "close"); + m_socket->close(); +} + +void SocketStreamHandleInternal::didOpenStream(WebSocketStreamHandle* socketHandle, int maxPendingSendAllowed) +{ + LOG(Network, "SocketStreamHandleInternal::didOpen %d", + maxPendingSendAllowed); + ASSERT(maxPendingSendAllowed > 0); + if (m_handle && m_socket.get()) { + ASSERT(socketHandle == m_socket.get()); + m_maxPendingSendAllowed = maxPendingSendAllowed; + m_handle->m_state = SocketStreamHandleBase::Open; + if (m_handle->m_client) { + m_handle->m_client->didOpen(m_handle); + return; + } + } + LOG(Network, "no m_handle or m_socket?"); +} + +void SocketStreamHandleInternal::didSendData(WebSocketStreamHandle* socketHandle, int amountSent) +{ + LOG(Network, "SocketStreamHandleInternal::didSendData %d", amountSent); + ASSERT(amountSent > 0); + if (m_handle && m_socket.get()) { + ASSERT(socketHandle == m_socket.get()); + m_pendingAmountSent -= amountSent; + ASSERT(m_pendingAmountSent >= 0); + m_handle->sendPendingData(); + } +} + +void SocketStreamHandleInternal::didReceiveData(WebSocketStreamHandle* socketHandle, const WebData& data) +{ + LOG(Network, "didReceiveData"); + if (m_handle && m_socket.get()) { + ASSERT(socketHandle == m_socket.get()); + if (m_handle->m_client) + m_handle->m_client->didReceiveData(m_handle, data.data(), data.size()); + } +} + +void SocketStreamHandleInternal::didClose(WebSocketStreamHandle* socketHandle) +{ + LOG(Network, "didClose"); + if (m_handle && m_socket.get()) { + ASSERT(socketHandle == m_socket.get()); + m_socket.clear(); + SocketStreamHandle* h = m_handle; + m_handle = 0; + if (h->m_client) + h->m_client->didClose(h); + } +} + +void SocketStreamHandleInternal::didFail(WebSocketStreamHandle* socketHandle, const WebSocketStreamError& err) +{ + LOG(Network, "didFail"); + if (m_handle && m_socket.get()) { + ASSERT(socketHandle == m_socket.get()); + m_socket.clear(); + SocketStreamHandle* h = m_handle; + m_handle = 0; + if (h->m_client) + h->m_client->didClose(h); // didFail(h, err); + } +} + +// FIXME: auth + +// SocketStreamHandle ---------------------------------------------------------- + +SocketStreamHandle::SocketStreamHandle(const KURL& url, SocketStreamHandleClient* client) + : SocketStreamHandleBase(url, client) +{ + m_internal = SocketStreamHandleInternal::create(this); + m_internal->connect(m_url); +} + +SocketStreamHandle::~SocketStreamHandle() +{ + setClient(0); + m_internal.clear(); +} + +int SocketStreamHandle::platformSend(const char* buf, int len) +{ + if (!m_internal.get()) + return 0; + return m_internal->send(buf, len); +} + +void SocketStreamHandle::platformClose() +{ + if (m_internal.get()) + m_internal->close(); +} + +void SocketStreamHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge& challenge) +{ + if (m_client) + m_client->didReceiveAuthenticationChallenge(this, challenge); +} + +void SocketStreamHandle::receivedCredential(const AuthenticationChallenge& challenge, const Credential& credential) +{ + notImplemented(); +} + +void SocketStreamHandle::receivedRequestToContinueWithoutCredential(const AuthenticationChallenge& challenge) +{ + notImplemented(); +} + +} // namespace WebCore + +#endif // ENABLE(WEB_SOCKETS) diff --git a/WebKit/chromium/src/StorageAreaProxy.cpp b/WebKit/chromium/src/StorageAreaProxy.cpp new file mode 100644 index 0000000..551507f --- /dev/null +++ b/WebKit/chromium/src/StorageAreaProxy.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2009 Google Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GOOGLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "StorageAreaProxy.h" + +#if ENABLE(DOM_STORAGE) + +#include "Document.h" +#include "ExceptionCode.h" +#include "Frame.h" +#include "SecurityOrigin.h" +#include "StorageAreaImpl.h" + +#include "WebStorageArea.h" +#include "WebString.h" +#include "WebURL.h" + +namespace WebCore { + +StorageAreaProxy::StorageAreaProxy(WebKit::WebStorageArea* storageArea) + : m_storageArea(storageArea) +{ +} + +StorageAreaProxy::~StorageAreaProxy() +{ +} + +unsigned StorageAreaProxy::length() const +{ + return m_storageArea->length(); +} + +String StorageAreaProxy::key(unsigned index) const +{ + return m_storageArea->key(index); +} + +String StorageAreaProxy::getItem(const String& key) const +{ + return m_storageArea->getItem(key); +} + +void StorageAreaProxy::setItem(const String& key, const String& value, ExceptionCode& ec, Frame* frame) +{ + bool quotaException = false; + m_storageArea->setItem(key, value, frame->document()->url(), quotaException); + ec = quotaException ? QUOTA_EXCEEDED_ERR : 0; +} + +void StorageAreaProxy::removeItem(const String& key, Frame* frame) +{ + m_storageArea->removeItem(key, frame->document()->url()); +} + +void StorageAreaProxy::clear(Frame* frame) +{ + m_storageArea->clear(frame->document()->url()); +} + +bool StorageAreaProxy::contains(const String& key) const +{ + return !getItem(key).isNull(); +} + +} // namespace WebCore + +#endif // ENABLE(DOM_STORAGE) diff --git a/WebKit/chromium/src/StorageAreaProxy.h b/WebKit/chromium/src/StorageAreaProxy.h new file mode 100644 index 0000000..5d09d82 --- /dev/null +++ b/WebKit/chromium/src/StorageAreaProxy.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2009 Google Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GOOGLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef StorageAreaProxy_h +#define StorageAreaProxy_h + +#if ENABLE(DOM_STORAGE) + +#include "StorageArea.h" + +namespace WebKit { class WebStorageArea; } + +namespace WebCore { + +class StorageAreaProxy : public StorageArea { +public: + StorageAreaProxy(WebKit::WebStorageArea* storageArea); + virtual ~StorageAreaProxy(); + + // The HTML5 DOM Storage API + virtual unsigned length() const; + virtual String key(unsigned index) const; + virtual String getItem(const String& key) const; + virtual void setItem(const String& key, const String& value, ExceptionCode& ec, Frame* sourceFrame); + virtual void removeItem(const String& key, Frame* sourceFrame); + virtual void clear(Frame* sourceFrame); + virtual bool contains(const String& key) const; + +private: + OwnPtr<WebKit::WebStorageArea> m_storageArea; +}; + +} // namespace WebCore + +#endif // ENABLE(DOM_STORAGE) + +#endif // StorageAreaProxy_h diff --git a/WebKit/chromium/src/StorageEventDispatcherChromium.cpp b/WebKit/chromium/src/StorageEventDispatcherChromium.cpp new file mode 100644 index 0000000..3286929 --- /dev/null +++ b/WebKit/chromium/src/StorageEventDispatcherChromium.cpp @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "StorageEventDispatcher.h" + +#if ENABLE(DOM_STORAGE) + +#include "SecurityOrigin.h" +#include "StorageArea.h" + +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebString.h" +#include "WebURL.h" + +namespace WebCore { + +void StorageEventDispatcher::dispatch(const String& key, const String& oldValue, + const String& newValue, StorageType storageType, + SecurityOrigin* origin, Frame* sourceFrame) +{ + ASSERT(!sourceFrame); // Sad, but true. + WebKit::webKitClient()->dispatchStorageEvent(key, oldValue, newValue, origin->toString(), WebKit::WebURL(), storageType == LocalStorage); +} + +} // namespace WebCore + +#endif // ENABLE(DOM_STORAGE) diff --git a/WebKit/chromium/src/StorageEventDispatcherImpl.cpp b/WebKit/chromium/src/StorageEventDispatcherImpl.cpp new file mode 100644 index 0000000..3518796 --- /dev/null +++ b/WebKit/chromium/src/StorageEventDispatcherImpl.cpp @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "StorageEventDispatcherImpl.h" + +#if ENABLE(DOM_STORAGE) + +#include "DOMWindow.h" +#include "EventNames.h" +#include "Frame.h" +#include "KURL.h" +#include "Page.h" +#include "PageGroup.h" +#include "SecurityOrigin.h" +#include "StorageEvent.h" + +namespace WebCore { + +StorageEventDispatcherImpl::StorageEventDispatcherImpl(const String& groupName) + : m_pageGroup(PageGroup::pageGroup(groupName)) +{ + ASSERT(m_pageGroup); +} + +void StorageEventDispatcherImpl::dispatchStorageEvent(const String& key, const String& oldValue, + const String& newValue, SecurityOrigin* securityOrigin, + const KURL& url, StorageType storageType) +{ + // FIXME: Implement + if (storageType == SessionStorage) + return; + + // We need to copy all relevant frames from every page to a vector since sending the event to one frame might mutate the frame tree + // of any given page in the group or mutate the page group itself. + Vector<RefPtr<Frame> > frames; + + const HashSet<Page*>& pages = m_pageGroup->pages(); + HashSet<Page*>::const_iterator end = pages.end(); + for (HashSet<Page*>::const_iterator it = pages.begin(); it != end; ++it) { + for (Frame* frame = (*it)->mainFrame(); frame; frame = frame->tree()->traverseNext()) { + if (frame->document()->securityOrigin()->equal(securityOrigin)) + frames.append(frame); + } + } + + // FIXME: Figure out how to pass in the document URI. + for (unsigned i = 0; i < frames.size(); ++i) { + frames[i]->document()->dispatchWindowEvent(StorageEvent::create(eventNames().storageEvent, key, oldValue, newValue, + url, frames[i]->domWindow()->localStorage())); + } +} + +} // namespace WebCore + +#endif // ENABLE(DOM_STORAGE) diff --git a/WebKit/chromium/src/StorageEventDispatcherImpl.h b/WebKit/chromium/src/StorageEventDispatcherImpl.h new file mode 100644 index 0000000..4c2db7c --- /dev/null +++ b/WebKit/chromium/src/StorageEventDispatcherImpl.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef StorageEventDispatcherImpl_h +#define StorageEventDispatcherImpl_h + +#if ENABLE(DOM_STORAGE) + +#include "PlatformString.h" +#include "StorageArea.h" + +namespace WebCore { + +class KURL; +class PageGroup; +class SecurityOrigin; + +class StorageEventDispatcherImpl { +public: + StorageEventDispatcherImpl(const String& groupName); + + void dispatchStorageEvent(const String& key, const String& oldValue, + const String& newValue, SecurityOrigin*, + const KURL&, StorageType); + +private: + PageGroup* m_pageGroup; +}; + +} // namespace WebCore + +#endif // ENABLE(DOM_STORAGE) + +#endif // StorageEventDispatcherImpl_h diff --git a/WebKit/chromium/src/StorageNamespaceProxy.cpp b/WebKit/chromium/src/StorageNamespaceProxy.cpp new file mode 100644 index 0000000..e22bbef --- /dev/null +++ b/WebKit/chromium/src/StorageNamespaceProxy.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2009 Google Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GOOGLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "StorageNamespaceProxy.h" + +#if ENABLE(DOM_STORAGE) + +#include "SecurityOrigin.h" +#include "StorageAreaProxy.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebStorageNamespace.h" +#include "WebString.h" + +namespace WebCore { + +PassRefPtr<StorageNamespace> StorageNamespace::localStorageNamespace(const String& path, unsigned quota) +{ + return new StorageNamespaceProxy(WebKit::webKitClient()->createLocalStorageNamespace(path, quota)); +} + +PassRefPtr<StorageNamespace> StorageNamespace::sessionStorageNamespace() +{ + return new StorageNamespaceProxy(WebKit::webKitClient()->createSessionStorageNamespace()); +} + +StorageNamespaceProxy::StorageNamespaceProxy(WebKit::WebStorageNamespace* storageNamespace) + : m_storageNamespace(storageNamespace) +{ +} + +StorageNamespaceProxy::~StorageNamespaceProxy() +{ +} + +PassRefPtr<StorageNamespace> StorageNamespaceProxy::copy() +{ + return adoptRef(new StorageNamespaceProxy(m_storageNamespace->copy())); +} + +PassRefPtr<StorageArea> StorageNamespaceProxy::storageArea(PassRefPtr<SecurityOrigin> origin) +{ + return adoptRef(new StorageAreaProxy(m_storageNamespace->createStorageArea(origin->toString()))); +} + +void StorageNamespaceProxy::close() +{ + m_storageNamespace->close(); +} + +void StorageNamespaceProxy::unlock() +{ + // FIXME: Implement. +} + +} // namespace WebCore + +#endif // ENABLE(DOM_STORAGE) diff --git a/WebKit/chromium/src/StorageNamespaceProxy.h b/WebKit/chromium/src/StorageNamespaceProxy.h new file mode 100644 index 0000000..9ff624b --- /dev/null +++ b/WebKit/chromium/src/StorageNamespaceProxy.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2009 Google Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GOOGLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef StorageNamespaceProxy_h +#define StorageNamespaceProxy_h + +#if ENABLE(DOM_STORAGE) + +#include "StorageNamespace.h" + +namespace WebKit { class WebStorageNamespace; } + +namespace WebCore { + +class StorageNamespaceProxy : public StorageNamespace { +public: + StorageNamespaceProxy(WebKit::WebStorageNamespace* storageNamespace); + virtual ~StorageNamespaceProxy(); + virtual PassRefPtr<StorageArea> storageArea(PassRefPtr<SecurityOrigin>); + virtual PassRefPtr<StorageNamespace> copy(); + virtual void close(); + virtual void unlock(); + +private: + OwnPtr<WebKit::WebStorageNamespace> m_storageNamespace; +}; + +} // namespace WebCore + +#endif // ENABLE(DOM_STORAGE) + +#endif // StorageNamespaceProxy_h diff --git a/WebKit/chromium/src/WebAccessibilityCache.cpp b/WebKit/chromium/src/WebAccessibilityCache.cpp new file mode 100644 index 0000000..8a3f697 --- /dev/null +++ b/WebKit/chromium/src/WebAccessibilityCache.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebAccessibilityCache.h" + +#include "AXObjectCache.h" + +using namespace WebCore; + +namespace WebKit { + +void WebAccessibilityCache::enableAccessibility() +{ + AXObjectCache::enableAccessibility(); +} + +} diff --git a/WebKit/chromium/src/WebAccessibilityCacheImpl.cpp b/WebKit/chromium/src/WebAccessibilityCacheImpl.cpp new file mode 100644 index 0000000..03e5f46 --- /dev/null +++ b/WebKit/chromium/src/WebAccessibilityCacheImpl.cpp @@ -0,0 +1,169 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebAccessibilityCacheImpl.h" + +#include "AccessibilityObject.h" +#include "AXObjectCache.h" +#include "Document.h" +#include "Frame.h" + +#include "WebAccessibilityObject.h" +#include "WebFrameImpl.h" +#include "WebViewImpl.h" + +using namespace WebCore; + +namespace WebKit { + +const int invalidObjectId = -1; +const int firstObjectId = 1000; + +static PassRefPtr<AccessibilityObject> toAccessibilityObject(const WebAccessibilityObject& object) +{ + return object; +} + +// WebView ---------------------------------------------------------------- + +WebAccessibilityCache* WebAccessibilityCache::create() +{ + return new WebAccessibilityCacheImpl(); +} + +// WeakHandle ------------------------------------------------------------- + +PassRefPtr<WebAccessibilityCacheImpl::WeakHandle> WebAccessibilityCacheImpl::WeakHandle::create(AccessibilityObject* object) +{ + // FIXME: Remove resetting ref-count from AccessibilityObjectWrapper + // and convert to use adoptRef. + return new WebAccessibilityCacheImpl::WeakHandle(object); +} + +WebAccessibilityCacheImpl::WeakHandle::WeakHandle(AccessibilityObject* object) + : AccessibilityObjectWrapper(object) +{ + m_object->setWrapper(this); +} + +// WebAccessibilityCacheImpl ---------------------------------------- + +void WebAccessibilityCacheImpl::WeakHandle::detach() +{ + if (m_object) + m_object = 0; +} + +WebAccessibilityCacheImpl::WebAccessibilityCacheImpl() + : m_nextNewId(firstObjectId) + , m_initialized(false) +{ +} + +WebAccessibilityCacheImpl::~WebAccessibilityCacheImpl() +{ +} + +void WebAccessibilityCacheImpl::initialize(WebView* view) +{ + AXObjectCache::enableAccessibility(); + WebAccessibilityObject root = view->accessibilityObject(); + if (root.isNull()) + return; + + RefPtr<AccessibilityObject> rootObject = toAccessibilityObject(root); + + // Insert root in hashmaps. + m_objectMap.set(m_nextNewId, WeakHandle::create(rootObject.get())); + m_idMap.set(rootObject.get(), m_nextNewId++); + + m_initialized = true; +} + +WebAccessibilityObject WebAccessibilityCacheImpl::getObjectById(int id) +{ + ObjectMap::iterator it = m_objectMap.find(id); + + if (it == m_objectMap.end() || !it->second) + return WebAccessibilityObject(); + + return WebAccessibilityObject(it->second->accessibilityObject()); +} + +bool WebAccessibilityCacheImpl::isValidId(int id) const +{ + return id >= firstObjectId; +} + +void WebAccessibilityCacheImpl::remove(int id) +{ + ObjectMap::iterator it = m_objectMap.find(id); + + if (it == m_objectMap.end()) + return; + + if (it->second) { + // Erase element from reverse hashmap. + IdMap::iterator it2 = m_idMap.find(it->second->accessibilityObject()); + if (it2 != m_idMap.end()) + m_idMap.remove(it2); + } + + m_objectMap.remove(it); +} + +void WebAccessibilityCacheImpl::clear() +{ + m_objectMap.clear(); + m_idMap.clear(); +} + +int WebAccessibilityCacheImpl::addOrGetId(const WebAccessibilityObject& object) +{ + if (object.isNull()) + return invalidObjectId; + + RefPtr<AccessibilityObject> o = toAccessibilityObject(object); + + IdMap::iterator it = m_idMap.find(o.get()); + + if (it != m_idMap.end()) + return it->second; + + // Insert new accessibility object in hashmaps and return its newly + // assigned accessibility object id. + m_objectMap.set(m_nextNewId, WeakHandle::create(o.get())); + m_idMap.set(o.get(), m_nextNewId); + + return m_nextNewId++; +} + +} diff --git a/WebKit/chromium/src/WebAccessibilityCacheImpl.h b/WebKit/chromium/src/WebAccessibilityCacheImpl.h new file mode 100644 index 0000000..5148b74 --- /dev/null +++ b/WebKit/chromium/src/WebAccessibilityCacheImpl.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebAccessibilityCacheImpl_h +#define WebAccessibilityCacheImpl_h + +#include "AccessibilityObjectWrapper.h" +#include "WebAccessibilityCache.h" +#include <wtf/HashMap.h> +#include <wtf/PassRefPtr.h> + +namespace WebKit { + +// FIXME: Should be eliminated to use AXObjectCache instead. +class WebAccessibilityCacheImpl : public WebKit::WebAccessibilityCache { +public: + virtual void initialize(WebView* view); + virtual bool isInitialized() const { return m_initialized; } + + virtual WebAccessibilityObject getObjectById(int); + virtual bool isValidId(int) const; + virtual int addOrGetId(const WebKit::WebAccessibilityObject&); + + virtual void remove(int); + virtual void clear(); + +protected: + friend class WebKit::WebAccessibilityCache; + + WebAccessibilityCacheImpl(); + ~WebAccessibilityCacheImpl(); + +private: + // FIXME: This can be just part of Chromium's AccessibilityObjectWrapper. + class WeakHandle : public WebCore::AccessibilityObjectWrapper { + public: + static PassRefPtr<WeakHandle> create(WebCore::AccessibilityObject*); + virtual void detach(); + private: + WeakHandle(WebCore::AccessibilityObject*); + }; + + typedef HashMap<int, RefPtr<WeakHandle> > ObjectMap; + typedef HashMap<WebCore::AccessibilityObject*, int> IdMap; + + // Hashmap for caching of elements in use by the AT, mapping id (int) to + // WebAccessibilityObject. + ObjectMap m_objectMap; + // Hashmap for caching of elements in use by the AT, mapping a + // AccessibilityObject pointer to its id (int). Needed for reverse lookup, + // to ensure unnecessary duplicate entries are not created in the + // ObjectMap and for focus changes in WebKit. + IdMap m_idMap; + + // Unique identifier for retrieving an accessibility object from the page's + // hashmaps. Id is always 0 for the root of the accessibility object + // hierarchy (on a per-renderer process basis). + int m_nextNewId; + + bool m_initialized; +}; + +} + +#endif diff --git a/WebKit/chromium/src/WebAccessibilityObject.cpp b/WebKit/chromium/src/WebAccessibilityObject.cpp new file mode 100644 index 0000000..bdbd260 --- /dev/null +++ b/WebKit/chromium/src/WebAccessibilityObject.cpp @@ -0,0 +1,413 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebAccessibilityObject.h" + +#include "AccessibilityObject.h" +#include "EventHandler.h" +#include "FrameView.h" +#include "PlatformKeyboardEvent.h" +#include "WebPoint.h" +#include "WebRect.h" +#include "WebString.h" + +using namespace WebCore; + +namespace WebKit { + +class WebAccessibilityObjectPrivate : public WebCore::AccessibilityObject { +}; + +void WebAccessibilityObject::reset() +{ + assign(0); +} + +void WebAccessibilityObject::assign(const WebKit::WebAccessibilityObject& other) +{ + WebAccessibilityObjectPrivate* p = const_cast<WebAccessibilityObjectPrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +WebString WebAccessibilityObject::accessibilityDescription() const +{ + if (!m_private) + return WebString(); + + m_private->updateBackingStore(); + return m_private->accessibilityDescription(); +} + +WebString WebAccessibilityObject::actionVerb() const +{ + if (!m_private) + return WebString(); + + m_private->updateBackingStore(); + return m_private->actionVerb(); +} + +bool WebAccessibilityObject::canSetFocusAttribute() const +{ + if (!m_private) + return false; + + m_private->updateBackingStore(); + return m_private->canSetFocusAttribute(); +} + +bool WebAccessibilityObject::canSetValueAttribute() const +{ + if (!m_private) + return false; + + m_private->updateBackingStore(); + return m_private->canSetValueAttribute(); +} + +unsigned WebAccessibilityObject::childCount() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->children().size(); +} + +WebAccessibilityObject WebAccessibilityObject::childAt(unsigned index) const +{ + if (!m_private) + return WebAccessibilityObject(); + + m_private->updateBackingStore(); + if (m_private->children().size() <= index) + return WebAccessibilityObject(); + + return WebAccessibilityObject(m_private->children()[index]); +} + +WebAccessibilityObject WebAccessibilityObject::firstChild() const +{ + if (!m_private) + return WebAccessibilityObject(); + + m_private->updateBackingStore(); + return WebAccessibilityObject(m_private->firstChild()); +} + +WebAccessibilityObject WebAccessibilityObject::focusedChild() const +{ + if (!m_private) + return WebAccessibilityObject(); + + m_private->updateBackingStore(); + RefPtr<AccessibilityObject> focused = m_private->focusedUIElement(); + if (m_private == focused.get() || focused->parentObject() == m_private) + return WebAccessibilityObject(focused); + + return WebAccessibilityObject(); +} + +WebAccessibilityObject WebAccessibilityObject::lastChild() const +{ + if (!m_private) + return WebAccessibilityObject(); + + m_private->updateBackingStore(); + return WebAccessibilityObject(m_private->lastChild()); +} + + +WebAccessibilityObject WebAccessibilityObject::nextSibling() const +{ + if (!m_private) + return WebAccessibilityObject(); + + m_private->updateBackingStore(); + return WebAccessibilityObject(m_private->nextSibling()); +} + +WebAccessibilityObject WebAccessibilityObject::parentObject() const +{ + if (!m_private) + return WebAccessibilityObject(); + + m_private->updateBackingStore(); + return WebAccessibilityObject(m_private->parentObject()); +} + + +WebAccessibilityObject WebAccessibilityObject::previousSibling() const +{ + if (!m_private) + return WebAccessibilityObject(); + + m_private->updateBackingStore(); + return WebAccessibilityObject(m_private->previousSibling()); +} + +bool WebAccessibilityObject::isAnchor() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isAnchor(); +} + +bool WebAccessibilityObject::isChecked() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isChecked(); +} + + +bool WebAccessibilityObject::isFocused() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isFocused(); +} + +bool WebAccessibilityObject::isEnabled() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isEnabled(); +} + +bool WebAccessibilityObject::isHovered() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isHovered(); +} + +bool WebAccessibilityObject::isIndeterminate() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isIndeterminate(); +} + +bool WebAccessibilityObject::isMultiSelect() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isMultiSelect(); +} + +bool WebAccessibilityObject::isOffScreen() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isOffScreen(); +} + +bool WebAccessibilityObject::isPasswordField() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isPasswordField(); +} + +bool WebAccessibilityObject::isPressed() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isPressed(); +} + +bool WebAccessibilityObject::isReadOnly() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isReadOnly(); +} + +bool WebAccessibilityObject::isVisited() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isVisited(); +} + +WebRect WebAccessibilityObject::boundingBoxRect() const +{ + if (!m_private) + return WebRect(); + + m_private->updateBackingStore(); + return m_private->documentFrameView()->contentsToWindow(m_private->boundingBoxRect()); +} + +WebString WebAccessibilityObject::helpText() const +{ + if (!m_private) + return WebString(); + + m_private->updateBackingStore(); + return m_private->helpText(); +} + +WebAccessibilityObject WebAccessibilityObject::hitTest(const WebPoint& point) const +{ + if (!m_private) + return WebAccessibilityObject(); + + m_private->updateBackingStore(); + IntPoint contentsPoint = m_private->documentFrameView()->windowToContents(point); + RefPtr<AccessibilityObject> hit = m_private->doAccessibilityHitTest(contentsPoint); + + if (hit.get()) + return WebAccessibilityObject(hit); + + if (m_private->boundingBoxRect().contains(contentsPoint)) + return *this; + + return WebAccessibilityObject(); +} + +WebString WebAccessibilityObject::keyboardShortcut() const +{ + if (!m_private) + return WebString(); + + m_private->updateBackingStore(); + String accessKey = m_private->accessKey(); + if (accessKey.isNull()) + return WebString(); + + static String modifierString; + if (modifierString.isNull()) { + unsigned modifiers = EventHandler::accessKeyModifiers(); + // Follow the same order as Mozilla MSAA implementation: + // Ctrl+Alt+Shift+Meta+key. MSDN states that keyboard shortcut strings + // should not be localized and defines the separator as "+". + if (modifiers & PlatformKeyboardEvent::CtrlKey) + modifierString += "Ctrl+"; + if (modifiers & PlatformKeyboardEvent::AltKey) + modifierString += "Alt+"; + if (modifiers & PlatformKeyboardEvent::ShiftKey) + modifierString += "Shift+"; + if (modifiers & PlatformKeyboardEvent::MetaKey) + modifierString += "Win+"; + } + + return modifierString + accessKey; +} + +bool WebAccessibilityObject::performDefaultAction() const +{ + if (!m_private) + return false; + + m_private->updateBackingStore(); + return m_private->performDefaultAction(); +} + +WebAccessibilityRole WebAccessibilityObject::roleValue() const +{ + if (!m_private) + return WebKit::WebAccessibilityRoleUnknown; + + m_private->updateBackingStore(); + return static_cast<WebAccessibilityRole>(m_private->roleValue()); +} + +WebString WebAccessibilityObject::stringValue() const +{ + if (!m_private) + return WebString(); + + m_private->updateBackingStore(); + return m_private->stringValue(); +} + +WebString WebAccessibilityObject::title() const +{ + if (!m_private) + return WebString(); + + m_private->updateBackingStore(); + return m_private->title(); +} + +WebAccessibilityObject::WebAccessibilityObject(const WTF::PassRefPtr<WebCore::AccessibilityObject>& object) + : m_private(static_cast<WebAccessibilityObjectPrivate*>(object.releaseRef())) +{ +} + +WebAccessibilityObject& WebAccessibilityObject::operator=(const WTF::PassRefPtr<WebCore::AccessibilityObject>& object) +{ + assign(static_cast<WebAccessibilityObjectPrivate*>(object.releaseRef())); + return *this; +} + +WebAccessibilityObject::operator WTF::PassRefPtr<WebCore::AccessibilityObject>() const +{ + return PassRefPtr<WebCore::AccessibilityObject>(const_cast<WebAccessibilityObjectPrivate*>(m_private)); +} + +void WebAccessibilityObject::assign(WebAccessibilityObjectPrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebBindings.cpp b/WebKit/chromium/src/WebBindings.cpp new file mode 100644 index 0000000..0bc67b6 --- /dev/null +++ b/WebKit/chromium/src/WebBindings.cpp @@ -0,0 +1,323 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebBindings.h" + +#include "npruntime_impl.h" +#include "npruntime_priv.h" + +#include "../public/WebDragData.h" +#include "../public/WebRange.h" + +#if USE(V8) +#include "ChromiumDataObject.h" +#include "ClipboardChromium.h" +#include "EventNames.h" +#include "MouseEvent.h" +#include "NPV8Object.h" // for PrivateIdentifier +#include "Range.h" +#include "V8DOMWrapper.h" +#include "V8Helpers.h" +#include "V8Proxy.h" +#elif USE(JSC) +#include "bridge/c/c_utility.h" +#endif + +#if USE(JAVASCRIPTCORE_BINDINGS) +using JSC::Bindings::PrivateIdentifier; +#endif + +using namespace WebCore; + +namespace WebKit { + +bool WebBindings::construct(NPP npp, NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant* result) +{ + return _NPN_Construct(npp, npobj, args, argCount, result); +} + +NPObject* WebBindings::createObject(NPP npp, NPClass* npClass) +{ + return _NPN_CreateObject(npp, npClass); +} + +bool WebBindings::enumerate(NPP id, NPObject* obj, NPIdentifier** identifier, uint32_t* val) +{ + return _NPN_Enumerate(id, obj, identifier, val); +} + +bool WebBindings::evaluate(NPP npp, NPObject* npObject, NPString* npScript, NPVariant* result) +{ + return _NPN_Evaluate(npp, npObject, npScript, result); +} + +bool WebBindings::evaluateHelper(NPP npp, bool popups_allowed, NPObject* npobj, NPString* npscript, NPVariant* result) +{ + return _NPN_EvaluateHelper(npp, popups_allowed, npobj, npscript, result); +} + +NPIdentifier WebBindings::getIntIdentifier(int32_t number) +{ + return _NPN_GetIntIdentifier(number); +} + +bool WebBindings::getProperty(NPP npp, NPObject* obj, NPIdentifier propertyName, NPVariant *result) +{ + return _NPN_GetProperty(npp, obj, propertyName, result); +} + +NPIdentifier WebBindings::getStringIdentifier(const NPUTF8* string) +{ + return _NPN_GetStringIdentifier(string); +} + +void WebBindings::getStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers) +{ + _NPN_GetStringIdentifiers(names, nameCount, identifiers); +} + +bool WebBindings::hasMethod(NPP npp, NPObject* npObject, NPIdentifier methodName) +{ + return _NPN_HasMethod(npp, npObject, methodName); +} + +bool WebBindings::hasProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName) +{ + return _NPN_HasProperty(npp, npObject, propertyName); +} + +bool WebBindings::identifierIsString(NPIdentifier identifier) +{ + return _NPN_IdentifierIsString(identifier); +} + +int32_t WebBindings::intFromIdentifier(NPIdentifier identifier) +{ + return _NPN_IntFromIdentifier(identifier); +} + +void WebBindings::initializeVariantWithStringCopy(NPVariant* variant, const NPString* value) +{ +#if USE(V8) + _NPN_InitializeVariantWithStringCopy(variant, value); +#else + NPN_InitializeVariantWithStringCopy(variant, value); +#endif +} + +bool WebBindings::invoke(NPP npp, NPObject* npObject, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result) +{ + return _NPN_Invoke(npp, npObject, methodName, arguments, argumentCount, result); +} + +bool WebBindings::invokeDefault(NPP id, NPObject* obj, const NPVariant* args, uint32_t count, NPVariant* result) +{ + return _NPN_InvokeDefault(id, obj, args, count, result); +} + +void WebBindings::releaseObject(NPObject* npObject) +{ + return _NPN_ReleaseObject(npObject); +} + +void WebBindings::releaseVariantValue(NPVariant* variant) +{ + _NPN_ReleaseVariantValue(variant); +} + +bool WebBindings::removeProperty(NPP id, NPObject* object, NPIdentifier identifier) +{ + return _NPN_RemoveProperty(id, object, identifier); +} + +NPObject* WebBindings::retainObject(NPObject* npObject) +{ + return _NPN_RetainObject(npObject); +} + +void WebBindings::setException(NPObject* obj, const NPUTF8* message) +{ + _NPN_SetException(obj, message); +} + +bool WebBindings::setProperty(NPP id, NPObject* obj, NPIdentifier identifier, const NPVariant* variant) +{ + return _NPN_SetProperty(id, obj, identifier, variant); +} + +void WebBindings::unregisterObject(NPObject* npObject) +{ +#if USE(V8) + _NPN_UnregisterObject(npObject); +#endif +} + +NPUTF8* WebBindings::utf8FromIdentifier(NPIdentifier identifier) +{ + return _NPN_UTF8FromIdentifier(identifier); +} + +void WebBindings::extractIdentifierData(const NPIdentifier& identifier, const NPUTF8*& string, int32_t& number, bool& isString) +{ + PrivateIdentifier* priv = static_cast<PrivateIdentifier*>(identifier); + if (!priv) { + isString = false; + number = 0; + return; + } + + isString = priv->isString; + if (isString) + string = priv->value.string; + else + number = priv->value.number; +} + +#if USE(V8) + +static v8::Local<v8::Value> getEvent(const v8::Handle<v8::Context>& context) +{ + static v8::Persistent<v8::String> eventSymbol(v8::Persistent<v8::String>::New(v8::String::NewSymbol("event"))); + return context->Global()->GetHiddenValue(eventSymbol); +} + +static bool getDragDataImpl(NPObject* npobj, int* eventId, WebDragData* data) +{ + if (!npobj) + return false; + if (npobj->_class != npScriptObjectClass) + return false; + + v8::HandleScope handleScope; + v8::Handle<v8::Context> context = v8::Context::GetEntered(); + if (context.IsEmpty()) + return false; + + // Get the current WebCore event. + v8::Handle<v8::Value> currentEvent(getEvent(context)); + Event* event = V8DOMWrapper::convertToNativeEvent(currentEvent); + if (!event) + return false; + + // Check that the given npobj is that event. + V8NPObject* object = reinterpret_cast<V8NPObject*>(npobj); + Event* given = V8DOMWrapper::convertToNativeEvent(object->v8Object); + if (given != event) + return false; + + // Check the execution frames are same origin. + V8Proxy* current = V8Proxy::retrieve(V8Proxy::retrieveFrameForCurrentContext()); + Frame* frame = V8Proxy::retrieveFrame(context); + if (!current || !current->canAccessFrame(frame, false)) + return false; + + const EventNames& names(eventNames()); + const AtomicString& eventType(event->type()); + + enum DragTargetMouseEventId { + DragEnterId = 1, DragOverId = 2, DragLeaveId = 3, DropId = 4 + }; + + // The event type should be a drag event. + if (eventType == names.dragenterEvent) + *eventId = DragEnterId; + else if (eventType == names.dragoverEvent) + *eventId = DragOverId; + else if (eventType == names.dragleaveEvent) + *eventId = DragLeaveId; + else if (eventType == names.dropEvent) + *eventId = DropId; + else + return false; + + // Drag events are mouse events and should have a clipboard. + MouseEvent* me = static_cast<MouseEvent*>(event); + Clipboard* clipboard = me->clipboard(); + if (!clipboard) + return false; + + // And that clipboard should be accessible by WebKit policy. + ClipboardChromium* chrome = static_cast<ClipboardChromium*>(clipboard); + HashSet<String> accessible(chrome->types()); + if (accessible.isEmpty()) + return false; + + RefPtr<ChromiumDataObject> dataObject(chrome->dataObject()); + if (dataObject && data) + *data = WebDragData(dataObject); + + return dataObject; +} + +static bool getRangeImpl(NPObject* npobj, WebRange* range) +{ + V8NPObject* v8npobject = reinterpret_cast<V8NPObject*>(npobj); + v8::Handle<v8::Object> v8object(v8npobject->v8Object); + if (V8ClassIndex::RANGE != V8DOMWrapper::domWrapperType(v8object)) + return false; + + Range* native = V8DOMWrapper::convertToNativeObject<WebCore::Range>(V8ClassIndex::RANGE, v8object); + if (!native) + return false; + + *range = WebRange(native); + return true; +} + +#endif + +bool WebBindings::getDragData(NPObject* event, int* eventId, WebDragData* data) +{ +#if USE(V8) + return getDragDataImpl(event, eventId, data); +#else + // Not supported on other ports (JSC, etc). + return false; +#endif +} + +bool WebBindings::isDragEvent(NPObject* event) +{ + int eventId; + return getDragData(event, &eventId, 0); +} + +bool WebBindings::getRange(NPObject* range, WebRange* webrange) +{ +#if USE(V8) + return getRangeImpl(range, webrange); +#else + // Not supported on other ports (JSC, etc). + return false; +#endif +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebCString.cpp b/WebKit/chromium/src/WebCString.cpp new file mode 100644 index 0000000..82fbac0 --- /dev/null +++ b/WebKit/chromium/src/WebCString.cpp @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebCString.h" + +#include "CString.h" +#include "TextEncoding.h" + +#include "WebString.h" + +namespace WebKit { + +class WebCStringPrivate : public WebCore::CStringBuffer { +}; + +void WebCString::reset() +{ + if (m_private) { + m_private->deref(); + m_private = 0; + } +} + +void WebCString::assign(const WebCString& other) +{ + assign(const_cast<WebCStringPrivate*>(other.m_private)); +} + +void WebCString::assign(const char* data, size_t length) +{ + char* newData; + RefPtr<WebCore::CStringBuffer> buffer = + WebCore::CString::newUninitialized(length, newData).buffer(); + memcpy(newData, data, length); + assign(static_cast<WebCStringPrivate*>(buffer.get())); +} + +size_t WebCString::length() const +{ + if (!m_private) + return 0; + // NOTE: The buffer's length includes the null byte. + return const_cast<WebCStringPrivate*>(m_private)->length() - 1; +} + +const char* WebCString::data() const +{ + if (!m_private) + return 0; + return const_cast<WebCStringPrivate*>(m_private)->data(); +} + +WebString WebCString::utf16() const +{ + return WebCore::UTF8Encoding().decode(data(), length()); +} + +WebCString WebCString::fromUTF16(const WebUChar* data, size_t length) +{ + return WebCore::UTF8Encoding().encode( + data, length, WebCore::QuestionMarksForUnencodables); +} + +WebCString WebCString::fromUTF16(const WebUChar* data) +{ + size_t len = 0; + while (data[len] != WebUChar(0)) + len++; + return fromUTF16(data, len); +} + +WebCString::WebCString(const WebCore::CString& s) + : m_private(static_cast<WebCStringPrivate*>(s.buffer())) +{ + if (m_private) + m_private->ref(); +} + +WebCString& WebCString::operator=(const WebCore::CString& s) +{ + assign(static_cast<WebCStringPrivate*>(s.buffer())); + return *this; +} + +WebCString::operator WebCore::CString() const +{ + return m_private; +} + +void WebCString::assign(WebCStringPrivate* p) +{ + // Take care to handle the case where m_private == p + if (p) + p->ref(); + if (m_private) + m_private->deref(); + m_private = p; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebCache.cpp b/WebKit/chromium/src/WebCache.cpp new file mode 100644 index 0000000..9d03a4d --- /dev/null +++ b/WebKit/chromium/src/WebCache.cpp @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebCache.h" + +// Instead of providing accessors, we make all members of Cache public. +// This will make it easier to track WebCore changes to the Cache class. +// FIXME: We should introduce public getters on the Cache class. +#define private public +#include "Cache.h" +#undef private + +using namespace WebCore; + +namespace WebKit { + +// A helper method for coverting a Cache::TypeStatistic to a +// WebCache::ResourceTypeStat. +static void ToResourceTypeStat(const Cache::TypeStatistic& from, + WebCache::ResourceTypeStat& to) +{ + to.count = static_cast<size_t>(from.count); + to.size = static_cast<size_t>(from.size); + to.liveSize = static_cast<size_t>(from.liveSize); + to.decodedSize = static_cast<size_t>(from.decodedSize); +} + +void WebCache::setCapacities( + size_t minDeadCapacity, size_t maxDeadCapacity, size_t capacity) +{ + Cache* cache = WebCore::cache(); + if (cache) + cache->setCapacities(static_cast<unsigned int>(minDeadCapacity), + static_cast<unsigned int>(maxDeadCapacity), + static_cast<unsigned int>(capacity)); +} + +void WebCache::clear() +{ + Cache* cache = WebCore::cache(); + if (cache && !cache->disabled()) { + // NOTE: I think using setDisabled() instead of setCapacities() will + // remove from the cache items that won't actually be freed from memory + // (due to other live references to them), so it just results in wasting + // time later and not saving memory compared to the below technique. + unsigned minDeadCapacity = cache->m_minDeadCapacity; + unsigned maxDeadCapacity = cache->m_maxDeadCapacity; + unsigned capacity = cache->m_capacity; + cache->setCapacities(0, 0, 0); // Will prune the cache. + cache->setCapacities(minDeadCapacity, maxDeadCapacity, capacity); + } +} + +void WebCache::getUsageStats(UsageStats* result) +{ + ASSERT(result); + + Cache* cache = WebCore::cache(); + if (cache) { + result->minDeadCapacity = cache->m_minDeadCapacity; + result->maxDeadCapacity = cache->m_maxDeadCapacity; + result->capacity = cache->m_capacity; + result->liveSize = cache->m_liveSize; + result->deadSize = cache->m_deadSize; + } else + memset(result, 0, sizeof(UsageStats)); +} + +void WebCache::getResourceTypeStats(ResourceTypeStats* result) +{ + Cache* cache = WebCore::cache(); + if (cache) { + Cache::Statistics stats = cache->getStatistics(); + ToResourceTypeStat(stats.images, result->images); + ToResourceTypeStat(stats.cssStyleSheets, result->cssStyleSheets); + ToResourceTypeStat(stats.scripts, result->scripts); +#if ENABLE(XSLT) + ToResourceTypeStat(stats.xslStyleSheets, result->xslStyleSheets); +#else + memset(&result->xslStyleSheets, 0, sizeof(result->xslStyleSheets)); +#endif + ToResourceTypeStat(stats.fonts, result->fonts); + } else + memset(result, 0, sizeof(WebCache::ResourceTypeStats)); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebColor.cpp b/WebKit/chromium/src/WebColor.cpp new file mode 100644 index 0000000..9323433 --- /dev/null +++ b/WebKit/chromium/src/WebColor.cpp @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebColor.h" + +#include "Color.h" +#include "CSSValueKeywords.h" +#include "RenderTheme.h" +#include "UnusedParam.h" +#include "WebColorName.h" + +using namespace::WebCore; + +namespace WebKit { + +static int toCSSValueKeyword(WebColorName in_value) +{ + switch (in_value) { + case WebColorActiveBorder: + return CSSValueActiveborder; + case WebColorActiveCaption: + return CSSValueActivecaption; + case WebColorAppworkspace: + return CSSValueAppworkspace; + case WebColorBackground: + return CSSValueBackground; + case WebColorButtonFace: + return CSSValueButtonface; + case WebColorButtonHighlight: + return CSSValueButtonhighlight; + case WebColorButtonShadow: + return CSSValueButtonshadow; + case WebColorButtonText: + return CSSValueButtontext; + case WebColorCaptionText: + return CSSValueCaptiontext; + case WebColorGrayText: + return CSSValueGraytext; + case WebColorHighlight: + return CSSValueHighlight; + case WebColorHighlightText: + return CSSValueHighlighttext; + case WebColorInactiveBorder: + return CSSValueInactiveborder; + case WebColorInactiveCaption: + return CSSValueInactivecaption; + case WebColorInactiveCaptionText: + return CSSValueInactivecaptiontext; + case WebColorInfoBackground: + return CSSValueInfobackground; + case WebColorInfoText: + return CSSValueInfotext; + case WebColorMenu: + return CSSValueMenu; + case WebColorMenuText: + return CSSValueMenutext; + case WebColorScrollbar: + return CSSValueScrollbar; + case WebColorText: + return CSSValueText; + case WebColorThreedDarkShadow: + return CSSValueThreeddarkshadow; + case WebColorThreedShadow: + return CSSValueThreedshadow; + case WebColorThreedFace: + return CSSValueThreedface; + case WebColorThreedHighlight: + return CSSValueThreedhighlight; + case WebColorThreedLightShadow: + return CSSValueThreedlightshadow; + case WebColorWebkitFocusRingColor: + return CSSValueWebkitFocusRingColor; + case WebColorWindow: + return CSSValueWindow; + case WebColorWindowFrame: + return CSSValueWindowframe; + case WebColorWindowText: + return CSSValueWindowtext; + default: + return CSSValueInvalid; + } +} + +void setNamedColors(const WebColorName* colorNames, const WebColor* colors, size_t length) +{ + for (size_t i = 0; i < length; ++i) { + WebColorName colorName = colorNames[i]; + WebColor color = colors[i]; + + // Convert color to internal value identifier. + int internalColorName = toCSSValueKeyword(colorName); + if (internalColorName == CSSValueWebkitFocusRingColor) { + RenderTheme::setCustomFocusRingColor(color); + continue; + } + } + + // TODO(jeremy): Tell RenderTheme to update colors. +} + +} // WebKit diff --git a/WebKit/chromium/src/WebCrossOriginPreflightResultCache.cpp b/WebKit/chromium/src/WebCrossOriginPreflightResultCache.cpp new file mode 100644 index 0000000..719316d --- /dev/null +++ b/WebKit/chromium/src/WebCrossOriginPreflightResultCache.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebCrossOriginPreflightResultCache.h" + +#include "CrossOriginPreflightResultCache.h" + +namespace WebKit { + +void WebCrossOriginPreflightResultCache::clear() +{ + WebCore::CrossOriginPreflightResultCache::shared().empty(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebCursorInfo.cpp b/WebKit/chromium/src/WebCursorInfo.cpp new file mode 100644 index 0000000..d4b0f81 --- /dev/null +++ b/WebKit/chromium/src/WebCursorInfo.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebCursorInfo.h" + +#include "Cursor.h" + +using namespace WebCore; + +namespace WebKit { + +WebCursorInfo::WebCursorInfo(const Cursor& cursor) +{ + type = static_cast<Type>(cursor.impl().type()); + hotSpot = cursor.impl().hotSpot(); + customImage = cursor.impl().customImage(); +#ifdef WIN32 + externalHandle = 0; +#endif +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebData.cpp b/WebKit/chromium/src/WebData.cpp new file mode 100644 index 0000000..6aafe79 --- /dev/null +++ b/WebKit/chromium/src/WebData.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebData.h" + +#include "SharedBuffer.h" + +using namespace WebCore; + +namespace WebKit { + +class WebDataPrivate : public SharedBuffer { +}; + +void WebData::reset() +{ + if (m_private) { + m_private->deref(); + m_private = 0; + } +} + +void WebData::assign(const WebData& other) +{ + WebDataPrivate* p = const_cast<WebDataPrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +void WebData::assign(const char* data, size_t size) +{ + assign(static_cast<WebDataPrivate*>( + SharedBuffer::create(data, size).releaseRef())); +} + +size_t WebData::size() const +{ + if (!m_private) + return 0; + return const_cast<WebDataPrivate*>(m_private)->size(); +} + +const char* WebData::data() const +{ + if (!m_private) + return 0; + return const_cast<WebDataPrivate*>(m_private)->data(); +} + +WebData::WebData(const PassRefPtr<SharedBuffer>& buffer) + : m_private(static_cast<WebDataPrivate*>(buffer.releaseRef())) +{ +} + +WebData& WebData::operator=(const PassRefPtr<SharedBuffer>& buffer) +{ + assign(static_cast<WebDataPrivate*>(buffer.releaseRef())); + return *this; +} + +WebData::operator PassRefPtr<SharedBuffer>() const +{ + return PassRefPtr<SharedBuffer>(const_cast<WebDataPrivate*>(m_private)); +} + +void WebData::assign(WebDataPrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebDataSourceImpl.cpp b/WebKit/chromium/src/WebDataSourceImpl.cpp new file mode 100644 index 0000000..456706a --- /dev/null +++ b/WebKit/chromium/src/WebDataSourceImpl.cpp @@ -0,0 +1,173 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebDataSourceImpl.h" + +#include "WebURL.h" +#include "WebURLError.h" +#include "WebVector.h" + +using namespace WebCore; + +namespace WebKit { + +WebPluginLoadObserver* WebDataSourceImpl::m_nextPluginLoadObserver = 0; + +PassRefPtr<WebDataSourceImpl> WebDataSourceImpl::create(const ResourceRequest& request, const SubstituteData& data) +{ + return adoptRef(new WebDataSourceImpl(request, data)); +} + +const WebURLRequest& WebDataSourceImpl::originalRequest() const +{ + m_originalRequestWrapper.bind(DocumentLoader::originalRequest()); + return m_originalRequestWrapper; +} + +const WebURLRequest& WebDataSourceImpl::request() const +{ + m_requestWrapper.bind(DocumentLoader::request()); + return m_requestWrapper; +} + +const WebURLResponse& WebDataSourceImpl::response() const +{ + m_responseWrapper.bind(DocumentLoader::response()); + return m_responseWrapper; +} + +bool WebDataSourceImpl::hasUnreachableURL() const +{ + return !DocumentLoader::unreachableURL().isEmpty(); +} + +WebURL WebDataSourceImpl::unreachableURL() const +{ + return DocumentLoader::unreachableURL(); +} + +void WebDataSourceImpl::redirectChain(WebVector<WebURL>& result) const +{ + result.assign(m_redirectChain); +} + +WebString WebDataSourceImpl::pageTitle() const +{ + return title(); +} + +WebNavigationType WebDataSourceImpl::navigationType() const +{ + return toWebNavigationType(triggeringAction().type()); +} + +double WebDataSourceImpl::triggeringEventTime() const +{ + if (!triggeringAction().event()) + return 0.0; + + // DOMTimeStamp uses units of milliseconds. + return triggeringAction().event()->timeStamp() / 1000.0; +} + +WebDataSource::ExtraData* WebDataSourceImpl::extraData() const +{ + return m_extraData.get(); +} + +void WebDataSourceImpl::setExtraData(ExtraData* extraData) +{ + m_extraData.set(extraData); +} + +WebNavigationType WebDataSourceImpl::toWebNavigationType(NavigationType type) +{ + switch (type) { + case NavigationTypeLinkClicked: + return WebNavigationTypeLinkClicked; + case NavigationTypeFormSubmitted: + return WebNavigationTypeFormSubmitted; + case NavigationTypeBackForward: + return WebNavigationTypeBackForward; + case NavigationTypeReload: + return WebNavigationTypeReload; + case NavigationTypeFormResubmitted: + return WebNavigationTypeFormResubmitted; + case NavigationTypeOther: + default: + return WebNavigationTypeOther; + } +} + +const KURL& WebDataSourceImpl::endOfRedirectChain() const +{ + ASSERT(!m_redirectChain.isEmpty()); + return m_redirectChain.last(); +} + +void WebDataSourceImpl::clearRedirectChain() +{ + m_redirectChain.clear(); +} + +void WebDataSourceImpl::appendRedirect(const KURL& url) +{ + m_redirectChain.append(url); +} + +void WebDataSourceImpl::setNextPluginLoadObserver(PassOwnPtr<WebPluginLoadObserver> observer) +{ + // This call should always be followed up with the creation of a + // WebDataSourceImpl, so we should never leak this object. + m_nextPluginLoadObserver = observer.release(); +} + +WebDataSourceImpl::WebDataSourceImpl(const ResourceRequest& request, const SubstituteData& data) + : DocumentLoader(request, data) +{ + if (m_nextPluginLoadObserver) { + // When a new frame is created, it initially gets a data source for an + // empty document. Then it is navigated to the source URL of the + // frame, which results in a second data source being created. We want + // to wait to attach the WebPluginLoadObserver to that data source. + if (!request.url().isEmpty()) { + ASSERT(m_nextPluginLoadObserver->url() == request.url()); + m_pluginLoadObserver.set(m_nextPluginLoadObserver); + m_nextPluginLoadObserver = 0; + } + } +} + +WebDataSourceImpl::~WebDataSourceImpl() +{ +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebDataSourceImpl.h b/WebKit/chromium/src/WebDataSourceImpl.h new file mode 100644 index 0000000..8860fe4 --- /dev/null +++ b/WebKit/chromium/src/WebDataSourceImpl.h @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDataSourceImpl_h +#define WebDataSourceImpl_h + +// FIXME: This relative path is a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebDataSource.h" + +#include "DocumentLoader.h" +#include "KURL.h" + +#include "WebPluginLoadObserver.h" +#include "WrappedResourceRequest.h" +#include "WrappedResourceResponse.h" + +#include <wtf/OwnPtr.h> +#include <wtf/PassOwnPtr.h> +#include <wtf/Vector.h> + + +namespace WebKit { + +class WebPluginLoadObserver; + +class WebDataSourceImpl : public WebCore::DocumentLoader, public WebDataSource { +public: + static PassRefPtr<WebDataSourceImpl> create(const WebCore::ResourceRequest&, + const WebCore::SubstituteData&); + + static WebDataSourceImpl* fromDocumentLoader(WebCore::DocumentLoader* loader) + { + return static_cast<WebDataSourceImpl*>(loader); + } + + // WebDataSource methods: + virtual const WebURLRequest& originalRequest() const; + virtual const WebURLRequest& request() const; + virtual const WebURLResponse& response() const; + virtual bool hasUnreachableURL() const; + virtual WebURL unreachableURL() const; + virtual void redirectChain(WebVector<WebURL>&) const; + virtual WebString pageTitle() const; + virtual WebNavigationType navigationType() const; + virtual double triggeringEventTime() const; + virtual ExtraData* extraData() const; + virtual void setExtraData(ExtraData*); + + static WebNavigationType toWebNavigationType(WebCore::NavigationType type); + + bool hasRedirectChain() const { return !m_redirectChain.isEmpty(); } + const WebCore::KURL& endOfRedirectChain() const; + void clearRedirectChain(); + void appendRedirect(const WebCore::KURL& url); + + PassOwnPtr<WebPluginLoadObserver> releasePluginLoadObserver() { return m_pluginLoadObserver.release(); } + static void setNextPluginLoadObserver(PassOwnPtr<WebPluginLoadObserver>); + +private: + WebDataSourceImpl(const WebCore::ResourceRequest&, const WebCore::SubstituteData&); + ~WebDataSourceImpl(); + + // Mutable because the const getters will magically sync these to the + // latest version from WebKit. + mutable WrappedResourceRequest m_originalRequestWrapper; + mutable WrappedResourceRequest m_requestWrapper; + mutable WrappedResourceResponse m_responseWrapper; + + // Lists all intermediate URLs that have redirected for the current provisional load. + // See WebFrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad for a + // description of who modifies this when to keep it up to date. + Vector<WebCore::KURL> m_redirectChain; + + OwnPtr<ExtraData> m_extraData; + OwnPtr<WebPluginLoadObserver> m_pluginLoadObserver; + + static WebPluginLoadObserver* m_nextPluginLoadObserver; +}; + +} // namespace WebKit + +#endif // WebDataSourceImpl_h diff --git a/WebKit/chromium/src/WebDatabase.cpp b/WebKit/chromium/src/WebDatabase.cpp new file mode 100644 index 0000000..2cd36b6 --- /dev/null +++ b/WebKit/chromium/src/WebDatabase.cpp @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebDatabase.h" + +#include "Database.h" +#include "DatabaseThread.h" +#include "Document.h" +#include "KURL.h" +#include "QuotaTracker.h" +#include "SecurityOrigin.h" +#include "WebDatabaseObserver.h" +#include "WebString.h" +#include <wtf/PassRefPtr.h> +#include <wtf/RefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +static WebDatabaseObserver* databaseObserver = 0; + +class WebDatabasePrivate : public Database { +}; + +void WebDatabase::reset() +{ + assign(0); +} + +void WebDatabase::assign(const WebDatabase& other) +{ + WebDatabasePrivate* d = const_cast<WebDatabasePrivate*>(other.m_private); + if (d) + d->ref(); + assign(d); +} + +WebString WebDatabase::name() const +{ + ASSERT(m_private); + return m_private->stringIdentifier(); +} + +WebString WebDatabase::displayName() const +{ + ASSERT(m_private); + return m_private->displayName(); +} + +unsigned long WebDatabase::estimatedSize() const +{ + ASSERT(m_private); + return m_private->estimatedSize(); +} + +WebSecurityOrigin WebDatabase::securityOrigin() const +{ + ASSERT(m_private); + return WebSecurityOrigin(m_private->securityOrigin()); +} + +void WebDatabase::setObserver(WebDatabaseObserver* observer) +{ + databaseObserver = observer; +} + +WebDatabaseObserver* WebDatabase::observer() +{ + return databaseObserver; +} + +void WebDatabase::updateDatabaseSize( + const WebString& originIdentifier, const WebString& databaseName, + unsigned long long databaseSize, unsigned long long spaceAvailable) +{ + WebCore::QuotaTracker::instance().updateDatabaseSizeAndSpaceAvailableToOrigin( + originIdentifier, databaseName, databaseSize, spaceAvailable); +} + +WebDatabase::WebDatabase(const WTF::PassRefPtr<Database>& database) + : m_private(static_cast<WebDatabasePrivate*>(database.releaseRef())) +{ +} + +WebDatabase& WebDatabase::operator=(const WTF::PassRefPtr<Database>& database) +{ + assign(static_cast<WebDatabasePrivate*>(database.releaseRef())); + return *this; +} + +WebDatabase::operator WTF::PassRefPtr<Database>() const +{ + return PassRefPtr<Database>(const_cast<WebDatabasePrivate*>(m_private)); +} + +void WebDatabase::assign(WebDatabasePrivate* d) +{ + // d is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = d; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebDevToolsAgentPrivate.h b/WebKit/chromium/src/WebDevToolsAgentPrivate.h new file mode 100644 index 0000000..0c1c67e --- /dev/null +++ b/WebKit/chromium/src/WebDevToolsAgentPrivate.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDevToolsAgentPrivate_h +#define WebDevToolsAgentPrivate_h + +// FIXME: This relative path is a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebDevToolsAgent.h" + +namespace WebKit { +class WebFrameImpl; + +class WebDevToolsAgentPrivate : public WebDevToolsAgent { +public: + // Notifications from FrameLoaderClientImpl: + + // The window object for the frame has been cleared of any extra properties + // that may have been set by script from the previously loaded document. + virtual void didClearWindowObject(WebFrameImpl*) = 0; + + // The provisional datasource is now committed. The first part of the + // response body has been received, and the encoding of the response body + // is known. + virtual void didCommitProvisionalLoad(WebFrameImpl*, bool isNewNavigation) = 0; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebDragData.cpp b/WebKit/chromium/src/WebDragData.cpp new file mode 100644 index 0000000..4af1119 --- /dev/null +++ b/WebKit/chromium/src/WebDragData.cpp @@ -0,0 +1,219 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebDragData.h" + +#include "ChromiumDataObject.h" +#include "WebData.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebVector.h" + +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +class WebDragDataPrivate : public ChromiumDataObject { +}; + +void WebDragData::initialize() +{ + assign(static_cast<WebDragDataPrivate*>(ChromiumDataObject::create().releaseRef())); +} + +void WebDragData::reset() +{ + assign(0); +} + +void WebDragData::assign(const WebDragData& other) +{ + WebDragDataPrivate* p = const_cast<WebDragDataPrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +WebURL WebDragData::url() const +{ + ASSERT(!isNull()); + return m_private->url; +} + +void WebDragData::setURL(const WebURL& url) +{ + ensureMutable(); + m_private->url = url; +} + +WebString WebDragData::urlTitle() const +{ + ASSERT(!isNull()); + return m_private->urlTitle; +} + +void WebDragData::setURLTitle(const WebString& urlTitle) +{ + ensureMutable(); + m_private->urlTitle = urlTitle; +} + +WebString WebDragData::fileExtension() const +{ + ASSERT(!isNull()); + return m_private->fileExtension; +} + +void WebDragData::setFileExtension(const WebString& fileExtension) +{ + ensureMutable(); + m_private->fileExtension = fileExtension; +} + +bool WebDragData::hasFileNames() const +{ + ASSERT(!isNull()); + return !m_private->filenames.isEmpty(); +} + +void WebDragData::fileNames(WebVector<WebString>& fileNames) const +{ + ASSERT(!isNull()); + fileNames = m_private->filenames; +} + +void WebDragData::setFileNames(const WebVector<WebString>& fileNames) +{ + ensureMutable(); + m_private->filenames.clear(); + m_private->filenames.append(fileNames.data(), fileNames.size()); +} + +void WebDragData::appendToFileNames(const WebString& fileName) +{ + ensureMutable(); + m_private->filenames.append(fileName); +} + +WebString WebDragData::plainText() const +{ + ASSERT(!isNull()); + return m_private->plainText; +} + +void WebDragData::setPlainText(const WebString& plainText) +{ + ensureMutable(); + m_private->plainText = plainText; +} + +WebString WebDragData::htmlText() const +{ + ASSERT(!isNull()); + return m_private->textHtml; +} + +void WebDragData::setHTMLText(const WebString& htmlText) +{ + ensureMutable(); + m_private->textHtml = htmlText; +} + +WebURL WebDragData::htmlBaseURL() const +{ + ASSERT(!isNull()); + return m_private->htmlBaseUrl; +} + +void WebDragData::setHTMLBaseURL(const WebURL& htmlBaseURL) +{ + ensureMutable(); + m_private->htmlBaseUrl = htmlBaseURL; +} + +WebString WebDragData::fileContentFileName() const +{ + ASSERT(!isNull()); + return m_private->fileContentFilename; +} + +void WebDragData::setFileContentFileName(const WebString& fileName) +{ + ensureMutable(); + m_private->fileContentFilename = fileName; +} + +WebData WebDragData::fileContent() const +{ + ASSERT(!isNull()); + return WebData(m_private->fileContent); +} + +void WebDragData::setFileContent(const WebData& fileContent) +{ + ensureMutable(); + m_private->fileContent = fileContent; +} + +WebDragData::WebDragData(const WTF::PassRefPtr<WebCore::ChromiumDataObject>& data) + : m_private(static_cast<WebDragDataPrivate*>(data.releaseRef())) +{ +} + +WebDragData& WebDragData::operator=(const WTF::PassRefPtr<WebCore::ChromiumDataObject>& data) +{ + assign(static_cast<WebDragDataPrivate*>(data.releaseRef())); + return *this; +} + +WebDragData::operator WTF::PassRefPtr<WebCore::ChromiumDataObject>() const +{ + return PassRefPtr<ChromiumDataObject>(const_cast<WebDragDataPrivate*>(m_private)); +} + +void WebDragData::assign(WebDragDataPrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +void WebDragData::ensureMutable() +{ + ASSERT(!isNull()); + if (!m_private->hasOneRef()) + assign(static_cast<WebDragDataPrivate*>(m_private->copy().releaseRef())); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebElement.cpp b/WebKit/chromium/src/WebElement.cpp new file mode 100644 index 0000000..3f13ee1 --- /dev/null +++ b/WebKit/chromium/src/WebElement.cpp @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebElement.h" + +#include "Element.h" +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +WebElement::WebElement(const WTF::PassRefPtr<WebCore::Element>& elem) + : WebNode(elem.releaseRef()) +{ +} + +WebElement& WebElement::operator=(const WTF::PassRefPtr<WebCore::Element>& elem) +{ + WebNode::assign(elem.releaseRef()); + return *this; +} + +WebElement::operator WTF::PassRefPtr<Element>() const +{ + return PassRefPtr<Element>(static_cast<Element*>(m_private)); +} + +} // namespace WebKit + diff --git a/WebKit/chromium/src/WebFileChooserCompletionImpl.cpp b/WebKit/chromium/src/WebFileChooserCompletionImpl.cpp new file mode 100644 index 0000000..4152dc5 --- /dev/null +++ b/WebKit/chromium/src/WebFileChooserCompletionImpl.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebFileChooserCompletionImpl.h" + +namespace WebKit { + +WebFileChooserCompletionImpl::WebFileChooserCompletionImpl(PassRefPtr<WebCore::FileChooser> chooser) + : m_fileChooser(chooser) +{ +} + +WebFileChooserCompletionImpl::~WebFileChooserCompletionImpl() +{ +} + +void WebFileChooserCompletionImpl::didChooseFile(const WebVector<WebString>& fileNames) +{ + if (fileNames.size() == 1) + m_fileChooser->chooseFile(fileNames[0]); + else { + // This clause handles a case of file_names.size()==0 too. + Vector<WebCore::String> paths; + for (size_t i = 0; i < fileNames.size(); ++i) + paths.append(fileNames[i]); + m_fileChooser->chooseFiles(paths); + } + // This object is no longer needed. + delete this; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebFileChooserCompletionImpl.h b/WebKit/chromium/src/WebFileChooserCompletionImpl.h new file mode 100644 index 0000000..fe759e0 --- /dev/null +++ b/WebKit/chromium/src/WebFileChooserCompletionImpl.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFileChooserCompletionImpl_h +#define WebFileChooserCompletionImpl_h + +// FIXME: These relative paths are a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebFileChooserCompletion.h" +#include "../public/WebString.h" +#include "../public/WebVector.h" + +#include "FileChooser.h" + +#include <wtf/PassRefPtr.h> + +using WebKit::WebFileChooserCompletion; +using WebKit::WebString; +using WebKit::WebVector; + +namespace WebKit { + +class WebFileChooserCompletionImpl : public WebFileChooserCompletion { +public: + WebFileChooserCompletionImpl(PassRefPtr<WebCore::FileChooser> chooser); + ~WebFileChooserCompletionImpl(); + virtual void didChooseFile(const WebVector<WebString>& fileNames); +private: + RefPtr<WebCore::FileChooser> m_fileChooser; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebFontCache.cpp b/WebKit/chromium/src/WebFontCache.cpp new file mode 100644 index 0000000..52358ec --- /dev/null +++ b/WebKit/chromium/src/WebFontCache.cpp @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebFontCache.h" + +#include "FontCache.h" + +using namespace WebCore; + +namespace WebKit { + +// static +size_t WebFontCache::fontDataCount() +{ + return fontCache()->fontDataCount(); +} + +// static +size_t WebFontCache::inactiveFontDataCount() +{ + return fontCache()->inactiveFontDataCount(); +} + +// static +void WebFontCache::clear() +{ + fontCache()->invalidate(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebFormElement.cpp b/WebKit/chromium/src/WebFormElement.cpp new file mode 100644 index 0000000..5471608 --- /dev/null +++ b/WebKit/chromium/src/WebFormElement.cpp @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebFormElement.h" + +#include "HTMLFormControlElement.h" +#include "HTMLFormElement.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "WebString.h" +#include "WebURL.h" +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +class WebFormPrivate : public HTMLFormElement { +}; + +WebFormElement::WebFormElement(const WTF::PassRefPtr<HTMLFormElement>& e) + : WebElement(e.releaseRef()) +{ +} + +WebFormElement& WebFormElement::operator=(const WTF::PassRefPtr<HTMLFormElement>& e) +{ + WebNode::assign(e.releaseRef()); + return *this; +} + +WebFormElement::operator WTF::PassRefPtr<WebCore::HTMLFormElement>() const +{ + return PassRefPtr<HTMLFormElement>(static_cast<HTMLFormElement*>(m_private)); +} + +bool WebFormElement::autoComplete() const +{ + return constUnwrap<HTMLFormElement>()->autoComplete(); +} + +WebString WebFormElement::action() const +{ + return constUnwrap<HTMLFormElement>()->action(); +} + +WebString WebFormElement::name() const +{ + return constUnwrap<HTMLFormElement>()->name(); +} + +WebString WebFormElement::method() const +{ + return constUnwrap<HTMLFormElement>()->method(); +} + +void WebFormElement::submit() +{ + unwrap<HTMLFormElement>()->submit(); +} + +void WebFormElement::getNamedElements(const WebString& name, + WebVector<WebNode>& result) +{ + Vector<RefPtr<Node> > tempVector; + unwrap<HTMLFormElement>()->getNamedElements(name, tempVector); + result.assign(tempVector); +} + +void WebFormElement::getInputElements(WebVector<WebInputElement>& result) const +{ + const HTMLFormElement* form = constUnwrap<HTMLFormElement>(); + Vector<RefPtr<HTMLInputElement> > tempVector; + for (size_t i = 0; i < form->formElements.size(); i++) { + if (form->formElements[i]->hasLocalName(HTMLNames::inputTag)) + tempVector.append(static_cast<HTMLInputElement*>( + form->formElements[i])); + } + result.assign(tempVector); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebFrameImpl.cpp b/WebKit/chromium/src/WebFrameImpl.cpp new file mode 100644 index 0000000..ab6769f --- /dev/null +++ b/WebKit/chromium/src/WebFrameImpl.cpp @@ -0,0 +1,1915 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// How ownership works +// ------------------- +// +// Big oh represents a refcounted relationship: owner O--- ownee +// +// WebView (for the toplevel frame only) +// O +// | +// Page O------- Frame (m_mainFrame) O-------O FrameView +// || +// || +// FrameLoader O-------- WebFrame (via FrameLoaderClient) +// +// FrameLoader and Frame are formerly one object that was split apart because +// it got too big. They basically have the same lifetime, hence the double line. +// +// WebFrame is refcounted and has one ref on behalf of the FrameLoader/Frame. +// This is not a normal reference counted pointer because that would require +// changing WebKit code that we don't control. Instead, it is created with this +// ref initially and it is removed when the FrameLoader is getting destroyed. +// +// WebFrames are created in two places, first in WebViewImpl when the root +// frame is created, and second in WebFrame::CreateChildFrame when sub-frames +// are created. WebKit will hook up this object to the FrameLoader/Frame +// and the refcount will be correct. +// +// How frames are destroyed +// ------------------------ +// +// The main frame is never destroyed and is re-used. The FrameLoader is re-used +// and a reference to the main frame is kept by the Page. +// +// When frame content is replaced, all subframes are destroyed. This happens +// in FrameLoader::detachFromParent for each subframe. +// +// Frame going away causes the FrameLoader to get deleted. In FrameLoader's +// destructor, it notifies its client with frameLoaderDestroyed. This calls +// WebFrame::Closing and then derefs the WebFrame and will cause it to be +// deleted (unless an external someone is also holding a reference). + +#include "config.h" +#include "WebFrameImpl.h" + +#include "Chrome.h" +#include "ChromiumBridge.h" +#include "ClipboardUtilitiesChromium.h" +#include "Console.h" +#include "Document.h" +#include "DocumentFragment.h" // Only needed for ReplaceSelectionCommand.h :( +#include "DocumentLoader.h" +#include "DocumentMarker.h" +#include "DOMUtilitiesPrivate.h" +#include "DOMWindow.h" +#include "Editor.h" +#include "EventHandler.h" +#include "FormState.h" +#include "FrameChromium.h" +#include "FrameLoader.h" +#include "FrameLoadRequest.h" +#include "FrameTree.h" +#include "FrameView.h" +#include "GraphicsContext.h" +#include "HistoryItem.h" +#include "HTMLCollection.h" +#include "HTMLFormElement.h" +#include "HTMLFrameOwnerElement.h" +#include "HTMLHeadElement.h" +#include "HTMLInputElement.h" +#include "HTMLLinkElement.h" +#include "HTMLNames.h" +#include "InspectorController.h" +#include "markup.h" +#include "Page.h" +#include "PlatformContextSkia.h" +#include "PrintContext.h" +#include "RenderFrame.h" +#include "RenderView.h" +#include "RenderWidget.h" +#include "ReplaceSelectionCommand.h" +#include "ResourceHandle.h" +#include "ResourceRequest.h" +#include "ScriptController.h" +#include "ScriptSourceCode.h" +#include "ScriptValue.h" +#include "ScrollbarTheme.h" +#include "ScrollTypes.h" +#include "SelectionController.h" +#include "Settings.h" +#include "SkiaUtils.h" +#include "SubstituteData.h" +#include "TextAffinity.h" +#include "TextIterator.h" +#include "WebConsoleMessage.h" +#include "WebDataSourceImpl.h" +#include "WebFindOptions.h" +#include "WebFormElement.h" +#include "WebFrameClient.h" +#include "WebHistoryItem.h" +#include "WebInputElement.h" +#include "WebPasswordAutocompleteListener.h" +#include "WebRange.h" +#include "WebRect.h" +#include "WebScriptSource.h" +#include "WebSecurityOrigin.h" +#include "WebSize.h" +#include "WebURLError.h" +#include "WebVector.h" +#include "WebViewImpl.h" +#include "XPathResult.h" + +#include <algorithm> +#include <wtf/CurrentTime.h> + + +#if PLATFORM(DARWIN) +#include "LocalCurrentGraphicsContext.h" +#endif + +#if PLATFORM(LINUX) +#include <gdk/gdk.h> +#endif + +using namespace WebCore; + +namespace WebKit { + +// Key for a StatsCounter tracking how many WebFrames are active. +static const char* const webFrameActiveCount = "WebFrameActiveCount"; + +static const char* const osdType = "application/opensearchdescription+xml"; +static const char* const osdRel = "search"; + +// Backend for contentAsPlainText, this is a recursive function that gets +// the text for the current frame and all of its subframes. It will append +// the text of each frame in turn to the |output| up to |maxChars| length. +// +// The |frame| must be non-null. +static void frameContentAsPlainText(size_t maxChars, Frame* frame, + Vector<UChar>* output) +{ + Document* doc = frame->document(); + if (!doc) + return; + + if (!frame->view()) + return; + + // TextIterator iterates over the visual representation of the DOM. As such, + // it requires you to do a layout before using it (otherwise it'll crash). + if (frame->view()->needsLayout()) + frame->view()->layout(); + + // Select the document body. + RefPtr<Range> range(doc->createRange()); + ExceptionCode exception = 0; + range->selectNodeContents(doc->body(), exception); + + if (!exception) { + // The text iterator will walk nodes giving us text. This is similar to + // the plainText() function in TextIterator.h, but we implement the maximum + // size and also copy the results directly into a wstring, avoiding the + // string conversion. + for (TextIterator it(range.get()); !it.atEnd(); it.advance()) { + const UChar* chars = it.characters(); + if (!chars) { + if (it.length()) { + // It appears from crash reports that an iterator can get into a state + // where the character count is nonempty but the character pointer is + // null. advance()ing it will then just add that many to the null + // pointer which won't be caught in a null check but will crash. + // + // A null pointer and 0 length is common for some nodes. + // + // IF YOU CATCH THIS IN A DEBUGGER please let brettw know. We don't + // currently understand the conditions for this to occur. Ideally, the + // iterators would never get into the condition so we should fix them + // if we can. + ASSERT_NOT_REACHED(); + break; + } + + // Just got a null node, we can forge ahead! + continue; + } + size_t toAppend = + std::min(static_cast<size_t>(it.length()), maxChars - output->size()); + output->append(chars, toAppend); + if (output->size() >= maxChars) + return; // Filled up the buffer. + } + } + + // The separator between frames when the frames are converted to plain text. + const UChar frameSeparator[] = { '\n', '\n' }; + const size_t frameSeparatorLen = 2; + + // Recursively walk the children. + FrameTree* frameTree = frame->tree(); + for (Frame* curChild = frameTree->firstChild(); curChild; curChild = curChild->tree()->nextSibling()) { + // Make sure the frame separator won't fill up the buffer, and give up if + // it will. The danger is if the separator will make the buffer longer than + // maxChars. This will cause the computation above: + // maxChars - output->size() + // to be a negative number which will crash when the subframe is added. + if (output->size() >= maxChars - frameSeparatorLen) + return; + + output->append(frameSeparator, frameSeparatorLen); + frameContentAsPlainText(maxChars, curChild, output); + if (output->size() >= maxChars) + return; // Filled up the buffer. + } +} + +// Simple class to override some of PrintContext behavior. +class ChromePrintContext : public PrintContext, public Noncopyable { +public: + ChromePrintContext(Frame* frame) + : PrintContext(frame) + , m_printedPageWidth(0) + { + } + + void begin(float width) + { + ASSERT(!m_printedPageWidth); + m_printedPageWidth = width; + PrintContext::begin(m_printedPageWidth); + } + + float getPageShrink(int pageNumber) const + { + IntRect pageRect = m_pageRects[pageNumber]; + return m_printedPageWidth / pageRect.width(); + } + + // Spools the printed page, a subrect of m_frame. Skip the scale step. + // NativeTheme doesn't play well with scaling. Scaling is done browser side + // instead. Returns the scale to be applied. + float spoolPage(GraphicsContext& ctx, int pageNumber) + { + IntRect pageRect = m_pageRects[pageNumber]; + float scale = m_printedPageWidth / pageRect.width(); + + ctx.save(); + ctx.translate(static_cast<float>(-pageRect.x()), + static_cast<float>(-pageRect.y())); + ctx.clip(pageRect); + m_frame->view()->paintContents(&ctx, pageRect); + ctx.restore(); + return scale; + } + +private: + // Set when printing. + float m_printedPageWidth; +}; + +static WebDataSource* DataSourceForDocLoader(DocumentLoader* loader) +{ + return loader ? WebDataSourceImpl::fromDocumentLoader(loader) : 0; +} + + +// WebFrame ------------------------------------------------------------------- + +class WebFrameImpl::DeferredScopeStringMatches { +public: + DeferredScopeStringMatches(WebFrameImpl* webFrame, + int identifier, + const WebString& searchText, + const WebFindOptions& options, + bool reset) + : m_timer(this, &DeferredScopeStringMatches::doTimeout) + , m_webFrame(webFrame) + , m_identifier(identifier) + , m_searchText(searchText) + , m_options(options) + , m_reset(reset) + { + m_timer.startOneShot(0.0); + } + +private: + void doTimeout(Timer<DeferredScopeStringMatches>*) + { + m_webFrame->callScopeStringMatches( + this, m_identifier, m_searchText, m_options, m_reset); + } + + Timer<DeferredScopeStringMatches> m_timer; + RefPtr<WebFrameImpl> m_webFrame; + int m_identifier; + WebString m_searchText; + WebFindOptions m_options; + bool m_reset; +}; + + +// WebFrame ------------------------------------------------------------------- + +WebFrame* WebFrame::frameForEnteredContext() +{ + Frame* frame = + ScriptController::retrieveFrameForEnteredContext(); + return WebFrameImpl::fromFrame(frame); +} + +WebFrame* WebFrame::frameForCurrentContext() +{ + Frame* frame = + ScriptController::retrieveFrameForCurrentContext(); + return WebFrameImpl::fromFrame(frame); +} + +WebString WebFrameImpl::name() const +{ + return m_frame->tree()->name(); +} + +WebURL WebFrameImpl::url() const +{ + const WebDataSource* ds = dataSource(); + if (!ds) + return WebURL(); + return ds->request().url(); +} + +WebURL WebFrameImpl::favIconURL() const +{ + FrameLoader* frameLoader = m_frame->loader(); + // The URL to the favicon may be in the header. As such, only + // ask the loader for the favicon if it's finished loading. + if (frameLoader->state() == FrameStateComplete) { + const KURL& url = frameLoader->iconURL(); + if (!url.isEmpty()) + return url; + } + return WebURL(); +} + +WebURL WebFrameImpl::openSearchDescriptionURL() const +{ + FrameLoader* frameLoader = m_frame->loader(); + if (frameLoader->state() == FrameStateComplete + && m_frame->document() && m_frame->document()->head() + && !m_frame->tree()->parent()) { + HTMLHeadElement* head = m_frame->document()->head(); + if (head) { + RefPtr<HTMLCollection> children = head->children(); + for (Node* child = children->firstItem(); child; child = children->nextItem()) { + HTMLLinkElement* linkElement = toHTMLLinkElement(child); + if (linkElement + && linkElement->type() == osdType + && linkElement->rel() == osdRel + && !linkElement->href().isEmpty()) + return linkElement->href(); + } + } + } + return WebURL(); +} + +WebSize WebFrameImpl::scrollOffset() const +{ + FrameView* view = frameView(); + if (view) + return view->scrollOffset(); + + return WebSize(); +} + +WebSize WebFrameImpl::contentsSize() const +{ + return frame()->view()->contentsSize(); +} + +int WebFrameImpl::contentsPreferredWidth() const +{ + if (m_frame->document() && m_frame->document()->renderView()) + return m_frame->document()->renderView()->minPrefWidth(); + return 0; +} + +int WebFrameImpl::documentElementScrollHeight() const +{ + if (m_frame->document() && m_frame->document()->documentElement()) + return m_frame->document()->documentElement()->scrollHeight(); + return 0; +} + +bool WebFrameImpl::hasVisibleContent() const +{ + return frame()->view()->visibleWidth() > 0 && frame()->view()->visibleHeight() > 0; +} + +WebView* WebFrameImpl::view() const +{ + return viewImpl(); +} + +WebFrame* WebFrameImpl::opener() const +{ + Frame* opener = 0; + if (m_frame) + opener = m_frame->loader()->opener(); + return fromFrame(opener); +} + +WebFrame* WebFrameImpl::parent() const +{ + Frame* parent = 0; + if (m_frame) + parent = m_frame->tree()->parent(); + return fromFrame(parent); +} + +WebFrame* WebFrameImpl::top() const +{ + if (m_frame) + return fromFrame(m_frame->tree()->top()); + + return 0; +} + +WebFrame* WebFrameImpl::firstChild() const +{ + return fromFrame(frame()->tree()->firstChild()); +} + +WebFrame* WebFrameImpl::lastChild() const +{ + return fromFrame(frame()->tree()->lastChild()); +} + +WebFrame* WebFrameImpl::nextSibling() const +{ + return fromFrame(frame()->tree()->nextSibling()); +} + +WebFrame* WebFrameImpl::previousSibling() const +{ + return fromFrame(frame()->tree()->previousSibling()); +} + +WebFrame* WebFrameImpl::traverseNext(bool wrap) const +{ + return fromFrame(frame()->tree()->traverseNextWithWrap(wrap)); +} + +WebFrame* WebFrameImpl::traversePrevious(bool wrap) const +{ + return fromFrame(frame()->tree()->traversePreviousWithWrap(wrap)); +} + +WebFrame* WebFrameImpl::findChildByName(const WebString& name) const +{ + return fromFrame(frame()->tree()->child(name)); +} + +WebFrame* WebFrameImpl::findChildByExpression(const WebString& xpath) const +{ + if (xpath.isEmpty()) + return 0; + + Document* document = m_frame->document(); + + ExceptionCode ec = 0; + PassRefPtr<XPathResult> xpathResult = + document->evaluate(xpath, + document, + 0, // namespace + XPathResult::ORDERED_NODE_ITERATOR_TYPE, + 0, // XPathResult object + ec); + if (!xpathResult.get()) + return 0; + + Node* node = xpathResult->iterateNext(ec); + + if (!node || !node->isFrameOwnerElement()) + return 0; + HTMLFrameOwnerElement* frameElement = + static_cast<HTMLFrameOwnerElement*>(node); + return fromFrame(frameElement->contentFrame()); +} + +void WebFrameImpl::forms(WebVector<WebFormElement>& results) const +{ + if (!m_frame) + return; + + RefPtr<HTMLCollection> forms = m_frame->document()->forms(); + size_t formCount = forms->length(); + + WebVector<WebFormElement> temp(formCount); + for (size_t i = 0; i < formCount; ++i) { + Node* node = forms->item(i); + // Strange but true, sometimes item can be 0. + if (node) + temp[i] = static_cast<HTMLFormElement*>(node); + } + results.swap(temp); +} + +WebSecurityOrigin WebFrameImpl::securityOrigin() const +{ + if (!m_frame || !m_frame->document()) + return WebSecurityOrigin(); + + return WebSecurityOrigin(m_frame->document()->securityOrigin()); +} + +void WebFrameImpl::grantUniversalAccess() +{ + ASSERT(m_frame && m_frame->document()); + if (m_frame && m_frame->document()) + m_frame->document()->securityOrigin()->grantUniversalAccess(); +} + +NPObject* WebFrameImpl::windowObject() const +{ + if (!m_frame) + return 0; + + return m_frame->script()->windowScriptNPObject(); +} + +void WebFrameImpl::bindToWindowObject(const WebString& name, NPObject* object) +{ + ASSERT(m_frame); + if (!m_frame || !m_frame->script()->isEnabled()) + return; + + String key = name; +#if USE(V8) + m_frame->script()->bindToWindowObject(m_frame, key, object); +#else + notImplemented(); +#endif +} + +void WebFrameImpl::executeScript(const WebScriptSource& source) +{ + m_frame->script()->executeScript( + ScriptSourceCode(source.code, source.url, source.startLine)); +} + +void WebFrameImpl::executeScriptInNewContext( + const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup) +{ + Vector<ScriptSourceCode> sources; + + for (unsigned i = 0; i < numSources; ++i) { + sources.append(ScriptSourceCode( + sourcesIn[i].code, sourcesIn[i].url, sourcesIn[i].startLine)); + } + + m_frame->script()->evaluateInNewContext(sources, extensionGroup); +} + +void WebFrameImpl::executeScriptInIsolatedWorld( + int worldId, const WebScriptSource* sourcesIn, unsigned numSources, + int extensionGroup) +{ + Vector<ScriptSourceCode> sources; + + for (unsigned i = 0; i < numSources; ++i) { + sources.append(ScriptSourceCode( + sourcesIn[i].code, sourcesIn[i].url, sourcesIn[i].startLine)); + } + + m_frame->script()->evaluateInIsolatedWorld(worldId, sources, extensionGroup); +} + +void WebFrameImpl::addMessageToConsole(const WebConsoleMessage& message) +{ + ASSERT(frame()); + + MessageLevel webCoreMessageLevel; + switch (message.level) { + case WebConsoleMessage::LevelTip: + webCoreMessageLevel = TipMessageLevel; + break; + case WebConsoleMessage::LevelLog: + webCoreMessageLevel = LogMessageLevel; + break; + case WebConsoleMessage::LevelWarning: + webCoreMessageLevel = WarningMessageLevel; + break; + case WebConsoleMessage::LevelError: + webCoreMessageLevel = ErrorMessageLevel; + break; + default: + ASSERT_NOT_REACHED(); + return; + } + + frame()->domWindow()->console()->addMessage( + OtherMessageSource, LogMessageType, webCoreMessageLevel, message.text, + 1, String()); +} + +void WebFrameImpl::collectGarbage() +{ + if (!m_frame) + return; + if (!m_frame->settings()->isJavaScriptEnabled()) + return; + // FIXME: Move this to the ScriptController and make it JS neutral. +#if USE(V8) + m_frame->script()->collectGarbage(); +#else + notImplemented(); +#endif +} + +#if USE(V8) +// Returns the V8 context for this frame, or an empty handle if there is none. +v8::Local<v8::Context> WebFrameImpl::mainWorldScriptContext() const +{ + if (!m_frame) + return v8::Local<v8::Context>(); + + return V8Proxy::mainWorldContext(m_frame); +} +#endif + +bool WebFrameImpl::insertStyleText( + const WebString& css, const WebString& id) { + Document* document = frame()->document(); + if (!document) + return false; + Element* documentElement = document->documentElement(); + if (!documentElement) + return false; + + ExceptionCode err = 0; + + if (!id.isEmpty()) { + Element* oldElement = document->getElementById(id); + if (oldElement) { + Node* parent = oldElement->parent(); + if (!parent) + return false; + parent->removeChild(oldElement, err); + } + } + + RefPtr<Element> stylesheet = document->createElement( + HTMLNames::styleTag, false); + if (!id.isEmpty()) + stylesheet->setAttribute(HTMLNames::idAttr, id); + stylesheet->setTextContent(css, err); + ASSERT(!err); + Node* first = documentElement->firstChild(); + bool success = documentElement->insertBefore(stylesheet, first, err); + ASSERT(success); + return success; +} + +void WebFrameImpl::reload() +{ + m_frame->loader()->history()->saveDocumentAndScrollState(); + + stopLoading(); // Make sure existing activity stops. + m_frame->loader()->reload(); +} + +void WebFrameImpl::loadRequest(const WebURLRequest& request) +{ + ASSERT(!request.isNull()); + const ResourceRequest& resourceRequest = request.toResourceRequest(); + + if (resourceRequest.url().protocolIs("javascript")) { + loadJavaScriptURL(resourceRequest.url()); + return; + } + + stopLoading(); // Make sure existing activity stops. + m_frame->loader()->load(resourceRequest, false); +} + +void WebFrameImpl::loadHistoryItem(const WebHistoryItem& item) +{ + RefPtr<HistoryItem> historyItem = PassRefPtr<HistoryItem>(item); + ASSERT(historyItem.get()); + + stopLoading(); // Make sure existing activity stops. + + // If there is no currentItem, which happens when we are navigating in + // session history after a crash, we need to manufacture one otherwise WebKit + // hoarks. This is probably the wrong thing to do, but it seems to work. + RefPtr<HistoryItem> currentItem = m_frame->loader()->history()->currentItem(); + if (!currentItem) { + currentItem = HistoryItem::create(); + currentItem->setLastVisitWasFailure(true); + m_frame->loader()->history()->setCurrentItem(currentItem.get()); + viewImpl()->setCurrentHistoryItem(currentItem.get()); + } + + m_frame->loader()->history()->goToItem( + historyItem.get(), FrameLoadTypeIndexedBackForward); +} + +void WebFrameImpl::loadData(const WebData& data, + const WebString& mimeType, + const WebString& textEncoding, + const WebURL& baseURL, + const WebURL& unreachableURL, + bool replace) +{ + SubstituteData substData(data, mimeType, textEncoding, unreachableURL); + ASSERT(substData.isValid()); + + // If we are loading substitute data to replace an existing load, then + // inherit all of the properties of that original request. This way, + // reload will re-attempt the original request. It is essential that + // we only do this when there is an unreachableURL since a non-empty + // unreachableURL informs FrameLoader::reload to load unreachableURL + // instead of the currently loaded URL. + ResourceRequest request; + if (replace && !unreachableURL.isEmpty()) + request = m_frame->loader()->originalRequest(); + request.setURL(baseURL); + + stopLoading(); // Make sure existing activity stops. + + m_frame->loader()->load(request, substData, false); + if (replace) { + // Do this to force WebKit to treat the load as replacing the currently + // loaded page. + m_frame->loader()->setReplacing(); + } +} + +void WebFrameImpl::loadHTMLString(const WebData& data, + const WebURL& baseURL, + const WebURL& unreachableURL, + bool replace) +{ + loadData(data, + WebString::fromUTF8("text/html"), + WebString::fromUTF8("UTF-8"), + baseURL, + unreachableURL, + replace); +} + +bool WebFrameImpl::isLoading() const +{ + if (!m_frame) + return false; + return m_frame->loader()->isLoading(); +} + +void WebFrameImpl::stopLoading() +{ + if (!m_frame) + return; + + // FIXME: Figure out what we should really do here. It seems like a bug + // that FrameLoader::stopLoading doesn't call stopAllLoaders. + m_frame->loader()->stopAllLoaders(); + m_frame->loader()->stopLoading(UnloadEventPolicyNone); +} + +WebDataSource* WebFrameImpl::provisionalDataSource() const +{ + FrameLoader* frameLoader = m_frame->loader(); + + // We regard the policy document loader as still provisional. + DocumentLoader* docLoader = frameLoader->provisionalDocumentLoader(); + if (!docLoader) + docLoader = frameLoader->policyDocumentLoader(); + + return DataSourceForDocLoader(docLoader); +} + +WebDataSource* WebFrameImpl::dataSource() const +{ + return DataSourceForDocLoader(m_frame->loader()->documentLoader()); +} + +WebHistoryItem WebFrameImpl::previousHistoryItem() const +{ + // We use the previous item here because documentState (filled-out forms) + // only get saved to history when it becomes the previous item. The caller + // is expected to query the history item after a navigation occurs, after + // the desired history item has become the previous entry. + return WebHistoryItem(viewImpl()->previousHistoryItem()); +} + +WebHistoryItem WebFrameImpl::currentHistoryItem() const +{ + m_frame->loader()->history()->saveDocumentAndScrollState(); + + return WebHistoryItem(m_frame->page()->backForwardList()->currentItem()); +} + +void WebFrameImpl::enableViewSourceMode(bool enable) +{ + if (m_frame) + m_frame->setInViewSourceMode(enable); +} + +bool WebFrameImpl::isViewSourceModeEnabled() const +{ + if (m_frame) + return m_frame->inViewSourceMode(); + + return false; +} + +void WebFrameImpl::setReferrerForRequest( + WebURLRequest& request, const WebURL& referrerURL) { + String referrer; + if (referrerURL.isEmpty()) + referrer = m_frame->loader()->outgoingReferrer(); + else + referrer = referrerURL.spec().utf16(); + if (SecurityOrigin::shouldHideReferrer(request.url(), referrer)) + return; + request.setHTTPHeaderField(WebString::fromUTF8("Referer"), referrer); +} + +void WebFrameImpl::dispatchWillSendRequest(WebURLRequest& request) +{ + ResourceResponse response; + m_frame->loader()->client()->dispatchWillSendRequest( + 0, 0, request.toMutableResourceRequest(), response); +} + +void WebFrameImpl::commitDocumentData(const char* data, size_t dataLen) +{ + DocumentLoader* documentLoader = m_frame->loader()->documentLoader(); + + // Set the text encoding. This calls begin() for us. It is safe to call + // this multiple times (Mac does: page/mac/WebCoreFrameBridge.mm). + bool userChosen = true; + String encoding = documentLoader->overrideEncoding(); + if (encoding.isNull()) { + userChosen = false; + encoding = documentLoader->response().textEncodingName(); + } + m_frame->loader()->setEncoding(encoding, userChosen); + + // NOTE: mac only does this if there is a document + m_frame->loader()->addData(data, dataLen); +} + +unsigned WebFrameImpl::unloadListenerCount() const +{ + return frame()->domWindow()->pendingUnloadEventListeners(); +} + +bool WebFrameImpl::isProcessingUserGesture() const +{ + return frame()->loader()->isProcessingUserGesture(); +} + +bool WebFrameImpl::willSuppressOpenerInNewFrame() const +{ + return frame()->loader()->suppressOpenerInNewFrame(); +} + +void WebFrameImpl::replaceSelection(const WebString& text) +{ + RefPtr<DocumentFragment> fragment = createFragmentFromText( + frame()->selection()->toNormalizedRange().get(), text); + applyCommand(ReplaceSelectionCommand::create( + frame()->document(), fragment.get(), false, true, true)); +} + +void WebFrameImpl::insertText(const WebString& text) +{ + frame()->editor()->insertText(text, 0); +} + +void WebFrameImpl::setMarkedText( + const WebString& text, unsigned location, unsigned length) +{ + Editor* editor = frame()->editor(); + + editor->confirmComposition(text); + + Vector<CompositionUnderline> decorations; + editor->setComposition(text, decorations, location, length); +} + +void WebFrameImpl::unmarkText() +{ + frame()->editor()->confirmCompositionWithoutDisturbingSelection(); +} + +bool WebFrameImpl::hasMarkedText() const +{ + return frame()->editor()->hasComposition(); +} + +WebRange WebFrameImpl::markedRange() const +{ + return frame()->editor()->compositionRange(); +} + +bool WebFrameImpl::executeCommand(const WebString& name) +{ + ASSERT(frame()); + + if (name.length() <= 2) + return false; + + // Since we don't have NSControl, we will convert the format of command + // string and call the function on Editor directly. + String command = name; + + // Make sure the first letter is upper case. + command.replace(0, 1, command.substring(0, 1).upper()); + + // Remove the trailing ':' if existing. + if (command[command.length() - 1] == UChar(':')) + command = command.substring(0, command.length() - 1); + + bool rv = true; + + // Specially handling commands that Editor::execCommand does not directly + // support. + if (command == "DeleteToEndOfParagraph") { + Editor* editor = frame()->editor(); + if (!editor->deleteWithDirection(SelectionController::FORWARD, + ParagraphBoundary, + true, + false)) { + editor->deleteWithDirection(SelectionController::FORWARD, + CharacterGranularity, + true, + false); + } + } else if (command == "Indent") + frame()->editor()->indent(); + else if (command == "Outdent") + frame()->editor()->outdent(); + else if (command == "DeleteBackward") + rv = frame()->editor()->command(AtomicString("BackwardDelete")).execute(); + else if (command == "DeleteForward") + rv = frame()->editor()->command(AtomicString("ForwardDelete")).execute(); + else if (command == "AdvanceToNextMisspelling") { + // False must be passed here, or the currently selected word will never be + // skipped. + frame()->editor()->advanceToNextMisspelling(false); + } else if (command == "ToggleSpellPanel") + frame()->editor()->showSpellingGuessPanel(); + else + rv = frame()->editor()->command(command).execute(); + return rv; +} + +bool WebFrameImpl::executeCommand(const WebString& name, const WebString& value) +{ + ASSERT(frame()); + String webName = name; + + // moveToBeginningOfDocument and moveToEndfDocument are only handled by WebKit + // for editable nodes. + if (!frame()->editor()->canEdit() && webName == "moveToBeginningOfDocument") + return viewImpl()->propagateScroll(ScrollUp, ScrollByDocument); + + if (!frame()->editor()->canEdit() && webName == "moveToEndOfDocument") + return viewImpl()->propagateScroll(ScrollDown, ScrollByDocument); + + return frame()->editor()->command(webName).execute(value); +} + +bool WebFrameImpl::isCommandEnabled(const WebString& name) const +{ + ASSERT(frame()); + return frame()->editor()->command(name).isEnabled(); +} + +void WebFrameImpl::enableContinuousSpellChecking(bool enable) +{ + if (enable == isContinuousSpellCheckingEnabled()) + return; + frame()->editor()->toggleContinuousSpellChecking(); +} + +bool WebFrameImpl::isContinuousSpellCheckingEnabled() const +{ + return frame()->editor()->isContinuousSpellCheckingEnabled(); +} + +bool WebFrameImpl::hasSelection() const +{ + // frame()->selection()->isNone() never returns true. + return (frame()->selection()->start() != frame()->selection()->end()); +} + +WebRange WebFrameImpl::selectionRange() const +{ + return frame()->selection()->toNormalizedRange(); +} + +WebString WebFrameImpl::selectionAsText() const +{ + RefPtr<Range> range = frame()->selection()->toNormalizedRange(); + if (!range.get()) + return WebString(); + + String text = range->text(); +#if PLATFORM(WIN_OS) + replaceNewlinesWithWindowsStyleNewlines(text); +#endif + replaceNBSPWithSpace(text); + return text; +} + +WebString WebFrameImpl::selectionAsMarkup() const +{ + RefPtr<Range> range = frame()->selection()->toNormalizedRange(); + if (!range.get()) + return WebString(); + + return createMarkup(range.get(), 0); +} + +int WebFrameImpl::printBegin(const WebSize& pageSize) +{ + ASSERT(!frame()->document()->isFrameSet()); + + m_printContext.set(new ChromePrintContext(frame())); + FloatRect rect(0, 0, static_cast<float>(pageSize.width), + static_cast<float>(pageSize.height)); + m_printContext->begin(rect.width()); + float pageHeight; + // We ignore the overlays calculation for now since they are generated in the + // browser. pageHeight is actually an output parameter. + m_printContext->computePageRects(rect, 0, 0, 1.0, pageHeight); + return m_printContext->pageCount(); +} + +float WebFrameImpl::getPrintPageShrink(int page) +{ + // Ensure correct state. + if (!m_printContext.get() || page < 0) { + ASSERT_NOT_REACHED(); + return 0; + } + + return m_printContext->getPageShrink(page); +} + +float WebFrameImpl::printPage(int page, WebCanvas* canvas) +{ + // Ensure correct state. + if (!m_printContext.get() || page < 0 || !frame() || !frame()->document()) { + ASSERT_NOT_REACHED(); + return 0; + } + +#if PLATFORM(WIN_OS) || PLATFORM(LINUX) || PLATFORM(FREEBSD) + PlatformContextSkia context(canvas); + GraphicsContext spool(&context); +#elif PLATFORM(DARWIN) + GraphicsContext spool(canvas); + LocalCurrentGraphicsContext localContext(&spool); +#endif + + return m_printContext->spoolPage(spool, page); +} + +void WebFrameImpl::printEnd() +{ + ASSERT(m_printContext.get()); + if (m_printContext.get()) + m_printContext->end(); + m_printContext.clear(); +} + +bool WebFrameImpl::find(int identifier, + const WebString& searchText, + const WebFindOptions& options, + bool wrapWithinFrame, + WebRect* selectionRect) +{ + WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl(); + + if (!options.findNext) + frame()->page()->unmarkAllTextMatches(); + else + setMarkerActive(m_activeMatch.get(), false); // Active match is changing. + + // Starts the search from the current selection. + bool startInSelection = true; + + // If the user has selected something since the last Find operation we want + // to start from there. Otherwise, we start searching from where the last Find + // operation left off (either a Find or a FindNext operation). + VisibleSelection selection(frame()->selection()->selection()); + bool activeSelection = !selection.isNone(); + if (!activeSelection && m_activeMatch) { + selection = VisibleSelection(m_activeMatch.get()); + frame()->selection()->setSelection(selection); + } + + ASSERT(frame() && frame()->view()); + bool found = frame()->findString( + searchText, options.forward, options.matchCase, wrapWithinFrame, + startInSelection); + if (found) { + // Store which frame was active. This will come in handy later when we + // change the active match ordinal below. + WebFrameImpl* oldActiveFrame = mainFrameImpl->m_activeMatchFrame; + // Set this frame as the active frame (the one with the active highlight). + mainFrameImpl->m_activeMatchFrame = this; + + // We found something, so we can now query the selection for its position. + VisibleSelection newSelection(frame()->selection()->selection()); + IntRect currSelectionRect; + + // If we thought we found something, but it couldn't be selected (perhaps + // because it was marked -webkit-user-select: none), we can't set it to + // be active but we still continue searching. This matches Safari's + // behavior, including some oddities when selectable and un-selectable text + // are mixed on a page: see https://bugs.webkit.org/show_bug.cgi?id=19127. + if (newSelection.isNone() || (newSelection.start() == newSelection.end())) + m_activeMatch = 0; + else { + m_activeMatch = newSelection.toNormalizedRange(); + currSelectionRect = m_activeMatch->boundingBox(); + setMarkerActive(m_activeMatch.get(), true); // Active. + // WebKit draws the highlighting for all matches. + executeCommand(WebString::fromUTF8("Unselect")); + } + + if (!options.findNext || activeSelection) { + // This is either a Find operation or a Find-next from a new start point + // due to a selection, so we set the flag to ask the scoping effort + // to find the active rect for us so we can update the ordinal (n of m). + m_locatingActiveRect = true; + } else { + if (oldActiveFrame != this) { + // If the active frame has changed it means that we have a multi-frame + // page and we just switch to searching in a new frame. Then we just + // want to reset the index. + if (options.forward) + m_activeMatchIndex = 0; + else + m_activeMatchIndex = m_lastMatchCount - 1; + } else { + // We are still the active frame, so increment (or decrement) the + // |m_activeMatchIndex|, wrapping if needed (on single frame pages). + options.forward ? ++m_activeMatchIndex : --m_activeMatchIndex; + if (m_activeMatchIndex + 1 > m_lastMatchCount) + m_activeMatchIndex = 0; + if (m_activeMatchIndex == -1) + m_activeMatchIndex = m_lastMatchCount - 1; + } + if (selectionRect) { + WebRect rect = frame()->view()->convertToContainingWindow(currSelectionRect); + rect.x -= frameView()->scrollOffset().width(); + rect.y -= frameView()->scrollOffset().height(); + *selectionRect = rect; + + reportFindInPageSelection(rect, m_activeMatchIndex + 1, identifier); + } + } + } else { + // Nothing was found in this frame. + m_activeMatch = 0; + + // Erase all previous tickmarks and highlighting. + invalidateArea(InvalidateAll); + } + + return found; +} + +void WebFrameImpl::stopFinding(bool clearSelection) +{ + if (!clearSelection) + setFindEndstateFocusAndSelection(); + cancelPendingScopingEffort(); + + // Remove all markers for matches found and turn off the highlighting. + if (!parent()) + frame()->document()->removeMarkers(DocumentMarker::TextMatch); + frame()->setMarkedTextMatchesAreHighlighted(false); + + // Let the frame know that we don't want tickmarks or highlighting anymore. + invalidateArea(InvalidateAll); +} + +void WebFrameImpl::scopeStringMatches(int identifier, + const WebString& searchText, + const WebFindOptions& options, + bool reset) +{ + if (!shouldScopeMatches(searchText)) + return; + + WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl(); + + if (reset) { + // This is a brand new search, so we need to reset everything. + // Scoping is just about to begin. + m_scopingComplete = false; + // Clear highlighting for this frame. + if (frame()->markedTextMatchesAreHighlighted()) + frame()->page()->unmarkAllTextMatches(); + // Clear the counters from last operation. + m_lastMatchCount = 0; + m_nextInvalidateAfter = 0; + + m_resumeScopingFromRange = 0; + + mainFrameImpl->m_framesScopingCount++; + + // Now, defer scoping until later to allow find operation to finish quickly. + scopeStringMatchesSoon( + identifier, + searchText, + options, + false); // false=we just reset, so don't do it again. + return; + } + + RefPtr<Range> searchRange(rangeOfContents(frame()->document())); + + ExceptionCode ec = 0, ec2 = 0; + if (m_resumeScopingFromRange.get()) { + // This is a continuation of a scoping operation that timed out and didn't + // complete last time around, so we should start from where we left off. + searchRange->setStart(m_resumeScopingFromRange->startContainer(), + m_resumeScopingFromRange->startOffset(ec2) + 1, + ec); + if (ec || ec2) { + if (ec2) // A non-zero |ec| happens when navigating during search. + ASSERT_NOT_REACHED(); + return; + } + } + + // This timeout controls how long we scope before releasing control. This + // value does not prevent us from running for longer than this, but it is + // periodically checked to see if we have exceeded our allocated time. + const double maxScopingDuration = 0.1; // seconds + + int matchCount = 0; + bool timedOut = false; + double startTime = currentTime(); + do { + // Find next occurrence of the search string. + // FIXME: (http://b/1088245) This WebKit operation may run for longer + // than the timeout value, and is not interruptible as it is currently + // written. We may need to rewrite it with interruptibility in mind, or + // find an alternative. + RefPtr<Range> resultRange(findPlainText(searchRange.get(), + searchText, + true, + options.matchCase)); + if (resultRange->collapsed(ec)) { + if (!resultRange->startContainer()->isInShadowTree()) + break; + + searchRange = rangeOfContents(frame()->document()); + searchRange->setStartAfter( + resultRange->startContainer()->shadowAncestorNode(), ec); + continue; + } + + // A non-collapsed result range can in some funky whitespace cases still not + // advance the range's start position (4509328). Break to avoid infinite + // loop. (This function is based on the implementation of + // Frame::markAllMatchesForText, which is where this safeguard comes from). + VisiblePosition newStart = endVisiblePosition(resultRange.get(), DOWNSTREAM); + if (newStart == startVisiblePosition(searchRange.get(), DOWNSTREAM)) + break; + + // Only treat the result as a match if it is visible + if (frame()->editor()->insideVisibleArea(resultRange.get())) { + ++matchCount; + + setStart(searchRange.get(), newStart); + Node* shadowTreeRoot = searchRange->shadowTreeRootNode(); + if (searchRange->collapsed(ec) && shadowTreeRoot) + searchRange->setEnd(shadowTreeRoot, shadowTreeRoot->childNodeCount(), ec); + + // Catch a special case where Find found something but doesn't know what + // the bounding box for it is. In this case we set the first match we find + // as the active rect. + IntRect resultBounds = resultRange->boundingBox(); + IntRect activeSelectionRect; + if (m_locatingActiveRect) { + activeSelectionRect = m_activeMatch.get() ? + m_activeMatch->boundingBox() : resultBounds; + } + + // If the Find function found a match it will have stored where the + // match was found in m_activeSelectionRect on the current frame. If we + // find this rect during scoping it means we have found the active + // tickmark. + bool foundActiveMatch = false; + if (m_locatingActiveRect && (activeSelectionRect == resultBounds)) { + // We have found the active tickmark frame. + mainFrameImpl->m_activeMatchFrame = this; + foundActiveMatch = true; + // We also know which tickmark is active now. + m_activeMatchIndex = matchCount - 1; + // To stop looking for the active tickmark, we set this flag. + m_locatingActiveRect = false; + + // Notify browser of new location for the selected rectangle. + resultBounds.move(-frameView()->scrollOffset().width(), + -frameView()->scrollOffset().height()); + reportFindInPageSelection( + frame()->view()->convertToContainingWindow(resultBounds), + m_activeMatchIndex + 1, + identifier); + } + + addMarker(resultRange.get(), foundActiveMatch); + } + + m_resumeScopingFromRange = resultRange; + timedOut = (currentTime() - startTime) >= maxScopingDuration; + } while (!timedOut); + + // Remember what we search for last time, so we can skip searching if more + // letters are added to the search string (and last outcome was 0). + m_lastSearchString = searchText; + + if (matchCount > 0) { + frame()->setMarkedTextMatchesAreHighlighted(true); + + m_lastMatchCount += matchCount; + + // Let the mainframe know how much we found during this pass. + mainFrameImpl->increaseMatchCount(matchCount, identifier); + } + + if (timedOut) { + // If we found anything during this pass, we should redraw. However, we + // don't want to spam too much if the page is extremely long, so if we + // reach a certain point we start throttling the redraw requests. + if (matchCount > 0) + invalidateIfNecessary(); + + // Scoping effort ran out of time, lets ask for another time-slice. + scopeStringMatchesSoon( + identifier, + searchText, + options, + false); // don't reset. + return; // Done for now, resume work later. + } + + // This frame has no further scoping left, so it is done. Other frames might, + // of course, continue to scope matches. + m_scopingComplete = true; + mainFrameImpl->m_framesScopingCount--; + + // If this is the last frame to finish scoping we need to trigger the final + // update to be sent. + if (!mainFrameImpl->m_framesScopingCount) + mainFrameImpl->increaseMatchCount(0, identifier); + + // This frame is done, so show any scrollbar tickmarks we haven't drawn yet. + invalidateArea(InvalidateScrollbar); +} + +void WebFrameImpl::cancelPendingScopingEffort() +{ + deleteAllValues(m_deferredScopingWork); + m_deferredScopingWork.clear(); + + m_activeMatchIndex = -1; +} + +void WebFrameImpl::increaseMatchCount(int count, int identifier) +{ + // This function should only be called on the mainframe. + ASSERT(!parent()); + + m_totalMatchCount += count; + + // Update the UI with the latest findings. + if (client()) + client()->reportFindInPageMatchCount(identifier, m_totalMatchCount, !m_framesScopingCount); +} + +void WebFrameImpl::reportFindInPageSelection(const WebRect& selectionRect, + int activeMatchOrdinal, + int identifier) +{ + // Update the UI with the latest selection rect. + if (client()) + client()->reportFindInPageSelection(identifier, ordinalOfFirstMatchForFrame(this) + activeMatchOrdinal, selectionRect); +} + +void WebFrameImpl::resetMatchCount() +{ + m_totalMatchCount = 0; + m_framesScopingCount = 0; +} + +WebURL WebFrameImpl::completeURL(const WebString& url) const +{ + if (!m_frame || !m_frame->document()) + return WebURL(); + + return m_frame->document()->completeURL(url); +} + +WebString WebFrameImpl::contentAsText(size_t maxChars) const +{ + if (!m_frame) + return WebString(); + + Vector<UChar> text; + frameContentAsPlainText(maxChars, m_frame, &text); + return String::adopt(text); +} + +WebString WebFrameImpl::contentAsMarkup() const +{ + return createFullMarkup(m_frame->document()); +} + +// WebFrameImpl public --------------------------------------------------------- + +int WebFrameImpl::m_liveObjectCount = 0; + +PassRefPtr<WebFrameImpl> WebFrameImpl::create(WebFrameClient* client) +{ + return adoptRef(new WebFrameImpl(client)); +} + +WebFrameImpl::WebFrameImpl(WebFrameClient* client) + : m_frameLoaderClient(this) + , m_client(client) + , m_activeMatchFrame(0) + , m_activeMatchIndex(-1) + , m_locatingActiveRect(false) + , m_resumeScopingFromRange(0) + , m_lastMatchCount(-1) + , m_totalMatchCount(-1) + , m_framesScopingCount(-1) + , m_scopingComplete(false) + , m_nextInvalidateAfter(0) +{ + ChromiumBridge::incrementStatsCounter(webFrameActiveCount); + m_liveObjectCount++; +} + +WebFrameImpl::~WebFrameImpl() +{ + ChromiumBridge::decrementStatsCounter(webFrameActiveCount); + m_liveObjectCount--; + + cancelPendingScopingEffort(); + clearPasswordListeners(); +} + +void WebFrameImpl::initializeAsMainFrame(WebViewImpl* webViewImpl) +{ + RefPtr<Frame> frame = Frame::create(webViewImpl->page(), 0, &m_frameLoaderClient); + m_frame = frame.get(); + + // Add reference on behalf of FrameLoader. See comments in + // WebFrameLoaderClient::frameLoaderDestroyed for more info. + ref(); + + // We must call init() after m_frame is assigned because it is referenced + // during init(). + m_frame->init(); +} + +PassRefPtr<Frame> WebFrameImpl::createChildFrame( + const FrameLoadRequest& request, HTMLFrameOwnerElement* ownerElement) +{ + RefPtr<WebFrameImpl> webframe(adoptRef(new WebFrameImpl(m_client))); + + // Add an extra ref on behalf of the Frame/FrameLoader, which references the + // WebFrame via the FrameLoaderClient interface. See the comment at the top + // of this file for more info. + webframe->ref(); + + RefPtr<Frame> childFrame = Frame::create( + m_frame->page(), ownerElement, &webframe->m_frameLoaderClient); + webframe->m_frame = childFrame.get(); + + childFrame->tree()->setName(request.frameName()); + + m_frame->tree()->appendChild(childFrame); + + // Frame::init() can trigger onload event in the parent frame, + // which may detach this frame and trigger a null-pointer access + // in FrameTree::removeChild. Move init() after appendChild call + // so that webframe->mFrame is in the tree before triggering + // onload event handler. + // Because the event handler may set webframe->mFrame to null, + // it is necessary to check the value after calling init() and + // return without loading URL. + // (b:791612) + childFrame->init(); // create an empty document + if (!childFrame->tree()->parent()) + return 0; + + m_frame->loader()->loadURLIntoChildFrame( + request.resourceRequest().url(), + request.resourceRequest().httpReferrer(), + childFrame.get()); + + // A synchronous navigation (about:blank) would have already processed + // onload, so it is possible for the frame to have already been destroyed by + // script in the page. + if (!childFrame->tree()->parent()) + return 0; + + return childFrame.release(); +} + +void WebFrameImpl::layout() +{ + // layout this frame + FrameView* view = m_frame->view(); + if (view) + view->layoutIfNeededRecursive(); +} + +void WebFrameImpl::paint(WebCanvas* canvas, const WebRect& rect) +{ + if (rect.isEmpty()) + return; + IntRect dirtyRect(rect); +#if WEBKIT_USING_CG + GraphicsContext gc(canvas); + LocalCurrentGraphicsContext localContext(&gc); +#elif WEBKIT_USING_SKIA + PlatformContextSkia context(canvas); + + // PlatformGraphicsContext is actually a pointer to PlatformContextSkia + GraphicsContext gc(reinterpret_cast<PlatformGraphicsContext*>(&context)); +#else + notImplemented(); +#endif + gc.save(); + if (m_frame->document() && frameView()) { + gc.clip(dirtyRect); + frameView()->paint(&gc, dirtyRect); + m_frame->page()->inspectorController()->drawNodeHighlight(gc); + } else + gc.fillRect(dirtyRect, Color::white, DeviceColorSpace); + gc.restore(); +} + +void WebFrameImpl::createFrameView() +{ + ASSERT(m_frame); // If m_frame doesn't exist, we probably didn't init properly. + + Page* page = m_frame->page(); + ASSERT(page); + ASSERT(page->mainFrame()); + + bool isMainFrame = m_frame == page->mainFrame(); + if (isMainFrame && m_frame->view()) + m_frame->view()->setParentVisible(false); + + m_frame->setView(0); + + WebViewImpl* webView = viewImpl(); + + RefPtr<FrameView> view; + if (isMainFrame) + view = FrameView::create(m_frame, webView->size()); + else + view = FrameView::create(m_frame); + + m_frame->setView(view); + + if (webView->isTransparent()) + view->setTransparent(true); + + // FIXME: The Mac code has a comment about this possibly being unnecessary. + // See installInFrame in WebCoreFrameBridge.mm + if (m_frame->ownerRenderer()) + m_frame->ownerRenderer()->setWidget(view.get()); + + if (HTMLFrameOwnerElement* owner = m_frame->ownerElement()) + view->setCanHaveScrollbars(owner->scrollingMode() != ScrollbarAlwaysOff); + + if (isMainFrame) + view->setParentVisible(true); +} + +WebFrameImpl* WebFrameImpl::fromFrame(Frame* frame) +{ + if (!frame) + return 0; + + return static_cast<FrameLoaderClientImpl*>(frame->loader()->client())->webFrame(); +} + +WebViewImpl* WebFrameImpl::viewImpl() const +{ + if (!m_frame) + return 0; + + return WebViewImpl::fromPage(m_frame->page()); +} + +WebDataSourceImpl* WebFrameImpl::dataSourceImpl() const +{ + return static_cast<WebDataSourceImpl*>(dataSource()); +} + +WebDataSourceImpl* WebFrameImpl::provisionalDataSourceImpl() const +{ + return static_cast<WebDataSourceImpl*>(provisionalDataSource()); +} + +void WebFrameImpl::setFindEndstateFocusAndSelection() +{ + WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl(); + + if (this == mainFrameImpl->activeMatchFrame() && m_activeMatch.get()) { + // If the user has set the selection since the match was found, we + // don't focus anything. + VisibleSelection selection(frame()->selection()->selection()); + if (!selection.isNone()) + return; + + // Try to find the first focusable node up the chain, which will, for + // example, focus links if we have found text within the link. + Node* node = m_activeMatch->firstNode(); + while (node && !node->isFocusable() && node != frame()->document()) + node = node->parent(); + + if (node && node != frame()->document()) { + // Found a focusable parent node. Set focus to it. + frame()->document()->setFocusedNode(node); + return; + } + + // Iterate over all the nodes in the range until we find a focusable node. + // This, for example, sets focus to the first link if you search for + // text and text that is within one or more links. + node = m_activeMatch->firstNode(); + while (node && node != m_activeMatch->pastLastNode()) { + if (node->isFocusable()) { + frame()->document()->setFocusedNode(node); + return; + } + node = node->traverseNextNode(); + } + + // No node related to the active match was focusable, so set the + // active match as the selection (so that when you end the Find session, + // you'll have the last thing you found highlighted) and make sure that + // we have nothing focused (otherwise you might have text selected but + // a link focused, which is weird). + frame()->selection()->setSelection(m_activeMatch.get()); + frame()->document()->setFocusedNode(0); + } +} + +void WebFrameImpl::didFail(const ResourceError& error, bool wasProvisional) +{ + if (!client()) + return; + WebURLError webError = error; + if (wasProvisional) + client()->didFailProvisionalLoad(this, webError); + else + client()->didFailLoad(this, webError); +} + +void WebFrameImpl::setAllowsScrolling(bool flag) +{ + m_frame->view()->setCanHaveScrollbars(flag); +} + +void WebFrameImpl::registerPasswordListener( + WebInputElement inputElement, + WebPasswordAutocompleteListener* listener) +{ + RefPtr<HTMLInputElement> element = inputElement.operator PassRefPtr<HTMLInputElement>(); + ASSERT(m_passwordListeners.find(element) == m_passwordListeners.end()); + m_passwordListeners.set(element, listener); +} + +WebPasswordAutocompleteListener* WebFrameImpl::getPasswordListener( + HTMLInputElement* inputElement) +{ + return m_passwordListeners.get(RefPtr<HTMLInputElement>(inputElement)); +} + +// WebFrameImpl private -------------------------------------------------------- + +void WebFrameImpl::closing() +{ + m_frame = 0; +} + +void WebFrameImpl::invalidateArea(AreaToInvalidate area) +{ + ASSERT(frame() && frame()->view()); + FrameView* view = frame()->view(); + + if ((area & InvalidateAll) == InvalidateAll) + view->invalidateRect(view->frameRect()); + else { + if ((area & InvalidateContentArea) == InvalidateContentArea) { + IntRect contentArea( + view->x(), view->y(), view->visibleWidth(), view->visibleHeight()); + view->invalidateRect(contentArea); + } + + if ((area & InvalidateScrollbar) == InvalidateScrollbar) { + // Invalidate the vertical scroll bar region for the view. + IntRect scrollBarVert( + view->x() + view->visibleWidth(), view->y(), + ScrollbarTheme::nativeTheme()->scrollbarThickness(), + view->visibleHeight()); + view->invalidateRect(scrollBarVert); + } + } +} + +void WebFrameImpl::addMarker(Range* range, bool activeMatch) +{ + // Use a TextIterator to visit the potentially multiple nodes the range + // covers. + TextIterator markedText(range); + for (; !markedText.atEnd(); markedText.advance()) { + RefPtr<Range> textPiece = markedText.range(); + int exception = 0; + + DocumentMarker marker = { + DocumentMarker::TextMatch, + textPiece->startOffset(exception), + textPiece->endOffset(exception), + "", + activeMatch + }; + + if (marker.endOffset > marker.startOffset) { + // Find the node to add a marker to and add it. + Node* node = textPiece->startContainer(exception); + frame()->document()->addMarker(node, marker); + + // Rendered rects for markers in WebKit are not populated until each time + // the markers are painted. However, we need it to happen sooner, because + // the whole purpose of tickmarks on the scrollbar is to show where + // matches off-screen are (that haven't been painted yet). + Vector<DocumentMarker> markers = frame()->document()->markersForNode(node); + frame()->document()->setRenderedRectForMarker( + textPiece->startContainer(exception), + markers[markers.size() - 1], + range->boundingBox()); + } + } +} + +void WebFrameImpl::setMarkerActive(Range* range, bool active) +{ + if (!range) + return; + + frame()->document()->setMarkersActive(range, active); +} + +int WebFrameImpl::ordinalOfFirstMatchForFrame(WebFrameImpl* frame) const +{ + int ordinal = 0; + WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl(); + // Iterate from the main frame up to (but not including) |frame| and + // add up the number of matches found so far. + for (WebFrameImpl* it = mainFrameImpl; + it != frame; + it = static_cast<WebFrameImpl*>(it->traverseNext(true))) { + if (it->m_lastMatchCount > 0) + ordinal += it->m_lastMatchCount; + } + return ordinal; +} + +bool WebFrameImpl::shouldScopeMatches(const String& searchText) +{ + // Don't scope if we can't find a frame or if the frame is not visible. + // The user may have closed the tab/application, so abort. + if (!frame() || !hasVisibleContent()) + return false; + + ASSERT(frame()->document() && frame()->view()); + + // If the frame completed the scoping operation and found 0 matches the last + // time it was searched, then we don't have to search it again if the user is + // just adding to the search string or sending the same search string again. + if (m_scopingComplete && !m_lastSearchString.isEmpty() && !m_lastMatchCount) { + // Check to see if the search string prefixes match. + String previousSearchPrefix = + searchText.substring(0, m_lastSearchString.length()); + + if (previousSearchPrefix == m_lastSearchString) + return false; // Don't search this frame, it will be fruitless. + } + + return true; +} + +void WebFrameImpl::scopeStringMatchesSoon(int identifier, const WebString& searchText, + const WebFindOptions& options, bool reset) +{ + m_deferredScopingWork.append(new DeferredScopeStringMatches( + this, identifier, searchText, options, reset)); +} + +void WebFrameImpl::callScopeStringMatches(DeferredScopeStringMatches* caller, + int identifier, const WebString& searchText, + const WebFindOptions& options, bool reset) +{ + m_deferredScopingWork.remove(m_deferredScopingWork.find(caller)); + + scopeStringMatches(identifier, searchText, options, reset); + + // This needs to happen last since searchText is passed by reference. + delete caller; +} + +void WebFrameImpl::invalidateIfNecessary() +{ + if (m_lastMatchCount > m_nextInvalidateAfter) { + // FIXME: (http://b/1088165) Optimize the drawing of the tickmarks and + // remove this. This calculation sets a milestone for when next to + // invalidate the scrollbar and the content area. We do this so that we + // don't spend too much time drawing the scrollbar over and over again. + // Basically, up until the first 500 matches there is no throttle. + // After the first 500 matches, we set set the milestone further and + // further out (750, 1125, 1688, 2K, 3K). + static const int startSlowingDownAfter = 500; + static const int slowdown = 750; + int i = (m_lastMatchCount / startSlowingDownAfter); + m_nextInvalidateAfter += i * slowdown; + + invalidateArea(InvalidateScrollbar); + } +} + +void WebFrameImpl::clearPasswordListeners() +{ + deleteAllValues(m_passwordListeners); + m_passwordListeners.clear(); +} + +void WebFrameImpl::loadJavaScriptURL(const KURL& url) +{ + // This is copied from FrameLoader::executeIfJavaScriptURL. Unfortunately, + // we cannot just use that method since it is private, and it also doesn't + // quite behave as we require it to for bookmarklets. The key difference is + // that we need to suppress loading the string result from evaluating the JS + // URL if executing the JS URL resulted in a location change. We also allow + // a JS URL to be loaded even if scripts on the page are otherwise disabled. + + if (!m_frame->document() || !m_frame->page()) + return; + + String script = decodeURLEscapeSequences(url.string().substring(strlen("javascript:"))); + ScriptValue result = m_frame->script()->executeScript(script, true); + + String scriptResult; + if (!result.getString(scriptResult)) + return; + + SecurityOrigin* securityOrigin = m_frame->document()->securityOrigin(); + + if (!m_frame->redirectScheduler()->locationChangePending()) { + m_frame->loader()->stopAllLoaders(); + m_frame->loader()->begin(m_frame->loader()->url(), true, securityOrigin); + m_frame->loader()->write(scriptResult); + m_frame->loader()->end(); + } +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebFrameImpl.h b/WebKit/chromium/src/WebFrameImpl.h new file mode 100644 index 0000000..2cd332a --- /dev/null +++ b/WebKit/chromium/src/WebFrameImpl.h @@ -0,0 +1,355 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFrameImpl_h +#define WebFrameImpl_h + +// FIXME: remove this relative path once consumers from glue are removed. +#include "../public/WebFrame.h" +#include "Frame.h" +#include "FrameLoaderClientImpl.h" +#include "PlatformString.h" +#include <wtf/OwnPtr.h> +#include <wtf/RefCounted.h> + +namespace WebCore { +class HistoryItem; +class KURL; +class Node; +class Range; +class SubstituteData; +struct WindowFeatures; +} + +namespace WebKit { +class ChromePrintContext; +class WebDataSourceImpl; +class WebInputElement; +class WebFrameClient; +class WebPasswordAutocompleteListener; +class WebView; +class WebViewImpl; + +// Implementation of WebFrame, note that this is a reference counted object. +class WebFrameImpl : public WebFrame, public RefCounted<WebFrameImpl> { +public: + // WebFrame methods: + virtual WebString name() const; + virtual WebURL url() const; + virtual WebURL favIconURL() const; + virtual WebURL openSearchDescriptionURL() const; + virtual WebSize scrollOffset() const; + virtual WebSize contentsSize() const; + virtual int contentsPreferredWidth() const; + virtual int documentElementScrollHeight() const; + virtual bool hasVisibleContent() const; + virtual WebView* view() const; + virtual WebFrame* opener() const; + virtual WebFrame* parent() const; + virtual WebFrame* top() const; + virtual WebFrame* firstChild() const; + virtual WebFrame* lastChild() const; + virtual WebFrame* nextSibling() const; + virtual WebFrame* previousSibling() const; + virtual WebFrame* traverseNext(bool wrap) const; + virtual WebFrame* traversePrevious(bool wrap) const; + virtual WebFrame* findChildByName(const WebString&) const; + virtual WebFrame* findChildByExpression(const WebString&) const; + virtual void forms(WebVector<WebFormElement>&) const; + virtual WebSecurityOrigin securityOrigin() const; + virtual void grantUniversalAccess(); + virtual NPObject* windowObject() const; + virtual void bindToWindowObject(const WebString& name, NPObject*); + virtual void executeScript(const WebScriptSource&); + virtual void executeScriptInNewContext( + const WebScriptSource* sources, unsigned numSources, int extensionGroup); + virtual void executeScriptInIsolatedWorld( + int worldId, const WebScriptSource* sources, unsigned numSources, + int extensionGroup); + virtual void addMessageToConsole(const WebConsoleMessage&); + virtual void collectGarbage(); +#if WEBKIT_USING_V8 + virtual v8::Local<v8::Context> mainWorldScriptContext() const; +#endif + virtual bool insertStyleText(const WebString& css, const WebString& id); + virtual void reload(); + virtual void loadRequest(const WebURLRequest&); + virtual void loadHistoryItem(const WebHistoryItem&); + virtual void loadData( + const WebData&, const WebString& mimeType, const WebString& textEncoding, + const WebURL& baseURL, const WebURL& unreachableURL, bool replace); + virtual void loadHTMLString( + const WebData& html, const WebURL& baseURL, const WebURL& unreachableURL, + bool replace); + virtual bool isLoading() const; + virtual void stopLoading(); + virtual WebDataSource* provisionalDataSource() const; + virtual WebDataSource* dataSource() const; + virtual WebHistoryItem previousHistoryItem() const; + virtual WebHistoryItem currentHistoryItem() const; + virtual void enableViewSourceMode(bool enable); + virtual bool isViewSourceModeEnabled() const; + virtual void setReferrerForRequest(WebURLRequest&, const WebURL& referrer); + virtual void dispatchWillSendRequest(WebURLRequest&); + virtual void commitDocumentData(const char* data, size_t length); + virtual unsigned unloadListenerCount() const; + virtual bool isProcessingUserGesture() const; + virtual bool willSuppressOpenerInNewFrame() const; + virtual void replaceSelection(const WebString&); + virtual void insertText(const WebString&); + virtual void setMarkedText(const WebString&, unsigned location, unsigned length); + virtual void unmarkText(); + virtual bool hasMarkedText() const; + virtual WebRange markedRange() const; + virtual bool executeCommand(const WebString&); + virtual bool executeCommand(const WebString&, const WebString& value); + virtual bool isCommandEnabled(const WebString&) const; + virtual void enableContinuousSpellChecking(bool); + virtual bool isContinuousSpellCheckingEnabled() const; + virtual bool hasSelection() const; + virtual WebRange selectionRange() const; + virtual WebString selectionAsText() const; + virtual WebString selectionAsMarkup() const; + virtual int printBegin(const WebSize& pageSize); + virtual float printPage(int pageToPrint, WebCanvas*); + virtual float getPrintPageShrink(int page); + virtual void printEnd(); + virtual bool find( + int identifier, const WebString& searchText, const WebFindOptions&, + bool wrapWithinFrame, WebRect* selectionRect); + virtual void stopFinding(bool clearSelection); + virtual void scopeStringMatches( + int identifier, const WebString& searchText, const WebFindOptions&, + bool reset); + virtual void cancelPendingScopingEffort(); + virtual void increaseMatchCount(int count, int identifier); + virtual void resetMatchCount(); + virtual void registerPasswordListener( + WebInputElement, WebPasswordAutocompleteListener*); + + virtual WebURL completeURL(const WebString& url) const; + virtual WebString contentAsText(size_t maxChars) const; + virtual WebString contentAsMarkup() const; + + static PassRefPtr<WebFrameImpl> create(WebFrameClient* client); + ~WebFrameImpl(); + + static int liveObjectCount() { return m_liveObjectCount; } + + // Called by the WebViewImpl to initialize its main frame: + void initializeAsMainFrame(WebViewImpl*); + + PassRefPtr<WebCore::Frame> createChildFrame( + const WebCore::FrameLoadRequest&, WebCore::HTMLFrameOwnerElement*); + + void layout(); + void paint(WebCanvas*, const WebRect&); + void createFrameView(); + + static WebFrameImpl* fromFrame(WebCore::Frame* frame); + + WebViewImpl* viewImpl() const; + + WebCore::Frame* frame() const { return m_frame; } + WebCore::FrameView* frameView() const { return m_frame ? m_frame->view() : 0; } + + // Getters for the impls corresponding to Get(Provisional)DataSource. They + // may return 0 if there is no corresponding data source. + WebDataSourceImpl* dataSourceImpl() const; + WebDataSourceImpl* provisionalDataSourceImpl() const; + + // Returns which frame has an active match. This function should only be + // called on the main frame, as it is the only frame keeping track. Returned + // value can be 0 if no frame has an active match. + const WebFrameImpl* activeMatchFrame() const { return m_activeMatchFrame; } + + // When a Find operation ends, we want to set the selection to what was active + // and set focus to the first focusable node we find (starting with the first + // node in the matched range and going up the inheritance chain). If we find + // nothing to focus we focus the first focusable node in the range. This + // allows us to set focus to a link (when we find text inside a link), which + // allows us to navigate by pressing Enter after closing the Find box. + void setFindEndstateFocusAndSelection(); + + void didFail(const WebCore::ResourceError&, bool wasProvisional); + + // Sets whether the WebFrameImpl allows its document to be scrolled. + // If the parameter is true, allow the document to be scrolled. + // Otherwise, disallow scrolling. + void setAllowsScrolling(bool); + + // Returns the password autocomplete listener associated with the passed + // user name input element, or 0 if none available. + // Note that the returned listener is owner by the WebFrameImpl and should not + // be kept around as it is deleted when the page goes away. + WebPasswordAutocompleteListener* getPasswordListener(WebCore::HTMLInputElement*); + + WebFrameClient* client() const { return m_client; } + void dropClient() { m_client = 0; } + +private: + class DeferredScopeStringMatches; + friend class DeferredScopeStringMatches; + friend class FrameLoaderClientImpl; + + // A bit mask specifying area of the frame to invalidate. + enum AreaToInvalidate { + InvalidateNothing, + InvalidateContentArea, + InvalidateScrollbar, // Vertical scrollbar only. + InvalidateAll // Both content area and the scrollbar. + }; + + WebFrameImpl(WebFrameClient*); + + // Informs the WebFrame that the Frame is being closed, called by the + // WebFrameLoaderClient + void closing(); + + // Notifies the delegate about a new selection rect. + void reportFindInPageSelection( + const WebRect& selectionRect, int activeMatchOrdinal, int identifier); + + // Invalidates a certain area within the frame. + void invalidateArea(AreaToInvalidate); + + // Add a WebKit TextMatch-highlight marker to nodes in a range. + void addMarker(WebCore::Range*, bool activeMatch); + + // Sets the markers within a range as active or inactive. + void setMarkerActive(WebCore::Range*, bool active); + + // Returns the ordinal of the first match in the frame specified. This + // function enumerates the frames, starting with the main frame and up to (but + // not including) the frame passed in as a parameter and counts how many + // matches have been found. + int ordinalOfFirstMatchForFrame(WebFrameImpl*) const; + + // Determines whether the scoping effort is required for a particular frame. + // It is not necessary if the frame is invisible, for example, or if this + // is a repeat search that already returned nothing last time the same prefix + // was searched. + bool shouldScopeMatches(const WebCore::String& searchText); + + // Queue up a deferred call to scopeStringMatches. + void scopeStringMatchesSoon( + int identifier, const WebString& searchText, const WebFindOptions&, + bool reset); + + // Called by a DeferredScopeStringMatches instance. + void callScopeStringMatches( + DeferredScopeStringMatches*, int identifier, const WebString& searchText, + const WebFindOptions&, bool reset); + + // Determines whether to invalidate the content area and scrollbar. + void invalidateIfNecessary(); + + // Clears the map of password listeners. + void clearPasswordListeners(); + + void loadJavaScriptURL(const WebCore::KURL&); + + // Used to check for leaks of this object. + static int m_liveObjectCount; + + FrameLoaderClientImpl m_frameLoaderClient; + + WebFrameClient* m_client; + + // This is a weak pointer to our corresponding WebCore frame. A reference to + // ourselves is held while frame_ is valid. See our Closing method. + WebCore::Frame* m_frame; + + // A way for the main frame to keep track of which frame has an active + // match. Should be 0 for all other frames. + WebFrameImpl* m_activeMatchFrame; + + // The range of the active match for the current frame. + RefPtr<WebCore::Range> m_activeMatch; + + // The index of the active match. + int m_activeMatchIndex; + + // This flag is used by the scoping effort to determine if we need to figure + // out which rectangle is the active match. Once we find the active + // rectangle we clear this flag. + bool m_locatingActiveRect; + + // The scoping effort can time out and we need to keep track of where we + // ended our last search so we can continue from where we left of. + RefPtr<WebCore::Range> m_resumeScopingFromRange; + + // Keeps track of the last string this frame searched for. This is used for + // short-circuiting searches in the following scenarios: When a frame has + // been searched and returned 0 results, we don't need to search that frame + // again if the user is just adding to the search (making it more specific). + WebCore::String m_lastSearchString; + + // Keeps track of how many matches this frame has found so far, so that we + // don't loose count between scoping efforts, and is also used (in conjunction + // with m_lastSearchString and m_scopingComplete) to figure out if we need to + // search the frame again. + int m_lastMatchCount; + + // This variable keeps a cumulative total of matches found so far for ALL the + // frames on the page, and is only incremented by calling IncreaseMatchCount + // (on the main frame only). It should be -1 for all other frames. + size_t m_totalMatchCount; + + // This variable keeps a cumulative total of how many frames are currently + // scoping, and is incremented/decremented on the main frame only. + // It should be -1 for all other frames. + int m_framesScopingCount; + + // Keeps track of whether the scoping effort was completed (the user may + // interrupt it before it completes by submitting a new search). + bool m_scopingComplete; + + // Keeps track of when the scoping effort should next invalidate the scrollbar + // and the frame area. + int m_nextInvalidateAfter; + + // A list of all of the pending calls to scopeStringMatches. + Vector<DeferredScopeStringMatches*> m_deferredScopingWork; + + // Valid between calls to BeginPrint() and EndPrint(). Containts the print + // information. Is used by PrintPage(). + OwnPtr<ChromePrintContext> m_printContext; + + // The input fields that are interested in edit events and their associated + // listeners. + typedef HashMap<RefPtr<WebCore::HTMLInputElement>, + WebPasswordAutocompleteListener*> PasswordListenerMap; + PasswordListenerMap m_passwordListeners; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebHTTPBody.cpp b/WebKit/chromium/src/WebHTTPBody.cpp new file mode 100644 index 0000000..335ed5c --- /dev/null +++ b/WebKit/chromium/src/WebHTTPBody.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebHTTPBody.h" + +#include "FormData.h" + +using namespace WebCore; + +namespace WebKit { + +class WebHTTPBodyPrivate : public FormData { +}; + +void WebHTTPBody::initialize() +{ + assign(static_cast<WebHTTPBodyPrivate*>(FormData::create().releaseRef())); +} + +void WebHTTPBody::reset() +{ + assign(0); +} + +void WebHTTPBody::assign(const WebHTTPBody& other) +{ + WebHTTPBodyPrivate* p = const_cast<WebHTTPBodyPrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +size_t WebHTTPBody::elementCount() const +{ + ASSERT(!isNull()); + return m_private->elements().size(); +} + +bool WebHTTPBody::elementAt(size_t index, Element& result) const +{ + ASSERT(!isNull()); + + if (index >= m_private->elements().size()) + return false; + + const FormDataElement& element = m_private->elements()[index]; + + switch (element.m_type) { + case FormDataElement::data: + result.type = Element::TypeData; + result.data.assign(element.m_data.data(), element.m_data.size()); + result.filePath.reset(); + break; + case FormDataElement::encodedFile: + result.type = Element::TypeFile; + result.data.reset(); + result.filePath = element.m_filename; + break; + default: + ASSERT_NOT_REACHED(); + return false; + } + + return true; +} + +void WebHTTPBody::appendData(const WebData& data) +{ + ensureMutable(); + // FIXME: FormDataElement::m_data should be a SharedBuffer<char>. Then we + // could avoid this buffer copy. + m_private->appendData(data.data(), data.size()); +} + +void WebHTTPBody::appendFile(const WebString& filePath) +{ + ensureMutable(); + m_private->appendFile(filePath); +} + +long long WebHTTPBody::identifier() const +{ + ASSERT(!isNull()); + return m_private->identifier(); +} + +void WebHTTPBody::setIdentifier(long long identifier) +{ + ensureMutable(); + return m_private->setIdentifier(identifier); +} + +WebHTTPBody::WebHTTPBody(const PassRefPtr<FormData>& data) + : m_private(static_cast<WebHTTPBodyPrivate*>(data.releaseRef())) +{ +} + +WebHTTPBody& WebHTTPBody::operator=(const PassRefPtr<FormData>& data) +{ + assign(static_cast<WebHTTPBodyPrivate*>(data.releaseRef())); + return *this; +} + +WebHTTPBody::operator PassRefPtr<FormData>() const +{ + return m_private; +} + +void WebHTTPBody::assign(WebHTTPBodyPrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +void WebHTTPBody::ensureMutable() +{ + ASSERT(!isNull()); + if (!m_private->hasOneRef()) + assign(static_cast<WebHTTPBodyPrivate*>(m_private->copy().releaseRef())); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebHistoryItem.cpp b/WebKit/chromium/src/WebHistoryItem.cpp new file mode 100644 index 0000000..d4ee50a --- /dev/null +++ b/WebKit/chromium/src/WebHistoryItem.cpp @@ -0,0 +1,296 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebHistoryItem.h" + +#include "FormData.h" +#include "HistoryItem.h" +#include "KURL.h" + +#include "WebHTTPBody.h" +#include "WebPoint.h" +#include "WebString.h" +#include "WebVector.h" + +using namespace WebCore; + +namespace WebKit { + +class WebHistoryItemPrivate : public HistoryItem { +}; + +void WebHistoryItem::initialize() +{ + assign(static_cast<WebHistoryItemPrivate*>(HistoryItem::create().releaseRef())); +} + +void WebHistoryItem::reset() +{ + assign(0); +} + +void WebHistoryItem::assign(const WebHistoryItem& other) +{ + WebHistoryItemPrivate* p = const_cast<WebHistoryItemPrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +WebString WebHistoryItem::urlString() const +{ + ASSERT(!isNull()); + return m_private->urlString(); +} + +void WebHistoryItem::setURLString(const WebString& url) +{ + ensureMutable(); + m_private->setURLString(KURL(ParsedURLString, url).string()); +} + +WebString WebHistoryItem::originalURLString() const +{ + ASSERT(!isNull()); + return m_private->originalURLString(); +} + +void WebHistoryItem::setOriginalURLString(const WebString& originalURLString) +{ + ensureMutable(); + m_private->setOriginalURLString(originalURLString); +} + +WebString WebHistoryItem::referrer() const +{ + ASSERT(!isNull()); + return m_private->referrer(); +} + +void WebHistoryItem::setReferrer(const WebString& referrer) +{ + ensureMutable(); + m_private->setReferrer(referrer); +} + +WebString WebHistoryItem::target() const +{ + ASSERT(!isNull()); + return m_private->target(); +} + +void WebHistoryItem::setTarget(const WebString& target) +{ + ensureMutable(); + m_private->setTarget(target); +} + +WebString WebHistoryItem::parent() const +{ + ASSERT(!isNull()); + return m_private->parent(); +} + +void WebHistoryItem::setParent(const WebString& parent) +{ + ensureMutable(); + m_private->setParent(parent); +} + +WebString WebHistoryItem::title() const +{ + ASSERT(!isNull()); + return m_private->title(); +} + +void WebHistoryItem::setTitle(const WebString& title) +{ + ensureMutable(); + m_private->setTitle(title); +} + +WebString WebHistoryItem::alternateTitle() const +{ + ASSERT(!isNull()); + return m_private->alternateTitle(); +} + +void WebHistoryItem::setAlternateTitle(const WebString& alternateTitle) +{ + ensureMutable(); + m_private->setAlternateTitle(alternateTitle); +} + +double WebHistoryItem::lastVisitedTime() const +{ + ASSERT(!isNull()); + return m_private->lastVisitedTime(); +} + +void WebHistoryItem::setLastVisitedTime(double lastVisitedTime) +{ + ensureMutable(); + // FIXME: setLastVisitedTime increments the visit count, so we have to + // correct for that. Instead, we should have a back-door to just mutate + // the last visited time directly. + int count = m_private->visitCount(); + m_private->setLastVisitedTime(lastVisitedTime); + m_private->setVisitCount(count); +} + +WebPoint WebHistoryItem::scrollOffset() const +{ + ASSERT(!isNull()); + return m_private->scrollPoint(); +} + +void WebHistoryItem::setScrollOffset(const WebPoint& scrollOffset) +{ + ensureMutable(); + m_private->setScrollPoint(scrollOffset); +} + +bool WebHistoryItem::isTargetItem() const +{ + ASSERT(!isNull()); + return m_private->isTargetItem(); +} + +void WebHistoryItem::setIsTargetItem(bool isTargetItem) +{ + ensureMutable(); + m_private->setIsTargetItem(isTargetItem); +} + +int WebHistoryItem::visitCount() const +{ + ASSERT(!isNull()); + return m_private->visitCount(); +} + +void WebHistoryItem::setVisitCount(int count) +{ + ensureMutable(); + m_private->setVisitCount(count); +} + +WebVector<WebString> WebHistoryItem::documentState() const +{ + ASSERT(!isNull()); + return m_private->documentState(); +} + +void WebHistoryItem::setDocumentState(const WebVector<WebString>& state) +{ + ensureMutable(); + // FIXME: would be nice to avoid the intermediate copy + Vector<String> ds; + for (size_t i = 0; i < state.size(); ++i) + ds.append(state[i]); + m_private->setDocumentState(ds); +} + +WebString WebHistoryItem::httpContentType() const +{ + ASSERT(!isNull()); + return m_private->formContentType(); +} + +void WebHistoryItem::setHTTPContentType(const WebString& httpContentType) +{ + ensureMutable(); + m_private->setFormContentType(httpContentType); +} + +WebHTTPBody WebHistoryItem::httpBody() const +{ + ASSERT(!isNull()); + return WebHTTPBody(m_private->formData()); +} + +void WebHistoryItem::setHTTPBody(const WebHTTPBody& httpBody) +{ + ensureMutable(); + m_private->setFormData(httpBody); +} + +WebVector<WebHistoryItem> WebHistoryItem::children() const +{ + ASSERT(!isNull()); + return m_private->children(); +} + +void WebHistoryItem::setChildren(const WebVector<WebHistoryItem>& items) +{ + ensureMutable(); + m_private->clearChildren(); + for (size_t i = 0; i < items.size(); ++i) + m_private->addChildItem(items[i]); +} + +void WebHistoryItem::appendToChildren(const WebHistoryItem& item) +{ + ensureMutable(); + m_private->addChildItem(item); +} + +WebHistoryItem::WebHistoryItem(const PassRefPtr<HistoryItem>& item) + : m_private(static_cast<WebHistoryItemPrivate*>(item.releaseRef())) +{ +} + +WebHistoryItem& WebHistoryItem::operator=(const PassRefPtr<HistoryItem>& item) +{ + assign(static_cast<WebHistoryItemPrivate*>(item.releaseRef())); + return *this; +} + +WebHistoryItem::operator PassRefPtr<HistoryItem>() const +{ + return m_private; +} + +void WebHistoryItem::assign(WebHistoryItemPrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +void WebHistoryItem::ensureMutable() +{ + ASSERT(!isNull()); + if (!m_private->hasOneRef()) + assign(static_cast<WebHistoryItemPrivate*>(m_private->copy().releaseRef())); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebImageCG.cpp b/WebKit/chromium/src/WebImageCG.cpp new file mode 100644 index 0000000..60b2449 --- /dev/null +++ b/WebKit/chromium/src/WebImageCG.cpp @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebImage.h" + +#include "Image.h" +#include "ImageSource.h" +#include "SharedBuffer.h" + +#include "WebData.h" +#include "WebSize.h" + +#include <CoreGraphics/CGImage.h> + +#include <wtf/PassRefPtr.h> +#include <wtf/RetainPtr.h> + +using namespace WebCore; + +namespace WebKit { + +WebImage WebImage::fromData(const WebData& data, const WebSize& desiredSize) +{ + // FIXME: Do something like what WebImageSkia.cpp does to enumerate frames. + // Not sure whether the CG decoder uses the same frame ordering rules (if so + // we can just use the same logic). + + ImageSource source; + source.setData(PassRefPtr<SharedBuffer>(data).get(), true); + if (!source.isSizeAvailable()) + return WebImage(); + + RetainPtr<CGImageRef> frame0(AdoptCF, source.createFrameAtIndex(0)); + if (!frame0) + return WebImage(); + + return WebImage(frame0.get()); +} + +void WebImage::reset() +{ + CGImageRelease(m_imageRef); + m_imageRef = 0; +} + +void WebImage::assign(const WebImage& image) +{ + assign(image.m_imageRef); +} + +bool WebImage::isNull() const +{ + return !m_imageRef; +} + +WebSize WebImage::size() const +{ + return WebSize(CGImageGetWidth(m_imageRef), CGImageGetHeight(m_imageRef)); +} + +WebImage::WebImage(const PassRefPtr<Image>& image) + : m_imageRef(0) +{ + if (image.get()) + assign(image->nativeImageForCurrentFrame()); +} + +WebImage& WebImage::operator=(const PassRefPtr<Image>& image) +{ + if (image.get()) + assign(image->nativeImageForCurrentFrame()); + else + reset(); + return *this; +} + +void WebImage::assign(CGImageRef imageRef) +{ + // Make sure to retain the imageRef first incase m_imageRef == imageRef. + CGImageRetain(imageRef); + CGImageRelease(m_imageRef); + m_imageRef = imageRef; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebImageSkia.cpp b/WebKit/chromium/src/WebImageSkia.cpp new file mode 100644 index 0000000..0684b58 --- /dev/null +++ b/WebKit/chromium/src/WebImageSkia.cpp @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebImage.h" + +#include "Image.h" +#include "ImageSource.h" +#include "NativeImageSkia.h" +#include "SharedBuffer.h" + +#include "WebData.h" +#include "WebSize.h" + +#include <wtf/OwnPtr.h> +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +WebImage WebImage::fromData(const WebData& data, const WebSize& desiredSize) +{ + ImageSource source; + source.setData(PassRefPtr<SharedBuffer>(data).get(), true); + if (!source.isSizeAvailable()) + return WebImage(); + + // Frames are arranged by decreasing size, then decreasing bit depth. + // Pick the frame closest to |desiredSize|'s area without being smaller, + // which has the highest bit depth. + const size_t frameCount = source.frameCount(); + size_t index = 0; // Default to first frame if none are large enough. + int frameAreaAtIndex = 0; + for (size_t i = 0; i < frameCount; ++i) { + const IntSize frameSize = source.frameSizeAtIndex(i); + if (WebSize(frameSize) == desiredSize) { + index = i; + break; // Perfect match. + } + + const int frameArea = frameSize.width() * frameSize.height(); + if (frameArea < (desiredSize.width * desiredSize.height)) + break; // No more frames that are large enough. + + if (!i || (frameArea < frameAreaAtIndex)) { + index = i; // Closer to desired area than previous best match. + frameAreaAtIndex = frameArea; + } + } + + OwnPtr<NativeImageSkia> frame(source.createFrameAtIndex(index)); + if (!frame.get()) + return WebImage(); + + return WebImage(*frame); +} + +void WebImage::reset() +{ + m_bitmap.reset(); +} + +void WebImage::assign(const WebImage& image) +{ + m_bitmap = image.m_bitmap; +} + +bool WebImage::isNull() const +{ + return m_bitmap.isNull(); +} + +WebSize WebImage::size() const +{ + return WebSize(m_bitmap.width(), m_bitmap.height()); +} + +WebImage::WebImage(const PassRefPtr<Image>& image) +{ + operator=(image); +} + +WebImage& WebImage::operator=(const PassRefPtr<Image>& image) +{ + NativeImagePtr p; + if (image.get() && (p = image->nativeImageForCurrentFrame())) + assign(*p); + else + reset(); + return *this; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebInputElement.cpp b/WebKit/chromium/src/WebInputElement.cpp new file mode 100644 index 0000000..d403120 --- /dev/null +++ b/WebKit/chromium/src/WebInputElement.cpp @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebInputElement.h" + +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "WebString.h" +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +WebInputElement::WebInputElement(const WTF::PassRefPtr<HTMLInputElement>& elem) + : WebElement(elem.releaseRef()) +{ +} + +WebInputElement& WebInputElement::operator=(const WTF::PassRefPtr<HTMLInputElement>& elem) +{ + WebNode::assign(elem.releaseRef()); + return *this; +} + +WebInputElement::operator WTF::PassRefPtr<HTMLInputElement>() const +{ + return PassRefPtr<HTMLInputElement>(static_cast<HTMLInputElement*>(m_private)); +} + +bool WebInputElement::isEnabledFormControl() const +{ + return constUnwrap<HTMLInputElement>()->isEnabledFormControl(); +} + +WebInputElement::InputType WebInputElement::inputType() const +{ + return static_cast<InputType>(constUnwrap<HTMLInputElement>()->inputType()); +} + +WebString WebInputElement::formControlType() const +{ + return constUnwrap<HTMLInputElement>()->formControlType(); +} + +void WebInputElement::setActivatedSubmit(bool activated) +{ + unwrap<HTMLInputElement>()->setActivatedSubmit(activated); +} + +void WebInputElement::setValue(const WebString& value) +{ + unwrap<HTMLInputElement>()->setValue(value); +} + +WebString WebInputElement::value() const +{ + return constUnwrap<HTMLInputElement>()->value(); +} + +void WebInputElement::setAutofilled(bool autoFilled) +{ + unwrap<HTMLInputElement>()->setAutofilled(autoFilled); +} + +void WebInputElement::dispatchFormControlChangeEvent() +{ + unwrap<HTMLInputElement>()->dispatchFormControlChangeEvent(); +} + +void WebInputElement::setSelectionRange(int start, int end) +{ + unwrap<HTMLInputElement>()->setSelectionRange(start, end); +} + +WebString WebInputElement::name() const +{ + return constUnwrap<HTMLInputElement>()->name(); +} + +WebString WebInputElement::nameForAutofill() const +{ + String name = constUnwrap<HTMLInputElement>()->name(); + String trimmedName = name.stripWhiteSpace(); + if (!trimmedName.isEmpty()) + return trimmedName; + name = constUnwrap<HTMLInputElement>()->getAttribute(HTMLNames::idAttr); + trimmedName = name.stripWhiteSpace(); + if (!trimmedName.isEmpty()) + return trimmedName; + return String(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebInputEvent.cpp b/WebKit/chromium/src/WebInputEvent.cpp new file mode 100644 index 0000000..b5c56fa --- /dev/null +++ b/WebKit/chromium/src/WebInputEvent.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebInputEvent.h" + +#include "KeyboardCodes.h" + +#include <ctype.h> +#include <stdio.h> + +#include <wtf/Assertions.h> +#include <wtf/StringExtras.h> + +using namespace WebCore; + +namespace WebKit { + +static const char* staticKeyIdentifiers(unsigned short keyCode) +{ + switch (keyCode) { + case VKEY_MENU: + return "Alt"; + case VKEY_CONTROL: + return "Control"; + case VKEY_SHIFT: + return "Shift"; + case VKEY_CAPITAL: + return "CapsLock"; + case VKEY_LWIN: + case VKEY_RWIN: + return "Win"; + case VKEY_CLEAR: + return "Clear"; + case VKEY_DOWN: + return "Down"; + case VKEY_END: + return "End"; + case VKEY_RETURN: + return "Enter"; + case VKEY_EXECUTE: + return "Execute"; + case VKEY_F1: + return "F1"; + case VKEY_F2: + return "F2"; + case VKEY_F3: + return "F3"; + case VKEY_F4: + return "F4"; + case VKEY_F5: + return "F5"; + case VKEY_F6: + return "F6"; + case VKEY_F7: + return "F7"; + case VKEY_F8: + return "F8"; + case VKEY_F9: + return "F9"; + case VKEY_F10: + return "F11"; + case VKEY_F12: + return "F12"; + case VKEY_F13: + return "F13"; + case VKEY_F14: + return "F14"; + case VKEY_F15: + return "F15"; + case VKEY_F16: + return "F16"; + case VKEY_F17: + return "F17"; + case VKEY_F18: + return "F18"; + case VKEY_F19: + return "F19"; + case VKEY_F20: + return "F20"; + case VKEY_F21: + return "F21"; + case VKEY_F22: + return "F22"; + case VKEY_F23: + return "F23"; + case VKEY_F24: + return "F24"; + case VKEY_HELP: + return "Help"; + case VKEY_HOME: + return "Home"; + case VKEY_INSERT: + return "Insert"; + case VKEY_LEFT: + return "Left"; + case VKEY_NEXT: + return "PageDown"; + case VKEY_PRIOR: + return "PageUp"; + case VKEY_PAUSE: + return "Pause"; + case VKEY_SNAPSHOT: + return "PrintScreen"; + case VKEY_RIGHT: + return "Right"; + case VKEY_SCROLL: + return "Scroll"; + case VKEY_SELECT: + return "Select"; + case VKEY_UP: + return "Up"; + case VKEY_DELETE: + return "U+007F"; // Standard says that DEL becomes U+007F. + default: + return 0; + } +} + +void WebKeyboardEvent::setKeyIdentifierFromWindowsKeyCode() +{ + const char* id = staticKeyIdentifiers(windowsKeyCode); + if (id) { + strncpy(keyIdentifier, id, sizeof(keyIdentifier) - 1); + keyIdentifier[sizeof(keyIdentifier) - 1] = '\0'; + } else + snprintf(keyIdentifier, sizeof(keyIdentifier), "U+%04X", toupper(windowsKeyCode)); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebInputEventConversion.cpp b/WebKit/chromium/src/WebInputEventConversion.cpp new file mode 100644 index 0000000..147f88b --- /dev/null +++ b/WebKit/chromium/src/WebInputEventConversion.cpp @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebInputEventConversion.h" + +#include "EventNames.h" +#include "KeyboardCodes.h" +#include "KeyboardEvent.h" +#include "MouseEvent.h" +#include "PlatformKeyboardEvent.h" +#include "PlatformMouseEvent.h" +#include "PlatformWheelEvent.h" +#include "ScrollView.h" +#include "WebInputEvent.h" +#include "Widget.h" + +using namespace WebCore; + +namespace WebKit { + +// MakePlatformMouseEvent ----------------------------------------------------- + +PlatformMouseEventBuilder::PlatformMouseEventBuilder(Widget* widget, const WebMouseEvent& e) +{ + // FIXME: widget is always toplevel, unless it's a popup. We may be able + // to get rid of this once we abstract popups into a WebKit API. + m_position = widget->convertFromContainingWindow(IntPoint(e.x, e.y)); + m_globalPosition = IntPoint(e.globalX, e.globalY); + m_button = static_cast<MouseButton>(e.button); + m_shiftKey = (e.modifiers & WebInputEvent::ShiftKey); + m_ctrlKey = (e.modifiers & WebInputEvent::ControlKey); + m_altKey = (e.modifiers & WebInputEvent::AltKey); + m_metaKey = (e.modifiers & WebInputEvent::MetaKey); + m_modifierFlags = e.modifiers; + m_timestamp = e.timeStampSeconds; + m_clickCount = e.clickCount; + + switch (e.type) { + case WebInputEvent::MouseMove: + case WebInputEvent::MouseLeave: // synthesize a move event + m_eventType = MouseEventMoved; + break; + + case WebInputEvent::MouseDown: + m_eventType = MouseEventPressed; + break; + + case WebInputEvent::MouseUp: + m_eventType = MouseEventReleased; + break; + + default: + ASSERT_NOT_REACHED(); + } +} + +// PlatformWheelEventBuilder -------------------------------------------------- + +PlatformWheelEventBuilder::PlatformWheelEventBuilder(Widget* widget, const WebMouseWheelEvent& e) +{ + m_position = widget->convertFromContainingWindow(IntPoint(e.x, e.y)); + m_globalPosition = IntPoint(e.globalX, e.globalY); + m_deltaX = e.deltaX; + m_deltaY = e.deltaY; + m_wheelTicksX = e.wheelTicksX; + m_wheelTicksY = e.wheelTicksY; + m_isAccepted = false; + m_granularity = e.scrollByPage ? + ScrollByPageWheelEvent : ScrollByPixelWheelEvent; + m_shiftKey = (e.modifiers & WebInputEvent::ShiftKey); + m_ctrlKey = (e.modifiers & WebInputEvent::ControlKey); + m_altKey = (e.modifiers & WebInputEvent::AltKey); + m_metaKey = (e.modifiers & WebInputEvent::MetaKey); +} + +// MakePlatformKeyboardEvent -------------------------------------------------- + +static inline const PlatformKeyboardEvent::Type toPlatformKeyboardEventType(WebInputEvent::Type type) +{ + switch (type) { + case WebInputEvent::KeyUp: + return PlatformKeyboardEvent::KeyUp; + case WebInputEvent::KeyDown: + return PlatformKeyboardEvent::KeyDown; + case WebInputEvent::RawKeyDown: + return PlatformKeyboardEvent::RawKeyDown; + case WebInputEvent::Char: + return PlatformKeyboardEvent::Char; + default: + ASSERT_NOT_REACHED(); + } + return PlatformKeyboardEvent::KeyDown; +} + +PlatformKeyboardEventBuilder::PlatformKeyboardEventBuilder(const WebKeyboardEvent& e) +{ + m_type = toPlatformKeyboardEventType(e.type); + m_text = String(e.text); + m_unmodifiedText = String(e.unmodifiedText); + m_keyIdentifier = String(e.keyIdentifier); + m_autoRepeat = (e.modifiers & WebInputEvent::IsAutoRepeat); + m_windowsVirtualKeyCode = e.windowsKeyCode; + m_nativeVirtualKeyCode = e.nativeKeyCode; + m_isKeypad = (e.modifiers & WebInputEvent::IsKeyPad); + m_shiftKey = (e.modifiers & WebInputEvent::ShiftKey); + m_ctrlKey = (e.modifiers & WebInputEvent::ControlKey); + m_altKey = (e.modifiers & WebInputEvent::AltKey); + m_metaKey = (e.modifiers & WebInputEvent::MetaKey); + m_isSystemKey = e.isSystemKey; +} + +void PlatformKeyboardEventBuilder::setKeyType(Type type) +{ + // According to the behavior of Webkit in Windows platform, + // we need to convert KeyDown to RawKeydown and Char events + // See WebKit/WebKit/Win/WebView.cpp + ASSERT(m_type == KeyDown); + ASSERT(type == RawKeyDown || type == Char); + m_type = type; + + if (type == RawKeyDown) { + m_text = String(); + m_unmodifiedText = String(); + } else { + m_keyIdentifier = String(); + m_windowsVirtualKeyCode = 0; + } +} + +// Please refer to bug http://b/issue?id=961192, which talks about Webkit +// keyboard event handling changes. It also mentions the list of keys +// which don't have associated character events. +bool PlatformKeyboardEventBuilder::isCharacterKey() const +{ + switch (windowsVirtualKeyCode()) { + case VKEY_BACK: + case VKEY_ESCAPE: + return false; + } + return true; +} + +static int getWebInputModifiers(const UIEventWithKeyState& event) +{ + int modifiers = 0; + if (event.ctrlKey()) + modifiers |= WebInputEvent::ControlKey; + if (event.shiftKey()) + modifiers |= WebInputEvent::ShiftKey; + if (event.altKey()) + modifiers |= WebInputEvent::AltKey; + if (event.metaKey()) + modifiers |= WebInputEvent::MetaKey; + return modifiers; +} + +WebMouseEventBuilder::WebMouseEventBuilder(const ScrollView* view, const MouseEvent& event) +{ + if (event.type() == eventNames().mousemoveEvent) + type = WebInputEvent::MouseMove; + else if (event.type() == eventNames().mouseoutEvent) + type = WebInputEvent::MouseLeave; + else if (event.type() == eventNames().mouseoverEvent) + type = WebInputEvent::MouseEnter; + else if (event.type() == eventNames().mousedownEvent) + type = WebInputEvent::MouseDown; + else if (event.type() == eventNames().mouseupEvent) + type = WebInputEvent::MouseUp; + else + return; // Skip all other mouse events. + timeStampSeconds = event.timeStamp() * 1.0e-3; + switch (event.button()) { + case LeftButton: + button = WebMouseEvent::ButtonLeft; + break; + case MiddleButton: + button = WebMouseEvent::ButtonMiddle; + break; + case RightButton: + button = WebMouseEvent::ButtonRight; + break; + } + modifiers = getWebInputModifiers(event); + if (event.buttonDown()) { + switch (event.button()) { + case LeftButton: + modifiers |= WebInputEvent::LeftButtonDown; + break; + case MiddleButton: + modifiers |= WebInputEvent::MiddleButtonDown; + break; + case RightButton: + modifiers |= WebInputEvent::RightButtonDown; + break; + } + } + IntPoint p = view->contentsToWindow(IntPoint(event.pageX(), event.pageY())); + globalX = event.screenX(); + globalY = event.screenY(); + windowX = p.x(); + windowY = p.y(); + x = event.offsetX(); + y = event.offsetY(); + clickCount = event.detail(); +} + +WebKeyboardEventBuilder::WebKeyboardEventBuilder(const KeyboardEvent& event) +{ + if (event.type() == eventNames().keydownEvent) + type = KeyDown; + else if (event.type() == eventNames().keyupEvent) + type = WebInputEvent::KeyUp; + else if (event.type() == eventNames().keypressEvent) + type = WebInputEvent::Char; + else + return; // Skip all other keyboard events. + modifiers = getWebInputModifiers(event); + timeStampSeconds = event.timeStamp() * 1.0e-3; + windowsKeyCode = event.keyCode(); + nativeKeyCode = event.keyEvent()->nativeVirtualKeyCode(); + unsigned int numChars = std::min(event.keyEvent()->text().length(), + static_cast<unsigned int>(WebKeyboardEvent::textLengthCap)); + for (unsigned int i = 0; i < numChars; i++) { + text[i] = event.keyEvent()->text()[i]; + unmodifiedText[i] = event.keyEvent()->unmodifiedText()[i]; + } +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebInputEventConversion.h b/WebKit/chromium/src/WebInputEventConversion.h new file mode 100644 index 0000000..4c9cf82 --- /dev/null +++ b/WebKit/chromium/src/WebInputEventConversion.h @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebInputEventConversion_h +#define WebInputEventConversion_h + +// FIXME: This relative path is a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebInputEvent.h" + +#include "PlatformKeyboardEvent.h" +#include "PlatformMouseEvent.h" +#include "PlatformWheelEvent.h" + +namespace WebCore { +class KeyboardEvent; +class MouseEvent; +class ScrollView; +class Widget; +} + +namespace WebKit { + +class WebMouseEvent; +class WebMouseWheelEvent; +class WebKeyboardEvent; + +// These classes are used to convert from WebInputEvent subclasses to +// corresponding WebCore events. + +class PlatformMouseEventBuilder : public WebCore::PlatformMouseEvent { +public: + PlatformMouseEventBuilder(WebCore::Widget*, const WebMouseEvent&); +}; + +class PlatformWheelEventBuilder : public WebCore::PlatformWheelEvent { +public: + PlatformWheelEventBuilder(WebCore::Widget*, const WebMouseWheelEvent&); +}; + +class PlatformKeyboardEventBuilder : public WebCore::PlatformKeyboardEvent { +public: + PlatformKeyboardEventBuilder(const WebKeyboardEvent&); + void setKeyType(Type); + bool isCharacterKey() const; +}; + +// Converts a WebCore::MouseEvent to a corresponding WebMouseEvent. view is +// the ScrollView corresponding to the event. Returns true if successful. +// NOTE: This is only implemented for mousemove, mouseover, mouseout, +// mousedown and mouseup. If the event mapping fails, the event type will +// be set to Undefined. +class WebMouseEventBuilder : public WebMouseEvent { +public: + WebMouseEventBuilder(const WebCore::ScrollView*, const WebCore::MouseEvent&); +}; + +// Converts a WebCore::KeyboardEvent to a corresponding WebKeyboardEvent. +// Returns true if successful. NOTE: This is only implemented for keydown +// and keyup. If the event mapping fails, the event type will be set to +// Undefined. +class WebKeyboardEventBuilder : public WebKeyboardEvent { +public: + WebKeyboardEventBuilder(const WebCore::KeyboardEvent&); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebKit.cpp b/WebKit/chromium/src/WebKit.cpp new file mode 100644 index 0000000..a129f85 --- /dev/null +++ b/WebKit/chromium/src/WebKit.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebKit.h" + +#include "AtomicString.h" +#include "DOMTimer.h" +#include "Page.h" +#include "RuntimeEnabledFeatures.h" +#include "TextEncoding.h" +#include "WebMediaPlayerClientImpl.h" +#include "WebSocket.h" +#include "WorkerContextExecutionProxy.h" + +#include <wtf/Assertions.h> +#include <wtf/Threading.h> + +namespace WebKit { + +static WebKitClient* s_webKitClient = 0; +static bool s_layoutTestMode = false; + +void initialize(WebKitClient* webKitClient) +{ + ASSERT(webKitClient); + ASSERT(!s_webKitClient); + s_webKitClient = webKitClient; + + WTF::initializeThreading(); + WebCore::AtomicString::init(); + + // Chromium sets the minimum interval timeout to 4ms, overriding the + // default of 10ms. We'd like to go lower, however there are poorly + // coded websites out there which do create CPU-spinning loops. Using + // 4ms prevents the CPU from spinning too busily and provides a balance + // between CPU spinning and the smallest possible interval timer. + WebCore::DOMTimer::setMinTimerInterval(0.004); + + // There are some code paths (for example, running WebKit in the browser + // process and calling into LocalStorage before anything else) where the + // UTF8 string encoding tables are used on a background thread before + // they're set up. This is a problem because their set up routines assert + // they're running on the main WebKitThread. It might be possible to make + // the initialization thread-safe, but given that so many code paths use + // this, initializing this lazily probably doesn't buy us much. + WebCore::UTF8Encoding(); +} + +void shutdown() +{ + s_webKitClient = 0; +} + +WebKitClient* webKitClient() +{ + return s_webKitClient; +} + +void setLayoutTestMode(bool value) +{ + s_layoutTestMode = value; +} + +bool layoutTestMode() +{ + return s_layoutTestMode; +} + +void resetPluginCache(bool reloadPages) +{ + WebCore::Page::refreshPlugins(reloadPages); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp b/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp new file mode 100644 index 0000000..c2a3535 --- /dev/null +++ b/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp @@ -0,0 +1,397 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "config.h" +#include "WebMediaPlayerClientImpl.h" + +#if ENABLE(VIDEO) + +#include "CString.h" +#include "Frame.h" +#include "GraphicsContext.h" +#include "HTMLMediaElement.h" +#include "IntSize.h" +#include "KURL.h" +#include "MediaPlayer.h" +#include "NotImplemented.h" +#include "TimeRanges.h" + +#include "WebCanvas.h" +#include "WebCString.h" +#include "WebFrameClient.h" +#include "WebFrameImpl.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebMediaPlayer.h" +#include "WebMimeRegistry.h" +#include "WebRect.h" +#include "WebSize.h" +#include "WebString.h" +#include "WebURL.h" + +// WebCommon.h defines WEBKIT_USING_SKIA so this has to be included last. +#if WEBKIT_USING_SKIA +#include "PlatformContextSkia.h" +#endif + +#include <wtf/Assertions.h> + +using namespace WebCore; + +namespace WebKit { + +static WebMediaPlayer* createWebMediaPlayer( + WebMediaPlayerClient* client, Frame* frame) +{ + WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame); + if (!webFrame->client()) + return 0; + return webFrame->client()->createMediaPlayer(webFrame, client); +} + +bool WebMediaPlayerClientImpl::m_isEnabled = false; + +bool WebMediaPlayerClientImpl::isEnabled() +{ + return m_isEnabled; +} + +void WebMediaPlayerClientImpl::setIsEnabled(bool isEnabled) +{ + m_isEnabled = isEnabled; +} + +void WebMediaPlayerClientImpl::registerSelf(MediaEngineRegistrar registrar) +{ + if (m_isEnabled) { + registrar(WebMediaPlayerClientImpl::create, + WebMediaPlayerClientImpl::getSupportedTypes, + WebMediaPlayerClientImpl::supportsType); + } +} + +// WebMediaPlayerClient -------------------------------------------------------- + +void WebMediaPlayerClientImpl::networkStateChanged() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->networkStateChanged(); +} + +void WebMediaPlayerClientImpl::readyStateChanged() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->readyStateChanged(); +} + +void WebMediaPlayerClientImpl::volumeChanged() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->volumeChanged(); +} + +void WebMediaPlayerClientImpl::timeChanged() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->timeChanged(); +} + +void WebMediaPlayerClientImpl::repaint() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->repaint(); +} + +void WebMediaPlayerClientImpl::durationChanged() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->durationChanged(); +} + +void WebMediaPlayerClientImpl::rateChanged() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->rateChanged(); +} + +void WebMediaPlayerClientImpl::sizeChanged() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->sizeChanged(); +} + +void WebMediaPlayerClientImpl::sawUnsupportedTracks() +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->mediaPlayerClient()->mediaPlayerSawUnsupportedTracks(m_mediaPlayer); +} + +// MediaPlayerPrivateInterface ------------------------------------------------- + +void WebMediaPlayerClientImpl::load(const String& url) +{ + Frame* frame = static_cast<HTMLMediaElement*>( + m_mediaPlayer->mediaPlayerClient())->document()->frame(); + m_webMediaPlayer.set(createWebMediaPlayer(this, frame)); + if (m_webMediaPlayer.get()) + m_webMediaPlayer->load(KURL(ParsedURLString, url)); +} + +void WebMediaPlayerClientImpl::cancelLoad() +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->cancelLoad(); +} + +void WebMediaPlayerClientImpl::play() +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->play(); +} + +void WebMediaPlayerClientImpl::pause() +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->pause(); +} + +IntSize WebMediaPlayerClientImpl::naturalSize() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->naturalSize(); + return IntSize(); +} + +bool WebMediaPlayerClientImpl::hasVideo() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->hasVideo(); + return false; +} + +bool WebMediaPlayerClientImpl::hasAudio() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->hasAudio(); + return false; +} + +void WebMediaPlayerClientImpl::setVisible(bool visible) +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->setVisible(visible); +} + +float WebMediaPlayerClientImpl::duration() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->duration(); + return 0.0f; +} + +float WebMediaPlayerClientImpl::currentTime() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->currentTime(); + return 0.0f; +} + +void WebMediaPlayerClientImpl::seek(float time) +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->seek(time); +} + +bool WebMediaPlayerClientImpl::seeking() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->seeking(); + return false; +} + +void WebMediaPlayerClientImpl::setEndTime(float time) +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->setEndTime(time); +} + +void WebMediaPlayerClientImpl::setRate(float rate) +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->setRate(rate); +} + +bool WebMediaPlayerClientImpl::paused() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->paused(); + return false; +} + +bool WebMediaPlayerClientImpl::supportsFullscreen() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->supportsFullscreen(); + return false; +} + +bool WebMediaPlayerClientImpl::supportsSave() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->supportsSave(); + return false; +} + +void WebMediaPlayerClientImpl::setVolume(float volume) +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->setVolume(volume); +} + +MediaPlayer::NetworkState WebMediaPlayerClientImpl::networkState() const +{ + if (m_webMediaPlayer.get()) + return static_cast<MediaPlayer::NetworkState>(m_webMediaPlayer->networkState()); + return MediaPlayer::Empty; +} + +MediaPlayer::ReadyState WebMediaPlayerClientImpl::readyState() const +{ + if (m_webMediaPlayer.get()) + return static_cast<MediaPlayer::ReadyState>(m_webMediaPlayer->readyState()); + return MediaPlayer::HaveNothing; +} + +float WebMediaPlayerClientImpl::maxTimeSeekable() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->maxTimeSeekable(); + return 0.0f; +} + +PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::buffered() const +{ + if (m_webMediaPlayer.get()) { + const WebTimeRanges& webRanges = m_webMediaPlayer->buffered(); + + // FIXME: Save the time ranges in a member variable and update it when needed. + RefPtr<TimeRanges> ranges = TimeRanges::create(); + for (size_t i = 0; i < webRanges.size(); ++i) + ranges->add(webRanges[i].start, webRanges[i].end); + return ranges.release(); + } + return TimeRanges::create(); +} + +int WebMediaPlayerClientImpl::dataRate() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->dataRate(); + return 0; +} + +bool WebMediaPlayerClientImpl::totalBytesKnown() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->totalBytesKnown(); + return false; +} + +unsigned WebMediaPlayerClientImpl::totalBytes() const +{ + if (m_webMediaPlayer.get()) + return static_cast<unsigned>(m_webMediaPlayer->totalBytes()); + return 0; +} + +unsigned WebMediaPlayerClientImpl::bytesLoaded() const +{ + if (m_webMediaPlayer.get()) + return static_cast<unsigned>(m_webMediaPlayer->bytesLoaded()); + return 0; +} + +void WebMediaPlayerClientImpl::setSize(const IntSize& size) +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->setSize(WebSize(size.width(), size.height())); +} + +void WebMediaPlayerClientImpl::paint(GraphicsContext* context, const IntRect& rect) +{ + // Normally GraphicsContext operations do nothing when painting is disabled. + // Since we're accessing platformContext() directly we have to manually + // check. + if (m_webMediaPlayer.get() && !context->paintingDisabled()) { +#if WEBKIT_USING_SKIA + m_webMediaPlayer->paint(context->platformContext()->canvas(), rect); +#elif WEBKIT_USING_CG + m_webMediaPlayer->paint(context->platformContext(), rect); +#else + notImplemented(); +#endif + } +} + +void WebMediaPlayerClientImpl::setAutobuffer(bool autoBuffer) +{ + if (m_webMediaPlayer.get()) + m_webMediaPlayer->setAutoBuffer(autoBuffer); +} + +bool WebMediaPlayerClientImpl::hasSingleSecurityOrigin() const +{ + if (m_webMediaPlayer.get()) + return m_webMediaPlayer->hasSingleSecurityOrigin(); + return false; +} + +MediaPlayer::MovieLoadType WebMediaPlayerClientImpl::movieLoadType() const +{ + if (m_webMediaPlayer.get()) + return static_cast<MediaPlayer::MovieLoadType>( + m_webMediaPlayer->movieLoadType()); + return MediaPlayer::Unknown; +} + +MediaPlayerPrivateInterface* WebMediaPlayerClientImpl::create(MediaPlayer* player) +{ + WebMediaPlayerClientImpl* client = new WebMediaPlayerClientImpl(); + client->m_mediaPlayer = player; + return client; +} + +void WebMediaPlayerClientImpl::getSupportedTypes(HashSet<String>& supportedTypes) +{ + // FIXME: integrate this list with WebMediaPlayerClientImpl::supportsType. + notImplemented(); +} + +MediaPlayer::SupportsType WebMediaPlayerClientImpl::supportsType(const String& type, + const String& codecs) +{ + WebMimeRegistry::SupportsType supportsType = + webKitClient()->mimeRegistry()->supportsMediaMIMEType(type, codecs); + + switch (supportsType) { + default: + ASSERT_NOT_REACHED(); + case WebMimeRegistry::IsNotSupported: + return MediaPlayer::IsNotSupported; + case WebMimeRegistry::IsSupported: + return MediaPlayer::IsSupported; + case WebMimeRegistry::MayBeSupported: + return MediaPlayer::MayBeSupported; + } + return MediaPlayer::IsNotSupported; +} + +WebMediaPlayerClientImpl::WebMediaPlayerClientImpl() + : m_mediaPlayer(0) +{ +} + +} // namespace WebKit + +#endif // ENABLE(VIDEO) diff --git a/WebKit/chromium/src/WebMediaPlayerClientImpl.h b/WebKit/chromium/src/WebMediaPlayerClientImpl.h new file mode 100644 index 0000000..7f087d0 --- /dev/null +++ b/WebKit/chromium/src/WebMediaPlayerClientImpl.h @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebMediaPlayerClientImpl_h +#define WebMediaPlayerClientImpl_h + +#if ENABLE(VIDEO) + +#include "MediaPlayerPrivate.h" +#include "WebMediaPlayerClient.h" +#include <wtf/OwnPtr.h> + +namespace WebKit { + +class WebMediaPlayer; + +// This class serves as a bridge between WebCore::MediaPlayer and +// WebKit::WebMediaPlayer. +class WebMediaPlayerClientImpl : public WebMediaPlayerClient + , public WebCore::MediaPlayerPrivateInterface { +public: + static bool isEnabled(); + static void setIsEnabled(bool); + static void registerSelf(WebCore::MediaEngineRegistrar); + + // WebMediaPlayerClient methods: + virtual void networkStateChanged(); + virtual void readyStateChanged(); + virtual void volumeChanged(); + virtual void timeChanged(); + virtual void repaint(); + virtual void durationChanged(); + virtual void rateChanged(); + virtual void sizeChanged(); + virtual void sawUnsupportedTracks(); + + // MediaPlayerPrivateInterface methods: + virtual void load(const WebCore::String& url); + virtual void cancelLoad(); + virtual void play(); + virtual void pause(); + virtual bool supportsFullscreen() const; + virtual bool supportsSave() const; + virtual WebCore::IntSize naturalSize() const; + virtual bool hasVideo() const; + virtual bool hasAudio() const; + virtual void setVisible(bool); + virtual float duration() const; + virtual float currentTime() const; + virtual void seek(float time); + virtual bool seeking() const; + virtual void setEndTime(float time); + virtual void setRate(float); + virtual bool paused() const; + virtual void setVolume(float); + virtual WebCore::MediaPlayer::NetworkState networkState() const; + virtual WebCore::MediaPlayer::ReadyState readyState() const; + virtual float maxTimeSeekable() const; + virtual WTF::PassRefPtr<WebCore::TimeRanges> buffered() const; + virtual int dataRate() const; + virtual void setAutobuffer(bool); + virtual bool totalBytesKnown() const; + virtual unsigned totalBytes() const; + virtual unsigned bytesLoaded() const; + virtual void setSize(const WebCore::IntSize&); + virtual void paint(WebCore::GraphicsContext*, const WebCore::IntRect&); + virtual bool hasSingleSecurityOrigin() const; + virtual WebCore::MediaPlayer::MovieLoadType movieLoadType() const; + +private: + WebMediaPlayerClientImpl(); + + static WebCore::MediaPlayerPrivateInterface* create(WebCore::MediaPlayer*); + static void getSupportedTypes(WTF::HashSet<WebCore::String>&); + static WebCore::MediaPlayer::SupportsType supportsType( + const WebCore::String& type, const WebCore::String& codecs); + + WebCore::MediaPlayer* m_mediaPlayer; + OwnPtr<WebMediaPlayer> m_webMediaPlayer; + static bool m_isEnabled; +}; + +} // namespace WebKit + +#endif + +#endif diff --git a/WebKit/chromium/src/WebNode.cpp b/WebKit/chromium/src/WebNode.cpp new file mode 100644 index 0000000..965c412 --- /dev/null +++ b/WebKit/chromium/src/WebNode.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebNode.h" + +#include "Document.h" +#include "Frame.h" +#include "FrameLoaderClientImpl.h" +#include "Node.h" + +#include "WebFrameImpl.h" +#include "WebString.h" + +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +class WebNodePrivate : public Node { +}; + +void WebNode::reset() +{ + assign(0); +} + +void WebNode::assign(const WebNode& other) +{ + WebNodePrivate* p = const_cast<WebNodePrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +WebNode WebNode::parentNode() const +{ + return PassRefPtr<Node>(const_cast<Node*>(m_private->parentNode())); +} + +WebString WebNode::nodeName() const +{ + return m_private->nodeName(); +} + +WebNode::WebNode(const WTF::PassRefPtr<WebCore::Node>& node) + : m_private(static_cast<WebNodePrivate*>(node.releaseRef())) +{ +} + +WebNode& WebNode::operator=(const WTF::PassRefPtr<WebCore::Node>& node) +{ + assign(static_cast<WebNodePrivate*>(node.releaseRef())); + return *this; +} + +WebNode::operator WTF::PassRefPtr<WebCore::Node>() const +{ + return PassRefPtr<Node>(const_cast<WebNodePrivate*>(m_private)); +} + +void WebNode::assign(WebNodePrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +WebFrame* WebNode::frame() const +{ + return WebFrameImpl::fromFrame(m_private->document()->frame()); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebNotification.cpp b/WebKit/chromium/src/WebNotification.cpp new file mode 100644 index 0000000..1f6916e --- /dev/null +++ b/WebKit/chromium/src/WebNotification.cpp @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebNotification.h" + +#if ENABLE(NOTIFICATIONS) + +#include "Notification.h" + +#include "WebString.h" +#include "WebURL.h" + +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +class WebNotificationPrivate : public Notification { +}; + +void WebNotification::reset() +{ + assign(0); +} + +void WebNotification::assign(const WebNotification& other) +{ + WebNotificationPrivate* p = const_cast<WebNotificationPrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +bool WebNotification::lessThan(const WebNotification& other) const +{ + return reinterpret_cast<uintptr_t>(m_private) < reinterpret_cast<uintptr_t>(other.m_private); +} + +bool WebNotification::isHTML() const +{ + return m_private->isHTML(); +} + +WebURL WebNotification::url() const +{ + ASSERT(isHTML()); + return m_private->url(); +} + +WebString WebNotification::icon() const +{ + ASSERT(!isHTML()); + return m_private->contents().icon(); +} + +WebString WebNotification::title() const +{ + ASSERT(!isHTML()); + return m_private->contents().title(); +} + +WebString WebNotification::body() const +{ + ASSERT(!isHTML()); + return m_private->contents().body(); +} + +void WebNotification::dispatchDisplayEvent() +{ + RefPtr<Event> event = Event::create("display", false, true); + m_private->dispatchEvent(event.release()); +} + +void WebNotification::dispatchErrorEvent(const WebKit::WebString& /* errorMessage */) +{ + // FIXME: errorMessage not supported by WebCore yet + RefPtr<Event> event = Event::create(eventNames().errorEvent, false, true); + m_private->dispatchEvent(event.release()); +} + +void WebNotification::dispatchCloseEvent(bool /* byUser */) +{ + // FIXME: byUser flag not supported by WebCore yet + RefPtr<Event> event = Event::create(eventNames().closeEvent, false, true); + m_private->dispatchEvent(event.release()); +} + +WebNotification::WebNotification(const WTF::PassRefPtr<Notification>& notification) + : m_private(static_cast<WebNotificationPrivate*>(notification.releaseRef())) +{ +} + +WebNotification& WebNotification::operator=(const WTF::PassRefPtr<Notification>& notification) +{ + assign(static_cast<WebNotificationPrivate*>(notification.releaseRef())); + return *this; +} + +WebNotification::operator WTF::PassRefPtr<Notification>() const +{ + return WTF::PassRefPtr<Notification>(const_cast<WebNotificationPrivate*>(m_private)); +} + +void WebNotification::assign(WebNotificationPrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +} // namespace WebKit + +#endif // ENABLE(NOTIFICATIONS) diff --git a/WebKit/chromium/src/WebPasswordFormData.cpp b/WebKit/chromium/src/WebPasswordFormData.cpp new file mode 100644 index 0000000..64b1754 --- /dev/null +++ b/WebKit/chromium/src/WebPasswordFormData.cpp @@ -0,0 +1,180 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebPasswordFormData.h" + +#include "Document.h" +#include "DocumentLoader.h" +#include "Frame.h" +#include "FrameLoader.h" +#include "HTMLFormElement.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "KURL.h" + +#include "DOMUtilitiesPrivate.h" +#include "WebPasswordFormUtils.h" + +using namespace WebCore; + +namespace WebKit { + +namespace { + +// Helper to determine which password is the main one, and which is +// an old password (e.g on a "make new password" form), if any. +bool locateSpecificPasswords(PasswordFormFields* fields, + HTMLInputElement** password, + HTMLInputElement** oldPassword) +{ + ASSERT(fields); + ASSERT(password); + ASSERT(oldPassword); + switch (fields->passwords.size()) { + case 1: + // Single password, easy. + *password = fields->passwords[0]; + break; + case 2: + if (fields->passwords[0]->value() == fields->passwords[1]->value()) + // Treat two identical passwords as a single password. + *password = fields->passwords[0]; + else { + // Assume first is old password, second is new (no choice but to guess). + *oldPassword = fields->passwords[0]; + *password = fields->passwords[1]; + } + break; + case 3: + if (fields->passwords[0]->value() == fields->passwords[1]->value() + && fields->passwords[0]->value() == fields->passwords[2]->value()) { + // All three passwords the same? Just treat as one and hope. + *password = fields->passwords[0]; + } else if (fields->passwords[0]->value() == fields->passwords[1]->value()) { + // Two the same and one different -> old password is duplicated one. + *oldPassword = fields->passwords[0]; + *password = fields->passwords[2]; + } else if (fields->passwords[1]->value() == fields->passwords[2]->value()) { + *oldPassword = fields->passwords[0]; + *password = fields->passwords[1]; + } else { + // Three different passwords, or first and last match with middle + // different. No idea which is which, so no luck. + return false; + } + break; + default: + return false; + } + return true; +} + +// Helped method to clear url of unneeded parts. +KURL stripURL(const KURL& url) +{ + KURL strippedURL = url; + strippedURL.setUser(String()); + strippedURL.setPass(String()); + strippedURL.setQuery(String()); + strippedURL.setFragmentIdentifier(String()); + return strippedURL; +} + +// Helper to gather up the final form data and create a PasswordForm. +void assemblePasswordFormResult(const KURL& fullOrigin, + const KURL& fullAction, + HTMLFormControlElement* submit, + HTMLInputElement* userName, + HTMLInputElement* oldPassword, + HTMLInputElement* password, + WebPasswordFormData* result) +{ + // We want to keep the path but strip any authentication data, as well as + // query and ref portions of URL, for the form action and form origin. + result->action = stripURL(fullAction); + result->origin = stripURL(fullOrigin); + + // Naming is confusing here because we have both the HTML form origin URL + // the page where the form was seen), and the "origin" components of the url + // (scheme, host, and port). + KURL signonRealmURL = stripURL(fullOrigin); + signonRealmURL.setPath(""); + result->signonRealm = signonRealmURL; + + if (submit) + result->submitElement = submit->name(); + if (userName) { + result->userNameElement = userName->name(); + result->userNameValue = userName->value(); + } + if (password) { + result->passwordElement = password->name(); + result->passwordValue = password->value(); + } + if (oldPassword) { + result->oldPasswordElement = oldPassword->name(); + result->oldPasswordValue = oldPassword->value(); + } +} + +} // namespace + +WebPasswordFormData::WebPasswordFormData(const WebFormElement& webForm) +{ + RefPtr<HTMLFormElement> form = webForm.operator PassRefPtr<HTMLFormElement>(); + + Frame* frame = form->document()->frame(); + if (!frame) + return; + + PasswordFormFields fields; + findPasswordFormFields(form.get(), &fields); + + // Get the document URL + KURL fullOrigin(ParsedURLString, form->document()->documentURI()); + + // Calculate the canonical action URL + KURL fullAction = frame->loader()->completeURL(form->action()); + if (!fullAction.isValid()) + return; + + // Determine the types of the password fields + HTMLInputElement* password = 0; + HTMLInputElement* oldPassword = 0; + if (!locateSpecificPasswords(&fields, &password, &oldPassword)) + return; + + assemblePasswordFormResult(fullOrigin, fullAction, + fields.submit, fields.userName, + oldPassword, password, this); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebPasswordFormUtils.cpp b/WebKit/chromium/src/WebPasswordFormUtils.cpp new file mode 100644 index 0000000..766dc63 --- /dev/null +++ b/WebKit/chromium/src/WebPasswordFormUtils.cpp @@ -0,0 +1,110 @@ +/* ***** BEGIN LICENSE BLOCK ***** +* Version: MPL 1.1/GPL 2.0/LGPL 2.1 +* +* The contents of this file are subject to the Mozilla Public License Version +* 1.1 (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* http://www.mozilla.org/MPL/ +* +* Software distributed under the License is distributed on an "AS IS" basis, +* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +* for the specific language governing rights and limitations under the +* License. +* +* The Original Code is Mozilla Password Manager. +* +* The Initial Developer of the Original Code is +* Brian Ryner. +* Portions created by the Initial Developer are Copyright (C) 2003 +* the Initial Developer. All Rights Reserved. +* +* Contributor(s): +* Brian Ryner <bryner@brianryner.com> +* +* Alternatively, the contents of this file may be used under the terms of +* either the GNU General Public License Version 2 or later (the "GPL"), or +* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +* in which case the provisions of the GPL or the LGPL are applicable instead +* of those above. If you wish to allow use of your version of this file only +* under the terms of either the GPL or the LGPL, and not to allow others to +* use your version of this file under the terms of the MPL, indicate your +* decision by deleting the provisions above and replace them with the notice +* and other provisions required by the GPL or the LGPL. If you do not delete +* the provisions above, a recipient may use your version of this file under +* the terms of any one of the MPL, the GPL or the LGPL. +* +* ***** END LICENSE BLOCK ***** */ + +// Helper to WebPasswordFormData to do the locating of username/password +// fields. +// This method based on Firefox2 code in +// toolkit/components/passwordmgr/base/nsPasswordManager.cpp + +#include "config.h" +#include "WebPasswordFormUtils.h" + +#include "HTMLFormElement.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "KURL.h" + +#include "DOMUtilitiesPrivate.h" + +using namespace WebCore; + +namespace WebKit { + +// Maximum number of password fields we will observe before throwing our +// hands in the air and giving up with a given form. +static const size_t maxPasswords = 3; + +void findPasswordFormFields(HTMLFormElement* form, PasswordFormFields* fields) +{ + ASSERT(form); + ASSERT(fields); + + int firstPasswordIndex = 0; + // First, find the password fields and activated submit button + const Vector<HTMLFormControlElement*>& formElements = form->formElements; + for (size_t i = 0; i < formElements.size(); i++) { + HTMLFormControlElement* formElement = formElements[i]; + if (formElement->isActivatedSubmit()) + fields->submit = formElement; + + if (!formElement->hasLocalName(HTMLNames::inputTag)) + continue; + + HTMLInputElement* inputElement = toHTMLInputElement(formElement); + if (!inputElement->isEnabledFormControl()) + continue; + + if ((fields->passwords.size() < maxPasswords) + && (inputElement->inputType() == HTMLInputElement::PASSWORD) + && (inputElement->autoComplete())) { + if (fields->passwords.isEmpty()) + firstPasswordIndex = i; + fields->passwords.append(inputElement); + } + } + + if (!fields->passwords.isEmpty()) { + // Then, search backwards for the username field + for (int i = firstPasswordIndex - 1; i >= 0; i--) { + HTMLFormControlElement* formElement = formElements[i]; + if (!formElement->hasLocalName(HTMLNames::inputTag)) + continue; + + HTMLInputElement* inputElement = toHTMLInputElement(formElement); + if (!inputElement->isEnabledFormControl()) + continue; + + if ((inputElement->inputType() == HTMLInputElement::TEXT) + && (inputElement->autoComplete())) { + fields->userName = inputElement; + break; + } + } + } +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebPasswordFormUtils.h b/WebKit/chromium/src/WebPasswordFormUtils.h new file mode 100644 index 0000000..fd503b4 --- /dev/null +++ b/WebKit/chromium/src/WebPasswordFormUtils.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPasswordFormUtils_h +#define WebPasswordFormUtils_h + +#include <wtf/Vector.h> + +namespace WebCore { +class HTMLInputElement; +class HTMLFormControlElement; +class HTMLFormElement; +} + +namespace WebKit { + +// Helper structure to locate username, passwords and submit fields. +struct PasswordFormFields { + WebCore::HTMLInputElement* userName; + Vector<WebCore::HTMLInputElement*> passwords; + WebCore::HTMLFormControlElement* submit; + PasswordFormFields() : userName(0), submit(0) { } +}; + +void findPasswordFormFields(WebCore::HTMLFormElement* form, + PasswordFormFields* fields); + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebPluginContainerImpl.cpp b/WebKit/chromium/src/WebPluginContainerImpl.cpp new file mode 100644 index 0000000..43f3cef --- /dev/null +++ b/WebKit/chromium/src/WebPluginContainerImpl.cpp @@ -0,0 +1,556 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebPluginContainerImpl.h" + +#include "ChromeClientImpl.h" +#include "WebCursorInfo.h" +#include "WebDataSourceImpl.h" +#include "WebInputEvent.h" +#include "WebInputEventConversion.h" +#include "WebKit.h" +#include "WebPlugin.h" +#include "WebRect.h" +#include "WebURLError.h" +#include "WebURLRequest.h" +#include "WebVector.h" +#include "WrappedResourceResponse.h" + +#include "EventNames.h" +#include "FocusController.h" +#include "FormState.h" +#include "Frame.h" +#include "FrameLoadRequest.h" +#include "FrameView.h" +#include "GraphicsContext.h" +#include "HostWindow.h" +#include "HTMLFormElement.h" +#include "HTMLNames.h" +#include "HTMLPlugInElement.h" +#include "KeyboardEvent.h" +#include "MouseEvent.h" +#include "Page.h" +#include "ScrollView.h" + +#if WEBKIT_USING_SKIA +#include "PlatformContextSkia.h" +#endif + +using namespace WebCore; + +namespace WebKit { + +// Public methods -------------------------------------------------------------- + +void WebPluginContainerImpl::setFrameRect(const IntRect& frameRect) +{ + Widget::setFrameRect(frameRect); + reportGeometry(); +} + +void WebPluginContainerImpl::paint(GraphicsContext* gc, const IntRect& damageRect) +{ + if (gc->paintingDisabled()) + return; + + if (!parent()) + return; + + // Don't paint anything if the plugin doesn't intersect the damage rect. + if (!frameRect().intersects(damageRect)) + return; + + gc->save(); + + ASSERT(parent()->isFrameView()); + ScrollView* view = parent(); + + // The plugin is positioned in window coordinates, so it needs to be painted + // in window coordinates. + IntPoint origin = view->windowToContents(IntPoint(0, 0)); + gc->translate(static_cast<float>(origin.x()), static_cast<float>(origin.y())); + +#if WEBKIT_USING_SKIA + WebCanvas* canvas = gc->platformContext()->canvas(); +#elif WEBKIT_USING_CG + WebCanvas* canvas = gc->platformContext(); +#endif + + IntRect windowRect = + IntRect(view->contentsToWindow(damageRect.location()), damageRect.size()); + m_webPlugin->paint(canvas, windowRect); + + gc->restore(); +} + +void WebPluginContainerImpl::invalidateRect(const IntRect& rect) +{ + if (!parent()) + return; + + IntRect damageRect = convertToContainingWindow(rect); + + // Get our clip rect and intersect with it to ensure we don't invalidate + // too much. + IntRect clipRect = parent()->windowClipRect(); + damageRect.intersect(clipRect); + + parent()->hostWindow()->repaint(damageRect, true); +} + +void WebPluginContainerImpl::setFocus() +{ + Widget::setFocus(); + m_webPlugin->updateFocus(true); +} + +void WebPluginContainerImpl::show() +{ + setSelfVisible(true); + m_webPlugin->updateVisibility(true); + + Widget::show(); +} + +void WebPluginContainerImpl::hide() +{ + setSelfVisible(false); + m_webPlugin->updateVisibility(false); + + Widget::hide(); +} + +void WebPluginContainerImpl::handleEvent(Event* event) +{ + if (!m_webPlugin->acceptsInputEvents()) + return; + + // The events we pass are defined at: + // http://devedge-temp.mozilla.org/library/manuals/2002/plugin/1.0/structures5.html#1000000 + // Don't take the documentation as truth, however. There are many cases + // where mozilla behaves differently than the spec. + if (event->isMouseEvent()) + handleMouseEvent(static_cast<MouseEvent*>(event)); + else if (event->isKeyboardEvent()) + handleKeyboardEvent(static_cast<KeyboardEvent*>(event)); +} + +void WebPluginContainerImpl::frameRectsChanged() +{ + Widget::frameRectsChanged(); + reportGeometry(); +} + +void WebPluginContainerImpl::setParentVisible(bool parentVisible) +{ + // We override this function to make sure that geometry updates are sent + // over to the plugin. For e.g. when a plugin is instantiated it does not + // have a valid parent. As a result the first geometry update from webkit + // is ignored. This function is called when the plugin eventually gets a + // parent. + + if (isParentVisible() == parentVisible) + return; // No change. + + Widget::setParentVisible(parentVisible); + if (!isSelfVisible()) + return; // This widget has explicitely been marked as not visible. + + m_webPlugin->updateVisibility(isVisible()); +} + +void WebPluginContainerImpl::setParent(ScrollView* view) +{ + // We override this function so that if the plugin is windowed, we can call + // NPP_SetWindow at the first possible moment. This ensures that + // NPP_SetWindow is called before the manual load data is sent to a plugin. + // If this order is reversed, Flash won't load videos. + + Widget::setParent(view); + if (view) + reportGeometry(); +} + +void WebPluginContainerImpl::invalidate() +{ + Widget::invalidate(); +} + +void WebPluginContainerImpl::invalidateRect(const WebRect& rect) +{ + invalidateRect(static_cast<IntRect>(rect)); +} + +void WebPluginContainerImpl::reportGeometry() +{ + if (!parent()) + return; + + IntRect windowRect, clipRect; + Vector<IntRect> cutOutRects; + calculateGeometry(frameRect(), windowRect, clipRect, cutOutRects); + + m_webPlugin->updateGeometry(windowRect, clipRect, cutOutRects, isVisible()); +} + +void WebPluginContainerImpl::clearScriptObjects() +{ + Frame* frame = m_element->document()->frame(); + if (!frame) + return; + frame->script()->cleanupScriptObjectsForPlugin(this); +} + +NPObject* WebPluginContainerImpl::scriptableObjectForElement() +{ + return m_element->getNPObject(); +} + +WebString WebPluginContainerImpl::executeScriptURL(const WebURL& url, bool popupsAllowed) +{ + Frame* frame = m_element->document()->frame(); + if (!frame) + return WebString(); + + const KURL& kurl = url; + ASSERT(kurl.protocolIs("javascript")); + + String script = decodeURLEscapeSequences( + kurl.string().substring(strlen("javascript:"))); + + ScriptValue result = frame->script()->executeScript(script, popupsAllowed); + + // Failure is reported as a null string. + String resultStr; + result.getString(resultStr); + return resultStr; +} + +void WebPluginContainerImpl::loadFrameRequest( + const WebURLRequest& request, const WebString& target, bool notifyNeeded, void* notifyData) +{ + Frame* frame = m_element->document()->frame(); + if (!frame) + return; // FIXME: send a notification in this case? + + if (notifyNeeded) { + // FIXME: This is a bit of hack to allow us to observe completion of + // our frame request. It would be better to evolve FrameLoader to + // support a completion callback instead. + WebPluginLoadObserver* observer = + new WebPluginLoadObserver(this, request.url(), notifyData); + m_pluginLoadObservers.append(observer); + WebDataSourceImpl::setNextPluginLoadObserver(observer); + } + + FrameLoadRequest frameRequest(request.toResourceRequest()); + frameRequest.setFrameName(target); + + frame->loader()->loadFrameRequest( + frameRequest, + false, // lock history + false, // lock back forward list + 0, // event + 0, // form state + SendReferrer); +} + +void WebPluginContainerImpl::didReceiveResponse(const ResourceResponse& response) +{ + // Make sure that the plugin receives window geometry before data, or else + // plugins misbehave. + frameRectsChanged(); + + WrappedResourceResponse urlResponse(response); + m_webPlugin->didReceiveResponse(urlResponse); +} + +void WebPluginContainerImpl::didReceiveData(const char *data, int dataLength) +{ + m_webPlugin->didReceiveData(data, dataLength); +} + +void WebPluginContainerImpl::didFinishLoading() +{ + m_webPlugin->didFinishLoading(); +} + +void WebPluginContainerImpl::didFailLoading(const ResourceError& error) +{ + m_webPlugin->didFailLoading(error); +} + +NPObject* WebPluginContainerImpl::scriptableObject() +{ + return m_webPlugin->scriptableObject(); +} + +void WebPluginContainerImpl::willDestroyPluginLoadObserver(WebPluginLoadObserver* observer) +{ + size_t pos = m_pluginLoadObservers.find(observer); + if (pos == notFound) + return; + m_pluginLoadObservers.remove(pos); +} + +// Private methods ------------------------------------------------------------- + +WebPluginContainerImpl::~WebPluginContainerImpl() +{ + for (size_t i = 0; i < m_pluginLoadObservers.size(); ++i) + m_pluginLoadObservers[i]->clearPluginContainer(); + m_webPlugin->destroy(); +} + +void WebPluginContainerImpl::handleMouseEvent(MouseEvent* event) +{ + ASSERT(parent()->isFrameView()); + + // We cache the parent FrameView here as the plugin widget could be deleted + // in the call to HandleEvent. See http://b/issue?id=1362948 + FrameView* parentView = static_cast<FrameView*>(parent()); + + WebMouseEventBuilder webEvent(parentView, *event); + if (webEvent.type == WebInputEvent::Undefined) + return; + + if (event->type() == eventNames().mousedownEvent) { + // Ensure that the frame containing the plugin has focus. + Frame* containingFrame = parentView->frame(); + if (Page* currentPage = containingFrame->page()) + currentPage->focusController()->setFocusedFrame(containingFrame); + // Give focus to our containing HTMLPluginElement. + containingFrame->document()->setFocusedNode(m_element); + } + + WebCursorInfo cursorInfo; + bool handled = m_webPlugin->handleInputEvent(webEvent, cursorInfo); +#if !PLATFORM(DARWIN) + // TODO(pkasting): http://b/1119691 This conditional seems exactly + // backwards, but if I reverse it, giving focus to a transparent + // (windowless) plugin fails. + handled = !handled; + // TODO(awalker): oddly, the above is not true in Mac builds. Looking + // at Apple's corresponding code for Mac and Windows (PluginViewMac and + // PluginViewWin), setDefaultHandled() gets called when handleInputEvent() + // returns true, which then indicates to WebCore that the plugin wants to + // swallow the event--which is what we want. Calling setDefaultHandled() + // fixes several Mac Chromium bugs, but does indeed prevent windowless plugins + // from getting focus in Windows builds, as pkasting notes above. So for + // now, we only do so in Mac builds. +#endif + if (handled) + event->setDefaultHandled(); + + // A windowless plugin can change the cursor in response to a mouse move + // event. We need to reflect the changed cursor in the frame view as the + // mouse is moved in the boundaries of the windowless plugin. + Page* page = parentView->frame()->page(); + if (!page) + return; + ChromeClientImpl* chromeClient = + static_cast<ChromeClientImpl*>(page->chrome()->client()); + chromeClient->setCursorForPlugin(cursorInfo); +} + +void WebPluginContainerImpl::handleKeyboardEvent(KeyboardEvent* event) +{ + WebKeyboardEventBuilder webEvent(*event); + if (webEvent.type == WebInputEvent::Undefined) + return; + + WebCursorInfo cursor_info; + bool handled = m_webPlugin->handleInputEvent(webEvent, cursor_info); +#if !PLATFORM(DARWIN) + // TODO(pkasting): http://b/1119691 See above. + handled = !handled; +#endif + if (handled) + event->setDefaultHandled(); +} + +void WebPluginContainerImpl::calculateGeometry(const IntRect& frameRect, + IntRect& windowRect, + IntRect& clipRect, + Vector<IntRect>& cutOutRects) +{ + windowRect = IntRect( + parent()->contentsToWindow(frameRect.location()), frameRect.size()); + + // Calculate a clip-rect so that we don't overlap the scrollbars, etc. + clipRect = windowClipRect(); + clipRect.move(-windowRect.x(), -windowRect.y()); + + windowCutOutRects(frameRect, cutOutRects); + // Convert to the plugin position. + for (size_t i = 0; i < cutOutRects.size(); i++) + cutOutRects[i].move(-frameRect.x(), -frameRect.y()); +} + +WebCore::IntRect WebPluginContainerImpl::windowClipRect() const +{ + // Start by clipping to our bounds. + IntRect clipRect = + convertToContainingWindow(IntRect(0, 0, width(), height())); + + // document()->renderer() can be 0 when we receive messages from the + // plugins while we are destroying a frame. + if (m_element->renderer()->document()->renderer()) { + // Take our element and get the clip rect from the enclosing layer and + // frame view. + RenderLayer* layer = m_element->renderer()->enclosingLayer(); + clipRect.intersect( + m_element->document()->view()->windowClipRectForLayer(layer, true)); + } + + return clipRect; +} + +static void getObjectStack(const RenderObject* ro, + Vector<const RenderObject*>* roStack) +{ + roStack->clear(); + while (ro) { + roStack->append(ro); + ro = ro->parent(); + } +} + +// Returns true if stack1 is at or above stack2 +static bool checkStackOnTop( + const Vector<const RenderObject*>& iframeZstack, + const Vector<const RenderObject*>& pluginZstack) +{ + for (size_t i1 = 0, i2 = 0; + i1 < iframeZstack.size() && i2 < pluginZstack.size(); + i1++, i2++) { + // The root is at the end of these stacks. We want to iterate + // root-downwards so we index backwards from the end. + const RenderObject* ro1 = iframeZstack[iframeZstack.size() - 1 - i1]; + const RenderObject* ro2 = pluginZstack[pluginZstack.size() - 1 - i2]; + + if (ro1 != ro2) { + // When we find nodes in the stack that are not the same, then + // we've found the nodes just below the lowest comment ancestor. + // Determine which should be on top. + + // See if z-index determines an order. + if (ro1->style() && ro2->style()) { + int z1 = ro1->style()->zIndex(); + int z2 = ro2->style()->zIndex(); + if (z1 > z2) + return true; + if (z1 < z2) + return false; + } + + // For compatibility with IE: when the plugin is not positioned, + // it stacks behind the iframe, even if it's later in the + // document order. + if (ro2->style()->position() == StaticPosition) + return true; + + // Inspect the document order. Later order means higher + // stacking. + const RenderObject* parent = ro1->parent(); + if (!parent) + return false; + ASSERT(parent == ro2->parent()); + + for (const RenderObject* ro = parent->firstChild(); ro; ro = ro->nextSibling()) { + if (ro == ro1) + return false; + if (ro == ro2) + return true; + } + ASSERT(false); // We should have seen ro1 and ro2 by now. + return false; + } + } + return true; +} + +// Return a set of rectangles that should not be overdrawn by the +// plugin ("cutouts"). This helps implement the "iframe shim" +// technique of overlaying a windowed plugin with content from the +// page. In a nutshell, iframe elements should occlude plugins when +// they occur higher in the stacking order. +void WebPluginContainerImpl::windowCutOutRects(const IntRect& frameRect, + Vector<IntRect>& cutOutRects) +{ + RenderObject* pluginNode = m_element->renderer(); + ASSERT(pluginNode); + if (!pluginNode->style()) + return; + Vector<const RenderObject*> pluginZstack; + Vector<const RenderObject*> iframeZstack; + getObjectStack(pluginNode, &pluginZstack); + + // Get the parent widget + Widget* parentWidget = this->parent(); + if (!parentWidget->isFrameView()) + return; + + FrameView* parentFrameView = static_cast<FrameView*>(parentWidget); + + const HashSet<RefPtr<Widget> >* children = parentFrameView->children(); + for (HashSet<RefPtr<Widget> >::const_iterator it = children->begin(); it != children->end(); ++it) { + // We only care about FrameView's because iframes show up as FrameViews. + if (!(*it)->isFrameView()) + continue; + + const FrameView* frameView = + static_cast<const FrameView*>((*it).get()); + // Check to make sure we can get both the element and the RenderObject + // for this FrameView, if we can't just move on to the next object. + if (!frameView->frame() || !frameView->frame()->ownerElement() + || !frameView->frame()->ownerElement()->renderer()) + continue; + + HTMLElement* element = frameView->frame()->ownerElement(); + RenderObject* iframeRenderer = element->renderer(); + + if (element->hasTagName(HTMLNames::iframeTag) + && iframeRenderer->absoluteBoundingBoxRect().intersects(frameRect) + && (!iframeRenderer->style() || iframeRenderer->style()->visibility() == VISIBLE)) { + getObjectStack(iframeRenderer, &iframeZstack); + if (checkStackOnTop(iframeZstack, pluginZstack)) { + IntPoint point = + roundedIntPoint(iframeRenderer->localToAbsolute()); + RenderBox* rbox = toRenderBox(iframeRenderer); + IntSize size(rbox->width(), rbox->height()); + cutOutRects.append(IntRect(point, size)); + } + } + } +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebPluginContainerImpl.h b/WebKit/chromium/src/WebPluginContainerImpl.h new file mode 100644 index 0000000..00450bb --- /dev/null +++ b/WebKit/chromium/src/WebPluginContainerImpl.h @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPluginContainerImpl_h +#define WebPluginContainerImpl_h + +// FIXME: This relative path is a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebPluginContainer.h" + +#include "Widget.h" +#include <wtf/PassRefPtr.h> +#include <wtf/Vector.h> + +struct NPObject; + +namespace WebCore { +class HTMLPlugInElement; +class IntRect; +class KeyboardEvent; +class MouseEvent; +class ResourceError; +class ResourceResponse; +} + +namespace WebKit { + +class WebPlugin; +class WebPluginLoadObserver; + +class WebPluginContainerImpl : public WebCore::Widget, public WebPluginContainer { +public: + static PassRefPtr<WebPluginContainerImpl> create(WebCore::HTMLPlugInElement* element, WebPlugin* webPlugin) + { + return adoptRef(new WebPluginContainerImpl(element, webPlugin)); + } + + // Widget methods + virtual void setFrameRect(const WebCore::IntRect&); + virtual void paint(WebCore::GraphicsContext*, const WebCore::IntRect&); + virtual void invalidateRect(const WebCore::IntRect&); + virtual void setFocus(); + virtual void show(); + virtual void hide(); + virtual void handleEvent(WebCore::Event*); + virtual void frameRectsChanged(); + virtual void setParentVisible(bool); + virtual void setParent(WebCore::ScrollView*); + + // WebPluginContainer methods + virtual void invalidate(); + virtual void invalidateRect(const WebRect&); + virtual void reportGeometry(); + virtual void clearScriptObjects(); + virtual NPObject* scriptableObjectForElement(); + virtual WebString executeScriptURL(const WebURL&, bool popupsAllowed); + virtual void loadFrameRequest(const WebURLRequest&, const WebString& target, bool notifyNeeded, void* notifyData); + + // Resource load events for the plugin's source data: + void didReceiveResponse(const WebCore::ResourceResponse&); + void didReceiveData(const char *data, int dataLength); + void didFinishLoading(); + void didFailLoading(const WebCore::ResourceError&); + + NPObject* scriptableObject(); + + // This cannot be null. + WebPlugin* plugin() { return m_webPlugin; } + + void willDestroyPluginLoadObserver(WebPluginLoadObserver*); + +private: + WebPluginContainerImpl(WebCore::HTMLPlugInElement* element, WebPlugin* webPlugin) + : m_element(element) + , m_webPlugin(webPlugin) { } + ~WebPluginContainerImpl(); + + void handleMouseEvent(WebCore::MouseEvent*); + void handleKeyboardEvent(WebCore::KeyboardEvent*); + + void calculateGeometry(const WebCore::IntRect& frameRect, + WebCore::IntRect& windowRect, + WebCore::IntRect& clipRect, + Vector<WebCore::IntRect>& cutOutRects); + WebCore::IntRect windowClipRect() const; + void windowCutOutRects(const WebCore::IntRect& frameRect, + Vector<WebCore::IntRect>& cutOutRects); + + WebCore::HTMLPlugInElement* m_element; + WebPlugin* m_webPlugin; + Vector<WebPluginLoadObserver*> m_pluginLoadObservers; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebPluginListBuilderImpl.cpp b/WebKit/chromium/src/WebPluginListBuilderImpl.cpp new file mode 100644 index 0000000..6926a2d --- /dev/null +++ b/WebKit/chromium/src/WebPluginListBuilderImpl.cpp @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebPluginListBuilderImpl.h" + +#include "PluginData.h" +#include "WebString.h" +#include <wtf/Vector.h> + +using namespace WebCore; + +namespace WebKit { + +void WebPluginListBuilderImpl::addPlugin(const WebString& name, const WebString& description, const WebString& fileName) +{ + PluginInfo* info = new PluginInfo(); + info->name = name; + info->desc = description; + info->file = fileName; + m_results->append(info); +} + +void WebPluginListBuilderImpl::addMediaTypeToLastPlugin(const WebString& name, const WebString& description) +{ + MimeClassInfo* info = new MimeClassInfo(); + info->type = name; + info->desc = description; + m_results->last()->mimes.append(info); +} + +void WebPluginListBuilderImpl::addFileExtensionToLastMediaType(const WebString& extension) +{ + MimeClassInfo* info = m_results->last()->mimes.last(); + if (!info->suffixes.isEmpty()) + info->suffixes.append(','); + info->suffixes.append(extension); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebPluginListBuilderImpl.h b/WebKit/chromium/src/WebPluginListBuilderImpl.h new file mode 100644 index 0000000..7a8a497 --- /dev/null +++ b/WebKit/chromium/src/WebPluginListBuilderImpl.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPluginListBuilderImpl_h +#define WebPluginListBuilderImpl_h + +#include "WebPluginListBuilder.h" + +#include "PluginData.h" +#include <wtf/Vector.h> + +namespace WebKit { + +class WebPluginListBuilderImpl : public WebPluginListBuilder { +public: + WebPluginListBuilderImpl(Vector<WebCore::PluginInfo*>* results) : m_results(results) { } + + // WebPluginListBuilder methods: + virtual void addPlugin(const WebString& name, const WebString& description, const WebString& fileName); + virtual void addMediaTypeToLastPlugin(const WebString& name, const WebString& description); + virtual void addFileExtensionToLastMediaType(const WebString& extension); + +private: + Vector<WebCore::PluginInfo*>* m_results; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebPluginLoadObserver.cpp b/WebKit/chromium/src/WebPluginLoadObserver.cpp new file mode 100644 index 0000000..5ec59a6 --- /dev/null +++ b/WebKit/chromium/src/WebPluginLoadObserver.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebPluginLoadObserver.h" + +#include "WebPlugin.h" +#include "WebPluginContainerImpl.h" + +namespace WebKit { + +WebPluginLoadObserver::~WebPluginLoadObserver() +{ + if (m_pluginContainer) + m_pluginContainer->willDestroyPluginLoadObserver(this); +} + +void WebPluginLoadObserver::didFinishLoading() +{ + if (m_pluginContainer) + m_pluginContainer->plugin()->didFinishLoadingFrameRequest(m_notifyURL, m_notifyData); +} + +void WebPluginLoadObserver::didFailLoading(const WebURLError& error) +{ + if (m_pluginContainer) + m_pluginContainer->plugin()->didFailLoadingFrameRequest(m_notifyURL, m_notifyData, error); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebPluginLoadObserver.h b/WebKit/chromium/src/WebPluginLoadObserver.h new file mode 100644 index 0000000..097d08d --- /dev/null +++ b/WebKit/chromium/src/WebPluginLoadObserver.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPluginLoadObserver_h +#define WebPluginLoadObserver_h + +#include "../public/WebURL.h" + +namespace WebKit { + +class WebPluginContainerImpl; +struct WebURLError; + +class WebPluginLoadObserver { +public: + WebPluginLoadObserver(WebPluginContainerImpl* pluginContainer, + const WebURL& notifyURL, void* notifyData) + : m_pluginContainer(pluginContainer) + , m_notifyURL(notifyURL) + , m_notifyData(notifyData) + { + } + + ~WebPluginLoadObserver(); + + const WebURL& url() const { return m_notifyURL; } + + void clearPluginContainer() { m_pluginContainer = 0; } + void didFinishLoading(); + void didFailLoading(const WebURLError&); + +private: + WebPluginContainerImpl* m_pluginContainer; + WebURL m_notifyURL; + void* m_notifyData; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebPopupMenuImpl.cpp b/WebKit/chromium/src/WebPopupMenuImpl.cpp new file mode 100644 index 0000000..f6d360e --- /dev/null +++ b/WebKit/chromium/src/WebPopupMenuImpl.cpp @@ -0,0 +1,312 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebPopupMenuImpl.h" + +#include "Cursor.h" +#include "FramelessScrollView.h" +#include "FrameView.h" +#include "IntRect.h" +#include "PlatformContextSkia.h" +#include "PlatformKeyboardEvent.h" +#include "PlatformMouseEvent.h" +#include "PlatformWheelEvent.h" +#include "SkiaUtils.h" + +#include "WebInputEvent.h" +#include "WebInputEventConversion.h" +#include "WebRect.h" +#include "WebWidgetClient.h" + +#include <skia/ext/platform_canvas.h> + +using namespace WebCore; + +namespace WebKit { + +// WebPopupMenu --------------------------------------------------------------- + +WebPopupMenu* WebPopupMenu::create(WebWidgetClient* client) +{ + return new WebPopupMenuImpl(client); +} + +// WebWidget ------------------------------------------------------------------ + +WebPopupMenuImpl::WebPopupMenuImpl(WebWidgetClient* client) + : m_client(client) + , m_widget(0) +{ + // set to impossible point so we always get the first mouse pos + m_lastMousePosition = WebPoint(-1, -1); +} + +WebPopupMenuImpl::~WebPopupMenuImpl() +{ + if (m_widget) + m_widget->setClient(0); +} + +void WebPopupMenuImpl::Init(FramelessScrollView* widget, const WebRect& bounds) +{ + m_widget = widget; + m_widget->setClient(this); + + if (m_client) { + m_client->setWindowRect(bounds); + m_client->show(WebNavigationPolicy()); // Policy is ignored + } +} + +void WebPopupMenuImpl::MouseMove(const WebMouseEvent& event) +{ + // don't send mouse move messages if the mouse hasn't moved. + if (event.x != m_lastMousePosition.x || event.y != m_lastMousePosition.y) { + m_lastMousePosition = WebPoint(event.x, event.y); + m_widget->handleMouseMoveEvent(PlatformMouseEventBuilder(m_widget, event)); + } +} + +void WebPopupMenuImpl::MouseLeave(const WebMouseEvent& event) +{ + m_widget->handleMouseMoveEvent(PlatformMouseEventBuilder(m_widget, event)); +} + +void WebPopupMenuImpl::MouseDown(const WebMouseEvent& event) +{ + m_widget->handleMouseDownEvent(PlatformMouseEventBuilder(m_widget, event)); +} + +void WebPopupMenuImpl::MouseUp(const WebMouseEvent& event) +{ + mouseCaptureLost(); + m_widget->handleMouseReleaseEvent(PlatformMouseEventBuilder(m_widget, event)); +} + +void WebPopupMenuImpl::MouseWheel(const WebMouseWheelEvent& event) +{ + m_widget->handleWheelEvent(PlatformWheelEventBuilder(m_widget, event)); +} + +bool WebPopupMenuImpl::KeyEvent(const WebKeyboardEvent& event) +{ + return m_widget->handleKeyEvent(PlatformKeyboardEventBuilder(event)); +} + +// WebWidget ------------------------------------------------------------------- + +void WebPopupMenuImpl::close() +{ + if (m_widget) + m_widget->hide(); + + m_client = 0; + + deref(); // Balances ref() from WebWidget::Create +} + +void WebPopupMenuImpl::resize(const WebSize& newSize) +{ + if (m_size == newSize) + return; + m_size = newSize; + + if (m_widget) { + IntRect newGeometry(0, 0, m_size.width, m_size.height); + m_widget->setFrameRect(newGeometry); + } + + if (m_client) { + WebRect damagedRect(0, 0, m_size.width, m_size.height); + m_client->didInvalidateRect(damagedRect); + } +} + +void WebPopupMenuImpl::layout() +{ +} + +void WebPopupMenuImpl::paint(WebCanvas* canvas, const WebRect& rect) +{ + if (!m_widget) + return; + + if (!rect.isEmpty()) { +#if WEBKIT_USING_CG + GraphicsContext gc(canvas); +#elif WEBKIT_USING_SKIA + PlatformContextSkia context(canvas); + // PlatformGraphicsContext is actually a pointer to PlatformContextSkia. + GraphicsContext gc(reinterpret_cast<PlatformGraphicsContext*>(&context)); +#else + notImplemented(); +#endif + m_widget->paint(&gc, rect); + } +} + +bool WebPopupMenuImpl::handleInputEvent(const WebInputEvent& inputEvent) +{ + if (!m_widget) + return false; + + // TODO (jcampan): WebKit seems to always return false on mouse events + // methods. For now we'll assume it has processed them (as we are only + // interested in whether keyboard events are processed). + switch (inputEvent.type) { + case WebInputEvent::MouseMove: + MouseMove(*static_cast<const WebMouseEvent*>(&inputEvent)); + return true; + + case WebInputEvent::MouseLeave: + MouseLeave(*static_cast<const WebMouseEvent*>(&inputEvent)); + return true; + + case WebInputEvent::MouseWheel: + MouseWheel(*static_cast<const WebMouseWheelEvent*>(&inputEvent)); + return true; + + case WebInputEvent::MouseDown: + MouseDown(*static_cast<const WebMouseEvent*>(&inputEvent)); + return true; + + case WebInputEvent::MouseUp: + MouseUp(*static_cast<const WebMouseEvent*>(&inputEvent)); + return true; + + // In Windows, RawKeyDown only has information about the physical key, but + // for "selection", we need the information about the character the key + // translated into. For English, the physical key value and the character + // value are the same, hence, "selection" works for English. But for other + // languages, such as Hebrew, the character value is different from the + // physical key value. Thus, without accepting Char event type which + // contains the key's character value, the "selection" won't work for + // non-English languages, such as Hebrew. + case WebInputEvent::RawKeyDown: + case WebInputEvent::KeyDown: + case WebInputEvent::KeyUp: + case WebInputEvent::Char: + return KeyEvent(*static_cast<const WebKeyboardEvent*>(&inputEvent)); + + default: + break; + } + return false; +} + +void WebPopupMenuImpl::mouseCaptureLost() +{ +} + +void WebPopupMenuImpl::setFocus(bool enable) +{ +} + +bool WebPopupMenuImpl::handleCompositionEvent( + WebCompositionCommand command, int cursorPosition, int targetStart, + int targetEnd, const WebString& imeString) +{ + return false; +} + +bool WebPopupMenuImpl::queryCompositionStatus(bool* enabled, WebRect* caretRect) +{ + return false; +} + +void WebPopupMenuImpl::setTextDirection(WebTextDirection direction) +{ +} + + +//----------------------------------------------------------------------------- +// WebCore::HostWindow + +void WebPopupMenuImpl::repaint(const IntRect& paintRect, + bool contentChanged, + bool immediate, + bool repaintContentOnly) +{ + // Ignore spurious calls. + if (!contentChanged || paintRect.isEmpty()) + return; + if (m_client) + m_client->didInvalidateRect(paintRect); +} + +void WebPopupMenuImpl::scroll(const IntSize& scrollDelta, + const IntRect& scrollRect, + const IntRect& clipRect) +{ + if (m_client) { + int dx = scrollDelta.width(); + int dy = scrollDelta.height(); + m_client->didScrollRect(dx, dy, clipRect); + } +} + +IntPoint WebPopupMenuImpl::screenToWindow(const IntPoint& point) const +{ + notImplemented(); + return IntPoint(); +} + +IntRect WebPopupMenuImpl::windowToScreen(const IntRect& rect) const +{ + notImplemented(); + return IntRect(); +} + +void WebPopupMenuImpl::scrollRectIntoView(const IntRect&, const ScrollView*) const +{ + // Nothing to be done here since we do not have the concept of a container + // that implements its own scrolling. +} + +void WebPopupMenuImpl::scrollbarsModeDidChange() const +{ + // Nothing to be done since we have no concept of different scrollbar modes. +} + +//----------------------------------------------------------------------------- +// WebCore::FramelessScrollViewClient + +void WebPopupMenuImpl::popupClosed(FramelessScrollView* widget) +{ + ASSERT(widget == m_widget); + if (m_widget) { + m_widget->setClient(0); + m_widget = 0; + } + m_client->closeWidgetSoon(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebPopupMenuImpl.h b/WebKit/chromium/src/WebPopupMenuImpl.h new file mode 100644 index 0000000..13eb674 --- /dev/null +++ b/WebKit/chromium/src/WebPopupMenuImpl.h @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebPopupMenuImpl_h +#define WebPopupMenuImpl_h + +// FIXME: Add this to FramelessScrollViewClient.h +namespace WebCore { class FramelessScrollView; } + +#include "FramelessScrollViewClient.h" +// FIXME: remove the relative paths once glue/ consumers are removed. +#include "../public/WebPoint.h" +#include "../public/WebPopupMenu.h" +#include "../public/WebSize.h" +#include <wtf/RefCounted.h> + +namespace WebCore { +class Frame; +class FramelessScrollView; +class KeyboardEvent; +class Page; +class PlatformKeyboardEvent; +class Range; +class Widget; +} + +namespace WebKit { +class WebKeyboardEvent; +class WebMouseEvent; +class WebMouseWheelEvent; +struct WebRect; + +class WebPopupMenuImpl : public WebPopupMenu, + public WebCore::FramelessScrollViewClient, + public RefCounted<WebPopupMenuImpl> { +public: + // WebWidget + virtual void close(); + virtual WebSize size() { return m_size; } + virtual void resize(const WebSize&); + virtual void layout(); + virtual void paint(WebCanvas* canvas, const WebRect& rect); + virtual bool handleInputEvent(const WebInputEvent&); + virtual void mouseCaptureLost(); + virtual void setFocus(bool enable); + virtual bool handleCompositionEvent( + WebCompositionCommand command, int cursorPosition, + int targetStart, int targetEnd, const WebString& text); + virtual bool queryCompositionStatus(bool* enabled, WebRect* caretRect); + virtual void setTextDirection(WebTextDirection direction); + + // WebPopupMenuImpl + void Init(WebCore::FramelessScrollView* widget, + const WebRect& bounds); + + WebWidgetClient* client() { return m_client; } + + void MouseMove(const WebMouseEvent&); + void MouseLeave(const WebMouseEvent&); + void MouseDown(const WebMouseEvent&); + void MouseUp(const WebMouseEvent&); + void MouseDoubleClick(const WebMouseEvent&); + void MouseWheel(const WebMouseWheelEvent&); + bool KeyEvent(const WebKeyboardEvent&); + + protected: + friend class WebPopupMenu; // For WebPopupMenu::create + friend class WTF::RefCounted<WebPopupMenuImpl>; + + WebPopupMenuImpl(WebWidgetClient* client); + ~WebPopupMenuImpl(); + + // WebCore::HostWindow methods: + virtual void repaint( + const WebCore::IntRect&, bool contentChanged, bool immediate = false, + bool repaintContentOnly = false); + virtual void scroll( + const WebCore::IntSize& scrollDelta, const WebCore::IntRect& scrollRect, + const WebCore::IntRect& clipRect); + virtual WebCore::IntPoint screenToWindow(const WebCore::IntPoint&) const; + virtual WebCore::IntRect windowToScreen(const WebCore::IntRect&) const; + virtual PlatformPageClient platformPageClient() const { return 0; } + virtual void scrollRectIntoView(const WebCore::IntRect&, const WebCore::ScrollView*) const; + virtual void scrollbarsModeDidChange() const; + + // WebCore::FramelessScrollViewClient methods: + virtual void popupClosed(WebCore::FramelessScrollView*); + + WebWidgetClient* m_client; + WebSize m_size; + + WebPoint m_lastMousePosition; + + // This is a non-owning ref. The popup will notify us via popupClosed() + // before it is destroyed. + WebCore::FramelessScrollView* m_widget; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebRange.cpp b/WebKit/chromium/src/WebRange.cpp new file mode 100644 index 0000000..3dd000d --- /dev/null +++ b/WebKit/chromium/src/WebRange.cpp @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebRange.h" + +#include "Range.h" +#include "WebNode.h" +#include "WebString.h" +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +class WebRangePrivate : public Range { +}; + +void WebRange::reset() +{ + assign(0); +} + +void WebRange::assign(const WebRange& other) +{ + WebRangePrivate* p = const_cast<WebRangePrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +int WebRange::startOffset() const +{ + return m_private->startOffset(); +} + +int WebRange::endOffset() const +{ + return m_private->endOffset(); +} + +WebNode WebRange::startContainer(int& exceptionCode) const +{ + return PassRefPtr<Node>(m_private->startContainer(exceptionCode)); +} + +WebNode WebRange::endContainer(int& exceptionCode) const +{ + return PassRefPtr<Node>(m_private->endContainer(exceptionCode)); +} + +WebString WebRange::toHTMLText() const +{ + return m_private->toHTML(); +} + +WebString WebRange::toPlainText() const +{ + return m_private->text(); +} + +WebRange::WebRange(const WTF::PassRefPtr<WebCore::Range>& range) + : m_private(static_cast<WebRangePrivate*>(range.releaseRef())) +{ +} + +WebRange& WebRange::operator=(const WTF::PassRefPtr<WebCore::Range>& range) +{ + assign(static_cast<WebRangePrivate*>(range.releaseRef())); + return *this; +} + +WebRange::operator WTF::PassRefPtr<WebCore::Range>() const +{ + return PassRefPtr<Range>(const_cast<WebRangePrivate*>(m_private)); +} + +void WebRange::assign(WebRangePrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebRegularExpression.cpp b/WebKit/chromium/src/WebRegularExpression.cpp new file mode 100644 index 0000000..558b750 --- /dev/null +++ b/WebKit/chromium/src/WebRegularExpression.cpp @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebRegularExpression.h" + +#include "RegularExpression.h" +#include "WebString.h" + +using namespace WebCore; + +namespace WebKit { + +class WebRegularExpressionPrivate : public RegularExpression { +}; + +WebRegularExpression::WebRegularExpression(const WebString& pattern, + WebTextCaseSensitivity caseSensitivity) +{ + TextCaseSensitivity sensitivity = static_cast<TextCaseSensitivity>(caseSensitivity); + RegularExpression* re = new RegularExpression(pattern, sensitivity); + m_private = static_cast<WebRegularExpressionPrivate*>(re); +} + +WebRegularExpression::~WebRegularExpression() +{ + delete m_private; +} + +int WebRegularExpression::match(const WebString& str, + int startFrom, + int* matchLength) const +{ + if (!m_private) + return -1; + + return m_private->match(str, startFrom, matchLength); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebRuntimeFeatures.cpp b/WebKit/chromium/src/WebRuntimeFeatures.cpp new file mode 100644 index 0000000..b630a09 --- /dev/null +++ b/WebKit/chromium/src/WebRuntimeFeatures.cpp @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebRuntimeFeatures.h" + +#include "RuntimeEnabledFeatures.h" +#include "WebMediaPlayerClientImpl.h" +#include "WebSocket.h" + +using namespace WebCore; + +namespace WebKit { + +void WebRuntimeFeatures::enableDatabase(bool enable) +{ +#if ENABLE(DATABASE) + RuntimeEnabledFeatures::setDatabaseEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isDatabaseEnabled() +{ +#if ENABLE(DATABASE) + return RuntimeEnabledFeatures::databaseEnabled(); +#else + return false; +#endif +} + +void WebRuntimeFeatures::enableLocalStorage(bool enable) +{ +#if ENABLE(DOM_STORAGE) + RuntimeEnabledFeatures::setLocalStorageEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isLocalStorageEnabled() +{ +#if ENABLE(DOM_STORAGE) + return RuntimeEnabledFeatures::localStorageEnabled(); +#else + return false; +#endif +} + +void WebRuntimeFeatures::enableSessionStorage(bool enable) +{ +#if ENABLE(DOM_STORAGE) + RuntimeEnabledFeatures::setSessionStorageEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isSessionStorageEnabled() +{ +#if ENABLE(DOM_STORAGE) + return RuntimeEnabledFeatures::sessionStorageEnabled(); +#else + return false; +#endif +} + +void WebRuntimeFeatures::enableMediaPlayer(bool enable) +{ +#if ENABLE(VIDEO) + WebMediaPlayerClientImpl::setIsEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isMediaPlayerEnabled() +{ +#if ENABLE(VIDEO) + return WebMediaPlayerClientImpl::isEnabled(); +#else + return false; +#endif +} + +void WebRuntimeFeatures::enableSockets(bool enable) +{ +#if ENABLE(WEB_SOCKETS) + WebSocket::setIsAvailable(enable); +#endif +} + +bool WebRuntimeFeatures::isSocketsEnabled() +{ +#if ENABLE(WEB_SOCKETS) + return WebSocket::isAvailable(); +#else + return false; +#endif +} + +void WebRuntimeFeatures::enableNotifications(bool enable) +{ +#if ENABLE(NOTIFICATIONS) + RuntimeEnabledFeatures::setNotificationsEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isNotificationsEnabled() +{ +#if ENABLE(NOTIFICATIONS) + return RuntimeEnabledFeatures::notificationsEnabled(); +#else + return false; +#endif +} + +void WebRuntimeFeatures::enableApplicationCache(bool enable) +{ +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + RuntimeEnabledFeatures::setApplicationCacheEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isApplicationCacheEnabled() +{ +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + return RuntimeEnabledFeatures::applicationCacheEnabled(); +#else + return false; +#endif +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebScriptController.cpp b/WebKit/chromium/src/WebScriptController.cpp new file mode 100644 index 0000000..d2c168d --- /dev/null +++ b/WebKit/chromium/src/WebScriptController.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebScriptController.h" + +#include "V8Binding.h" +#include "V8DOMMap.h" +#include "V8Proxy.h" + +#include "WebString.h" + +using namespace WebCore; + +namespace WebKit { + +void WebScriptController::registerExtension(v8::Extension* extension) +{ + V8Proxy::registerExtension(extension, WebString()); +} + +void WebScriptController::registerExtension(v8::Extension* extension, + const WebString& schemeRestriction) +{ + V8Proxy::registerExtension(extension, schemeRestriction); +} + +void WebScriptController::registerExtension(v8::Extension* extension, + int extensionGroup) +{ + V8Proxy::registerExtension(extension, extensionGroup); +} + +void WebScriptController::enableV8SingleThreadMode() +{ + enableStringImplCache(); + enableFasterDOMStoreAccess(); +} + +void WebScriptController::flushConsoleMessages() +{ + WebCore::V8Proxy::processConsoleMessages(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebSearchableFormData.cpp b/WebKit/chromium/src/WebSearchableFormData.cpp new file mode 100644 index 0000000..eddaffe --- /dev/null +++ b/WebKit/chromium/src/WebSearchableFormData.cpp @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebSearchableFormData.h" + +#include "Document.h" +#include "FormDataBuilder.h" +#include "FormDataList.h" +#include "Frame.h" +#include "HTMLFormControlElement.h" +#include "HTMLFormElement.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "HTMLOptionElement.h" +#include "HTMLOptionsCollection.h" +#include "HTMLSelectElement.h" +#include "TextEncoding.h" +#include "WebFormElement.h" + +using namespace WebCore; + +namespace { + +// Gets the encoding for the form. +void GetFormEncoding(const HTMLFormElement* form, TextEncoding* encoding) +{ + String str(form->getAttribute(HTMLNames::accept_charsetAttr)); + str.replace(',', ' '); + Vector<String> charsets; + str.split(' ', charsets); + for (Vector<String>::const_iterator i(charsets.begin()); i != charsets.end(); ++i) { + *encoding = TextEncoding(*i); + if (encoding->isValid()) + return; + } + const Frame* frame = form->document()->frame(); + *encoding = frame ? TextEncoding(frame->loader()->encoding()) : Latin1Encoding(); +} + +// Returns true if the submit request results in an HTTP URL. +bool IsHTTPFormSubmit(const HTMLFormElement* form) +{ + String action(form->action()); + return form->document()->frame()->loader()->completeURL(action.isNull() ? "" : action).protocol() == "http"; +} + +// If the form does not have an activated submit button, the first submit +// button is returned. +HTMLFormControlElement* GetButtonToActivate(HTMLFormElement* form) +{ + HTMLFormControlElement* firstSubmitButton = 0; + for (Vector<HTMLFormControlElement*>::const_iterator i(form->formElements.begin()); i != form->formElements.end(); ++i) { + HTMLFormControlElement* formElement = *i; + if (formElement->isActivatedSubmit()) + // There's a button that is already activated for submit, return 0. + return 0; + if (!firstSubmitButton && formElement->isSuccessfulSubmitButton()) + firstSubmitButton = formElement; + } + return firstSubmitButton; +} + +// Returns true if the selected state of all the options matches the default +// selected state. +bool IsSelectInDefaultState(const HTMLSelectElement* select) +{ + const Vector<Element*>& listItems = select->listItems(); + if (select->multiple() || select->size() > 1) { + for (Vector<Element*>::const_iterator i(listItems.begin()); i != listItems.end(); ++i) { + if (!(*i)->hasLocalName(HTMLNames::optionTag)) + continue; + const HTMLOptionElement* optionElement = static_cast<const HTMLOptionElement*>(*i); + if (optionElement->selected() != optionElement->defaultSelected()) + return false; + } + return true; + } + + // The select is rendered as a combobox (called menulist in WebKit). At + // least one item is selected, determine which one. + const HTMLOptionElement* initialSelected = 0; + for (Vector<Element*>::const_iterator i(listItems.begin()); i != listItems.end(); ++i) { + if (!(*i)->hasLocalName(HTMLNames::optionTag)) + continue; + const HTMLOptionElement* optionElement = static_cast<const HTMLOptionElement*>(*i); + if (optionElement->defaultSelected()) { + // The page specified the option to select. + initialSelected = optionElement; + break; + } + if (!initialSelected) + initialSelected = optionElement; + } + return initialSelected ? initialSelected->selected() : true; +} + +// Returns true if the form element is in its default state, false otherwise. +// The default state is the state of the form element on initial load of the +// page, and varies depending upon the form element. For example, a checkbox is +// in its default state if the checked state matches the defaultChecked state. +bool IsInDefaultState(const HTMLFormControlElement* formElement) +{ + if (formElement->hasTagName(HTMLNames::inputTag)) { + const HTMLInputElement* inputElement = static_cast<const HTMLInputElement*>(formElement); + if (inputElement->inputType() == HTMLInputElement::CHECKBOX || inputElement->inputType() == HTMLInputElement::RADIO) + return inputElement->checked() == inputElement->defaultChecked(); + } else if (formElement->hasTagName(HTMLNames::selectTag)) + return IsSelectInDefaultState(static_cast<const HTMLSelectElement*>(formElement)); + return true; +} + +// If form has only one text input element, return true. If a valid input +// element is not found, return false. Additionally, the form data for all +// elements is added to enc_string and the encoding used is set in +// encoding_name. +bool HasSuitableTextElement(const HTMLFormElement* form, Vector<char>* encodedString, String* encodingName) +{ + TextEncoding encoding; + GetFormEncoding(form, &encoding); + if (!encoding.isValid()) { + // Need a valid encoding to encode the form elements. + // If the encoding isn't found webkit ends up replacing the params with + // empty strings. So, we don't try to do anything here. + return 0; + } + *encodingName = encoding.name(); + + HTMLInputElement* textElement = 0; + for (Vector<HTMLFormControlElement*>::const_iterator i(form->formElements.begin()); i != form->formElements.end(); ++i) { + HTMLFormControlElement* formElement = *i; + if (formElement->disabled() || formElement->name().isNull()) + continue; + + if (!IsInDefaultState(formElement) || formElement->hasTagName(HTMLNames::textareaTag)) + return 0; + + bool isTextElement = false; + if (formElement->hasTagName(HTMLNames::inputTag)) { + switch (static_cast<const HTMLInputElement*>(formElement)->inputType()) { + case HTMLInputElement::TEXT: + case HTMLInputElement::ISINDEX: + isTextElement = true; + break; + case HTMLInputElement::PASSWORD: + // Don't store passwords! This is most likely an https anyway. + // Fall through. + case HTMLInputElement::FILE: + // Too big, don't try to index this. + return 0; + default: + // All other input types are indexable. + break; + } + } + + FormDataList dataList(encoding); + if (!formElement->appendFormData(dataList, false)) + continue; + + const Vector<FormDataList::Item>& itemList = dataList.list(); + if (isTextElement && !itemList.isEmpty()) { + if (textElement) { + // The auto-complete bar only knows how to fill in one value. + // This form has multiple fields; don't treat it as searchable. + return false; + } + textElement = static_cast<HTMLInputElement*>(formElement); + } + for (Vector<FormDataList::Item>::const_iterator j(itemList.begin()); j != itemList.end(); ++j) { + // Handle ISINDEX / <input name=isindex> specially, but only if it's + // the first entry. + if (!encodedString->isEmpty() || j->data() != "isindex") { + if (!encodedString->isEmpty()) + encodedString->append('&'); + FormDataBuilder::encodeStringAsFormData(*encodedString, j->data()); + encodedString->append('='); + } + ++j; + if (formElement == textElement) + encodedString->append("{searchTerms}", 13); + else + FormDataBuilder::encodeStringAsFormData(*encodedString, j->data()); + } + } + + return textElement; +} + +} // namespace + +namespace WebKit { + +WebSearchableFormData::WebSearchableFormData(const WebFormElement& form) +{ + RefPtr<HTMLFormElement> formElement = form.operator PassRefPtr<HTMLFormElement>(); + const Frame* frame = formElement->document()->frame(); + if (!frame) + return; + + // Only consider forms that GET data and the action targets an http page. + if (equalIgnoringCase(formElement->getAttribute(HTMLNames::methodAttr), "post") || !IsHTTPFormSubmit(formElement.get())) + return; + + HTMLFormControlElement* firstSubmitButton = GetButtonToActivate(formElement.get()); + if (firstSubmitButton) { + // The form does not have an active submit button, make the first button + // active. We need to do this, otherwise the URL will not contain the + // name of the submit button. + firstSubmitButton->setActivatedSubmit(true); + } + Vector<char> encodedString; + String encoding; + bool hasElement = HasSuitableTextElement(formElement.get(), &encodedString, &encoding); + if (firstSubmitButton) + firstSubmitButton->setActivatedSubmit(false); + if (!hasElement) { + // Not a searchable form. + return; + } + + String action(formElement->action()); + KURL url(frame->loader()->completeURL(action.isNull() ? "" : action)); + RefPtr<FormData> formData = FormData::create(encodedString); + url.setQuery(formData->flattenToString()); + m_url = url; + m_encoding = encoding; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebSecurityOrigin.cpp b/WebKit/chromium/src/WebSecurityOrigin.cpp new file mode 100644 index 0000000..3cf7364 --- /dev/null +++ b/WebKit/chromium/src/WebSecurityOrigin.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebSecurityOrigin.h" + +#include "SecurityOrigin.h" +#include "WebString.h" +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +class WebSecurityOriginPrivate : public SecurityOrigin { +}; + +void WebSecurityOrigin::reset() +{ + assign(0); +} + +void WebSecurityOrigin::assign(const WebSecurityOrigin& other) +{ + WebSecurityOriginPrivate* p = const_cast<WebSecurityOriginPrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +WebString WebSecurityOrigin::protocol() const +{ + ASSERT(m_private); + return m_private->protocol(); +} + +WebString WebSecurityOrigin::host() const +{ + ASSERT(m_private); + return m_private->host(); +} + +unsigned short WebSecurityOrigin::port() const +{ + ASSERT(m_private); + return m_private->port(); +} + +bool WebSecurityOrigin::isEmpty() const +{ + ASSERT(m_private); + return m_private->isEmpty(); +} + +WebString WebSecurityOrigin::toString() const +{ + ASSERT(m_private); + return m_private->toString(); +} + +WebString WebSecurityOrigin::databaseIdentifier() +{ + ASSERT(m_private); + return m_private->databaseIdentifier(); +} + +WebSecurityOrigin::WebSecurityOrigin(const WTF::PassRefPtr<WebCore::SecurityOrigin>& origin) + : m_private(static_cast<WebSecurityOriginPrivate*>(origin.releaseRef())) +{ +} + +WebSecurityOrigin& WebSecurityOrigin::operator=(const WTF::PassRefPtr<WebCore::SecurityOrigin>& origin) +{ + assign(static_cast<WebSecurityOriginPrivate*>(origin.releaseRef())); + return *this; +} + +WebSecurityOrigin::operator WTF::PassRefPtr<WebCore::SecurityOrigin>() const +{ + return PassRefPtr<SecurityOrigin>(const_cast<WebSecurityOriginPrivate*>(m_private)); +} + +void WebSecurityOrigin::assign(WebSecurityOriginPrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebSecurityPolicy.cpp b/WebKit/chromium/src/WebSecurityPolicy.cpp new file mode 100644 index 0000000..c66c805 --- /dev/null +++ b/WebKit/chromium/src/WebSecurityPolicy.cpp @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebSecurityPolicy.h" + +#include "FrameLoader.h" +#include "SecurityOrigin.h" + +#include "WebString.h" +#include "WebURL.h" + +using namespace WebCore; + +namespace WebKit { + +void WebSecurityPolicy::registerURLSchemeAsLocal(const WebString& scheme) +{ + SecurityOrigin::registerURLSchemeAsLocal(scheme); +} + +void WebSecurityPolicy::registerURLSchemeAsNoAccess(const WebString& scheme) +{ + SecurityOrigin::registerURLSchemeAsNoAccess(scheme); +} + +void WebSecurityPolicy::whiteListAccessFromOrigin(const WebURL& sourceOrigin, + const WebString& destinationProtocol, + const WebString& destinationHost, + bool allowDestinationSubdomains) +{ + SecurityOrigin::whiteListAccessFromOrigin( + *SecurityOrigin::create(sourceOrigin), destinationProtocol, + destinationHost, allowDestinationSubdomains); +} + +void WebSecurityPolicy::resetOriginAccessWhiteLists() +{ + SecurityOrigin::resetOriginAccessWhiteLists(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebSettingsImpl.cpp b/WebKit/chromium/src/WebSettingsImpl.cpp new file mode 100644 index 0000000..e019653 --- /dev/null +++ b/WebKit/chromium/src/WebSettingsImpl.cpp @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebSettingsImpl.h" + +#include "FontRenderingMode.h" +#include "Settings.h" +#include "WebString.h" +#include "WebURL.h" + +#if defined(OS_WIN) +#include "RenderThemeChromiumWin.h" +#endif + +using namespace WebCore; + +namespace WebKit { + +WebSettingsImpl::WebSettingsImpl(Settings* settings) + : m_settings(settings) +{ + ASSERT(settings); +} + +void WebSettingsImpl::setStandardFontFamily(const WebString& font) +{ + m_settings->setStandardFontFamily(font); +} + +void WebSettingsImpl::setFixedFontFamily(const WebString& font) +{ + m_settings->setFixedFontFamily((String)font); +} + +void WebSettingsImpl::setSerifFontFamily(const WebString& font) +{ + m_settings->setSerifFontFamily((String)font); +} + +void WebSettingsImpl::setSansSerifFontFamily(const WebString& font) +{ + m_settings->setSansSerifFontFamily((String)font); +} + +void WebSettingsImpl::setCursiveFontFamily(const WebString& font) +{ + m_settings->setCursiveFontFamily((String)font); +} + +void WebSettingsImpl::setFantasyFontFamily(const WebString& font) +{ + m_settings->setFantasyFontFamily((String)font); +} + +void WebSettingsImpl::setDefaultFontSize(int size) +{ + m_settings->setDefaultFontSize(size); +#if defined(OS_WIN) + // RenderTheme is a singleton that needs to know the default font size to + // draw some form controls. We let it know each time the size changes. + WebCore::RenderThemeChromiumWin::setDefaultFontSize(size); +#endif +} + +void WebSettingsImpl::setDefaultFixedFontSize(int size) +{ + m_settings->setDefaultFixedFontSize(size); +} + +void WebSettingsImpl::setMinimumFontSize(int size) +{ + m_settings->setMinimumFontSize(size); +} + +void WebSettingsImpl::setMinimumLogicalFontSize(int size) +{ + m_settings->setMinimumLogicalFontSize(size); +} + +void WebSettingsImpl::setDefaultTextEncodingName(const WebString& encoding) +{ + m_settings->setDefaultTextEncodingName((String)encoding); +} + +void WebSettingsImpl::setJavaScriptEnabled(bool enabled) +{ + m_settings->setJavaScriptEnabled(enabled); +} + +void WebSettingsImpl::setWebSecurityEnabled(bool enabled) +{ + m_settings->setWebSecurityEnabled(enabled); +} + +void WebSettingsImpl::setJavaScriptCanOpenWindowsAutomatically(bool canOpenWindows) +{ + m_settings->setJavaScriptCanOpenWindowsAutomatically(canOpenWindows); +} + +void WebSettingsImpl::setLoadsImagesAutomatically(bool loadsImagesAutomatically) +{ + m_settings->setLoadsImagesAutomatically(loadsImagesAutomatically); +} + +void WebSettingsImpl::setPluginsEnabled(bool enabled) +{ + m_settings->setPluginsEnabled(enabled); +} + +void WebSettingsImpl::setDOMPasteAllowed(bool enabled) +{ + m_settings->setDOMPasteAllowed(enabled); +} + +void WebSettingsImpl::setDeveloperExtrasEnabled(bool enabled) +{ + m_settings->setDeveloperExtrasEnabled(enabled); +} + +void WebSettingsImpl::setNeedsSiteSpecificQuirks(bool enabled) +{ + m_settings->setNeedsSiteSpecificQuirks(enabled); +} + +void WebSettingsImpl::setShrinksStandaloneImagesToFit(bool shrinkImages) +{ + m_settings->setShrinksStandaloneImagesToFit(shrinkImages); +} + +void WebSettingsImpl::setUsesEncodingDetector(bool usesDetector) +{ + m_settings->setUsesEncodingDetector(usesDetector); +} + +void WebSettingsImpl::setTextAreasAreResizable(bool areResizable) +{ + m_settings->setTextAreasAreResizable(areResizable); +} + +void WebSettingsImpl::setJavaEnabled(bool enabled) +{ + m_settings->setJavaEnabled(enabled); +} + +void WebSettingsImpl::setAllowScriptsToCloseWindows(bool allow) +{ + m_settings->setAllowScriptsToCloseWindows(allow); +} + +void WebSettingsImpl::setUserStyleSheetLocation(const WebURL& location) +{ + m_settings->setUserStyleSheetLocation(location); +} + +void WebSettingsImpl::setUsesPageCache(bool usesPageCache) +{ + m_settings->setUsesPageCache(usesPageCache); +} + +void WebSettingsImpl::setDownloadableBinaryFontsEnabled(bool enabled) +{ + m_settings->setDownloadableBinaryFontsEnabled(enabled); +} + +void WebSettingsImpl::setXSSAuditorEnabled(bool enabled) +{ + m_settings->setXSSAuditorEnabled(enabled); +} + +void WebSettingsImpl::setLocalStorageEnabled(bool enabled) +{ + m_settings->setLocalStorageEnabled(enabled); +} + +void WebSettingsImpl::setEditableLinkBehaviorNeverLive() +{ + // FIXME: If you ever need more behaviors than this, then we should probably + // define an enum in WebSettings.h and have a switch statement that + // translates. Until then, this is probably fine, though. + m_settings->setEditableLinkBehavior(WebCore::EditableLinkNeverLive); +} + +void WebSettingsImpl::setFontRenderingModeNormal() +{ + // FIXME: If you ever need more behaviors than this, then we should probably + // define an enum in WebSettings.h and have a switch statement that + // translates. Until then, this is probably fine, though. + m_settings->setFontRenderingMode(WebCore::NormalRenderingMode); +} + +void WebSettingsImpl::setShouldPaintCustomScrollbars(bool enabled) +{ + m_settings->setShouldPaintCustomScrollbars(enabled); +} + +void WebSettingsImpl::setDatabasesEnabled(bool enabled) +{ + m_settings->setDatabasesEnabled(enabled); +} + +void WebSettingsImpl::setAllowUniversalAccessFromFileURLs(bool allow) +{ + m_settings->setAllowUniversalAccessFromFileURLs(allow); +} + +void WebSettingsImpl::setTextDirectionSubmenuInclusionBehaviorNeverIncluded() +{ + // FIXME: If you ever need more behaviors than this, then we should probably + // define an enum in WebSettings.h and have a switch statement that + // translates. Until then, this is probably fine, though. + m_settings->setTextDirectionSubmenuInclusionBehavior(WebCore::TextDirectionSubmenuNeverIncluded); +} + +void WebSettingsImpl::setOfflineWebApplicationCacheEnabled(bool enabled) +{ + m_settings->setOfflineWebApplicationCacheEnabled(enabled); +} + +void WebSettingsImpl::setExperimentalWebGLEnabled(bool enabled) +{ + m_settings->setWebGLEnabled(enabled); +} + +void WebSettingsImpl::setGeolocationEnabled(bool enabled) +{ + m_settings->setGeolocationEnabled(enabled); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebSettingsImpl.h b/WebKit/chromium/src/WebSettingsImpl.h new file mode 100644 index 0000000..9c0f9f4 --- /dev/null +++ b/WebKit/chromium/src/WebSettingsImpl.h @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSettingsImpl_h +#define WebSettingsImpl_h + +// TODO(jorlow): Remove this hack once WebView is free of glue. +#include "../public/WebSettings.h" + +namespace WebCore { +class Settings; +} + +namespace WebKit { + +class WebSettingsImpl : public WebSettings { +public: + explicit WebSettingsImpl(WebCore::Settings*); + virtual ~WebSettingsImpl() { } + + virtual void setStandardFontFamily(const WebString&); + virtual void setFixedFontFamily(const WebString&); + virtual void setSerifFontFamily(const WebString&); + virtual void setSansSerifFontFamily(const WebString&); + virtual void setCursiveFontFamily(const WebString&); + virtual void setFantasyFontFamily(const WebString&); + virtual void setDefaultFontSize(int); + virtual void setDefaultFixedFontSize(int); + virtual void setMinimumFontSize(int); + virtual void setMinimumLogicalFontSize(int); + virtual void setDefaultTextEncodingName(const WebString&); + virtual void setJavaScriptEnabled(bool); + virtual void setWebSecurityEnabled(bool); + virtual void setJavaScriptCanOpenWindowsAutomatically(bool); + virtual void setLoadsImagesAutomatically(bool); + virtual void setPluginsEnabled(bool); + virtual void setDOMPasteAllowed(bool); + virtual void setDeveloperExtrasEnabled(bool); + virtual void setNeedsSiteSpecificQuirks(bool); + virtual void setShrinksStandaloneImagesToFit(bool); + virtual void setUsesEncodingDetector(bool); + virtual void setTextAreasAreResizable(bool); + virtual void setJavaEnabled(bool); + virtual void setAllowScriptsToCloseWindows(bool); + virtual void setUserStyleSheetLocation(const WebURL&); + virtual void setUsesPageCache(bool); + virtual void setDownloadableBinaryFontsEnabled(bool); + virtual void setXSSAuditorEnabled(bool); + virtual void setLocalStorageEnabled(bool); + virtual void setEditableLinkBehaviorNeverLive(); + virtual void setFontRenderingModeNormal(); + virtual void setShouldPaintCustomScrollbars(bool); + virtual void setDatabasesEnabled(bool); + virtual void setAllowUniversalAccessFromFileURLs(bool); + virtual void setTextDirectionSubmenuInclusionBehaviorNeverIncluded(); + virtual void setOfflineWebApplicationCacheEnabled(bool); + virtual void setExperimentalWebGLEnabled(bool); + virtual void setGeolocationEnabled(bool); + +private: + WebCore::Settings* m_settings; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebSharedWorkerImpl.cpp b/WebKit/chromium/src/WebSharedWorkerImpl.cpp new file mode 100644 index 0000000..4547336 --- /dev/null +++ b/WebKit/chromium/src/WebSharedWorkerImpl.cpp @@ -0,0 +1,127 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebSharedWorkerImpl.h" + +#include "GenericWorkerTask.h" +#include "KURL.h" +#include "MessageEvent.h" +#include "MessagePortChannel.h" +#include "PlatformMessagePortChannel.h" +#include "ScriptExecutionContext.h" +#include "SharedWorkerContext.h" +#include "SharedWorkerThread.h" + +#include "WebMessagePortChannel.h" +#include "WebString.h" +#include "WebURL.h" + +using namespace WebCore; + +namespace WebKit { + +#if ENABLE(SHARED_WORKERS) + +WebSharedWorkerImpl::WebSharedWorkerImpl(WebCommonWorkerClient* client) + : m_client(client) +{ +} + +WebSharedWorkerImpl::~WebSharedWorkerImpl() +{ +} + +bool WebSharedWorkerImpl::isStarted() +{ + // Should not ever be called from the worker thread (this API is only called on WebSharedWorkerProxy on the renderer thread). + ASSERT_NOT_REACHED(); + return workerThread(); +} + +void WebSharedWorkerImpl::connect(WebMessagePortChannel* webChannel, ConnectListener* listener) +{ + // Convert the WebMessagePortChanel to a WebCore::MessagePortChannel. + RefPtr<PlatformMessagePortChannel> platform_channel = + PlatformMessagePortChannel::create(webChannel); + webChannel->setClient(platform_channel.get()); + OwnPtr<MessagePortChannel> channel = + MessagePortChannel::create(platform_channel); + + workerThread()->runLoop().postTask( + createCallbackTask(&connectTask, this, channel.release())); + if (listener) + listener->connected(); +} + +void WebSharedWorkerImpl::connectTask(ScriptExecutionContext* context, WebSharedWorkerImpl* worker, PassOwnPtr<MessagePortChannel> channel) +{ + // Wrap the passed-in channel in a MessagePort, and send it off via a connect event. + RefPtr<MessagePort> port = MessagePort::create(*context); + port->entangle(channel.release()); + ASSERT(context->isWorkerContext()); + WorkerContext* workerContext = static_cast<WorkerContext*>(context); + ASSERT(workerContext->isSharedWorkerContext()); + workerContext->toSharedWorkerContext()->dispatchEvent(createConnectEvent(port)); +} + +void WebSharedWorkerImpl::startWorkerContext(const WebURL& url, const WebString& name, const WebString& userAgent, const WebString& sourceCode) +{ + initializeLoader(url); + setWorkerThread(SharedWorkerThread::create(name, url, userAgent, sourceCode, *this, *this)); + workerThread()->start(); +} + +void WebSharedWorkerImpl::terminateWorkerContext() +{ + stopWorkerThread(); +} + +void WebSharedWorkerImpl::clientDestroyed() +{ + m_client = 0; +} + +WebWorkerClient* WebSharedWorkerImpl::client() +{ + // We should never be asked for a WebWorkerClient (only dedicated workers have an associated WebWorkerClient). + // It should not be possible for SharedWorkerContext to generate an API call outside those supported by WebCommonWorkerClient. + ASSERT_NOT_REACHED(); + return 0; +} + +WebSharedWorker* WebSharedWorker::create(WebCommonWorkerClient* client) +{ + return new WebSharedWorkerImpl(client); +} + +#endif // ENABLE(SHARED_WORKERS) + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebSharedWorkerImpl.h b/WebKit/chromium/src/WebSharedWorkerImpl.h new file mode 100644 index 0000000..7c10d76 --- /dev/null +++ b/WebKit/chromium/src/WebSharedWorkerImpl.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebSharedWorkerImpl_h +#define WebSharedWorkerImpl_h + +#include "WebSharedWorker.h" + +#if ENABLE(SHARED_WORKERS) + +#include "ScriptExecutionContext.h" + +#include "WebWorkerBase.h" + +namespace WebKit { + +// This class is used by the worker process code to talk to the WebCore::SharedWorker implementation. +// It can't use it directly since it uses WebKit types, so this class converts the data types. +// When the WebCore::SharedWorker object wants to call WebCore::WorkerReportingProxy, this class will +// convert to Chrome data types first and then call the supplied WebCommonWorkerClient. +class WebSharedWorkerImpl : public WebWorkerBase, public WebSharedWorker { +public: + explicit WebSharedWorkerImpl(WebCommonWorkerClient* client); + + // WebSharedWorker methods: + virtual bool isStarted(); + virtual void startWorkerContext(const WebURL&, const WebString& name, const WebString& userAgent, const WebString& sourceCode); + virtual void connect(WebMessagePortChannel*, ConnectListener*); + virtual void terminateWorkerContext(); + virtual void clientDestroyed(); + + // WebWorkerBase methods: + WebWorkerClient* client(); + WebCommonWorkerClient* commonClient() { return m_client; } + +private: + virtual ~WebSharedWorkerImpl(); + + static void connectTask(WebCore::ScriptExecutionContext*, WebSharedWorkerImpl*, PassOwnPtr<WebCore::MessagePortChannel>); + + WebCommonWorkerClient* m_client; +}; + +} // namespace WebKit + +#endif // ENABLE(SHARED_WORKERS) + +#endif diff --git a/WebKit/chromium/src/WebStorageAreaImpl.cpp b/WebKit/chromium/src/WebStorageAreaImpl.cpp new file mode 100644 index 0000000..f24bee3 --- /dev/null +++ b/WebKit/chromium/src/WebStorageAreaImpl.cpp @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebStorageAreaImpl.h" + +#if ENABLE(DOM_STORAGE) + +#include "ExceptionCode.h" + +#include "WebString.h" +#include "WebURL.h" + +namespace WebKit { + +const WebURL* WebStorageAreaImpl::storageEventURL = 0; + +WebStorageAreaImpl::WebStorageAreaImpl(PassRefPtr<WebCore::StorageArea> storageArea) + : m_storageArea(storageArea) +{ +} + +WebStorageAreaImpl::~WebStorageAreaImpl() +{ +} + +unsigned WebStorageAreaImpl::length() +{ + return m_storageArea->length(); +} + +WebString WebStorageAreaImpl::key(unsigned index) +{ + return m_storageArea->key(index); +} + +WebString WebStorageAreaImpl::getItem(const WebString& key) +{ + return m_storageArea->getItem(key); +} + +void WebStorageAreaImpl::setItem(const WebString& key, const WebString& value, const WebURL& url, bool& quotaException) +{ + int exceptionCode = 0; + + ScopedStorageEventURL scope(url); + m_storageArea->setItem(key, value, exceptionCode, 0); + + if (exceptionCode) { + ASSERT(exceptionCode == WebCore::QUOTA_EXCEEDED_ERR); + quotaException = true; + } else + quotaException = false; +} + +void WebStorageAreaImpl::removeItem(const WebString& key, const WebURL& url) +{ + ScopedStorageEventURL scope(url); + m_storageArea->removeItem(key, 0); +} + +void WebStorageAreaImpl::clear(const WebURL& url) +{ + ScopedStorageEventURL scope(url); + m_storageArea->clear(0); +} + +} // namespace WebKit + +#endif // ENABLE(DOM_STORAGE) diff --git a/WebKit/chromium/src/WebStorageAreaImpl.h b/WebKit/chromium/src/WebStorageAreaImpl.h new file mode 100644 index 0000000..e1f74e0 --- /dev/null +++ b/WebKit/chromium/src/WebStorageAreaImpl.h @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebStorageAreaImpl_h +#define WebStorageAreaImpl_h + +#if ENABLE(DOM_STORAGE) + +#include "StorageAreaImpl.h" +#include "WebStorageArea.h" + +namespace WebKit { + +class WebStorageAreaImpl : public WebStorageArea { +public: + WebStorageAreaImpl(PassRefPtr<WebCore::StorageArea> storageArea); + virtual ~WebStorageAreaImpl(); + virtual unsigned length(); + virtual WebString key(unsigned index); + virtual WebString getItem(const WebString& key); + virtual void setItem(const WebString& key, const WebString& value, const WebURL& url, bool& quotaException); + virtual void removeItem(const WebString& key, const WebURL& url); + virtual void clear(const WebURL& url); + + // For storage events in single-process mode and test shell. + static const WebURL* currentStorageEventURL() { return storageEventURL; } + +private: + class ScopedStorageEventURL { + public: + ScopedStorageEventURL(const WebURL& url) + { + // FIXME: Once storage events are fired async in WebKit (as they should + // be) this can be ASSERTed to be 0 rather than saved. + m_existingStorageEventURL = storageEventURL; + storageEventURL = &url; + } + ~ScopedStorageEventURL() + { + storageEventURL = m_existingStorageEventURL; + } + + private: + const WebURL* m_existingStorageEventURL; + }; + + static const WebURL* storageEventURL; + + RefPtr<WebCore::StorageArea> m_storageArea; +}; + +} // namespace WebKit + +#endif // ENABLE(DOM_STORAGE) + +#endif // WebStorageAreaImpl_h diff --git a/WebKit/chromium/src/WebStorageEventDispatcherImpl.cpp b/WebKit/chromium/src/WebStorageEventDispatcherImpl.cpp new file mode 100644 index 0000000..515a423 --- /dev/null +++ b/WebKit/chromium/src/WebStorageEventDispatcherImpl.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebStorageEventDispatcherImpl.h" + +#if ENABLE(DOM_STORAGE) + +#include "KURL.h" +#include "SecurityOrigin.h" + +#include "WebStorageAreaImpl.h" +#include "WebURL.h" + +namespace WebKit { + +extern const char* pageGroupName; + +WebStorageEventDispatcher* WebStorageEventDispatcher::create() +{ + return new WebStorageEventDispatcherImpl(); +} + +WebStorageEventDispatcherImpl::WebStorageEventDispatcherImpl() + : m_eventDispatcher(new WebCore::StorageEventDispatcherImpl(pageGroupName)) +{ + ASSERT(m_eventDispatcher); +} + +void WebStorageEventDispatcherImpl::dispatchStorageEvent(const WebString& key, const WebString& oldValue, + const WebString& newValue, const WebString& origin, + const WebURL& passedInURL, bool isLocalStorage) +{ + // Hack for single-process mode and test shell. + const WebURL* storageAreaImplURL = WebStorageAreaImpl::currentStorageEventURL(); + const WebURL& url = storageAreaImplURL ? *storageAreaImplURL : passedInURL; + + WebCore::StorageType storageType = isLocalStorage ? WebCore::LocalStorage : WebCore::SessionStorage; + RefPtr<WebCore::SecurityOrigin> securityOrigin = WebCore::SecurityOrigin::createFromString(origin); + m_eventDispatcher->dispatchStorageEvent(key, oldValue, newValue, securityOrigin.get(), url, storageType); +} + +} // namespace WebKit + +#endif // ENABLE(DOM_STORAGE) diff --git a/WebKit/chromium/src/WebStorageEventDispatcherImpl.h b/WebKit/chromium/src/WebStorageEventDispatcherImpl.h new file mode 100644 index 0000000..6848b99 --- /dev/null +++ b/WebKit/chromium/src/WebStorageEventDispatcherImpl.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebStorageEventDispatcherImpl_h +#define WebStorageEventDispatcherImpl_h + +#if ENABLE(DOM_STORAGE) + +#include "StorageEventDispatcherImpl.h" +#include "WebStorageEventDispatcher.h" +#include <wtf/OwnPtr.h> + +namespace WebKit { + +class WebStorageEventDispatcherImpl : public WebStorageEventDispatcher { +public: + WebStorageEventDispatcherImpl(); + + virtual void dispatchStorageEvent(const WebString& key, const WebString& oldValue, + const WebString& newValue, const WebString& origin, + const WebURL&, bool isLocalStorage); + +private: + OwnPtr<WebCore::StorageEventDispatcherImpl> m_eventDispatcher; +}; + +} // namespace WebKit + +#endif // ENABLE(DOM_STORAGE) + +#endif // WebStorageEventDispatcherImpl_h diff --git a/WebKit/chromium/src/WebStorageNamespaceImpl.cpp b/WebKit/chromium/src/WebStorageNamespaceImpl.cpp new file mode 100644 index 0000000..e6f6548 --- /dev/null +++ b/WebKit/chromium/src/WebStorageNamespaceImpl.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebStorageNamespaceImpl.h" + +#if ENABLE(DOM_STORAGE) + +#include "SecurityOrigin.h" + +#include "WebStorageAreaImpl.h" +#include "WebString.h" + +namespace WebKit { + +WebStorageNamespace* WebStorageNamespace::createLocalStorageNamespace(const WebString& path, unsigned quota) +{ + return new WebStorageNamespaceImpl(WebCore::StorageNamespaceImpl::localStorageNamespace(path, quota)); +} + +WebStorageNamespace* WebStorageNamespace::createSessionStorageNamespace() +{ + return new WebStorageNamespaceImpl(WebCore::StorageNamespaceImpl::sessionStorageNamespace()); +} + +WebStorageNamespaceImpl::WebStorageNamespaceImpl(PassRefPtr<WebCore::StorageNamespace> storageNamespace) + : m_storageNamespace(storageNamespace) +{ +} + +WebStorageNamespaceImpl::~WebStorageNamespaceImpl() +{ +} + +WebStorageArea* WebStorageNamespaceImpl::createStorageArea(const WebString& originString) +{ + WebCore::String originWebCoreString = originString; + if (originWebCoreString == "file://") { + // FIXME: We should really be passing around WebSecurityOrigin objects + // to represent security origins instead of strings. One issue + // with using strings is that createFromString(toString) does + // not round-trip for file URLs because file:// looks like a + // directory (which is sandboxed). + // + // For the time being, we work around this issue by using "file:///a", + // which does not look like a directory. We should fix this when + // jorlow gets back from vactation. + originWebCoreString = "file:///a"; + } + RefPtr<WebCore::SecurityOrigin> origin = WebCore::SecurityOrigin::createFromString(originWebCoreString); + return new WebStorageAreaImpl(m_storageNamespace->storageArea(origin.release())); +} + +WebStorageNamespace* WebStorageNamespaceImpl::copy() +{ + return new WebStorageNamespaceImpl(m_storageNamespace->copy()); +} + +void WebStorageNamespaceImpl::close() +{ + m_storageNamespace->close(); +} + +} // namespace WebKit + +#endif // ENABLE(DOM_STORAGE) diff --git a/WebKit/chromium/src/WebStorageNamespaceImpl.h b/WebKit/chromium/src/WebStorageNamespaceImpl.h new file mode 100644 index 0000000..4e82c21 --- /dev/null +++ b/WebKit/chromium/src/WebStorageNamespaceImpl.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebStorageNamespaceImpl_h +#define WebStorageNamespaceImpl_h + +#if ENABLE(DOM_STORAGE) + +#include "StorageNamespaceImpl.h" +#include "WebStorageNamespace.h" + +namespace WebKit { + +class WebStorageNamespaceImpl : public WebStorageNamespace { +public: + WebStorageNamespaceImpl(PassRefPtr<WebCore::StorageNamespace> storageNamespace); + virtual ~WebStorageNamespaceImpl(); + virtual WebStorageArea* createStorageArea(const WebString& origin); + virtual WebStorageNamespace* copy(); + virtual void close(); + +private: + RefPtr<WebCore::StorageNamespace> m_storageNamespace; +}; + +} // namespace WebKit + +#endif // ENABLE(DOM_STORAGE) + +#endif // WebStorageNamespaceImpl_h diff --git a/WebKit/chromium/src/WebString.cpp b/WebKit/chromium/src/WebString.cpp new file mode 100644 index 0000000..f45e05f --- /dev/null +++ b/WebKit/chromium/src/WebString.cpp @@ -0,0 +1,134 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebString.h" + +#include "AtomicString.h" +#include "CString.h" +#include "PlatformString.h" + +#include "WebCString.h" + +namespace WebKit { + +class WebStringPrivate : public WebCore::StringImpl { +}; + +void WebString::reset() +{ + if (m_private) { + m_private->deref(); + m_private = 0; + } +} + +void WebString::assign(const WebString& other) +{ + assign(const_cast<WebStringPrivate*>(other.m_private)); +} + +void WebString::assign(const WebUChar* data, size_t length) +{ + assign(static_cast<WebStringPrivate*>( + WebCore::StringImpl::create(data, length).get())); +} + +size_t WebString::length() const +{ + return m_private ? const_cast<WebStringPrivate*>(m_private)->length() : 0; +} + +const WebUChar* WebString::data() const +{ + return m_private ? const_cast<WebStringPrivate*>(m_private)->characters() : 0; +} + +WebCString WebString::utf8() const +{ + return WebCore::String(m_private).utf8(); +} + +WebString WebString::fromUTF8(const char* data, size_t length) +{ + return WebCore::String::fromUTF8(data, length); +} + +WebString WebString::fromUTF8(const char* data) +{ + return WebCore::String::fromUTF8(data); +} + +WebString::WebString(const WebCore::String& s) + : m_private(static_cast<WebStringPrivate*>(s.impl())) +{ + if (m_private) + m_private->ref(); +} + +WebString& WebString::operator=(const WebCore::String& s) +{ + assign(static_cast<WebStringPrivate*>(s.impl())); + return *this; +} + +WebString::operator WebCore::String() const +{ + return m_private; +} + +WebString::WebString(const WebCore::AtomicString& s) + : m_private(0) +{ + assign(s.string()); +} + +WebString& WebString::operator=(const WebCore::AtomicString& s) +{ + assign(s.string()); + return *this; +} + +WebString::operator WebCore::AtomicString() const +{ + return WebCore::AtomicString(static_cast<WebCore::StringImpl *>(m_private)); +} + +void WebString::assign(WebStringPrivate* p) +{ + // Take care to handle the case where m_private == p + if (p) + p->ref(); + if (m_private) + m_private->deref(); + m_private = p; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebURL.cpp b/WebKit/chromium/src/WebURL.cpp new file mode 100644 index 0000000..feb92c1 --- /dev/null +++ b/WebKit/chromium/src/WebURL.cpp @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebURL.h" + +#include "KURL.h" + +namespace WebKit { + +WebURL::WebURL(const WebCore::KURL& url) + : m_spec(url.utf8String()) + , m_parsed(url.parsed()) + , m_isValid(url.isValid()) +{ +} + +WebURL& WebURL::operator=(const WebCore::KURL& url) +{ + m_spec = url.utf8String(); + m_parsed = url.parsed(); + m_isValid = url.isValid(); + return *this; +} + +WebURL::operator WebCore::KURL() const +{ + return WebCore::KURL(m_spec, m_parsed, m_isValid); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebURLError.cpp b/WebKit/chromium/src/WebURLError.cpp new file mode 100644 index 0000000..a038aee --- /dev/null +++ b/WebKit/chromium/src/WebURLError.cpp @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebURLError.h" + +#include "CString.h" +#include "KURL.h" +#include "ResourceError.h" + +using namespace WebCore; + +namespace WebKit { + +WebURLError::WebURLError(const ResourceError& error) +{ + *this = error; +} + +WebURLError& WebURLError::operator=(const ResourceError& error) +{ + if (error.isNull()) + *this = WebURLError(); + else { + domain = error.domain(); + reason = error.errorCode(); + unreachableURL = KURL(ParsedURLString, error.failingURL()); + } + return *this; +} + +WebURLError::operator ResourceError() const +{ + if (!reason) + return ResourceError(); + CString spec = unreachableURL.spec(); + return ResourceError(domain, reason, + String::fromUTF8(spec.data(), spec.length()), + String()); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebURLRequest.cpp b/WebKit/chromium/src/WebURLRequest.cpp new file mode 100644 index 0000000..46fa842 --- /dev/null +++ b/WebKit/chromium/src/WebURLRequest.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebURLRequest.h" + +#include "ResourceRequest.h" + +#include "WebHTTPBody.h" +#include "WebHTTPHeaderVisitor.h" +#include "WebURL.h" +#include "WebURLRequestPrivate.h" + +using namespace WebCore; + +namespace WebKit { + +// The standard implementation of WebURLRequestPrivate, which maintains +// ownership of a ResourceRequest instance. +class WebURLRequestPrivateImpl : public WebURLRequestPrivate { +public: + WebURLRequestPrivateImpl() + { + m_resourceRequest = &m_resourceRequestAllocation; + } + + WebURLRequestPrivateImpl(const WebURLRequestPrivate* p) + : m_resourceRequestAllocation(*p->m_resourceRequest) + { + m_resourceRequest = &m_resourceRequestAllocation; + } + + virtual void dispose() { delete this; } + + ResourceRequest m_resourceRequestAllocation; +}; + +void WebURLRequest::initialize() +{ + assign(new WebURLRequestPrivateImpl()); +} + +void WebURLRequest::reset() +{ + assign(0); +} + +void WebURLRequest::assign(const WebURLRequest& r) +{ + if (&r != this) + assign(r.m_private ? new WebURLRequestPrivateImpl(r.m_private) : 0); +} + +bool WebURLRequest::isNull() const +{ + return !m_private || m_private->m_resourceRequest->isNull(); +} + +WebURL WebURLRequest::url() const +{ + return m_private->m_resourceRequest->url(); +} + +void WebURLRequest::setURL(const WebURL& url) +{ + m_private->m_resourceRequest->setURL(url); +} + +WebURL WebURLRequest::firstPartyForCookies() const +{ + return m_private->m_resourceRequest->firstPartyForCookies(); +} + +void WebURLRequest::setFirstPartyForCookies(const WebURL& firstPartyForCookies) +{ + m_private->m_resourceRequest->setFirstPartyForCookies(firstPartyForCookies); +} + +bool WebURLRequest::allowCookies() const +{ + return m_private->m_resourceRequest->allowCookies(); +} + +void WebURLRequest::setAllowCookies(bool allowCookies) +{ + m_private->m_resourceRequest->setAllowCookies(allowCookies); +} + +bool WebURLRequest::allowStoredCredentials() const +{ + return m_private->m_allowStoredCredentials; +} + +void WebURLRequest::setAllowStoredCredentials(bool allowStoredCredentials) +{ + m_private->m_allowStoredCredentials = allowStoredCredentials; +} + +WebURLRequest::CachePolicy WebURLRequest::cachePolicy() const +{ + return static_cast<WebURLRequest::CachePolicy>( + m_private->m_resourceRequest->cachePolicy()); +} + +void WebURLRequest::setCachePolicy(CachePolicy cachePolicy) +{ + m_private->m_resourceRequest->setCachePolicy( + static_cast<ResourceRequestCachePolicy>(cachePolicy)); +} + +WebString WebURLRequest::httpMethod() const +{ + return m_private->m_resourceRequest->httpMethod(); +} + +void WebURLRequest::setHTTPMethod(const WebString& httpMethod) +{ + m_private->m_resourceRequest->setHTTPMethod(httpMethod); +} + +WebString WebURLRequest::httpHeaderField(const WebString& name) const +{ + return m_private->m_resourceRequest->httpHeaderField(name); +} + +void WebURLRequest::setHTTPHeaderField(const WebString& name, const WebString& value) +{ + m_private->m_resourceRequest->setHTTPHeaderField(name, value); +} + +void WebURLRequest::addHTTPHeaderField(const WebString& name, const WebString& value) +{ + m_private->m_resourceRequest->addHTTPHeaderField(name, value); +} + +void WebURLRequest::clearHTTPHeaderField(const WebString& name) +{ + // FIXME: Add a clearHTTPHeaderField method to ResourceRequest. + const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields(); + const_cast<HTTPHeaderMap*>(&map)->remove(name); +} + +void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const +{ + const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields(); + for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it) + visitor->visitHeader(it->first, it->second); +} + +WebHTTPBody WebURLRequest::httpBody() const +{ + return WebHTTPBody(m_private->m_resourceRequest->httpBody()); +} + +void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody) +{ + m_private->m_resourceRequest->setHTTPBody(httpBody); +} + +bool WebURLRequest::reportUploadProgress() const +{ + return m_private->m_resourceRequest->reportUploadProgress(); +} + +void WebURLRequest::setReportUploadProgress(bool reportUploadProgress) +{ + m_private->m_resourceRequest->setReportUploadProgress(reportUploadProgress); +} + +WebURLRequest::TargetType WebURLRequest::targetType() const +{ + return static_cast<TargetType>(m_private->m_resourceRequest->targetType()); +} + +void WebURLRequest::setTargetType(TargetType targetType) +{ + m_private->m_resourceRequest->setTargetType( + static_cast<ResourceRequest::TargetType>(targetType)); +} + +int WebURLRequest::requestorID() const +{ + return m_private->m_resourceRequest->requestorID(); +} + +void WebURLRequest::setRequestorID(int requestorID) +{ + m_private->m_resourceRequest->setRequestorID(requestorID); +} + +int WebURLRequest::requestorProcessID() const +{ + return m_private->m_resourceRequest->requestorProcessID(); +} + +void WebURLRequest::setRequestorProcessID(int requestorProcessID) +{ + m_private->m_resourceRequest->setRequestorProcessID(requestorProcessID); +} + +int WebURLRequest::appCacheHostID() const +{ + return m_private->m_resourceRequest->appCacheHostID(); +} + +void WebURLRequest::setAppCacheHostID(int appCacheHostID) +{ + m_private->m_resourceRequest->setAppCacheHostID(appCacheHostID); +} + +ResourceRequest& WebURLRequest::toMutableResourceRequest() +{ + ASSERT(m_private); + ASSERT(m_private->m_resourceRequest); + + return *m_private->m_resourceRequest; +} + +const ResourceRequest& WebURLRequest::toResourceRequest() const +{ + ASSERT(m_private); + ASSERT(m_private->m_resourceRequest); + + return *m_private->m_resourceRequest; +} + +void WebURLRequest::assign(WebURLRequestPrivate* p) +{ + // Subclasses may call this directly so a self-assignment check is needed + // here as well as in the public assign method. + if (m_private == p) + return; + if (m_private) + m_private->dispose(); + m_private = p; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebURLRequestPrivate.h b/WebKit/chromium/src/WebURLRequestPrivate.h new file mode 100644 index 0000000..2f7c25f --- /dev/null +++ b/WebKit/chromium/src/WebURLRequestPrivate.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebURLRequestPrivate_h +#define WebURLRequestPrivate_h + +namespace WebCore { class ResourceRequest; } + +namespace WebKit { + +class WebURLRequestPrivate { +public: + WebURLRequestPrivate() : m_resourceRequest(0), m_allowStoredCredentials(true) { } + + // Called by WebURLRequest when it no longer needs this object. + virtual void dispose() = 0; + + WebCore::ResourceRequest* m_resourceRequest; + bool m_allowStoredCredentials; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebURLResponse.cpp b/WebKit/chromium/src/WebURLResponse.cpp new file mode 100644 index 0000000..49f07f9 --- /dev/null +++ b/WebKit/chromium/src/WebURLResponse.cpp @@ -0,0 +1,269 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebURLResponse.h" + +#include "ResourceResponse.h" + +#include "WebHTTPHeaderVisitor.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebURLResponsePrivate.h" + +using namespace WebCore; + +namespace WebKit { + +// The standard implementation of WebURLResponsePrivate, which maintains +// ownership of a ResourceResponse instance. +class WebURLResponsePrivateImpl : public WebURLResponsePrivate { +public: + WebURLResponsePrivateImpl() + { + m_resourceResponse = &m_resourceResponseAllocation; + } + + WebURLResponsePrivateImpl(const WebURLResponsePrivate* p) + : m_resourceResponseAllocation(*p->m_resourceResponse) + { + m_resourceResponse = &m_resourceResponseAllocation; + } + + virtual void dispose() { delete this; } + + ResourceResponse m_resourceResponseAllocation; +}; + +void WebURLResponse::initialize() +{ + assign(new WebURLResponsePrivateImpl()); +} + +void WebURLResponse::reset() +{ + assign(0); +} + +void WebURLResponse::assign(const WebURLResponse& r) +{ + if (&r != this) + assign(r.m_private ? new WebURLResponsePrivateImpl(r.m_private) : 0); +} + +bool WebURLResponse::isNull() const +{ + return !m_private || m_private->m_resourceResponse->isNull(); +} + +WebURL WebURLResponse::url() const +{ + return m_private->m_resourceResponse->url(); +} + +void WebURLResponse::setURL(const WebURL& url) +{ + m_private->m_resourceResponse->setURL(url); +} + +WebString WebURLResponse::mimeType() const +{ + return m_private->m_resourceResponse->mimeType(); +} + +void WebURLResponse::setMIMEType(const WebString& mimeType) +{ + m_private->m_resourceResponse->setMimeType(mimeType); +} + +long long WebURLResponse::expectedContentLength() const +{ + return m_private->m_resourceResponse->expectedContentLength(); +} + +void WebURLResponse::setExpectedContentLength(long long expectedContentLength) +{ + m_private->m_resourceResponse->setExpectedContentLength(expectedContentLength); +} + +WebString WebURLResponse::textEncodingName() const +{ + return m_private->m_resourceResponse->textEncodingName(); +} + +void WebURLResponse::setTextEncodingName(const WebString& textEncodingName) +{ + m_private->m_resourceResponse->setTextEncodingName(textEncodingName); +} + +WebString WebURLResponse::suggestedFileName() const +{ + return m_private->m_resourceResponse->suggestedFilename(); +} + +void WebURLResponse::setSuggestedFileName(const WebString& suggestedFileName) +{ + m_private->m_resourceResponse->setSuggestedFilename(suggestedFileName); +} + +int WebURLResponse::httpStatusCode() const +{ + return m_private->m_resourceResponse->httpStatusCode(); +} + +void WebURLResponse::setHTTPStatusCode(int httpStatusCode) +{ + m_private->m_resourceResponse->setHTTPStatusCode(httpStatusCode); +} + +WebString WebURLResponse::httpStatusText() const +{ + return m_private->m_resourceResponse->httpStatusText(); +} + +void WebURLResponse::setHTTPStatusText(const WebString& httpStatusText) +{ + m_private->m_resourceResponse->setHTTPStatusText(httpStatusText); +} + +WebString WebURLResponse::httpHeaderField(const WebString& name) const +{ + return m_private->m_resourceResponse->httpHeaderField(name); +} + +void WebURLResponse::setHTTPHeaderField(const WebString& name, const WebString& value) +{ + m_private->m_resourceResponse->setHTTPHeaderField(name, value); +} + +void WebURLResponse::addHTTPHeaderField(const WebString& name, const WebString& value) +{ + // FIXME: Add an addHTTPHeaderField method to ResourceResponse. + const HTTPHeaderMap& map = m_private->m_resourceResponse->httpHeaderFields(); + String valueStr(value); + pair<HTTPHeaderMap::iterator, bool> result = + const_cast<HTTPHeaderMap*>(&map)->add(name, valueStr); + if (!result.second) + result.first->second += ", " + valueStr; +} + +void WebURLResponse::clearHTTPHeaderField(const WebString& name) +{ + // FIXME: Add a clearHTTPHeaderField method to ResourceResponse. + const HTTPHeaderMap& map = m_private->m_resourceResponse->httpHeaderFields(); + const_cast<HTTPHeaderMap*>(&map)->remove(name); +} + +void WebURLResponse::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const +{ + const HTTPHeaderMap& map = m_private->m_resourceResponse->httpHeaderFields(); + for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it) + visitor->visitHeader(it->first, it->second); +} + +double WebURLResponse::lastModifiedDate() const +{ + return static_cast<double>(m_private->m_resourceResponse->lastModifiedDate()); +} + +void WebURLResponse::setLastModifiedDate(double lastModifiedDate) +{ + m_private->m_resourceResponse->setLastModifiedDate(static_cast<time_t>(lastModifiedDate)); +} + +bool WebURLResponse::isContentFiltered() const +{ + return m_private->m_resourceResponse->isContentFiltered(); +} + +void WebURLResponse::setIsContentFiltered(bool isContentFiltered) +{ + m_private->m_resourceResponse->setIsContentFiltered(isContentFiltered); +} + +long long WebURLResponse::appCacheID() const +{ + return m_private->m_resourceResponse->appCacheID(); +} + +void WebURLResponse::setAppCacheID(long long appCacheID) +{ + m_private->m_resourceResponse->setAppCacheID(appCacheID); +} + +WebURL WebURLResponse::appCacheManifestURL() const +{ + return m_private->m_resourceResponse->appCacheManifestURL(); +} + +void WebURLResponse::setAppCacheManifestURL(const WebURL& url) +{ + m_private->m_resourceResponse->setAppCacheManifestURL(url); +} + +WebCString WebURLResponse::securityInfo() const +{ + // FIXME: getSecurityInfo is misnamed. + return m_private->m_resourceResponse->getSecurityInfo(); +} + +void WebURLResponse::setSecurityInfo(const WebCString& securityInfo) +{ + m_private->m_resourceResponse->setSecurityInfo(securityInfo); +} + +ResourceResponse& WebURLResponse::toMutableResourceResponse() +{ + ASSERT(m_private); + ASSERT(m_private->m_resourceResponse); + + return *m_private->m_resourceResponse; +} + +const ResourceResponse& WebURLResponse::toResourceResponse() const +{ + ASSERT(m_private); + ASSERT(m_private->m_resourceResponse); + + return *m_private->m_resourceResponse; +} + +void WebURLResponse::assign(WebURLResponsePrivate* p) +{ + // Subclasses may call this directly so a self-assignment check is needed + // here as well as in the public assign method. + if (m_private == p) + return; + if (m_private) + m_private->dispose(); + m_private = p; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebURLResponsePrivate.h b/WebKit/chromium/src/WebURLResponsePrivate.h new file mode 100644 index 0000000..716c8db --- /dev/null +++ b/WebKit/chromium/src/WebURLResponsePrivate.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebURLResponsePrivate_h +#define WebURLResponsePrivate_h + +namespace WebCore { class ResourceResponse; } + +namespace WebKit { + +class WebURLResponsePrivate { +public: + WebURLResponsePrivate() : m_resourceResponse(0) { } + + // Called by WebURLResponse when it no longer needs this object. + virtual void dispose() = 0; + + WebCore::ResourceResponse* m_resourceResponse; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebViewImpl.cpp b/WebKit/chromium/src/WebViewImpl.cpp new file mode 100644 index 0000000..357cdca --- /dev/null +++ b/WebKit/chromium/src/WebViewImpl.cpp @@ -0,0 +1,1798 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebViewImpl.h" + +#include "AutocompletePopupMenuClient.h" +#include "AXObjectCache.h" +#include "ContextMenu.h" +#include "ContextMenuController.h" +#include "ContextMenuItem.h" +#include "CSSStyleSelector.h" +#include "CSSValueKeywords.h" +#include "Cursor.h" +#include "Document.h" +#include "DocumentLoader.h" +#include "DOMUtilitiesPrivate.h" +#include "DragController.h" +#include "DragData.h" +#include "Editor.h" +#include "EventHandler.h" +#include "FocusController.h" +#include "FontDescription.h" +#include "FrameLoader.h" +#include "FrameTree.h" +#include "FrameView.h" +#include "GraphicsContext.h" +#include "HitTestResult.h" +#include "HTMLInputElement.h" +#include "HTMLMediaElement.h" +#include "HTMLNames.h" +#include "Image.h" +#include "InspectorController.h" +#include "IntRect.h" +#include "KeyboardCodes.h" +#include "KeyboardEvent.h" +#include "MIMETypeRegistry.h" +#include "NodeRenderStyle.h" +#include "Page.h" +#include "PageGroup.h" +#include "Pasteboard.h" +#include "PlatformContextSkia.h" +#include "PlatformKeyboardEvent.h" +#include "PlatformMouseEvent.h" +#include "PlatformWheelEvent.h" +#include "PluginInfoStore.h" +#include "PopupMenuChromium.h" +#include "PopupMenuClient.h" +#include "ProgressTracker.h" +#include "RenderView.h" +#include "ResourceHandle.h" +#include "SecurityOrigin.h" +#include "SelectionController.h" +#include "Settings.h" +#include "TypingCommand.h" +#include "WebAccessibilityObject.h" +#include "WebDevToolsAgentPrivate.h" +#include "WebDragData.h" +#include "WebFrameImpl.h" +#include "WebInputEvent.h" +#include "WebInputEventConversion.h" +#include "WebMediaPlayerAction.h" +#include "WebNode.h" +#include "WebPoint.h" +#include "WebPopupMenuImpl.h" +#include "WebRect.h" +#include "WebSettingsImpl.h" +#include "WebString.h" +#include "WebVector.h" +#include "WebViewClient.h" + +#if PLATFORM(WIN_OS) +#include "KeyboardCodesWin.h" +#include "RenderThemeChromiumWin.h" +#else +#if PLATFORM(LINUX) +#include "RenderThemeChromiumLinux.h" +#endif +#include "KeyboardCodesPosix.h" +#include "RenderTheme.h" +#endif + +// Get rid of WTF's pow define so we can use std::pow. +#undef pow +#include <cmath> // for std::pow + +using namespace WebCore; + +namespace WebKit { + +// Change the text zoom level by kTextSizeMultiplierRatio each time the user +// zooms text in or out (ie., change by 20%). The min and max values limit +// text zoom to half and 3x the original text size. These three values match +// those in Apple's port in WebKit/WebKit/WebView/WebView.mm +static const double textSizeMultiplierRatio = 1.2; +static const double minTextSizeMultiplier = 0.5; +static const double maxTextSizeMultiplier = 3.0; + +// The group name identifies a namespace of pages. Page group is used on OSX +// for some programs that use HTML views to display things that don't seem like +// web pages to the user (so shouldn't have visited link coloring). We only use +// one page group. +const char* pageGroupName = "default"; + +// Ensure that the WebDragOperation enum values stay in sync with the original +// DragOperation constants. +#define COMPILE_ASSERT_MATCHING_ENUM(coreName) \ + COMPILE_ASSERT(int(coreName) == int(Web##coreName), dummy##coreName) +COMPILE_ASSERT_MATCHING_ENUM(DragOperationNone); +COMPILE_ASSERT_MATCHING_ENUM(DragOperationCopy); +COMPILE_ASSERT_MATCHING_ENUM(DragOperationLink); +COMPILE_ASSERT_MATCHING_ENUM(DragOperationGeneric); +COMPILE_ASSERT_MATCHING_ENUM(DragOperationPrivate); +COMPILE_ASSERT_MATCHING_ENUM(DragOperationMove); +COMPILE_ASSERT_MATCHING_ENUM(DragOperationDelete); +COMPILE_ASSERT_MATCHING_ENUM(DragOperationEvery); + +// Note that focusOnShow is false so that the autocomplete popup is shown not +// activated. We need the page to still have focus so the user can keep typing +// while the popup is showing. +static const PopupContainerSettings autocompletePopupSettings = { + false, // focusOnShow + false, // setTextOnIndexChange + false, // acceptOnAbandon + true, // loopSelectionNavigation + true, // restrictWidthOfListBox. Same as other browser (Fx, IE, and safari) + // For autocomplete, we use the direction of the input field as the direction + // of the popup items. The main reason is to keep the display of items in + // drop-down the same as the items in the input field. + PopupContainerSettings::DOMElementDirection, +}; + +// WebView ---------------------------------------------------------------- + +WebView* WebView::create(WebViewClient* client) +{ + return new WebViewImpl(client); +} + +void WebView::updateVisitedLinkState(unsigned long long linkHash) +{ + Page::visitedStateChanged(PageGroup::pageGroup(pageGroupName), linkHash); +} + +void WebView::resetVisitedLinkState() +{ + Page::allVisitedStateChanged(PageGroup::pageGroup(pageGroupName)); +} + +void WebViewImpl::initializeMainFrame(WebFrameClient* frameClient) +{ + // NOTE: The WebFrameImpl takes a reference to itself within InitMainFrame + // and releases that reference once the corresponding Frame is destroyed. + RefPtr<WebFrameImpl> frame = WebFrameImpl::create(frameClient); + + frame->initializeAsMainFrame(this); + + // Restrict the access to the local file system + // (see WebView.mm WebView::_commonInitializationWithFrameName). + SecurityOrigin::setLocalLoadPolicy(SecurityOrigin::AllowLocalLoadsForLocalOnly); +} + +WebViewImpl::WebViewImpl(WebViewClient* client) + : m_client(client) + , m_backForwardListClientImpl(this) + , m_chromeClientImpl(this) + , m_contextMenuClientImpl(this) + , m_dragClientImpl(this) + , m_editorClientImpl(this) + , m_inspectorClientImpl(this) + , m_observedNewNavigation(false) +#ifndef NDEBUG + , m_newNavigationLoader(0) +#endif + , m_zoomLevel(0) + , m_contextMenuAllowed(false) + , m_doingDragAndDrop(false) + , m_ignoreInputEvents(false) + , m_suppressNextKeypressEvent(false) + , m_initialNavigationPolicy(WebNavigationPolicyIgnore) + , m_imeAcceptEvents(true) + , m_dragTargetDispatch(false) + , m_dragIdentity(0) + , m_dropEffect(DropEffectDefault) + , m_operationsAllowed(WebDragOperationNone) + , m_dragOperation(WebDragOperationNone) + , m_autocompletePopupShowing(false) + , m_isTransparent(false) + , m_tabsToLinks(false) +{ + // WebKit/win/WebView.cpp does the same thing, except they call the + // KJS specific wrapper around this method. We need to have threading + // initialized because CollatorICU requires it. + WTF::initializeThreading(); + + // set to impossible point so we always get the first mouse pos + m_lastMousePosition = WebPoint(-1, -1); + + // the page will take ownership of the various clients + m_page.set(new Page(&m_chromeClientImpl, + &m_contextMenuClientImpl, + &m_editorClientImpl, + &m_dragClientImpl, + &m_inspectorClientImpl, + 0)); + + m_page->backForwardList()->setClient(&m_backForwardListClientImpl); + m_page->setGroupName(pageGroupName); +} + +WebViewImpl::~WebViewImpl() +{ + ASSERT(!m_page); +} + +RenderTheme* WebViewImpl::theme() const +{ + return m_page.get() ? m_page->theme() : RenderTheme::defaultTheme().get(); +} + +WebFrameImpl* WebViewImpl::mainFrameImpl() +{ + return m_page.get() ? WebFrameImpl::fromFrame(m_page->mainFrame()) : 0; +} + +bool WebViewImpl::tabKeyCyclesThroughElements() const +{ + ASSERT(m_page.get()); + return m_page->tabKeyCyclesThroughElements(); +} + +void WebViewImpl::setTabKeyCyclesThroughElements(bool value) +{ + if (m_page) + m_page->setTabKeyCyclesThroughElements(value); +} + +void WebViewImpl::mouseMove(const WebMouseEvent& event) +{ + if (!mainFrameImpl() || !mainFrameImpl()->frameView()) + return; + + m_lastMousePosition = WebPoint(event.x, event.y); + + // We call mouseMoved here instead of handleMouseMovedEvent because we need + // our ChromeClientImpl to receive changes to the mouse position and + // tooltip text, and mouseMoved handles all of that. + mainFrameImpl()->frame()->eventHandler()->mouseMoved( + PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event)); +} + +void WebViewImpl::mouseLeave(const WebMouseEvent& event) +{ + // This event gets sent as the main frame is closing. In that case, just + // ignore it. + if (!mainFrameImpl() || !mainFrameImpl()->frameView()) + return; + + m_client->setMouseOverURL(WebURL()); + + mainFrameImpl()->frame()->eventHandler()->handleMouseMoveEvent( + PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event)); +} + +void WebViewImpl::mouseDown(const WebMouseEvent& event) +{ + if (!mainFrameImpl() || !mainFrameImpl()->frameView()) + return; + + m_lastMouseDownPoint = WebPoint(event.x, event.y); + + // If a text field that has focus is clicked again, we should display the + // autocomplete popup. + RefPtr<Node> clickedNode; + if (event.button == WebMouseEvent::ButtonLeft) { + RefPtr<Node> focusedNode = focusedWebCoreNode(); + if (focusedNode.get() && toHTMLInputElement(focusedNode.get())) { + IntPoint point(event.x, event.y); + point = m_page->mainFrame()->view()->windowToContents(point); + HitTestResult result(point); + result = m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(point, false); + if (result.innerNonSharedNode() == focusedNode) { + // Already focused text field was clicked, let's remember this. If + // focus has not changed after the mouse event is processed, we'll + // trigger the autocomplete. + clickedNode = focusedNode; + } + } + } + + mainFrameImpl()->frame()->eventHandler()->handleMousePressEvent( + PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event)); + + if (clickedNode.get() && clickedNode == focusedWebCoreNode()) { + // Focus has not changed, show the autocomplete popup. + static_cast<EditorClientImpl*>(m_page->editorClient())-> + showFormAutofillForNode(clickedNode.get()); + } + + // Dispatch the contextmenu event regardless of if the click was swallowed. + // On Windows, we handle it on mouse up, not down. +#if PLATFORM(DARWIN) + if (event.button == WebMouseEvent::ButtonRight + || (event.button == WebMouseEvent::ButtonLeft + && event.modifiers & WebMouseEvent::ControlKey)) + mouseContextMenu(event); +#elif PLATFORM(LINUX) + if (event.button == WebMouseEvent::ButtonRight) + mouseContextMenu(event); +#endif +} + +void WebViewImpl::mouseContextMenu(const WebMouseEvent& event) +{ + if (!mainFrameImpl() || !mainFrameImpl()->frameView()) + return; + + m_page->contextMenuController()->clearContextMenu(); + + PlatformMouseEventBuilder pme(mainFrameImpl()->frameView(), event); + + // Find the right target frame. See issue 1186900. + HitTestResult result = hitTestResultForWindowPos(pme.pos()); + Frame* targetFrame; + if (result.innerNonSharedNode()) + targetFrame = result.innerNonSharedNode()->document()->frame(); + else + targetFrame = m_page->focusController()->focusedOrMainFrame(); + +#if PLATFORM(WIN_OS) + targetFrame->view()->setCursor(pointerCursor()); +#endif + + m_contextMenuAllowed = true; + targetFrame->eventHandler()->sendContextMenuEvent(pme); + m_contextMenuAllowed = false; + // Actually showing the context menu is handled by the ContextMenuClient + // implementation... +} + +void WebViewImpl::mouseUp(const WebMouseEvent& event) +{ + if (!mainFrameImpl() || !mainFrameImpl()->frameView()) + return; + +#if PLATFORM(LINUX) + // If the event was a middle click, attempt to copy text into the focused + // frame. We execute this before we let the page have a go at the event + // because the page may change what is focused during in its event handler. + // + // This code is in the mouse up handler. There is some debate about putting + // this here, as opposed to the mouse down handler. + // xterm: pastes on up. + // GTK: pastes on down. + // Firefox: pastes on up. + // Midori: couldn't paste at all with 0.1.2 + // + // There is something of a webcompat angle to this well, as highlighted by + // crbug.com/14608. Pages can clear text boxes 'onclick' and, if we paste on + // down then the text is pasted just before the onclick handler runs and + // clears the text box. So it's important this happens after the + // handleMouseReleaseEvent() earlier in this function + if (event.button == WebMouseEvent::ButtonMiddle) { + Frame* focused = focusedWebCoreFrame(); + IntPoint clickPoint(m_lastMouseDownPoint.x, m_lastMouseDownPoint.y); + clickPoint = m_page->mainFrame()->view()->windowToContents(clickPoint); + HitTestResult hitTestResult = + focused->eventHandler()->hitTestResultAtPoint(clickPoint, false, false, + ShouldHitTestScrollbars); + // We don't want to send a paste when middle clicking a scroll bar or a + // link (which will navigate later in the code). + if (!hitTestResult.scrollbar() && !hitTestResult.isLiveLink() && focused) { + Editor* editor = focused->editor(); + Pasteboard* pasteboard = Pasteboard::generalPasteboard(); + bool oldSelectionMode = pasteboard->isSelectionMode(); + pasteboard->setSelectionMode(true); + editor->command(AtomicString("Paste")).execute(); + pasteboard->setSelectionMode(oldSelectionMode); + } + } +#endif + + mouseCaptureLost(); + mainFrameImpl()->frame()->eventHandler()->handleMouseReleaseEvent( + PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event)); + +#if PLATFORM(WIN_OS) + // Dispatch the contextmenu event regardless of if the click was swallowed. + // On Mac/Linux, we handle it on mouse down, not up. + if (event.button == WebMouseEvent::ButtonRight) + mouseContextMenu(event); +#endif +} + +void WebViewImpl::mouseWheel(const WebMouseWheelEvent& event) +{ + PlatformWheelEventBuilder platformEvent(mainFrameImpl()->frameView(), event); + mainFrameImpl()->frame()->eventHandler()->handleWheelEvent(platformEvent); +} + +bool WebViewImpl::keyEvent(const WebKeyboardEvent& event) +{ + ASSERT((event.type == WebInputEvent::RawKeyDown) + || (event.type == WebInputEvent::KeyDown) + || (event.type == WebInputEvent::KeyUp)); + + // Please refer to the comments explaining the m_suppressNextKeypressEvent + // member. + // The m_suppressNextKeypressEvent is set if the KeyDown is handled by + // Webkit. A keyDown event is typically associated with a keyPress(char) + // event and a keyUp event. We reset this flag here as this is a new keyDown + // event. + m_suppressNextKeypressEvent = false; + + // Give autocomplete a chance to consume the key events it is interested in. + if (autocompleteHandleKeyEvent(event)) + return true; + + Frame* frame = focusedWebCoreFrame(); + if (!frame) + return false; + + EventHandler* handler = frame->eventHandler(); + if (!handler) + return keyEventDefault(event); + +#if PLATFORM(WIN_OS) || PLATFORM(LINUX) + if ((!event.modifiers && (event.windowsKeyCode == VKEY_APPS)) + || ((event.modifiers == WebInputEvent::ShiftKey) && (event.windowsKeyCode == VKEY_F10))) { + sendContextMenuEvent(event); + return true; + } +#endif + + // It's not clear if we should continue after detecting a capslock keypress. + // I'll err on the side of continuing, which is the pre-existing behaviour. + if (event.windowsKeyCode == VKEY_CAPITAL) + handler->capsLockStateMayHaveChanged(); + + PlatformKeyboardEventBuilder evt(event); + + if (handler->keyEvent(evt)) { + if (WebInputEvent::RawKeyDown == event.type) + m_suppressNextKeypressEvent = true; + return true; + } + + return keyEventDefault(event); +} + +bool WebViewImpl::autocompleteHandleKeyEvent(const WebKeyboardEvent& event) +{ + if (!m_autocompletePopupShowing + // Home and End should be left to the text field to process. + || event.windowsKeyCode == VKEY_HOME + || event.windowsKeyCode == VKEY_END) + return false; + + // Pressing delete triggers the removal of the selected suggestion from the DB. + if (event.windowsKeyCode == VKEY_DELETE + && m_autocompletePopup->selectedIndex() != -1) { + Node* node = focusedWebCoreNode(); + if (!node || (node->nodeType() != Node::ELEMENT_NODE)) { + ASSERT_NOT_REACHED(); + return false; + } + Element* element = static_cast<Element*>(node); + if (!element->hasLocalName(HTMLNames::inputTag)) { + ASSERT_NOT_REACHED(); + return false; + } + + int selectedIndex = m_autocompletePopup->selectedIndex(); + HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(element); + WebString name = inputElement->name(); + WebString value = m_autocompletePopupClient->itemText(selectedIndex); + m_client->removeAutofillSuggestions(name, value); + // Update the entries in the currently showing popup to reflect the + // deletion. + m_autocompletePopupClient->removeItemAtIndex(selectedIndex); + refreshAutofillPopup(); + return false; + } + + if (!m_autocompletePopup->isInterestedInEventForKey(event.windowsKeyCode)) + return false; + + if (m_autocompletePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event))) { + // We need to ignore the next Char event after this otherwise pressing + // enter when selecting an item in the menu will go to the page. + if (WebInputEvent::RawKeyDown == event.type) + m_suppressNextKeypressEvent = true; + return true; + } + + return false; +} + +bool WebViewImpl::charEvent(const WebKeyboardEvent& event) +{ + ASSERT(event.type == WebInputEvent::Char); + + // Please refer to the comments explaining the m_suppressNextKeypressEvent + // member. The m_suppressNextKeypressEvent is set if the KeyDown is + // handled by Webkit. A keyDown event is typically associated with a + // keyPress(char) event and a keyUp event. We reset this flag here as it + // only applies to the current keyPress event. + bool suppress = m_suppressNextKeypressEvent; + m_suppressNextKeypressEvent = false; + + Frame* frame = focusedWebCoreFrame(); + if (!frame) + return suppress; + + EventHandler* handler = frame->eventHandler(); + if (!handler) + return suppress || keyEventDefault(event); + + PlatformKeyboardEventBuilder evt(event); + if (!evt.isCharacterKey()) + return true; + + // Accesskeys are triggered by char events and can't be suppressed. + if (handler->handleAccessKey(evt)) + return true; + + // Safari 3.1 does not pass off windows system key messages (WM_SYSCHAR) to + // the eventHandler::keyEvent. We mimic this behavior on all platforms since + // for now we are converting other platform's key events to windows key + // events. + if (evt.isSystemKey()) + return false; + + if (!suppress && !handler->keyEvent(evt)) + return keyEventDefault(event); + + return true; +} + +// The WebViewImpl::SendContextMenuEvent function is based on the Webkit +// function +// bool WebView::handleContextMenuEvent(WPARAM wParam, LPARAM lParam) in +// webkit\webkit\win\WebView.cpp. The only significant change in this +// function is the code to convert from a Keyboard event to the Right +// Mouse button up event. +// +// This function is an ugly copy/paste and should be cleaned up when the +// WebKitWin version is cleaned: https://bugs.webkit.org/show_bug.cgi?id=20438 +#if PLATFORM(WIN_OS) || PLATFORM(LINUX) +// FIXME: implement on Mac +bool WebViewImpl::sendContextMenuEvent(const WebKeyboardEvent& event) +{ + static const int kContextMenuMargin = 1; + Frame* mainFrameImpl = page()->mainFrame(); + FrameView* view = mainFrameImpl->view(); + if (!view) + return false; + + IntPoint coords(-1, -1); +#if PLATFORM(WIN_OS) + int rightAligned = ::GetSystemMetrics(SM_MENUDROPALIGNMENT); +#else + int rightAligned = 0; +#endif + IntPoint location; + + // The context menu event was generated from the keyboard, so show the + // context menu by the current selection. + Position start = mainFrameImpl->selection()->selection().start(); + Position end = mainFrameImpl->selection()->selection().end(); + + Frame* focusedFrame = page()->focusController()->focusedOrMainFrame(); + Node* focusedNode = focusedFrame->document()->focusedNode(); + + if (start.node() && end.node()) { + RenderObject* renderer = start.node()->renderer(); + if (!renderer) + return false; + + RefPtr<Range> selection = mainFrameImpl->selection()->toNormalizedRange(); + IntRect firstRect = mainFrameImpl->firstRectForRange(selection.get()); + + int x = rightAligned ? firstRect.right() : firstRect.x(); + location = IntPoint(x, firstRect.bottom()); + } else if (focusedNode) + location = focusedNode->getRect().bottomLeft(); + else { + location = IntPoint( + rightAligned ? view->contentsWidth() - kContextMenuMargin : kContextMenuMargin, + kContextMenuMargin); + } + + location = view->contentsToWindow(location); + // FIXME: The IntSize(0, -1) is a hack to get the hit-testing to result in + // the selected element. Ideally we'd have the position of a context menu + // event be separate from its target node. + coords = location + IntSize(0, -1); + + // The contextMenuController() holds onto the last context menu that was + // popped up on the page until a new one is created. We need to clear + // this menu before propagating the event through the DOM so that we can + // detect if we create a new menu for this event, since we won't create + // a new menu if the DOM swallows the event and the defaultEventHandler does + // not run. + page()->contextMenuController()->clearContextMenu(); + + focusedFrame->view()->setCursor(pointerCursor()); + WebMouseEvent mouseEvent; + mouseEvent.button = WebMouseEvent::ButtonRight; + mouseEvent.x = coords.x(); + mouseEvent.y = coords.y(); + mouseEvent.type = WebInputEvent::MouseUp; + + PlatformMouseEventBuilder platformEvent(view, mouseEvent); + + m_contextMenuAllowed = true; + bool handled = focusedFrame->eventHandler()->sendContextMenuEvent(platformEvent); + m_contextMenuAllowed = false; + return handled; +} +#endif + +bool WebViewImpl::keyEventDefault(const WebKeyboardEvent& event) +{ + Frame* frame = focusedWebCoreFrame(); + if (!frame) + return false; + + switch (event.type) { + case WebInputEvent::Char: + if (event.windowsKeyCode == VKEY_SPACE) { + int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR : VKEY_NEXT); + return scrollViewWithKeyboard(keyCode, event.modifiers); + } + break; + case WebInputEvent::RawKeyDown: + if (event.modifiers == WebInputEvent::ControlKey) { + switch (event.windowsKeyCode) { + case 'A': + focusedFrame()->executeCommand(WebString::fromUTF8("SelectAll")); + return true; + case VKEY_INSERT: + case 'C': + focusedFrame()->executeCommand(WebString::fromUTF8("Copy")); + return true; + // Match FF behavior in the sense that Ctrl+home/end are the only Ctrl + // key combinations which affect scrolling. Safari is buggy in the + // sense that it scrolls the page for all Ctrl+scrolling key + // combinations. For e.g. Ctrl+pgup/pgdn/up/down, etc. + case VKEY_HOME: + case VKEY_END: + break; + default: + return false; + } + } + if (!event.isSystemKey && !(event.modifiers & WebInputEvent::ShiftKey)) + return scrollViewWithKeyboard(event.windowsKeyCode, event.modifiers); + break; + default: + break; + } + return false; +} + +bool WebViewImpl::scrollViewWithKeyboard(int keyCode, int modifiers) +{ + ScrollDirection scrollDirection; + ScrollGranularity scrollGranularity; + + switch (keyCode) { + case VKEY_LEFT: + scrollDirection = ScrollLeft; + scrollGranularity = ScrollByLine; + break; + case VKEY_RIGHT: + scrollDirection = ScrollRight; + scrollGranularity = ScrollByLine; + break; + case VKEY_UP: + scrollDirection = ScrollUp; + scrollGranularity = ScrollByLine; + break; + case VKEY_DOWN: + scrollDirection = ScrollDown; + scrollGranularity = ScrollByLine; + break; + case VKEY_HOME: + scrollDirection = ScrollUp; + scrollGranularity = ScrollByDocument; + break; + case VKEY_END: + scrollDirection = ScrollDown; + scrollGranularity = ScrollByDocument; + break; + case VKEY_PRIOR: // page up + scrollDirection = ScrollUp; + scrollGranularity = ScrollByPage; + break; + case VKEY_NEXT: // page down + scrollDirection = ScrollDown; + scrollGranularity = ScrollByPage; + break; + default: + return false; + } + + return propagateScroll(scrollDirection, scrollGranularity); +} + +bool WebViewImpl::propagateScroll(ScrollDirection scrollDirection, + ScrollGranularity scrollGranularity) +{ + Frame* frame = focusedWebCoreFrame(); + if (!frame) + return false; + + bool scrollHandled = + frame->eventHandler()->scrollOverflow(scrollDirection, + scrollGranularity); + Frame* currentFrame = frame; + while (!scrollHandled && currentFrame) { + scrollHandled = currentFrame->view()->scroll(scrollDirection, + scrollGranularity); + currentFrame = currentFrame->tree()->parent(); + } + return scrollHandled; +} + +Frame* WebViewImpl::focusedWebCoreFrame() +{ + return m_page.get() ? m_page->focusController()->focusedOrMainFrame() : 0; +} + +WebViewImpl* WebViewImpl::fromPage(Page* page) +{ + if (!page) + return 0; + + return static_cast<ChromeClientImpl*>(page->chrome()->client())->webView(); +} + +// WebWidget ------------------------------------------------------------------ + +void WebViewImpl::close() +{ + RefPtr<WebFrameImpl> mainFrameImpl; + + if (m_page.get()) { + // Initiate shutdown for the entire frameset. This will cause a lot of + // notifications to be sent. + if (m_page->mainFrame()) { + mainFrameImpl = WebFrameImpl::fromFrame(m_page->mainFrame()); + m_page->mainFrame()->loader()->frameDetached(); + } + m_page.clear(); + } + + // Should happen after m_page.clear(). + if (m_devToolsAgent.get()) + m_devToolsAgent.clear(); + + // Reset the delegate to prevent notifications being sent as we're being + // deleted. + m_client = 0; + + deref(); // Balances ref() acquired in WebView::create +} + +void WebViewImpl::resize(const WebSize& newSize) +{ + if (m_size == newSize) + return; + m_size = newSize; + + if (mainFrameImpl()->frameView()) { + mainFrameImpl()->frameView()->resize(m_size.width, m_size.height); + mainFrameImpl()->frame()->eventHandler()->sendResizeEvent(); + } + + if (m_client) { + WebRect damagedRect(0, 0, m_size.width, m_size.height); + m_client->didInvalidateRect(damagedRect); + } +} + +void WebViewImpl::layout() +{ + WebFrameImpl* webframe = mainFrameImpl(); + if (webframe) { + // In order for our child HWNDs (NativeWindowWidgets) to update properly, + // they need to be told that we are updating the screen. The problem is + // that the native widgets need to recalculate their clip region and not + // overlap any of our non-native widgets. To force the resizing, call + // setFrameRect(). This will be a quick operation for most frames, but + // the NativeWindowWidgets will update a proper clipping region. + FrameView* view = webframe->frameView(); + if (view) + view->setFrameRect(view->frameRect()); + + // setFrameRect may have the side-effect of causing existing page + // layout to be invalidated, so layout needs to be called last. + + webframe->layout(); + } +} + +void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect) +{ + WebFrameImpl* webframe = mainFrameImpl(); + if (webframe) + webframe->paint(canvas, rect); +} + +// FIXME: m_currentInputEvent should be removed once ChromeClient::show() can +// get the current-event information from WebCore. +const WebInputEvent* WebViewImpl::m_currentInputEvent = 0; + +bool WebViewImpl::handleInputEvent(const WebInputEvent& inputEvent) +{ + // If we've started a drag and drop operation, ignore input events until + // we're done. + if (m_doingDragAndDrop) + return true; + + if (m_ignoreInputEvents) + return true; + + // FIXME: Remove m_currentInputEvent. + // This only exists to allow ChromeClient::show() to know which mouse button + // triggered a window.open event. + // Safari must perform a similar hack, ours is in our WebKit glue layer + // theirs is in the application. This should go when WebCore can be fixed + // to pass more event information to ChromeClient::show() + m_currentInputEvent = &inputEvent; + + bool handled = true; + + // FIXME: WebKit seems to always return false on mouse events processing + // methods. For now we'll assume it has processed them (as we are only + // interested in whether keyboard events are processed). + switch (inputEvent.type) { + case WebInputEvent::MouseMove: + mouseMove(*static_cast<const WebMouseEvent*>(&inputEvent)); + break; + + case WebInputEvent::MouseLeave: + mouseLeave(*static_cast<const WebMouseEvent*>(&inputEvent)); + break; + + case WebInputEvent::MouseWheel: + mouseWheel(*static_cast<const WebMouseWheelEvent*>(&inputEvent)); + break; + + case WebInputEvent::MouseDown: + mouseDown(*static_cast<const WebMouseEvent*>(&inputEvent)); + break; + + case WebInputEvent::MouseUp: + mouseUp(*static_cast<const WebMouseEvent*>(&inputEvent)); + break; + + case WebInputEvent::RawKeyDown: + case WebInputEvent::KeyDown: + case WebInputEvent::KeyUp: + handled = keyEvent(*static_cast<const WebKeyboardEvent*>(&inputEvent)); + break; + + case WebInputEvent::Char: + handled = charEvent(*static_cast<const WebKeyboardEvent*>(&inputEvent)); + break; + + default: + handled = false; + } + + m_currentInputEvent = 0; + + return handled; +} + +void WebViewImpl::mouseCaptureLost() +{ +} + +void WebViewImpl::setFocus(bool enable) +{ + m_page->focusController()->setFocused(enable); + if (enable) { + // Note that we don't call setActive() when disabled as this cause extra + // focus/blur events to be dispatched. + m_page->focusController()->setActive(true); + RefPtr<Frame> focusedFrame = m_page->focusController()->focusedFrame(); + if (focusedFrame) { + Node* focusedNode = focusedFrame->document()->focusedNode(); + if (focusedNode && focusedNode->isElementNode() + && focusedFrame->selection()->selection().isNone()) { + // If the selection was cleared while the WebView was not + // focused, then the focus element shows with a focus ring but + // no caret and does respond to keyboard inputs. + Element* element = static_cast<Element*>(focusedNode); + if (element->isTextFormControl()) + element->updateFocusAppearance(true); + else if (focusedNode->isContentEditable()) { + // updateFocusAppearance() selects all the text of + // contentseditable DIVs. So we set the selection explicitly + // instead. Note that this has the side effect of moving the + // caret back to the beginning of the text. + Position position(focusedNode, 0, + Position::PositionIsOffsetInAnchor); + focusedFrame->selection()->setSelection( + VisibleSelection(position, SEL_DEFAULT_AFFINITY)); + } + } + } + m_imeAcceptEvents = true; + } else { + hideAutoCompletePopup(); + + // Clear focus on the currently focused frame if any. + if (!m_page.get()) + return; + + Frame* frame = m_page->mainFrame(); + if (!frame) + return; + + RefPtr<Frame> focusedFrame = m_page->focusController()->focusedFrame(); + if (focusedFrame.get()) { + // Finish an ongoing composition to delete the composition node. + Editor* editor = focusedFrame->editor(); + if (editor && editor->hasComposition()) + editor->confirmComposition(); + m_imeAcceptEvents = false; + } + } +} + +bool WebViewImpl::handleCompositionEvent(WebCompositionCommand command, + int cursorPosition, + int targetStart, + int targetEnd, + const WebString& imeString) +{ + Frame* focused = focusedWebCoreFrame(); + if (!focused || !m_imeAcceptEvents) + return false; + Editor* editor = focused->editor(); + if (!editor) + return false; + if (!editor->canEdit()) { + // The input focus has been moved to another WebWidget object. + // We should use this |editor| object only to complete the ongoing + // composition. + if (!editor->hasComposition()) + return false; + } + + // We should verify the parent node of this IME composition node are + // editable because JavaScript may delete a parent node of the composition + // node. In this case, WebKit crashes while deleting texts from the parent + // node, which doesn't exist any longer. + PassRefPtr<Range> range = editor->compositionRange(); + if (range) { + const Node* node = range->startPosition().node(); + if (!node || !node->isContentEditable()) + return false; + } + + if (command == WebCompositionCommandDiscard) { + // A browser process sent an IPC message which does not contain a valid + // string, which means an ongoing composition has been canceled. + // If the ongoing composition has been canceled, replace the ongoing + // composition string with an empty string and complete it. + String emptyString; + Vector<CompositionUnderline> emptyUnderlines; + editor->setComposition(emptyString, emptyUnderlines, 0, 0); + } else { + // A browser process sent an IPC message which contains a string to be + // displayed in this Editor object. + // To display the given string, set the given string to the + // m_compositionNode member of this Editor object and display it. + if (targetStart < 0) + targetStart = 0; + if (targetEnd < 0) + targetEnd = static_cast<int>(imeString.length()); + String compositionString(imeString); + // Create custom underlines. + // To emphasize the selection, the selected region uses a solid black + // for its underline while other regions uses a pale gray for theirs. + Vector<CompositionUnderline> underlines(3); + underlines[0].startOffset = 0; + underlines[0].endOffset = targetStart; + underlines[0].thick = true; + underlines[0].color.setRGB(0xd3, 0xd3, 0xd3); + underlines[1].startOffset = targetStart; + underlines[1].endOffset = targetEnd; + underlines[1].thick = true; + underlines[1].color.setRGB(0x00, 0x00, 0x00); + underlines[2].startOffset = targetEnd; + underlines[2].endOffset = static_cast<int>(imeString.length()); + underlines[2].thick = true; + underlines[2].color.setRGB(0xd3, 0xd3, 0xd3); + // When we use custom underlines, WebKit ("InlineTextBox.cpp" Line 282) + // prevents from writing a text in between 'selectionStart' and + // 'selectionEnd' somehow. + // Therefore, we use the 'cursorPosition' for these arguments so that + // there are not any characters in the above region. + editor->setComposition(compositionString, underlines, + cursorPosition, cursorPosition); + // The given string is a result string, which means the ongoing + // composition has been completed. I have to call the + // Editor::confirmCompletion() and complete this composition. + if (command == WebCompositionCommandConfirm) + editor->confirmComposition(); + } + + return editor->hasComposition(); +} + +bool WebViewImpl::queryCompositionStatus(bool* enableIME, WebRect* caretRect) +{ + // Store whether the selected node needs IME and the caret rectangle. + // This process consists of the following four steps: + // 1. Retrieve the selection controller of the focused frame; + // 2. Retrieve the caret rectangle from the controller; + // 3. Convert the rectangle, which is relative to the parent view, to the + // one relative to the client window, and; + // 4. Store the converted rectangle. + const Frame* focused = focusedWebCoreFrame(); + if (!focused) + return false; + + const Editor* editor = focused->editor(); + if (!editor || !editor->canEdit()) + return false; + + SelectionController* controller = focused->selection(); + if (!controller) + return false; + + const Node* node = controller->start().node(); + if (!node) + return false; + + *enableIME = node->shouldUseInputMethod() && !controller->isInPasswordField(); + const FrameView* view = node->document()->view(); + if (!view) + return false; + + *caretRect = view->contentsToWindow(controller->absoluteCaretBounds()); + return true; +} + +void WebViewImpl::setTextDirection(WebTextDirection direction) +{ + // The Editor::setBaseWritingDirection() function checks if we can change + // the text direction of the selected node and updates its DOM "dir" + // attribute and its CSS "direction" property. + // So, we just call the function as Safari does. + const Frame* focused = focusedWebCoreFrame(); + if (!focused) + return; + + Editor* editor = focused->editor(); + if (!editor || !editor->canEdit()) + return; + + switch (direction) { + case WebTextDirectionDefault: + editor->setBaseWritingDirection(NaturalWritingDirection); + break; + + case WebTextDirectionLeftToRight: + editor->setBaseWritingDirection(LeftToRightWritingDirection); + break; + + case WebTextDirectionRightToLeft: + editor->setBaseWritingDirection(RightToLeftWritingDirection); + break; + + default: + notImplemented(); + break; + } +} + +// WebView -------------------------------------------------------------------- + +WebSettings* WebViewImpl::settings() +{ + if (!m_webSettings.get()) + m_webSettings.set(new WebSettingsImpl(m_page->settings())); + ASSERT(m_webSettings.get()); + return m_webSettings.get(); +} + +WebString WebViewImpl::pageEncoding() const +{ + if (!m_page.get()) + return WebString(); + + return m_page->mainFrame()->loader()->encoding(); +} + +void WebViewImpl::setPageEncoding(const WebString& encodingName) +{ + if (!m_page.get()) + return; + + // Only change override encoding, don't change default encoding. + // Note that the new encoding must be 0 if it isn't supposed to be set. + String newEncodingName; + if (!encodingName.isEmpty()) + newEncodingName = encodingName; + m_page->mainFrame()->loader()->reloadWithOverrideEncoding(newEncodingName); +} + +bool WebViewImpl::dispatchBeforeUnloadEvent() +{ + // FIXME: This should really cause a recursive depth-first walk of all + // frames in the tree, calling each frame's onbeforeunload. At the moment, + // we're consistent with Safari 3.1, not IE/FF. + Frame* frame = m_page->focusController()->focusedOrMainFrame(); + if (!frame) + return true; + + return frame->shouldClose(); +} + +void WebViewImpl::dispatchUnloadEvent() +{ + // Run unload handlers. + m_page->mainFrame()->loader()->closeURL(); +} + +WebFrame* WebViewImpl::mainFrame() +{ + return mainFrameImpl(); +} + +WebFrame* WebViewImpl::findFrameByName( + const WebString& name, WebFrame* relativeToFrame) +{ + if (!relativeToFrame) + relativeToFrame = mainFrame(); + Frame* frame = static_cast<WebFrameImpl*>(relativeToFrame)->frame(); + frame = frame->tree()->find(name); + return WebFrameImpl::fromFrame(frame); +} + +WebFrame* WebViewImpl::focusedFrame() +{ + return WebFrameImpl::fromFrame(focusedWebCoreFrame()); +} + +void WebViewImpl::setFocusedFrame(WebFrame* frame) +{ + if (!frame) { + // Clears the focused frame if any. + Frame* frame = focusedWebCoreFrame(); + if (frame) + frame->selection()->setFocused(false); + return; + } + WebFrameImpl* frameImpl = static_cast<WebFrameImpl*>(frame); + Frame* webcoreFrame = frameImpl->frame(); + webcoreFrame->page()->focusController()->setFocusedFrame(webcoreFrame); +} + +void WebViewImpl::setInitialFocus(bool reverse) +{ + if (!m_page.get()) + return; + + // Since we don't have a keyboard event, we'll create one. + WebKeyboardEvent keyboardEvent; + keyboardEvent.type = WebInputEvent::RawKeyDown; + if (reverse) + keyboardEvent.modifiers = WebInputEvent::ShiftKey; + + // VK_TAB which is only defined on Windows. + keyboardEvent.windowsKeyCode = 0x09; + PlatformKeyboardEventBuilder platformEvent(keyboardEvent); + RefPtr<KeyboardEvent> webkitEvent = KeyboardEvent::create(platformEvent, 0); + page()->focusController()->setInitialFocus( + reverse ? FocusDirectionBackward : FocusDirectionForward, + webkitEvent.get()); +} + +void WebViewImpl::clearFocusedNode() +{ + if (!m_page.get()) + return; + + RefPtr<Frame> frame = m_page->mainFrame(); + if (!frame.get()) + return; + + RefPtr<Document> document = frame->document(); + if (!document.get()) + return; + + RefPtr<Node> oldFocusedNode = document->focusedNode(); + + // Clear the focused node. + document->setFocusedNode(0); + + if (!oldFocusedNode.get()) + return; + + // If a text field has focus, we need to make sure the selection controller + // knows to remove selection from it. Otherwise, the text field is still + // processing keyboard events even though focus has been moved to the page and + // keystrokes get eaten as a result. + if (oldFocusedNode->hasTagName(HTMLNames::textareaTag) + || (oldFocusedNode->hasTagName(HTMLNames::inputTag) + && static_cast<HTMLInputElement*>(oldFocusedNode.get())->isTextField())) { + // Clear the selection. + SelectionController* selection = frame->selection(); + selection->clear(); + } +} + +int WebViewImpl::zoomLevel() +{ + return m_zoomLevel; +} + +int WebViewImpl::setZoomLevel(bool textOnly, int zoomLevel) +{ + float zoomFactor = static_cast<float>( + std::max(std::min(std::pow(textSizeMultiplierRatio, zoomLevel), + maxTextSizeMultiplier), + minTextSizeMultiplier)); + Frame* frame = mainFrameImpl()->frame(); + if (zoomFactor != frame->zoomFactor()) { + m_zoomLevel = zoomLevel; + frame->setZoomFactor(zoomFactor, textOnly); + } + return m_zoomLevel; +} + +void WebViewImpl::performMediaPlayerAction(const WebMediaPlayerAction& action, + const WebPoint& location) +{ + HitTestResult result = + hitTestResultForWindowPos(location); + RefPtr<Node> node = result.innerNonSharedNode(); + if (!node->hasTagName(HTMLNames::videoTag) && !node->hasTagName(HTMLNames::audioTag)) + return; + + RefPtr<HTMLMediaElement> mediaElement = + static_pointer_cast<HTMLMediaElement>(node); + switch (action.type) { + case WebMediaPlayerAction::Play: + if (action.enable) + mediaElement->play(); + else + mediaElement->pause(); + break; + case WebMediaPlayerAction::Mute: + mediaElement->setMuted(action.enable); + break; + case WebMediaPlayerAction::Loop: + mediaElement->setLoop(action.enable); + break; + default: + ASSERT_NOT_REACHED(); + } +} + +void WebViewImpl::copyImageAt(const WebPoint& point) +{ + if (!m_page.get()) + return; + + HitTestResult result = hitTestResultForWindowPos(point); + + if (result.absoluteImageURL().isEmpty()) { + // There isn't actually an image at these coordinates. Might be because + // the window scrolled while the context menu was open or because the page + // changed itself between when we thought there was an image here and when + // we actually tried to retreive the image. + // + // FIXME: implement a cache of the most recent HitTestResult to avoid having + // to do two hit tests. + return; + } + + m_page->mainFrame()->editor()->copyImage(result); +} + +void WebViewImpl::dragSourceEndedAt( + const WebPoint& clientPoint, + const WebPoint& screenPoint, + WebDragOperation operation) +{ + PlatformMouseEvent pme(clientPoint, + screenPoint, + LeftButton, MouseEventMoved, 0, false, false, false, + false, 0); + m_page->mainFrame()->eventHandler()->dragSourceEndedAt(pme, + static_cast<DragOperation>(operation)); +} + +void WebViewImpl::dragSourceSystemDragEnded() +{ + // It's possible for us to get this callback while not doing a drag if + // it's from a previous page that got unloaded. + if (m_doingDragAndDrop) { + m_page->dragController()->dragEnded(); + m_doingDragAndDrop = false; + } +} + +WebDragOperation WebViewImpl::dragTargetDragEnter( + const WebDragData& webDragData, int identity, + const WebPoint& clientPoint, + const WebPoint& screenPoint, + WebDragOperationsMask operationsAllowed) +{ + ASSERT(!m_currentDragData.get()); + + m_currentDragData = webDragData; + m_dragIdentity = identity; + m_operationsAllowed = operationsAllowed; + + DragData dragData( + m_currentDragData.get(), + clientPoint, + screenPoint, + static_cast<DragOperation>(operationsAllowed)); + + m_dropEffect = DropEffectDefault; + m_dragTargetDispatch = true; + DragOperation effect = m_page->dragController()->dragEntered(&dragData); + // Mask the operation against the drag source's allowed operations. + if ((effect & dragData.draggingSourceOperationMask()) != effect) + effect = DragOperationNone; + m_dragTargetDispatch = false; + + if (m_dropEffect != DropEffectDefault) { + m_dragOperation = (m_dropEffect != DropEffectNone) ? WebDragOperationCopy + : WebDragOperationNone; + } else + m_dragOperation = static_cast<WebDragOperation>(effect); + return m_dragOperation; +} + +WebDragOperation WebViewImpl::dragTargetDragOver( + const WebPoint& clientPoint, + const WebPoint& screenPoint, + WebDragOperationsMask operationsAllowed) +{ + ASSERT(m_currentDragData.get()); + + m_operationsAllowed = operationsAllowed; + DragData dragData( + m_currentDragData.get(), + clientPoint, + screenPoint, + static_cast<DragOperation>(operationsAllowed)); + + m_dropEffect = DropEffectDefault; + m_dragTargetDispatch = true; + DragOperation effect = m_page->dragController()->dragUpdated(&dragData); + // Mask the operation against the drag source's allowed operations. + if ((effect & dragData.draggingSourceOperationMask()) != effect) + effect = DragOperationNone; + m_dragTargetDispatch = false; + + if (m_dropEffect != DropEffectDefault) { + m_dragOperation = (m_dropEffect != DropEffectNone) ? WebDragOperationCopy + : WebDragOperationNone; + } else + m_dragOperation = static_cast<WebDragOperation>(effect); + return m_dragOperation; +} + +void WebViewImpl::dragTargetDragLeave() +{ + ASSERT(m_currentDragData.get()); + + DragData dragData( + m_currentDragData.get(), + IntPoint(), + IntPoint(), + static_cast<DragOperation>(m_operationsAllowed)); + + m_dragTargetDispatch = true; + m_page->dragController()->dragExited(&dragData); + m_dragTargetDispatch = false; + + m_currentDragData = 0; + m_dropEffect = DropEffectDefault; + m_dragOperation = WebDragOperationNone; + m_dragIdentity = 0; +} + +void WebViewImpl::dragTargetDrop(const WebPoint& clientPoint, + const WebPoint& screenPoint) +{ + ASSERT(m_currentDragData.get()); + + // If this webview transitions from the "drop accepting" state to the "not + // accepting" state, then our IPC message reply indicating that may be in- + // flight, or else delayed by javascript processing in this webview. If a + // drop happens before our IPC reply has reached the browser process, then + // the browser forwards the drop to this webview. So only allow a drop to + // proceed if our webview m_dragOperation state is not DragOperationNone. + + if (m_dragOperation == WebDragOperationNone) { // IPC RACE CONDITION: do not allow this drop. + dragTargetDragLeave(); + return; + } + + DragData dragData( + m_currentDragData.get(), + clientPoint, + screenPoint, + static_cast<DragOperation>(m_operationsAllowed)); + + m_dragTargetDispatch = true; + m_page->dragController()->performDrag(&dragData); + m_dragTargetDispatch = false; + + m_currentDragData = 0; + m_dropEffect = DropEffectDefault; + m_dragOperation = WebDragOperationNone; + m_dragIdentity = 0; +} + +int WebViewImpl::dragIdentity() +{ + if (m_dragTargetDispatch) + return m_dragIdentity; + return 0; +} + +unsigned long WebViewImpl::createUniqueIdentifierForRequest() { + if (m_page) + return m_page->progress()->createUniqueIdentifier(); + return 0; +} + +void WebViewImpl::inspectElementAt(const WebPoint& point) +{ + if (!m_page.get()) + return; + + if (point.x == -1 || point.y == -1) + m_page->inspectorController()->inspect(0); + else { + HitTestResult result = hitTestResultForWindowPos(point); + + if (!result.innerNonSharedNode()) + return; + + m_page->inspectorController()->inspect(result.innerNonSharedNode()); + } +} + +WebString WebViewImpl::inspectorSettings() const +{ + return m_inspectorSettings; +} + +void WebViewImpl::setInspectorSettings(const WebString& settings) +{ + m_inspectorSettings = settings; +} + +WebDevToolsAgent* WebViewImpl::devToolsAgent() +{ + return m_devToolsAgent.get(); +} + +void WebViewImpl::setDevToolsAgent(WebDevToolsAgent* devToolsAgent) +{ + ASSERT(!m_devToolsAgent.get()); // May only set once! + m_devToolsAgent.set(static_cast<WebDevToolsAgentPrivate*>(devToolsAgent)); +} + +WebAccessibilityObject WebViewImpl::accessibilityObject() +{ + if (!mainFrameImpl()) + return WebAccessibilityObject(); + + Document* document = mainFrameImpl()->frame()->document(); + return WebAccessibilityObject( + document->axObjectCache()->getOrCreate(document->renderer())); +} + +void WebViewImpl::applyAutofillSuggestions( + const WebNode& node, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex) +{ + if (!m_page.get() || suggestions.isEmpty()) { + hideAutoCompletePopup(); + return; + } + + ASSERT(defaultSuggestionIndex < static_cast<int>(suggestions.size())); + + if (RefPtr<Frame> focused = m_page->focusController()->focusedFrame()) { + RefPtr<Document> document = focused->document(); + if (!document.get()) { + hideAutoCompletePopup(); + return; + } + + RefPtr<Node> focusedNode = document->focusedNode(); + // If the node for which we queried the autofill suggestions is not the + // focused node, then we have nothing to do. FIXME: also check the + // carret is at the end and that the text has not changed. + if (!focusedNode.get() || focusedNode != PassRefPtr<Node>(node)) { + hideAutoCompletePopup(); + return; + } + + if (!focusedNode->hasTagName(HTMLNames::inputTag)) { + ASSERT_NOT_REACHED(); + return; + } + + HTMLInputElement* inputElem = + static_cast<HTMLInputElement*>(focusedNode.get()); + + // The first time the autocomplete is shown we'll create the client and the + // popup. + if (!m_autocompletePopupClient.get()) + m_autocompletePopupClient.set(new AutocompletePopupMenuClient(this)); + m_autocompletePopupClient->initialize(inputElem, + suggestions, + defaultSuggestionIndex); + if (!m_autocompletePopup.get()) { + m_autocompletePopup = + PopupContainer::create(m_autocompletePopupClient.get(), + autocompletePopupSettings); + } + + if (m_autocompletePopupShowing) { + m_autocompletePopupClient->setSuggestions(suggestions); + refreshAutofillPopup(); + } else { + m_autocompletePopup->show(focusedNode->getRect(), + focusedNode->ownerDocument()->view(), 0); + m_autocompletePopupShowing = true; + } + } +} + +void WebViewImpl::hideAutofillPopup() +{ + hideAutoCompletePopup(); +} + +void WebViewImpl::performCustomContextMenuAction(unsigned action) +{ + if (!m_page) + return; + ContextMenu* menu = m_page->contextMenuController()->contextMenu(); + if (!menu) + return; + ContextMenuItem* item = menu->itemWithAction(static_cast<ContextMenuAction>(ContextMenuItemBaseCustomTag + action)); + if (item) + m_page->contextMenuController()->contextMenuItemSelected(item); + m_page->contextMenuController()->clearContextMenu(); +} + +// WebView -------------------------------------------------------------------- + +bool WebViewImpl::setDropEffect(bool accept) +{ + if (m_dragTargetDispatch) { + m_dropEffect = accept ? DropEffectCopy : DropEffectNone; + return true; + } + return false; +} + +void WebViewImpl::setIsTransparent(bool isTransparent) +{ + // Set any existing frames to be transparent. + Frame* frame = m_page->mainFrame(); + while (frame) { + frame->view()->setTransparent(isTransparent); + frame = frame->tree()->traverseNext(); + } + + // Future frames check this to know whether to be transparent. + m_isTransparent = isTransparent; +} + +bool WebViewImpl::isTransparent() const +{ + return m_isTransparent; +} + +void WebViewImpl::setIsActive(bool active) +{ + if (page() && page()->focusController()) + page()->focusController()->setActive(active); +} + +bool WebViewImpl::isActive() const +{ + return (page() && page()->focusController()) ? page()->focusController()->isActive() : false; +} + +void WebViewImpl::setScrollbarColors(unsigned inactiveColor, + unsigned activeColor, + unsigned trackColor) { +#if PLATFORM(LINUX) + RenderThemeChromiumLinux::setScrollbarColors(inactiveColor, + activeColor, + trackColor); +#endif +} + +void WebViewImpl::didCommitLoad(bool* isNewNavigation) +{ + if (isNewNavigation) + *isNewNavigation = m_observedNewNavigation; + +#ifndef NDEBUG + ASSERT(!m_observedNewNavigation + || m_page->mainFrame()->loader()->documentLoader() == m_newNavigationLoader); + m_newNavigationLoader = 0; +#endif + m_observedNewNavigation = false; +} + +bool WebViewImpl::navigationPolicyFromMouseEvent(unsigned short button, + bool ctrl, bool shift, + bool alt, bool meta, + WebNavigationPolicy* policy) +{ +#if PLATFORM(WIN_OS) || PLATFORM(LINUX) || PLATFORM(FREEBSD) + const bool newTabModifier = (button == 1) || ctrl; +#elif PLATFORM(DARWIN) + const bool newTabModifier = (button == 1) || meta; +#endif + if (!newTabModifier && !shift && !alt) + return false; + + ASSERT(policy); + if (newTabModifier) { + if (shift) + *policy = WebNavigationPolicyNewForegroundTab; + else + *policy = WebNavigationPolicyNewBackgroundTab; + } else { + if (shift) + *policy = WebNavigationPolicyNewWindow; + else + *policy = WebNavigationPolicyDownload; + } + return true; +} + +void WebViewImpl::startDragging(const WebPoint& eventPos, + const WebDragData& dragData, + WebDragOperationsMask mask) +{ + if (!m_client) + return; + ASSERT(!m_doingDragAndDrop); + m_doingDragAndDrop = true; + m_client->startDragging(eventPos, dragData, mask); +} + +void WebViewImpl::setCurrentHistoryItem(HistoryItem* item) +{ + m_backForwardListClientImpl.setCurrentHistoryItem(item); +} + +HistoryItem* WebViewImpl::previousHistoryItem() +{ + return m_backForwardListClientImpl.previousHistoryItem(); +} + +void WebViewImpl::observeNewNavigation() +{ + m_observedNewNavigation = true; +#ifndef NDEBUG + m_newNavigationLoader = m_page->mainFrame()->loader()->documentLoader(); +#endif +} + +void WebViewImpl::hideAutoCompletePopup() +{ + if (m_autocompletePopupShowing) { + m_autocompletePopup->hidePopup(); + autoCompletePopupDidHide(); + } +} + +void WebViewImpl::autoCompletePopupDidHide() +{ + m_autocompletePopupShowing = false; +} + +void WebViewImpl::setIgnoreInputEvents(bool newValue) +{ + ASSERT(m_ignoreInputEvents != newValue); + m_ignoreInputEvents = newValue; +} + +#if ENABLE(NOTIFICATIONS) +NotificationPresenterImpl* WebViewImpl::notificationPresenterImpl() +{ + if (!m_notificationPresenter.isInitialized() && m_client) + m_notificationPresenter.initialize(m_client->notificationPresenter()); + return &m_notificationPresenter; +} +#endif + +void WebViewImpl::refreshAutofillPopup() +{ + ASSERT(m_autocompletePopupShowing); + + // Hide the popup if it has become empty. + if (!m_autocompletePopupClient->listSize()) { + hideAutoCompletePopup(); + return; + } + + IntRect oldBounds = m_autocompletePopup->boundsRect(); + m_autocompletePopup->refresh(); + IntRect newBounds = m_autocompletePopup->boundsRect(); + // Let's resize the backing window if necessary. + if (oldBounds != newBounds) { + WebPopupMenuImpl* popupMenu = + static_cast<WebPopupMenuImpl*>(m_autocompletePopup->client()); + popupMenu->client()->setWindowRect(newBounds); + } +} + +Node* WebViewImpl::focusedWebCoreNode() +{ + Frame* frame = m_page->focusController()->focusedFrame(); + if (!frame) + return 0; + + Document* document = frame->document(); + if (!document) + return 0; + + return document->focusedNode(); +} + +HitTestResult WebViewImpl::hitTestResultForWindowPos(const IntPoint& pos) +{ + IntPoint docPoint(m_page->mainFrame()->view()->windowToContents(pos)); + return m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(docPoint, false); +} + +void WebViewImpl::setTabsToLinks(bool enable) +{ + m_tabsToLinks = enable; +} + +bool WebViewImpl::tabsToLinks() const +{ + return m_tabsToLinks; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebViewImpl.h b/WebKit/chromium/src/WebViewImpl.h new file mode 100644 index 0000000..dd5191e --- /dev/null +++ b/WebKit/chromium/src/WebViewImpl.h @@ -0,0 +1,420 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebViewImpl_h +#define WebViewImpl_h + +// FIXME: Remove these relative paths once consumers from glue are removed. +#include "../public/WebNavigationPolicy.h" +#include "../public/WebPoint.h" +#include "../public/WebSize.h" +#include "../public/WebString.h" +#include "../public/WebView.h" + +#include "BackForwardListClientImpl.h" +#include "ChromeClientImpl.h" +#include "ContextMenuClientImpl.h" +#include "DragClientImpl.h" +#include "EditorClientImpl.h" +#include "InspectorClientImpl.h" +#include "NotificationPresenterImpl.h" + +#include <wtf/OwnPtr.h> +#include <wtf/RefCounted.h> + +namespace WebCore { +class ChromiumDataObject; +class Frame; +class HistoryItem; +class HitTestResult; +class KeyboardEvent; +class Page; +class PlatformKeyboardEvent; +class PopupContainer; +class Range; +class RenderTheme; +class Widget; +} + +namespace WebKit { +class AutocompletePopupMenuClient; +class ContextMenuClientImpl; +class WebAccessibilityObject; +class WebDevToolsAgentPrivate; +class WebFrameImpl; +class WebKeyboardEvent; +class WebMouseEvent; +class WebMouseWheelEvent; +class WebSettingsImpl; + +class WebViewImpl : public WebView, public RefCounted<WebViewImpl> { +public: + // WebWidget methods: + virtual void close(); + virtual WebSize size() { return m_size; } + virtual void resize(const WebSize&); + virtual void layout(); + virtual void paint(WebCanvas*, const WebRect&); + virtual bool handleInputEvent(const WebInputEvent&); + virtual void mouseCaptureLost(); + virtual void setFocus(bool enable); + virtual bool handleCompositionEvent(WebCompositionCommand command, + int cursorPosition, + int targetStart, + int targetEnd, + const WebString& text); + virtual bool queryCompositionStatus(bool* enabled, + WebRect* caretRect); + virtual void setTextDirection(WebTextDirection direction); + + // WebView methods: + virtual void initializeMainFrame(WebFrameClient*); + virtual WebSettings* settings(); + virtual WebString pageEncoding() const; + virtual void setPageEncoding(const WebString& encoding); + virtual bool isTransparent() const; + virtual void setIsTransparent(bool value); + virtual bool tabsToLinks() const; + virtual void setTabsToLinks(bool value); + virtual bool tabKeyCyclesThroughElements() const; + virtual void setTabKeyCyclesThroughElements(bool value); + virtual bool isActive() const; + virtual void setIsActive(bool value); + virtual bool dispatchBeforeUnloadEvent(); + virtual void dispatchUnloadEvent(); + virtual WebFrame* mainFrame(); + virtual WebFrame* findFrameByName( + const WebString& name, WebFrame* relativeToFrame); + virtual WebFrame* focusedFrame(); + virtual void setFocusedFrame(WebFrame* frame); + virtual void setInitialFocus(bool reverse); + virtual void clearFocusedNode(); + virtual int zoomLevel(); + virtual int setZoomLevel(bool textOnly, int zoomLevel); + virtual void performMediaPlayerAction( + const WebMediaPlayerAction& action, + const WebPoint& location); + virtual void copyImageAt(const WebPoint& point); + virtual void dragSourceEndedAt( + const WebPoint& clientPoint, + const WebPoint& screenPoint, + WebDragOperation operation); + virtual void dragSourceSystemDragEnded(); + virtual WebDragOperation dragTargetDragEnter( + const WebDragData& dragData, int identity, + const WebPoint& clientPoint, + const WebPoint& screenPoint, + WebDragOperationsMask operationsAllowed); + virtual WebDragOperation dragTargetDragOver( + const WebPoint& clientPoint, + const WebPoint& screenPoint, + WebDragOperationsMask operationsAllowed); + virtual void dragTargetDragLeave(); + virtual void dragTargetDrop( + const WebPoint& clientPoint, + const WebPoint& screenPoint); + virtual int dragIdentity(); + virtual bool setDropEffect(bool accept); + virtual unsigned long createUniqueIdentifierForRequest(); + virtual void inspectElementAt(const WebPoint& point); + virtual WebString inspectorSettings() const; + virtual void setInspectorSettings(const WebString& settings); + virtual WebDevToolsAgent* devToolsAgent(); + virtual void setDevToolsAgent(WebDevToolsAgent*); + virtual WebAccessibilityObject accessibilityObject(); + virtual void applyAutofillSuggestions( + const WebNode&, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex); + virtual void hideAutofillPopup(); + virtual void setScrollbarColors(unsigned inactiveColor, + unsigned activeColor, + unsigned trackColor); + virtual void performCustomContextMenuAction(unsigned action); + + // WebViewImpl + + void setIgnoreInputEvents(bool newValue); + WebDevToolsAgentPrivate* devToolsAgentPrivate() { return m_devToolsAgent.get(); } + + const WebPoint& lastMouseDownPoint() const + { + return m_lastMouseDownPoint; + } + + WebCore::Frame* focusedWebCoreFrame(); + + // Returns the currently focused Node or null if no node has focus. + WebCore::Node* focusedWebCoreNode(); + + static WebViewImpl* fromPage(WebCore::Page*); + + WebViewClient* client() + { + return m_client; + } + + // Returns the page object associated with this view. This may be null when + // the page is shutting down, but will be valid at all other times. + WebCore::Page* page() const + { + return m_page.get(); + } + + WebCore::RenderTheme* theme() const; + + // Returns the main frame associated with this view. This may be null when + // the page is shutting down, but will be valid at all other times. + WebFrameImpl* mainFrameImpl(); + + // History related methods: + void setCurrentHistoryItem(WebCore::HistoryItem*); + WebCore::HistoryItem* previousHistoryItem(); + void observeNewNavigation(); + + // Event related methods: + void mouseMove(const WebMouseEvent&); + void mouseLeave(const WebMouseEvent&); + void mouseDown(const WebMouseEvent&); + void mouseUp(const WebMouseEvent&); + void mouseContextMenu(const WebMouseEvent&); + void mouseDoubleClick(const WebMouseEvent&); + void mouseWheel(const WebMouseWheelEvent&); + bool keyEvent(const WebKeyboardEvent&); + bool charEvent(const WebKeyboardEvent&); + + // Handles context menu events orignated via the the keyboard. These + // include the VK_APPS virtual key and the Shift+F10 combine. Code is + // based on the Webkit function bool WebView::handleContextMenuEvent(WPARAM + // wParam, LPARAM lParam) in webkit\webkit\win\WebView.cpp. The only + // significant change in this function is the code to convert from a + // Keyboard event to the Right Mouse button down event. + bool sendContextMenuEvent(const WebKeyboardEvent&); + + // Notifies the WebView that a load has been committed. isNewNavigation + // will be true if a new session history item should be created for that + // load. + void didCommitLoad(bool* isNewNavigation); + + bool contextMenuAllowed() const + { + return m_contextMenuAllowed; + } + + // Set the disposition for how this webview is to be initially shown. + void setInitialNavigationPolicy(WebNavigationPolicy policy) + { + m_initialNavigationPolicy = policy; + } + WebNavigationPolicy initialNavigationPolicy() const + { + return m_initialNavigationPolicy; + } + + // Determines whether a page should e.g. be opened in a background tab. + // Returns false if it has no opinion, in which case it doesn't set *policy. + static bool navigationPolicyFromMouseEvent( + unsigned short button, + bool ctrl, + bool shift, + bool alt, + bool meta, + WebNavigationPolicy*); + + // Start a system drag and drop operation. + void startDragging( + const WebPoint& eventPos, + const WebDragData& dragData, + WebDragOperationsMask dragSourceOperationMask); + + // Hides the autocomplete popup if it is showing. + void hideAutoCompletePopup(); + void autoCompletePopupDidHide(); + +#if ENABLE(NOTIFICATIONS) + // Returns the provider of desktop notifications. + NotificationPresenterImpl* notificationPresenterImpl(); +#endif + + // Tries to scroll a frame or any parent of a frame. Returns true if the view + // was scrolled. + bool propagateScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity); + + // HACK: currentInputEvent() is for ChromeClientImpl::show(), until we can + // fix WebKit to pass enough information up into ChromeClient::show() so we + // can decide if the window.open event was caused by a middle-mouse click + static const WebInputEvent* currentInputEvent() + { + return m_currentInputEvent; + } + +private: + friend class WebView; // So WebView::Create can call our constructor + friend class WTF::RefCounted<WebViewImpl>; + + WebViewImpl(WebViewClient* client); + ~WebViewImpl(); + + // Returns true if the event was actually processed. + bool keyEventDefault(const WebKeyboardEvent&); + + // Returns true if the autocomple has consumed the event. + bool autocompleteHandleKeyEvent(const WebKeyboardEvent&); + + // Repaints the autofill popup. Should be called when the suggestions have + // changed. Note that this should only be called when the autofill popup is + // showing. + void refreshAutofillPopup(); + + // Returns true if the view was scrolled. + bool scrollViewWithKeyboard(int keyCode, int modifiers); + + // Converts |pos| from window coordinates to contents coordinates and gets + // the HitTestResult for it. + WebCore::HitTestResult hitTestResultForWindowPos(const WebCore::IntPoint&); + + WebViewClient* m_client; + + BackForwardListClientImpl m_backForwardListClientImpl; + ChromeClientImpl m_chromeClientImpl; + ContextMenuClientImpl m_contextMenuClientImpl; + DragClientImpl m_dragClientImpl; + EditorClientImpl m_editorClientImpl; + InspectorClientImpl m_inspectorClientImpl; + + WebSize m_size; + + WebPoint m_lastMousePosition; + OwnPtr<WebCore::Page> m_page; + + // This flag is set when a new navigation is detected. It is used to satisfy + // the corresponding argument to WebFrameClient::didCommitProvisionalLoad. + bool m_observedNewNavigation; +#ifndef NDEBUG + // Used to assert that the new navigation we observed is the same navigation + // when we make use of m_observedNewNavigation. + const WebCore::DocumentLoader* m_newNavigationLoader; +#endif + + // An object that can be used to manipulate m_page->settings() without linking + // against WebCore. This is lazily allocated the first time GetWebSettings() + // is called. + OwnPtr<WebSettingsImpl> m_webSettings; + + // A copy of the web drop data object we received from the browser. + RefPtr<WebCore::ChromiumDataObject> m_currentDragData; + + // The point relative to the client area where the mouse was last pressed + // down. This is used by the drag client to determine what was under the + // mouse when the drag was initiated. We need to track this here in + // WebViewImpl since DragClient::startDrag does not pass the position the + // mouse was at when the drag was initiated, only the current point, which + // can be misleading as it is usually not over the element the user actually + // dragged by the time a drag is initiated. + WebPoint m_lastMouseDownPoint; + + // Keeps track of the current zoom level. 0 means no zoom, positive numbers + // mean zoom in, negative numbers mean zoom out. + int m_zoomLevel; + + bool m_contextMenuAllowed; + + bool m_doingDragAndDrop; + + bool m_ignoreInputEvents; + + // Webkit expects keyPress events to be suppressed if the associated keyDown + // event was handled. Safari implements this behavior by peeking out the + // associated WM_CHAR event if the keydown was handled. We emulate + // this behavior by setting this flag if the keyDown was handled. + bool m_suppressNextKeypressEvent; + + // The policy for how this webview is to be initially shown. + WebNavigationPolicy m_initialNavigationPolicy; + + // Represents whether or not this object should process incoming IME events. + bool m_imeAcceptEvents; + + // True while dispatching system drag and drop events to drag/drop targets + // within this WebView. + bool m_dragTargetDispatch; + + // Valid when m_dragTargetDispatch is true; the identity of the drag data + // copied from the WebDropData object sent from the browser process. + int m_dragIdentity; + + // Valid when m_dragTargetDispatch is true. Used to override the default + // browser drop effect with the effects "none" or "copy". + enum DragTargetDropEffect { + DropEffectDefault = -1, + DropEffectNone, + DropEffectCopy + } m_dropEffect; + + // The available drag operations (copy, move link...) allowed by the source. + WebDragOperation m_operationsAllowed; + + // The current drag operation as negotiated by the source and destination. + // When not equal to DragOperationNone, the drag data can be dropped onto the + // current drop target in this WebView (the drop target can accept the drop). + WebDragOperation m_dragOperation; + + // The autocomplete popup. Kept around and reused every-time new suggestions + // should be shown. + RefPtr<WebCore::PopupContainer> m_autocompletePopup; + + // Whether the autocomplete popup is currently showing. + bool m_autocompletePopupShowing; + + // The autocomplete client. + OwnPtr<AutocompletePopupMenuClient> m_autocompletePopupClient; + + OwnPtr<WebDevToolsAgentPrivate> m_devToolsAgent; + + // Whether the webview is rendering transparently. + bool m_isTransparent; + + // Whether the user can press tab to focus links. + bool m_tabsToLinks; + + // Inspector settings. + WebString m_inspectorSettings; + +#if ENABLE(NOTIFICATIONS) + // The provider of desktop notifications; + NotificationPresenterImpl m_notificationPresenter; +#endif + + static const WebInputEvent* m_currentInputEvent; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebWorkerBase.cpp b/WebKit/chromium/src/WebWorkerBase.cpp new file mode 100644 index 0000000..85a263b --- /dev/null +++ b/WebKit/chromium/src/WebWorkerBase.cpp @@ -0,0 +1,308 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebWorkerBase.h" + +#include "GenericWorkerTask.h" +#include "MessagePortChannel.h" +#include "PlatformMessagePortChannel.h" + +#include "WebDataSourceImpl.h" +#include "WebFrameClient.h" +#include "WebFrameImpl.h" +#include "WebMessagePortChannel.h" +#include "WebView.h" +#include "WebWorkerClient.h" + +#include "WorkerThread.h" +#include <wtf/MainThread.h> + +using namespace WebCore; + +namespace WebKit { + +#if ENABLE(WORKERS) + +// Dummy WebViewDelegate - we only need it in Worker process to load a +// 'shadow page' which will initialize WebCore loader. +class WorkerWebFrameClient : public WebFrameClient { +public: + // Tell the loader to load the data into the 'shadow page' synchronously, + // so we can grab the resulting Document right after load. + virtual void didCreateDataSource(WebFrame* frame, WebDataSource* ds) + { + static_cast<WebDataSourceImpl*>(ds)->setDeferMainResourceDataLoad(false); + } + + // Lazy allocate and leak this instance. + static WorkerWebFrameClient* sharedInstance() + { + static WorkerWebFrameClient client; + return &client; + } + +private: + WorkerWebFrameClient() + { + } +}; + +// This function is called on the main thread to force to initialize some static +// values used in WebKit before any worker thread is started. This is because in +// our worker processs, we do not run any WebKit code in main thread and thus +// when multiple workers try to start at the same time, we might hit crash due +// to contention for initializing static values. +static void initializeWebKitStaticValues() +{ + static bool initialized = false; + if (!initialized) { + initialized = true; + // Note that we have to pass a URL with valid protocol in order to follow + // the path to do static value initializations. + RefPtr<SecurityOrigin> origin = + SecurityOrigin::create(KURL(ParsedURLString, "http://localhost")); + origin.release(); + } +} + +WebWorkerBase::WebWorkerBase() + : m_webView(0) + , m_askedToTerminate(false) +{ + initializeWebKitStaticValues(); +} + +WebWorkerBase::~WebWorkerBase() +{ + ASSERT(m_webView); + m_webView->close(); +} + +void WebWorkerBase::stopWorkerThread() +{ + if (m_askedToTerminate) + return; + m_askedToTerminate = true; + if (m_workerThread) + m_workerThread->stop(); +} + +void WebWorkerBase::initializeLoader(const WebURL& url) +{ + // Create 'shadow page'. This page is never displayed, it is used to proxy the + // loading requests from the worker context to the rest of WebKit and Chromium + // infrastructure. + ASSERT(!m_webView); + m_webView = WebView::create(0); + m_webView->initializeMainFrame(WorkerWebFrameClient::sharedInstance()); + + WebFrameImpl* webFrame = static_cast<WebFrameImpl*>(m_webView->mainFrame()); + + // Construct substitute data source for the 'shadow page'. We only need it + // to have same origin as the worker so the loading checks work correctly. + CString content(""); + int len = static_cast<int>(content.length()); + RefPtr<SharedBuffer> buf(SharedBuffer::create(content.data(), len)); + SubstituteData substData(buf, String("text/html"), String("UTF-8"), KURL()); + ResourceRequest request(url, CString()); + webFrame->frame()->loader()->load(request, substData, false); + + // This document will be used as 'loading context' for the worker. + m_loadingDocument = webFrame->frame()->document(); +} + +void WebWorkerBase::dispatchTaskToMainThread(PassOwnPtr<ScriptExecutionContext::Task> task) +{ + return callOnMainThread(invokeTaskMethod, task.release()); +} + +void WebWorkerBase::invokeTaskMethod(void* param) +{ + ScriptExecutionContext::Task* task = + static_cast<ScriptExecutionContext::Task*>(param); + task->performTask(0); + delete task; +} + +// WorkerObjectProxy ----------------------------------------------------------- + +void WebWorkerBase::postMessageToWorkerObject(PassRefPtr<SerializedScriptValue> message, + PassOwnPtr<MessagePortChannelArray> channels) +{ + dispatchTaskToMainThread(createCallbackTask(&postMessageTask, this, + message->toString(), channels)); +} + +void WebWorkerBase::postMessageTask(ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + String message, + PassOwnPtr<MessagePortChannelArray> channels) +{ + if (!thisPtr->client()) + return; + + WebMessagePortChannelArray webChannels(channels.get() ? channels->size() : 0); + for (size_t i = 0; i < webChannels.size(); ++i) { + webChannels[i] = (*channels)[i]->channel()->webChannelRelease(); + webChannels[i]->setClient(0); + } + + thisPtr->client()->postMessageToWorkerObject(message, webChannels); +} + +void WebWorkerBase::postExceptionToWorkerObject(const String& errorMessage, + int lineNumber, + const String& sourceURL) +{ + dispatchTaskToMainThread(createCallbackTask(&postExceptionTask, this, + errorMessage, lineNumber, + sourceURL)); +} + +void WebWorkerBase::postExceptionTask(ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + const String& errorMessage, + int lineNumber, const String& sourceURL) +{ + if (!thisPtr->commonClient()) + return; + + thisPtr->commonClient()->postExceptionToWorkerObject(errorMessage, + lineNumber, + sourceURL); +} + +void WebWorkerBase::postConsoleMessageToWorkerObject(MessageDestination destination, + MessageSource source, + MessageType type, + MessageLevel level, + const String& message, + int lineNumber, + const String& sourceURL) +{ + dispatchTaskToMainThread(createCallbackTask(&postConsoleMessageTask, this, + static_cast<int>(destination), + static_cast<int>(source), + static_cast<int>(type), + static_cast<int>(level), + message, lineNumber, sourceURL)); +} + +void WebWorkerBase::postConsoleMessageTask(ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + int destination, int source, + int type, int level, + const String& message, + int lineNumber, + const String& sourceURL) +{ + if (!thisPtr->commonClient()) + return; + thisPtr->commonClient()->postConsoleMessageToWorkerObject(destination, source, + type, level, message, + lineNumber, sourceURL); +} + +void WebWorkerBase::confirmMessageFromWorkerObject(bool hasPendingActivity) +{ + dispatchTaskToMainThread(createCallbackTask(&confirmMessageTask, this, + hasPendingActivity)); +} + +void WebWorkerBase::confirmMessageTask(ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + bool hasPendingActivity) +{ + if (!thisPtr->client()) + return; + thisPtr->client()->confirmMessageFromWorkerObject(hasPendingActivity); +} + +void WebWorkerBase::reportPendingActivity(bool hasPendingActivity) +{ + dispatchTaskToMainThread(createCallbackTask(&reportPendingActivityTask, + this, hasPendingActivity)); +} + +void WebWorkerBase::reportPendingActivityTask(ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + bool hasPendingActivity) +{ + if (!thisPtr->client()) + return; + thisPtr->client()->reportPendingActivity(hasPendingActivity); +} + +void WebWorkerBase::workerContextClosed() +{ + dispatchTaskToMainThread(createCallbackTask(&workerContextClosedTask, + this)); +} + +void WebWorkerBase::workerContextClosedTask(ScriptExecutionContext* context, + WebWorkerBase* thisPtr) +{ + if (thisPtr->commonClient()) + thisPtr->commonClient()->workerContextClosed(); +} + +void WebWorkerBase::workerContextDestroyed() +{ + dispatchTaskToMainThread(createCallbackTask(&workerContextDestroyedTask, + this)); +} + +void WebWorkerBase::workerContextDestroyedTask(ScriptExecutionContext* context, + WebWorkerBase* thisPtr) +{ + if (thisPtr->commonClient()) + thisPtr->commonClient()->workerContextDestroyed(); + // The lifetime of this proxy is controlled by the worker context. + delete thisPtr; +} + +// WorkerLoaderProxy ----------------------------------------------------------- + +void WebWorkerBase::postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task> task) +{ + ASSERT(m_loadingDocument->isDocument()); + m_loadingDocument->postTask(task); +} + +void WebWorkerBase::postTaskForModeToWorkerContext( + PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode) +{ + m_workerThread->runLoop().postTaskForMode(task, mode); +} + +#endif // ENABLE(WORKERS) + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebWorkerBase.h b/WebKit/chromium/src/WebWorkerBase.h new file mode 100644 index 0000000..0217401 --- /dev/null +++ b/WebKit/chromium/src/WebWorkerBase.h @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebWorkerBase_h +#define WebWorkerBase_h + +#if ENABLE(WORKERS) + +#include "ScriptExecutionContext.h" +#include "WorkerLoaderProxy.h" +#include "WorkerObjectProxy.h" +#include <wtf/PassOwnPtr.h> +#include <wtf/RefPtr.h> + +namespace WebCore { +class WorkerThread; +} + +namespace WebKit { +class WebCommonWorkerClient; +class WebURL; +class WebView; +class WebWorkerClient; + +// Base class for WebSharedWorkerImpl and WebWorkerImpl. It contains common +// code used by both implementation classes, including implementations of the +// WorkerObjectProxy and WorkerLoaderProxy interfaces. +class WebWorkerBase : public WebCore::WorkerObjectProxy + , public WebCore::WorkerLoaderProxy { +public: + WebWorkerBase(); + virtual ~WebWorkerBase(); + + // WebCore::WorkerObjectProxy methods: + virtual void postMessageToWorkerObject( + PassRefPtr<WebCore::SerializedScriptValue>, + PassOwnPtr<WebCore::MessagePortChannelArray>); + virtual void postExceptionToWorkerObject( + const WebCore::String&, int, const WebCore::String&); + virtual void postConsoleMessageToWorkerObject( + WebCore::MessageDestination, WebCore::MessageSource, WebCore::MessageType, + WebCore::MessageLevel, const WebCore::String&, int, const WebCore::String&); + virtual void confirmMessageFromWorkerObject(bool); + virtual void reportPendingActivity(bool); + virtual void workerContextClosed(); + virtual void workerContextDestroyed(); + + // WebCore::WorkerLoaderProxy methods: + virtual void postTaskToLoader(PassOwnPtr<WebCore::ScriptExecutionContext::Task>); + virtual void postTaskForModeToWorkerContext( + PassOwnPtr<WebCore::ScriptExecutionContext::Task>, const WebCore::String& mode); + + // Executes the given task on the main thread. + static void dispatchTaskToMainThread(PassOwnPtr<WebCore::ScriptExecutionContext::Task>); + +protected: + virtual WebWorkerClient* client() = 0; + virtual WebCommonWorkerClient* commonClient() = 0; + + void setWorkerThread(PassRefPtr<WebCore::WorkerThread> thread) { m_workerThread = thread; } + WebCore::WorkerThread* workerThread() { return m_workerThread.get(); } + + // Shuts down the worker thread. + void stopWorkerThread(); + + // Creates the shadow loader used for worker network requests. + void initializeLoader(const WebURL&); + +private: + // Function used to invoke tasks on the main thread. + static void invokeTaskMethod(void*); + + // Tasks that are run on the main thread. + static void postMessageTask( + WebCore::ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + WebCore::String message, + PassOwnPtr<WebCore::MessagePortChannelArray> channels); + static void postExceptionTask( + WebCore::ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + const WebCore::String& message, + int lineNumber, + const WebCore::String& sourceURL); + static void postConsoleMessageTask( + WebCore::ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + int destination, + int source, + int type, + int level, + const WebCore::String& message, + int lineNumber, + const WebCore::String& sourceURL); + static void confirmMessageTask( + WebCore::ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + bool hasPendingActivity); + static void reportPendingActivityTask( + WebCore::ScriptExecutionContext* context, + WebWorkerBase* thisPtr, + bool hasPendingActivity); + static void workerContextClosedTask( + WebCore::ScriptExecutionContext* context, + WebWorkerBase* thisPtr); + static void workerContextDestroyedTask( + WebCore::ScriptExecutionContext* context, + WebWorkerBase* thisPtr); + + // 'shadow page' - created to proxy loading requests from the worker. + RefPtr<WebCore::ScriptExecutionContext> m_loadingDocument; + WebView* m_webView; + bool m_askedToTerminate; + + RefPtr<WebCore::WorkerThread> m_workerThread; +}; + +} // namespace WebKit + +#endif // ENABLE(WORKERS) + +#endif diff --git a/WebKit/chromium/src/WebWorkerClientImpl.cpp b/WebKit/chromium/src/WebWorkerClientImpl.cpp new file mode 100644 index 0000000..6be03a7 --- /dev/null +++ b/WebKit/chromium/src/WebWorkerClientImpl.cpp @@ -0,0 +1,416 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebWorkerClientImpl.h" + +#if ENABLE(WORKERS) + +#include "DedicatedWorkerThread.h" +#include "ErrorEvent.h" +#include "Frame.h" +#include "FrameLoaderClient.h" +#include "GenericWorkerTask.h" +#include "MessageEvent.h" +#include "MessagePort.h" +#include "MessagePortChannel.h" +#include "ScriptExecutionContext.h" +#include "Worker.h" +#include "WorkerContext.h" +#include "WorkerContextExecutionProxy.h" +#include "WorkerMessagingProxy.h" +#include <wtf/Threading.h> + +#include "FrameLoaderClientImpl.h" +#include "PlatformMessagePortChannel.h" +#include "WebFrameClient.h" +#include "WebFrameImpl.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebMessagePortChannel.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebViewImpl.h" +#include "WebWorker.h" +#include "WebWorkerImpl.h" + +using namespace WebCore; + +namespace WebKit { + +// When WebKit creates a WorkerContextProxy object, we check if we're in the +// renderer or worker process. If the latter, then we just use +// WorkerMessagingProxy. +// +// If we're in the renderer process, then we need use the glue provided +// WebWorker object to talk to the worker process over IPC. The worker process +// talks to Worker* using WorkerObjectProxy, which we implement on +// WebWorkerClientImpl. +// +// Note that if we're running each worker in a separate process, then nested +// workers end up using the same codepath as the renderer process. + +// static +WorkerContextProxy* WebWorkerClientImpl::createWorkerContextProxy(Worker* worker) +{ + // Special behavior for multiple workers per process. + // FIXME: v8 doesn't support more than one workers per process. + // if (!worker->scriptExecutionContext()->isDocument()) + // return new WorkerMessagingProxy(worker); + + WebWorker* webWorker = 0; + WebWorkerClientImpl* proxy = new WebWorkerClientImpl(worker); + + if (worker->scriptExecutionContext()->isDocument()) { + Document* document = static_cast<Document*>( + worker->scriptExecutionContext()); + WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame()); + webWorker = webFrame->client()->createWorker(webFrame, proxy); + } else { + WorkerContextExecutionProxy* currentContext = + WorkerContextExecutionProxy::retrieve(); + if (!currentContext) { + ASSERT_NOT_REACHED(); + return 0; + } + + DedicatedWorkerThread* thread = + static_cast<DedicatedWorkerThread*>(currentContext->workerContext()->thread()); + WorkerObjectProxy* workerObjectProxy = &thread->workerObjectProxy(); + WebWorkerImpl* impl = reinterpret_cast<WebWorkerImpl*>(workerObjectProxy); + webWorker = impl->client()->createWorker(proxy); + } + + proxy->setWebWorker(webWorker); + return proxy; +} + +WebWorkerClientImpl::WebWorkerClientImpl(Worker* worker) + : m_scriptExecutionContext(worker->scriptExecutionContext()) + , m_worker(worker) + , m_askedToTerminate(false) + , m_unconfirmedMessageCount(0) + , m_workerContextHadPendingActivity(false) + , m_workerThreadId(currentThread()) +{ +} + +WebWorkerClientImpl::~WebWorkerClientImpl() +{ +} + +void WebWorkerClientImpl::setWebWorker(WebWorker* webWorker) +{ + m_webWorker = webWorker; +} + +void WebWorkerClientImpl::startWorkerContext(const KURL& scriptURL, + const String& userAgent, + const String& sourceCode) +{ + // Worker.terminate() could be called from JS before the context is started. + if (m_askedToTerminate) + return; + if (!isMainThread()) { + WebWorkerBase::dispatchTaskToMainThread(createCallbackTask( + &startWorkerContextTask, + this, + scriptURL.string(), + userAgent, + sourceCode)); + return; + } + m_webWorker->startWorkerContext(scriptURL, userAgent, sourceCode); +} + +void WebWorkerClientImpl::terminateWorkerContext() +{ + if (m_askedToTerminate) + return; + m_askedToTerminate = true; + if (!isMainThread()) { + WebWorkerBase::dispatchTaskToMainThread(createCallbackTask(&terminateWorkerContextTask, this)); + return; + } + m_webWorker->terminateWorkerContext(); +} + +void WebWorkerClientImpl::postMessageToWorkerContext( + PassRefPtr<SerializedScriptValue> message, + PassOwnPtr<MessagePortChannelArray> channels) +{ + // Worker.terminate() could be called from JS before the context is started. + if (m_askedToTerminate) + return; + ++m_unconfirmedMessageCount; + if (!isMainThread()) { + WebWorkerBase::dispatchTaskToMainThread(createCallbackTask(&postMessageToWorkerContextTask, + this, + message->toString(), + channels)); + return; + } + WebMessagePortChannelArray webChannels(channels.get() ? channels->size() : 0); + for (size_t i = 0; i < webChannels.size(); ++i) { + WebMessagePortChannel* webchannel = + (*channels)[i]->channel()->webChannelRelease(); + webchannel->setClient(0); + webChannels[i] = webchannel; + } + m_webWorker->postMessageToWorkerContext(message->toString(), webChannels); +} + +bool WebWorkerClientImpl::hasPendingActivity() const +{ + return !m_askedToTerminate + && (m_unconfirmedMessageCount || m_workerContextHadPendingActivity); +} + +void WebWorkerClientImpl::workerObjectDestroyed() +{ + if (isMainThread()) { + m_webWorker->workerObjectDestroyed(); + m_worker = 0; + } + // Even if this is called on the main thread, there could be a queued task for + // this object, so don't delete it right away. + WebWorkerBase::dispatchTaskToMainThread(createCallbackTask(&workerObjectDestroyedTask, + this)); +} + +void WebWorkerClientImpl::postMessageToWorkerObject(const WebString& message, + const WebMessagePortChannelArray& channels) +{ + OwnPtr<MessagePortChannelArray> channels2; + if (channels.size()) { + channels2 = new MessagePortChannelArray(channels.size()); + for (size_t i = 0; i < channels.size(); ++i) { + RefPtr<PlatformMessagePortChannel> platform_channel = + PlatformMessagePortChannel::create(channels[i]); + channels[i]->setClient(platform_channel.get()); + (*channels2)[i] = MessagePortChannel::create(platform_channel); + } + } + + if (currentThread() != m_workerThreadId) { + m_scriptExecutionContext->postTask(createCallbackTask(&postMessageToWorkerObjectTask, + this, + String(message), + channels2.release())); + return; + } + + postMessageToWorkerObjectTask(m_scriptExecutionContext.get(), this, + message, channels2.release()); +} + +void WebWorkerClientImpl::postExceptionToWorkerObject(const WebString& errorMessage, + int lineNumber, + const WebString& sourceURL) +{ + if (currentThread() != m_workerThreadId) { + m_scriptExecutionContext->postTask(createCallbackTask(&postExceptionToWorkerObjectTask, + this, + String(errorMessage), + lineNumber, + String(sourceURL))); + return; + } + + bool handled = false; + handled = m_worker->dispatchEvent(ErrorEvent::create(errorMessage, + sourceURL, + lineNumber)); + if (!handled) + m_scriptExecutionContext->reportException(errorMessage, lineNumber, sourceURL); +} + +void WebWorkerClientImpl::postConsoleMessageToWorkerObject(int destinationId, + int sourceId, + int messageType, + int messageLevel, + const WebString& message, + int lineNumber, + const WebString& sourceURL) +{ + if (currentThread() != m_workerThreadId) { + m_scriptExecutionContext->postTask(createCallbackTask(&postConsoleMessageToWorkerObjectTask, + this, + destinationId, + sourceId, + messageType, + messageLevel, + String(message), + lineNumber, + String(sourceURL))); + return; + } + + m_scriptExecutionContext->addMessage(static_cast<MessageDestination>(destinationId), + static_cast<MessageSource>(sourceId), + static_cast<MessageType>(messageType), + static_cast<MessageLevel>(messageLevel), + String(message), lineNumber, + String(sourceURL)); +} + +void WebWorkerClientImpl::confirmMessageFromWorkerObject(bool hasPendingActivity) +{ + // unconfirmed_message_count_ can only be updated on the thread where it's + // accessed. Otherwise there are race conditions with v8's garbage + // collection. + m_scriptExecutionContext->postTask(createCallbackTask(&confirmMessageFromWorkerObjectTask, + this)); +} + +void WebWorkerClientImpl::reportPendingActivity(bool hasPendingActivity) +{ + // See above comment in confirmMessageFromWorkerObject. + m_scriptExecutionContext->postTask(createCallbackTask(&reportPendingActivityTask, + this, + hasPendingActivity)); +} + +void WebWorkerClientImpl::workerContextDestroyed() +{ +} + +void WebWorkerClientImpl::workerContextClosed() +{ +} + +void WebWorkerClientImpl::startWorkerContextTask(ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + const String& scriptURL, + const String& userAgent, + const String& sourceCode) +{ + thisPtr->m_webWorker->startWorkerContext(KURL(ParsedURLString, scriptURL), + userAgent, sourceCode); +} + +void WebWorkerClientImpl::terminateWorkerContextTask(ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr) +{ + thisPtr->m_webWorker->terminateWorkerContext(); +} + +void WebWorkerClientImpl::postMessageToWorkerContextTask(ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + const String& message, + PassOwnPtr<MessagePortChannelArray> channels) +{ + WebMessagePortChannelArray webChannels(channels.get() ? channels->size() : 0); + + for (size_t i = 0; i < webChannels.size(); ++i) { + webChannels[i] = (*channels)[i]->channel()->webChannelRelease(); + webChannels[i]->setClient(0); + } + + thisPtr->m_webWorker->postMessageToWorkerContext(message, webChannels); +} + +void WebWorkerClientImpl::workerObjectDestroyedTask(ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr) +{ + if (thisPtr->m_worker) // Check we haven't alread called this. + thisPtr->m_webWorker->workerObjectDestroyed(); + delete thisPtr; +} + +void WebWorkerClientImpl::postMessageToWorkerObjectTask( + ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + const String& message, + PassOwnPtr<MessagePortChannelArray> channels) +{ + + if (thisPtr->m_worker) { + OwnPtr<MessagePortArray> ports = + MessagePort::entanglePorts(*context, channels.release()); + RefPtr<SerializedScriptValue> serializedMessage = + SerializedScriptValue::create(message); + thisPtr->m_worker->dispatchEvent(MessageEvent::create(ports.release(), + serializedMessage.release())); + } +} + +void WebWorkerClientImpl::postExceptionToWorkerObjectTask( + ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + const String& errorMessage, + int lineNumber, + const String& sourceURL) +{ + bool handled = false; + if (thisPtr->m_worker) + handled = thisPtr->m_worker->dispatchEvent(ErrorEvent::create(errorMessage, + sourceURL, + lineNumber)); + if (!handled) + thisPtr->m_scriptExecutionContext->reportException(errorMessage, + lineNumber, + sourceURL); +} + +void WebWorkerClientImpl::postConsoleMessageToWorkerObjectTask(ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + int destinationId, + int sourceId, + int messageType, + int messageLevel, + const String& message, + int lineNumber, + const String& sourceURL) +{ + thisPtr->m_scriptExecutionContext->addMessage(static_cast<MessageDestination>(destinationId), + static_cast<MessageSource>(sourceId), + static_cast<MessageType>(messageType), + static_cast<MessageLevel>(messageLevel), + message, lineNumber, + sourceURL); +} + +void WebWorkerClientImpl::confirmMessageFromWorkerObjectTask(ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr) +{ + thisPtr->m_unconfirmedMessageCount--; +} + +void WebWorkerClientImpl::reportPendingActivityTask(ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + bool hasPendingActivity) +{ + thisPtr->m_workerContextHadPendingActivity = hasPendingActivity; +} + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebWorkerClientImpl.h b/WebKit/chromium/src/WebWorkerClientImpl.h new file mode 100644 index 0000000..63acebc --- /dev/null +++ b/WebKit/chromium/src/WebWorkerClientImpl.h @@ -0,0 +1,156 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebWorkerClientImpl_h +#define WebWorkerClientImpl_h + +#if ENABLE(WORKERS) + +// FIXME: fix to just "WebWorkerClient.h" once nobody in glue depends on us. +#include "../public/WebWorkerClient.h" + +#include "WorkerContextProxy.h" +#include <wtf/PassOwnPtr.h> +#include <wtf/RefPtr.h> + +namespace WebCore { +class ScriptExecutionContext; +} + +namespace WebKit { +class WebWorker; + +// The purpose of this class is to provide a WorkerContextProxy +// implementation that we can give to WebKit. Internally, it converts the +// data types to Chrome compatible ones so that renderer code can use it over +// IPC. +class WebWorkerClientImpl : public WebCore::WorkerContextProxy + , public WebWorkerClient { +public: + WebWorkerClientImpl(WebCore::Worker*); + + // WebCore::WorkerContextProxy Factory. + static WebCore::WorkerContextProxy* createWorkerContextProxy(WebCore::Worker*); + void setWebWorker(WebWorker*); + + // WebCore::WorkerContextProxy methods: + // These are called on the thread that created the worker. In the renderer + // process, this will be the main WebKit thread. In the worker process, this + // will be the thread of the executing worker (not the main WebKit thread). + virtual void startWorkerContext(const WebCore::KURL&, + const WebCore::String&, + const WebCore::String&); + virtual void terminateWorkerContext(); + virtual void postMessageToWorkerContext( + PassRefPtr<WebCore::SerializedScriptValue> message, + PassOwnPtr<WebCore::MessagePortChannelArray> channels); + virtual bool hasPendingActivity() const; + virtual void workerObjectDestroyed(); + + // WebWorkerClient methods: + // These are called on the main WebKit thread. + virtual void postMessageToWorkerObject(const WebString&, const WebMessagePortChannelArray&); + virtual void postExceptionToWorkerObject(const WebString&, int, const WebString&); + virtual void postConsoleMessageToWorkerObject(int, int, int, int, const WebString&, + int, const WebString&); + virtual void confirmMessageFromWorkerObject(bool); + virtual void reportPendingActivity(bool); + virtual void workerContextClosed(); + virtual void workerContextDestroyed(); + virtual WebWorker* createWorker(WebWorkerClient*) { return 0; } + virtual WebNotificationPresenter* notificationPresenter() + { + // FIXME: Notifications not yet supported in workers. + return 0; + } + +private: + virtual ~WebWorkerClientImpl(); + + // Methods used to support WebWorkerClientImpl being constructed on worker + // threads. + // These tasks are dispatched on the WebKit thread. + static void startWorkerContextTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + const WebCore::String& scriptURL, + const WebCore::String& userAgent, + const WebCore::String& sourceCode); + static void terminateWorkerContextTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr); + static void postMessageToWorkerContextTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + const WebCore::String& message, + PassOwnPtr<WebCore::MessagePortChannelArray> channels); + static void workerObjectDestroyedTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr); + + // These tasks are dispatched on the thread that created the worker (i.e. + // main WebKit thread in renderer process, and the worker thread in the + // worker process). + static void postMessageToWorkerObjectTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + const WebCore::String& message, + PassOwnPtr<WebCore::MessagePortChannelArray> channels); + static void postExceptionToWorkerObjectTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + const WebCore::String& message, + int lineNumber, + const WebCore::String& sourceURL); + static void postConsoleMessageToWorkerObjectTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + int destinationId, + int sourceId, + int messageType, + int messageLevel, + const WebCore::String& message, + int lineNumber, + const WebCore::String& sourceURL); + static void confirmMessageFromWorkerObjectTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr); + static void reportPendingActivityTask(WebCore::ScriptExecutionContext* context, + WebWorkerClientImpl* thisPtr, + bool hasPendingActivity); + + // Guard against context from being destroyed before a worker exits. + RefPtr<WebCore::ScriptExecutionContext> m_scriptExecutionContext; + + WebCore::Worker* m_worker; + WebWorker* m_webWorker; + bool m_askedToTerminate; + unsigned m_unconfirmedMessageCount; + bool m_workerContextHadPendingActivity; + ThreadIdentifier m_workerThreadId; +}; + +} // namespace WebKit; + +#endif // ENABLE(WORKERS) + +#endif diff --git a/WebKit/chromium/src/WebWorkerImpl.cpp b/WebKit/chromium/src/WebWorkerImpl.cpp new file mode 100644 index 0000000..744be30 --- /dev/null +++ b/WebKit/chromium/src/WebWorkerImpl.cpp @@ -0,0 +1,158 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebWorkerImpl.h" + +#include "DedicatedWorkerContext.h" +#include "DedicatedWorkerThread.h" +#include "GenericWorkerTask.h" +#include "KURL.h" +#include "MessageEvent.h" +#include "MessagePort.h" +#include "MessagePortChannel.h" +#include "ScriptExecutionContext.h" +#include "SecurityOrigin.h" +#include "SerializedScriptValue.h" +#include "SubstituteData.h" +#include <wtf/Threading.h> + +#include "PlatformMessagePortChannel.h" +#include "WebMessagePortChannel.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebWorkerClient.h" + +using namespace WebCore; + +namespace WebKit { + +#if ENABLE(WORKERS) + +WebWorker* WebWorker::create(WebWorkerClient* client) +{ + return new WebWorkerImpl(client); +} + + +WebWorkerImpl::WebWorkerImpl(WebWorkerClient* client) + : m_client(client) +{ +} + +WebWorkerImpl::~WebWorkerImpl() +{ +} + +WebCommonWorkerClient* WebWorkerImpl::commonClient() +{ + return m_client; +} + +void WebWorkerImpl::postMessageToWorkerContextTask(WebCore::ScriptExecutionContext* context, + WebWorkerImpl* thisPtr, + const String& message, + PassOwnPtr<MessagePortChannelArray> channels) +{ + ASSERT(context->isWorkerContext()); + DedicatedWorkerContext* workerContext = + static_cast<DedicatedWorkerContext*>(context); + + OwnPtr<MessagePortArray> ports = + MessagePort::entanglePorts(*context, channels.release()); + RefPtr<SerializedScriptValue> serializedMessage = + SerializedScriptValue::create(message); + workerContext->dispatchEvent(MessageEvent::create( + ports.release(), serializedMessage.release())); + thisPtr->confirmMessageFromWorkerObject(workerContext->hasPendingActivity()); +} + +// WebWorker ------------------------------------------------------------------- + +void WebWorkerImpl::startWorkerContext(const WebURL& scriptUrl, + const WebString& userAgent, + const WebString& sourceCode) +{ + initializeLoader(scriptUrl); + setWorkerThread(DedicatedWorkerThread::create(scriptUrl, userAgent, + sourceCode, *this, *this)); + // Worker initialization means a pending activity. + reportPendingActivity(true); + workerThread()->start(); +} + +void WebWorkerImpl::terminateWorkerContext() +{ + stopWorkerThread(); +} + +void WebWorkerImpl::postMessageToWorkerContext(const WebString& message, + const WebMessagePortChannelArray& webChannels) +{ + OwnPtr<MessagePortChannelArray> channels; + if (webChannels.size()) { + channels = new MessagePortChannelArray(webChannels.size()); + for (size_t i = 0; i < webChannels.size(); ++i) { + RefPtr<PlatformMessagePortChannel> platform_channel = + PlatformMessagePortChannel::create(webChannels[i]); + webChannels[i]->setClient(platform_channel.get()); + (*channels)[i] = MessagePortChannel::create(platform_channel); + } + } + + workerThread()->runLoop().postTask( + createCallbackTask(&postMessageToWorkerContextTask, + this, String(message), channels.release())); +} + +void WebWorkerImpl::workerObjectDestroyed() +{ + // Worker object in the renderer was destroyed, perhaps a result of GC. + // For us, it's a signal to start terminating the WorkerContext too. + // FIXME: when 'kill a worker' html5 spec algorithm is implemented, it + // should be used here instead of 'terminate a worker'. + terminateWorkerContext(); +} + +void WebWorkerImpl::clientDestroyed() +{ + m_client = 0; +} + +#else + +WebWorker* WebWorker::create(WebWorkerClient* client) +{ + return 0; +} + +#endif // ENABLE(WORKERS) + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebWorkerImpl.h b/WebKit/chromium/src/WebWorkerImpl.h new file mode 100644 index 0000000..bec96cd --- /dev/null +++ b/WebKit/chromium/src/WebWorkerImpl.h @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebWorkerImpl_h +#define WebWorkerImpl_h + +#include "WebWorker.h" + +#if ENABLE(WORKERS) + +#include "ScriptExecutionContext.h" + +#include "WebWorkerBase.h" + +namespace WebKit { +class WebView; + +// This class is used by the worker process code to talk to the WebCore::Worker +// implementation. It can't use it directly since it uses WebKit types, so this +// class converts the data types. When the WebCore::Worker object wants to call +// WebCore::WorkerObjectProxy, this class will conver to Chrome data types first +// and then call the supplied WebWorkerClient. +class WebWorkerImpl : public WebWorkerBase, public WebWorker { +public: + explicit WebWorkerImpl(WebWorkerClient* client); + + // WebWorker methods: + virtual void startWorkerContext(const WebURL&, const WebString&, const WebString&); + virtual void terminateWorkerContext(); + virtual void postMessageToWorkerContext(const WebString&, const WebMessagePortChannelArray&); + virtual void workerObjectDestroyed(); + virtual void clientDestroyed(); + + // WebWorkerBase methods: + virtual WebWorkerClient* client() { return m_client; } + virtual WebCommonWorkerClient* commonClient(); + +private: + virtual ~WebWorkerImpl(); + + // Tasks that are run on the worker thread. + static void postMessageToWorkerContextTask( + WebCore::ScriptExecutionContext* context, + WebWorkerImpl* thisPtr, + const WebCore::String& message, + PassOwnPtr<WebCore::MessagePortChannelArray> channels); + + WebWorkerClient* m_client; + +}; + +} // namespace WebKit + +#endif // ENABLE(WORKERS) + +#endif diff --git a/WebKit/chromium/src/WrappedResourceRequest.h b/WebKit/chromium/src/WrappedResourceRequest.h new file mode 100644 index 0000000..97311db --- /dev/null +++ b/WebKit/chromium/src/WrappedResourceRequest.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WrappedResourceRequest_h +#define WrappedResourceRequest_h + +// FIXME: This relative path is a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebURLRequest.h" +#include "WebURLRequestPrivate.h" + +namespace WebKit { + +class WrappedResourceRequest : public WebURLRequest { +public: + ~WrappedResourceRequest() + { + reset(); // Need to drop reference to m_handle + } + + WrappedResourceRequest() { } + + WrappedResourceRequest(WebCore::ResourceRequest& resourceRequest) + { + bind(resourceRequest); + } + + WrappedResourceRequest(const WebCore::ResourceRequest& resourceRequest) + { + bind(resourceRequest); + } + + void bind(WebCore::ResourceRequest& resourceRequest) + { + m_handle.m_resourceRequest = &resourceRequest; + assign(&m_handle); + } + + void bind(const WebCore::ResourceRequest& resourceRequest) + { + bind(*const_cast<WebCore::ResourceRequest*>(&resourceRequest)); + } + +private: + class Handle : public WebURLRequestPrivate { + public: + virtual void dispose() { m_resourceRequest = 0; } + }; + + Handle m_handle; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WrappedResourceResponse.h b/WebKit/chromium/src/WrappedResourceResponse.h new file mode 100644 index 0000000..af4f88f --- /dev/null +++ b/WebKit/chromium/src/WrappedResourceResponse.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WrappedResourceResponse_h +#define WrappedResourceResponse_h + +// FIXME: This relative path is a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebURLResponse.h" +#include "WebURLResponsePrivate.h" + +namespace WebKit { + +class WrappedResourceResponse : public WebURLResponse { +public: + ~WrappedResourceResponse() + { + reset(); // Need to drop reference to m_handle + } + + WrappedResourceResponse() { } + + WrappedResourceResponse(WebCore::ResourceResponse& resourceResponse) + { + bind(resourceResponse); + } + + WrappedResourceResponse(const WebCore::ResourceResponse& resourceResponse) + { + bind(resourceResponse); + } + + void bind(WebCore::ResourceResponse& resourceResponse) + { + m_handle.m_resourceResponse = &resourceResponse; + assign(&m_handle); + } + + void bind(const WebCore::ResourceResponse& resourceResponse) + { + bind(*const_cast<WebCore::ResourceResponse*>(&resourceResponse)); + } + +private: + class Handle : public WebURLResponsePrivate { + public: + virtual void dispose() { m_resourceResponse = 0; } + }; + + Handle m_handle; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/gtk/WebFontInfo.cpp b/WebKit/chromium/src/gtk/WebFontInfo.cpp new file mode 100644 index 0000000..76ed618 --- /dev/null +++ b/WebKit/chromium/src/gtk/WebFontInfo.cpp @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebFontInfo.h" + +#include <fontconfig/fontconfig.h> +#include <string.h> +#include <unicode/utf16.h> + +namespace WebKit { + +WebCString WebFontInfo::familyForChars(const WebUChar* characters, size_t numCharacters) +{ + FcCharSet* cset = FcCharSetCreate(); + for (size_t i = 0; i < numCharacters; ++i) { + if (U16_IS_SURROGATE(characters[i]) + && U16_IS_SURROGATE_LEAD(characters[i]) + && i != numCharacters - 1 + && U16_IS_TRAIL(characters[i + 1])) { + FcCharSetAddChar(cset, U16_GET_SUPPLEMENTARY(characters[i], characters[i+1])); + i++; + } else + FcCharSetAddChar(cset, characters[i]); + } + FcPattern* pattern = FcPatternCreate(); + + FcValue fcvalue; + fcvalue.type = FcTypeCharSet; + fcvalue.u.c = cset; + FcPatternAdd(pattern, FC_CHARSET, fcvalue, 0); + + fcvalue.type = FcTypeBool; + fcvalue.u.b = FcTrue; + FcPatternAdd(pattern, FC_SCALABLE, fcvalue, 0); + + FcConfigSubstitute(0, pattern, FcMatchPattern); + FcDefaultSubstitute(pattern); + + FcResult result; + FcFontSet* fontSet = FcFontSort(0, pattern, 0, 0, &result); + FcPatternDestroy(pattern); + FcCharSetDestroy(cset); + + if (!fontSet) + return WebCString(); + + // Older versions of fontconfig have a bug where they cannot select + // only scalable fonts so we have to manually filter the results. + for (int i = 0; i < fontSet->nfont; ++i) { + FcPattern* current = fontSet->fonts[i]; + FcBool isScalable; + + if (FcPatternGetBool(current, FC_SCALABLE, 0, &isScalable) != FcResultMatch + || !isScalable) + continue; + + // fontconfig can also return fonts which are unreadable + FcChar8* cFilename; + if (FcPatternGetString(current, FC_FILE, 0, &cFilename) != FcResultMatch) + continue; + + if (access(reinterpret_cast<char*>(cFilename), R_OK)) + continue; + + FcChar8* family; + WebCString result; + if (FcPatternGetString(current, FC_FAMILY, 0, &family) == FcResultMatch) { + const char* charFamily = reinterpret_cast<char*>(family); + result = WebCString(charFamily, strlen(charFamily)); + } + FcFontSetDestroy(fontSet); + return result; + } + + FcFontSetDestroy(fontSet); + return WebCString(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/gtk/WebInputEventFactory.cpp b/WebKit/chromium/src/gtk/WebInputEventFactory.cpp new file mode 100644 index 0000000..7125a16 --- /dev/null +++ b/WebKit/chromium/src/gtk/WebInputEventFactory.cpp @@ -0,0 +1,496 @@ +/* + * Copyright (C) 2006-2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebInputEventFactory.h" + +#include "KeyboardCodes.h" +#include "KeyCodeConversion.h" + +#include "WebInputEvent.h" + +#include <gdk/gdk.h> +#include <gdk/gdkkeysyms.h> +#include <gtk/gtk.h> +#include <gtk/gtkversion.h> + +#include <wtf/Assertions.h> + +namespace { + +gint getDoubleClickTime() +{ + static GtkSettings* settings = gtk_settings_get_default(); + gint doubleClickTime = 250; + g_object_get(G_OBJECT(settings), "gtk-double-click-time", &doubleClickTime, 0); + return doubleClickTime; +} + +} // namespace + +namespace WebKit { + +static double gdkEventTimeToWebEventTime(guint32 time) +{ + // Convert from time in ms to time in sec. + return time / 1000.0; +} + +static int gdkStateToWebEventModifiers(guint state) +{ + int modifiers = 0; + if (state & GDK_SHIFT_MASK) + modifiers |= WebInputEvent::ShiftKey; + if (state & GDK_CONTROL_MASK) + modifiers |= WebInputEvent::ControlKey; + if (state & GDK_MOD1_MASK) + modifiers |= WebInputEvent::AltKey; +#if GTK_CHECK_VERSION(2, 10, 0) + if (state & GDK_META_MASK) + modifiers |= WebInputEvent::MetaKey; +#endif + if (state & GDK_BUTTON1_MASK) + modifiers |= WebInputEvent::LeftButtonDown; + if (state & GDK_BUTTON2_MASK) + modifiers |= WebInputEvent::MiddleButtonDown; + if (state & GDK_BUTTON3_MASK) + modifiers |= WebInputEvent::RightButtonDown; + return modifiers; +} + +static int gdkEventToWindowsKeyCode(const GdkEventKey* event) +{ + static const unsigned int hardwareCodeToGDKKeyval[] = { + 0, // 0x00: + 0, // 0x01: + 0, // 0x02: + 0, // 0x03: + 0, // 0x04: + 0, // 0x05: + 0, // 0x06: + 0, // 0x07: + 0, // 0x08: + 0, // 0x09: GDK_Escape + GDK_1, // 0x0A: GDK_1 + GDK_2, // 0x0B: GDK_2 + GDK_3, // 0x0C: GDK_3 + GDK_4, // 0x0D: GDK_4 + GDK_5, // 0x0E: GDK_5 + GDK_6, // 0x0F: GDK_6 + GDK_7, // 0x10: GDK_7 + GDK_8, // 0x11: GDK_8 + GDK_9, // 0x12: GDK_9 + GDK_0, // 0x13: GDK_0 + GDK_minus, // 0x14: GDK_minus + GDK_equal, // 0x15: GDK_equal + 0, // 0x16: GDK_BackSpace + 0, // 0x17: GDK_Tab + GDK_q, // 0x18: GDK_q + GDK_w, // 0x19: GDK_w + GDK_e, // 0x1A: GDK_e + GDK_r, // 0x1B: GDK_r + GDK_t, // 0x1C: GDK_t + GDK_y, // 0x1D: GDK_y + GDK_u, // 0x1E: GDK_u + GDK_i, // 0x1F: GDK_i + GDK_o, // 0x20: GDK_o + GDK_p, // 0x21: GDK_p + GDK_bracketleft, // 0x22: GDK_bracketleft + GDK_bracketright, // 0x23: GDK_bracketright + 0, // 0x24: GDK_Return + 0, // 0x25: GDK_Control_L + GDK_a, // 0x26: GDK_a + GDK_s, // 0x27: GDK_s + GDK_d, // 0x28: GDK_d + GDK_f, // 0x29: GDK_f + GDK_g, // 0x2A: GDK_g + GDK_h, // 0x2B: GDK_h + GDK_j, // 0x2C: GDK_j + GDK_k, // 0x2D: GDK_k + GDK_l, // 0x2E: GDK_l + GDK_semicolon, // 0x2F: GDK_semicolon + GDK_apostrophe, // 0x30: GDK_apostrophe + GDK_grave, // 0x31: GDK_grave + 0, // 0x32: GDK_Shift_L + GDK_backslash, // 0x33: GDK_backslash + GDK_z, // 0x34: GDK_z + GDK_x, // 0x35: GDK_x + GDK_c, // 0x36: GDK_c + GDK_v, // 0x37: GDK_v + GDK_b, // 0x38: GDK_b + GDK_n, // 0x39: GDK_n + GDK_m, // 0x3A: GDK_m + GDK_comma, // 0x3B: GDK_comma + GDK_period, // 0x3C: GDK_period + GDK_slash, // 0x3D: GDK_slash + 0, // 0x3E: GDK_Shift_R + }; + + // |windowsKeyCode| has to include a valid virtual-key code even when we + // use non-US layouts, e.g. even when we type an 'A' key of a US keyboard + // on the Hebrew layout, |windowsKeyCode| should be VK_A. + // On the other hand, |event->keyval| value depends on the current + // GdkKeymap object, i.e. when we type an 'A' key of a US keyboard on + // the Hebrew layout, |event->keyval| becomes GDK_hebrew_shin and this + // WebCore::windowsKeyCodeForKeyEvent() call returns 0. + // To improve compatibilty with Windows, we use |event->hardware_keycode| + // for retrieving its Windows key-code for the keys when the + // WebCore::windowsKeyCodeForEvent() call returns 0. + // We shouldn't use |event->hardware_keycode| for keys that GdkKeymap + // objects cannot change because |event->hardware_keycode| doesn't change + // even when we change the layout options, e.g. when we swap a control + // key and a caps-lock key, GTK doesn't swap their + // |event->hardware_keycode| values but swap their |event->keyval| values. + int windowsKeyCode = WebCore::windowsKeyCodeForKeyEvent(event->keyval); + if (windowsKeyCode) + return windowsKeyCode; + + const int tableSize = sizeof(hardwareCodeToGDKKeyval) / sizeof(hardwareCodeToGDKKeyval[0]); + if (event->hardware_keycode < tableSize) { + int keyval = hardwareCodeToGDKKeyval[event->hardware_keycode]; + if (keyval) + return WebCore::windowsKeyCodeForKeyEvent(keyval); + } + + // This key is one that keyboard-layout drivers cannot change. + // Use |event->keyval| to retrieve its |windowsKeyCode| value. + return WebCore::windowsKeyCodeForKeyEvent(event->keyval); +} + +// Gets the corresponding control character of a specified key code. See: +// http://en.wikipedia.org/wiki/Control_characters +// We emulate Windows behavior here. +static WebUChar getControlCharacter(int windowsKeyCode, bool shift) +{ + if (windowsKeyCode >= WebCore::VKEY_A && windowsKeyCode <= WebCore::VKEY_Z) { + // ctrl-A ~ ctrl-Z map to \x01 ~ \x1A + return windowsKeyCode - WebCore::VKEY_A + 1; + } + if (shift) { + // following graphics chars require shift key to input. + switch (windowsKeyCode) { + // ctrl-@ maps to \x00 (Null byte) + case WebCore::VKEY_2: + return 0; + // ctrl-^ maps to \x1E (Record separator, Information separator two) + case WebCore::VKEY_6: + return 0x1E; + // ctrl-_ maps to \x1F (Unit separator, Information separator one) + case WebCore::VKEY_OEM_MINUS: + return 0x1F; + // Returns 0 for all other keys to avoid inputting unexpected chars. + default: + return 0; + } + } else { + switch (windowsKeyCode) { + // ctrl-[ maps to \x1B (Escape) + case WebCore::VKEY_OEM_4: + return 0x1B; + // ctrl-\ maps to \x1C (File separator, Information separator four) + case WebCore::VKEY_OEM_5: + return 0x1C; + // ctrl-] maps to \x1D (Group separator, Information separator three) + case WebCore::VKEY_OEM_6: + return 0x1D; + // ctrl-Enter maps to \x0A (Line feed) + case WebCore::VKEY_RETURN: + return 0x0A; + // Returns 0 for all other keys to avoid inputting unexpected chars. + default: + return 0; + } + } +} + +// WebKeyboardEvent ----------------------------------------------------------- + +WebKeyboardEvent WebInputEventFactory::keyboardEvent(const GdkEventKey* event) +{ + WebKeyboardEvent result; + + result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); + result.modifiers = gdkStateToWebEventModifiers(event->state); + + switch (event->type) { + case GDK_KEY_RELEASE: + result.type = WebInputEvent::KeyUp; + break; + case GDK_KEY_PRESS: + result.type = WebInputEvent::RawKeyDown; + break; + default: + ASSERT_NOT_REACHED(); + } + + // According to MSDN: + // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx + // Key events with Alt modifier and F10 are system key events. + // We just emulate this behavior. It's necessary to prevent webkit from + // processing keypress event generated by alt-d, etc. + // F10 is not special on Linux, so don't treat it as system key. + if (result.modifiers & WebInputEvent::AltKey) + result.isSystemKey = true; + + // The key code tells us which physical key was pressed (for example, the + // A key went down or up). It does not determine whether A should be lower + // or upper case. This is what text does, which should be the keyval. + result.windowsKeyCode = gdkEventToWindowsKeyCode(event); + result.nativeKeyCode = event->hardware_keycode; + + if (result.windowsKeyCode == WebCore::VKEY_RETURN) + // We need to treat the enter key as a key press of character \r. This + // is apparently just how webkit handles it and what it expects. + result.unmodifiedText[0] = '\r'; + else + // FIXME: fix for non BMP chars + result.unmodifiedText[0] = + static_cast<WebUChar>(gdk_keyval_to_unicode(event->keyval)); + + // If ctrl key is pressed down, then control character shall be input. + if (result.modifiers & WebInputEvent::ControlKey) + result.text[0] = getControlCharacter( + result.windowsKeyCode, result.modifiers & WebInputEvent::ShiftKey); + else + result.text[0] = result.unmodifiedText[0]; + + result.setKeyIdentifierFromWindowsKeyCode(); + + // FIXME: Do we need to set IsAutoRepeat or IsKeyPad? + + return result; +} + +WebKeyboardEvent WebInputEventFactory::keyboardEvent(wchar_t character, int state, double timeStampSeconds) +{ + // keyboardEvent(const GdkEventKey*) depends on the GdkEventKey object and + // it is hard to use/ it from signal handlers which don't use GdkEventKey + // objects (e.g. GtkIMContext signal handlers.) For such handlers, this + // function creates a WebInputEvent::Char event without using a + // GdkEventKey object. + WebKeyboardEvent result; + result.type = WebKit::WebInputEvent::Char; + result.timeStampSeconds = timeStampSeconds; + result.modifiers = gdkStateToWebEventModifiers(state); + result.windowsKeyCode = character; + result.nativeKeyCode = character; + result.text[0] = character; + result.unmodifiedText[0] = character; + + // According to MSDN: + // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx + // Key events with Alt modifier and F10 are system key events. + // We just emulate this behavior. It's necessary to prevent webkit from + // processing keypress event generated by alt-d, etc. + // F10 is not special on Linux, so don't treat it as system key. + if (result.modifiers & WebInputEvent::AltKey) + result.isSystemKey = true; + + return result; +} + +// WebMouseEvent -------------------------------------------------------------- + +WebMouseEvent WebInputEventFactory::mouseEvent(const GdkEventButton* event) +{ + WebMouseEvent result; + + result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); + + result.modifiers = gdkStateToWebEventModifiers(event->state); + result.x = static_cast<int>(event->x); + result.y = static_cast<int>(event->y); + result.windowX = result.x; + result.windowY = result.y; + result.globalX = static_cast<int>(event->x_root); + result.globalY = static_cast<int>(event->y_root); + result.clickCount = 0; + + switch (event->type) { + case GDK_BUTTON_PRESS: + result.type = WebInputEvent::MouseDown; + break; + case GDK_BUTTON_RELEASE: + result.type = WebInputEvent::MouseUp; + break; + case GDK_3BUTTON_PRESS: + case GDK_2BUTTON_PRESS: + default: + ASSERT_NOT_REACHED(); + }; + + if (GDK_BUTTON_PRESS == event->type) { + static int numClicks = 0; + static GdkWindow* eventWindow = 0; + static gint lastLeftClickTime = 0; + + gint time_diff = event->time - lastLeftClickTime; + if (eventWindow == event->window && time_diff < getDoubleClickTime()) + numClicks++; + else + numClicks = 1; + + result.clickCount = numClicks; + eventWindow = event->window; + lastLeftClickTime = event->time; + } + + result.button = WebMouseEvent::ButtonNone; + if (event->button == 1) + result.button = WebMouseEvent::ButtonLeft; + else if (event->button == 2) + result.button = WebMouseEvent::ButtonMiddle; + else if (event->button == 3) + result.button = WebMouseEvent::ButtonRight; + + return result; +} + +WebMouseEvent WebInputEventFactory::mouseEvent(const GdkEventMotion* event) +{ + WebMouseEvent result; + + result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); + result.modifiers = gdkStateToWebEventModifiers(event->state); + result.x = static_cast<int>(event->x); + result.y = static_cast<int>(event->y); + result.windowX = result.x; + result.windowY = result.y; + result.globalX = static_cast<int>(event->x_root); + result.globalY = static_cast<int>(event->y_root); + + switch (event->type) { + case GDK_MOTION_NOTIFY: + result.type = WebInputEvent::MouseMove; + break; + default: + ASSERT_NOT_REACHED(); + } + + result.button = WebMouseEvent::ButtonNone; + if (event->state & GDK_BUTTON1_MASK) + result.button = WebMouseEvent::ButtonLeft; + else if (event->state & GDK_BUTTON2_MASK) + result.button = WebMouseEvent::ButtonMiddle; + else if (event->state & GDK_BUTTON3_MASK) + result.button = WebMouseEvent::ButtonRight; + + return result; +} + +WebMouseEvent WebInputEventFactory::mouseEvent(const GdkEventCrossing* event) +{ + WebMouseEvent result; + + result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); + result.modifiers = gdkStateToWebEventModifiers(event->state); + result.x = static_cast<int>(event->x); + result.y = static_cast<int>(event->y); + result.windowX = result.x; + result.windowY = result.y; + result.globalX = static_cast<int>(event->x_root); + result.globalY = static_cast<int>(event->y_root); + + switch (event->type) { + case GDK_ENTER_NOTIFY: + case GDK_LEAVE_NOTIFY: + // Note that if we sent MouseEnter or MouseLeave to WebKit, it + // wouldn't work - they don't result in the proper JavaScript events. + // MouseMove does the right thing. + result.type = WebInputEvent::MouseMove; + break; + default: + ASSERT_NOT_REACHED(); + } + + result.button = WebMouseEvent::ButtonNone; + if (event->state & GDK_BUTTON1_MASK) + result.button = WebMouseEvent::ButtonLeft; + else if (event->state & GDK_BUTTON2_MASK) + result.button = WebMouseEvent::ButtonMiddle; + else if (event->state & GDK_BUTTON3_MASK) + result.button = WebMouseEvent::ButtonRight; + + return result; +} + +// WebMouseWheelEvent --------------------------------------------------------- + +WebMouseWheelEvent WebInputEventFactory::mouseWheelEvent(const GdkEventScroll* event) +{ + WebMouseWheelEvent result; + + result.type = WebInputEvent::MouseWheel; + result.button = WebMouseEvent::ButtonNone; + + result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); + result.modifiers = gdkStateToWebEventModifiers(event->state); + result.x = static_cast<int>(event->x); + result.y = static_cast<int>(event->y); + result.windowX = result.x; + result.windowY = result.y; + result.globalX = static_cast<int>(event->x_root); + result.globalY = static_cast<int>(event->y_root); + + // How much should we scroll per mouse wheel event? + // - Windows uses 3 lines by default and obeys a system setting. + // - Mozilla has a pref that lets you either use the "system" number of lines + // to scroll, or lets the user override it. + // For the "system" number of lines, it appears they've hardcoded 3. + // See case NS_MOUSE_SCROLL in content/events/src/nsEventStateManager.cpp + // and InitMouseScrollEvent in widget/src/gtk2/nsCommonWidget.cpp . + // - Gtk makes the scroll amount a function of the size of the scroll bar, + // which is not available to us here. + // Instead, we pick a number that empirically matches Firefox's behavior. + static const float scrollbarPixelsPerTick = 160.0f / 3.0f; + + switch (event->direction) { + case GDK_SCROLL_UP: + result.deltaY = scrollbarPixelsPerTick; + result.wheelTicksY = 1; + break; + case GDK_SCROLL_DOWN: + result.deltaY = -scrollbarPixelsPerTick; + result.wheelTicksY = -1; + break; + case GDK_SCROLL_LEFT: + result.deltaX = scrollbarPixelsPerTick; + result.wheelTicksX = 1; + break; + case GDK_SCROLL_RIGHT: + result.deltaX = -scrollbarPixelsPerTick; + result.wheelTicksX = -1; + break; + } + + return result; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/gtk/WebScreenInfoFactory.cpp b/WebKit/chromium/src/gtk/WebScreenInfoFactory.cpp new file mode 100644 index 0000000..081daa2 --- /dev/null +++ b/WebKit/chromium/src/gtk/WebScreenInfoFactory.cpp @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebScreenInfoFactory.h" + +#include "WebScreenInfo.h" +#include <gtk/gtk.h> + +namespace WebKit { + +WebScreenInfo WebScreenInfoFactory::screenInfo(GtkWidget* widget) +{ + WebScreenInfo results; + results.depth = 32; + results.depthPerComponent = 8; + results.isMonochrome = false; + + if (!widget) + return results; + + GdkScreen* screen = gtk_widget_get_screen(widget); + + results.rect = WebRect( + 0, 0, gdk_screen_get_width(screen), gdk_screen_get_height(screen)); + + // I don't know of a way to query the "maximize" size of the window (e.g. + // screen size less sidebars etc) since this is something which only the + // window manager knows. + results.availableRect = results.rect; + + return results; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/linux/WebFontRendering.cpp b/WebKit/chromium/src/linux/WebFontRendering.cpp new file mode 100644 index 0000000..b9862f5 --- /dev/null +++ b/WebKit/chromium/src/linux/WebFontRendering.cpp @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebFontRendering.h" + +#include "FontPlatformData.h" + +using WebCore::FontPlatformData; + +namespace WebKit { + +// static +void WebFontRendering::setHinting(SkPaint::Hinting hinting) +{ + FontPlatformData::setHinting(hinting); +} + +// static +void WebFontRendering::setAntiAlias(bool isAntiAlias) +{ + FontPlatformData::setAntiAlias(isAntiAlias); +} + +// static +void WebFontRendering::setSubpixelGlyphs(bool isSubpixelGlyphs) +{ + FontPlatformData::setSubpixelGlyphs(isSubpixelGlyphs); +} + +// static +void WebFontRendering::setLCDOrder(SkFontHost::LCDOrder order) +{ + SkFontHost::SetSubpixelOrder(order); +} + +// static +void WebFontRendering::setLCDOrientation(SkFontHost::LCDOrientation orientation) +{ + SkFontHost::SetSubpixelOrientation(orientation); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/mac/WebInputEventFactory.mm b/WebKit/chromium/src/mac/WebInputEventFactory.mm new file mode 100644 index 0000000..d618228 --- /dev/null +++ b/WebKit/chromium/src/mac/WebInputEventFactory.mm @@ -0,0 +1,1196 @@ +/* + * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved. + * Copyright (C) 2006-2009 Google Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebInputEventFactory.h" + +#include <ApplicationServices/ApplicationServices.h> +#import <Cocoa/Cocoa.h> + +#include "WebInputEvent.h" +#include <wtf/ASCIICType.h> + +namespace WebKit { + +// WebKeyboardEvent ----------------------------------------------------------- + +// ---------------------------------------------------------------------------- +// Begin Apple code, copied from KeyEventMac.mm +// +// We can share some of this code if we factored it out of KeyEventMac, but +// the main problem is that it relies on the NSString ctor on String for +// conversions, and since we're building without PLATFORM(MAC), we don't have +// that. As a result we have to use NSString here exclusively and thus tweak +// the code so it's not re-usable as-is. One possiblity would be to make the +// upstream code only use NSString, but I'm not certain how far that change +// would propagate. + +static inline bool isKeyUpEvent(NSEvent* event) +{ + if ([event type] != NSFlagsChanged) + return [event type] == NSKeyUp; + // FIXME: This logic fails if the user presses both Shift keys at once, for example: + // we treat releasing one of them as keyDown. + switch ([event keyCode]) { + case 54: // Right Command + case 55: // Left Command + return ([event modifierFlags] & NSCommandKeyMask) == 0; + + case 57: // Capslock + return ([event modifierFlags] & NSAlphaShiftKeyMask) == 0; + + case 56: // Left Shift + case 60: // Right Shift + return ([event modifierFlags] & NSShiftKeyMask) == 0; + + case 58: // Left Alt + case 61: // Right Alt + return ([event modifierFlags] & NSAlternateKeyMask) == 0; + + case 59: // Left Ctrl + case 62: // Right Ctrl + return ([event modifierFlags] & NSControlKeyMask) == 0; + + case 63: // Function + return ([event modifierFlags] & NSFunctionKeyMask) == 0; + } + return false; +} + +static bool isKeypadEvent(NSEvent* event) +{ + // Check that this is the type of event that has a keyCode. + switch ([event type]) { + case NSKeyDown: + case NSKeyUp: + case NSFlagsChanged: + break; + default: + return false; + } + + switch ([event keyCode]) { + case 71: // Clear + case 81: // = + case 75: // / + case 67: // * + case 78: // - + case 69: // + + case 76: // Enter + case 65: // . + case 82: // 0 + case 83: // 1 + case 84: // 2 + case 85: // 3 + case 86: // 4 + case 87: // 5 + case 88: // 6 + case 89: // 7 + case 91: // 8 + case 92: // 9 + return true; + } + + return false; +} + +static int windowsKeyCodeForKeyEvent(NSEvent* event) +{ + switch ([event keyCode]) { + // VK_TAB (09) TAB key + case 48: + return 0x09; + + // VK_APPS (5D) Right windows/meta key + case 54: // Right Command + return 0x5D; + + // VK_LWIN (5B) Left windows/meta key + case 55: // Left Command + return 0x5B; + + // VK_CAPITAL (14) caps locks key + case 57: // Capslock + return 0x14; + + // VK_SHIFT (10) either shift key + case 56: // Left Shift + case 60: // Right Shift + return 0x10; + + // VK_MENU (12) either alt key + case 58: // Left Alt + case 61: // Right Alt + return 0x12; + + // VK_CONTROL (11) either ctrl key + case 59: // Left Ctrl + case 62: // Right Ctrl + return 0x11; + +// Begin non-Apple addition --------------------------------------------------- + case 63: // Function (no Windows key code) + return 0; +// End non-Apple addition ----------------------------------------------------- + + // VK_CLEAR (0C) CLEAR key + case 71: return 0x0C; + + // VK_NUMPAD0 (60) Numeric keypad 0 key + case 82: return 0x60; + // VK_NUMPAD1 (61) Numeric keypad 1 key + case 83: return 0x61; + // VK_NUMPAD2 (62) Numeric keypad 2 key + case 84: return 0x62; + // VK_NUMPAD3 (63) Numeric keypad 3 key + case 85: return 0x63; + // VK_NUMPAD4 (64) Numeric keypad 4 key + case 86: return 0x64; + // VK_NUMPAD5 (65) Numeric keypad 5 key + case 87: return 0x65; + // VK_NUMPAD6 (66) Numeric keypad 6 key + case 88: return 0x66; + // VK_NUMPAD7 (67) Numeric keypad 7 key + case 89: return 0x67; + // VK_NUMPAD8 (68) Numeric keypad 8 key + case 91: return 0x68; + // VK_NUMPAD9 (69) Numeric keypad 9 key + case 92: return 0x69; + // VK_MULTIPLY (6A) Multiply key + case 67: return 0x6A; + // VK_ADD (6B) Add key + case 69: return 0x6B; + + // VK_SUBTRACT (6D) Subtract key + case 78: return 0x6D; + // VK_DECIMAL (6E) Decimal key + case 65: return 0x6E; + // VK_DIVIDE (6F) Divide key + case 75: return 0x6F; + } + +// Begin non-Apple addition --------------------------------------------------- + // |-[NSEvent charactersIgnoringModifiers]| isn't allowed for + // NSFlagsChanged, and conceivably we may not have caught everything + // which causes an NSFlagsChanged above. + if ([event type] == NSFlagsChanged) + return 0; +// End non-Apple addition ----------------------------------------------------- + + NSString* s = [event charactersIgnoringModifiers]; + if ([s length] != 1) + return 0; + + switch ([s characterAtIndex:0]) { + // VK_LBUTTON (01) Left mouse button + // VK_RBUTTON (02) Right mouse button + // VK_CANCEL (03) Control-break processing + // VK_MBUTTON (04) Middle mouse button (three-button mouse) + // VK_XBUTTON1 (05) + // VK_XBUTTON2 (06) + + // VK_BACK (08) BACKSPACE key + case 8: case 0x7F: return 0x08; + // VK_TAB (09) TAB key + case 9: return 0x09; + + // VK_CLEAR (0C) CLEAR key + // handled by key code above + + // VK_RETURN (0D) + case 0xD: case 3: return 0x0D; + + // VK_SHIFT (10) SHIFT key + // VK_CONTROL (11) CTRL key + // VK_MENU (12) ALT key + + // VK_PAUSE (13) PAUSE key + case NSPauseFunctionKey: return 0x13; + + // VK_CAPITAL (14) CAPS LOCK key + // VK_KANA (15) Input Method Editor (IME) Kana mode + // VK_HANGUEL (15) IME Hanguel mode (maintained for compatibility; use VK_HANGUL) + // VK_HANGUL (15) IME Hangul mode + // VK_JUNJA (17) IME Junja mode + // VK_FINAL (18) IME final mode + // VK_HANJA (19) IME Hanja mode + // VK_KANJI (19) IME Kanji mode + + // VK_ESCAPE (1B) ESC key + case 0x1B: return 0x1B; + + // VK_CONVERT (1C) IME convert + // VK_NONCONVERT (1D) IME nonconvert + // VK_ACCEPT (1E) IME accept + // VK_MODECHANGE (1F) IME mode change request + + // VK_SPACE (20) SPACEBAR + case ' ': return 0x20; + // VK_PRIOR (21) PAGE UP key + case NSPageUpFunctionKey: return 0x21; + // VK_NEXT (22) PAGE DOWN key + case NSPageDownFunctionKey: return 0x22; + // VK_END (23) END key + case NSEndFunctionKey: return 0x23; + // VK_HOME (24) HOME key + case NSHomeFunctionKey: return 0x24; + // VK_LEFT (25) LEFT ARROW key + case NSLeftArrowFunctionKey: return 0x25; + // VK_UP (26) UP ARROW key + case NSUpArrowFunctionKey: return 0x26; + // VK_RIGHT (27) RIGHT ARROW key + case NSRightArrowFunctionKey: return 0x27; + // VK_DOWN (28) DOWN ARROW key + case NSDownArrowFunctionKey: return 0x28; + // VK_SELECT (29) SELECT key + case NSSelectFunctionKey: return 0x29; + // VK_PRINT (2A) PRINT key + case NSPrintFunctionKey: return 0x2A; + // VK_EXECUTE (2B) EXECUTE key + case NSExecuteFunctionKey: return 0x2B; + // VK_SNAPSHOT (2C) PRINT SCREEN key + case NSPrintScreenFunctionKey: return 0x2C; + // VK_INSERT (2D) INS key + case NSInsertFunctionKey: case NSHelpFunctionKey: return 0x2D; + // VK_DELETE (2E) DEL key + case NSDeleteFunctionKey: return 0x2E; + + // VK_HELP (2F) HELP key + + // (30) 0 key + case '0': case ')': return 0x30; + // (31) 1 key + case '1': case '!': return 0x31; + // (32) 2 key + case '2': case '@': return 0x32; + // (33) 3 key + case '3': case '#': return 0x33; + // (34) 4 key + case '4': case '$': return 0x34; + // (35) 5 key + case '5': case '%': return 0x35; + // (36) 6 key + case '6': case '^': return 0x36; + // (37) 7 key + case '7': case '&': return 0x37; + // (38) 8 key + case '8': case '*': return 0x38; + // (39) 9 key + case '9': case '(': return 0x39; + // (41) A key + case 'a': case 'A': return 0x41; + // (42) B key + case 'b': case 'B': return 0x42; + // (43) C key + case 'c': case 'C': return 0x43; + // (44) D key + case 'd': case 'D': return 0x44; + // (45) E key + case 'e': case 'E': return 0x45; + // (46) F key + case 'f': case 'F': return 0x46; + // (47) G key + case 'g': case 'G': return 0x47; + // (48) H key + case 'h': case 'H': return 0x48; + // (49) I key + case 'i': case 'I': return 0x49; + // (4A) J key + case 'j': case 'J': return 0x4A; + // (4B) K key + case 'k': case 'K': return 0x4B; + // (4C) L key + case 'l': case 'L': return 0x4C; + // (4D) M key + case 'm': case 'M': return 0x4D; + // (4E) N key + case 'n': case 'N': return 0x4E; + // (4F) O key + case 'o': case 'O': return 0x4F; + // (50) P key + case 'p': case 'P': return 0x50; + // (51) Q key + case 'q': case 'Q': return 0x51; + // (52) R key + case 'r': case 'R': return 0x52; + // (53) S key + case 's': case 'S': return 0x53; + // (54) T key + case 't': case 'T': return 0x54; + // (55) U key + case 'u': case 'U': return 0x55; + // (56) V key + case 'v': case 'V': return 0x56; + // (57) W key + case 'w': case 'W': return 0x57; + // (58) X key + case 'x': case 'X': return 0x58; + // (59) Y key + case 'y': case 'Y': return 0x59; + // (5A) Z key + case 'z': case 'Z': return 0x5A; + + // VK_LWIN (5B) Left Windows key (Microsoft Natural keyboard) + // VK_RWIN (5C) Right Windows key (Natural keyboard) + // VK_APPS (5D) Applications key (Natural keyboard) + // VK_SLEEP (5F) Computer Sleep key + + // VK_NUMPAD0 (60) Numeric keypad 0 key + // VK_NUMPAD1 (61) Numeric keypad 1 key + // VK_NUMPAD2 (62) Numeric keypad 2 key + // VK_NUMPAD3 (63) Numeric keypad 3 key + // VK_NUMPAD4 (64) Numeric keypad 4 key + // VK_NUMPAD5 (65) Numeric keypad 5 key + // VK_NUMPAD6 (66) Numeric keypad 6 key + // VK_NUMPAD7 (67) Numeric keypad 7 key + // VK_NUMPAD8 (68) Numeric keypad 8 key + // VK_NUMPAD9 (69) Numeric keypad 9 key + // VK_MULTIPLY (6A) Multiply key + // VK_ADD (6B) Add key + // handled by key code above + + // VK_SEPARATOR (6C) Separator key + + // VK_SUBTRACT (6D) Subtract key + // VK_DECIMAL (6E) Decimal key + // VK_DIVIDE (6F) Divide key + // handled by key code above + + // VK_F1 (70) F1 key + case NSF1FunctionKey: return 0x70; + // VK_F2 (71) F2 key + case NSF2FunctionKey: return 0x71; + // VK_F3 (72) F3 key + case NSF3FunctionKey: return 0x72; + // VK_F4 (73) F4 key + case NSF4FunctionKey: return 0x73; + // VK_F5 (74) F5 key + case NSF5FunctionKey: return 0x74; + // VK_F6 (75) F6 key + case NSF6FunctionKey: return 0x75; + // VK_F7 (76) F7 key + case NSF7FunctionKey: return 0x76; + // VK_F8 (77) F8 key + case NSF8FunctionKey: return 0x77; + // VK_F9 (78) F9 key + case NSF9FunctionKey: return 0x78; + // VK_F10 (79) F10 key + case NSF10FunctionKey: return 0x79; + // VK_F11 (7A) F11 key + case NSF11FunctionKey: return 0x7A; + // VK_F12 (7B) F12 key + case NSF12FunctionKey: return 0x7B; + // VK_F13 (7C) F13 key + case NSF13FunctionKey: return 0x7C; + // VK_F14 (7D) F14 key + case NSF14FunctionKey: return 0x7D; + // VK_F15 (7E) F15 key + case NSF15FunctionKey: return 0x7E; + // VK_F16 (7F) F16 key + case NSF16FunctionKey: return 0x7F; + // VK_F17 (80H) F17 key + case NSF17FunctionKey: return 0x80; + // VK_F18 (81H) F18 key + case NSF18FunctionKey: return 0x81; + // VK_F19 (82H) F19 key + case NSF19FunctionKey: return 0x82; + // VK_F20 (83H) F20 key + case NSF20FunctionKey: return 0x83; + // VK_F21 (84H) F21 key + case NSF21FunctionKey: return 0x84; + // VK_F22 (85H) F22 key + case NSF22FunctionKey: return 0x85; + // VK_F23 (86H) F23 key + case NSF23FunctionKey: return 0x86; + // VK_F24 (87H) F24 key + case NSF24FunctionKey: return 0x87; + + // VK_NUMLOCK (90) NUM LOCK key + + // VK_SCROLL (91) SCROLL LOCK key + case NSScrollLockFunctionKey: return 0x91; + + // VK_LSHIFT (A0) Left SHIFT key + // VK_RSHIFT (A1) Right SHIFT key + // VK_LCONTROL (A2) Left CONTROL key + // VK_RCONTROL (A3) Right CONTROL key + // VK_LMENU (A4) Left MENU key + // VK_RMENU (A5) Right MENU key + // VK_BROWSER_BACK (A6) Windows 2000/XP: Browser Back key + // VK_BROWSER_FORWARD (A7) Windows 2000/XP: Browser Forward key + // VK_BROWSER_REFRESH (A8) Windows 2000/XP: Browser Refresh key + // VK_BROWSER_STOP (A9) Windows 2000/XP: Browser Stop key + // VK_BROWSER_SEARCH (AA) Windows 2000/XP: Browser Search key + // VK_BROWSER_FAVORITES (AB) Windows 2000/XP: Browser Favorites key + // VK_BROWSER_HOME (AC) Windows 2000/XP: Browser Start and Home key + // VK_VOLUME_MUTE (AD) Windows 2000/XP: Volume Mute key + // VK_VOLUME_DOWN (AE) Windows 2000/XP: Volume Down key + // VK_VOLUME_UP (AF) Windows 2000/XP: Volume Up key + // VK_MEDIA_NEXT_TRACK (B0) Windows 2000/XP: Next Track key + // VK_MEDIA_PREV_TRACK (B1) Windows 2000/XP: Previous Track key + // VK_MEDIA_STOP (B2) Windows 2000/XP: Stop Media key + // VK_MEDIA_PLAY_PAUSE (B3) Windows 2000/XP: Play/Pause Media key + // VK_LAUNCH_MAIL (B4) Windows 2000/XP: Start Mail key + // VK_LAUNCH_MEDIA_SELECT (B5) Windows 2000/XP: Select Media key + // VK_LAUNCH_APP1 (B6) Windows 2000/XP: Start Application 1 key + // VK_LAUNCH_APP2 (B7) Windows 2000/XP: Start Application 2 key + + // VK_OEM_1 (BA) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the ';:' key + case ';': case ':': return 0xBA; + // VK_OEM_PLUS (BB) Windows 2000/XP: For any country/region, the '+' key + case '=': case '+': return 0xBB; + // VK_OEM_COMMA (BC) Windows 2000/XP: For any country/region, the ',' key + case ',': case '<': return 0xBC; + // VK_OEM_MINUS (BD) Windows 2000/XP: For any country/region, the '-' key + case '-': case '_': return 0xBD; + // VK_OEM_PERIOD (BE) Windows 2000/XP: For any country/region, the '.' key + case '.': case '>': return 0xBE; + // VK_OEM_2 (BF) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '/?' key + case '/': case '?': return 0xBF; + // VK_OEM_3 (C0) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '`~' key + case '`': case '~': return 0xC0; + // VK_OEM_4 (DB) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '[{' key + case '[': case '{': return 0xDB; + // VK_OEM_5 (DC) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '\|' key + case '\\': case '|': return 0xDC; + // VK_OEM_6 (DD) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the ']}' key + case ']': case '}': return 0xDD; + // VK_OEM_7 (DE) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the 'single-quote/double-quote' key + case '\'': case '"': return 0xDE; + + // VK_OEM_8 (DF) Used for miscellaneous characters; it can vary by keyboard. + // VK_OEM_102 (E2) Windows 2000/XP: Either the angle bracket key or the backslash key on the RT 102-key keyboard + // VK_PROCESSKEY (E5) Windows 95/98/Me, Windows NT 4.0, Windows 2000/XP: IME PROCESS key + // VK_PACKET (E7) Windows 2000/XP: Used to pass Unicode characters as if they were keystrokes. The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information, see Remark in KEYBDINPUT,SendInput, WM_KEYDOWN, and WM_KEYUP + // VK_ATTN (F6) Attn key + // VK_CRSEL (F7) CrSel key + // VK_EXSEL (F8) ExSel key + // VK_EREOF (F9) Erase EOF key + // VK_PLAY (FA) Play key + // VK_ZOOM (FB) Zoom key + // VK_NONAME (FC) Reserved for future use + // VK_PA1 (FD) PA1 key + // VK_OEM_CLEAR (FE) Clear key + } + + return 0; +} + +static inline NSString* textFromEvent(NSEvent* event) +{ + if ([event type] == NSFlagsChanged) + return @""; + return [event characters]; +} + +static inline NSString* unmodifiedTextFromEvent(NSEvent* event) +{ + if ([event type] == NSFlagsChanged) + return @""; + return [event charactersIgnoringModifiers]; +} + +static NSString* keyIdentifierForKeyEvent(NSEvent* event) +{ + if ([event type] == NSFlagsChanged) { + switch ([event keyCode]) { + case 54: // Right Command + case 55: // Left Command + return @"Meta"; + + case 57: // Capslock + return @"CapsLock"; + + case 56: // Left Shift + case 60: // Right Shift + return @"Shift"; + + case 58: // Left Alt + case 61: // Right Alt + return @"Alt"; + + case 59: // Left Ctrl + case 62: // Right Ctrl + return @"Control"; + +// Begin non-Apple addition/modification -------------------------------------- + case 63: // Function + return @"Function"; + + default: // Unknown, but this may be a strange/new keyboard. + return @"Unidentified"; +// End non-Apple addition/modification ---------------------------------------- + } + } + + NSString* s = [event charactersIgnoringModifiers]; + if ([s length] != 1) + return @"Unidentified"; + + unichar c = [s characterAtIndex:0]; + switch (c) { + // Each identifier listed in the DOM spec is listed here. + // Many are simply commented out since they do not appear on standard Macintosh keyboards + // or are on a key that doesn't have a corresponding character. + + // "Accept" + // "AllCandidates" + + // "Alt" + case NSMenuFunctionKey: + return @"Alt"; + + // "Apps" + // "BrowserBack" + // "BrowserForward" + // "BrowserHome" + // "BrowserRefresh" + // "BrowserSearch" + // "BrowserStop" + // "CapsLock" + + // "Clear" + case NSClearLineFunctionKey: + return @"Clear"; + + // "CodeInput" + // "Compose" + // "Control" + // "Crsel" + // "Convert" + // "Copy" + // "Cut" + + // "Down" + case NSDownArrowFunctionKey: + return @"Down"; + // "End" + case NSEndFunctionKey: + return @"End"; + // "Enter" + case 0x3: case 0xA: case 0xD: // Macintosh calls the one on the main keyboard Return, but Windows calls it Enter, so we'll do the same for the DOM + return @"Enter"; + + // "EraseEof" + + // "Execute" + case NSExecuteFunctionKey: + return @"Execute"; + + // "Exsel" + + // "F1" + case NSF1FunctionKey: + return @"F1"; + // "F2" + case NSF2FunctionKey: + return @"F2"; + // "F3" + case NSF3FunctionKey: + return @"F3"; + // "F4" + case NSF4FunctionKey: + return @"F4"; + // "F5" + case NSF5FunctionKey: + return @"F5"; + // "F6" + case NSF6FunctionKey: + return @"F6"; + // "F7" + case NSF7FunctionKey: + return @"F7"; + // "F8" + case NSF8FunctionKey: + return @"F8"; + // "F9" + case NSF9FunctionKey: + return @"F9"; + // "F10" + case NSF10FunctionKey: + return @"F10"; + // "F11" + case NSF11FunctionKey: + return @"F11"; + // "F12" + case NSF12FunctionKey: + return @"F12"; + // "F13" + case NSF13FunctionKey: + return @"F13"; + // "F14" + case NSF14FunctionKey: + return @"F14"; + // "F15" + case NSF15FunctionKey: + return @"F15"; + // "F16" + case NSF16FunctionKey: + return @"F16"; + // "F17" + case NSF17FunctionKey: + return @"F17"; + // "F18" + case NSF18FunctionKey: + return @"F18"; + // "F19" + case NSF19FunctionKey: + return @"F19"; + // "F20" + case NSF20FunctionKey: + return @"F20"; + // "F21" + case NSF21FunctionKey: + return @"F21"; + // "F22" + case NSF22FunctionKey: + return @"F22"; + // "F23" + case NSF23FunctionKey: + return @"F23"; + // "F24" + case NSF24FunctionKey: + return @"F24"; + + // "FinalMode" + + // "Find" + case NSFindFunctionKey: + return @"Find"; + + // "FullWidth" + // "HalfWidth" + // "HangulMode" + // "HanjaMode" + + // "Help" + case NSHelpFunctionKey: + return @"Help"; + + // "Hiragana" + + // "Home" + case NSHomeFunctionKey: + return @"Home"; + // "Insert" + case NSInsertFunctionKey: + return @"Insert"; + + // "JapaneseHiragana" + // "JapaneseKatakana" + // "JapaneseRomaji" + // "JunjaMode" + // "KanaMode" + // "KanjiMode" + // "Katakana" + // "LaunchApplication1" + // "LaunchApplication2" + // "LaunchMail" + + // "Left" + case NSLeftArrowFunctionKey: + return @"Left"; + + // "Meta" + // "MediaNextTrack" + // "MediaPlayPause" + // "MediaPreviousTrack" + // "MediaStop" + + // "ModeChange" + case NSModeSwitchFunctionKey: + return @"ModeChange"; + + // "Nonconvert" + // "NumLock" + + // "PageDown" + case NSPageDownFunctionKey: + return @"PageDown"; + // "PageUp" + case NSPageUpFunctionKey: + return @"PageUp"; + + // "Paste" + + // "Pause" + case NSPauseFunctionKey: + return @"Pause"; + + // "Play" + // "PreviousCandidate" + + // "PrintScreen" + case NSPrintScreenFunctionKey: + return @"PrintScreen"; + + // "Process" + // "Props" + + // "Right" + case NSRightArrowFunctionKey: + return @"Right"; + + // "RomanCharacters" + + // "Scroll" + case NSScrollLockFunctionKey: + return @"Scroll"; + // "Select" + case NSSelectFunctionKey: + return @"Select"; + + // "SelectMedia" + // "Shift" + + // "Stop" + case NSStopFunctionKey: + return @"Stop"; + // "Up" + case NSUpArrowFunctionKey: + return @"Up"; + // "Undo" + case NSUndoFunctionKey: + return @"Undo"; + + // "VolumeDown" + // "VolumeMute" + // "VolumeUp" + // "Win" + // "Zoom" + + // More function keys, not in the key identifier specification. + case NSF25FunctionKey: + return @"F25"; + case NSF26FunctionKey: + return @"F26"; + case NSF27FunctionKey: + return @"F27"; + case NSF28FunctionKey: + return @"F28"; + case NSF29FunctionKey: + return @"F29"; + case NSF30FunctionKey: + return @"F30"; + case NSF31FunctionKey: + return @"F31"; + case NSF32FunctionKey: + return @"F32"; + case NSF33FunctionKey: + return @"F33"; + case NSF34FunctionKey: + return @"F34"; + case NSF35FunctionKey: + return @"F35"; + + // Turn 0x7F into 0x08, because backspace needs to always be 0x08. + case 0x7F: + return @"U+0008"; + // Standard says that DEL becomes U+007F. + case NSDeleteFunctionKey: + return @"U+007F"; + + // Always use 0x09 for tab instead of AppKit's backtab character. + case NSBackTabCharacter: + return @"U+0009"; + + case NSBeginFunctionKey: + case NSBreakFunctionKey: + case NSClearDisplayFunctionKey: + case NSDeleteCharFunctionKey: + case NSDeleteLineFunctionKey: + case NSInsertCharFunctionKey: + case NSInsertLineFunctionKey: + case NSNextFunctionKey: + case NSPrevFunctionKey: + case NSPrintFunctionKey: + case NSRedoFunctionKey: + case NSResetFunctionKey: + case NSSysReqFunctionKey: + case NSSystemFunctionKey: + case NSUserFunctionKey: + // FIXME: We should use something other than the vendor-area Unicode values for the above keys. + // For now, just fall through to the default. + default: + return [NSString stringWithFormat:@"U+%04X", WTF::toASCIIUpper(c)]; + } +} + +// End Apple code. +// ---------------------------------------------------------------------------- + +static inline int modifiersFromEvent(NSEvent* event) { + int modifiers = 0; + + if ([event modifierFlags] & NSControlKeyMask) + modifiers |= WebInputEvent::ControlKey; + if ([event modifierFlags] & NSShiftKeyMask) + modifiers |= WebInputEvent::ShiftKey; + if ([event modifierFlags] & NSAlternateKeyMask) + modifiers |= WebInputEvent::AltKey; + if ([event modifierFlags] & NSCommandKeyMask) + modifiers |= WebInputEvent::MetaKey; + // TODO(port): Set mouse button states + + return modifiers; +} + +WebKeyboardEvent WebInputEventFactory::keyboardEvent(NSEvent* event) +{ + WebKeyboardEvent result; + + result.type = + isKeyUpEvent(event) ? WebInputEvent::KeyUp : WebInputEvent::RawKeyDown; + + result.modifiers = modifiersFromEvent(event); + + if (isKeypadEvent(event)) + result.modifiers |= WebInputEvent::IsKeyPad; + + if (([event type] != NSFlagsChanged) && [event isARepeat]) + result.modifiers |= WebInputEvent::IsAutoRepeat; + + result.windowsKeyCode = windowsKeyCodeForKeyEvent(event); + result.nativeKeyCode = [event keyCode]; + + NSString* textStr = textFromEvent(event); + NSString* unmodifiedStr = unmodifiedTextFromEvent(event); + NSString* identifierStr = keyIdentifierForKeyEvent(event); + + // Begin Apple code, copied from KeyEventMac.mm + + // Always use 13 for Enter/Return -- we don't want to use AppKit's + // different character for Enter. + if (result.windowsKeyCode == '\r') { + textStr = @"\r"; + unmodifiedStr = @"\r"; + } + + // The adjustments below are only needed in backward compatibility mode, + // but we cannot tell what mode we are in from here. + + // Turn 0x7F into 8, because backspace needs to always be 8. + if ([textStr isEqualToString:@"\x7F"]) + textStr = @"\x8"; + if ([unmodifiedStr isEqualToString:@"\x7F"]) + unmodifiedStr = @"\x8"; + // Always use 9 for tab -- we don't want to use AppKit's different character + // for shift-tab. + if (result.windowsKeyCode == 9) { + textStr = @"\x9"; + unmodifiedStr = @"\x9"; + } + + // End Apple code. + + if ([textStr length] < WebKeyboardEvent::textLengthCap && + [unmodifiedStr length] < WebKeyboardEvent::textLengthCap) { + [textStr getCharacters:&result.text[0]]; + [unmodifiedStr getCharacters:&result.unmodifiedText[0]]; + } else + ASSERT_NOT_REACHED(); + + [identifierStr getCString:&result.keyIdentifier[0] + maxLength:sizeof(result.keyIdentifier) + encoding:NSASCIIStringEncoding]; + + result.timeStampSeconds = [event timestamp]; + + // Windows and Linux set |isSystemKey| if alt is down. WebKit looks at this + // flag to decide if it should handle a key or not. E.g. alt-left/right + // shouldn't be used by WebKit to scroll the current page, because we want + // to get that key back for it to do history navigation. Hence, the + // corresponding situation on OS X is to set this for cmd key presses. + if (result.modifiers & WebInputEvent::MetaKey) + result.isSystemKey = true; + + return result; +} + +WebKeyboardEvent WebInputEventFactory::keyboardEvent(wchar_t character, + int modifiers, + double timeStampSeconds) +{ + // keyboardEvent(NSEvent*) depends on the NSEvent object and + // it is hard to use it from methods of the NSTextInput protocol. For + // such methods, this function creates a WebInputEvent::Char event without + // using a NSEvent object. + WebKeyboardEvent result; + result.type = WebKit::WebInputEvent::Char; + result.timeStampSeconds = timeStampSeconds; + result.modifiers = modifiers; + result.windowsKeyCode = character; + result.nativeKeyCode = character; + result.text[0] = character; + result.unmodifiedText[0] = character; + + // Windows and Linux set |isSystemKey| if alt is down. WebKit looks at this + // flag to decide if it should handle a key or not. E.g. alt-left/right + // shouldn't be used by WebKit to scroll the current page, because we want + // to get that key back for it to do history navigation. Hence, the + // corresponding situation on OS X is to set this for cmd key presses. + if (result.modifiers & WebInputEvent::MetaKey) + result.isSystemKey = true; + + return result; +} + +// WebMouseEvent -------------------------------------------------------------- + +WebMouseEvent WebInputEventFactory::mouseEvent(NSEvent* event, NSView* view) +{ + WebMouseEvent result; + + result.clickCount = 0; + + switch ([event type]) { + case NSMouseExited: + result.type = WebInputEvent::MouseLeave; + result.button = WebMouseEvent::ButtonNone; + break; + case NSLeftMouseDown: + result.type = WebInputEvent::MouseDown; + result.clickCount = [event clickCount]; + result.button = WebMouseEvent::ButtonLeft; + break; + case NSOtherMouseDown: + result.type = WebInputEvent::MouseDown; + result.clickCount = [event clickCount]; + result.button = WebMouseEvent::ButtonMiddle; + break; + case NSRightMouseDown: + result.type = WebInputEvent::MouseDown; + result.clickCount = [event clickCount]; + result.button = WebMouseEvent::ButtonRight; + break; + case NSLeftMouseUp: + result.type = WebInputEvent::MouseUp; + result.button = WebMouseEvent::ButtonLeft; + break; + case NSOtherMouseUp: + result.type = WebInputEvent::MouseUp; + result.button = WebMouseEvent::ButtonMiddle; + break; + case NSRightMouseUp: + result.type = WebInputEvent::MouseUp; + result.button = WebMouseEvent::ButtonRight; + break; + case NSMouseMoved: + case NSMouseEntered: + result.type = WebInputEvent::MouseMove; + break; + case NSLeftMouseDragged: + result.type = WebInputEvent::MouseMove; + result.button = WebMouseEvent::ButtonLeft; + break; + case NSOtherMouseDragged: + result.type = WebInputEvent::MouseMove; + result.button = WebMouseEvent::ButtonMiddle; + break; + case NSRightMouseDragged: + result.type = WebInputEvent::MouseMove; + result.button = WebMouseEvent::ButtonRight; + break; + default: + ASSERT_NOT_REACHED(); + } + + NSPoint location = [NSEvent mouseLocation]; // global coordinates + result.globalX = location.x; + result.globalY = [[[view window] screen] frame].size.height - location.y; + + NSPoint windowLocal = [event locationInWindow]; + location = [view convertPoint:windowLocal fromView:nil]; + result.y = [view frame].size.height - location.y; // flip y + result.x = location.x; + result.windowX = result.x; + result.windowY = result.y; + + result.modifiers = modifiersFromEvent(event); + + result.timeStampSeconds = [event timestamp]; + + return result; +} + +// WebMouseWheelEvent --------------------------------------------------------- + +WebMouseWheelEvent WebInputEventFactory::mouseWheelEvent(NSEvent* event, NSView* view) +{ + WebMouseWheelEvent result; + + result.type = WebInputEvent::MouseWheel; + result.button = WebMouseEvent::ButtonNone; + + result.modifiers = modifiersFromEvent(event); + + // Set coordinates by translating event coordinates from screen to client. + NSPoint location = [NSEvent mouseLocation]; // global coordinates + result.globalX = location.x; + result.globalY = location.y; + NSPoint windowLocal = [event locationInWindow]; + location = [view convertPoint:windowLocal fromView:nil]; + result.x = location.x; + result.y = [view frame].size.height - location.y; // flip y + result.windowX = result.x; + result.windowY = result.y; + + // Of Mice and Men + // --------------- + // + // There are three types of scroll data available on a scroll wheel CGEvent. + // Apple's documentation ([1]) is rather vague in their differences, and not + // terribly helpful in deciding which to use. This is what's really going on. + // + // First, these events behave very differently depending on whether a standard + // wheel mouse is used (one that scrolls in discrete units) or a + // trackpad/Mighty Mouse is used (which both provide continuous scrolling). + // You must check to see which was used for the event by testing the + // kCGScrollWheelEventIsContinuous field. + // + // Second, these events refer to "axes". Axis 1 is the y-axis, and axis 2 is + // the x-axis. + // + // Third, there is a concept of mouse acceleration. Scrolling the same amount + // of physical distance will give you different results logically depending on + // whether you scrolled a little at a time or in one continuous motion. Some + // fields account for this while others do not. + // + // Fourth, for trackpads there is a concept of chunkiness. When scrolling + // continuously, events can be delivered in chunks. That is to say, lots of + // scroll events with delta 0 will be delivered, and every so often an event + // with a non-zero delta will be delivered, containing the accumulated deltas + // from all the intermediate moves. [2] + // + // For notchy wheel mice (kCGScrollWheelEventIsContinuous == 0) + // ------------------------------------------------------------ + // + // kCGScrollWheelEventDeltaAxis* + // This is the rawest of raw events. For each mouse notch you get a value of + // +1/-1. This does not take acceleration into account and thus is less + // useful for building UIs. + // + // kCGScrollWheelEventPointDeltaAxis* + // This is smarter. In general, for each mouse notch you get a value of + // +1/-1, but this _does_ take acceleration into account, so you will get + // larger values on longer scrolls. This field would be ideal for building + // UIs except for one nasty bug: when the shift key is pressed, this set of + // fields fails to move the value into the axis2 field (the other two types + // of data do). This wouldn't be so bad except for the fact that while the + // number of axes is used in the creation of a CGScrollWheelEvent, there is + // no way to get that information out of the event once created. + // + // kCGScrollWheelEventFixedPtDeltaAxis* + // This is a fixed value, and for each mouse notch you get a value of + // +0.1/-0.1 (but, like above, scaled appropriately for acceleration). This + // value takes acceleration into account, and in fact is identical to the + // results you get from -[NSEvent delta*]. (That is, if you linked on Tiger + // or greater; see [2] for details.) + // + // A note about continuous devices + // ------------------------------- + // + // There are two devices that provide continuous scrolling events (trackpads + // and Mighty Mouses) and they behave rather differently. The Mighty Mouse + // behaves a lot like a regular mouse. There is no chunking, and the + // FixedPtDelta values are the PointDelta values multiplied by 0.1. With the + // trackpad, though, there is chunking. While the FixedPtDelta values are + // reasonable (they occur about every fifth event but have values five times + // larger than usual) the Delta values are unreasonable. They don't appear to + // accumulate properly. + // + // For continuous devices (kCGScrollWheelEventIsContinuous != 0) + // ------------------------------------------------------------- + // + // kCGScrollWheelEventDeltaAxis* + // This provides values with no acceleration. With a trackpad, these values + // are chunked but each non-zero value does not appear to be cumulative. + // This seems to be a bug. + // + // kCGScrollWheelEventPointDeltaAxis* + // This provides values with acceleration. With a trackpad, these values are + // not chunked and are highly accurate. + // + // kCGScrollWheelEventFixedPtDeltaAxis* + // This provides values with acceleration. With a trackpad, these values are + // chunked but unlike Delta events are properly cumulative. + // + // Summary + // ------- + // + // In general the best approach to take is: determine if the event is + // continuous. If it is not, then use the FixedPtDelta events (or just stick + // with Cocoa events). They provide both acceleration and proper horizontal + // scrolling. If the event is continuous, then doing pixel scrolling with the + // PointDelta is the way to go. In general, avoid the Delta events. They're + // the oldest (dating back to 10.4, before CGEvents were public) but they lack + // acceleration and precision, making them useful only in specific edge cases. + // + // References + // ---------- + // + // [1] <http://developer.apple.com/documentation/Carbon/Reference/QuartzEventServicesRef/Reference/reference.html> + // [2] <http://developer.apple.com/releasenotes/Cocoa/AppKitOlderNotes.html> + // Scroll to the section headed "NSScrollWheel events". + // + // P.S. The "smooth scrolling" option in the system preferences is utterly + // unrelated to any of this. + + CGEventRef cgEvent = [event CGEvent]; + ASSERT(cgEvent); + + // Wheel ticks are supposed to be raw, unaccelerated values, one per physical + // mouse wheel notch. The delta event is perfect for this (being a good + // "specific edge case" as mentioned above). Trackpads, unfortunately, do + // event chunking, and sending mousewheel events with 0 ticks causes some + // websites to malfunction. Therefore, for all continuous input devices we use + // the point delta data instead, since we cannot distinguish trackpad data + // from data from any other continuous device. + + if (CGEventGetIntegerValueField(cgEvent, kCGScrollWheelEventIsContinuous)) { + result.wheelTicksY = result.deltaY = + CGEventGetIntegerValueField(cgEvent, kCGScrollWheelEventPointDeltaAxis1); + result.wheelTicksX = result.deltaX = + CGEventGetIntegerValueField(cgEvent, kCGScrollWheelEventPointDeltaAxis2); + } else { + result.wheelTicksY = + CGEventGetIntegerValueField(cgEvent, kCGScrollWheelEventDeltaAxis1); + result.wheelTicksX = + CGEventGetIntegerValueField(cgEvent, kCGScrollWheelEventDeltaAxis2); + + // Convert wheel delta amount to a number of pixels to scroll. + static const double scrollbarPixelsPerCocoaTick = 40.0; + + result.deltaX = [event deltaX] * scrollbarPixelsPerCocoaTick; + result.deltaY = [event deltaY] * scrollbarPixelsPerCocoaTick; + } + + result.timeStampSeconds = [event timestamp]; + + return result; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/mac/WebScreenInfoFactory.mm b/WebKit/chromium/src/mac/WebScreenInfoFactory.mm new file mode 100644 index 0000000..2805f7a --- /dev/null +++ b/WebKit/chromium/src/mac/WebScreenInfoFactory.mm @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebScreenInfoFactory.h" + +#import <AppKit/AppKit.h> + +#include "WebScreenInfo.h" + +namespace WebKit { + +static NSScreen* screenForWindow(NSWindow* window) +{ + NSScreen* screen = [window screen]; // nil if the window is off-screen + if (screen) + return screen; + + NSArray* screens = [NSScreen screens]; + if ([screens count] > 0) + return [screens objectAtIndex:0]; // screen containing the menubar + + return nil; +} + +static WebRect toUserSpace(const NSRect& rect, NSWindow* destination) +{ + CGRect userRect = NSRectToCGRect(rect); + + userRect.origin.y = + NSMaxY([screenForWindow(destination) frame]) - (userRect.origin.y + userRect.size.height); // flip + + if (destination) { + CGFloat scale = 1 / [destination userSpaceScaleFactor]; // scale down + userRect.origin.x *= scale; + userRect.origin.y *= scale; + userRect.size.width *= scale; + userRect.size.height *= scale; + } + + return WebRect(userRect.origin.x, + userRect.origin.y, + userRect.size.width, + userRect.size.height); +} + +WebScreenInfo WebScreenInfoFactory::screenInfo(NSView* view) +{ + NSString *colorSpace = NSColorSpaceFromDepth([[NSScreen deepestScreen] depth]); + + WebScreenInfo results; + results.depth = + NSBitsPerPixelFromDepth([[NSScreen deepestScreen] depth]); + results.depthPerComponent = + NSBitsPerSampleFromDepth([[NSScreen deepestScreen] depth]); + results.isMonochrome = colorSpace == NSCalibratedWhiteColorSpace + || colorSpace == NSCalibratedBlackColorSpace + || colorSpace == NSDeviceWhiteColorSpace + || colorSpace == NSDeviceBlackColorSpace; + results.rect = + toUserSpace([screenForWindow([view window]) frame], [view window]); + results.availableRect = + toUserSpace([screenForWindow([view window]) visibleFrame], [view window]); + return results; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/win/WebInputEventFactory.cpp b/WebKit/chromium/src/win/WebInputEventFactory.cpp new file mode 100644 index 0000000..a5bd935 --- /dev/null +++ b/WebKit/chromium/src/win/WebInputEventFactory.cpp @@ -0,0 +1,437 @@ +/* + * Copyright (C) 2006-2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebInputEventFactory.h" + +#include "WebInputEvent.h" + +#include <wtf/Assertions.h> + +namespace WebKit { + +static const unsigned long defaultScrollLinesPerWheelDelta = 3; +static const unsigned long defaultScrollCharsPerWheelDelta = 1; + +// WebKeyboardEvent ----------------------------------------------------------- + +static bool isKeyPad(WPARAM wparam, LPARAM lparam) +{ + bool keypad = false; + switch (wparam) { + case VK_RETURN: + keypad = (lparam >> 16) & KF_EXTENDED; + break; + case VK_INSERT: + case VK_DELETE: + case VK_HOME: + case VK_END: + case VK_PRIOR: + case VK_NEXT: + case VK_UP: + case VK_DOWN: + case VK_LEFT: + case VK_RIGHT: + keypad = !((lparam >> 16) & KF_EXTENDED); + break; + case VK_NUMLOCK: + case VK_NUMPAD0: + case VK_NUMPAD1: + case VK_NUMPAD2: + case VK_NUMPAD3: + case VK_NUMPAD4: + case VK_NUMPAD5: + case VK_NUMPAD6: + case VK_NUMPAD7: + case VK_NUMPAD8: + case VK_NUMPAD9: + case VK_DIVIDE: + case VK_MULTIPLY: + case VK_SUBTRACT: + case VK_ADD: + case VK_DECIMAL: + case VK_CLEAR: + keypad = true; + break; + default: + keypad = false; + } + return keypad; +} + +WebKeyboardEvent WebInputEventFactory::keyboardEvent(HWND hwnd, UINT message, + WPARAM wparam, LPARAM lparam) +{ + WebKeyboardEvent result; + + // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that + // GetMessageTime() refers to is the same one that we're passed in? Perhaps + // one of the construction parameters should be the time passed by the + // caller, who would know for sure. + result.timeStampSeconds = GetMessageTime() / 1000.0; + + result.windowsKeyCode = result.nativeKeyCode = static_cast<int>(wparam); + + switch (message) { + case WM_SYSKEYDOWN: + result.isSystemKey = true; + case WM_KEYDOWN: + result.type = WebInputEvent::RawKeyDown; + break; + case WM_SYSKEYUP: + result.isSystemKey = true; + case WM_KEYUP: + result.type = WebInputEvent::KeyUp; + break; + case WM_IME_CHAR: + result.type = WebInputEvent::Char; + break; + case WM_SYSCHAR: + result.isSystemKey = true; + result.type = WebInputEvent::Char; + case WM_CHAR: + result.type = WebInputEvent::Char; + break; + default: + ASSERT_NOT_REACHED(); + } + + if (result.type == WebInputEvent::Char || result.type == WebInputEvent::RawKeyDown) { + result.text[0] = result.windowsKeyCode; + result.unmodifiedText[0] = result.windowsKeyCode; + } + if (result.type != WebInputEvent::Char) + result.setKeyIdentifierFromWindowsKeyCode(); + + if (GetKeyState(VK_SHIFT) & 0x8000) + result.modifiers |= WebInputEvent::ShiftKey; + if (GetKeyState(VK_CONTROL) & 0x8000) + result.modifiers |= WebInputEvent::ControlKey; + if (GetKeyState(VK_MENU) & 0x8000) + result.modifiers |= WebInputEvent::AltKey; + // NOTE: There doesn't seem to be a way to query the mouse button state in + // this case. + + if (LOWORD(lparam) > 1) + result.modifiers |= WebInputEvent::IsAutoRepeat; + if (isKeyPad(wparam, lparam)) + result.modifiers |= WebInputEvent::IsKeyPad; + + return result; +} + +// WebMouseEvent -------------------------------------------------------------- + +static int gLastClickCount; +static double gLastClickTime; + +static LPARAM GetRelativeCursorPos(HWND hwnd) +{ + POINT pos = {-1, -1}; + GetCursorPos(&pos); + ScreenToClient(hwnd, &pos); + return MAKELPARAM(pos.x, pos.y); +} + +void WebInputEventFactory::resetLastClickState() +{ + gLastClickTime = gLastClickCount = 0; +} + +WebMouseEvent WebInputEventFactory::mouseEvent(HWND hwnd, UINT message, + WPARAM wparam, LPARAM lparam) +{ + WebMouseEvent result; //(WebInputEvent::Uninitialized()); + + switch (message) { + case WM_MOUSEMOVE: + result.type = WebInputEvent::MouseMove; + if (wparam & MK_LBUTTON) + result.button = WebMouseEvent::ButtonLeft; + else if (wparam & MK_MBUTTON) + result.button = WebMouseEvent::ButtonMiddle; + else if (wparam & MK_RBUTTON) + result.button = WebMouseEvent::ButtonRight; + else + result.button = WebMouseEvent::ButtonNone; + break; + case WM_MOUSELEAVE: + result.type = WebInputEvent::MouseLeave; + result.button = WebMouseEvent::ButtonNone; + // set the current mouse position (relative to the client area of the + // current window) since none is specified for this event + lparam = GetRelativeCursorPos(hwnd); + break; + case WM_LBUTTONDOWN: + case WM_LBUTTONDBLCLK: + result.type = WebInputEvent::MouseDown; + result.button = WebMouseEvent::ButtonLeft; + break; + case WM_MBUTTONDOWN: + case WM_MBUTTONDBLCLK: + result.type = WebInputEvent::MouseDown; + result.button = WebMouseEvent::ButtonMiddle; + break; + case WM_RBUTTONDOWN: + case WM_RBUTTONDBLCLK: + result.type = WebInputEvent::MouseDown; + result.button = WebMouseEvent::ButtonRight; + break; + case WM_LBUTTONUP: + result.type = WebInputEvent::MouseUp; + result.button = WebMouseEvent::ButtonLeft; + break; + case WM_MBUTTONUP: + result.type = WebInputEvent::MouseUp; + result.button = WebMouseEvent::ButtonMiddle; + break; + case WM_RBUTTONUP: + result.type = WebInputEvent::MouseUp; + result.button = WebMouseEvent::ButtonRight; + break; + default: + ASSERT_NOT_REACHED(); + } + + // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that + // GetMessageTime() refers to is the same one that we're passed in? Perhaps + // one of the construction parameters should be the time passed by the + // caller, who would know for sure. + result.timeStampSeconds = GetMessageTime() / 1000.0; + + // set position fields: + + result.x = static_cast<short>(LOWORD(lparam)); + result.y = static_cast<short>(HIWORD(lparam)); + result.windowX = result.x; + result.windowY = result.y; + + POINT globalPoint = { result.x, result.y }; + ClientToScreen(hwnd, &globalPoint); + + result.globalX = globalPoint.x; + result.globalY = globalPoint.y; + + // calculate number of clicks: + + // This differs slightly from the WebKit code in WebKit/win/WebView.cpp + // where their original code looks buggy. + static int lastClickPositionX; + static int lastClickPositionY; + static WebMouseEvent::Button lastClickButton = WebMouseEvent::ButtonLeft; + + double currentTime = result.timeStampSeconds; + bool cancelPreviousClick = + (abs(lastClickPositionX - result.x) > (GetSystemMetrics(SM_CXDOUBLECLK) / 2)) + || (abs(lastClickPositionY - result.y) > (GetSystemMetrics(SM_CYDOUBLECLK) / 2)) + || ((currentTime - gLastClickTime) * 1000.0 > GetDoubleClickTime()); + + if (result.type == WebInputEvent::MouseDown) { + if (!cancelPreviousClick && (result.button == lastClickButton)) + ++gLastClickCount; + else { + gLastClickCount = 1; + lastClickPositionX = result.x; + lastClickPositionY = result.y; + } + gLastClickTime = currentTime; + lastClickButton = result.button; + } else if (result.type == WebInputEvent::MouseMove + || result.type == WebInputEvent::MouseLeave) { + if (cancelPreviousClick) { + gLastClickCount = 0; + lastClickPositionX = 0; + lastClickPositionY = 0; + gLastClickTime = 0; + } + } + result.clickCount = gLastClickCount; + + // set modifiers: + + if (wparam & MK_CONTROL) + result.modifiers |= WebInputEvent::ControlKey; + if (wparam & MK_SHIFT) + result.modifiers |= WebInputEvent::ShiftKey; + if (GetKeyState(VK_MENU) & 0x8000) + result.modifiers |= WebInputEvent::AltKey; + if (wparam & MK_LBUTTON) + result.modifiers |= WebInputEvent::LeftButtonDown; + if (wparam & MK_MBUTTON) + result.modifiers |= WebInputEvent::MiddleButtonDown; + if (wparam & MK_RBUTTON) + result.modifiers |= WebInputEvent::RightButtonDown; + + return result; +} + +// WebMouseWheelEvent --------------------------------------------------------- + +WebMouseWheelEvent WebInputEventFactory::mouseWheelEvent(HWND hwnd, UINT message, + WPARAM wparam, LPARAM lparam) +{ + WebMouseWheelEvent result; //(WebInputEvent::Uninitialized()); + + result.type = WebInputEvent::MouseWheel; + + // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that + // GetMessageTime() refers to is the same one that we're passed in? Perhaps + // one of the construction parameters should be the time passed by the + // caller, who would know for sure. + result.timeStampSeconds = GetMessageTime() / 1000.0; + + result.button = WebMouseEvent::ButtonNone; + + // Get key state, coordinates, and wheel delta from event. + typedef SHORT (WINAPI *GetKeyStateFunction)(int key); + GetKeyStateFunction getKeyState; + UINT keyState; + float wheelDelta; + bool horizontalScroll = false; + if ((message == WM_VSCROLL) || (message == WM_HSCROLL)) { + // Synthesize mousewheel event from a scroll event. This is needed to + // simulate middle mouse scrolling in some laptops. Use GetAsyncKeyState + // for key state since we are synthesizing the input event. + getKeyState = GetAsyncKeyState; + keyState = 0; + if (getKeyState(VK_SHIFT)) + keyState |= MK_SHIFT; + if (getKeyState(VK_CONTROL)) + keyState |= MK_CONTROL; + // NOTE: There doesn't seem to be a way to query the mouse button state + // in this case. + + POINT cursorPosition = {0}; + GetCursorPos(&cursorPosition); + result.globalX = cursorPosition.x; + result.globalY = cursorPosition.y; + + switch (LOWORD(wparam)) { + case SB_LINEUP: // == SB_LINELEFT + wheelDelta = WHEEL_DELTA; + break; + case SB_LINEDOWN: // == SB_LINERIGHT + wheelDelta = -WHEEL_DELTA; + break; + case SB_PAGEUP: + wheelDelta = 1; + result.scrollByPage = true; + break; + case SB_PAGEDOWN: + wheelDelta = -1; + result.scrollByPage = true; + break; + default: // We don't supoprt SB_THUMBPOSITION or SB_THUMBTRACK here. + wheelDelta = 0; + break; + } + + if (message == WM_HSCROLL) + horizontalScroll = true; + } else { + // Non-synthesized event; we can just read data off the event. + getKeyState = GetKeyState; + keyState = GET_KEYSTATE_WPARAM(wparam); + + result.globalX = static_cast<short>(LOWORD(lparam)); + result.globalY = static_cast<short>(HIWORD(lparam)); + + wheelDelta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wparam)); + if (message == WM_MOUSEHWHEEL) { + horizontalScroll = true; + wheelDelta = -wheelDelta; // Windows is <- -/+ ->, WebKit <- +/- ->. + } + } + if (keyState & MK_SHIFT) + horizontalScroll = true; + + // Set modifiers based on key state. + if (keyState & MK_SHIFT) + result.modifiers |= WebInputEvent::ShiftKey; + if (keyState & MK_CONTROL) + result.modifiers |= WebInputEvent::ControlKey; + if (getKeyState(VK_MENU) & 0x8000) + result.modifiers |= WebInputEvent::AltKey; + if (keyState & MK_LBUTTON) + result.modifiers |= WebInputEvent::LeftButtonDown; + if (keyState & MK_MBUTTON) + result.modifiers |= WebInputEvent::MiddleButtonDown; + if (keyState & MK_RBUTTON) + result.modifiers |= WebInputEvent::RightButtonDown; + + // Set coordinates by translating event coordinates from screen to client. + POINT clientPoint = { result.globalX, result.globalY }; + MapWindowPoints(0, hwnd, &clientPoint, 1); + result.x = clientPoint.x; + result.y = clientPoint.y; + result.windowX = result.x; + result.windowY = result.y; + + // Convert wheel delta amount to a number of pixels to scroll. + // + // How many pixels should we scroll per line? Gecko uses the height of the + // current line, which means scroll distance changes as you go through the + // page or go to different pages. IE 7 is ~50 px/line, although the value + // seems to vary slightly by page and zoom level. Since IE 7 has a smoothing + // algorithm on scrolling, it can get away with slightly larger scroll values + // without feeling jerky. Here we use 100 px per three lines (the default + // scroll amount is three lines per wheel tick). + static const float scrollbarPixelsPerLine = 100.0f / 3.0f; + wheelDelta /= WHEEL_DELTA; + float scrollDelta = wheelDelta; + if (horizontalScroll) { + unsigned long scrollChars = defaultScrollCharsPerWheelDelta; + SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &scrollChars, 0); + // TODO(pkasting): Should probably have a different multiplier + // scrollbarPixelsPerChar here. + scrollDelta *= static_cast<float>(scrollChars) * scrollbarPixelsPerLine; + } else { + unsigned long scrollLines = defaultScrollLinesPerWheelDelta; + SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &scrollLines, 0); + if (scrollLines == WHEEL_PAGESCROLL) + result.scrollByPage = true; + if (!result.scrollByPage) + scrollDelta *= static_cast<float>(scrollLines) * scrollbarPixelsPerLine; + } + + // Set scroll amount based on above calculations. WebKit expects positive + // deltaY to mean "scroll up" and positive deltaX to mean "scroll left". + if (horizontalScroll) { + result.deltaX = scrollDelta; + result.wheelTicksX = wheelDelta; + } else { + result.deltaY = scrollDelta; + result.wheelTicksY = wheelDelta; + } + + return result; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/win/WebScreenInfoFactory.cpp b/WebKit/chromium/src/win/WebScreenInfoFactory.cpp new file mode 100644 index 0000000..8416acc --- /dev/null +++ b/WebKit/chromium/src/win/WebScreenInfoFactory.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebScreenInfoFactory.h" + +#include "WebScreenInfo.h" + +#include <windows.h> + +namespace WebKit { + +static WebRect toWebRect(const RECT& input) +{ + WebRect output; + output.x = input.left; + output.y = input.top; + output.width = input.right - input.left; + output.height = input.bottom - input.top; + return output; +} + +WebScreenInfo WebScreenInfoFactory::screenInfo(HWND window) +{ + HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTOPRIMARY); + + MONITORINFOEX monitorInfo; + monitorInfo.cbSize = sizeof(MONITORINFOEX); + GetMonitorInfo(monitor, &monitorInfo); + + DEVMODE devMode; + devMode.dmSize = sizeof(devMode); + devMode.dmDriverExtra = 0; + EnumDisplaySettings(monitorInfo.szDevice, ENUM_CURRENT_SETTINGS, &devMode); + + WebScreenInfo results; + results.depth = devMode.dmBitsPerPel; + results.depthPerComponent = devMode.dmBitsPerPel / 3; // Assumes RGB + results.isMonochrome = devMode.dmColor == DMCOLOR_MONOCHROME; + results.rect = toWebRect(monitorInfo.rcMonitor); + results.availableRect = toWebRect(monitorInfo.rcWork); + return results; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/x11/WebScreenInfoFactory.cpp b/WebKit/chromium/src/x11/WebScreenInfoFactory.cpp new file mode 100644 index 0000000..548880c --- /dev/null +++ b/WebKit/chromium/src/x11/WebScreenInfoFactory.cpp @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebScreenInfoFactory.h" + +#include "WebScreenInfo.h" + +#include <X11/Xlib.h> + +namespace WebKit { + +WebScreenInfo WebScreenInfoFactory::screenInfo(Display* display, int screenNumber) +{ + WebScreenInfo results; + // FIXME: not all screens with use 8bpp. + results.depthPerComponent = 8; + + int displayWidth = XDisplayWidth(display, screenNumber); + int displayHeight = XDisplayHeight(display, screenNumber); + results.depth = XDisplayPlanes(display, screenNumber); + results.isMonochrome = results.depth == 1; + + results.rect = WebRect(0, 0, displayWidth, displayHeight); + + // I don't know of a way to query the "maximize" size of the window (e.g. + // screen size less sidebars etc) since this is something which only the + // window manager knows. + results.availableRect = results.rect; + + return results; +} + +} // namespace WebKit diff --git a/WebKit/chromium/webkit.gyp b/WebKit/chromium/webkit.gyp deleted file mode 100644 index 04d1bad..0000000 --- a/WebKit/chromium/webkit.gyp +++ /dev/null @@ -1,42 +0,0 @@ -# -# Copyright (C) 2009 Google Inc. All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# * Neither the name of Google Inc. nor the names of its contributors -# may be used to endorse or promote products derived from this software -# without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# - -{ - 'targets': [ - { - # This target only builds webcore right now, but it will also build - # the chromium webkit api once the api is upstreamed. - 'target_name': 'webkit', - 'type': 'none', - 'dependencies': [ - '../../WebCore/WebCore.gyp/WebCore.gyp:webcore', - ], - }, - ], # targets -} |